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 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 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 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 load_procedure(cls, concept_id, list_id, handler_variables):
cls.__procedures.append([])
index = len(cls.__procedures) - 1
query = "SELECT id, prev_line_id, text FROM qsl_list WHERE concept_id = " + str(
list_id) + ";"
cls.__cursor.execute(query)
row = cls.__cursor.fetchone()
rows = []
while (row != None):
rows.append(row)
row = cls.__cursor.fetchone()
if DebuggerProvider.use == True:
dbg_procedure = DebuggerProcedure(list_id, "name_of_procedure")
i = 1
for row in rows:
is_comment = False
if row[2][:1] == '#' or row[2][:2] == '//':
is_comment = True
if is_comment == False:
code_line = CodeLine()
code_line.id = row[0]
code_line.concept_id = list_id
code_line.prev_line_id = row[1]
code_line.text = row[2]
SyntaxAnalyzer.analize(code_line.text)
code_line.tree = SyntaxAnalyzer.proposition_tree
#PropositionTree.print_tree (code_line.tree)
cls.__procedures[index].append(code_line)
cls.__procedures_keys[concept_id] = index
if DebuggerProvider.use == True:
dbg_code_line = DebuggerCodeLine()
dbg_code_line.internal_id = i
dbg_code_line.external_id = row[0]
dbg_code_line.text = row[2]
dbg_procedure.append_line(dbg_code_line)
i += 1
if is_comment == False:
# Раскрытие вложенных суждений
node = code_line.tree.root_node
if 1 != 1: #node.text == "создавать":
node.child_index = 0
side = None
error_text = ""
k = 0
while node != None:
if node.child_index == 0:
if node.type == PropositionTreeNodeType.concept:
if node.concept.subroot == True:
child, error_text = PropositionTree.replace_subtree(
node, side, True, cls.__cursor)
if child != None:
parent.children[0] = child
else:
side = node.side
if node.child_index < len(node.children):
idx = node.child_index
node.child_index += 1
code_line.tree.push_node(node)
parent = node
node = node.children[idx]
node.child_index = 0
k += 1
else:
node = code_line.tree.pop_node()
k -= 1
#PropositionTree.print_tree (code_line.tree)
#continue
#Поиск всех переменных в коде
node = code_line.tree.root_node
node.child_index = 0
field_id = None
list1_id = None
element1_id = None
k = 0
parent = None
while node != None:
if node.child_index == 0:
if node.type == PropositionTreeNodeType.concept:
if node.concept.type == TreeNodeConceptType.field or \
node.concept.type == TreeNodeConceptType.element:
pass
elif node.concept.type == TreeNodeConceptType.definition:
field_id = MemoryProvider.get_field_id(
node.concept.name)
s = ""
if field_id != None:
#print parent.text, node.concept.name, field_id
node1 = node.parent
while node1 != None:
if s != "":
s = node1.text + '_' + s
else:
s = node1.text
node1 = node1.parent
else:
list1_id = MemoryProvider.get_list_id(
node.concept.name)
if list1_id != None:
#print parent.text, node.concept.name, list1_id
node1 = node.parent
while node1 != None:
#print node1.text
if node1.text == "элемент":
i = 0
node2 = node1.children[i]
while node2 != None and node2.text != "?какой":
node2 = node1.children[i]
i += 1
if node2 != None and node2.text == "?какой":
node2 = node2.children[0]
if node2.type == PropositionTreeNodeType.number:
element1_id = int(
node2.text)
if s != "":
s = node1.text + '_' + s
else:
s = node1.text
node1 = node1.parent
if s != "":
i = None
vi = 0
for v in handler_variables.variables:
if field_id != None:
if v[:1] == 'F':
if int(v[1:]) == field_id:
i = vi
break
elif list1_id != None:
if v[:1] == 'L':
n = v.find('.')
if n != 0:
if int(v[1:n]) == list1_id:
i = vi
break
vi += 1
if i == None:
if field_id != None:
object_key = 'F' + str(field_id)
handler_variables.variables.append(
object_key)
elif list1_id != None:
object_key = 'L' + str(
list1_id) + '.' + str(
element1_id)
handler_variables.variables.append(
object_key)
if s == cls.TEMPL1 or s == cls.TEMPL2 or s == cls.TEMPL3 \
or s == cls.TEMPL4 or s == cls.TEMPL5:
#print s
handler_variables.changeable.append(
True)
else:
#print s
handler_variables.changeable.append(
False)
else:
if s == cls.TEMPL1 or s == cls.TEMPL2 or s == cls.TEMPL3 \
or s == cls.TEMPL4 or s == cls.TEMPL5:
#print s
if handler_variables.changeable[
i] == False:
handler_variables.changeable[
i] = True
if node.child_index < len(node.children):
idx = node.child_index
node.child_index += 1
code_line.tree.push_node(node)
parent = node
node = node.children[idx]
node.child_index = 0
k += 1
else:
node = code_line.tree.pop_node()
k -= 1
if DebuggerProvider.use == True:
DebuggerProvider.register_procedure(dbg_procedure)
cls.__handler_variables.append(handler_variables)
def load_procedure (cls, concept_id, list_id, handler_variables):
cls.__procedures.append ([])
index = len (cls.__procedures)-1
query = "SELECT id, prev_line_id, text FROM qsl_list WHERE concept_id = " + str (list_id) + ";"
cls.__cursor.execute (query)
row = cls.__cursor.fetchone ()
rows = []
while (row != None):
rows.append (row)
row = cls.__cursor.fetchone ()
if DebuggerProvider.use == True:
dbg_procedure = DebuggerProcedure (list_id, "name_of_procedure")
i = 1
for row in rows:
is_comment = False
if row[2][:1] == '#' or row[2][:2] == '//':
is_comment = True
if is_comment == False:
code_line = CodeLine ()
code_line.id = row[0]
code_line.concept_id = list_id
code_line.prev_line_id = row[1]
code_line.text = row[2]
SyntaxAnalyzer.analize (code_line.text)
code_line.tree = SyntaxAnalyzer.proposition_tree
#PropositionTree.print_tree (code_line.tree)
cls.__procedures[index].append (code_line)
cls.__procedures_keys[concept_id] = index
if DebuggerProvider.use == True:
dbg_code_line = DebuggerCodeLine ()
dbg_code_line.internal_id = i
dbg_code_line.external_id = row[0]
dbg_code_line.text = row[2]
dbg_procedure.append_line (dbg_code_line)
i += 1
if is_comment == False:
# Раскрытие вложенных суждений
node = code_line.tree.root_node
if 1!=1: #node.text == "создавать":
node.child_index = 0
side = None
error_text = ""
k = 0
while node != None:
if node.child_index == 0:
if node.type == PropositionTreeNodeType.concept:
if node.concept.subroot == True:
child, error_text = PropositionTree.replace_subtree (node, side, True, cls.__cursor)
if child != None:
parent.children[0] = child
else:
side = node.side
if node.child_index < len (node.children):
idx = node.child_index
node.child_index += 1
code_line.tree.push_node (node)
parent = node
node = node.children[idx]
node.child_index = 0
k += 1
else:
node = code_line.tree.pop_node ()
k -= 1
#PropositionTree.print_tree (code_line.tree)
#continue
#Поиск всех переменных в коде
node = code_line.tree.root_node
node.child_index = 0
field_id = None
list1_id = None
element1_id = None
k = 0
parent = None
while node != None:
if node.child_index == 0:
if node.type == PropositionTreeNodeType.concept:
if node.concept.type == TreeNodeConceptType.field or \
node.concept.type == TreeNodeConceptType.element:
pass
elif node.concept.type == TreeNodeConceptType.definition:
field_id = MemoryProvider.get_field_id (node.concept.name)
s = ""
if field_id != None:
#print parent.text, node.concept.name, field_id
node1 = node.parent
while node1 != None:
if s != "":
s = node1.text + '_' + s
else:
s = node1.text
node1 = node1.parent
else:
list1_id = MemoryProvider.get_list_id (node.concept.name)
if list1_id != None:
#print parent.text, node.concept.name, list1_id
node1 = node.parent
while node1 != None:
#print node1.text
if node1.text == "элемент":
i = 0
node2 = node1.children[i]
while node2 != None and node2.text != "?какой":
node2 = node1.children[i]
i += 1
if node2 != None and node2.text == "?какой":
node2 = node2.children[0]
if node2.type == PropositionTreeNodeType.number:
element1_id = int (node2.text)
if s != "":
s = node1.text + '_' + s
else:
s = node1.text
node1 = node1.parent
if s != "":
i = None
vi = 0
for v in handler_variables.variables:
if field_id != None:
if v[:1] == 'F':
if int (v[1:]) == field_id:
i = vi
break
elif list1_id != None:
if v[:1] == 'L':
n = v.find ('.')
if n != 0:
if int (v[1:n]) == list1_id:
i = vi
break
vi += 1
if i == None:
if field_id != None:
object_key = 'F' + str (field_id)
handler_variables.variables.append (object_key)
elif list1_id != None:
object_key = 'L' + str (list1_id) + '.' + str (element1_id)
handler_variables.variables.append (object_key)
if s == cls.TEMPL1 or s == cls.TEMPL2 or s == cls.TEMPL3 \
or s == cls.TEMPL4 or s == cls.TEMPL5:
#print s
handler_variables.changeable.append (True)
else:
#print s
handler_variables.changeable.append (False)
else:
if s == cls.TEMPL1 or s == cls.TEMPL2 or s == cls.TEMPL3 \
or s == cls.TEMPL4 or s == cls.TEMPL5:
#print s
if handler_variables.changeable[i] == False:
handler_variables.changeable[i] = True
if node.child_index < len (node.children):
idx = node.child_index
node.child_index += 1
code_line.tree.push_node (node)
parent = node
node = node.children[idx]
node.child_index = 0
k += 1
else:
node = code_line.tree.pop_node ()
k -= 1
if DebuggerProvider.use == True:
DebuggerProvider.register_procedure (dbg_procedure)
cls.__handler_variables.append (handler_variables)
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()
