gecko-dev/js/js2/nodefactory.h

// -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
//
// The contents of this file are subject to the Netscape Public
// License Version 1.1 (the "License"); you may not use this file
// except in compliance with the License. You may obtain a copy of
// the License at http://www.mozilla.org/NPL/
//
// Software distributed under the License is distributed on an "AS
// IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
// implied. See the License for the specific language governing
// rights and limitations under the License.
//
// The Original Code is the JavaScript 2 Prototype.
//
// The Initial Developer of the Original Code is Netscape
// Communications Corporation.  Portions created by Netscape are
// Copyright (C) 1998 Netscape Communications Corporation. All
// Rights Reserved.

#ifndef nodefactory_h
#define nodefactory_h

#include "utilities.h"
#include <vector>
#include "parser.h"

namespace JavaScript {

    class NodeFactory {

    private:

        static NodeFactory *state;

        NodeFactory(Arena& arena) : arena(arena) {
        }

        // state variables

        Arena &arena;


    public:
        static void Init(Arena& arena) {
            state = new NodeFactory(arena);
        }
        static Arena& getArena() {
            return NodeFactory::state->arena;
        }
		static IdentifierExprNode *Identifier(const Token &t) {
            return new(getArena()) IdentifierExprNode(t);
        }
		static IdentifierList *ListedIdentifier(String &name) {
            return new(getArena()) IdentifierList(*new StringAtom(name));
        }
#if 0
        static QualifiedIdentifierNode QualifiedIdentifier( Node qualifier, IdentifierNode identifier ) {
            return new QualifiedIdentifierNode(qualifier,identifier);
        }
        static LiteralNullNode LiteralNull() {
            return new LiteralNullNode();
        }
        static LiteralBooleanNode LiteralBoolean(boolean value) {
            return new LiteralBooleanNode(value);
        }
        static LiteralArrayNode LiteralArray( Node elementlist ) {
            return new LiteralArrayNode(elementlist);
        }
#endif
        static ExprPairList *LiteralField(ExprNode *name = 0, ExprNode *value = 0) {
            return new(getArena()) ExprPairList(name,value);
        }
        static NumberExprNode * LiteralNumber(const Token &t) {
            return new(getArena()) NumberExprNode(t);
        }
#if 0
        static LiteralObjectNode LiteralObject( Node fieldlist ) {
            return new LiteralObjectNode(fieldlist);
        }
        static LiteralRegExpNode LiteralRegExp( String value ) {
            return new LiteralRegExpNode(value);
        }
#endif
        static StringExprNode *LiteralString(uint32 pos, ExprNode::Kind kind, String &str) {
            return new(getArena()) StringExprNode(pos,kind,str);
        }
#if 0
        static LiteralTypeNode LiteralType( Type type ) {
            return new LiteralTypeNode(type);
        }
        static LiteralUndefinedNode LiteralUndefined() {
            return new LiteralUndefinedNode();
        }
        static FunctionExpressionNode FunctionExpression( Node name, Node signature, Node body ) {
            return new FunctionExpressionNode(name,signature,body);
        }
        static AnnotatedDefinitionNode AnnotatedDefinition( Node attributes, Node definition ) {
            return new AnnotatedDefinitionNode(attributes,definition);
        }
        static AttributeDefinitionNode AttributeDefinition( Node name, int kind, Node value ) {
            return new AttributeDefinitionNode(name,kind,value);
        }
        static AttributeListNode AttributeList( Node item, Node list ) {
            return new AttributeListNode(item,list);
        }
        static UnitExpressionNode UnitExpression( Node value, Node type ) {
            return new UnitExpressionNode(value,type);
        }
        static ThisExpressionNode ThisExpression() {
            return new ThisExpressionNode();
        }
        static SuperExpressionNode SuperExpression() {
            return new SuperExpressionNode();
        }
        static EvalExpressionNode EvalExpression( Node expr ) {
            return new EvalExpressionNode(expr);
        }
        static ListNode List( Node list, Node item ) {
            return new ListNode(list,item);
        }
        static PostfixExpressionNode PostfixExpression( int op, Node expr ) {
            return new PostfixExpressionNode(op,expr);
        }
        static NewExpressionNode NewExpression( Node member ) {
            return new NewExpressionNode(member);
        }
        static CallExpressionNode CallExpression( Node member, Node args ) {
            return new CallExpressionNode(member,args);
        }
        static IndexedMemberExpressionNode IndexedMemberExpression( Node base, Node member ) {
            return new IndexedMemberExpressionNode(base,member);
        }
        static MemberExpressionNode MemberExpression( Node base, Node name ) {
            return new MemberExpressionNode(base,name);
        }
        static CoersionExpressionNode CoersionExpression( Node expr, Node type ) {
            return new CoersionExpressionNode(expr,type);
        }
        static UnaryExpressionNode UnaryExpression( int op, Node expr ) {
            return new UnaryExpressionNode(op,expr);
        }
        static BinaryExpressionNode BinaryExpression( int op, Node lhs, Node rhs ) {
            return new BinaryExpressionNode(op,lhs,rhs);
        }
        static ConditionalExpressionNode ConditionalExpression( Node cond, Node thenexpr, Node elseexpr ) {
            return new ConditionalExpressionNode(cond,thenexpr,elseexpr);
        }
        static AssignmentExpressionNode AssignmentExpression( Node lhs, int op, Node rhs ) {
            return new AssignmentExpressionNode(lhs,op,rhs);
        }
        static StatementListNode StatementList( StatementListNode list, Node item ) {
            return new StatementListNode(list,item);
        }
        static EmptyStatementNode EmptyStatement() {
            return new EmptyStatementNode();
        }
        static ExpressionStatementNode ExpressionStatement( Node expr ) {
            return new ExpressionStatementNode(expr);
        }
        static AnnotatedBlockNode AnnotatedBlock( Node attributes, Node definition ) {
            return new AnnotatedBlockNode(attributes,definition);
        }
        static LabeledStatementNode LabeledStatement( Node label, Node statement ) {
            return new LabeledStatementNode(label,statement);
        }
        static IfStatementNode IfStatement( Node test, Node tblock, Node eblock ) {
            return new IfStatementNode(test,tblock,eblock);
        }
        static SwitchStatementNode SwitchStatement( Node expr, Node statements ) {
            return new SwitchStatementNode(expr,statements);
        }
        static DefaultStatementNode DefaultStatement() {
            return new DefaultStatementNode();
        }
        static DoStatementNode DoStatement( Node block, Node expr ) {
            return new DoStatementNode(block,expr);
        }
        static WhileStatementNode WhileStatement( Node expr, Node statement ) {
            return new WhileStatementNode(expr,statement);
        }
        static ForInStatementNode ForInStatement( Node expr1, Node expr2, Node statement ) {
            return new ForInStatementNode(expr1,expr2,statement);
        }
        static ForStatementNode ForStatement( Node expr1, Node expr2, Node expr3, Node statement ) {
            return new ForStatementNode(expr1,expr2,expr3,statement);
        }
        static WithStatementNode WithStatement( Node expr, Node statement ) {
            return new WithStatementNode(expr,statement);
        }
        static ContinueStatementNode ContinueStatement(Node expr) {
            return new ContinueStatementNode(expr);
        }
        static BreakStatementNode BreakStatement(Node expr) {
            return new BreakStatementNode(expr);
        }
        static ReturnStatementNode ReturnStatement( Node expr ) {
            return new ReturnStatementNode(expr);
        }
        static ThrowStatementNode ThrowStatement(Node list) {
            return new ThrowStatementNode(list);
        }
        static TryStatementNode TryStatement(Node tryblock, Node catchlist, Node finallyblock) {
            return new TryStatementNode(tryblock,catchlist,finallyblock);
        }
        static CatchClauseNode CatchClause(Node parameter, Node block) {
            return new CatchClauseNode(parameter,block);
        }
        static FinallyClauseNode FinallyClause( Node block ) {
            return new FinallyClauseNode(block);
        }
        static IncludeStatementNode IncludeStatement( Node list ) {
            return new IncludeStatementNode(list);
        }
        static UseStatementNode UseStatement( Node expr ) {
            return new UseStatementNode(expr);
        }
    
        static ImportDefinitionNode ImportDefinition( Node item, Node list ) {
            return new ImportDefinitionNode(item,list);
        }
        static ImportBindingNode ImportBinding( Node identifer, Node item ) {
            return new ImportBindingNode(identifer,item);
        }
        static ExportDefinitionNode ExportDefinition( Node list ) {
            return new ExportDefinitionNode(list);
        }
        static ExportBindingNode ExportBinding( Node name, Node value ) {
            return new ExportBindingNode(name,value);
        }
        static VariableDefinitionNode VariableDefinition( int kind, Node list ) {
            return new VariableDefinitionNode(kind,list);
        }
        static VariableBindingNode VariableBinding( Node identifier, Node initializer ) {
            return new VariableBindingNode(identifier,initializer);
        }
        static TypedVariableNode TypedVariable( Node identifier, Node type ) {
            return new TypedVariableNode(identifier,type);
        }
        static FunctionDefinitionNode FunctionDefinition( Node decl, Node body ) {
            return new FunctionDefinitionNode(decl,body);
        }
        static FunctionDeclarationNode FunctionDeclaration( Node name, Node signature ) {
            return new FunctionDeclarationNode(name,signature);
        }
        static FunctionNameNode FunctionName( int kind, Node name ) {
            return new FunctionNameNode(kind,name);
        }
        static RestParameterNode RestParameter( Node expr ) {
            return new RestParameterNode(expr);
        }
        static ParameterNode Parameter( Node identifer, Node type ) {
            return new ParameterNode(identifer,type);
        }
#endif
        static VariableBinding *Parameter(ExprNode *name, ExprNode *type) {
	        return new(getArena()) VariableBinding(0, name, type);
        }
#if 0
        static VariableBinding *NamedParameter( StringExprNode *name, ParseNode *parameter ) {
	        return new(Arena()) NamedParameterNode(name, parameter);
        }
        static ClassDeclarationNode ClassDeclaration( Node name ) {
            return new ClassDeclarationNode(name);
        }
        static ClassDefinitionNode ClassDefinition( Node name, Node interfaces, Node statements ) {
            return new ClassDefinitionNode(name,interfaces,statements);
        }
        static InheritanceNode Inheritance( Node baseclass, Node interfaces ) {
        return new InheritanceNode(baseclass,interfaces);
        }
        static InterfaceDeclarationNode InterfaceDeclaration( Node name ) {
            return new InterfaceDeclarationNode(name);
        }
        static InterfaceDefinitionNode InterfaceDefinition( Node name, Node interfaces, Node statements ) {
            return new InterfaceDefinitionNode(name,interfaces,statements);
        }
        static NamespaceDefinitionNode NamespaceDefinition( Node identifier, Node list ) {
            return new NamespaceDefinitionNode(identifier,list);
        }
        static LanguageDeclarationNode LanguageDeclaration( Node list ) {
            return new LanguageDeclarationNode(list);
        }
        static PackageDefinitionNode PackageDefinition( Node name, Node block ) {
            return new PackageDefinitionNode(name,block);
        }
        static ProgramNode Program( Node statements ) {
            return new ProgramNode(statements);
        }
#endif
    };
}
#endif // nodefactory_h