path: root/Godeps/_workspace/src/github.com/obscuren/otto/parser/expression.go

package parser

import (
    "regexp"

    "github.com/robertkrimen/otto/ast"
    "github.com/robertkrimen/otto/file"
    "github.com/robertkrimen/otto/token"
)

func (self *_parser) parseIdentifier() *ast.Identifier {
    literal := self.literal
    idx := self.idx
    self.next()
    return &ast.Identifier{
        Name: literal,
        Idx:  idx,
    }
}

func (self *_parser) parsePrimaryExpression() ast.Expression {
    literal := self.literal
    idx := self.idx
    switch self.token {
    case token.IDENTIFIER:
        self.next()
        if len(literal) > 1 {
            tkn, strict := token.IsKeyword(literal)
            if tkn == token.KEYWORD {
                if !strict {
                    self.error(idx, "Unexpected reserved word")
                }
            }
        }
        return &ast.Identifier{
            Name: literal,
            Idx:  idx,
        }
    case token.NULL:
        self.next()
        return &ast.NullLiteral{
            Idx:     idx,
            Literal: literal,
        }
    case token.BOOLEAN:
        self.next()
        value := false
        switch literal {
        case "true":
            value = true
        case "false":
            value = false
        default:
            self.error(idx, "Illegal boolean literal")
        }
        return &ast.BooleanLiteral{
            Idx:     idx,
            Literal: literal,
            Value:   value,
        }
    case token.STRING:
        self.next()
        value, err := parseStringLiteral(literal[1 : len(literal)-1])
        if err != nil {
            self.error(idx, err.Error())
        }
        return &ast.StringLiteral{
            Idx:     idx,
            Literal: literal,
            Value:   value,
        }
    case token.NUMBER:
        self.next()
        value, err := parseNumberLiteral(literal)
        if err != nil {
            self.error(idx, err.Error())
            value = 0
        }
        return &ast.NumberLiteral{
            Idx:     idx,
            Literal: literal,
            Value:   value,
        }
    case token.SLASH, token.QUOTIENT_ASSIGN:
        return self.parseRegExpLiteral()
    case token.LEFT_BRACE:
        return self.parseObjectLiteral()
    case token.LEFT_BRACKET:
        return self.parseArrayLiteral()
    case token.LEFT_PARENTHESIS:
        self.expect(token.LEFT_PARENTHESIS)
        expression := self.parseExpression()
        self.expect(token.RIGHT_PARENTHESIS)
        return expression
    case token.THIS:
        self.next()
        return &ast.ThisExpression{
            Idx: idx,
        }
    case token.FUNCTION:
        return self.parseFunction(false)
    }

    self.errorUnexpectedToken(self.token)
    self.nextStatement()
    return &ast.BadExpression{From: idx, To: self.idx}
}

func (self *_parser) parseRegExpLiteral() *ast.RegExpLiteral {

    offset := self.chrOffset - 1 // Opening slash already gotten
    if self.token == token.QUOTIENT_ASSIGN {
        offset -= 1 // =
    }
    idx := self.idxOf(offset)

    pattern, err := self.scanString(offset)
    endOffset := self.chrOffset

    self.next()
    if err == nil {
        pattern = pattern[1 : len(pattern)-1]
    }

    flags := ""
    if self.token == token.IDENTIFIER { // gim

        flags = self.literal
        self.next()
        endOffset = self.chrOffset - 1
    }

    var value string
    // TODO 15.10
    {
        // Test during parsing that this is a valid regular expression
        // Sorry, (?=) and (?!) are invalid (for now)
        pattern, err := TransformRegExp(pattern)
        if err != nil {
            if pattern == "" || self.mode&IgnoreRegExpErrors == 0 {
                self.error(idx, "Invalid regular expression: %s", err.Error())
            }
        } else {
            _, err = regexp.Compile(pattern)
            if err != nil {
                // We should not get here, ParseRegExp should catch any errors
                self.error(idx, "Invalid regular expression: %s", err.Error()[22:]) // Skip redundant "parse regexp error"
            } else {
                value = pattern
            }
        }
    }

    literal := self.str[offset:endOffset]

    return &ast.RegExpLiteral{
        Idx:     idx,
        Literal: literal,
        Pattern: pattern,
        Flags:   flags,
        Value:   value,
    }
}

func (self *_parser) parseVariableDeclaration(declarationList *[]*ast.VariableExpression) ast.Expression {

    if self.token != token.IDENTIFIER {
        idx := self.expect(token.IDENTIFIER)
        self.nextStatement()
        return &ast.BadExpression{From: idx, To: self.idx}
    }

    literal := self.literal
    idx := self.idx
    self.next()
    node := &ast.VariableExpression{
        Name: literal,
        Idx:  idx,
    }

    if declarationList != nil {
        *declarationList = append(*declarationList, node)
    }

    if self.token == token.ASSIGN {
        self.next()
        node.Initializer = self.parseAssignmentExpression()
    }

    return node
}

func (self *_parser) parseVariableDeclarationList(var_ file.Idx) []ast.Expression {

    var declarationList []*ast.VariableExpression // Avoid bad expressions
    var list []ast.Expression

    for {
        list = append(list, self.parseVariableDeclaration(&declarationList))
        if self.token != token.COMMA {
            break
        }
        self.next()
    }

    self.scope.declare(&ast.VariableDeclaration{
        Var:  var_,
        List: declarationList,
    })

    return list
}

func (self *_parser) parseObjectPropertyKey() (string, string) {
    idx, tkn, literal := self.idx, self.token, self.literal
    value := ""
    self.next()
    switch tkn {
    case token.IDENTIFIER:
        value = literal
    case token.NUMBER:
        var err error
        _, err = parseNumberLiteral(literal)
        if err != nil {
            self.error(idx, err.Error())
        } else {
            value = literal
        }
    case token.STRING:
        var err error
        value, err = parseStringLiteral(literal[1 : len(literal)-1])
        if err != nil {
            self.error(idx, err.Error())
        }
    default:
        // null, false, class, etc.
        if matchIdentifier.MatchString(literal) {
            value = literal
        }
    }
    return literal, value
}

func (self *_parser) parseObjectProperty() ast.Property {

    literal, value := self.parseObjectPropertyKey()
    if literal == "get" && self.token != token.COLON {
        idx := self.idx
        _, value := self.parseObjectPropertyKey()
        parameterList := self.parseFunctionParameterList()

        node := &ast.FunctionLiteral{
            Function:      idx,
            ParameterList: parameterList,
        }
        self.parseFunctionBlock(node)
        return ast.Property{
            Key:   value,
            Kind:  "get",
            Value: node,
        }
    } else if literal == "set" && self.token != token.COLON {
        idx := self.idx
        _, value := self.parseObjectPropertyKey()
        parameterList := self.parseFunctionParameterList()

        node := &ast.FunctionLiteral{
            Function:      idx,
            ParameterList: parameterList,
        }
        self.parseFunctionBlock(node)
        return ast.Property{
            Key:   value,
            Kind:  "set",
            Value: node,
        }
    }

    self.expect(token.COLON)

    return ast.Property{
        Key:   value,
        Kind:  "value",
        Value: self.parseAssignmentExpression(),
    }
}

func (self *_parser) parseObjectLiteral() ast.Expression {
    var value []ast.Property
    idx0 := self.expect(token.LEFT_BRACE)
    for self.token != token.RIGHT_BRACE && self.token != token.EOF {
        property := self.parseObjectProperty()
        value = append(value, property)
        if self.token == token.COMMA {
            self.next()
            continue
        }
    }
    idx1 := self.expect(token.RIGHT_BRACE)

    return &ast.ObjectLiteral{
        LeftBrace:  idx0,
        RightBrace: idx1,
        Value:      value,
    }
}

func (self *_parser) parseArrayLiteral() ast.Expression {

    idx0 := self.expect(token.LEFT_BRACKET)
    var value []ast.Expression
    for self.token != token.RIGHT_BRACKET && self.token != token.EOF {
        if self.token == token.COMMA {
            self.next()
            value = append(value, nil)
            continue
        }
        value = append(value, self.parseAssignmentExpression())
        if self.token != token.RIGHT_BRACKET {
            self.expect(token.COMMA)
        }
    }
    idx1 := self.expect(token.RIGHT_BRACKET)

    return &ast.ArrayLiteral{
        LeftBracket:  idx0,
        RightBracket: idx1,
        Value:        value,
    }
}

func (self *_parser) parseArgumentList() (argumentList []ast.Expression, idx0, idx1 file.Idx) {
    idx0 = self.expect(token.LEFT_PARENTHESIS)
    if self.token != token.RIGHT_PARENTHESIS {
        for {
            argumentList = append(argumentList, self.parseAssignmentExpression())
            if self.token != token.COMMA {
                break
            }
            self.next()
        }
    }
    idx1 = self.expect(token.RIGHT_PARENTHESIS)
    return
}

func (self *_parser) parseCallExpression(left ast.Expression) ast.Expression {
    argumentList, idx0, idx1 := self.parseArgumentList()
    return &ast.CallExpression{
        Callee:           left,
        LeftParenthesis:  idx0,
        ArgumentList:     argumentList,
        RightParenthesis: idx1,
    }
}

func (self *_parser) parseDotMember(left ast.Expression) ast.Expression {
    period := self.expect(token.PERIOD)

    literal := self.literal
    idx := self.idx

    if !matchIdentifier.MatchString(literal) {
        self.expect(token.IDENTIFIER)
        self.nextStatement()
        return &ast.BadExpression{From: period, To: self.idx}
    }

    self.next()

    return &ast.DotExpression{
        Left: left,
        Identifier: ast.Identifier{
            Idx:  idx,
            Name: literal,
        },
    }
}

func (self *_parser) parseBracketMember(left ast.Expression) ast.Expression {
    idx0 := self.expect(token.LEFT_BRACKET)
    member := self.parseExpression()
    idx1 := self.expect(token.RIGHT_BRACKET)
    return &ast.BracketExpression{
        LeftBracket:  idx0,
        Left:         left,
        Member:       member,
        RightBracket: idx1,
    }
}

func (self *_parser) parseNewExpression() ast.Expression {
    idx := self.expect(token.NEW)
    callee := self.parseLeftHandSideExpression()
    node := &ast.NewExpression{
        New:    idx,
        Callee: callee,
    }
    if self.token == token.LEFT_PARENTHESIS {
        argumentList, idx0, idx1 := self.parseArgumentList()
        node.ArgumentList = argumentList
        node.LeftParenthesis = idx0
        node.RightParenthesis = idx1
    }
    return node
}

func (self *_parser) parseLeftHandSideExpression() ast.Expression {

    var left ast.Expression
    if self.token == token.NEW {
        left = self.parseNewExpression()
    } else {
        left = self.parsePrimaryExpression()
    }

    for {
        if self.token == token.PERIOD {
            left = self.parseDotMember(left)
        } else if self.token == token.LEFT_BRACE {
            left = self.parseBracketMember(left)
        } else {
            break
        }
    }

    return left
}

func (self *_parser) parseLeftHandSideExpressionAllowCall() ast.Expression {

    allowIn := self.scope.allowIn
    self.scope.allowIn = true
    defer func() {
        self.scope.allowIn = allowIn
    }()

    var left ast.Expression
    if self.token == token.NEW {
        left = self.parseNewExpression()
    } else {
        left = self.parsePrimaryExpression()
    }

    for {
        if self.token == token.PERIOD {
            left = self.parseDotMember(left)
        } else if self.token == token.LEFT_BRACKET {
            left = self.parseBracketMember(left)
        } else if self.token == token.LEFT_PARENTHESIS {
            left = self.parseCallExpression(left)
        } else {
            break
        }
    }

    return left
}

func (self *_parser) parsePostfixExpression() ast.Expression {
    operand := self.parseLeftHandSideExpressionAllowCall()

    switch self.token {
    case token.INCREMENT, token.DECREMENT:
        // Make sure there is no line terminator here
        if self.implicitSemicolon {
            break
        }
        tkn := self.token
        idx := self.idx
        self.next()
        switch operand.(type) {
        case *ast.Identifier, *ast.DotExpression, *ast.BracketExpression:
        default:
            self.error(idx, "Invalid left-hand side in assignment")
            self.nextStatement()
            return &ast.BadExpression{From: idx, To: self.idx}
        }
        return &ast.UnaryExpression{
            Operator: tkn,
            Idx:      idx,
            Operand:  operand,
            Postfix:  true,
        }
    }

    return operand
}

func (self *_parser) parseUnaryExpression() ast.Expression {

    switch self.token {
    case token.PLUS, token.MINUS, token.NOT, token.BITWISE_NOT:
        fallthrough
    case token.DELETE, token.VOID, token.TYPEOF:
        tkn := self.token
        idx := self.idx
        self.next()
        return &ast.UnaryExpression{
            Operator: tkn,
            Idx:      idx,
            Operand:  self.parseUnaryExpression(),
        }
    case token.INCREMENT, token.DECREMENT:
        tkn := self.token
        idx := self.idx
        self.next()
        operand := self.parseUnaryExpression()
        switch operand.(type) {
        case *ast.Identifier, *ast.DotExpression, *ast.BracketExpression:
        default:
            self.error(idx, "Invalid left-hand side in assignment")
            self.nextStatement()
            return &ast.BadExpression{From: idx, To: self.idx}
        }
        return &ast.UnaryExpression{
            Operator: tkn,
            Idx:      idx,
            Operand:  operand,
        }
    }

    return self.parsePostfixExpression()
}

func (self *_parser) parseMultiplicativeExpression() ast.Expression {
    next := self.parseUnaryExpression
    left := next()

    for self.token == token.MULTIPLY || self.token == token.SLASH ||
        self.token == token.REMAINDER {
        tkn := self.token
        self.next()
        left = &ast.BinaryExpression{
            Operator: tkn,
            Left:     left,
            Right:    next(),
        }
    }

    return left
}

func (self *_parser) parseAdditiveExpression() ast.Expression {
    next := self.parseMultiplicativeExpression
    left := next()

    for self.token == token.PLUS || self.token == token.MINUS {
        tkn := self.token
        self.next()
        left = &ast.BinaryExpression{
            Operator: tkn,
            Left:     left,
            Right:    next(),
        }
    }

    return left
}

func (self *_parser) parseShiftExpression() ast.Expression {
    next := self.parseAdditiveExpression
    left := next()

    for self.token == token.SHIFT_LEFT || self.token == token.SHIFT_RIGHT ||
        self.token == token.UNSIGNED_SHIFT_RIGHT {
        tkn := self.token
        self.next()
        left = &ast.BinaryExpression{
            Operator: tkn,
            Left:     left,
            Right:    next(),
        }
    }

    return left
}

func (self *_parser) parseRelationalExpression() ast.Expression {
    next := self.parseShiftExpression
    left := next()

    allowIn := self.scope.allowIn
    self.scope.allowIn = true
    defer func() {
        self.scope.allowIn = allowIn
    }()

    switch self.token {
    case token.LESS, token.LESS_OR_EQUAL, token.GREATER, token.GREATER_OR_EQUAL:
        tkn := self.token
        self.next()
        return &ast.BinaryExpression{
            Operator:   tkn,
            Left:       left,
            Right:      self.parseRelationalExpression(),
            Comparison: true,
        }
    case token.INSTANCEOF:
        tkn := self.token
        self.next()
        return &ast.BinaryExpression{
            Operator: tkn,
            Left:     left,
            Right:    self.parseRelationalExpression(),
        }
    case token.IN:
        if !allowIn {
            return left
        }
        tkn := self.token
        self.next()
        return &ast.BinaryExpression{
            Operator: tkn,
            Left:     left,
            Right:    self.parseRelationalExpression(),
        }
    }

    return left
}

func (self *_parser) parseEqualityExpression() ast.Expression {
    next := self.parseRelationalExpression
    left := next()

    for self.token == token.EQUAL || self.token == token.NOT_EQUAL ||
        self.token == token.STRICT_EQUAL || self.token == token.STRICT_NOT_EQUAL {
        tkn := self.token
        self.next()
        left = &ast.BinaryExpression{
            Operator:   tkn,
            Left:       left,
            Right:      next(),
            Comparison: true,
        }
    }

    return left
}

func (self *_parser) parseBitwiseAndExpression() ast.Expression {
    next := self.parseEqualityExpression
    left := next()

    for self.token == token.AND {
        tkn := self.token
        self.next()
        left = &ast.BinaryExpression{
            Operator: tkn,
            Left:     left,
            Right:    next(),
        }
    }

    return left
}

func (self *_parser) parseBitwiseExclusiveOrExpression() ast.Expression {
    next := self.parseBitwiseAndExpression
    left := next()

    for self.token == token.EXCLUSIVE_OR {
        tkn := self.token
        self.next()
        left = &ast.BinaryExpression{
            Operator: tkn,
            Left:     left,
            Right:    next(),
        }
    }

    return left
}

func (self *_parser) parseBitwiseOrExpression() ast.Expression {
    next := self.parseBitwiseExclusiveOrExpression
    left := next()

    for self.token == token.OR {
        tkn := self.token
        self.next()
        left = &ast.BinaryExpression{
            Operator: tkn,
            Left:     left,
            Right:    next(),
        }
    }

    return left
}

func (self *_parser) parseLogicalAndExpression() ast.Expression {
    next := self.parseBitwiseOrExpression
    left := next()

    for self.token == token.LOGICAL_AND {
        tkn := self.token
        self.next()
        left = &ast.BinaryExpression{
            Operator: tkn,
            Left:     left,
            Right:    next(),
        }
    }

    return left
}

func (self *_parser) parseLogicalOrExpression() ast.Expression {
    next := self.parseLogicalAndExpression
    left := next()

    for self.token == token.LOGICAL_OR {
        tkn := self.token
        self.next()
        left = &ast.BinaryExpression{
            Operator: tkn,
            Left:     left,
            Right:    next(),
        }
    }

    return left
}

func (self *_parser) parseConditionlExpression() ast.Expression {
    left := self.parseLogicalOrExpression()

    if self.token == token.QUESTION_MARK {
        self.next()
        consequent := self.parseAssignmentExpression()
        self.expect(token.COLON)
        return &ast.ConditionalExpression{
            Test:       left,
            Consequent: consequent,
            Alternate:  self.parseAssignmentExpression(),
        }
    }

    return left
}

func (self *_parser) parseAssignmentExpression() ast.Expression {
    left := self.parseConditionlExpression()
    var operator token.Token
    switch self.token {
    case token.ASSIGN:
        operator = self.token
    case token.ADD_ASSIGN:
        operator = token.PLUS
    case token.SUBTRACT_ASSIGN:
        operator = token.MINUS
    case token.MULTIPLY_ASSIGN:
        operator = token.MULTIPLY
    case token.QUOTIENT_ASSIGN:
        operator = token.SLASH
    case token.REMAINDER_ASSIGN:
        operator = token.REMAINDER
    case token.AND_ASSIGN:
        operator = token.AND
    case token.AND_NOT_ASSIGN:
        operator = token.AND_NOT
    case token.OR_ASSIGN:
        operator = token.OR
    case token.EXCLUSIVE_OR_ASSIGN:
        operator = token.EXCLUSIVE_OR
    case token.SHIFT_LEFT_ASSIGN:
        operator = token.SHIFT_LEFT
    case token.SHIFT_RIGHT_ASSIGN:
        operator = token.SHIFT_RIGHT
    case token.UNSIGNED_SHIFT_RIGHT_ASSIGN:
        operator = token.UNSIGNED_SHIFT_RIGHT
    }

    if operator != 0 {
        idx := self.idx
        self.next()
        switch left.(type) {
        case *ast.Identifier, *ast.DotExpression, *ast.BracketExpression:
        default:
            self.error(left.Idx0(), "Invalid left-hand side in assignment")
            self.nextStatement()
            return &ast.BadExpression{From: idx, To: self.idx}
        }
        return &ast.AssignExpression{
            Left:     left,
            Operator: operator,
            Right:    self.parseAssignmentExpression(),
        }
    }

    return left
}

func (self *_parser) parseExpression() ast.Expression {
    next := self.parseAssignmentExpression
    left := next()

    if self.token == token.COMMA {
        sequence := []ast.Expression{left}
        for {
            if self.token != token.COMMA {
                break
            }
            self.next()
            sequence = append(sequence, next())
        }
        return &ast.SequenceExpression{
            Sequence: sequence,
        }
    }

    return left
}