def run(cls, args, file_ptr): try: sa = SyntaxAnalyzer(file_ptr, args) sa.run_analyzer() except Exception as ex: print(ex) traceback.print_exc()
def helper_run_invalid(self, filename, line, expect_str): input_path = os.path.join(self.test_files, filename) sys.argv.extend(['-i', input_path]) with open(input_path, 'r') as input_file: sa = SyntaxAnalyzer(input_file, CompilersMain.get_args()) with self.assertRaises(CompilerExceptions.CSyntaxError) as ex: sa.r_Rat18F() print(ex.exception) self.assertEqual(ex.exception.token.line, line) if expect_str is not None: self.assertEqual(ex.exception.expect, expect_str)
def test_syntaxanalyzer(file, exp_result): #print file, exp_result fl = FileAccessManager(file) analyzer = LexicalAnalyzer(fl) result = analyzer.analyze() syntaxer = SyntaxAnalyzer(result) run_result = syntaxer.Run() assert run_result == exp_result
def helper_run(self, filename): input_name = os.path.join(self.test_files, filename) output_path = os.path.join(self.test_files, "instructions_" + filename) assert_name = os.path.join(self.test_files, "assert_" + filename) sys.argv.extend(['-i', input_name]) argp = CompilersMain.get_args() with open(input_name, 'r') as input_file: sa = SyntaxAnalyzer(input_file, argp) sa.run_analyzer() with open(output_path) as ofile: with open(assert_name) as afile: for line in afile: self.assertEqual(ofile.readline().strip(), line.strip())
def Compiler(path): global T, vm if os.path.isfile(path) and path[-5:] == '.jack': sys.stderr.write("Compiling Jack file %s\n" % path) try: f = open(path) except: sys.stderr.write("(Error) Cannot open file %s\n" % path) return 1 try: T.tokens = Tokenizer(f.read()) T.tokend = 0 f.close() except Exception as err: sys.stderr.write("(Error) Tokenization failed: %s\n" % str(err)) return 1 try: root = ET.Element('SyntaxLayout') SyntaxAnalyzer(root, 'class') except Exception as err: sys.stderr.write("(Error) Invalid syntax: %s\n" % str(err)) return 1 try: path_xml = path[:-5] + '.xml' pretty_xml = copy.deepcopy(root[0]) indent(pretty_xml) ET.ElementTree(pretty_xml).write(path_xml) except: sys.stderr.write("(Error) Cannot write to file %s\n" % path_xml) try: vm.code = [] CodeWriter(root[0]) except Exception as err: sys.stderr.write("(Error) Invalid syntax: %s\n" % str(err)) try: path = path[:-5] + '.vm' f = open(path, 'w') f.write('\n'.join(vm.code) + '\n') f.close() except: sys.stderr.write("(Error) Cannot write to file %s\n" % path) return 1 num_jack = 0 if os.path.isdir(path): for filename in os.listdir(path): num_jack += Compiler(path + '/' + filename) return num_jack
def process(self): ''' Process the assembly code ''' lexicalAnalyzer = LexicalAnalyzer(self.args) syntaxAnalyzer = SyntaxAnalyzer(self.args) codeGenerator = CodeGenerator(self.args) # lexical analysis ok = lexicalAnalyzer.analyze() if not ok: return False # syntax analysis ok = syntaxAnalyzer.analyze(lexicalAnalyzer.tokens) if not ok: return False # code generation ok = codeGenerator.generate(syntaxAnalyzer.expressions) if not ok: return False return True
def main (single_run, use_ctl, use_dbg, text): exit = False db = MySQLdb.connect (host="localhost", user="******", passwd="qslbase", db="qslbase", charset="utf8") cursor = db.cursor () result = "" sys.setdefaultencoding ("utf8") SyntaxAnalyzer (cursor) semantic_analyzer = SemanticAnalyzer (cursor) CodeProvider (cursor) CodeStack () ErrorHelper (cursor) MemoryProvider () ContextProvider () TriggerProvider () ConditionProvider () DebuggerProvider (use_dbg) if single_run == False: stdin = os.open ("/tmp/qslime-std-in", os.O_RDONLY | os.O_NONBLOCK) stdout = os.open ("/tmp/qslime-std-out", os.O_WRONLY) if use_ctl == True: ctlout = os.open ("/tmp/qslime-ctl-out", os.O_WRONLY) ctlin = open ("/tmp/qslime-ctl-in", "r") if use_dbg == True: dbgout = os.open ("/tmp/qslime-dbg-out", os.O_WRONLY) dbgin = open ("/tmp/qslime-dbg-in", "r") DebuggerProvider.dbgin = dbgin DebuggerProvider.dbgout = dbgout if use_ctl == True: text = ctlin.readline () if text != "": if SyntaxAnalyzer.analize (text): #PropositionTree.print_tree (SyntaxAnalyzer.proposition_tree) if semantic_analyzer.analize (SyntaxAnalyzer.proposition_tree, None): #semantic_analyzer.proposition_tree.print_tree () result += semantic_analyzer.result os.write (ctlout, 'OK.\n') else: os.write (ctlout, semantic_analyzer.get_error_text () + '\n') else: os.write (ctlout, semantic_analyzer.get_error_text () + '\n') else: if text != "": #print text if DebuggerProvider.use == True: DebuggerProvider.reset () DebuggerProvider.set_single_code_line (text) DebuggerProvider.build_debug_data () DebuggerProvider.send_data () DebuggerProvider.receive_data () if SyntaxAnalyzer.analize (text): #SyntaxAnalyzer.proposition_tree.print_tree (SyntaxAnalyzer.proposition_tree) if semantic_analyzer.analize (SyntaxAnalyzer.proposition_tree, None): #semantic_analyzer.proposition_tree.print_tree () result += semantic_analyzer.result else: return semantic_analyzer.get_error_text () else: return SyntaxAnalyzer.get_error_text () while (exit != True): code_line = CodeStack.pop () while (code_line != None): if code_line.text != "": #print code_line.text if DebuggerProvider.use == True: if code_line.concept_id != 0 and code_line.id != 0: DebuggerProvider.set_procedure_id (code_line.concept_id) DebuggerProvider.set_line_id (code_line.id) else: DebuggerProvider.set_single_code_line (code_line.text) DebuggerProvider.build_debug_data () DebuggerProvider.send_data () DebuggerProvider.receive_data () analized = True if code_line.tree == None: analized = SyntaxAnalyzer.analize (code_line.text) tree = SyntaxAnalyzer.proposition_tree else: tree = code_line.tree if analized: #tree.print_tree (tree) if semantic_analyzer.analize (tree, code_line): #tree.print_tree (tree) if code_line.tree != None: if code_line.tree.is_totally_parsed == False: code_line.tree = semantic_analyzer.proposition_tree code_line.tree.is_totally_parsed = True result += semantic_analyzer.result else: return semantic_analyzer.get_error_text () else: return SyntaxAnalyzer.get_error_text () if CodeStack.is_empty () == True: if CodeStack.inside_procedure == False: if CodeProvider.is_priorities_assigned () == False: CodeProvider.assign_priorities () TriggerProvider.dispatch_triggers () ConditionProvider.dispatch_conditions () CodeStack.sort () else: if code_line.prev_line_id == -1 and code_line.concept_id != 0: CodeProvider.execute_procedure (code_line.concept_id) code_line = CodeStack.pop () if result != "" and single_run == False: #print result os.write (stdout, result) result = "" exit = True if single_run == True: return result os.close (stdin) os.close (stdout) os.close (ctlin) os.close (ctlout) os.close (dbgin) os.close (dbgout)
def helper_run_valid(self, file_path): sys.argv.extend(['-i', file_path]) with open(file_path, 'r') as input_file: sa = SyntaxAnalyzer(input_file, CompilersMain.get_args()) sa.r_Rat18F()