path: root/vendor/github.com/robertkrimen/otto/cmpl_parse.go

package otto

import (
    "fmt"
    "regexp"

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

var trueLiteral = &_nodeLiteral{value: toValue_bool(true)}
var falseLiteral = &_nodeLiteral{value: toValue_bool(false)}
var nullLiteral = &_nodeLiteral{value: nullValue}
var emptyStatement = &_nodeEmptyStatement{}

func (cmpl *_compiler) parseExpression(in ast.Expression) _nodeExpression {
    if in == nil {
        return nil
    }

    switch in := in.(type) {

    case *ast.ArrayLiteral:
        out := &_nodeArrayLiteral{
            value: make([]_nodeExpression, len(in.Value)),
        }
        for i, value := range in.Value {
            out.value[i] = cmpl.parseExpression(value)
        }
        return out

    case *ast.AssignExpression:
        return &_nodeAssignExpression{
            operator: in.Operator,
            left:     cmpl.parseExpression(in.Left),
            right:    cmpl.parseExpression(in.Right),
        }

    case *ast.BinaryExpression:
        return &_nodeBinaryExpression{
            operator:   in.Operator,
            left:       cmpl.parseExpression(in.Left),
            right:      cmpl.parseExpression(in.Right),
            comparison: in.Comparison,
        }

    case *ast.BooleanLiteral:
        if in.Value {
            return trueLiteral
        }
        return falseLiteral

    case *ast.BracketExpression:
        return &_nodeBracketExpression{
            idx:    in.Left.Idx0(),
            left:   cmpl.parseExpression(in.Left),
            member: cmpl.parseExpression(in.Member),
        }

    case *ast.CallExpression:
        out := &_nodeCallExpression{
            callee:       cmpl.parseExpression(in.Callee),
            argumentList: make([]_nodeExpression, len(in.ArgumentList)),
        }
        for i, value := range in.ArgumentList {
            out.argumentList[i] = cmpl.parseExpression(value)
        }
        return out

    case *ast.ConditionalExpression:
        return &_nodeConditionalExpression{
            test:       cmpl.parseExpression(in.Test),
            consequent: cmpl.parseExpression(in.Consequent),
            alternate:  cmpl.parseExpression(in.Alternate),
        }

    case *ast.DotExpression:
        return &_nodeDotExpression{
            idx:        in.Left.Idx0(),
            left:       cmpl.parseExpression(in.Left),
            identifier: in.Identifier.Name,
        }

    case *ast.EmptyExpression:
        return nil

    case *ast.FunctionLiteral:
        name := ""
        if in.Name != nil {
            name = in.Name.Name
        }
        out := &_nodeFunctionLiteral{
            name:   name,
            body:   cmpl.parseStatement(in.Body),
            source: in.Source,
            file:   cmpl.file,
        }
        if in.ParameterList != nil {
            list := in.ParameterList.List
            out.parameterList = make([]string, len(list))
            for i, value := range list {
                out.parameterList[i] = value.Name
            }
        }
        for _, value := range in.DeclarationList {
            switch value := value.(type) {
            case *ast.FunctionDeclaration:
                out.functionList = append(out.functionList, cmpl.parseExpression(value.Function).(*_nodeFunctionLiteral))
            case *ast.VariableDeclaration:
                for _, value := range value.List {
                    out.varList = append(out.varList, value.Name)
                }
            default:
                panic(fmt.Errorf("Here be dragons: parseProgram.declaration(%T)", value))
            }
        }
        return out

    case *ast.Identifier:
        return &_nodeIdentifier{
            idx:  in.Idx,
            name: in.Name,
        }

    case *ast.NewExpression:
        out := &_nodeNewExpression{
            callee:       cmpl.parseExpression(in.Callee),
            argumentList: make([]_nodeExpression, len(in.ArgumentList)),
        }
        for i, value := range in.ArgumentList {
            out.argumentList[i] = cmpl.parseExpression(value)
        }
        return out

    case *ast.NullLiteral:
        return nullLiteral

    case *ast.NumberLiteral:
        return &_nodeLiteral{
            value: toValue(in.Value),
        }

    case *ast.ObjectLiteral:
        out := &_nodeObjectLiteral{
            value: make([]_nodeProperty, len(in.Value)),
        }
        for i, value := range in.Value {
            out.value[i] = _nodeProperty{
                key:   value.Key,
                kind:  value.Kind,
                value: cmpl.parseExpression(value.Value),
            }
        }
        return out

    case *ast.RegExpLiteral:
        return &_nodeRegExpLiteral{
            flags:   in.Flags,
            pattern: in.Pattern,
        }

    case *ast.SequenceExpression:
        out := &_nodeSequenceExpression{
            sequence: make([]_nodeExpression, len(in.Sequence)),
        }
        for i, value := range in.Sequence {
            out.sequence[i] = cmpl.parseExpression(value)
        }
        return out

    case *ast.StringLiteral:
        return &_nodeLiteral{
            value: toValue_string(in.Value),
        }

    case *ast.ThisExpression:
        return &_nodeThisExpression{}

    case *ast.UnaryExpression:
        return &_nodeUnaryExpression{
            operator: in.Operator,
            operand:  cmpl.parseExpression(in.Operand),
            postfix:  in.Postfix,
        }

    case *ast.VariableExpression:
        return &_nodeVariableExpression{
            idx:         in.Idx0(),
            name:        in.Name,
            initializer: cmpl.parseExpression(in.Initializer),
        }

    }

    panic(fmt.Errorf("Here be dragons: cmpl.parseExpression(%T)", in))
}

func (cmpl *_compiler) parseStatement(in ast.Statement) _nodeStatement {
    if in == nil {
        return nil
    }

    switch in := in.(type) {

    case *ast.BlockStatement:
        out := &_nodeBlockStatement{
            list: make([]_nodeStatement, len(in.List)),
        }
        for i, value := range in.List {
            out.list[i] = cmpl.parseStatement(value)
        }
        return out

    case *ast.BranchStatement:
        out := &_nodeBranchStatement{
            branch: in.Token,
        }
        if in.Label != nil {
            out.label = in.Label.Name
        }
        return out

    case *ast.DebuggerStatement:
        return &_nodeDebuggerStatement{}

    case *ast.DoWhileStatement:
        out := &_nodeDoWhileStatement{
            test: cmpl.parseExpression(in.Test),
        }
        body := cmpl.parseStatement(in.Body)
        if block, ok := body.(*_nodeBlockStatement); ok {
            out.body = block.list
        } else {
            out.body = append(out.body, body)
        }
        return out

    case *ast.EmptyStatement:
        return emptyStatement

    case *ast.ExpressionStatement:
        return &_nodeExpressionStatement{
            expression: cmpl.parseExpression(in.Expression),
        }

    case *ast.ForInStatement:
        out := &_nodeForInStatement{
            into:   cmpl.parseExpression(in.Into),
            source: cmpl.parseExpression(in.Source),
        }
        body := cmpl.parseStatement(in.Body)
        if block, ok := body.(*_nodeBlockStatement); ok {
            out.body = block.list
        } else {
            out.body = append(out.body, body)
        }
        return out

    case *ast.ForStatement:
        out := &_nodeForStatement{
            initializer: cmpl.parseExpression(in.Initializer),
            update:      cmpl.parseExpression(in.Update),
            test:        cmpl.parseExpression(in.Test),
        }
        body := cmpl.parseStatement(in.Body)
        if block, ok := body.(*_nodeBlockStatement); ok {
            out.body = block.list
        } else {
            out.body = append(out.body, body)
        }
        return out

    case *ast.FunctionStatement:
        return emptyStatement

    case *ast.IfStatement:
        return &_nodeIfStatement{
            test:       cmpl.parseExpression(in.Test),
            consequent: cmpl.parseStatement(in.Consequent),
            alternate:  cmpl.parseStatement(in.Alternate),
        }

    case *ast.LabelledStatement:
        return &_nodeLabelledStatement{
            label:     in.Label.Name,
            statement: cmpl.parseStatement(in.Statement),
        }

    case *ast.ReturnStatement:
        return &_nodeReturnStatement{
            argument: cmpl.parseExpression(in.Argument),
        }

    case *ast.SwitchStatement:
        out := &_nodeSwitchStatement{
            discriminant: cmpl.parseExpression(in.Discriminant),
            default_:     in.Default,
            body:         make([]*_nodeCaseStatement, len(in.Body)),
        }
        for i, clause := range in.Body {
            out.body[i] = &_nodeCaseStatement{
                test:       cmpl.parseExpression(clause.Test),
                consequent: make([]_nodeStatement, len(clause.Consequent)),
            }
            for j, value := range clause.Consequent {
                out.body[i].consequent[j] = cmpl.parseStatement(value)
            }
        }
        return out

    case *ast.ThrowStatement:
        return &_nodeThrowStatement{
            argument: cmpl.parseExpression(in.Argument),
        }

    case *ast.TryStatement:
        out := &_nodeTryStatement{
            body:    cmpl.parseStatement(in.Body),
            finally: cmpl.parseStatement(in.Finally),
        }
        if in.Catch != nil {
            out.catch = &_nodeCatchStatement{
                parameter: in.Catch.Parameter.Name,
                body:      cmpl.parseStatement(in.Catch.Body),
            }
        }
        return out

    case *ast.VariableStatement:
        out := &_nodeVariableStatement{
            list: make([]_nodeExpression, len(in.List)),
        }
        for i, value := range in.List {
            out.list[i] = cmpl.parseExpression(value)
        }
        return out

    case *ast.WhileStatement:
        out := &_nodeWhileStatement{
            test: cmpl.parseExpression(in.Test),
        }
        body := cmpl.parseStatement(in.Body)
        if block, ok := body.(*_nodeBlockStatement); ok {
            out.body = block.list
        } else {
            out.body = append(out.body, body)
        }
        return out

    case *ast.WithStatement:
        return &_nodeWithStatement{
            object: cmpl.parseExpression(in.Object),
            body:   cmpl.parseStatement(in.Body),
        }

    }

    panic(fmt.Errorf("Here be dragons: cmpl.parseStatement(%T)", in))
}

func cmpl_parse(in *ast.Program) *_nodeProgram {
    cmpl := _compiler{
        program: in,
    }
    return cmpl.parse()
}

func (cmpl *_compiler) _parse(in *ast.Program) *_nodeProgram {
    out := &_nodeProgram{
        body: make([]_nodeStatement, len(in.Body)),
        file: in.File,
    }
    for i, value := range in.Body {
        out.body[i] = cmpl.parseStatement(value)
    }
    for _, value := range in.DeclarationList {
        switch value := value.(type) {
        case *ast.FunctionDeclaration:
            out.functionList = append(out.functionList, cmpl.parseExpression(value.Function).(*_nodeFunctionLiteral))
        case *ast.VariableDeclaration:
            for _, value := range value.List {
                out.varList = append(out.varList, value.Name)
            }
        default:
            panic(fmt.Errorf("Here be dragons: cmpl.parseProgram.DeclarationList(%T)", value))
        }
    }
    return out
}

type _nodeProgram struct {
    body []_nodeStatement

    varList      []string
    functionList []*_nodeFunctionLiteral

    variableList []_nodeDeclaration

    file *file.File
}

type _nodeDeclaration struct {
    name       string
    definition _node
}

type _node interface {
}

type (
    _nodeExpression interface {
        _node
        _expressionNode()
    }

    _nodeArrayLiteral struct {
        value []_nodeExpression
    }

    _nodeAssignExpression struct {
        operator token.Token
        left     _nodeExpression
        right    _nodeExpression
    }

    _nodeBinaryExpression struct {
        operator   token.Token
        left       _nodeExpression
        right      _nodeExpression
        comparison bool
    }

    _nodeBracketExpression struct {
        idx    file.Idx
        left   _nodeExpression
        member _nodeExpression
    }

    _nodeCallExpression struct {
        callee       _nodeExpression
        argumentList []_nodeExpression
    }

    _nodeConditionalExpression struct {
        test       _nodeExpression
        consequent _nodeExpression
        alternate  _nodeExpression
    }

    _nodeDotExpression struct {
        idx        file.Idx
        left       _nodeExpression
        identifier string
    }

    _nodeFunctionLiteral struct {
        name          string
        body          _nodeStatement
        source        string
        parameterList []string
        varList       []string
        functionList  []*_nodeFunctionLiteral
        file          *file.File
    }

    _nodeIdentifier struct {
        idx  file.Idx
        name string
    }

    _nodeLiteral struct {
        value Value
    }

    _nodeNewExpression struct {
        callee       _nodeExpression
        argumentList []_nodeExpression
    }

    _nodeObjectLiteral struct {
        value []_nodeProperty
    }

    _nodeProperty struct {
        key   string
        kind  string
        value _nodeExpression
    }

    _nodeRegExpLiteral struct {
        flags   string
        pattern string // Value?
        regexp  *regexp.Regexp
    }

    _nodeSequenceExpression struct {
        sequence []_nodeExpression
    }

    _nodeThisExpression struct {
    }

    _nodeUnaryExpression struct {
        operator token.Token
        operand  _nodeExpression
        postfix  bool
    }

    _nodeVariableExpression struct {
        idx         file.Idx
        name        string
        initializer _nodeExpression
    }
)

type (
    _nodeStatement interface {
        _node
        _statementNode()
    }

    _nodeBlockStatement struct {
        list []_nodeStatement
    }

    _nodeBranchStatement struct {
        branch token.Token
        label  string
    }

    _nodeCaseStatement struct {
        test       _nodeExpression
        consequent []_nodeStatement
    }

    _nodeCatchStatement struct {
        parameter string
        body      _nodeStatement
    }

    _nodeDebuggerStatement struct {
    }

    _nodeDoWhileStatement struct {
        test _nodeExpression
        body []_nodeStatement
    }

    _nodeEmptyStatement struct {
    }

    _nodeExpressionStatement struct {
        expression _nodeExpression
    }

    _nodeForInStatement struct {
        into   _nodeExpression
        source _nodeExpression
        body   []_nodeStatement
    }

    _nodeForStatement struct {
        initializer _nodeExpression
        update      _nodeExpression
        test        _nodeExpression
        body        []_nodeStatement
    }

    _nodeIfStatement struct {
        test       _nodeExpression
        consequent _nodeStatement
        alternate  _nodeStatement
    }

    _nodeLabelledStatement struct {
        label     string
        statement _nodeStatement
    }

    _nodeReturnStatement struct {
        argument _nodeExpression
    }

    _nodeSwitchStatement struct {
        discriminant _nodeExpression
        default_     int
        body         []*_nodeCaseStatement
    }

    _nodeThrowStatement struct {
        argument _nodeExpression
    }

    _nodeTryStatement struct {
        body    _nodeStatement
        catch   *_nodeCatchStatement
        finally _nodeStatement
    }

    _nodeVariableStatement struct {
        list []_nodeExpression
    }

    _nodeWhileStatement struct {
        test _nodeExpression
        body []_nodeStatement
    }

    _nodeWithStatement struct {
        object _nodeExpression
        body   _nodeStatement
    }
)

// _expressionNode

func (*_nodeArrayLiteral) _expressionNode()          {}
func (*_nodeAssignExpression) _expressionNode()      {}
func (*_nodeBinaryExpression) _expressionNode()      {}
func (*_nodeBracketExpression) _expressionNode()     {}
func (*_nodeCallExpression) _expressionNode()        {}
func (*_nodeConditionalExpression) _expressionNode() {}
func (*_nodeDotExpression) _expressionNode()         {}
func (*_nodeFunctionLiteral) _expressionNode()       {}
func (*_nodeIdentifier) _expressionNode()            {}
func (*_nodeLiteral) _expressionNode()               {}
func (*_nodeNewExpression) _expressionNode()         {}
func (*_nodeObjectLiteral) _expressionNode()         {}
func (*_nodeRegExpLiteral) _expressionNode()         {}
func (*_nodeSequenceExpression) _expressionNode()    {}
func (*_nodeThisExpression) _expressionNode()        {}
func (*_nodeUnaryExpression) _expressionNode()       {}
func (*_nodeVariableExpression) _expressionNode()    {}

// _statementNode

func (*_nodeBlockStatement) _statementNode()      {}
func (*_nodeBranchStatement) _statementNode()     {}
func (*_nodeCaseStatement) _statementNode()       {}
func (*_nodeCatchStatement) _statementNode()      {}
func (*_nodeDebuggerStatement) _statementNode()   {}
func (*_nodeDoWhileStatement) _statementNode()    {}
func (*_nodeEmptyStatement) _statementNode()      {}
func (*_nodeExpressionStatement) _statementNode() {}
func (*_nodeForInStatement) _statementNode()      {}
func (*_nodeForStatement) _statementNode()        {}
func (*_nodeIfStatement) _statementNode()         {}
func (*_nodeLabelledStatement) _statementNode()   {}
func (*_nodeReturnStatement) _statementNode()     {}
func (*_nodeSwitchStatement) _statementNode()     {}
func (*_nodeThrowStatement) _statementNode()      {}
func (*_nodeTryStatement) _statementNode()        {}
func (*_nodeVariableStatement) _statementNode()   {}
func (*_nodeWhileStatement) _statementNode()      {}
func (*_nodeWithStatement) _statementNode()       {}