def callback(res):
lexical = Lexical()
lexical.get_dfa('./help/dfa.json') # 读取DFA转换表
lexical_res = lexical.lexical_run(str(res).replace(
'\r\n', '\n')) # 得到词法分析的token序列
tokens, nums_attr = [], []
if not lexical_res[0] and not lexical_res[1]:
QMessageBox.warning(self, '输入无效', '请输入有效程序文本')
return
for idx in range(len(
lexical_res[0])): # item[1]为种别码,item[3]为行号,item[2]为属性值
item = lexical_res[0][idx]
if 'comment' not in item[1]:
tokens.append(item[1])
nums_attr.append((item[3], item[2]))
if not self.syntax:
self.syntax = Syntax()
self.syntax.syntax_init('./help/semantic.json')
semantic = Semantic()
res_lst, res_err = semantic.semantic_run(tokens, nums_attr,
self.syntax)
self.semantic_win = QDialog()
ui = semantic_res.Ui_Dialog()
init_win(self.semantic_win, ui)
set_semantic_win(ui, semantic)
def Run(self, event=0):
self.objMain = Main()
self.consoleT.delete(1.0, END)
#open file and write all the IDE code text area content
self.codeFile = open(Main._codeFile, 'w')
self.codeFile.write(self.codeT.get('1.0', END))
self.codeFile.close()
#open file for reading
self.codeFile = open(Main._codeFile, 'rb+')
self.objMain.mainMethod(self.codeFile)
self.codeFile.close()
#write tokens to console area
self.consoleT.insert(1.0, Main._fileData)
#write tokens to test file
self.outputFile = open(Main._outputFile, 'w')
self.outputFile.write(Main._fileData)
self.outputFile.close()
#call syntax
# self.objMain.PROG()
self.objSyntax = Syntax(Main._tokens)
self.objSemantic = Semantic(Main._tokens)
if self.objSyntax.PROG():
print("Code is parsed")
else:
print("there is error in code")
def semantic_info(self): # 语义相关信息
if not self.syntax:
self.syntax = Syntax()
self.syntax.syntax_init('./help/semantic.json')
self.semantic_info_win = QDialog()
ui = semantic_info.Ui_Dialog()
init_win(self.semantic_info_win, ui)
_set_grammar_tbl(ui.grammar_tbl, self.syntax)
def __init__(self, input_phrase: str):
self.input_phrase = input_phrase
self.root = Node()
self.load_config()
self.syntax = Syntax(self.config)
self.parser = Parser(input_phrase, self.config)
self.evaluator = Evaluator(self.eval_config, self.config)
self.output = ""
def grammar(self): # 展示语法分析中可以计算的集合和表
syntax = Syntax()
syntax.syntax_init('./help/syntax.json')
syntax.get_follow()
self.grammar_window = QDialog()
ui = syntax_grammar.Ui_dialog()
init_win(self.grammar_window, ui)
set_grammar_tbl(ui, syntax)
def parse(self, expression):
self.expression = expression
syntactic = Syntax(self.expression)
# try:
self.ast = syntactic.parse()
# except ValueError:
# print("erro!")
# try:
return self.evaluate(self.ast)
def multipleTestCases():
print("=" * 6, "multipleTestCases", "=" * 6)
s = Syntax("testCases/target_test1/lex/out.lex", "none")
s.go()
result = evaluator(s.root.getChild(0).getChild(1))
assertThat((5 - 3) * (8 / 2), result)
s = Syntax("testCases/target_test2/lex/out.lex", "none")
s.go()
result = evaluator(s.root.getChild(0).getChild(1))
assertThat(5 + 1 * 3 - 4 / 5 * 6 - 1 * 2 - 3 * 4, result)
s = Syntax("testCases/target_test4/lex/out.lex", "none")
s.go()
result = evaluator(s.root.getChild(0).getChild(1))
assertThat(24 + 4 - 1 * 3 / 2 + 34 - 1, result)
s = Syntax("testCases/target_test3/lex/out.lex", "none")
s.go()
result = evaluator(s.root.getChild(0).getChild(1))
assertThat(19 - 8 - 7 - 6 - 5 - 4 - 3 - 2 - 1 * (2 + 3 + 4 + 3 + 2),
result)
def syntax_matching(message):
pattern = "^(?P<span>次の?|毎(週|月)|来週の?|来月の?|来年の?)?(?P<days>([0-9]{4}年[0-9]{1,2}月[0-9]{1,2}日|[0-9]{1,2}月[0-9]{1,2}日|[0-9]{1,2}日|末|(第[1-5])?[日月火水木金土]曜日?)+)の?(?P<time>(午前|午後)?[0-9]{1,2}時([0-9]{1,2}分)?|(AM|PM|am|pm)?[0-9]{1,2}:[0-9]{1,2})に?(?P<lab>研究室にいる|研究室の)?(?P<member>B4|M1|M2|awareness|AWARENESS|novel\s?interface|NOVEL\s?INTERFACE|cmc|CMC|全員|人)に(?P<item>\S+)をリマインド$"
#pattern = "^(?P<span>次の?|毎(週|月)|来週の?|来月の?|来年の?)?(?P<days>([0-9]{4}年[0-9]{1,2}月[0-9]{1,2}日|[0-9]{1,2}月[0-9]{1,2}日|[0-9]{1,2}日|末|(第[1-5])?[日月火水木金土]曜日?)+)の?(?P<time>(午前|午後)?[0-9]{1,2}時([0-9]{1,2}分)?|(AM|PM|am|pm)?[0-9]{1,2}:[0-9]{1,2})に?(?P<lab>研究室にいる|研究室の)?(?P<member>B4|M1|M2|awareness|AWARENESS|novel\s?interface|NOVEL\s?INTERFACE|cmc|CMC|全員|人)に?(?P<item>\S+)をリマインド$"
match = re.search(pattern, message)
if match:
print("match")
print(match.group("span"))
s = Syntax(match.group("span"), match.group("days"),
match.group("time"), match.group("lab"),
match.group("member"), match.group("item"))
s.show_all()
return s
else:
print("unmatch")
return False
def main():
print('Welcome to IPOL interpreter!')
# returns lines of string containing the cleaned code
file_reader = FileReader()
# tabs removed, double spaces removed
lines = file_reader.read_file()
tokenizer = Tokenizer()
# returns a 2d list containing the tokens per line of code
tokens_list = tokenizer.tokenize(lines)
tokens_list_copy = tokens_list.copy()
# create instance of the parser with the syntax declared in Syntax class
parser = Parser(syntax=Syntax().get_syntax())
# iterate each line of the list containing the tokens
for line in tokens_list:
recursive_parse(parser, line, callback)
# create a new instance of the parser now with the syntax for recuding operations to expressions
parser = Parser(syntax=Syntax().get_final_syntax())
# Parse to an expression to see if it is valid
for line in parsed_list:
recursive_parse(parser, line, callback1)
exception_checker = ExceptionCheker()
for i in range(len(final_parsed_list)):
# there must be a syntax error because it cannot be converted to a single statement
# check which kind of exception it is
if len(final_parsed_list[i]) > 1:
exception = exception_checker.check_exception(
final_parsed_list[i], i)
if isinstance(exception, IpolException):
exceptions.append(exception)
# now check if the overall structure of the code is valid
# check if there are unused values
# for index, token in enumerate(reduce(final_parsed_list)):
# if token.type == Type.NUMBER or token.type == Type.STR:
# exceptions.append(IpolException(
# ExceptionType.UNUSED_VALUE_ERROR, None, index))
# print exceptions if there are any and halt the build process
if len(exceptions) > 0:
for exception in exceptions:
exception.print()
return
else:
# create a new instance of the parser now with the syntax of the overall ipol code
parser = Parser(syntax=Syntax().get_ipol_syntax())
# finally, verify that the full code is valid
reduced_final_parsed_list = reduce(final_parsed_list)
# recursive_parse(parser, reduced_final_parsed_list, callback2)
reduced_final_parsed_list[:] = (token for token in reduced_final_parsed_list \
if token.type != Type.EMPTY_LINE)
recursive_parse(parser, reduced_final_parsed_list, callback2)
for line in ipol_code_verified:
for token in line:
print(token.type)
# check syntax in class Syntax
# Type.E means accepted
build_failed_message = 'Build Failed.'
try:
if ipol_code_verified[0][0].type == Type.E:
print('Build Successful\n')
else:
print(build_failed_message)
return
except:
print(build_failed_message)
return
# there are no exceptions
# continue with code generation
tokens_list_copy.pop(0)
tokens_list_copy.pop(len(tokens_list_copy) - 1)
generated_code = CodeGenerator().generate(tokens_list_copy)
# this may return a bool data type
if isinstance(generated_code, list):
runnable_code = '\n'.join(generated_code)
runnable_code = runnable_code.replace('&n0', '')
# run the generated python code
with open('ic.py', '+w') as ic:
ic.write(runnable_code)
print('\nBuild Complete.\nView logs on ipol_logs.txt\nView generated code on ic.py\n')
exec(runnable_code, globals())
with open('ipol_logs.txt', '+w') as logs:
text_to_write = 'PARSING LOGS\n\nGENERATED TOKENS\n'
for line in tokens_list:
for token in line:
text_to_write = text_to_write + '{} -> {}'.format(token.type, token.val) + ", "
text_to_write = text_to_write + '\n'
text_to_write = text_to_write + '\PARSED AS...\n'
for line in parsed_list:
for token in line:
text_to_write = text_to_write + str(token.type) + ', '
text_to_write = text_to_write + '\n'
text_to_write = text_to_write + '\nGENERATED INTERMEDIATE CODE\n' + runnable_code
logs.write(text_to_write)
# if bool is returned, that means there was something wrong with the ipol code
else:
print('Build failed')
def __init__(self, code):
self.tabelaSimbolos = {}
self.escopo = "global"
self.tree = Syntax(code).ast
self.programa(self.tree)
self.verificacoes(self.tabelaSimbolos)
def __init__(self, code=""):
self.syntax = Syntax()
self.code = re.sub('\s+', '', code)
self.position = 0
args = parser.parse_args()
if args.source:
abs_file_path = os.path.join(script_dir, args.source)
with open(abs_file_path) as src:
source_code = src.read()
elif args.cmd:
source_code = args.cmd
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
lexer = Lexer(source_code)
syntax = Syntax(lexer)
parse_tree = syntax.parse()
print(1, parse_tree.declarator)
print(2, parse_tree.declarator.identifier)
print(3, parse_tree.next)
print(parse_tree.next.next)
print(parse_tree.next.next.next)
# for node in parse_tree:
# print(node)
Node.proccess_traversal_semantics(parse_tree)
Node.symtable.show()
for error in w:
args = parser.parse_args()
file_path = TEST_PATH if args.test else args.f
if not os.path.isfile(file_path):
raise Exception('File does not exists')
def get_source_text():
with open(file_path, 'r') as source_file:
return source_file.read()
program = get_source_text()
print(
f'source program:\n--------------------\n{program}\n--------------------\n'
)
print('Starting Lexical Analysis')
lexer = Lexer()
token_list = lexer.tokenize(program)
print('Token list:')
pprint(token_list)
print('Starting Syntax Analyzer')
syntax = Syntax(token_list)
result = syntax.run()
if result:
print('Syntax analyzer run successfully')
def sintactic(file, outputType):
syntax = Syntax(file, outputType)
global syntaxTree
syntaxTree = syntax.go(file)
from utils import load, gui_l
from lexer import Lexer
from sys import argv
from syntax import Syntax
import os
import webbrowser
Syntax(Lexer(load('code.for')).get_tokens(''),
debug="all").export_to_file('syntax.dot')
os.system("dot syntax.dot -Tpng -o syntax.png")
# Gambiarra Fedorenta.
#os.system('%SystemRoot%\\System32\\rundll32.exe "%ProgramFiles%\\Windows Photo Viewer\\PhotoViewer.dll", ImageView_Fullscreen D:\\Google Drive\\Computação\\Atual\\_Working\\Compiler\\syntax.png')
webbrowser.get(
"C:/Program Files (x86)/Google/Chrome/Application/chrome.exe %s"
).open_new(
"file:///D:/Google%20Drive/Computa%C3%A7%C3%A3o/Atual/_Working/Compiler/syntax.png"
)
'''
if __name__ == '__main__':
if len(argv) > 1:
if '-gui' in argv:
argv.remove('-gui')
gui_l(Lexer(load(argv[1])).get_tokens())
else:
Lexer(load(argv[1]),verbose=True).get_tokens()
else:
Lexer(load('code.for'),verbose=True).get_tokens()
'''
from lexer import Lexer
from syntax import Syntax
import os, webbrowser, time, sys
now = time.time()
#Syntax(Lexer('code.for').run()).export_to_file('syntax.dot')
if 'debug' in sys.argv: Syntax(Lexer('code.for').run(), debug=True).start()
else: Syntax(Lexer('code.for').run(), debug=False).start()
done = time.time()
#print(done - now) # imrpime tempo levado para análise
# Graphviz - Converter o arquivo .dot gerado em uma imagem PNG
#os.system("dot syntax.dot -Tpng -o syntax.png")
# Abrir o arquivo no Chrome
#webbrowser.get("C:/Program Files (x86)/Google/Chrome/Application/chrome.exe %s").open_new("file:///D:/Google%20Drive/Computa%C3%A7%C3%A3o/Atual/_Working/Compiler/syntax.png")