def __init__(self, file):
'''
Constructor
'''
self.file = file
self.mem = list()
self.lex = LexicalAnalyzer(file)
self.parse(self.lex)
def parse_new_object(queue):
if len(queue) == 0:
print("ERROR: Code Not Complete: Expected an Object")
raise SystemExit
else:
value = queue[0][1]
if value == "int":
queue.pop(0)
validate(queue, "[")
exp = parse_expression(queue)
throw_exception_expression(exp)
validate(queue, "]")
n = NewObject1(exp)
return n
elif LexicalAnalyzer.is_id(value):
i = parse_identifier(queue)
validate(queue, "(")
validate(queue, ")")
n = NewObject2(i)
return n
else:
print("ERROR: Code Not Complete: Expected an Object at line", queue[0][0])
raise SystemExit
def parse_dot(queue):
if len(queue) == 0:
print("ERROR: Code Not Complete: Expected a method call")
raise SystemExit
else:
value = queue[0][1]
if value == "length":
queue.pop(0)
d = Dot1()
return d
elif LexicalAnalyzer.is_id(value):
i = parse_identifier(queue)
validate(queue, "(")
exp_one = parse_exp_only_one(queue)
exp = parse_exp(queue)
validate(queue, ")")
d = Dot2(i, exp_one, exp)
return d
else:
print("ERROR: Code Not Complete: Expected a method call at line", queue[0][0])
raise SystemExit
def __init__(self, file):
'''
Constructor
'''
self.file = file
self.mem = list()
self.lex = LexicalAnalyzer(file)
self.parse(self.lex)
def compile_handler(self, event):
self.text_area_bottom.delete('1.0', END)
text = self.text_area_top.get('1.0', END)
lexer = LexicalAnalyzer(text)
try:
(t_lexemes, t_idns, t_constants) = lexer.run()
sAn = SyntaxAnalyzer2(t_lexemes, t_idns, t_constants,
transition_table.transition_table)
state_table = sAn.run()
if state_table == True:
state_table = None
# text2="".join(tablesToString(t_lexemes,t_idns,t_constants))
text2 = "".join(
makeTables(t_lexemes, t_idns, t_constants, state_table))
self.text_area_bottom.insert(1.0, text2)
except TranslatorException as ex:
self.text_area_bottom.insert(
1.0, ex.__class__.__name__ + "\n" + str(ex))
def parse_integer_literal(queue):
if len(queue) == 0:
print("ERROR: Expected an integer")
raise SystemExit
token = queue.pop(0)
if not LexicalAnalyzer.is_integer_literal(token[1]):
print("ERROR: Not an integer at line", token[0])
raise SystemExit
return token[1]
def __init__(self, filename):
self.filename = filename
self.p2File = open(self.filename[:-3] + ".p2", "a")
self.ct = ""
self.lex = LA.LexicalAnalyzer(filename.encode("utf-8"))
self.rule_mappings = {
1: self.program,
2: self.define,
3: self.more_defines,
4: self.stmt_list,
5: self.stmt,
6: self.literal,
7: self.quoted_lit,
8: self.more_tokens,
9: self.param_list,
10: self.else_part,
11: self.stmt_pair,
12: self.stmt_pair_body,
13: self.action,
14: self.any_other_token
}
def parse_identifier(queue):
if len(queue) == 0:
print("ERROR: Expected an identifier")
raise SystemExit
token = queue.pop(0)
if not LexicalAnalyzer.is_id(token[1]):
print("Not a correct identifier at line", token[0])
raise SystemExit
if token[1] == "public" or token[1] == "static" \
or token[1] == "void" or token[1] == "main" \
or token[1] == "int" or token[1] == "float" \
or token[1] == "if" or token[1] == "else" or token[1] == "while" \
or token[1] == "String" or token[1] == "char" or token[1] == "boolean" \
or token[1] == "extends" or token[1] == "return" or token[1] == "new" \
or token[1] == "this" or token[1] == "true" or token[1] == "false" or token[1] == "class":
print("Using keyword as an identifier at line", token[0])
raise SystemExit
return token[1]
elif transition['nezr'] == self.ERROR:
# raise SyntaxException("{} \n state = {}, lexeme_code = {}, lexeme = {}, stack = {}".format(
# transition['error_msg'], self.cur_state, lexeme_code, self.lexemes[self.i].name, self.stack,))
raise SyntaxException(transition['error_msg'],
self.line() - 1)
def exit(self):
# print("EXIT")
self.i -= 1
try:
state = self.stack.pop()
self.cur_state = state
except IndexError as ex:
pass
if __name__ == "__main__":
FILE_NAME = 'source.txt'
file = open(FILE_NAME, 'r')
input_text = file.read()
file.close()
lexer = LexicalAnalyzer(input_text)
# (t_lexemes,t_idns,t_constants) = lexer.run()
# text="".join(tablesToString(t_lexemes,t_idns,t_constants))
# print(text)
tableMaker = RelationTableMaker(grammar.grammar)
# relation_table = tableMaker.getRelationTable()
sAn = SyntaxAnalyzer3(*lexer.run(), tableMaker)
# sAn.run()
print(*sAn.run(), sep="\n")
import LexicalRulesParser
import Thompson
import Subset
import LexicalAnalyzer
rules = LexicalRulesParser.start_parsing('inputs/lexical.txt')
nfas = Thompson.Nfa.compile(rules)
dfas = []
for nfa in nfas:
dfas.append(Subset.Subset.nfa_to_dfa(nfa))
# for dfa in dfas:
# print('DFA: {}'.format(dfa.name))
# for dfaState in dfa.Dstates:
# print('({})'.format(dfaState.name) if dfaState.is_accept else '{}'.format(dfaState.name))
# for symb in dfaState.trans:
# print('{} => {} | '.format(symb, dfaState.trans[symb]), end='')
# print('\n')
# print('\n\n')
lexical_analyzer = LexicalAnalyzer.LexicalAnalyzer(dfas, rules['priorities'])
print(lexical_analyzer.parse_code('inputs/program.txt'))
def parse_expression(queue):
if len(queue) == 0:
print("ERROR: Code Not Complete: Expected an expression")
raise SystemExit
else:
value = queue[0][1]
if LexicalAnalyzer.is_integer_literal(value):
queue.pop(0)
e_rec = parse_expression_recursion_fix(queue)
e1 = Expression1(value, e_rec)
return e1
elif value == "true":
queue.pop(0)
e_rec = parse_expression_recursion_fix(queue)
e2 = Expression2(e_rec)
return e2
elif value == "false":
queue.pop(0)
e_rec = parse_expression_recursion_fix(queue)
e3 = Expression3(e_rec)
return e3
elif value == "this":
queue.pop(0)
e_rec = parse_expression_recursion_fix(queue)
e5 = Expression5(e_rec)
return e5
elif value == "new":
queue.pop(0)
n = parse_new_object(queue)
e_rec = parse_expression_recursion_fix(queue)
e6 = Expression6(n, e_rec)
return e6
elif value == "!":
queue.pop(0)
exp = parse_expression(queue)
throw_exception_expression(exp)
e_rec = parse_expression_recursion_fix(queue)
e7 = Expression7(exp, e_rec)
return e7
elif value == "(":
queue.pop(0)
exp = parse_expression(queue)
throw_exception_expression(exp)
validate(queue, ")")
e_rec = parse_expression_recursion_fix(queue)
e8 = Expression8(exp, e_rec)
return e8
elif LexicalAnalyzer.is_id(value):
i = parse_identifier(queue)
e_rec = parse_expression_recursion_fix(queue)
e4 = Expression4(i, e_rec)
return e4
else:
e = Epsilon()
return e
def parse_statement(queue):
if len(queue) == 0:
print("ERROR: Code Not Complete: Expected a Statement")
raise SystemExit
else:
value = queue[0][1]
if value == "{":
queue.pop(0)
st = parse_st(queue)
validate(queue, "}")
s = Statement1(st)
return s
elif value == "if":
queue.pop(0)
validate(queue, "(")
exp = parse_expression(queue)
throw_exception_expression(exp)
validate(queue, ")")
s = parse_statement(queue)
el = parse_else(queue)
s2 = Statement2(exp, s, el)
return s2
elif value == "while":
queue.pop(0)
validate(queue, "(")
exp = parse_expression(queue)
throw_exception_expression(exp)
validate(queue, ")")
s = parse_statement(queue)
s3 = Statement3(exp, s)
return s3
elif value == "System.out.println":
queue.pop(0)
validate(queue, "(")
exp = parse_expression(queue)
throw_exception_expression(exp)
validate(queue, ")")
validate(queue, ";")
s4 = Statement4(exp)
throw_exception_expression(exp)
return s4
elif LexicalAnalyzer.is_id(value):
i = parse_identifier(queue)
si = parse_single_or_array(queue)
s5 = Statement5(i, si)
return s5
else:
e = Epsilon()
return e
print("ERROR: Code Not Complete: expected \"" + expected_value + "\"")
raise SystemExit
else:
value = queue.pop(0)
if value[1] != expected_value:
print("ERROR: Expected \"" + expected_value + "\" found: \"" + value[1] + "\" at line", value[0])
raise SystemExit
def check_if_epsilon(queue, expected_value):
if len(queue) == 0 or queue[0][1] != expected_value:
return True
else:
return False
def throw_exception_expression(expression):
if type(expression) == Epsilon:
print("ERROR: Expected an expression")
raise SystemExit
files = LexicalAnalyzer.open_file()
lex = LexicalAnalyzer.tokenize(files[0], files[1])
goal = parse_goal(lex)
print(goal.get_value(), "\nCode Executed Successfully")
import LexicalAnalyzer
code = open('sample1.scb', 'r')
tokens = LexicalAnalyzer.tokenizer(code.read())
print("Tokens for Sample 1")
for s in tokens:
print(s + ", ", end="")
code = open('sample2.scb', 'r')
tokens = LexicalAnalyzer.tokenizer(code.read())
print("\n\nTokens for Sample 2")
for s in tokens:
print(s + ", ", end="")
code = open('sample3.scb', 'r')
tokens = LexicalAnalyzer.tokenizer(code.read())
print("\n\nTokens for Sample 3")
for s in tokens:
print(s + ", ", end="")
print('\n')
class Parser(object):
'''
classdocs
'''
def __init__(self, file):
'''
Constructor
'''
self.file = file
self.mem = list()
self.lex = LexicalAnalyzer(file)
self.parse(self.lex)
def parse(self, lex):
lex = self.lex
Parser.match(self, "main")
Parser.match(self, "(")
Parser.match(self, ")")
l = self.getStatementList()
s = lex.getToken()
if s != "$":
raise ParserException("Garbage")
self.execute(l)
def getStatementList(self):
l = []
s = self.getStatement()
l.append(s)
tok = self.lex.getLookAheadToken()
while tok == ";":
tok = self.lex.getToken()
s = self.getStatement()
l.append(s)
tok = self.lex.getLookAheadToken()
return l
def getStatement(self):
s = self.lex.getLookAheadToken()
if s == "if":
stmt = self.getIfStatement()
elif s == "while":
stmt = self.getWhileStatement()
elif s == "display":
stmt = self.getDisplayStatement()
else:
stmt = self.getAssignmentStatement()
return stmt
def getAssignmentStatement(self):
var = self.lex.getToken()
self.match("<-")
expr = self.getArithmeticExpression()
return AssignmentStatement(var, expr)
def getArithmeticExpression(self):
s = self.lex.getLookAheadToken()
if self.isValidArithmeticOp(s):
op = self.lex.getToken()
op1 = self.getOperand()
op2 = self.getOperand()
expr = self.createBinaryExpression(op, op1, op2)
else:
expr = self.getOperand()
return expr
def createBinaryExpression(self, op, op1, op2):
if op == "+":
expr = AddExpression(op1, op2)
elif op == "-":
expr = SubExpression(op1, op2)
elif op == "*":
expr = MulExpression(op1, op2)
else:
expr = DivExpression(op1, op2)
return expr
def getDisplayStatement(self):
self.match("display")
self.match("(")
var = self.getId()
self.match(")")
return DisplayStatement(var)
def getId(self):
s = self.lex.getToken()
if s == "" or len(s) > 1:
raise ParserException("id expected, received " + s)
return Id(s)
def getWhileStatement(self):
self.match("while")
expr = self.getBooleanExpression()
self.match("do")
l = self.getStatementList()
self.match("end")
return WhileStatement(expr, l)
def getBooleanExpression(self):
s = self.lex.getLookAheadToken()
if self.isValidBooleanOperator(s):
op = self.lex.getToken()
op1 = self.getOperand()
op2 = self.getOperand()
return self.createBooleanExpression(op, op1, op2)
def createBooleanExpression(self, op, op1, op2):
self.op = op
self.op1 = op1
self.op2 = op2
if self.op == "=":
expr = EQExpression(op1, op2)
elif op == "/=":
expr = NEExpression(op1, op2)
elif op == ">":
expr = GTExpression(op1, op2)
elif op == ">=":
expr = GEExpression(op1, op2)
elif op == "<":
expr = LTExpression(self, op1, op2)
else:
expr = LEExpression(op1, op2)
return expr
def getOperand(self):
s = self.lex.getLookAheadToken()
if s == "":
raise ParserException("Operand Expected")
elif s.isdigit():
op = self.getLiteralInteger()
else:
op = s
return op
def getLiteralInteger(self):
s = self.lex.getToken()
try:
return int(s)
except ValueError:
raise ParserException("literal integer expected")
def getIfStatement(self):
self.match("if")
expr = self.getBooleanExpression()
self.match("then")
l1 = self.getStatementList()
self.match("else")
l2 = self.getStatementList()
self.match("end")
return IfStatement(expr, l1, l2)
def isValidBooleanOperator(self, s):
self.s = s
if s == "=" or s == "/=" or s == ">" or s == "<" or s == ">=" or s == "<=":
return True
else:
return False
def isValidArithmeticOp(self, s):
self.s = s
if s == "+" or s == "-" or s =="*" or s == "/":
return True
else:
return False
def match(self, expected):
self.expected = expected
self.tok = self.lex.getToken()
if expected != self.tok:
raise ParserException("token equals " + self.tok + " and " +self.expected + " expected")
def execute(self, statementList):
self.statementList = statementList
i = 0
while statementList != () :
s = statementList.pop(i)
i += 1
s.execute(self)
def store(self, ch, value):
ch1 = str(ch)
ch1.strip()
self.mem.insert((ord(ch1)-ord('a')), value)
def fetch(self, ch):
ch1 = str(ch)
ch1.strip()
print(ch1)
value = self.mem.pop(ord(ch1)-ord('a'))
self.mem.insert(ord(ch1)-ord('a'))
return value
import sys
import LexicalAnalyzer
from LEXER_DATA import regexes
#COMMAND LINE RUN STATEMENT: python src/main.py testcases/test2.txt error.txt tokens.txt category.txt
codeFileName = sys.argv[1]
errorFileName = sys.argv[2]
tokFileName = sys.argv[3]
catFileName = sys.argv[4]
lerror = 0
LexicalAnalyzer.controlLexer(tokFileName, errorFileName, codeFileName,
catFileName, lerror)
if self.lexeme(31):
self.i += 1
return True
else:
raise SyntaxException("Відсутня закриваюча дужка )",
self.line())
else:
raise SyntaxException("Відсутній вираз", self.line())
return False
def idn(self):
if self.lexeme(100) or self.lexeme(102):
self.i += 1
return True
return False
if __name__ == "__main__":
FILE_NAME = 'source.txt'
file = open(FILE_NAME, 'r')
input_text = file.read()
file.close()
lexer = LexicalAnalyzer(input_text)
# (t_lexemes,t_idns,t_constants) = lexer.run()
# text="".join(tablesToString(t_lexemes,t_idns,t_constants))
# print(text)
sAn = SyntaxAnalyzer(*lexer.run())
print(sAn.run())
def main():
file_name = "test1.jl"
lex = LexicalAnalyzer.LexicalAnalyzer("test1.jl")
def saveFiles():
global ptStack
fname = filename.split('.', 1)[0]
with open(fname + '.err', "a") as myfile:
for i in errorList:
myfile.write(i + '\n')
ptStack = ptStack[::-1]
for i in ptStack:
a = 'Exiting: ' + i
pt.append(a)
f = open(fname + '.tr', "w+")
for i in pt:
f.write(i + '\n')
f.close()
filename = 'test11.pj'
tokenList, errorList, symbolTable = la.lexMain(filename)
print('ErrorList: ', errorList)
start()
saveFiles()
#Wla.saveFiles(tokenList,errorList, symbolTable)
class Parser(object):
'''
classdocs
'''
def __init__(self, file):
'''
Constructor
'''
self.file = file
self.mem = list()
self.lex = LexicalAnalyzer(file)
self.parse(self.lex)
def parse(self, lex):
lex = self.lex
Parser.match(self, "main")
Parser.match(self, "(")
Parser.match(self, ")")
l = self.getStatementList()
s = lex.getToken()
if s != "$":
raise ParserException("Garbage")
self.execute(l)
def getStatementList(self):
l = []
s = self.getStatement()
l.append(s)
tok = self.lex.getLookAheadToken()
while tok == ";":
tok = self.lex.getToken()
s = self.getStatement()
l.append(s)
tok = self.lex.getLookAheadToken()
return l
def getStatement(self):
s = self.lex.getLookAheadToken()
if s == "if":
stmt = self.getIfStatement()
elif s == "while":
stmt = self.getWhileStatement()
elif s == "display":
stmt = self.getDisplayStatement()
else:
stmt = self.getAssignmentStatement()
return stmt
def getAssignmentStatement(self):
var = self.lex.getToken()
self.match("<-")
expr = self.getArithmeticExpression()
return AssignmentStatement(var, expr)
def getArithmeticExpression(self):
s = self.lex.getLookAheadToken()
if self.isValidArithmeticOp(s):
op = self.lex.getToken()
op1 = self.getOperand()
op2 = self.getOperand()
expr = self.createBinaryExpression(op, op1, op2)
else:
expr = self.getOperand()
return expr
def createBinaryExpression(self, op, op1, op2):
if op == "+":
expr = AddExpression(op1, op2)
elif op == "-":
expr = SubExpression(op1, op2)
elif op == "*":
expr = MulExpression(op1, op2)
else:
expr = DivExpression(op1, op2)
return expr
def getDisplayStatement(self):
self.match("display")
self.match("(")
var = self.getId()
self.match(")")
return DisplayStatement(var)
def getId(self):
s = self.lex.getToken()
if s == "" or len(s) > 1:
raise ParserException("id expected, received " + s)
return Id(s)
def getWhileStatement(self):
self.match("while")
expr = self.getBooleanExpression()
self.match("do")
l = self.getStatementList()
self.match("end")
return WhileStatement(expr, l)
def getBooleanExpression(self):
s = self.lex.getLookAheadToken()
if self.isValidBooleanOperator(s):
op = self.lex.getToken()
op1 = self.getOperand()
op2 = self.getOperand()
return self.createBooleanExpression(op, op1, op2)
def createBooleanExpression(self, op, op1, op2):
self.op = op
self.op1 = op1
self.op2 = op2
if self.op == "=":
expr = EQExpression(op1, op2)
elif op == "/=":
expr = NEExpression(op1, op2)
elif op == ">":
expr = GTExpression(op1, op2)
elif op == ">=":
expr = GEExpression(op1, op2)
elif op == "<":
expr = LTExpression(self, op1, op2)
else:
expr = LEExpression(op1, op2)
return expr
def getOperand(self):
s = self.lex.getLookAheadToken()
if s == "":
raise ParserException("Operand Expected")
elif s.isdigit():
op = self.getLiteralInteger()
else:
op = s
return op
def getLiteralInteger(self):
s = self.lex.getToken()
try:
return int(s)
except ValueError:
raise ParserException("literal integer expected")
def getIfStatement(self):
self.match("if")
expr = self.getBooleanExpression()
self.match("then")
l1 = self.getStatementList()
self.match("else")
l2 = self.getStatementList()
self.match("end")
return IfStatement(expr, l1, l2)
def isValidBooleanOperator(self, s):
self.s = s
if s == "=" or s == "/=" or s == ">" or s == "<" or s == ">=" or s == "<=":
return True
else:
return False
def isValidArithmeticOp(self, s):
self.s = s
if s == "+" or s == "-" or s == "*" or s == "/":
return True
else:
return False
def match(self, expected):
self.expected = expected
self.tok = self.lex.getToken()
if expected != self.tok:
raise ParserException("token equals " + self.tok + " and " +
self.expected + " expected")
def execute(self, statementList):
self.statementList = statementList
i = 0
while statementList != ():
s = statementList.pop(i)
i += 1
s.execute(self)
def store(self, ch, value):
ch1 = str(ch)
ch1.strip()
self.mem.insert((ord(ch1) - ord('a')), value)
def fetch(self, ch):
ch1 = str(ch)
ch1.strip()
print(ch1)
value = self.mem.pop(ord(ch1) - ord('a'))
self.mem.insert(ord(ch1) - ord('a'))
return value
import LexicalAnalyzer
while True:
text = input('Icarus >>> ')
result, error = LexicalAnalyzer.run('<stdin>', text)
if error: print(error.as_string())
else: print(result)
def Main (): tokens = LA.LexicalAnalyzer () #LA.PrintTokens (tokens) SemanticTable = SA.SyntacticAnalyzer(tokens)
import LexicalAnalyzer
import SyntaxAnalyzer
code = open('sample1.scb', 'r')
tokens = LexicalAnalyzer.tokenizer(code.read())
print("Syntax Error for Sample 1")
SyntaxAnalyzer.parser(tokens)
print('\n')
#code = open('sample2.scb', 'r')
#tokens = LexicalAnalyzer.tokenizer(code.read())
#print("Syntax Error for Sample 2")
#SyntaxAnalyzer.parser(tokens)
#print('\n')
#code = open('sample3.scb', 'r')
#tokens = LexicalAnalyzer.tokenizer(code.read())
#print("Syntax Error for Sample 3")
#SyntaxAnalyzer.parser(tokens)
#print('\n')
#code = open('sample4.scb', 'r')
#tokens = LexicalAnalyzer.tokenizer(code.read())
#print("Syntax Error for Sample 4")
#SyntaxAnalyzer.parser(tokens)
#print('\n')
#code = open('sample5.scb', 'r')
#tokens = LexicalAnalyzer.tokenizer(code.read())
#print("Syntax Error for Sample 5")
#SyntaxAnalyzer.parser(tokens)
def getIndex(ch):
if LexicalAnalyzer.isValidIdentifier(ch):
return (ord(ch) - 65)
else:
raise ValueError(str(ch) + ' is not a valid identifier')
def lexicalAnalysis():
global tab1, tab2, tab3, text2
tab1.destroy()
tab1 = Frame(tabControl)
tabControl.add(tab1, text='Таблица лексем')
tab2.destroy()
tab2 = Frame(tabControl)
tabControl.add(tab2, text='Таблица переменных')
tab3.destroy()
tab3 = Frame(tabControl)
tabControl.add(tab3, text='Таблица констант')
code = codeArea.get("0.0", END)
lex_list, var_list, con_list = LexicalAnalyzer.analyze(code)
try:
SyntaxAnalyzer.analyze(lex_list, var_list, con_list)
poliz_list = PolishCodeGenerator.generatePOLIZ(lex_list, var_list, con_list)
for element in poliz_list:
print(element[1] + " ", end="")
Output_text = PolishCodeInterpreter.run(poliz_list, lex_list, var_list, con_list)
except Exception as e:
Output_text = "Line " + str(e)
raise e
text2.config(state=NORMAL)
text2.delete(1.0, END)
text2.insert("1.0", Output_text)
text2.config(state=DISABLED)
table = Treeview(tab1, selectmode="browse")
table["columns"] = ("one", "two", "three")
table.column("#0", width=0, minwidth=0, stretch=NO)
table.column("one", width=40, minwidth=40)
table.column("two", width=30, minwidth=30)
table.column("three", width=10, minwidth=10)
table.heading("one", text="Line", anchor=W)
table.heading("two", text="Type", anchor=W)
table.heading("three", text="Table number", anchor=W)
for row in lex_list:
table.insert('', END, values=tuple(row))
scrolltable = Scrollbar(tab1, command=table.yview)
table.configure(yscrollcommand=scrolltable.set)
scrolltable.pack(side=RIGHT, fill=Y)
table.pack(expand=YES, fill=BOTH)
table = Treeview(tab2, selectmode="browse")
table["columns"] = ("one", "two", "three")
table.column("#0", width=0, minwidth=0, stretch=NO)
table.column("one", width=40, minwidth=40)
table.column("two", width=30, minwidth=30)
table.column("three", width=10, minwidth=10)
table.heading("one", text="Index", anchor=W)
table.heading("two", text="Name", anchor=W)
table.heading("three", text="Value", anchor=W)
for row in var_list:
table.insert('', END, values=(var_list.index(row), row[0], row[1]))
scrolltable = Scrollbar(tab2, command=table.yview)
table.configure(yscrollcommand=scrolltable.set)
scrolltable.pack(side=RIGHT, fill=Y)
table.pack(expand=YES, fill=BOTH)
table = Treeview(tab3, selectmode="browse")
table["columns"] = ("one", "two")
table.column("#0", width=0, minwidth=0, stretch=NO)
table.column("one", width=40, minwidth=40)
table.column("two", width=30, minwidth=30)
table.heading("one", text="Index", anchor=W)
table.heading("two", text="Value", anchor=W)
for row in con_list:
table.insert('', END, values=(con_list.index(row), row))
scrolltable = Scrollbar(tab3, command=table.yview)
table.configure(yscrollcommand=scrolltable.set)
scrolltable.pack(side=RIGHT, fill=Y)
table.pack(expand=YES, fill=BOTH)
def __init__(self, ch):
if LexicalAnalyzer.isValidIdentifier(ch):
self.ch = ch
else:
raise ValueError("character is not a valid identifier")
while k<=n do
begin
f3:=f1+f2;
f1:=f2;
f2:=f3;
k:=k+1
end;
write (n, f1)
end.
'''
code1 = '''
program exemplo5(input, output,);
'''
tokens = LexicalAnalyzer.get_tokens(code)
program = SyntaxTree.program
def check(object, token):
try:
if object.name == token[0]:
return 1
elif object.name == '<id>':
return 2
elif object.name == '<lid>':
return 3
elif object.name == '<dv>':
return 4
elif object.name == '[pdv]':
