#
# Jasy - Web Tooling Framework
# Copyright 2010-2012 Zynga Inc.
# Copyright 2013-2014 Sebastian Werner
#
#
# License: MPL 1.1/GPL 2.0/LGPL 2.1
# Authors:
# - Brendan Eich <brendan@mozilla.org> (Original JavaScript) (2004-2010)
# - Sebastian Werner <info@sebastian-werner.net> (Python Port) (2010)
#
import jasy.script.parse.Node
[docs]class VanillaBuilder:
"""The vanilla AST builder."""
[docs] def IF_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "if")
[docs] def IF_setCondition(self, node, expression):
node.append(expression, "condition")
[docs] def IF_setThenPart(self, node, statement):
node.append(statement, "thenPart")
[docs] def IF_setElsePart(self, node, statement):
node.append(statement, "elsePart")
[docs] def IF_finish(self, node):
pass
[docs] def SWITCH_build(self, tokenizer):
node = jasy.script.parse.Node.Node(tokenizer, "switch")
node.defaultIndex = -1
return node
[docs] def SWITCH_setDiscriminant(self, node, expression):
node.append(expression, "discriminant")
[docs] def SWITCH_setDefaultIndex(self, node, index):
node.defaultIndex = index
[docs] def SWITCH_addCase(self, node, childNode):
node.append(childNode)
[docs] def SWITCH_finish(self, node):
pass
[docs] def CASE_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "case")
[docs] def CASE_setLabel(self, node, expression):
node.append(expression, "label")
[docs] def CASE_initializeStatements(self, node, tokenizer):
node.append(jasy.script.parse.Node.Node(tokenizer, "block"), "statements")
[docs] def CASE_addStatement(self, node, statement):
node.statements.append(statement)
[docs] def CASE_finish(self, node):
pass
[docs] def DEFAULT_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "default")
[docs] def DEFAULT_initializeStatements(self, node, tokenizer):
node.append(jasy.script.parse.Node.Node(tokenizer, "block"), "statements")
[docs] def DEFAULT_addStatement(self, node, statement):
node.statements.append(statement)
[docs] def DEFAULT_finish(self, node):
pass
[docs] def FOR_build(self, tokenizer):
node = jasy.script.parse.Node.Node(tokenizer, "for")
node.isLoop = True
node.isEach = False
return node
[docs] def FOR_rebuildForEach(self, node):
node.isEach = True
# NB: This function is called after rebuildForEach, if that'statement called at all.
[docs] def FOR_rebuildForIn(self, node):
node.type = "for_in"
[docs] def FOR_setCondition(self, node, expression):
node.append(expression, "condition")
[docs] def FOR_setSetup(self, node, expression):
node.append(expression, "setup")
[docs] def FOR_setUpdate(self, node, expression):
node.append(expression, "update")
[docs] def FOR_setObject(self, node, expression, forBlock=None):
# wpbasti: not sure what forBlock stands for but it is used in the parser
# JS tolerates the optinal unused parameter, but not so Python.
node.append(expression, "object")
[docs] def FOR_setIterator(self, node, expression, forBlock=None):
# wpbasti: not sure what forBlock stands for but it is used in the parser
# JS tolerates the optinal unused parameter, but not so Python.
node.append(expression, "iterator")
[docs] def FOR_setBody(self, node, statement):
node.append(statement, "body")
[docs] def FOR_finish(self, node):
pass
[docs] def WHILE_build(self, tokenizer):
node = jasy.script.parse.Node.Node(tokenizer, "while")
node.isLoop = True
return node
[docs] def WHILE_setCondition(self, node, expression):
node.append(expression, "condition")
[docs] def WHILE_setBody(self, node, statement):
node.append(statement, "body")
[docs] def WHILE_finish(self, node):
pass
[docs] def DO_build(self, tokenizer):
node = jasy.script.parse.Node.Node(tokenizer, "do")
node.isLoop = True
return node
[docs] def DO_setCondition(self, node, expression):
node.append(expression, "condition")
[docs] def DO_setBody(self, node, statement):
node.append(statement, "body")
[docs] def DO_finish(self, node):
pass
[docs] def BREAK_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "break")
[docs] def BREAK_setLabel(self, node, label):
node.label = label
[docs] def BREAK_setTarget(self, node, target):
# Hint, no append() - relation, but not a child
node.target = target
[docs] def BREAK_finish(self, node):
pass
[docs] def CONTINUE_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "continue")
[docs] def CONTINUE_setLabel(self, node, label):
node.label = label
[docs] def CONTINUE_setTarget(self, node, target):
# Hint, no append() - relation, but not a child
node.target = target
[docs] def CONTINUE_finish(self, node):
pass
[docs] def TRY_build(self, tokenizer):
node = jasy.script.parse.Node.Node(tokenizer, "try")
return node
[docs] def TRY_setTryBlock(self, node, statement):
node.append(statement, "tryBlock")
[docs] def TRY_addCatch(self, node, childNode):
node.append(childNode)
[docs] def TRY_finishCatches(self, node):
pass
[docs] def TRY_setFinallyBlock(self, node, statement):
node.append(statement, "finallyBlock")
[docs] def TRY_finish(self, node):
pass
[docs] def CATCH_build(self, tokenizer):
node = jasy.script.parse.Node.Node(tokenizer, "catch")
return node
[docs] def CATCH_wrapException(self, tokenizer):
node = jasy.script.parse.Node.Node(tokenizer, "exception")
node.value = tokenizer.token.value
return node
[docs] def CATCH_setException(self, node, exception):
node.append(exception, "exception")
[docs] def CATCH_setGuard(self, node, expression):
node.append(expression, "guard")
[docs] def CATCH_setBlock(self, node, statement):
node.append(statement, "block")
[docs] def CATCH_finish(self, node):
pass
[docs] def THROW_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "throw")
[docs] def THROW_setException(self, node, expression):
node.append(expression, "exception")
[docs] def THROW_finish(self, node):
pass
[docs] def RETURN_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "return")
[docs] def RETURN_setValue(self, node, expression):
node.append(expression, "value")
[docs] def RETURN_finish(self, node):
pass
[docs] def YIELD_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "yield")
[docs] def YIELD_setValue(self, node, expression):
node.append(expression, "value")
[docs] def YIELD_finish(self, node):
pass
[docs] def GENERATOR_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "generator")
[docs] def GENERATOR_setExpression(self, node, expression):
node.append(expression, "expression")
[docs] def GENERATOR_setTail(self, node, childNode):
node.append(childNode, "tail")
[docs] def GENERATOR_finish(self, node):
pass
[docs] def WITH_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "with")
[docs] def WITH_setObject(self, node, expression):
node.append(expression, "object")
[docs] def WITH_setBody(self, node, statement):
node.append(statement, "body")
[docs] def WITH_finish(self, node):
pass
[docs] def DEBUGGER_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "debugger")
[docs] def SEMICOLON_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "semicolon")
[docs] def SEMICOLON_setExpression(self, node, expression):
node.append(expression, "expression")
[docs] def SEMICOLON_finish(self, node):
pass
[docs] def LABEL_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "label")
[docs] def LABEL_setLabel(self, node, label):
node.label = label
[docs] def LABEL_setStatement(self, node, statement):
node.append(statement, "statement")
[docs] def LABEL_finish(self, node):
pass
[docs] def FUNCTION_build(self, tokenizer):
node = jasy.script.parse.Node.Node(tokenizer)
if node.type != "function":
if tokenizer.token.value == "get":
node.type = "getter"
else:
node.type = "setter"
return node
[docs] def FUNCTION_setName(self, node, identifier):
node.name = identifier
[docs] def FUNCTION_initParams(self, node, tokenizer):
node.append(jasy.script.parse.Node.Node(tokenizer, "list"), "params")
[docs] def FUNCTION_wrapParam(self, tokenizer):
param = jasy.script.parse.Node.Node(tokenizer)
param.value = tokenizer.token.value
return param
[docs] def FUNCTION_addParam(self, node, tokenizer, expression):
node.params.append(expression)
[docs] def FUNCTION_setExpressionClosure(self, node, expressionClosure):
node.expressionClosure = expressionClosure
[docs] def FUNCTION_setBody(self, node, statement):
# copy over function parameters to function body
params = getattr(node, "params", None)
# if params:
# statement.params = [param.value for param in params]
node.append(statement, "body")
[docs] def FUNCTION_hoistVars(self, x):
pass
[docs] def FUNCTION_finish(self, node, x):
pass
[docs] def VAR_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "var")
[docs] def VAR_addDecl(self, node, childNode, childContext=None):
node.append(childNode)
[docs] def VAR_finish(self, node):
pass
[docs] def CONST_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "const")
[docs] def CONST_addDecl(self, node, childNode, childContext=None):
node.append(childNode)
[docs] def CONST_finish(self, node):
pass
[docs] def LET_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "let")
[docs] def LET_addDecl(self, node, childNode, childContext=None):
node.append(childNode)
[docs] def LET_finish(self, node):
pass
[docs] def DECL_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "declaration")
[docs] def DECL_setNames(self, node, expression):
node.append(expression, "names")
[docs] def DECL_setName(self, node, identifier):
node.name = identifier
[docs] def DECL_setInitializer(self, node, expression):
node.append(expression, "initializer")
[docs] def DECL_setReadOnly(self, node, readOnly):
node.readOnly = readOnly
[docs] def DECL_finish(self, node):
pass
[docs] def LETBLOCK_build(self, tokenizer):
node = jasy.script.parse.Node.Node(tokenizer, "let_block")
return node
[docs] def LETBLOCK_setVariables(self, node, childNode):
node.append(childNode, "variables")
[docs] def LETBLOCK_setExpression(self, node, expression):
node.append(expression, "expression")
[docs] def LETBLOCK_setBlock(self, node, statement):
node.append(statement, "block")
[docs] def LETBLOCK_finish(self, node):
pass
[docs] def BLOCK_build(self, tokenizer, id):
node = jasy.script.parse.Node.Node(tokenizer, "block")
# node.id = id
return node
[docs] def BLOCK_hoistLets(self, node):
pass
[docs] def BLOCK_addStatement(self, node, childNode):
node.append(childNode)
[docs] def BLOCK_finish(self, node):
pass
[docs] def EXPRESSION_build(self, tokenizer, tokenType):
return jasy.script.parse.Node.Node(tokenizer, tokenType)
[docs] def EXPRESSION_addOperand(self, node, childNode):
node.append(childNode)
[docs] def EXPRESSION_finish(self, node):
pass
[docs] def ASSIGN_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "assign")
[docs] def ASSIGN_addOperand(self, node, childNode):
node.append(childNode)
[docs] def ASSIGN_setAssignOp(self, node, operator):
node.assignOp = operator
[docs] def ASSIGN_finish(self, node):
pass
[docs] def HOOK_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "hook")
[docs] def HOOK_setCondition(self, node, expression):
node.append(expression, "condition")
[docs] def HOOK_setThenPart(self, node, childNode):
node.append(childNode, "thenPart")
[docs] def HOOK_setElsePart(self, node, childNode):
node.append(childNode, "elsePart")
[docs] def HOOK_finish(self, node):
pass
[docs] def OR_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "or")
[docs] def OR_addOperand(self, node, childNode):
node.append(childNode)
[docs] def OR_finish(self, node):
pass
[docs] def AND_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "and")
[docs] def AND_addOperand(self, node, childNode):
node.append(childNode)
[docs] def AND_finish(self, node):
pass
[docs] def BITWISEOR_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "bitwise_or")
[docs] def BITWISEOR_addOperand(self, node, childNode):
node.append(childNode)
[docs] def BITWISEOR_finish(self, node):
pass
[docs] def BITWISEXOR_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "bitwise_xor")
[docs] def BITWISEXOR_addOperand(self, node, childNode):
node.append(childNode)
[docs] def BITWISEXOR_finish(self, node):
pass
[docs] def BITWISEAND_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "bitwise_and")
[docs] def BITWISEAND_addOperand(self, node, childNode):
node.append(childNode)
[docs] def BITWISEAND_finish(self, node):
pass
[docs] def EQUALITY_build(self, tokenizer):
# NB: tokenizer.token.type must be "eq", "ne", "strict_eq", or "strict_ne".
return jasy.script.parse.Node.Node(tokenizer)
[docs] def EQUALITY_addOperand(self, node, childNode):
node.append(childNode)
[docs] def EQUALITY_finish(self, node):
pass
[docs] def RELATIONAL_build(self, tokenizer):
# NB: tokenizer.token.type must be "lt", "le", "ge", or "gt".
return jasy.script.parse.Node.Node(tokenizer)
[docs] def RELATIONAL_addOperand(self, node, childNode):
node.append(childNode)
[docs] def RELATIONAL_finish(self, node):
pass
[docs] def SHIFT_build(self, tokenizer):
# NB: tokenizer.token.type must be "lsh", "rsh", or "ursh".
return jasy.script.parse.Node.Node(tokenizer)
[docs] def SHIFT_addOperand(self, node, childNode):
node.append(childNode)
[docs] def SHIFT_finish(self, node):
pass
[docs] def ADD_build(self, tokenizer):
# NB: tokenizer.token.type must be "plus" or "minus".
return jasy.script.parse.Node.Node(tokenizer)
[docs] def ADD_addOperand(self, node, childNode):
node.append(childNode)
[docs] def ADD_finish(self, node):
pass
[docs] def MULTIPLY_build(self, tokenizer):
# NB: tokenizer.token.type must be "mul", "div", or "mod".
return jasy.script.parse.Node.Node(tokenizer)
[docs] def MULTIPLY_addOperand(self, node, childNode):
node.append(childNode)
[docs] def MULTIPLY_finish(self, node):
pass
[docs] def UNARY_build(self, tokenizer):
# NB: tokenizer.token.type must be "delete", "void", "typeof", "not", "bitwise_not",
# "unary_plus", "unary_minus", "increment", or "decrement".
if tokenizer.token.type == "plus":
tokenizer.token.type = "unary_plus"
elif tokenizer.token.type == "minus":
tokenizer.token.type = "unary_minus"
return jasy.script.parse.Node.Node(tokenizer)
[docs] def UNARY_addOperand(self, node, childNode):
node.append(childNode)
[docs] def UNARY_setPostfix(self, node):
node.postfix = True
[docs] def UNARY_finish(self, node):
pass
[docs] def MEMBER_build(self, tokenizer, tokenType=None):
node = jasy.script.parse.Node.Node(tokenizer, tokenType)
if node.type == "identifier":
node.value = tokenizer.token.value
return node
[docs] def MEMBER_rebuildNewWithArgs(self, node):
node.type = "new_with_args"
[docs] def MEMBER_addOperand(self, node, childNode):
node.append(childNode)
[docs] def MEMBER_finish(self, node):
pass
[docs] def PRIMARY_build(self, tokenizer, tokenType):
# NB: tokenizer.token.type must be "null", "this", "true", "false", "identifier", "number", "string", or "regexp".
node = jasy.script.parse.Node.Node(tokenizer, tokenType)
if tokenType in ("identifier", "string", "regexp", "number"):
node.value = tokenizer.token.value
return node
[docs] def PRIMARY_finish(self, node):
pass
[docs] def ARRAYINIT_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "array_init")
[docs] def ARRAYINIT_addElement(self, node, childNode):
node.append(childNode)
[docs] def ARRAYINIT_finish(self, node):
pass
[docs] def ARRAYCOMP_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "array_comp")
[docs] def ARRAYCOMP_setExpression(self, node, expression):
node.append(expression, "expression")
[docs] def ARRAYCOMP_setTail(self, node, childNode):
node.append(childNode, "tail")
[docs] def ARRAYCOMP_finish(self, node):
pass
[docs] def COMPTAIL_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "comp_tail")
[docs] def COMPTAIL_setGuard(self, node, expression):
node.append(expression, "guard")
[docs] def COMPTAIL_addFor(self, node, childNode):
node.append(childNode, "for")
[docs] def COMPTAIL_finish(self, node):
pass
[docs] def OBJECTINIT_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "object_init")
[docs] def OBJECTINIT_addProperty(self, node, childNode):
node.append(childNode)
[docs] def OBJECTINIT_finish(self, node):
pass
[docs] def PROPERTYINIT_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "property_init")
[docs] def PROPERTYINIT_addOperand(self, node, childNode):
node.append(childNode)
[docs] def PROPERTYINIT_finish(self, node):
pass
[docs] def COMMA_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "comma")
[docs] def COMMA_addOperand(self, node, childNode):
node.append(childNode)
[docs] def COMMA_finish(self, node):
pass
[docs] def LIST_build(self, tokenizer):
return jasy.script.parse.Node.Node(tokenizer, "list")
[docs] def LIST_addOperand(self, node, childNode):
node.append(childNode)
[docs] def LIST_finish(self, node):
pass
[docs] def setHoists(self, id, vds):
pass