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
