314 lines
13 KiB
Java
314 lines
13 KiB
Java
/*******************************************************************************
|
|
* Copyright (c) 2013 IBM Corporation.
|
|
* All rights reserved. This program and the accompanying materials
|
|
* are made available under the terms of the Eclipse Public License v1.0
|
|
* which accompanies this distribution, and is available at
|
|
* http://www.eclipse.org/legal/epl-v10.html
|
|
*
|
|
* Contributors:
|
|
* IBM Corporation - initial API and implementation
|
|
*******************************************************************************/
|
|
package com.ibm.wala.cast.js.translator;
|
|
|
|
import org.mozilla.javascript.ast.ArrayComprehension;
|
|
import org.mozilla.javascript.ast.ArrayComprehensionLoop;
|
|
import org.mozilla.javascript.ast.ArrayLiteral;
|
|
import org.mozilla.javascript.ast.Assignment;
|
|
import org.mozilla.javascript.ast.AstNode;
|
|
import org.mozilla.javascript.ast.AstRoot;
|
|
import org.mozilla.javascript.ast.Block;
|
|
import org.mozilla.javascript.ast.BreakStatement;
|
|
import org.mozilla.javascript.ast.CatchClause;
|
|
import org.mozilla.javascript.ast.Comment;
|
|
import org.mozilla.javascript.ast.ConditionalExpression;
|
|
import org.mozilla.javascript.ast.ContinueStatement;
|
|
import org.mozilla.javascript.ast.DoLoop;
|
|
import org.mozilla.javascript.ast.ElementGet;
|
|
import org.mozilla.javascript.ast.EmptyExpression;
|
|
import org.mozilla.javascript.ast.ErrorNode;
|
|
import org.mozilla.javascript.ast.ExpressionStatement;
|
|
import org.mozilla.javascript.ast.ForInLoop;
|
|
import org.mozilla.javascript.ast.ForLoop;
|
|
import org.mozilla.javascript.ast.FunctionCall;
|
|
import org.mozilla.javascript.ast.FunctionNode;
|
|
import org.mozilla.javascript.ast.IfStatement;
|
|
import org.mozilla.javascript.ast.InfixExpression;
|
|
import org.mozilla.javascript.ast.Jump;
|
|
import org.mozilla.javascript.ast.KeywordLiteral;
|
|
import org.mozilla.javascript.ast.Label;
|
|
import org.mozilla.javascript.ast.LabeledStatement;
|
|
import org.mozilla.javascript.ast.LetNode;
|
|
import org.mozilla.javascript.ast.Name;
|
|
import org.mozilla.javascript.ast.NewExpression;
|
|
import org.mozilla.javascript.ast.NumberLiteral;
|
|
import org.mozilla.javascript.ast.ObjectLiteral;
|
|
import org.mozilla.javascript.ast.ObjectProperty;
|
|
import org.mozilla.javascript.ast.ParenthesizedExpression;
|
|
import org.mozilla.javascript.ast.PropertyGet;
|
|
import org.mozilla.javascript.ast.RegExpLiteral;
|
|
import org.mozilla.javascript.ast.ReturnStatement;
|
|
import org.mozilla.javascript.ast.Scope;
|
|
import org.mozilla.javascript.ast.ScriptNode;
|
|
import org.mozilla.javascript.ast.StringLiteral;
|
|
import org.mozilla.javascript.ast.SwitchCase;
|
|
import org.mozilla.javascript.ast.SwitchStatement;
|
|
import org.mozilla.javascript.ast.Symbol;
|
|
import org.mozilla.javascript.ast.ThrowStatement;
|
|
import org.mozilla.javascript.ast.TryStatement;
|
|
import org.mozilla.javascript.ast.UnaryExpression;
|
|
import org.mozilla.javascript.ast.VariableDeclaration;
|
|
import org.mozilla.javascript.ast.VariableInitializer;
|
|
import org.mozilla.javascript.ast.WhileLoop;
|
|
import org.mozilla.javascript.ast.WithStatement;
|
|
import org.mozilla.javascript.ast.XmlDotQuery;
|
|
import org.mozilla.javascript.ast.XmlElemRef;
|
|
import org.mozilla.javascript.ast.XmlExpression;
|
|
import org.mozilla.javascript.ast.XmlFragment;
|
|
import org.mozilla.javascript.ast.XmlLiteral;
|
|
import org.mozilla.javascript.ast.XmlMemberGet;
|
|
import org.mozilla.javascript.ast.XmlPropRef;
|
|
import org.mozilla.javascript.ast.XmlRef;
|
|
import org.mozilla.javascript.ast.XmlString;
|
|
import org.mozilla.javascript.ast.Yield;
|
|
|
|
public abstract class TypedNodeVisitor<R,A> {
|
|
|
|
public R visit(AstNode node, A arg) {
|
|
if (node instanceof ArrayComprehension) {
|
|
return visitArrayComprehension((ArrayComprehension) node, arg);
|
|
} else if (node instanceof WhileLoop) {
|
|
return visitWhileLoop((WhileLoop) node, arg);
|
|
} else if (node instanceof ArrayComprehensionLoop) {
|
|
return visitArrayComprehensionLoop((ArrayComprehensionLoop) node, arg);
|
|
} else if (node instanceof ArrayLiteral) {
|
|
return visitArrayLiteral((ArrayLiteral) node, arg);
|
|
} else if (node instanceof Assignment) {
|
|
return visitAssignment((Assignment) node, arg);
|
|
} else if (node instanceof AstRoot) {
|
|
return visitAstRoot((AstRoot) node, arg);
|
|
} else if (node instanceof Block) {
|
|
return visitBlock((Block) node, arg);
|
|
} else if (node instanceof BreakStatement) {
|
|
return visitBreakStatement((BreakStatement) node, arg);
|
|
} else if (node instanceof CatchClause) {
|
|
return visitCatchClause((CatchClause) node, arg);
|
|
} else if (node instanceof Comment) {
|
|
return visitComment((Comment) node, arg);
|
|
} else if (node instanceof ConditionalExpression) {
|
|
return visitConditionalExpression((ConditionalExpression) node, arg);
|
|
} else if (node instanceof ContinueStatement) {
|
|
return visitContinueStatement((ContinueStatement) node, arg);
|
|
} else if (node instanceof DoLoop) {
|
|
return visitDoLoop((DoLoop) node, arg);
|
|
} else if (node instanceof ElementGet) {
|
|
return visitElementGet((ElementGet) node, arg);
|
|
} else if (node instanceof EmptyExpression) {
|
|
return visitEmptyExpression((EmptyExpression) node, arg);
|
|
} else if (node instanceof ErrorNode) {
|
|
return visitErrorNode((ErrorNode) node, arg);
|
|
} else if (node instanceof ExpressionStatement) {
|
|
return visitExpressionStatement((ExpressionStatement) node, arg);
|
|
} else if (node instanceof ForInLoop) {
|
|
return visitForInLoop((ForInLoop) node, arg);
|
|
} else if (node instanceof ForLoop) {
|
|
return visitForLoop((ForLoop) node, arg);
|
|
} else if (node instanceof NewExpression) {
|
|
return visitNewExpression((NewExpression) node, arg);
|
|
} else if (node instanceof FunctionCall) {
|
|
return visitFunctionCall((FunctionCall) node, arg);
|
|
} else if (node instanceof FunctionNode) {
|
|
return visitFunctionNode((FunctionNode) node, arg);
|
|
} else if (node instanceof IfStatement) {
|
|
return visitIfStatement((IfStatement) node, arg);
|
|
} else if (node instanceof KeywordLiteral) {
|
|
return visitKeywordLiteral((KeywordLiteral) node, arg);
|
|
} else if (node instanceof Label) {
|
|
return visitLabel((Label) node, arg);
|
|
} else if (node instanceof LabeledStatement) {
|
|
return visitLabeledStatement((LabeledStatement) node, arg);
|
|
} else if (node instanceof LetNode) {
|
|
return visitLetNode((LetNode) node, arg);
|
|
} else if (node instanceof Name) {
|
|
return visitName((Name) node, arg);
|
|
} else if (node instanceof NumberLiteral) {
|
|
return visitNumberLiteral((NumberLiteral) node, arg);
|
|
} else if (node instanceof ObjectLiteral) {
|
|
return visitObjectLiteral((ObjectLiteral) node, arg);
|
|
} else if (node instanceof ObjectProperty) {
|
|
return visitObjectProperty((ObjectProperty) node, arg);
|
|
} else if (node instanceof ParenthesizedExpression) {
|
|
return visitParenthesizedExpression((ParenthesizedExpression) node, arg);
|
|
} else if (node instanceof PropertyGet) {
|
|
return visitPropertyGet((PropertyGet) node, arg);
|
|
} else if (node instanceof RegExpLiteral) {
|
|
return visitRegExpLiteral((RegExpLiteral) node, arg);
|
|
} else if (node instanceof ReturnStatement) {
|
|
return visitReturnStatement((ReturnStatement) node, arg);
|
|
} else if (node instanceof Scope) {
|
|
return visitScope((Scope) node, arg);
|
|
} else if (node instanceof ScriptNode) {
|
|
return visitScriptNode((ScriptNode) node, arg);
|
|
} else if (node instanceof StringLiteral) {
|
|
return visitStringLiteral((StringLiteral) node, arg);
|
|
} else if (node instanceof SwitchCase) {
|
|
return visitSwitchCase((SwitchCase) node, arg);
|
|
} else if (node instanceof SwitchStatement) {
|
|
return visitSwitchStatement((SwitchStatement) node, arg);
|
|
} else if (node instanceof ThrowStatement) {
|
|
return visitThrowStatement((ThrowStatement) node, arg);
|
|
} else if (node instanceof TryStatement) {
|
|
return visitTryStatement((TryStatement) node, arg);
|
|
} else if (node instanceof UnaryExpression) {
|
|
return visitUnaryExpression((UnaryExpression) node, arg);
|
|
} else if (node instanceof VariableDeclaration) {
|
|
return visitVariableDeclaration((VariableDeclaration) node, arg);
|
|
} else if (node instanceof VariableInitializer) {
|
|
return visitVariableInitializer((VariableInitializer) node, arg);
|
|
} else if (node instanceof WithStatement) {
|
|
return visitWithStatement((WithStatement) node, arg);
|
|
} else if (node instanceof XmlDotQuery) {
|
|
return visitXmlDotQuery((XmlDotQuery) node, arg);
|
|
} else if (node instanceof XmlElemRef) {
|
|
return visitXmlElemRef((XmlElemRef) node, arg);
|
|
} else if (node instanceof XmlExpression) {
|
|
return visitXmlExpression((XmlExpression) node, arg);
|
|
} else if (node instanceof XmlLiteral) {
|
|
return visitXmlLiteral((XmlLiteral) node, arg);
|
|
} else if (node instanceof XmlMemberGet) {
|
|
return visitXmlMemberGet((XmlMemberGet) node, arg);
|
|
} else if (node instanceof XmlPropRef) {
|
|
return visitXmlPropRef((XmlPropRef) node, arg);
|
|
} else if (node instanceof XmlString) {
|
|
return visitXmlString((XmlString) node, arg);
|
|
} else if (node instanceof Yield) {
|
|
return visitYield((Yield) node, arg);
|
|
} else if (node instanceof InfixExpression) {
|
|
return visitInfixExpression((InfixExpression) node, arg);
|
|
} else if (node instanceof Jump) {
|
|
return visitJump((Jump) node, arg);
|
|
} else {
|
|
throw new Error("unexpected node type " + node.getClass().getName());
|
|
}
|
|
|
|
}
|
|
|
|
public abstract R visitArrayComprehension(ArrayComprehension node, A arg) ;
|
|
|
|
public abstract R visitArrayComprehensionLoop(ArrayComprehensionLoop node, A arg) ;
|
|
|
|
public abstract R visitArrayLiteral(ArrayLiteral node, A arg) ;
|
|
|
|
public abstract R visitAssignment(Assignment node, A arg) ;
|
|
|
|
public abstract R visitAstRoot(AstRoot node, A arg) ;
|
|
|
|
public abstract R visitBlock(Block node, A arg) ;
|
|
|
|
public abstract R visitBreakStatement(BreakStatement node, A arg) ;
|
|
|
|
public abstract R visitCatchClause(CatchClause node, A arg) ;
|
|
|
|
public abstract R visitComment(Comment node, A arg) ;
|
|
|
|
public abstract R visitConditionalExpression(ConditionalExpression node, A arg) ;
|
|
|
|
public abstract R visitContinueStatement(ContinueStatement node, A arg) ;
|
|
|
|
public abstract R visitDoLoop(DoLoop node, A arg) ;
|
|
|
|
public abstract R visitElementGet(ElementGet node, A arg) ;
|
|
|
|
public abstract R visitEmptyExpression(EmptyExpression node, A arg) ;
|
|
|
|
public abstract R visitErrorNode(ErrorNode node, A arg) ;
|
|
|
|
public abstract R visitExpressionStatement(ExpressionStatement node, A arg) ;
|
|
|
|
public abstract R visitForInLoop(ForInLoop node, A arg) ;
|
|
|
|
public abstract R visitForLoop(ForLoop node, A arg) ;
|
|
|
|
public abstract R visitFunctionCall(FunctionCall node, A arg) ;
|
|
|
|
public abstract R visitFunctionNode(FunctionNode node, A arg) ;
|
|
|
|
public abstract R visitIfStatement(IfStatement node, A arg) ;
|
|
|
|
public abstract R visitInfixExpression(InfixExpression node, A arg) ;
|
|
|
|
public abstract R visitJump(Jump node, A arg) ;
|
|
|
|
public abstract R visitKeywordLiteral(KeywordLiteral node, A arg) ;
|
|
|
|
public abstract R visitLabel(Label node, A arg) ;
|
|
|
|
public abstract R visitLabeledStatement(LabeledStatement node, A arg) ;
|
|
|
|
public abstract R visitLetNode(LetNode node, A arg) ;
|
|
|
|
public abstract R visitName(Name node, A arg) ;
|
|
|
|
public abstract R visitNewExpression(NewExpression node, A arg) ;
|
|
|
|
public abstract R visitNumberLiteral(NumberLiteral node, A arg) ;
|
|
|
|
public abstract R visitObjectLiteral(ObjectLiteral node, A arg) ;
|
|
|
|
public abstract R visitObjectProperty(ObjectProperty node, A arg) ;
|
|
|
|
public abstract R visitParenthesizedExpression(ParenthesizedExpression node, A arg) ;
|
|
|
|
public abstract R visitPropertyGet(PropertyGet node, A arg) ;
|
|
|
|
public abstract R visitRegExpLiteral(RegExpLiteral node, A arg) ;
|
|
|
|
public abstract R visitReturnStatement(ReturnStatement node, A arg) ;
|
|
|
|
public abstract R visitScope(Scope node, A arg) ;
|
|
|
|
public abstract R visitScriptNode(ScriptNode node, A arg) ;
|
|
|
|
public abstract R visitStringLiteral(StringLiteral node, A arg) ;
|
|
|
|
public abstract R visitSwitchCase(SwitchCase node, A arg) ;
|
|
|
|
public abstract R visitSwitchStatement(SwitchStatement node, A arg) ;
|
|
|
|
public abstract R visitSymbol(Symbol node, A arg) ;
|
|
|
|
public abstract R visitThrowStatement(ThrowStatement node, A arg) ;
|
|
|
|
public abstract R visitTryStatement(TryStatement node, A arg) ;
|
|
|
|
public abstract R visitUnaryExpression(UnaryExpression node, A arg) ;
|
|
|
|
public abstract R visitVariableDeclaration(VariableDeclaration node, A arg) ;
|
|
|
|
public abstract R visitVariableInitializer(VariableInitializer node, A arg) ;
|
|
|
|
public abstract R visitWhileLoop(WhileLoop node, A arg) ;
|
|
|
|
public abstract R visitWithStatement(WithStatement node, A arg) ;
|
|
|
|
public abstract R visitXmlDotQuery(XmlDotQuery node, A arg) ;
|
|
|
|
public abstract R visitXmlElemRef(XmlElemRef node, A arg) ;
|
|
|
|
public abstract R visitXmlExpression(XmlExpression node, A arg) ;
|
|
|
|
public abstract R visitXmlFragment(XmlFragment node, A arg) ;
|
|
|
|
public abstract R visitXmlLiteral(XmlLiteral node, A arg) ;
|
|
|
|
public abstract R visitXmlMemberGet(XmlMemberGet node, A arg) ;
|
|
|
|
public abstract R visitXmlPropRef(XmlPropRef node, A arg) ;
|
|
|
|
public abstract R visitXmlRef(XmlRef node, A arg) ;
|
|
|
|
public abstract R visitXmlString(XmlString node, A arg) ;
|
|
|
|
public abstract R visitYield(Yield node, A arg) ;
|
|
|
|
}
|