def test_not(self): str = "int main() { !3; }" lex = lexical.Lexical(str) # self.assertEqual(8 + 6, len(lex)) syn = syntax.Syntax(lex) self.assertEqual(3 + 1, syn.size) str = "int main() { !!3; }" lex = lexical.Lexical(str) # self.assertEqual(8 + 6, len(lex)) syn = syntax.Syntax(lex) self.assertEqual(4 + 1, syn.size) str = "int main() { !(!1 + 2); }" lex = lexical.Lexical(str) # self.assertEqual(8 + 6, len(lex)) syn = syntax.Syntax(lex) self.assertEqual(6 + 1, syn.size)
def generic(self, str, lexSize, synSize): lex = lexical.Lexical(str) self.assertEqual(lexSize + 6, len(lex)) syn = syntax.Syntax(lex) print(syn.node) self.assertEqual(synSize + 1, syn.size)
def __init__(self, transitionSystem): """ A ctlChecker is linked to a certain transition system. When you build a CtlChecker you need to pass a TransitionSystem to it. """ self._syntax = syntax.Syntax() self._conv = conversions.Conversions() self._ts = transitionSystem self._callDic = { self._syntax.true: self._satTrue, self._syntax.ap: self._satAp, self._syntax.land: self._satAnd, self._syntax.lor: self._satConversionTwoSons, self._syntax.lnot: self._satNot, self._syntax.implies: self._satConversionTwoSonsOrdered, self._syntax.equals: self._satConversionTwoSons, self._syntax.exNext: self._satExNext, self._syntax.exUntil: self._satExUntil, self._syntax.exAlways: self._satExAlways, self._syntax.exEventually: self._satConversionOneSon, self._syntax.faNext: self._satConversionOneSon, self._syntax.faUntil: self._satConversionTwoSonsOrdered, self._syntax.faAlways: self._satConversionOneSon, self._syntax.faEventually: self._satConversionOneSon, self._syntax.exWeakUntil: self._satConversionTwoSonsOrdered, self._syntax.faWeakUntil: self._satConversionTwoSonsOrdered, self._syntax.phiNode: self._satPhi, }
def __init__(self, filename): self._syntax = syntax.Syntax() self._graph = nx.DiGraph() f = open(filename, 'r') nodesPart = True for line in f: fields = line.split('//')[0].split() if nodesPart and len(fields) == 0: nodesPart = False continue if nodesPart: if (len(fields) <= 2): self._graph.add_node( fields[0], initial=(fields[1] == self._syntax.true), att=[]) else: self._graph.add_node( fields[0], initial=(fields[1] == self._syntax.true), att=fields[2].split(',', fields[2].count(','))) else: self._graph.add_edge(fields[0], fields[1])
def test_constant(self): str = " 3 " lex = lexical.Lexical(str) syn = syntax.Syntax(lex, run=False) node = syn.P(lex.current()) self.assertEqual(syntax.nodes_const.NODE_CONSTANT, node.type) self.assertEqual(3, node.value)
def test_variable(self): str = "x;" lex = lexical.Lexical(str) syn = syntax.Syntax(lex, run=False) node = syn.P(lex.current()) self.assertEqual(syntax.nodes_const.NODE_VAR_REF, node.type) self.assertEqual("x", node.identifier)
def test_error(self): str = "int main() { 3 * (2 + 4) * 1 ( }" lex = lexical.Lexical(str) self.assertEqual(10 + 6, len(lex)) with self.assertRaises(CompileException) as e: syntax.Syntax(lex) print(e.exception) str = "int main() { 3 * (2 + 4) * 1 1 }" lex = lexical.Lexical(str) self.assertEqual(10 + 6, len(lex)) with self.assertRaises(CompileException) as e: syntax.Syntax(lex) print(e.exception) str = "int main() { 3 * (2 + 4) * 1 * }" lex = lexical.Lexical(str) self.assertEqual(10 + 6, len(lex)) with self.assertRaises(CompileException) as e: syntax.Syntax(lex) print(e.exception) str = "int main() { 3 * (2 + 4) * 1 ) }" lex = lexical.Lexical(str) self.assertEqual(10 + 6, len(lex)) with self.assertRaises(CompileException) as e: syntax.Syntax(lex) print(e.exception) str = "int main() { 3 * (2 + 4) * 1 - }" lex = lexical.Lexical(str) self.assertEqual(10 + 6, len(lex)) with self.assertRaises(CompileException) as e: syntax.Syntax(lex) print(e.exception)
def test_global(self): str = "int main() { 3 + x * 2 * -z; }" lex = lexical.Lexical(str) # self.assertEqual(8 + 6, len(lex)) syn = syntax.Syntax(lex) self.assertEqual(9 + 1, syn.size)
def test_if_else(self): str = "int main() { if (3 == 2) { 2 + 1; 4 + 3; } else { 3 + 5; } }" lex = lexical.Lexical(str) self.assertEqual(23 + 6, len(lex)) syn = syntax.Syntax(lex) self.assertEqual(18 + 1, syn.size)
def test_out_addition(self): str = "int main() { out 2 + 1; }" lex = lexical.Lexical(str) self.assertEqual(5 + 6, len(lex)) syn = syntax.Syntax(lex) self.assertEqual(4 + 1, syn.size)
def test_declaration(self): str = "int main() { int a; }" lex = lexical.Lexical(str) self.assertEqual(3 + 6, len(lex)) syn = syntax.Syntax(lex) self.assertEqual(1 + 1, syn.size)
def test_out(self): str = "int main() { out 2; }" lex = lexical.Lexical(str) self.assertEqual(3 + 6, len(lex)) syn = syntax.Syntax(lex) self.assertEqual(2 + 1, syn.size)
def test_affectation(self): str = "int main() { a = 10 + 2; }" lex = lexical.Lexical(str) self.assertEqual(6 + 6, len(lex)) syn = syntax.Syntax(lex) self.assertEqual(4 + 1, syn.size)
def test_if(self): str = "int main() { if (3 == 2) { 2 + 1; 4 + 3; } }" lex = lexical.Lexical(str) self.assertEqual(16 + 6, len(lex)) syn = syntax.Syntax(lex) self.assertEqual(13 + 1, syn.size)
def test_if_malformated(self): str = "if ( 1 || b { 1 + 2; }" lex = lexical.Lexical(str) self.assertEqual(11, len(lex)) with self.assertRaises(CompileException) as e: syntax.Syntax(lex) print(e.exception)
def test_block(self): str = 'int main() { { 3 + 3; 2 +2; } }' lex = lexical.Lexical(str) self.assertEqual(10 + 6, len(lex)) syn = syntax.Syntax(lex) self.assertEqual(9 + 1, syn.size)
def test_statement_equals(self): str = "int main() { 3 == 1; }" lex = lexical.Lexical(str) print(', '.join([t.category.name for t in lex.tokens])) self.assertEqual(4 + 6, len(lex)) syn = syntax.Syntax(lex) self.assertEqual(4 + 1, syn.size)
def test_cond_e(self): str = "3 == 1;" lex = lexical.Lexical(str) print(', '.join([t.category.name for t in lex.tokens])) self.assertEqual(4, len(lex)) syn = syntax.Syntax(lex, run=False) syn.E(lex.current()) self.assertEqual(3, syn.size)
def test_unitary_minus_const(self): str = "-4" lex = lexical.Lexical(str) syn = syntax.Syntax(lex, run=False) node = syn.P(lex.current()) self.assertEqual(syntax.nodes_const.NODE_UNITARY_MINUS, node.type) self.assertEqual(1, len(node.children)) child = node.children[0] self.assertEqual(syntax.nodes_const.NODE_CONSTANT, child.type) self.assertEqual(4, child.value)
def test_unitary_minus_ident(self): str = "-y;" lex = lexical.Lexical(str) syn = syntax.Syntax(lex, run=False) node = syn.P(lex.current()) self.assertEqual(syntax.nodes_const.NODE_UNITARY_MINUS, node.type) self.assertEqual(1, len(node.children)) child = node.children[0] self.assertEqual(syntax.nodes_const.NODE_VAR_REF, child.type) self.assertEqual('y', child.identifier)
def test_cond(self): token_cond = ["&&", "||", "==", "!=", "<", "<=", ">", ">="] for tok in token_cond: print tok str = "int main() { 3 %s 1; }" % tok lex = lexical.Lexical(str) print(', '.join([t.category.name for t in lex.tokens])) self.assertEqual(4 + 6, len(lex)) syn = syntax.Syntax(lex) self.assertEqual(4 + 1, syn.size)
def __init__(self): self._syntax = syntax.Syntax() self._trees = dict() self._roots = dict() self._phis = dict() self._psis = dict() self._trees[self._syntax.implies], self._roots[ self._syntax.implies], self._phis[ self._syntax.implies], self._psis[ self._syntax.implies] = self._createImpliesTree() self._trees[self._syntax.equals], self._roots[ self._syntax.equals], self._phis[self._syntax.equals], self._psis[ self._syntax.equals] = self._createEqualTree() self._trees[self._syntax.lor], self._roots[ self._syntax.lor], self._phis[self._syntax.lor], self._psis[ self._syntax.lor] = self._createOrTree() self._trees[self._syntax.exEventually], self._roots[ self._syntax.exEventually], self._phis[ self._syntax.exEventually] = self._createExEventuallyTree() self._trees[self._syntax.faNext], self._roots[ self._syntax.faNext], self._phis[ self._syntax.faNext] = self._createFaNextTree() self._trees[self._syntax.faUntil], self._roots[ self._syntax.faUntil], self._phis[ self._syntax.faUntil], self._psis[ self._syntax.faUntil] = self._createFaUntilTree() self._trees[self._syntax.faAlways], self._roots[ self._syntax.faAlways], self._phis[ self._syntax.faAlways] = self._createFaAlwaysTree() self._trees[self._syntax.faEventually], self._roots[ self._syntax.faEventually], self._phis[ self._syntax.faEventually] = self._createFaEventuallyTree() self._trees[self._syntax.exWeakUntil], self._roots[ self._syntax.exWeakUntil], self._phis[ self._syntax.exWeakUntil], self._psis[ self._syntax.exWeakUntil] = self._createExWeakUntilTree() self._trees[self._syntax.faWeakUntil], self._roots[ self._syntax.faWeakUntil], self._phis[ self._syntax.faWeakUntil], self._psis[ self._syntax.faWeakUntil] = self._createFaWeakUntilTree()
def main(argv): get_program_parameters(argv) read_input_file() m_lexer = lexer.Lexer(debug) m_lexer.init_lexer(source_content) m_symbol = st.Symbol(debug) m_inter = intermediate.Intermediate(debug, m_symbol) m_syntax = syntax.Syntax(m_lexer, m_symbol, m_inter) m_syntax.run_syntax() m_inter.generate_int_file(m_syntax.get_program_id()) m_inter.generate_c_code(m_syntax.get_program_id()) m_final = final.Final(debug, m_syntax.get_program_id(), m_symbol) m_final.generate_final(m_inter) m_final.generate_out_file(output_file_path) print "\n" + output_file_path + " file has been created." print "\nDone."
def run(str, skip_print=False, out=sys.stdout): nbLineRuntime = len(runtime().split('\n')) - 1 str = runtime() + str tableSymbol = table_symbol.TableSymbol() lex = lexical.Lexical(str, nbLineRuntime) syn = syntax.Syntax(lex) node = syn.node syn.draw() sem = semantic.Semantic(tableSymbol) sem.run(node) node = optimisator.Optimisator(node).node g = gencode.CodeGenerator(node) if not skip_print: print(g.getOutput(), file=out)
def main(): # syntax.MEM_Chack('107H','DW') #print(data.tablet_segment) #teste = syntax.MEM_Chack(123,'DB','HEX') asm_file = open(data.WAYTOASM) tmp_file = open(data.WAYTOLST,'w') count_line = 0 j = 0 ListOfSen = [] SenLine_string = [] SenLine_offset = [] under = 0 Tabl_ID =[] offset = [] #tmp_file.write("0000") for line in asm_file: line = line.replace('\n',''). replace('\t','') lst = LexAn.ParseFileToList(line) if len(lst) == 0: continue # tmp_file.write(line) # tmp_file.write('\n') SenLine = [] SenLine.append([line]) i = 0 count = len(lst) newsenline = [] k = 1 while i < count: _type = LexAn.SetLexemeType(lst[i]) SenLine.append([lst[i], _type]) i += 1 # tmp_file.write(str(i)) #tmp_file.write('\t') #tmp_file.write(lst[i-1]) #tmp_file.write('\t') #if _type != "error" : # tmp_file.write(str(len(lst[i-1]))) #tmp_file.write('\t') #tmp_file.write(_type) newsenline.append([str(i),lst[i-1],_type]) #tmp_file.write(' \n') # print(SenLine[1:]) # ListOfSen.append(syntax.SenLine(SenLine[1:])) #print(syntax.isStartSegment(ListOfSen[j])) #ListOfSen[j].SyntaxSize() #you = syntax.DecToHex(ListOfSen[j].getOffset()) #SenLine_offset.append(you) #SenLine_string.append(SenLine[0][0]) #print(you) #print(SenLine[0][0]) j += 1 # if (data.stopflag == True): # print('(! Error on line {0})'.format(j + 1), file=tmp_file) # break # tmp_file.write('\n') # offset.append('0000') # offset.extend(SenLine_offset) # offset.pop() # print(newsenline) Asew = syntax.Syntax(newsenline) # tmp_file.write(Asew) #tmp_file.write('\n\n') if i == 0: print("0000"+"\t"+line+"\n") else: # print(off + "\t" + line + "\n") off = syntax.sen_offset(lst,Asew, under,newsenline) # syntax.Second(lst,Asew, under,newsenline) # print(syntax.varrr) # print(syntax.code_command) if off == -1: break under = syntax.convert_base(off) # print(off + "\t" + line + "\n") under = int(under) # while() asm_file.close() tmp_file.close() asm_file = open(data.WAYTOASM) tmp_file = open(data.WAYTOLST, 'w') under = 0 for line in asm_file: line = line.replace('\n',''). replace('\t','') lst = LexAn.ParseFileToList(line) if len(lst) == 0: continue SenLine = [] SenLine.append([line]) i = 0 count = len(lst) newsenline = [] k = 1 while i < count: _type = LexAn.SetLexemeType(lst[i]) SenLine.append([lst[i], _type]) i += 1 newsenline.append([str(i),lst[i-1],_type]) j += 1 Asew = syntax.Syntax(newsenline) if i == 0: print("0000"+"\t"+line+"\n") else: # print(off + "\t" + line + "\n") off = syntax.sen_offset(lst,Asew, under,newsenline) syntax.Second(lst,Asew, under,newsenline) if off == -1: break under = syntax.convert_base(off) # print(off + "\t" + line + "\n") under = int(under) # print(syntax.tuor) # print(syntax.OFFSET) # print(syntax.T_D) #print(syntax.varrr) #print(syntax.code_command) tmp_file.write(syntax.PRINT_LST()) tmp_file.write("\nNAME\t\t\tTYPE\t\tVALUE\t\tATTR\t\t\n") tmp_file.write(syntax.PRINT_TABL_IDENT()) tmp_file.write("\nNAME\t\t\tSIZE\t\tLENGTH\t\tCOMBINE CLASS\t\t\n") tmp_file.write(syntax.PRINT_SEGS())
class CtlFormule(object): """ Class that contains the tree for a CTL formula parsed from a configuration file passed during costruction. """ _syntax = syntax.Syntax() _atom = pp.Word(pp.alphas) _true = pp.Literal(_syntax.true) _op = _atom | _true _form = pp.operatorPrecedence(_op, [ (_syntax.lnot, 1, pp.opAssoc.RIGHT), (pp.oneOf(_syntax.land + ' ' + _syntax.lor), 2, pp.opAssoc.LEFT), (pp.oneOf(_syntax.implies + ' ' + _syntax.equals), 2, pp.opAssoc.LEFT), (pp.oneOf(_syntax.exNext + ' ' + _syntax.exAlways + ' ' + _syntax.exEventually + ' ' + _syntax.faNext + ' ' + _syntax.faAlways + ' ' + _syntax.faEventually), 1, pp.opAssoc.RIGHT), (pp.oneOf(_syntax.exUntil + ' ' + _syntax.faUntil + ' ' + _syntax.exWeakUntil + ' ' + _syntax.faWeakUntil), 2, pp.opAssoc.LEFT) ]) def __init__(self, string, loadFromFile=False): self._graph = nx.DiGraph() if loadFromFile: self._loadFromFile(string) else: self._parseNode(self._form.parseString(string)[0], isRoot=True) def _parseNode(self, nodeList, isRoot=False): newId = nx.utils.misc.generate_unique_node() if isinstance(nodeList, str): if nodeList == self._syntax.true: self._graph.add_node(newId, root=isRoot, form=self._syntax.true) else: self._graph.add_node(newId, root=isRoot, form=self._syntax.ap, val=nodeList) elif len(nodeList) == 2: self._graph.add_node(newId, root=isRoot, form=nodeList[0]) self._graph.add_edge(newId, self._parseNode(nodeList[1])) else: #len(nodeList) == 3 self._graph.add_node(newId, root=isRoot, form=nodeList[1]) self._graph.add_edge(newId, self._parseNode(nodeList[0]), son=self._syntax.leftSon) self._graph.add_edge(newId, self._parseNode(nodeList[2]), son=self._syntax.rightSon) return newId def _loadFromFile(self, filename): f = open(filename, 'r') nodesPart = True firstLine = True for line in f: fields = line.split('//')[0].split() if nodesPart and len(fields) == 0: nodesPart = False continue if nodesPart: if (fields[1] == self._syntax.ap): self._graph.add_node(fields[0], root=firstLine, form=fields[1], val=fields[2]) else: self._graph.add_node(fields[0], root=firstLine, form=fields[1]) firstLine = False else: if len(fields) == 3: self._graph.add_edge(fields[0], fields[1], son=fields[2]) else: self._graph.add_edge(fields[0], fields[1]) def draw(self): labels = dict((n, { 'l': n, 'd': d['form'] }) for n, d in self._graph.nodes(data=True)) nx.draw_networkx(self._graph, labels=labels) plt.show() @property def graph(self): return self._graph