def run_test_executor(self, instructions, final_stack, initial_environment, final_environment): code = Code() for inst in instructions: code.add_instruction( Instruction(inst[0], *tuple(inst[1:len(inst)]))) env = Environment() for key, value in initial_environment.items(): env.defineVariable(key, value) executor = Executor(env) executor.execute(code) self.assertEqual(len(final_stack), len(executor.stack.stack)) for i in range(0, len(final_stack)): f_elt = final_stack[i] a_elt = executor.stack.stack[i] if (isinstance(f_elt, Object) or isinstance(f_elt, Function)): self.assertEqual(f_elt.__class__, a_elt.__class__) else: self.assertEqual(f_elt, a_elt) for key, value in final_environment.items(): self.assertEqual(env.value(key), value) return (executor.stack.stack, env)
def run_test_executor(self, instructions, final_stack, initial_environment, final_environment): code = Code() for inst in instructions: code.add_instruction(Instruction(inst[0], *tuple(inst[1:len(inst)]))) env = Environment() for key, value in initial_environment.items(): env.defineVariable(key, value) executor = Executor(env) executor.execute(code) self.assertEqual(len(final_stack), len(executor.stack.stack)) for i in range(0, len(final_stack)): f_elt = final_stack[i] a_elt = executor.stack.stack[i] if(isinstance(f_elt, Object) or isinstance(f_elt, Function)): self.assertEqual(f_elt.__class__, a_elt.__class__) else: self.assertEqual(f_elt, a_elt) for key, value in final_environment.items(): self.assertEqual(env.value(key), value) return (executor.stack.stack, env)
def runFunction(environment): self.environment = Environment(environment) for c in ctx.children: try: c.accept(self) except ReturnException as re: return re.value finally: self.environment = self.environment.parent
def func(env): previous_environment = self.environment self.environment = Environment(env) for c in ctx.children: res = c.accept(self) if isinstance(res, tuple) and res[0] == "RETURN": res = res[1] break self.environment = previous_environment return res
def visitNewExpression(self, ctx): func = ctx.children[1].accept(self) args = ctx.children[2].accept(self) if (args == None or args == ')'): args = [] if hasattr(func, "prototype") and hasattr(func.prototype, "create"): theNewObject = func.prototype.create(None, func.prototype) else: theNewObject = ObjectModule() self.environment = Environment(self.environment) func(theNewObject, *args) self.environment.defineVariable('this', theNewObject) if self.environment.parent: self.environment = self.environment.parent return theNewObject
def test_single_environment(self): environment = Environment() self.assertRaises(Utils.UnknownVariable, environment.value, "test") environment.defineVariable("test", 10) self.assertEqual(environment.value("test"), 10) environment.setVariable("test", 5) self.assertEqual(environment.value("test"), 5) self.assertRaises(Utils.UnknownVariable, environment.setVariable, "test2", 5)
def __call__(self, this, *args): ''' Call the function. With the this argument. step by step: create function-environment with correct parent in the local scope create pointer to self (this) zip argument names from function initiation with argument values set all environment variables with its values return function-body(function-arguments) == return f(x) ''' localEnvironment = Environment(self.parent) localEnvironment.defineVariable("this", this) argValuePairs = zip(self.argNames, args) for name, value in argValuePairs: localEnvironment.defineVariable(name, value) return self.body(localEnvironment)
def runFunction(environment): self.environment = Environment(environment) for c in ctx.children: try: c.accept(self) except ReturnException as re: return re.value finally: self.environment = self.environment.parent
def visitTryStatement(self, ctx): res = ctx.children[1].accept(self) if isinstance( res, tuple ) and res[0] == "THROW": # There was a throw in the try-block var_name, block = ctx.children[2].accept(self) # Create new environment for the catch block self.environment = Environment(self.environment) self.environment.defineVariable(var_name.accept(self), res[1].accept(self)) block.accept(self) # Set back the environment self.environment = self.environment.parent # Check for finally-clause and evaluate if so if len(ctx.children) == 4: ctx.children[3].accept(self)
def test_024_new(self): def func_new(env): self.assertTrue(env.value("this"), Object) self.assertEqual(env.value('a'), 1.0) self.assertEqual(env.value('b'), 2.0) f = Function(['a', 'b'], Environment(), func_new) self.run_test_executor([[OpCode.PUSH, 1.0], [OpCode.PUSH, 2.0], [OpCode.PUSH, f], [OpCode.NEW, 2]], [Object()], {}, {})
def test_023_call(self): global test_014_called test_014_called = False def func_body(env): global test_014_called test_014_called = True f = Function([], Environment(), func_body) self.run_test_executor([[OpCode.PUSH, f], [OpCode.CALL, 0]], [None], {}, {}) self.assertTrue(test_014_called) def func_body_params(env): self.assertEqual(env.value('a'), 1.0) self.assertEqual(env.value('b'), 2.0) f = Function(['a', 'b'], Environment(), func_body) self.run_test_executor([[OpCode.PUSH, 1.0], [OpCode.PUSH, 2.0], [OpCode.PUSH, f], [OpCode.CALL, 2]], [None], {}, {})
def call(self, that, this, *args): ''' Call the function. This function is usefull since in ECMAScript, a function is an object and it can be called with the function "call". For instance: function MyFunction(arg) { console.log(arg) } MyFunction.call(2) In which case, that is a pointer to MyFunction and this to None. But where it becomes tricky is with: var obj = { member: function(arg) { this.value = arg } } obj.call(2) In which case that contains obj.member and this contains obj. In practice, the that argument can be ignored. In other word: * that is the pointer to the object of the function * this is the pointer to the object (equivalent of self in python) * args is the list of arguments passed to the function ''' # Should you create a new Environment here and add the args to that env? current_env = Environment(self.environment) for i in range(len(args)): current_env.defineVariable(self.args[i], args[i]) # Add 'this' and 'that' to current_env?? current_env.defineVariable('this', this) current_env.defineVariable('that', that) return self.body(current_env)
def test_function(self): # # This test that a simple call works # env = Environment() function = Function(["arg1", "arg2", "finalarg"], env, lambda environment: self.func1(environment)) function(None, 10, 2, 5) function.call(None, None, 10, 2, 5) # # This test that "this" is correctly set # env = Environment() function = Function(["arg1", "arg2"], env, lambda environment: self.func2(environment)) function(10, 2, 5) function.call(None, 10, 2, 5) # # This test that global variables works # env = Environment() env.defineVariable("glob", 4) function = Function(["arg1", "arg2"], env, lambda environment: self.func3(environment)) function(10, 2, 5) self.assertEqual(env.value("glob"), 3) self.assertRaises(Utils.UnknownVariable, env.value, "testator") env.setVariable("glob", 4) function.call(None, 10, 2, 5) self.assertEqual(env.value("glob"), 3) self.assertRaises(Utils.UnknownVariable, env.value, "testator") # # This test that the ReturnException is correctly catched in the call function # env = Environment() function = Function(["arg1", "arg2"], env, lambda environment: self.func4(environment)) self.assertEqual(function(None, 2, 5), 7)
def visitNewExpression(self, ctx): func = ctx.children[1].accept(self) args = ctx.children[2].accept(self) if(args == None or args == ')'): args = [] if hasattr(func, "prototype") and hasattr(func.prototype, "create"): theNewObject = func.prototype.create(None, func.prototype) else: theNewObject = ObjectModule() self.environment = Environment(self.environment) func(theNewObject, *args) self.environment.defineVariable('this', theNewObject) if self.environment.parent: self.environment = self.environment.parent return theNewObject
def __call__(self, this, *args, thatVar=None): ''' Call the function. With the this argument. step by step: create function-environment with correct parent in the local scope create pointer to self (this) zip argument names from function initiation with argument values set all environment variables with its values return function-body(function-arguments) == return f(x) ''' localEnvironment = Environment(self.parent) if this: localEnvironment.defineVariable("this", this) if thatVar: localEnvironment.defineVariable("that", thatVar) argValuePairs = zip(self.argNames, args) for name, value in argValuePairs: localEnvironment.defineVariable(name, value) return self.body(localEnvironment)
def __init__(self, environment=Environment(), input=None): self.environment = environment self.environment.defineVariable("console", Console()) self.environment.defineVariable("Math", MathModule()) self.environment.defineVariable("Object", ObjectModule()) self.binaries = { '+': operator.add, '-': operator.sub, '*': operator.mul, '/': operator.truediv, '%': operator.mod, '<<': lambda x, y: float(operator.lshift(int(x), int(y))), '>>': lambda x, y: float(operator.rshift(int(x), int(y))), '>>>': lambda x, y: float((int(x) % 0x100000000) >> int(y)), '<': operator.lt, '>': operator.gt, '<=': operator.le, '>=': operator.ge, '==': operator.eq, '!=': operator.ne, '===': lambda x, y: type(x) == type(y) and x == y, '!==': lambda x, y: type(x) != type(y) or x != y, '||': lambda x, y: x or y, '&&': lambda x, y: x and y } self.unaries = { '-': operator.neg, '+': operator.pos, '~': lambda x: float(~int(x)), '!': operator.not_, '++': lambda x: x.__add__(1), '--': lambda x: x.__add__(-1) } self.assignment = { '=': lambda x, y: y, '+=': operator.iadd, '-=': operator.isub, '*=': operator.mul, '/=': operator.truediv }
def test_function(self): # # This test that a simple call works # env = Environment() function = Function(["arg1", "arg2", "finalarg"], env, lambda environment: self.func1(environment)) function(None, 10, 2, 5) function.call(None, None, 10, 2, 5) # # This test that "this" is correctly set # env = Environment() function = Function(["arg1", "arg2"], env, lambda environment: self.func2(environment)) function(10, 2, 5) function.call(None, 10, 2, 5) # # This test that global variables works # env = Environment() env.defineVariable("glob", 4) function = Function(["arg1", "arg2"], env, lambda environment: self.func3(environment)) function(10, 2, 5) self.assertEqual(env.value("glob"), 3) self.assertRaises(Utils.UnknownVariable, env.value, "testator") env.setVariable("glob", 4) function.call(None, 10, 2, 5) self.assertEqual(env.value("glob"), 3) self.assertRaises(Utils.UnknownVariable, env.value, "testator") # # This test that the ReturnException is correctly catched in the call function # env = Environment() function = Function(["arg1", "arg2"], env, lambda environment: self.func4(environment)) self.assertEqual(function(None, 2, 5), 7)
def test_chain_environment(self): root_environment = Environment() child_environment = Environment(root_environment) root_environment.defineVariable("test", 5) self.assertEqual(root_environment.value("test"), 5) self.assertEqual(child_environment.value("test"), 5) child_environment.setVariable("test", 2) self.assertEqual(root_environment.value("test"), 2) self.assertEqual(child_environment.value("test"), 2) child_environment.defineVariable("test", 3) self.assertEqual(root_environment.value("test"), 2) self.assertEqual(child_environment.value("test"), 3) child_environment.setVariable("test", 6) self.assertEqual(root_environment.value("test"), 2) self.assertEqual(child_environment.value("test"), 6) child_environment.defineVariable("test2", 4) self.assertRaises(Utils.UnknownVariable, root_environment.value, "test2") self.assertEqual(child_environment.value("test2"), 4) self.assertRaises(Utils.UnknownVariable, root_environment.setVariable, "test2", 5)
class InterpreterVisitor(ECMAScriptVisitor): def __init__(self, environment = Environment(), input=None): self.environment = environment self.environment.defineVariable("console", Console()) self.environment.defineVariable("Math", MathModule()) self.environment.defineVariable("Object", ObjectModule()) self.binaries = { '+': operator.add, '-': operator.sub, '*': operator.mul, '/': operator.truediv, '%': operator.mod, '<<': lambda x, y: float(operator.lshift(int(x), int(y))), '>>': lambda x, y: float(operator.rshift(int(x), int(y))), '>>>': lambda x, y: float((int(x) % 0x100000000) >> int(y)), '<': operator.lt, '>': operator.gt, '<=': operator.le, '>=': operator.ge, '==': operator.eq, '!=': operator.ne, '===': lambda x, y: type(x) == type(y) and x == y, '!==': lambda x, y: type(x) != type(y) or x != y, '||': lambda x, y: x or y, '&&': lambda x, y: x and y } self.unaries = { '-': operator.neg, '+': operator.pos, '~': lambda x: float(~int(x)), '!': operator.not_, '++': lambda x: x.__add__(1), '--': lambda x: x.__add__(-1)} self.assignment = { '=': lambda x, y: y, '+=': operator.iadd, '-=': operator.isub, '*=': operator.mul, '/=': operator.truediv} def print_env_chain(self, env): if not env.parent: print("GlobalFrame:", env.variableDictionary) else: print("Frame:", env.variableDictionary) self.print_env_chain(env.parent) def inspector(self, ctx): print("‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾") print("In function: ", inspect.stack()[1].function) self.print_env_chain(self.environment) print("_______________________") print("") print("Begin child list, there are", len(ctx.children), "children.") i = 0 for child in ctx.children: try: typ = type(child.accept(self)) except: typ = "<Unacceptable>" val = child.getText() print(i, str(typ) + ": " + str(val)) i += 1 print("End child list of", inspect.stack()[1].function, "\t.!.") print("") def visitTerminal(self, node): if node.symbol.text == "true": return True elif node.symbol.text == "false": return False elif node.symbol.text[0] == '"' or node.symbol.text[0] == "'" : return node.symbol.text[1:-1] elif node.symbol.text[0:2] == "0x": return float.fromhex(node.symbol.text) else: return node.symbol.text # Visit a parse tree produced by ECMAScriptParser#PropertyExpressionAssignment. def visitPropertyExpressionAssignment(self, ctx): return (ctx.children[0].accept(self), ctx.children[2].accept(self)) # Visit a parse tree produced by ECMAScriptParser#assignmentOperator. def visitAssignmentOperator(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#eos. def visitEos(self, ctx): return # Visit a parse tree produced by ECMAScriptParser#program. def visitProgram(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#argumentList. def visitArgumentList(self, ctx): args = [] for c in ctx.children: if(not isinstance(c, antlr4.tree.Tree.TerminalNodeImpl)): # Skip "," args.append(c.accept(self)) return args # Visit a parse tree produced by ECMAScriptParser#ArgumentsExpression. def visitArgumentsExpression(self, ctx): this = self.environment.value(ctx.children[0].getText().split('.')[0]) func = ctx.children[0].accept(self) args = ctx.children[1].accept(self) if(args == None or args == ')'): args = [] if isinstance(func, types.MethodType) and func.__func__ == ObjectModule.defineProperty: return func(args[0], *args) else: return func(this, *args) # Visit a parse tree produced by ECMAScriptParser#ThisExpression. def visitThisExpression(self, ctx): return self.environment.value(ctx.children[0].accept(self)) # Visit a parse tree produced by ECMAScriptParser#identifierName. def visitIdentifierName(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#BinaryExpression. def visitBinaryExpression(self, ctx): arg1 = ctx.children[0].accept(self) operator = ctx.children[1].accept(self) if operator == "&&": return arg1 and ctx.children[2].accept(self) elif operator == "||": return arg1 or ctx.children[2].accept(self) arg2 = ctx.children[2].accept(self) return self.binaries[operator](arg1, arg2) # Visit a parse tree produced by ECMAScriptParser#futureReservedWord. def visitFutureReservedWord(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#initialiser. def visitInitialiser(self, ctx): return ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#statementList. def visitStatementList(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#PropertyGetter. def visitPropertyGetter(self, ctx): name = ctx.children[1].accept(self) body = ctx.children[5].accept(self) param = Object() param.get = Function([], self.environment, body) return (name, param) # Visit a parse tree produced by ECMAScriptParser#block. def visitBlock(self, ctx): # We don't have to define any environment since we don't have # to implement the let keyword. self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#expressionStatement. def visitExpressionStatement(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#keyword. def visitKeyword(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#elementList. def visitElementList(self, ctx): return self.childrenToList(ctx.children) # Visit a parse tree produced by ECMAScriptParser#numericLiteral. def visitNumericLiteral(self, ctx): return float(self.visitChildren(ctx)) # Visit a parse tree produced by ECMAScriptParser#ForInStatement. def visitForInStatement(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#emptyStatement. def visitEmptyStatement(self, ctx): return # Visit a parse tree produced by ECMAScriptParser#labelledStatement. def visitLabelledStatement(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#PropertySetter. def visitPropertySetter(self, ctx): name = ctx.children[1].accept(self) argName = ctx.children[3].accept(self) body = ctx.children[6].accept(self) param = Object() param.set = Function([argName], self.environment, body) return (name, param) # Visit a parse tree produced by ECMAScriptParser#NewExpression. def visitNewExpression(self, ctx): func = ctx.children[1].accept(self) args = ctx.children[2].accept(self) if(args == None or args == ')'): args = [] if hasattr(func, "prototype") and hasattr(func.prototype, "create"): theNewObject = func.prototype.create(None, func.prototype) else: theNewObject = ObjectModule() self.environment = Environment(self.environment) func(theNewObject, *args) self.environment.defineVariable('this', theNewObject) if self.environment.parent: self.environment = self.environment.parent return theNewObject # Visit a parse tree produced by ECMAScriptParser#LiteralExpression. def visitLiteralExpression(self, ctx): return self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#ArrayLiteralExpression. def visitArrayLiteralExpression(self, ctx): return JSList(ctx.children[0].accept(self)) # Visit a parse tree produced by ECMAScriptParser#MemberDotExpression. def visitMemberDotExpression(self, ctx): obj = ctx.children[0].accept(self) member = ctx.children[2].accept(self) retval = getattr(obj, member) if type(retval) == Property: if isinstance(retval.get(), types.MethodType): return retval.get()() return retval.get() else: return retval # Visit a parse tree produced by ECMAScriptParser#withStatement. def visitWithStatement(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#MemberIndexExpression. def visitMemberIndexExpression(self, ctx): array = ctx.children[0].accept(self) index = ctx.children[2].accept(self) if type(array) == ObjectModule: return array.__dict__[str(index)] else: return array[int(index)] # Visit a parse tree produced by ECMAScriptParser#formalParameterList. def visitFormalParameterList(self, ctx): return self.childrenToList(ctx.children) # Visit a parse tree produced by ECMAScriptParser#incrementOperator. def visitIncrementOperator(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#AssignmentOperatorExpression. def visitAssignmentOperatorExpression(self, ctx): name = ctx.children[0].getText() # We're doing arrays now. if ctx.children[1].getText() == '[': index = ctx.children[2].accept(self) operator = ctx.children[4].accept(self) rhs = ctx.children[5].accept(self) lhs = self.environment.value(name) if type(lhs) == ObjectModule: lhs.__dict__[index] = self.assignment[operator](lhs.__dict__[index], rhs) value = lhs.__dict__[index] else: lhs[int(index)] = self.assignment[operator](lhs[int(index)], rhs) value = lhs[int(index)] self.environment.setVariable(name, lhs) elif ctx.children[1].getText() == '.': key = ctx.children[2].accept(self) operator = ctx.children[3].accept(self) rhs = ctx.children[4].accept(self) lhs = ctx.children[0].accept(self) if key not in lhs.__dict__: lhs.__dict__[key] = None # Is there a setter there? if type(lhs.__dict__[key]) == Property: lhs.__dict__[key].set(rhs) value = rhs else: lhs.__dict__[key] = self.assignment[operator](lhs.__dict__[key], rhs) value = lhs.__dict__[key] # If there are nestled objects if '.' in name: rootName = name.split('.')[0] rootObject = self.environment.value(rootName) rootObject.__dict__[name.split('.')[1]] = lhs self.environment.defineVariable(rootName, rootObject) else: self.environment.setVariable(name, lhs) else: operator = ctx.children[1].accept(self) rhs = ctx.children[2].accept(self) lhs = self.environment.value(name) if not self.environment.exists(name) and operator == '=': self.environment.defineGlobal(name) value = self.assignment[operator](lhs, rhs) self.environment.setVariable(name, value) return value # Visit a parse tree produced by ECMAScriptParser#PostUnaryAssignmentExpression. def visitPostUnaryAssignmentExpression(self, ctx): name = ctx.children[0].accept(self) operator = ctx.children[1].accept(self) value = self.environment.value(name) self.environment.setVariable(name, self.unaries[operator](value)) return value # Visit a parse tree produced by ECMAScriptParser#TernaryExpression. def visitTernaryExpression(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#tryStatement. def visitTryStatement(self, ctx): try: ctx.children[1].accept(self) except ESException as e: ctx.children[2].exceptionValue = e.value ctx.children[2].accept(self) if len(ctx.children) == 4: ctx.children[3].accept(self) # Visit a parse tree produced by ECMAScriptParser#debuggerStatement. def visitDebuggerStatement(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#DoStatement. def visitDoStatement(self, ctx): ctx.children[1].accept(self) while ctx.children[4].accept(self): ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#ObjectLiteralExpression. def visitObjectLiteralExpression(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#arrayLiteral. def visitArrayLiteral(self, ctx): return ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#elision. def visitElision(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#statements. def visitStatements(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#UnaryExpression. def visitUnaryExpression(self, ctx): operator = ctx.children[0].accept(self) argument = ctx.children[1].accept(self) return self.unaries[operator](argument) # Visit a parse tree produced by ECMAScriptParser#WhileStatement. def visitWhileStatement(self, ctx): while ctx.children[2].accept(self): try: ctx.children[4].accept(self) except BreakException: break except ContinueException: continue # Visit a parse tree produced by ECMAScriptParser#returnStatement. def visitReturnStatement(self, ctx): returnValue = ctx.children[1].accept(self) raise ReturnException(returnValue) # Visit a parse tree produced by ECMAScriptParser#switchStatement. def visitSwitchStatement(self, ctx): ctx.children[4].chosenValue = ctx.children[2].accept(self) ctx.children[4].accept(self) # Visit a parse tree produced by ECMAScriptParser#expressionSequence. def visitExpressionSequence(self, ctx): return self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#literal. def visitLiteral(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#variableStatement. def visitVariableStatement(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#FunctionExpression. def visitFunctionExpression(self, ctx): argumentIndex = 3 # If we are dealing with a lambda. if ctx.children[1].getText() == '(': argumentIndex -= 1 else: name = ctx.children[1].accept(self) if ctx.children[argumentIndex].getText() == ')': arguments = [] argumentIndex -= 1 else: arguments = ctx.children[argumentIndex].accept(self) body = ctx.children[argumentIndex + 3].accept(self) function = Function(arguments, self.environment, body) if ctx.children[1].getText() == '(': return Function(arguments, self.environment, body) else: self.environment.defineVariable(name, function) # Visit a parse tree produced by ECMAScriptParser#defaultClause. def visitDefaultClause(self, ctx): return (ctx.children[0].accept(self), ctx.children[2]) # Visit a parse tree produced by ECMAScriptParser#statement. def visitStatement(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#ForStatement. def visitForStatement(self, ctx): initialization = ctx.children[2].accept(self) condIndex = 4 if initialization == ';': condIndex -= 1 elif initialization == 'var': condIndex += 1 ctx.children[3].accept(self) condition = ctx.children[condIndex].accept(self) incrementorIndex = condIndex + 2 if condition == ';': incrementorIndex -= 1 incrementor = ctx.children[incrementorIndex].getText() expressionIndex = incrementorIndex + 2 if incrementor == ')': expressionIndex -= 1 while ctx.children[condIndex].accept(self): try: ctx.children[expressionIndex].accept(self) ctx.children[incrementorIndex].accept(self) except BreakException: break except ContinueException: ctx.children[incrementorIndex].accept(self) continue # Visit a parse tree produced by ECMAScriptParser#caseBlock. def visitCaseBlock(self, ctx): keyBodyPairs = collections.OrderedDict() for child in ctx.children[1:-1]: (key, body) = child.accept(self) keyBodyPairs[key] = body keys = list(keyBodyPairs) if ctx.chosenValue in keys: startIndex = keys.index(ctx.chosenValue) elif "default" in keys: startIndex = keys.index("default") bodies = list(keyBodyPairs.values()) for body in bodies[startIndex:]: try: body.accept(self) except BreakException: break # Visit a parse tree produced by ECMAScriptParser#ParenthesizedExpression. def visitParenthesizedExpression(self, ctx): # Return what's between the parenthesis ( what ). return ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#objectLiteral. def visitObjectLiteral(self, ctx): obj = ObjectModule() for key, value in self.childrenToList(ctx.children[1:-1]): if hasattr(value, "get") or hasattr(value, "set"): obj.defineProperty(obj, obj, str(key), value) else: setattr(obj, str(key), value) return obj # Visit a parse tree produced by ECMAScriptParser#throwStatement. def visitThrowStatement(self, ctx): raise ESException(ctx.children[1].accept(self)) # Visit a parse tree produced by ECMAScriptParser#breakStatement. def visitBreakStatement(self, ctx): raise BreakException() # Visit a parse tree produced by ECMAScriptParser#ifStatement. def visitIfStatement(self, ctx): if ctx.children[2].accept(self): ctx.children[4].accept(self) # If there is an else statement elif len(ctx.children) > 6: ctx.children[6].accept(self) # Visit a parse tree produced by ECMAScriptParser#reservedWord. def visitReservedWord(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#variableDeclaration. def visitVariableDeclaration(self, ctx): name = ctx.children[0].accept(self) if len(ctx.children) == 2: value = ctx.children[1].accept(self) else: value = None self.environment.defineVariable(name, value) # Visit a parse tree produced by ECMAScriptParser#finallyProduction. def visitFinallyProduction(self, ctx): ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#IdentifierExpression. def visitIdentifierExpression(self, ctx): return self.environment.value(ctx.children[0].accept(self)) # Visit a parse tree produced by ECMAScriptParser#propertyName. def visitPropertyName(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#catchProduction. def visitCatchProduction(self, ctx): exceptionName = ctx.children[2].accept(self) self.environment.defineVariable(exceptionName, ctx.exceptionValue) ctx.children[4].accept(self) self.environment.removeVariable(exceptionName) # Visit a parse tree produced by ECMAScriptParser#continueStatement. def visitContinueStatement(self, ctx): raise ContinueException # Visit a parse tree produced by ECMAScriptParser#caseClause. def visitCaseClause(self, ctx): return (ctx.children[1].accept(self), ctx.children[3]) # Visit a parse tree produced by ECMAScriptParser#arguments. def visitArguments(self, ctx): return ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#variableDeclarationList. def visitVariableDeclarationList(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#functionBody. def visitFunctionBody(self, ctx): def runFunction(environment): self.environment = Environment(environment) for c in ctx.children: try: c.accept(self) except ReturnException as re: return re.value finally: self.environment = self.environment.parent return runFunction # Visit a parse tree produced by ECMAScriptParser#eof. def visitEof(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#UnaryAssignmentExpression. def visitUnaryAssignmentExpression(self, ctx): operator = ctx.children[0].accept(self) name = ctx.children[1].accept(self) value = self.environment.value(name) self.environment.setVariable(name, self.unaries[operator](value)) return self.environment.value(name) def childrenToList(self, items): return [item.accept(self) for item in items if not item.getText() == ',']
#!/usr/bin/env python3 from Interpreter.Function import Function from Interpreter.Environment import Environment f = Function(["arg1", "arg2"], Environment(), lambda env: print(env.value("arg1") + env.value("arg2"))) f(None,1,2)
from Interpreter.Environment import Environment env = Environment() env.value("lol")
def __init__(self, environment=Environment()): self.environment = environment self.stack = Stack() self.current_index = 0 self.return_values = Stack() # Stack to push/pop return values self.try_addresses = Stack() # Stack to push/pop addresses # The following code acts as a switch statements for OpCodes self.opmaps = {} # Stack self.opmaps[OpCode.PUSH] = Executor.execute_push self.opmaps[OpCode.POP] = Executor.execute_pop self.opmaps[OpCode.DUP] = Executor.execute_dup self.opmaps[OpCode.SWAP] = Executor.execute_swap # Environment and objects manipulation self.opmaps[OpCode.LOAD] = Executor.execute_load self.opmaps[OpCode.STORE] = Executor.execute_store self.opmaps[OpCode.DCL] = Executor.execute_dcl self.opmaps[OpCode.LOAD_MEMBER] = Executor.execute_load_member self.opmaps[OpCode.STORE_MEMBER] = Executor.execute_store_member self.opmaps[OpCode.LOAD_INDEX] = Executor.execute_load_index self.opmaps[OpCode.STORE_INDEX] = Executor.execute_store_index # Control self.opmaps[OpCode.JMP] = Executor.execute_jmp self.opmaps[OpCode.IFJMP] = Executor.execute_ifjmp self.opmaps[OpCode.UNLESSJMP] = Executor.execute_unlessjmp self.opmaps[OpCode.CALL] = Executor.execute_call self.opmaps[OpCode.NEW] = Executor.execute_new self.opmaps[OpCode.RET] = Executor.execute_ret self.opmaps[OpCode.SWITCH] = Executor.execute_switch # Exceptions self.opmaps[OpCode.TRY_PUSH] = Executor.execute_try_push self.opmaps[OpCode.THROW] = Executor.execute_throw self.opmaps[OpCode.TRY_POP] = Executor.execute_try_pop # Array and Objects creation self.opmaps[OpCode.MAKE_ARRAY] = Executor.execute_make_array self.opmaps[OpCode.MAKE_OBJECT] = Executor.execute_make_object self.opmaps[OpCode.MAKE_FUNC] = Executor.execute_make_func self.opmaps[OpCode.MAKE_GETTER] = Executor.execute_make_getter self.opmaps[OpCode.MAKE_SETTER] = Executor.execute_make_setter # Binary arithmetic operation self.opmaps[OpCode.ADD] = Executor.execute_add self.opmaps[OpCode.SUB] = Executor.execute_sub self.opmaps[OpCode.DIV] = Executor.execute_div self.opmaps[OpCode.MUL] = Executor.execute_mul self.opmaps[OpCode.MOD] = Executor.execute_mod self.opmaps[OpCode.LEFT_SHIFT] = Executor.execute_left_shift self.opmaps[OpCode.RIGHT_SHIFT] = Executor.execute_right_shift self.opmaps[ OpCode. UNSIGNED_RIGHT_SHIFT] = Executor.execute_unsigned_right_shift # Binary bolean operation self.opmaps[OpCode.SUPPERIOR] = Executor.execute_superior self.opmaps[OpCode.SUPPERIOR_EQUAL] = Executor.execute_superior_equal self.opmaps[OpCode.INFERIOR] = Executor.execute_inferior self.opmaps[OpCode.INFERIOR_EQUAL] = Executor.execute_inferior_equal self.opmaps[OpCode.EQUAL] = Executor.execute_equal self.opmaps[OpCode.DIFFERENT] = Executor.execute_different self.opmaps[OpCode.AND] = Executor.execute_and self.opmaps[OpCode.OR] = Executor.execute_or # Unary operations self.opmaps[OpCode.NEG] = Executor.execute_neg self.opmaps[OpCode.TILDE] = Executor.execute_tilde self.opmaps[OpCode.NOT] = Executor.execute_not
def __init__(self, environment=Environment()): self.environment = environment self.stack = Stack() self.try_stack = Stack() self.program_counter = 0 self.program_counter_stack = [] # The following code acts as a switch statements for OpCodes self.opmaps = {} # Stack Manipulation self.opmaps[OpCode.NOP] = Executor.execute_NOP self.opmaps[OpCode.PUSH] = Executor.execute_PUSH self.opmaps[OpCode.POP] = Executor.execute_POP self.opmaps[OpCode.DUP] = Executor.execute_DUP self.opmaps[OpCode.SWAP] = Executor.execute_SWAP # Environment and objects manipulation self.opmaps[OpCode.LOAD] = Executor.execute_LOAD self.opmaps[OpCode.STORE] = Executor.execute_STORE self.opmaps[OpCode.DCL] = Executor.execute_DCL self.opmaps[OpCode.LOAD_MEMBER] = Executor.execute_LOAD_MEMBER self.opmaps[OpCode.STORE_MEMBER] = Executor.execute_STORE_MEMBER self.opmaps[OpCode.LOAD_INDEX] = Executor.execute_LOAD_INDEX self.opmaps[OpCode.STORE_INDEX] = Executor.execute_STORE_INDEX # Control self.opmaps[OpCode.JMP] = Executor.execute_JMP self.opmaps[OpCode.IFJMP] = Executor.execute_IFJMP self.opmaps[OpCode.UNLESSJMP] = Executor.execute_UNLESSJMP self.opmaps[OpCode.CALL] = Executor.execute_CALL self.opmaps[OpCode.NEW] = Executor.execute_NEW self.opmaps[OpCode.RET] = Executor.execute_RET self.opmaps[OpCode.SWITCH] = Executor.execute_SWITCH # Exceptions self.opmaps[OpCode.TRY_PUSH] = Executor.execute_TRY_PUSH self.opmaps[OpCode.TRY_POP] = Executor.execute_TRY_POP self.opmaps[OpCode.THROW] = Executor.execute_THROW # Array and Objects creation self.opmaps[OpCode.MAKE_ARRAY] = Executor.execute_MAKE_ARRAY self.opmaps[OpCode.MAKE_OBJECT] = Executor.execute_MAKE_OBJECT self.opmaps[OpCode.MAKE_FUNC] = Executor.execute_MAKE_FUNC self.opmaps[OpCode.MAKE_GETTER] = Executor.execute_MAKE_GETTER self.opmaps[OpCode.MAKE_SETTER] = Executor.execute_MAKE_SETTER # Binary arithmetic operation self.opmaps[OpCode.ADD] = Executor.execute_ADD self.opmaps[OpCode.MUL] = Executor.execute_MUL self.opmaps[OpCode.SUB] = Executor.execute_SUB self.opmaps[OpCode.DIV] = Executor.execute_DIV self.opmaps[OpCode.MOD] = Executor.execute_MOD self.opmaps[OpCode.LEFT_SHIFT] = Executor.execute_LEFT_SHIFT self.opmaps[OpCode.RIGHT_SHIFT] = Executor.execute_RIGHT_SHIFT self.opmaps[ OpCode. UNSIGNED_RIGHT_SHIFT] = Executor.execute_UNSIGNED_RIGHT_SHIFT # Binary bolean operation self.opmaps[OpCode.SUPPERIOR] = Executor.execute_SUPPERIOR self.opmaps[OpCode.SUPPERIOR_EQUAL] = Executor.execute_SUPPERIOR_EQUAL self.opmaps[OpCode.INFERIOR] = Executor.execute_INFERIOR self.opmaps[OpCode.INFERIOR_EQUAL] = Executor.execute_INFERIOR_EQUAL self.opmaps[OpCode.EQUAL] = Executor.execute_EQUAL self.opmaps[OpCode.DIFFERENT] = Executor.execute_DIFFERENT self.opmaps[OpCode.AND] = Executor.execute_AND self.opmaps[OpCode.OR] = Executor.execute_OR # Unary operations self.opmaps[OpCode.NEG] = Executor.execute_NEG self.opmaps[OpCode.TILDE] = Executor.execute_TILDE self.opmaps[OpCode.NOT] = Executor.execute_NOT
def __init__(self, environment=Environment(), input=None): self.environment = environment self.environment.defineVariable("console", Console()) self.environment.defineVariable("Math", MathModule()) self.environment.defineVariable("Object", ObjectModule())
class InterpreterVisitor(ECMAScriptVisitor): def __init__(self, environment=Environment(), input=None): self.environment = environment self.environment.defineVariable("console", Console()) self.environment.defineVariable("Math", MathModule()) self.environment.defineVariable("Object", ObjectModule()) def visitTerminal(self, node): if node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.BooleanLiteral: # 54 if node.symbol.text == 'true': return True elif node.symbol.text == 'false': return False elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.DecimalLiteral: # 55 # Not sure if were supposed to ever return int # Changes this because test 02_expression/01_addition expects float as result # Change back to make the implementation of binary_ops easier try: return int(node.symbol.text) except ValueError: return float(node.symbol.text) elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.HexIntegerLiteral: # 56 return float(int(node.symbol.text, 0)) elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.StringLiteral: # 101 # Assume that a string atleast contains ""? return node.symbol.text[1:-1] else: return node.symbol.text # Visit a parse tree produced by ECMAScriptParser#PropertyExpressionAssignment. def visitPropertyExpressionAssignment(self, ctx): # Example of input: <name>:<expression> # NOTE: convert expr to float if int name = ctx.children[0].accept(self) expr = ctx.children[2].accept(self) if isinstance(expr, int): expr = float(expr) return (name, expr) # Visit a parse tree produced by ECMAScriptParser#assignmentOperator. def visitAssignmentOperator(self, ctx): # Returns a lambda which performs the right operator node = ctx.children[0] if node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.Assign: # 11 return lambda x, y: y elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.PlusAssign: # 43 return lambda x, y: x + y elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.MinusAssign: # 44 return lambda x, y: x - y elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.MultiplyAssign: # 40 return lambda x, y: x * y elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.DivideAssign: # 41 return lambda x, y: x / y else: raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#eos. def visitEos(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#program. def visitProgram(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#argumentList. def visitArgumentList(self, ctx): args = [] for c in ctx.children: if (not isinstance(c, antlr4.tree.Tree.TerminalNodeImpl)): # Skip "," value = c.accept(self) if isinstance(value, Property): args.append(value.get()) else: args.append(value) return args # Visit a parse tree produced by ECMAScriptParser#ArgumentsExpression. def visitArgumentsExpression(self, ctx): func = ctx.children[0].accept(self) args = ctx.children[1].accept(self) if (args == None): args = [] res = None if isinstance(func, tuple): res = func[1](func[0], *args) elif str(type(func)) == "<class 'builtin_function_or_method'>": return func(*args) else: res = func(None, *args) if isinstance(res, int): res = float(res) #print('THE RES FROM ARGEXPR:', res) return res # Visit a parse tree produced by ECMAScriptParser#ThisExpression. def visitThisExpression(self, ctx): return self.environment.value("this") # Visit a parse tree produced by ECMAScriptParser#identifierName. def visitIdentifierName(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#BinaryExpression. def visitBinaryExpression(self, ctx): node = ctx.children[1] # Handle AND and OR first to achieve normal-order evaluation if node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.And: # 38 return ctx.children[0].accept(self) and ctx.children[2].accept( self) elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.Or: # 39 return ctx.children[0].accept(self) or ctx.children[2].accept(self) op1 = ctx.children[0].accept(self) op2 = ctx.children[2].accept(self) # Only convert to int if type is float if isinstance(op1, float) and op1 == int(op1): op1 = int(op1) if isinstance(op2, float) and op2 == int(op2): op2 = int(op2) if node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.Plus: # 17 if isinstance(op1, int): return float(op1 + op2) else: return op1 + op2 elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.Minus: # 18 return float(op1 - op2) elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.Multiply: # 21 return float(op1 * op2) elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.Divide: # 22 return float(op1 / op2) elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.Modulus: # 23 return float(op1 % op2) elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.LeftShiftArithmetic: # 25 return float(op1 << op2) elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.RightShiftArithmetic: # 24 return float(op1 >> op2) elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.RightShiftLogical: # 26 return float((op1 % 0x100000000) >> op2) elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.LessThan: # 27 return op1 < op2 elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.MoreThan: # 28 return op1 > op2 elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.LessThanEquals: # 29 return op1 <= op2 elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.GreaterThanEquals: # 30 return op1 >= op2 elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.Equals: # 31 return op1 == op2 elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.NotEquals: # 32 return not op1 == op2 elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.IdentityEquals: # 33 return op1 is op2 elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.IdentityNotEquals: # 34 return op1 is not op2 else: raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#futureReservedWord. def visitFutureReservedWord(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#initialiser. def visitInitialiser(self, ctx): return ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#statementList. def visitStatementList(self, ctx): res = None for c in ctx.children: res = c.accept(self) if res == "BREAK-LOOP": return "BREAK-LOOP" elif res == "CONTINUE-LOOP": # Skip the remaining statements return "CONTINUE-LOOP" elif isinstance(res, tuple) and res[0] == "THROW": return res return res # Visit a parse tree produced by ECMAScriptParser#PropertyGetter. def visitPropertyGetter(self, ctx): name = ctx.children[1].accept(self) getter_body = ctx.children[-2].children[0] def func(env): previous_env = self.environment self.environment = env return_val = getter_body.accept(self) if isinstance(return_val, tuple): return_val = return_val[1] self.environment = previous_env return return_val return ('get', name, Function([], self.environment, func)) #raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#block. def visitBlock(self, ctx): res = ctx.children[1].accept(self) return res # Visit a parse tree produced by ECMAScriptParser#expressionStatement. def visitExpressionStatement(self, ctx): return self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#keyword. def visitKeyword(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#elementList. def visitElementList(self, ctx): array = [] for c in ctx.children: if (not isinstance(c, antlr4.tree.Tree.TerminalNodeImpl)): # Skip "," res = c.accept(self) # NOTE: Conversion of int to float, should it be done here? if isinstance(res, int): res = float(res) array.append(res) return array # Visit a parse tree produced by ECMAScriptParser#numericLiteral. def visitNumericLiteral(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#ForInStatement. def visitForInStatement(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#emptyStatement. def visitEmptyStatement(self, ctx): return # Visit a parse tree produced by ECMAScriptParser#labelledStatement. def visitLabelledStatement(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#PropertySetter. def visitPropertySetter(self, ctx): name = ctx.children[1].accept(self) param = ctx.children[3].accept(self) setter_body = ctx.children[-2].children[0] def func(env): previous_env = self.environment self.environment = env return_value = setter_body.accept(self) self.environment = previous_env return return_value return ('set', name, Function([param], self.environment, func)) #raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#NewExpression. def visitNewExpression(self, ctx): obj = ctx.children[1].accept(self) params = ctx.children[2].accept(self) if params == None: params = [] if isinstance(obj, ObjectModule): return obj elif isinstance(obj, Function): new_obj = ObjectModule() obj(obj, *params) obj2 = new_obj.create(None, obj) setattr(obj2, "prototype", obj) obj = obj2 return obj else: raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#LiteralExpression. def visitLiteralExpression(self, ctx): return self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#ArrayLiteralExpression. def visitArrayLiteralExpression(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#MemberDotExpression. def visitMemberDotExpression(self, ctx): obj = ctx.children[0].accept(self) member = ctx.children[2].accept(self) if isinstance(obj, tuple): obj = obj[0] returnval = None if hasattr(obj, member): returnval = getattr(obj, member) elif isinstance(obj, list) and member == 'length': returnval = float(len(obj)) else: returnval = getattr(getattr(obj, "prototype"), member) if isinstance(returnval, Function): return (obj, returnval) return returnval # Visit a parse tree produced by ECMAScriptParser#withStatement. def visitWithStatement(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#MemberIndexExpression. def visitMemberIndexExpression(self, ctx): obj = ctx.children[0].accept(self) idx = ctx.children[2].accept(self) if (isinstance(obj, Object)): return getattr(obj, str(idx)) else: return obj[int(idx)] # Visit a parse tree produced by ECMAScriptParser#formalParameterList. def visitFormalParameterList(self, ctx): params = [param.accept(self) for param in ctx.children[0::2]] return params # Visit a parse tree produced by ECMAScriptParser#incrementOperator. def visitIncrementOperator(self, ctx): # Return a lambda based on what type of operator if ctx.children[ 0].symbol.type == ECMAScriptLexer.ECMAScriptLexer.PlusPlus: return lambda x: x + 1 elif ctx.children[ 0].symbol.type == ECMAScriptLexer.ECMAScriptLexer.MinusMinus: return lambda x: x - 1 else: raise Utils.UnimplementedVisitorException(ctx) ########################################################################### ############### Helper functions for AssignmentOperatorExpression ######### ########################################################################### def objectExpression(self, ctx, var): member = ctx.children[2].accept(self) op = None val = None if isinstance(ctx.children[3], antlr4.tree.Tree.TerminalNodeImpl): op = ctx.children[4].accept(self) val = ctx.children[5].accept(self) #print(ctx.children[5].children) else: op = ctx.children[3].accept(self) val = ctx.children[4].accept(self) #print(ctx.children[4].children) if isinstance(val, int): val = float(val) if hasattr(var, member): attr = getattr(var, member) if isinstance(attr, Property): attr.set(val) return val setattr(var, member, val) return val def prototypeExpression(self, ctx): prototype = ctx.children[0].accept(self) if isinstance(prototype, tuple): prototype = prototype[0] member = ctx.children[2].accept(self) value = ctx.children[4].accept(self) # if value is an object, add each member if isinstance(value, Object): for attr in dir(value): if attr.startswith('__'): continue val = getattr(value, attr) if isinstance(val, tuple): val = list(val) val[0] = prototype val = (val[0], val[1]) setattr(prototype, attr, val) else: setattr(prototype, member, value) # Visit a parse tree produced by ECMAScriptParser#AssignmentOperatorExpression. def visitAssignmentOperatorExpression(self, ctx): if isinstance( ctx.children[0], ECMAScriptParser.ECMAScriptParser.IdentifierExpressionContext): var = ctx.children[0].accept(self) #print('Type of var:',type(var)) if isinstance(var, Object) or isinstance(var, ObjectModule): return self.objectExpression(ctx, var) elif isinstance(var, Function): return self.prototypeExpression(ctx) else: # Handle the case when assigning to array element #print('IN ARRAY CASE') res = ctx.children[5].accept(self) if isinstance(res, int): res = float(res) var[ctx.children[2].accept(self)] = res return elif isinstance( ctx.children[0], ECMAScriptParser.ECMAScriptParser.ThisExpressionContext): return self.objectExpression(ctx, ctx.children[0].accept(self)) elif isinstance( ctx.children[0], ECMAScriptParser.ECMAScriptParser.MemberDotExpressionContext): return self.prototypeExpression(ctx) var_name = ctx.children[0].accept(self) func = ctx.children[1].accept(self) value = ctx.children[2].accept(self) res = func(self.environment.value(var_name), value) self.environment.setVariable(var_name, res) # Visit a parse tree produced by ECMAScriptParser#PostUnaryAssignmentExpression. def visitPostUnaryAssignmentExpression(self, ctx): var_name = ctx.children[0].accept(self) func = ctx.children[1].accept(self) old_value = self.environment.value(var_name) res = func(old_value) self.environment.setVariable(var_name, res) return float(old_value) # Visit a parse tree produced by ECMAScriptParser#TernaryExpression. def visitTernaryExpression(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#tryStatement. def visitTryStatement(self, ctx): res = ctx.children[1].accept(self) if isinstance( res, tuple ) and res[0] == "THROW": # There was a throw in the try-block var_name, block = ctx.children[2].accept(self) # Create new environment for the catch block self.environment = Environment(self.environment) self.environment.defineVariable(var_name.accept(self), res[1].accept(self)) block.accept(self) # Set back the environment self.environment = self.environment.parent # Check for finally-clause and evaluate if so if len(ctx.children) == 4: ctx.children[3].accept(self) # Visit a parse tree produced by ECMAScriptParser#debuggerStatement. def visitDebuggerStatement(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#DoStatement. def visitDoStatement(self, ctx): ctx.children[1].accept(self) while ctx.children[4].accept(self): if ctx.children[1].accept(self) == "BREAK-LOOP": break #raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#ObjectLiteralExpression. def visitObjectLiteralExpression(self, ctx): obj = Object() # res is a list of tuples res = ctx.children[0].accept(self) for value in res: if len(value) == 3: prop = Property(obj) if value[0] == 'get': prop.getter = value[-1] else: prop.setter = value[-1] setattr(obj, str(value[1]), prop) else: setattr(obj, str(value[0]), value[1]) return obj #raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#arrayLiteral. def visitArrayLiteral(self, ctx): return ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#elision. def visitElision(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#statements. def visitStatements(self, ctx): return self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#UnaryExpression. def visitUnaryExpression(self, ctx): node = ctx.children[0] if node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.Minus: # 18 return -float(ctx.children[1].accept(self)) elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.Plus: # 17 return float(ctx.children[1].accept(self)) elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.BitNot: # 19 return float(~int(ctx.children[1].accept(self))) elif node.symbol.type == ECMAScriptLexer.ECMAScriptLexer.Not: # 20 return not bool(ctx.children[1].accept(self)) else: raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#WhileStatement. def visitWhileStatement(self, ctx): while ctx.children[2].accept(self): res = ctx.children[4].accept(self) if res == "BREAK-LOOP": break #raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#returnStatement. def visitReturnStatement(self, ctx): return ("RETURN", ctx.children[1].accept(self)) # Visit a parse tree produced by ECMAScriptParser#switchStatement. def visitSwitchStatement(self, ctx): val_to_switch = ctx.children[2].accept(self) case_found = False # Indicates a case without break has been found cases = ctx.children[4].accept(self) for case in cases: if val_to_switch == case[0] or case_found: if case[1].accept(self) == "BREAK-LOOP": return case_found = True # Handle default case here if not case_found: for case in cases: if case[0] == "DEFAULT": case[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#expressionSequence. def visitExpressionSequence(self, ctx): return self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#literal. def visitLiteral(self, ctx): res = ctx.children[0].accept(self) return res # Visit a parse tree produced by ECMAScriptParser#variableStatement. def visitVariableStatement(self, ctx): # TODO: should probably somehow check if the variable already has been declared / # perhaps return variable_name and value as a tuple and then check... args = ctx.children[1].accept(self) for name, value in args: self.environment.defineVariable(name, value) #raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#FunctionExpression. def visitFunctionExpression(self, ctx): # Now uses the Function class # Check if it is an anonomous function if ctx.children[ 1].symbol.type == ECMAScriptLexer.ECMAScriptLexer.OpenParen: # 5 # Check if there are any params if isinstance( ctx.children[2], ECMAScriptParser.ECMAScriptParser. FormalParameterListContext): params = ctx.children[2].accept(self) body = ctx.children[5].accept(self) else: params = [] body = ctx.children[4].accept(self) new_func_to_return = Function(params, self.environment, body) setattr(new_func_to_return, "prototype", new_func_to_return) return new_func_to_return elif ctx.children[ 1].symbol.type == ECMAScriptLexer.ECMAScriptLexer.Identifier: # 100 variable declaration func_name = ctx.children[1].accept(self) # Check if there are any params if isinstance( ctx.children[3], ECMAScriptParser.ECMAScriptParser. FormalParameterListContext): params = ctx.children[3].accept(self) body = ctx.children[6].accept(self) else: params = [] body = ctx.children[5].accept(self) new_func = Function(params, self.environment, body) setattr(new_func, "prototype", new_func) self.environment.defineVariable(func_name, new_func) else: raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#defaultClause. def visitDefaultClause(self, ctx): return ("DEFAULT", ctx.children[2]) # Visit a parse tree produced by ECMAScriptParser#statement. def visitStatement(self, ctx): res = ctx.children[0].accept(self) return res class MockExpression(object): def __init__(self): self.v = True def accept(self, ctx): return True # Visit a parse tree produced by ECMAScriptParser#ForStatement. def visitForStatement(self, ctx): # This is working for the tests but there are alot of variations # of the for-loop that will not break, most of which will happen # when there is a variable definition in a statement. expression1 = InterpreterVisitor.MockExpression() expression2 = InterpreterVisitor.MockExpression() expression3 = InterpreterVisitor.MockExpression() # Three different cases to consider: 0,1,2 och 3(all) statements missing if len(ctx.children) == 10: # Not a really good solution, not generic at all... args = ctx.children[3].accept(self) for name, value in args: self.environment.defineVariable(name, value) expression2 = ctx.children[5] expression3 = ctx.children[7] elif len(ctx.children) == 9: # All statements provided expression1 = ctx.children[2] expression2 = ctx.children[4] expression3 = ctx.children[6] elif len(ctx.children) == 8: # One statement missing # Find which one if isinstance(ctx.children[2], antlr4.tree.Tree.TerminalNodeImpl): # First missing expression2 = ctx.children[3] expression3 = ctx.children[5] elif isinstance(ctx.children[4], antlr4.tree.Tree.TerminalNodeImpl): # Sec missing expression1 = ctx.children[2] expression3 = ctx.children[5] else: # third(last) missing expression1 = ctx.children[2] expression2 = ctx.children[4] elif len(ctx.children) == 7: # Two statements missing # Find which one exists if isinstance( ctx.children[2], ECMAScriptParser.ECMAScriptParser. ExpressionSequenceContext): # First provided expression1 = ctx.children[2] elif isinstance( ctx.children[3], ECMAScriptParser.ECMAScriptParser. ExpressionSequenceContext): # Second provided expression2 = ctx.children[3] else: # Third provided expression3 = ctx.children[4] #else: # all missing, no need to do anythin #print("In FOR-LOOP") #raise Utils.UnimplementedVisitorException(ctx) # Evaluate the for-loop: expression1.accept(self) while expression2.accept(self): # Execute the body if ctx.children[-1].accept(self) == "BREAK-LOOP": break # Execute last statement in for-loop expression3.accept(self) # Visit a parse tree produced by ECMAScriptParser#caseBlock. def visitCaseBlock(self, ctx): res = [] for c in ctx.children: if (not isinstance(c, antlr4.tree.Tree.TerminalNodeImpl)): # Skip "," res.append(c.accept(self)) return res #raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#ParenthesizedExpression. def visitParenthesizedExpression(self, ctx): return ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#objectLiteral. def visitObjectLiteral(self, ctx): res = [] for i in range(1, len(ctx.children), 2): res.append(ctx.children[i].accept(self)) return res # raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#throwStatement. def visitThrowStatement(self, ctx): #raise Utils.UnimplementedVisitorException(ctx) return ("THROW", ctx.children[1]) # Visit a parse tree produced by ECMAScriptParser#breakStatement. def visitBreakStatement(self, ctx): #raise Utils.UnimplementedVisitorException(ctx) return "BREAK-LOOP" # Visit a parse tree produced by ECMAScriptParser#ifStatement. def visitIfStatement(self, ctx): if not len(ctx.children) == 5 and not len(ctx.children) == 7: raise Utils.UnimplementedVisitorException(ctx) if ctx.children[2].accept(self): return ctx.children[4].accept(self) elif len(ctx.children) == 7: return ctx.children[6].accept(self) else: # The expression evaluated to false and no else clause: return None # Visit a parse tree produced by ECMAScriptParser#reservedWord. def visitReservedWord(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#variableDeclaration. def visitVariableDeclaration(self, ctx): variable_name = ctx.children[0].accept(self) value = None if len(ctx.children) == 2: value = ctx.children[1].accept(self) #print('######', value) #pprint(vars(value)) return (variable_name, value) #raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#finallyProduction. def visitFinallyProduction(self, ctx): #raise Utils.UnimplementedVisitorException(ctx) return ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#IdentifierExpression. def visitIdentifierExpression(self, ctx): res = self.environment.value(ctx.children[0].accept(self)) if isinstance(res, int): return float(res) else: return res # Visit a parse tree produced by ECMAScriptParser#propertyName. def visitPropertyName(self, ctx): return ctx.children[0].accept(self) raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#catchProduction. def visitCatchProduction(self, ctx): return (ctx.children[2], ctx.children[4]) # Visit a parse tree produced by ECMAScriptParser#continueStatement. def visitContinueStatement(self, ctx): return "CONTINUE-LOOP" # Visit a parse tree produced by ECMAScriptParser#caseClause. def visitCaseClause(self, ctx): return (ctx.children[1].accept(self), ctx.children[3]) # Visit a parse tree produced by ECMAScriptParser#arguments. def visitArguments(self, ctx): if len(ctx.children) == 2: return None else: return ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#variableDeclarationList. def visitVariableDeclarationList(self, ctx): args = [] for c in ctx.children: if (not isinstance(c, antlr4.tree.Tree.TerminalNodeImpl)): # Skip "," args.append(c.accept(self)) return args # Visit a parse tree produced by ECMAScriptParser#functionBody. def visitFunctionBody(self, ctx): # construct the function to be returned so this # body can be called def func(env): previous_environment = self.environment self.environment = Environment(env) for c in ctx.children: res = c.accept(self) if isinstance(res, tuple) and res[0] == "RETURN": res = res[1] break self.environment = previous_environment return res return func # Visit a parse tree produced by ECMAScriptParser#eof. def visitEof(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#UnaryAssignmentExpression. def visitUnaryAssignmentExpression(self, ctx): # It seems as if there is no way to determine if its pre- or postincrement # other than the position of IncrementOperatorContext in children # NOTE: It seem post increment is handled elsewhere... # Handle preincrement first if isinstance(ctx.children[1], antlr4.tree.Tree.TerminalNodeImpl): func = ctx.children[0].accept(self) var_name = ctx.children[1].accept(self) res = func(self.environment.value(var_name)) self.environment.setVariable(var_name, res) return float(res) else: raise Utils.UnimplementedVisitorException(ctx)
class InterpreterVisitor(ECMAScriptVisitor): def __init__(self, environment=Environment(), input=None): self.environment = environment self.environment.defineVariable("console", Console()) self.environment.defineVariable("Math", MathModule()) self.environment.defineVariable("Object", ObjectModule()) self.binaries = { '+': operator.add, '-': operator.sub, '*': operator.mul, '/': operator.truediv, '%': operator.mod, '<<': lambda x, y: float(operator.lshift(int(x), int(y))), '>>': lambda x, y: float(operator.rshift(int(x), int(y))), '>>>': lambda x, y: float((int(x) % 0x100000000) >> int(y)), '<': operator.lt, '>': operator.gt, '<=': operator.le, '>=': operator.ge, '==': operator.eq, '!=': operator.ne, '===': lambda x, y: type(x) == type(y) and x == y, '!==': lambda x, y: type(x) != type(y) or x != y, '||': lambda x, y: x or y, '&&': lambda x, y: x and y } self.unaries = { '-': operator.neg, '+': operator.pos, '~': lambda x: float(~int(x)), '!': operator.not_, '++': lambda x: x.__add__(1), '--': lambda x: x.__add__(-1) } self.assignment = { '=': lambda x, y: y, '+=': operator.iadd, '-=': operator.isub, '*=': operator.mul, '/=': operator.truediv } def print_env_chain(self, env): if not env.parent: print("GlobalFrame:", env.variableDictionary) else: print("Frame:", env.variableDictionary) self.print_env_chain(env.parent) def inspector(self, ctx): print("‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾") print("In function: ", inspect.stack()[1].function) self.print_env_chain(self.environment) print("_______________________") print("") print("Begin child list, there are", len(ctx.children), "children.") i = 0 for child in ctx.children: try: typ = type(child.accept(self)) except: typ = "<Unacceptable>" val = child.getText() print(i, str(typ) + ": " + str(val)) i += 1 print("End child list of", inspect.stack()[1].function, "\t.!.") print("") def visitTerminal(self, node): if node.symbol.text == "true": return True elif node.symbol.text == "false": return False elif node.symbol.text[0] == '"' or node.symbol.text[0] == "'": return node.symbol.text[1:-1] elif node.symbol.text[0:2] == "0x": return float.fromhex(node.symbol.text) else: return node.symbol.text # Visit a parse tree produced by ECMAScriptParser#PropertyExpressionAssignment. def visitPropertyExpressionAssignment(self, ctx): return (ctx.children[0].accept(self), ctx.children[2].accept(self)) # Visit a parse tree produced by ECMAScriptParser#assignmentOperator. def visitAssignmentOperator(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#eos. def visitEos(self, ctx): return # Visit a parse tree produced by ECMAScriptParser#program. def visitProgram(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#argumentList. def visitArgumentList(self, ctx): args = [] for c in ctx.children: if (not isinstance(c, antlr4.tree.Tree.TerminalNodeImpl)): # Skip "," args.append(c.accept(self)) return args # Visit a parse tree produced by ECMAScriptParser#ArgumentsExpression. def visitArgumentsExpression(self, ctx): this = self.environment.value(ctx.children[0].getText().split('.')[0]) func = ctx.children[0].accept(self) args = ctx.children[1].accept(self) if (args == None or args == ')'): args = [] if isinstance(func, types.MethodType ) and func.__func__ == ObjectModule.defineProperty: return func(args[0], *args) else: return func(this, *args) # Visit a parse tree produced by ECMAScriptParser#ThisExpression. def visitThisExpression(self, ctx): return self.environment.value(ctx.children[0].accept(self)) # Visit a parse tree produced by ECMAScriptParser#identifierName. def visitIdentifierName(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#BinaryExpression. def visitBinaryExpression(self, ctx): arg1 = ctx.children[0].accept(self) operator = ctx.children[1].accept(self) if operator == "&&": return arg1 and ctx.children[2].accept(self) elif operator == "||": return arg1 or ctx.children[2].accept(self) arg2 = ctx.children[2].accept(self) return self.binaries[operator](arg1, arg2) # Visit a parse tree produced by ECMAScriptParser#futureReservedWord. def visitFutureReservedWord(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#initialiser. def visitInitialiser(self, ctx): return ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#statementList. def visitStatementList(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#PropertyGetter. def visitPropertyGetter(self, ctx): name = ctx.children[1].accept(self) body = ctx.children[5].accept(self) param = Object() param.get = Function([], self.environment, body) return (name, param) # Visit a parse tree produced by ECMAScriptParser#block. def visitBlock(self, ctx): # We don't have to define any environment since we don't have # to implement the let keyword. self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#expressionStatement. def visitExpressionStatement(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#keyword. def visitKeyword(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#elementList. def visitElementList(self, ctx): return self.childrenToList(ctx.children) # Visit a parse tree produced by ECMAScriptParser#numericLiteral. def visitNumericLiteral(self, ctx): return float(self.visitChildren(ctx)) # Visit a parse tree produced by ECMAScriptParser#ForInStatement. def visitForInStatement(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#emptyStatement. def visitEmptyStatement(self, ctx): return # Visit a parse tree produced by ECMAScriptParser#labelledStatement. def visitLabelledStatement(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#PropertySetter. def visitPropertySetter(self, ctx): name = ctx.children[1].accept(self) argName = ctx.children[3].accept(self) body = ctx.children[6].accept(self) param = Object() param.set = Function([argName], self.environment, body) return (name, param) # Visit a parse tree produced by ECMAScriptParser#NewExpression. def visitNewExpression(self, ctx): func = ctx.children[1].accept(self) args = ctx.children[2].accept(self) if (args == None or args == ')'): args = [] if hasattr(func, "prototype") and hasattr(func.prototype, "create"): theNewObject = func.prototype.create(None, func.prototype) else: theNewObject = ObjectModule() self.environment = Environment(self.environment) func(theNewObject, *args) self.environment.defineVariable('this', theNewObject) if self.environment.parent: self.environment = self.environment.parent return theNewObject # Visit a parse tree produced by ECMAScriptParser#LiteralExpression. def visitLiteralExpression(self, ctx): return self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#ArrayLiteralExpression. def visitArrayLiteralExpression(self, ctx): return JSList(ctx.children[0].accept(self)) # Visit a parse tree produced by ECMAScriptParser#MemberDotExpression. def visitMemberDotExpression(self, ctx): obj = ctx.children[0].accept(self) member = ctx.children[2].accept(self) retval = getattr(obj, member) if type(retval) == Property: if isinstance(retval.get(), types.MethodType): return retval.get()() return retval.get() else: return retval # Visit a parse tree produced by ECMAScriptParser#withStatement. def visitWithStatement(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#MemberIndexExpression. def visitMemberIndexExpression(self, ctx): array = ctx.children[0].accept(self) index = ctx.children[2].accept(self) if type(array) == ObjectModule: return array.__dict__[str(index)] else: return array[int(index)] # Visit a parse tree produced by ECMAScriptParser#formalParameterList. def visitFormalParameterList(self, ctx): return self.childrenToList(ctx.children) # Visit a parse tree produced by ECMAScriptParser#incrementOperator. def visitIncrementOperator(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#AssignmentOperatorExpression. def visitAssignmentOperatorExpression(self, ctx): name = ctx.children[0].getText() # We're doing arrays now. if ctx.children[1].getText() == '[': index = ctx.children[2].accept(self) operator = ctx.children[4].accept(self) rhs = ctx.children[5].accept(self) lhs = self.environment.value(name) if type(lhs) == ObjectModule: lhs.__dict__[index] = self.assignment[operator]( lhs.__dict__[index], rhs) value = lhs.__dict__[index] else: lhs[int(index)] = self.assignment[operator](lhs[int(index)], rhs) value = lhs[int(index)] self.environment.setVariable(name, lhs) elif ctx.children[1].getText() == '.': key = ctx.children[2].accept(self) operator = ctx.children[3].accept(self) rhs = ctx.children[4].accept(self) lhs = ctx.children[0].accept(self) if key not in lhs.__dict__: lhs.__dict__[key] = None # Is there a setter there? if type(lhs.__dict__[key]) == Property: lhs.__dict__[key].set(rhs) value = rhs else: lhs.__dict__[key] = self.assignment[operator]( lhs.__dict__[key], rhs) value = lhs.__dict__[key] # If there are nestled objects if '.' in name: rootName = name.split('.')[0] rootObject = self.environment.value(rootName) rootObject.__dict__[name.split('.')[1]] = lhs self.environment.defineVariable(rootName, rootObject) else: self.environment.setVariable(name, lhs) else: operator = ctx.children[1].accept(self) rhs = ctx.children[2].accept(self) lhs = self.environment.value(name) if not self.environment.exists(name) and operator == '=': self.environment.defineGlobal(name) value = self.assignment[operator](lhs, rhs) self.environment.setVariable(name, value) return value # Visit a parse tree produced by ECMAScriptParser#PostUnaryAssignmentExpression. def visitPostUnaryAssignmentExpression(self, ctx): name = ctx.children[0].accept(self) operator = ctx.children[1].accept(self) value = self.environment.value(name) self.environment.setVariable(name, self.unaries[operator](value)) return value # Visit a parse tree produced by ECMAScriptParser#TernaryExpression. def visitTernaryExpression(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#tryStatement. def visitTryStatement(self, ctx): try: ctx.children[1].accept(self) except ESException as e: ctx.children[2].exceptionValue = e.value ctx.children[2].accept(self) if len(ctx.children) == 4: ctx.children[3].accept(self) # Visit a parse tree produced by ECMAScriptParser#debuggerStatement. def visitDebuggerStatement(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#DoStatement. def visitDoStatement(self, ctx): ctx.children[1].accept(self) while ctx.children[4].accept(self): ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#ObjectLiteralExpression. def visitObjectLiteralExpression(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#arrayLiteral. def visitArrayLiteral(self, ctx): return ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#elision. def visitElision(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#statements. def visitStatements(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#UnaryExpression. def visitUnaryExpression(self, ctx): operator = ctx.children[0].accept(self) argument = ctx.children[1].accept(self) return self.unaries[operator](argument) # Visit a parse tree produced by ECMAScriptParser#WhileStatement. def visitWhileStatement(self, ctx): while ctx.children[2].accept(self): try: ctx.children[4].accept(self) except BreakException: break except ContinueException: continue # Visit a parse tree produced by ECMAScriptParser#returnStatement. def visitReturnStatement(self, ctx): returnValue = ctx.children[1].accept(self) raise ReturnException(returnValue) # Visit a parse tree produced by ECMAScriptParser#switchStatement. def visitSwitchStatement(self, ctx): ctx.children[4].chosenValue = ctx.children[2].accept(self) ctx.children[4].accept(self) # Visit a parse tree produced by ECMAScriptParser#expressionSequence. def visitExpressionSequence(self, ctx): return self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#literal. def visitLiteral(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#variableStatement. def visitVariableStatement(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#FunctionExpression. def visitFunctionExpression(self, ctx): argumentIndex = 3 # If we are dealing with a lambda. if ctx.children[1].getText() == '(': argumentIndex -= 1 else: name = ctx.children[1].accept(self) if ctx.children[argumentIndex].getText() == ')': arguments = [] argumentIndex -= 1 else: arguments = ctx.children[argumentIndex].accept(self) body = ctx.children[argumentIndex + 3].accept(self) function = Function(arguments, self.environment, body) if ctx.children[1].getText() == '(': return Function(arguments, self.environment, body) else: self.environment.defineVariable(name, function) # Visit a parse tree produced by ECMAScriptParser#defaultClause. def visitDefaultClause(self, ctx): return (ctx.children[0].accept(self), ctx.children[2]) # Visit a parse tree produced by ECMAScriptParser#statement. def visitStatement(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#ForStatement. def visitForStatement(self, ctx): initialization = ctx.children[2].accept(self) condIndex = 4 if initialization == ';': condIndex -= 1 elif initialization == 'var': condIndex += 1 ctx.children[3].accept(self) condition = ctx.children[condIndex].accept(self) incrementorIndex = condIndex + 2 if condition == ';': incrementorIndex -= 1 incrementor = ctx.children[incrementorIndex].getText() expressionIndex = incrementorIndex + 2 if incrementor == ')': expressionIndex -= 1 while ctx.children[condIndex].accept(self): try: ctx.children[expressionIndex].accept(self) ctx.children[incrementorIndex].accept(self) except BreakException: break except ContinueException: ctx.children[incrementorIndex].accept(self) continue # Visit a parse tree produced by ECMAScriptParser#caseBlock. def visitCaseBlock(self, ctx): keyBodyPairs = collections.OrderedDict() for child in ctx.children[1:-1]: (key, body) = child.accept(self) keyBodyPairs[key] = body keys = list(keyBodyPairs) if ctx.chosenValue in keys: startIndex = keys.index(ctx.chosenValue) elif "default" in keys: startIndex = keys.index("default") bodies = list(keyBodyPairs.values()) for body in bodies[startIndex:]: try: body.accept(self) except BreakException: break # Visit a parse tree produced by ECMAScriptParser#ParenthesizedExpression. def visitParenthesizedExpression(self, ctx): # Return what's between the parenthesis ( what ). return ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#objectLiteral. def visitObjectLiteral(self, ctx): obj = ObjectModule() for key, value in self.childrenToList(ctx.children[1:-1]): if hasattr(value, "get") or hasattr(value, "set"): obj.defineProperty(obj, obj, str(key), value) else: setattr(obj, str(key), value) return obj # Visit a parse tree produced by ECMAScriptParser#throwStatement. def visitThrowStatement(self, ctx): raise ESException(ctx.children[1].accept(self)) # Visit a parse tree produced by ECMAScriptParser#breakStatement. def visitBreakStatement(self, ctx): raise BreakException() # Visit a parse tree produced by ECMAScriptParser#ifStatement. def visitIfStatement(self, ctx): if ctx.children[2].accept(self): ctx.children[4].accept(self) # If there is an else statement elif len(ctx.children) > 6: ctx.children[6].accept(self) # Visit a parse tree produced by ECMAScriptParser#reservedWord. def visitReservedWord(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#variableDeclaration. def visitVariableDeclaration(self, ctx): name = ctx.children[0].accept(self) if len(ctx.children) == 2: value = ctx.children[1].accept(self) else: value = None self.environment.defineVariable(name, value) # Visit a parse tree produced by ECMAScriptParser#finallyProduction. def visitFinallyProduction(self, ctx): ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#IdentifierExpression. def visitIdentifierExpression(self, ctx): return self.environment.value(ctx.children[0].accept(self)) # Visit a parse tree produced by ECMAScriptParser#propertyName. def visitPropertyName(self, ctx): return ctx.children[0].accept(self) # Visit a parse tree produced by ECMAScriptParser#catchProduction. def visitCatchProduction(self, ctx): exceptionName = ctx.children[2].accept(self) self.environment.defineVariable(exceptionName, ctx.exceptionValue) ctx.children[4].accept(self) self.environment.removeVariable(exceptionName) # Visit a parse tree produced by ECMAScriptParser#continueStatement. def visitContinueStatement(self, ctx): raise ContinueException # Visit a parse tree produced by ECMAScriptParser#caseClause. def visitCaseClause(self, ctx): return (ctx.children[1].accept(self), ctx.children[3]) # Visit a parse tree produced by ECMAScriptParser#arguments. def visitArguments(self, ctx): return ctx.children[1].accept(self) # Visit a parse tree produced by ECMAScriptParser#variableDeclarationList. def visitVariableDeclarationList(self, ctx): self.visitChildren(ctx) # Visit a parse tree produced by ECMAScriptParser#functionBody. def visitFunctionBody(self, ctx): def runFunction(environment): self.environment = Environment(environment) for c in ctx.children: try: c.accept(self) except ReturnException as re: return re.value finally: self.environment = self.environment.parent return runFunction # Visit a parse tree produced by ECMAScriptParser#eof. def visitEof(self, ctx): raise Utils.UnimplementedVisitorException(ctx) # Visit a parse tree produced by ECMAScriptParser#UnaryAssignmentExpression. def visitUnaryAssignmentExpression(self, ctx): operator = ctx.children[0].accept(self) name = ctx.children[1].accept(self) value = self.environment.value(name) self.environment.setVariable(name, self.unaries[operator](value)) return self.environment.value(name) def childrenToList(self, items): return [ item.accept(self) for item in items if not item.getText() == ',' ]