def test_should_ignore_invalid_ram_value(self): interpreter = Interpreter(['', None, 'Some non Int', '1000']) self.assertEqual('000', interpreter.get_ram_value(0)) self.assertEqual('000', interpreter.get_ram_value(1)) self.assertEqual('000', interpreter.get_ram_value(2)) self.assertEqual('000', interpreter.get_ram_value(3))
def parse(self): instructions = self._program() # do not print any output if error occurs if self.total_error_flag == 0: if self.print_symbol_table == 0: self.observer.print_output() elif self.print_symbol_table == 1: self.visitor.visitScope(self.program_scope) self.visitor.end() elif self.print_symbol_table == 2: currinstruction = instructions self.visitor.start() # while(currinstruction is not None): currinstruction.visit(self.visitor) # currinstruction = currinstruction._next elif self.print_symbol_table == 3: environment = self.program_scope.make_environment() stack = [] currinstruction = instructions # while curr is not None: # self.interpret(curr, environment, stack) # curr = curr._next # v = InterpreterVisitor(environment) # v.start() # currinstruction.int_visit(v) v = Interpreter(currinstruction, environment) v.start()
def test_0ds_should_not_go_to_location_d_when_s_is_zero(self): interpreter = Interpreter(['200', '214', '010', '201', '100']) instruction_count = interpreter.execute() self.assertEqual('001', interpreter.get_register_value(0)) self.assertEqual(5, instruction_count)
def test_should_set_ram_given_value(self): interpreter = Interpreter(['100']) self.assertEqual('100', interpreter.get_ram_value(0)) for index in range(1, 1000) : self.assertEqual('000', interpreter.get_ram_value(index))
def install_builtins(self): """ populate with the builtin functions, while adding our own flavors""" Interpreter.install_builtins(self) #input statements, length constructs tamil_equiv = {"சரம்_இடமாற்று":"replace", "சரம்_கண்டுபிடி":"find","நீளம்":"len", "சரம்_உள்ளீடு":"raw_input", "உள்ளீடு" : "input" } #list operators tamil_equiv.update( {"பட்டியல்":"list","பின்இணை":"append","தலைகீழ்":"reverse", "வரிசைப்படுத்து":"sort","நீட்டிக்க":"extend","நுழைக்க":"insert","குறியீட்டெண்":"index", "வெளியேஎடு":"pop","பொருந்தியஎண்":"count", "எடு":"__getitem__"} ) #file operators tamil_equiv.update({"கோப்பை_திற":"file_open", "கோப்பை_மூடு":"file_close","கோப்பை_படி":"file_read", "கோப்பை_எழுது":"file_write","கோப்பை_எழுது_வரிகள்":"file_writelines","கோப்பை_படி_வரிகள்":"file_readlines"}) for k,v in list(tamil_equiv.items()): self.builtin_map[k]=self.builtin_map[v]; # translations for turtle module turtle_map = { "முன்னாடி":"forward", "பின்னாடி" :"backward", "வலது":"lt", "இடது":"rt", "எழுதுகோல்மேலே":"penup", "எழுதுகோல்கிழே":"pendown"} for k,v in list(turtle_map.items()): vv = "turtle_"+v; self.builtin_map[k] = self.builtin_map[vv] return
def test_OP_Cxkk(self): # RND Vx, byte: Set Vx = random byte AND kk patch('Interpreter.getrandbits', lambda _: 0b10101010).start() path = os.path.join(os.getcwd(), "test_roms", "RND_Vx_byte.ch8") interpreter = Interpreter(path, False) interpreter.tick() self.assertEqual(interpreter.registers[1], 0b10101010 & 0b1100) patch.stopall()
def __init__(self, **kwargs ): """ create a Ezhil Interpeter and initialize runtime builtins etc.. in a RAII fashion, and associates a Ezhil parser object with this class """ Interpreter.__init__(self,**kwargs) Interpreter.change_parser(self,EzhilParser.factory) return
def test_OP_8xyE(self): # SHL Vx {, Vy}: Set Vx = Vx SHL 1 path = os.path.join(os.getcwd(), "test_roms", "SHL_VX.ch8") interpreter = Interpreter(path, False) interpreter.registers[1] = 129 interpreter.tick() self.assertEqual(interpreter.registers[1], 2) # Should wrap self.assertEqual(interpreter.registers[0xF], 1)
def processFile(self): interpreter = Interpreter() # return all the documents present in the file output = self.path + '.bin' if isfile(output): print('loading tokens') self.index = pickle.load(open(output, 'rb')) self.indexer = Indexer(self.tokenizer, index=self.index) else: self.indexer = Indexer(self.tokenizer) file = open(self.path, 'r', encoding='utf-8', errors='ignore') maximum = os.stat(self.path).st_size # initialize the variables i = 0 progress = 0 document = [] for line in file: progress += len(line) if line == '\n': interpreter.process(self.indexer, document) document = [] else: document += [line] i += 1 if i >= 5000: i = 0 log(progress, maximum) file.close() self.index = self.indexer.index print('\nsaving tokens') pickle.dump(self.index, open(output, 'wb'))
def __init__(self): self.data = Interpreter() self.difficulties = ['easy', 'normal', 'hard'] self.difficultySelected = self.data.getParameter('difficulty') self.musicValue = self.data.getParameter('music') self.sfxValue = self.data.getParameter('sfx') self.buttons = [] self.menuButtons = [] self.bigButtons = [] self.sliders = [] self.texts = {} self.images = [] self.logo = pygame.image.load('../Assets/menuAssets/logo.png') self.logoPos = [5, 0] self.animBool = True # self.sfxValue = self.data.getParameter('sfx') # self.musicValue = self.data.getParameter('music') self.loadImages() self.mainMenu() self.game = game(self) self.textGui = textGui() self.menuPage = { 'new': False, 'load': False, 'options': False, 'credits': False, 'quit': False } self.screen = pygame.display.set_mode((720, 480)) self.backgroundMenu = False self.sound = Sound() self.sound.playMusic(0, 2)
def __init__(self, height, width): self.camera = pygame.Rect(0, 0, width, height) self.width = width self.height = height self.data = Interpreter() self.screenWidth = self.data.getParameter('screenSize')[0] self.screenHeight = self.data.getParameter('screenSize')[1]
def run_ide(): print(": Welcome to Dymond V0.0.0!") print( ": Play around a little in this nice IDE type simple statements in and we will process them :)" ) print(": Type exit() to exit") user_in = "" total_user_in = "" while user_in != "exit()": user_in = input(">>> ") if (user_in == "exit()"): break try: test = total_user_in + user_in lexer = Lexer(test) se_parser = Parser(lexer, "ide") semantic_analyzer = SemanticAnalyzer(se_parser) semantic_analyzer.analyze() lexer = Lexer(test) in_parser = Parser(lexer, "ide") semantic_analyzer.current_scope.reset_multi_scope_vars() interpreter = Interpreter(in_parser, semantic_analyzer.current_scope) interpreter.interpret() if "print(" not in user_in and "input(" not in user_in: total_user_in += "\n" + user_in except Exception as ex: print(ex)
def main(): memory = defaultdict(int) states = ['PREFIX', 'INFIX', 'POSTFIX'] state = states[1] while True: try: text = input(state + ' --> ') except EOFError: break if not text: continue command = text.strip().upper() if command == 'EXIT': break if command in states: state = command continue lexer = Lexer(text) interpreter = Interpreter(lexer, state, memory) result = interpreter.evaluate() print(result)
def assign(self, interpreter_flag=False): Interpreter.interpreter_flag = interpreter_flag sc = self.scanner lexeme_identifier = sc.next_lexeme() if Interpreter.interpreter_flag: # semantic if not self.semantic_tree.is_describe_var_early(sc.get_pointer_line(), sc.get_pointer_position(), sc.lexeme): raise SemanticExceptionUndescribeVar(sc.get_pointer_line(), sc.get_pointer_position(), sc.lexeme) # semantic if Interpreter.interpreter_flag: # Interpreter node = self.semantic_tree.get_variable_node(sc.lexeme) # Interpreter sc.next_lexeme() # = value_obj = ValueObj() self.expression(value_obj, interpreter_flag=Interpreter.interpreter_flag) if Interpreter.interpreter_flag: # Interpreter Interpreter.to_type(value_obj, node.type_data) node.value = value_obj.value
def __init__(self): self.musics = [ pygame.mixer.Sound('../Assets/Sounds/dungeon.ogg'), pygame.mixer.Sound('../Assets/Sounds/dungeon2.ogg'), pygame.mixer.Sound('../Assets/Sounds/menu.ogg') ] self.bossMusics = [ pygame.mixer.Sound('../Assets/Sounds/bossMain.ogg'), pygame.mixer.Sound('../Assets/Sounds/bossFinal.ogg') ] self.effects = [ pygame.mixer.Sound('../Assets/Sounds/click.ogg'), pygame.mixer.Sound('../Assets/Sounds/magic.ogg'), pygame.mixer.Sound('../Assets/Sounds/youDied.ogg'), pygame.mixer.Sound('../Assets/Sounds/spike.ogg'), pygame.mixer.Sound('../Assets/Sounds/openingChest.ogg'), pygame.mixer.Sound('../Assets/Sounds/death.ogg') ] self.musicChannel = pygame.mixer.Channel(0) self.sfxChannel = pygame.mixer.Channel(1) self.sfx2Channel = pygame.mixer.Channel(2) self.musicChannel.set_volume(Interpreter().getParameter('music')) self.sfxChannel.set_volume(Interpreter().getParameter('sfx')) self.sfx2Channel.set_volume(Interpreter().getParameter('sfx')) self.lastMusic = self.musics[0] self.equalization()
def test_9sa_set_the_value_in_ram(self): interpreter = Interpreter(['209', '215', '901', '100']) instruction_count = interpreter.execute() self.assertEqual('009', interpreter.get_ram_value(5)) self.assertEqual(4, instruction_count)
def __init__(self, lexer, debug=False): """ create a Ezhil Interpeter and initialize runtime builtins etc.. in a RAII fashion, and associates a Ezhil parser object with this class """ Interpreter.__init__(self, lexer, debug) Interpreter.change_parser(self, EzhilParser.factory) return
def test_OP_2nnn(self): # CALL addr: Call subroutine at nnn path = os.path.join(os.getcwd(), "test_roms", "call_subroutine.ch8") interpreter = Interpreter(path, False) interpreter.tick() correct = [0x202, 0x204] + [0x200] * 14 self.assertEqual(interpreter.stack, correct) self.assertEqual(interpreter.stack_pointer, 1)
def __init__(self): self.hadError = False self.tokens = [] # saved tokens from previous uncompleted lines self.interp = Interpreter( ) # for retain inner statements when runPrompt() self.resolver = Resolver() self.compiler = Compiler() self.vm = StackVM()
def test_5ds_should_set_register_d_to_the_value_of_register_s(self): interpreter = Interpreter(['209', '510', '100']) instruction_count = interpreter.execute() self.assertEqual('009', interpreter.get_register_value(0)) self.assertEqual('009', interpreter.get_register_value(1)) self.assertEqual(3, instruction_count)
def testInterpreter3(): te.checkComplainAndAdjustExpected( 0) i= Interpreter() i.evalToken( s( '(')) # baustelle: testbarkeit der repl te.checkComplainAndAdjustExpected( 0)
def test_OP_8xy7( self): # SUBN Vx, Vy: Set Vx = Vy - Vx, set VF = NOT borrow path = os.path.join(os.getcwd(), "test_roms", "SHR_VX.ch8") interpreter = Interpreter(path, False) interpreter.registers[1] = 0b101 interpreter.tick() self.assertEqual(interpreter.registers[1], 0b10) # Should wrap self.assertEqual(interpreter.registers[0xF], 1)
def test_OP_00E0(self): # CLS: Clear the Display path = os.path.join(os.getcwd(), "test_roms", "clear_display.ch8") interpreter = Interpreter(path, False) interpreter.display = [1] * len(interpreter.display) interpreter.tick() self.assertTrue( not any(interpreter.display), F"Expected cleared display. Got {interpreter.display}")
def test_8da_should_set_register_d_to_the_value_in_ram_whose_address_is_in_register_a(self): interpreter = Interpreter(['203', '810', '100', '999']) instruction_count = interpreter.execute() self.assertEqual('003', interpreter.get_register_value(0)) self.assertEqual('999', interpreter.get_register_value(1)) self.assertEqual(3, instruction_count)
def test_7ds_should_multiply_register_d_to_the_value_of_register_s(self): interpreter = Interpreter(['209', '212', '710', '100']) instruction_count = interpreter.execute() self.assertEqual('009', interpreter.get_register_value(0)) self.assertEqual('018', interpreter.get_register_value(1)) self.assertEqual(4, instruction_count)
def main(): with open("source.dd") as f: code = ''.join(f.readlines()) #print(code) lexer = Lexer(code) parser = Parser(lexer) interpreter = Interpreter(parser) result = interpreter.interpret()
def find_accumulator_before_loop(instructions): interpreter = Interpreter() outputs = set() accumulator = 0 for output in interpreter.launch_process(instructions): if output[1] in outputs: return accumulator outputs.add(output[1]) accumulator = output[0]
def __init__(self, master=None): super().__init__(master) self.master = master self.master.minsize(600, 400) self.master.title("Brainfuck interpreter by Cezary Kania v 0.1") self.interpreter = Interpreter(self) self.init_menu() self.init_body() self.pack()
def update(self): if not self.musicChannel.get_busy(): self.musicChannel.queue(self.lastMusic) a = Interpreter().getParameter('music') b = Interpreter().getParameter('sfx') self.musicChannel.queue(self.lastMusic) self.musicChannel.set_volume(a) self.sfxChannel.set_volume(b) self.sfx2Channel.set_volume(b)
def main(args): input = FileStream(args[1]) lexer = MiniPLexer(input) stream = CommonTokenStream(lexer) parser = MiniPParser(stream) tree = parser.program() interpreter = Interpreter() interpreter.visit(tree)
def makeOverridenInterpreter(): ios= InterpreterOverridings() i= Interpreter() i.readTokenRawInput= ios.readTokenRawInput i.essentials_macro_function.ess_print= ios.ess_ess_print # 8c231655685648cc99e5b0bf3b0b8687 i.s_print= ios.s_print return ( ios, i)
def test_OP_Fx29( self): # LD F, Vx: Set I = location of sprite for digit Vx path = os.path.join(os.getcwd(), "test_roms", "LD_F_Vx.ch8") BYTES_PER_DIGIT = 5 interpreter = Interpreter(path, False) interpreter.registers[1] = 3 interpreter.tick() self.assertEqual( interpreter.index_register, interpreter.FONT_SET_START_ADDRESS + (interpreter.registers[1] * BYTES_PER_DIGIT))
class Shell: def __init__(self): self._interpreter = Interpreter() self._PROMPT = ">>" self._run() def _run(self): while True: line = input(self._PROMPT + " ") self._interpreter.interpret(line)
class InterpreterVisitor: def __init__(self, environment): self.environment = environment self.interpreter = Interpreter() def visitNode(self, ast): self.interpreter.interpret(ast, self.environment) if ast._next is not None: ast._next.int_visit(self)
def parseinfo(self,e): keycode = e.GetKeyCode() if keycode == wx.WXK_RETURN or keycode == wx.WXK_NUMPAD_ENTER or keycode == wx.WXK_TAB: if self.editname.GetValue() == "exit" or self.editname.GetValue() == "exit;": exit(0) else: z = Interpreter() #thread.start_new_thread(z.parse(self.editname.GetValue())) z.parse(self.editname.GetValue()) e.EventObject.Navigate() e.Skip()
def run_file(file_name): lexer = Lexer(open(file_name, "r").read()) se_parser = Parser(lexer, "input") semantic_analyzer = SemanticAnalyzer(se_parser) semantic_analyzer.analyze() lexer = Lexer(open(file_name, "r").read()) in_parser = Parser(lexer, "input") semantic_analyzer.current_scope.reset_multi_scope_vars() interpreter = Interpreter(in_parser, semantic_analyzer.current_scope) result = interpreter.interpret()
def entry_point(argv): filename = argv[1] args = [] args.append( filename ) for i in xrange(len(argv)): if i > 1: args.append( argv[i] ) interp = Interpreter( filename=filename, argv=args ) rv = interp.run() return rv
def test_OP_Fx65( self ): # LD Vx, [I]: Read registers V0 through Vx from memory starting at location I path = os.path.join(os.getcwd(), "test_roms", "LD_Vx_I.ch8") interpreter = Interpreter(path, False) interpreter.index_register = interpreter.MEMORY_START_ADDRESS interpreter.tick() correct = [ 0xFC, 0x65, 0x01, 0x23, 0x45, 0x67, 0x89, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x0, 0x0, 0x0 ] self.assertEqual(interpreter.registers, correct)
def install_builtins(self): """ populate with the builtin functions, while adding our own flavors""" Interpreter.install_builtins(self) #input statements, length constructs tamil_equiv = { "சரம்_இடமாற்று": "replace", "சரம்_கண்டுபிடி": "find", "நீளம்": "len", "சரம்_உள்ளீடு": "raw_input", "உள்ளீடு": "input" } #list operators tamil_equiv.update({ "பட்டியல்": "list", "பின்இணை": "append", "தலைகீழ்": "reverse", "வரிசைப்படுத்து": "sort", "நீட்டிக்க": "extend", "நுழைக்க": "insert", "குறியீட்டெண்": "index", "வெளியேஎடு": "pop", "பொருந்தியஎண்": "count", "எடு": "__getitem__" }) #file operators tamil_equiv.update({ "கோப்பை_திற": "file_open", "கோப்பை_மூடு": "file_close", "கோப்பை_படி": "file_read", "கோப்பை_எழுது": "file_write", "கோப்பை_எழுது_வரிகள்": "file_writelines", "கோப்பை_படி_வரிகள்": "file_readlines" }) for k, v in list(tamil_equiv.items()): self.builtin_map[k] = self.builtin_map[v] # translations for turtle module turtle_map = { "முன்னாடி": "forward", "பின்னாடி": "backward", "வலது": "lt", "இடது": "rt", "எழுதுகோல்மேலே": "penup", "எழுதுகோல்கிழே": "pendown" } for k, v in list(turtle_map.items()): vv = "turtle_" + v self.builtin_map[k] = self.builtin_map[vv] return
def start_JVM(cmd): class_path = Classpath.parse(cmd.XjreOption, cmd.cpOption) print("classpath:{0} class:{1} args:{2}".format(class_path, cmd.class_name, cmd.args)) class_loader = ClassLoader(class_path, cmd.verbose_class_flag) class_name = cmd.class_name.replace(".", "/") main_class = class_loader.load_class(class_name) main_method = main_class.get_main_method() if main_method: Interpreter.interpret(main_method, cmd.verbose_inst_flag) else: print("Main method not found in class {0}".format(cmd.class_name))
def a3(self, value_obj, interpreter_flag=False): Interpreter.interpreter_flag = interpreter_flag self.a4(value_obj, interpreter_flag=Interpreter.interpreter_flag) sc = self.scanner old_pointer = sc.get_pointer() lexeme_lege = sc.next_lexeme() while lexeme_lege == lId.TLess or lexeme_lege == lId.TGreater or \ lexeme_lege == lId.TLessEq or lexeme_lege == lId.TGreaterEq: _value_obj = ValueObj() self.a4(_value_obj, interpreter_flag=Interpreter.interpreter_flag) if Interpreter.interpreter_flag: # interpreter if lexeme_lege == lId.TLess: Interpreter.verify_less(value_obj, _value_obj) elif lexeme_lege == lId.TLessEq: Interpreter.verify_less_eq(value_obj, _value_obj) elif lexeme_lege == lId.TGreater: Interpreter.verify_greater(value_obj, _value_obj) else: Interpreter.verify_greater_eq(value_obj, _value_obj) # interpreter old_pointer = sc.get_pointer() lexeme_lege = sc.next_lexeme() sc.set_pointer(old_pointer)
def main(): file = open("examples/example3.txt", 'r').read() lexer = Lexer(file) # lexer.DEBUG = True lexer.run() parser = Parser(lexer.tokens) # parser.DEBUG = True parser.run() interpreter = Interpreter(parser.commands) # interpreter.DEBUG = True interpreter.run()
def create_dev(ip): dev = Router(ip, username, password, cmd_file, rdeb) if dev.err: print "Skipping device %s\n" %ip return #all input values are correct #create Interpreter i = Interpreter(dev, ideb, ideb) i.start() if ideb: #print last debug info print "Oper_st: %s" %i.oper_st print "Data_st: %s" %i.data_st print "Env: %s" %i.env
def run(fname, text): lexer = Lexer(fname, text) tokens, error = lexer.genTok() if error: return None, error parser = Parser(tokens) bTree = parser.parse() if bTree.error: return None, bTree.error interpreter = Interpreter() context = Context('<program>') context.symbTable = GlobalSymTable result = interpreter.visit(bTree.node, context) return result.value, result.error
def interpret_file(filename): parser = BoolangParser() interpreter = Interpreter() text = '' try: with open(filename) as f: # read entire file text = f.read() except FileNotFoundError: print('Error: file not found.') sys.exit(1) program = parser.parse(text) interpreter.interpret(program)
def test_one(self,benchmark): n=1 while(n<100): i = Interpreter() f = open('input.bas', 'r') for line in f: line = line.strip() split_line = line.split(" ") line_number = int(split_line[0]) i.add_line(line_number, split_line[1:]) i.run() f.close() n=n+1 benchmark(time.sleep, 0.000001)
def runtest( filename ): print "File: %s -> " % os.path.basename(filename), # get program contents f = open_file_as_stream(filename) program = f.readall() f.close() # expect? expect_rv = 0 expect_stack = [] expect_space = [] expect_stdout = '' # look for special tags in out for ln in program.split('\n'): if ln.startswith( 'Return:' ): expect_rv = int(ln.split(' ')[-1]) elif ln.startswith( 'Stack:' ): expect_stack = [Cell(int(v)) for v in ln.split(' ')[1:]] elif ln.startswith( 'Space:' ): parts = ln.split(' ')[1:] expect_space.append( (int(parts[0]),int(parts[1]),Cell(int(parts[2]))) ) elif ln.startswith( 'Stdout:' ): expect_stdout = ln[7:].strip() # run the interpreter on the file cap = py.io.StdCaptureFD() i = Interpreter( filename=filename, argv=['testrunner'] ) rv = i.run() fds = cap.done() actual_stdout = fds[0].read().strip() # check results #print "E: %s" % str(expect_stack) #print "A: %s" % str(i.stacks.head().inner) try: assert rv == expect_rv for v in expect_stack: assert 0 == v.cmp_( i.stacks.pop() ) for x,y,val in expect_space: assert 0 == val.cmp_( i.space.get( x, y ) ) assert expect_stdout == actual_stdout except: print "" print "RV: %s" % rv print str(i.stacks) raise
def main(): # Zpracovani argumentu args = handleArgs() if args is None: if '--help' not in sys.argv and '-h' not in sys.argv: sys.exit(ErrCodes.PARAM) else: sys.exit(ErrCodes.OK) try: file = open(args.source_file, "r") except: # Chyba vstupniho souboru sys.exit(ErrCodes.INPUT_FILE) try: tree = ET.parse(file) except ET.ParseError: # Chybny format xml sys.exit(ErrCodes.XML_FORMAT) interpreter = Interpreter(tree) # Vytvoreni objektu interpretu # Interpretace try: interpreter.run_code() except MyException as e: #chyba interpretace #print("Exiting with code: %d" % e.arg1) sys.exit(e.arg1) # rozsireni STATI if args.stats_file != None: try: out_file = open(args.stats_file, 'w') except: sys.exit(ErrCodes.OUTPUT) try: optlist, a = getopt.getopt(sys.argv[1:], '', ['source=', 'stats=', 'insts', 'vars']) except getopt.GetoptError: pass for opt in optlist: if opt[0] == '--insts': out_file.write(str(interpreter.ins_count) + '\n') if opt[0] == '--vars': out_file.write(str(interpreter.get_vars()) + '\n') exit(ErrCodes.OK)
def run (file,text): lexer = Lexer(file,text) tokens,error = lexer.make_tokens() if error: return None,error #abstract syntax tree parser = Parser(tokens) abstract_st = parser.parse() if abstract_st.error: return None,abstract_st.error #run program interpreter = Interpreter() context = Context('<basic context>') context.symbol_table=global_symbol_table result = interpreter.visit(abstract_st.node,context) return result.value,result.error
class Vector: def __init__(self, debug = False): self.debug = debug self.parser = Parser() self.interpreter = Interpreter() def eval(self, s): if self.debug: print "Input: " + s lexemes = Lexer.lex(s) if self.debug: print "Lexemes: " + str(lexemes) ast = self.parser.parse(lexemes) if self.debug: print "AST:" self.printAST(ast, 0) result = self.interpreter.eval(ast) if self.debug: print "Result: ", print str(result) def printAST(self, ast, indent): if ast == False: print "| " * indent + "ERROR" return print "| " * indent + str(ast[1]) if len(ast) < 3: return for c in ast[2]: self.printAST(c, indent + 1)
def __init__(self, **kwargs): super(MainLayout, self).__init__(**kwargs) self.Interpreter = Interpreter() self.command_stack = [] self.cols = 2 self.orientation = "vertical" self.padding = 10 self.workspace = Workspace() self.command_panel = CommandPanel(self.workspace) self.output = Output() self.spn_menu = Spinner(text='Menu', values=('New', 'Save', 'RUN', 'Exit'), size_hint =(None, None), size=(200, 44), pos_hint={'x': .1, 'y': .9}) self.spn_menu.bind(text=self.menu_option_selected_event) self.command_panel.draw(self.spn_menu) self.command_panel.add_expression_btn('LET') self.command_panel.add_expression_btn('PRINT') self.command_panel.add_expression_btn('GOTO') self.command_panel.add_expression_btn('IF') self.command_panel.add_expression_btn('GOSUB') self.command_panel.add_expression_btn('RETURN') self.command_panel.add_expression_btn('END') self.add_widget(self.command_panel) self.orientation = "horizontal" self.workspace.draw() self.add_widget(self.workspace) self.output.draw() self.add_widget(self.output)
class YazInterpreter: def __init__(self): self.interpreter = Interpreter() def menu(self): print("Welcome to the YazInterpreter!") print("You may interpret a YazLang program and output") print("the results to a .txt file or enter console YazInteractions") print("mode to run single commands of YazLang.") print() while(True): self.eleccion = input("\033[;37m" + "(C)onsole YazInteractions, (I)nterpret .yzy program, (Q)uit? ") if(self.eleccion == "I" or self.eleccion == "i"): self.archivos() elif(self.eleccion == 'C' or self.eleccion == 'c'): print("YazInteractions session. Type END to exit.") self.CLI() elif(self.eleccion == 'Q' or self.eleccion == 'q'): break def CLI(self): while True: self.string = input(">") self.a = self.interpreter.evaluateString(self.string) if(self.a == False): break print(self.a) def archivos(self): archivo = Archivos() archivo.menu()
def install_builtins(self): """ populate with the builtin functions, while adding our own flavors""" Interpreter.install_builtins(self) #input statements, length constructs tamil_equiv = {u"சரம்_இடமாற்று":u"replace", u"சரம்_கண்டுபிடி":u"find",u"நீளம்":u"len", u"சரம்_உள்ளீடு":u"raw_input", u"உள்ளீடு" : u"input" } # printf - as per survey request tamil_equiv.update( { u"அச்சிடு":u"printf" } ) #list operators tamil_equiv.update( {u"பட்டியல்":u"list",u"பின்இணை":u"append",u"தலைகீழ்":u"reverse", u"வரிசைப்படுத்து":u"sort",u"நீட்டிக்க":u"extend",u"நுழைக்க":u"insert",u"குறியீட்டெண்":u"index", u"வெளியேஎடு":u"pop_list",u"பொருந்தியஎண்":u"count"} ) #generic get/set ops for list/dict tamil_equiv.update( { u"எடு":u"__getitem__", u"வை":u"__setitem__",u"சாவிகள்":u"keys"} ) #file operators tamil_equiv.update({u"கோப்பை_திற":u"file_open", u"கோப்பை_மூடு":u"file_close",u"கோப்பை_படி":u"file_read", u"கோப்பை_எழுது":u"file_write",u"கோப்பை_எழுது_வரிகள்":u"file_writelines",u"கோப்பை_படி_வரிகள்":u"file_readlines"}) #type tamil_equiv.update({u"வகை":u"type"}) for k,v in list(tamil_equiv.items()): self.builtin_map[k]=self.builtin_map[v]; try: import EZTurtle except ImportError as ie: if ( self.debug ): print(u"ImportError => turtle ",unicode(ie)) return # translations for turtle module turtle_map = { u"முன்னாடி":u"forward", u"பின்னாடி" :u"backward", u"வலது":u"lt", u"இடது":u"rt", u"எழுதுகோல்மேலே":u"penup", u"எழுதுகோல்கிழே":u"pendown"} for k,v in list(turtle_map.items()): vv = u"turtle_"+v; self.builtin_map[k] = self.builtin_map[vv] return
def a7(self, value_obj, interpreter_flag=False): Interpreter.interpreter_flag = interpreter_flag sc = self.scanner old_pointer = sc.get_pointer() lexeme_open_bracket = sc.next_lexeme() fun_name = sc.lexeme if lexeme_open_bracket == lId.TOpen: self.expression(value_obj, interpreter_flag=Interpreter.interpreter_flag) lexeme_close_bracket = sc.next_lexeme() if lexeme_close_bracket != lId.TClose: raise SyntaxExceptionCharacter(sc.get_pointer_line(), sc.get_pointer_position(), ")", sc.lexeme) elif sc.next_lexeme() == lId.TOpen: sc.set_pointer(old_pointer) self.call_function(interpreter_flag=Interpreter.interpreter_flag) if Interpreter.interpreter_flag: # Interpreter node = self.semantic_tree.get_function_node(fun_name) value_obj.value = node.value value_obj.type = node.type_data # Interpreter else: sc.set_pointer(old_pointer) lexeme_operand = sc.next_lexeme() if lexeme_operand != lId.TId and lexeme_operand != lId.TNum10 and lexeme_operand != lId.TNum16: raise SyntaxExceptionOperand(sc.get_pointer_line(), sc.get_pointer_position(), sc.lexeme) if Interpreter.interpreter_flag: # semantic if lexeme_operand == lId.TId: if not self.semantic_tree.is_describe_var_early(sc.get_pointer_line(), sc.get_pointer_position(), sc.lexeme): raise SemanticExceptionUndescribeVar(sc.get_pointer_line(), sc.get_pointer_position(), sc.lexeme) # semantic if Interpreter.interpreter_flag: # Interpreter if lexeme_operand == lId.TId: _value_obj = self.semantic_tree.get_variable_value_obj(sc.lexeme) value_obj.value = _value_obj.value value_obj.type = _value_obj.type elif lexeme_operand == lId.TNum10: Interpreter.set_value_obj_from_num10(value_obj, sc.lexeme) else: Interpreter.set_value_obj_from_num16(value_obj, sc.lexeme)
def a6(self, value_obj, interpreter_flag=False): Interpreter.interpreter_flag = interpreter_flag sc = self.scanner old_pointer = sc.get_pointer() lexeme_pref = sc.next_lexeme() if lexeme_pref == lId.TMinus or lexeme_pref == lId.TPlus: #or lexeme_pref == lId.TMinusMinus or lexeme_pref == lId.TPlusPlus: if Interpreter.interpreter_flag: # Interpreter if lexeme_pref == lId.TMinus: Interpreter.sub({'value': 0, 'type': lId.TShort}, value_obj) # Interpreter self.a7(value_obj, interpreter_flag=Interpreter.interpreter_flag) else: sc.set_pointer(old_pointer) self.a7(value_obj, interpreter_flag=Interpreter.interpreter_flag)
def a4(self, value_obj, interpreter_flag=False): Interpreter.interpreter_flag = interpreter_flag self.a5(value_obj, interpreter_flag=Interpreter.interpreter_flag) sc = self.scanner old_pointer = sc.get_pointer() lexeme_plus_minus = sc.next_lexeme() while lexeme_plus_minus == lId.TPlus or lexeme_plus_minus == lId.TMinus: _value_obj = ValueObj() self.a5(_value_obj, interpreter_flag=Interpreter.interpreter_flag) if Interpreter.interpreter_flag: # interpreter if lexeme_plus_minus == lId.TPlus: Interpreter.sum(value_obj, _value_obj) else: Interpreter.sub(value_obj, _value_obj) # interpreter old_pointer = sc.get_pointer() lexeme_plus_minus = sc.next_lexeme() sc.set_pointer(old_pointer)
def a2(self, value_obj, interpreter_flag=False): Interpreter.interpreter_flag = interpreter_flag self.a3(value_obj, interpreter_flag=Interpreter.interpreter_flag) sc = self.scanner old_pointer = sc.get_pointer() lexeme_equal = sc.next_lexeme() while lexeme_equal == lId.TEq or lexeme_equal == lId.TUnEq: _value_obj = ValueObj() self.a3(_value_obj, interpreter_flag=Interpreter.interpreter_flag) if Interpreter.interpreter_flag: # interpreter if lexeme_equal == lId.TEq: Interpreter.verify_equal(value_obj, _value_obj) else: Interpreter.verify_unequal(value_obj, _value_obj) # interpreter old_pointer = sc.get_pointer() lexeme_equal = sc.next_lexeme() sc.set_pointer(old_pointer)
def enum_operand(self, interpreter_flag=False): Interpreter.interpreter_flag = interpreter_flag sc = self.scanner old_pointer = sc.get_pointer() lexeme = sc.next_lexeme() if lexeme != lId.TClose: sc.set_pointer(old_pointer) value_obj = ValueObj() self.expression(value_obj, interpreter_flag=Interpreter.interpreter_flag) if Interpreter.interpreter_flag: # semantic self.semantic_tree.current_count_parameter += 1 self.semantic_tree.go_left() if self.semantic_tree.pointer != self.semantic_tree.dummy: Interpreter.to_type(value_obj, self.semantic_tree.pointer.type_data) self.semantic_tree.pointer.value = value_obj.value # semantic old_pointer = sc.get_pointer() lexeme = sc.next_lexeme() while lexeme == lId.TComma: value_obj = ValueObj() self.expression(value_obj, interpreter_flag=Interpreter.interpreter_flag) if Interpreter.interpreter_flag: # semantic self.semantic_tree.current_count_parameter += 1 self.semantic_tree.go_left() if self.semantic_tree.pointer != self.semantic_tree.dummy: Interpreter.to_type(value_obj, self.semantic_tree.pointer.type_data) self.semantic_tree.pointer.value = value_obj.value # semantic old_pointer = sc.get_pointer() lexeme = sc.next_lexeme() sc.set_pointer(old_pointer)
def test_3dn_should_add_n_to_register_d(self): interpreter = Interpreter(['308', '100']) instruction_count = interpreter.execute() self.assertEqual('008', interpreter.get_register_value(0)) self.assertEqual(2, instruction_count) ## interpreter = Interpreter(['308', '302', '100']) instruction_count = interpreter.execute() self.assertEqual('010', interpreter.get_register_value(0)) self.assertEqual(3, instruction_count)
def test_4dn_should_multiply_d_by_n(self): interpreter = Interpreter(['408', '100']) instruction_count = interpreter.execute() self.assertEqual('000', interpreter.get_register_value(0)) self.assertEqual(2, instruction_count) ## interpreter = Interpreter(['302', '407', '100']) instruction_count = interpreter.execute() self.assertEqual('014', interpreter.get_register_value(0)) self.assertEqual(3, instruction_count)