def __init__(self, tokens: list):
self.itr = MyIterator(tokens)
self.sintax_analisys = [] # guarda os erros e sucessos do analisador sintático
self.brackets_stack = [] # balanceamento de { }
self.notDeclaration = False
self.statement_dict = {
"read": self.readProduction,
"print": self.printStatement,
"read":self.readStatement,
"local": self.varScoped,
"global": self.varScoped,
"typedef": self.structProduction,
"if": self.ifProduction,
"while": self.whileProduction,
}
self.global_dict = {
"var": self.varProduction, #
"const": self.varProduction, #
"function": self.functionProcedure, #
"procedure": self.functionProcedure, #
}
self.main = False
self.scope = 0
self.var_tree = []
self.const_tree = []
self.function_tree = []
self.procedure_tree = []
self.struct_tree = []
self.data ={"lexema": "-", "type":"-", "initialized":"-", "scope":"-", "params":"-"}
def __init__(self, whole_file: str):
'''
Construtor da classe GenerateTokens
whole_file: String contendo todo o conteúdo do arquivo de entrada
'''
self.tokens, self.error_tokens, self.symbols_table = [], [], []
self.line = 1
self.lexema = ''
self.itr = MyIterator(whole_file)
def __init__(self, tokens: list):
self.tokens=tokens
self.itr = MyIterator(tokens)
self.var_table=[]
self.const_table=[]
self.function_table=[]
self.procedure_table=[]
self.struct_table=[]
self.errors=[]
self.notGlobal = False
self.scope = 0
class GenerateTokens():
'''
Classe responsável por criar os tokens
'''
reservedWords = {
"var", "const", "typedef", "struct", "extends", "procedure",
"function", "start", "return", "if", "else", "then", "while", "read",
"print", "int", "real", "boolean", "string", "true", "false", "global",
"local"
}
delimitadores = {";", ",", "(", ")", "{", "}", "[", "]", "."}
operadoresAritmeticos = {"+", "-", "*", "/", "++", "--"}
operadoresRelacionais = {"==", "!=", ">", ">=", "<", "<=", "="}
operadoresLogicos = {"&&", "||", "!"}
def __init__(self, whole_file: str):
'''
Construtor da classe GenerateTokens
whole_file: String contendo todo o conteúdo do arquivo de entrada
'''
self.tokens, self.error_tokens, self.symbols_table = [], [], []
self.line = 1
self.lexema = ''
self.itr = MyIterator(whole_file)
def initialState(self) -> list:
'''
Estado inicial do autômato.
Analisa o tipo do caractere atual e transiciona para o próximo estado equivalente.
Returns:
getTokens(): Lista de Tokens Válidos
'''
while True:
try:
self.lexema = ''
if self.itr.cur == None:
return self.getTokens()
if self.itr.cur.isspace():
if self.itr.cur == "\n":
self.line += 1
self.itr.next()
elif self.isAscii(self.itr.cur):
if self.itr.cur.isidentifier():
if self.itr.cur == "_":
token = self.symbolState()
else:
token = self.ideState()
elif self.itr.cur.isnumeric():
token = self.numberState()
else:
token = self.symbolState()
if isinstance(token, Error_Token):
self.error_tokens.append(token)
elif isinstance(token, Token) and token != None:
self.tokens.append(token)
else:
self.error_tokens.append(
Error_Token(OUT_ASCII_ERROR, self.itr.cur, self.line))
self.itr.next()
except StopIteration:
return self.getTokens()
def ideState(self) -> Token:
'''
Estado de Identificadores, responsável por criar
tokens de identificadores e palavras reservadas, transicionando para o estado
inicial, pós-identificação de token.
Returns:
Token(): Token de Identificadores ou Palavra Reservada
'''
while (self.itr.cur.isidentifier() or self.itr.cur.isnumeric()
or self.itr.cur == "_") and self.isAscii(self.itr.cur):
self.lexema += self.itr.cur
self.itr.next()
if self.itr.cur == None:
break
if not self.symbols_table.__contains__(
self.lexema): # Insere o na tabela de simbolos
self.symbols_table.append(self.lexema)
if self.reservedWords.__contains__(
self.lexema): # Caso seja uma palavra reservada
return Token(RW_TOKEN, self.lexema, self.line)
else: # Se não for uma palavra reservada, será um identificador
return Token(ID_TOKEN, self.lexema, self.line)
def numberState(self) -> Token:
'''
Estado inteiro dos Números, responsável por criar
tokens de números inteiros. Caso um "." seja encontrado
ocorrerá uma transição para o estado float, se não, retornará o estado inicial
pós-identificação de token.
Returns:
Token(): Token de Número
floatState(): Token de Número Float
'''
while self.itr.cur.isnumeric():
self.lexema += self.itr.cur
self.itr.next()
if self.itr.cur == None:
break
if self.itr.cur == ".":
self.lexema += self.itr.cur
return self.floatState()
else:
return Token(NUMBER_TOKEN, self.lexema, self.line)
def floatState(self) -> Token:
'''
Estado Decimal dos Números, responsável por criar tokens de números,
retornando para o estado inicial pós-identificação de token.
Returns:
Token(): Token de Número Float
'''
self.itr.next()
if self.itr.cur.isnumeric():
while self.itr.cur.isnumeric():
self.lexema += self.itr.cur
self.itr.next()
if self.itr.cur == None:
break
return Token(NUMBER_TOKEN, self.lexema, self.line)
else:
return Error_Token(NUMBER_ERROR, self.lexema, self.line)
def symbolState(self) -> Token:
'''
Estado de Símbolos, responsável por criar transições para
os estados equivalentes a cada símbolo. Retornará ao estado inicial Caso
o símbolo não corresponda a nenhum dos estados.
Returns:
stringState(): Token de Cadeia de Caracteres
commentState(): Token de Comentário
delimiterState(): Token de Delimitador
opaState(): Token de Operador Aritmético
oprState(): Token de Operador Relacional
oplState(): Token de Operador Lógico
Error_Token(): Token de Erro
'''
if self.itr.cur == "\"":
self.lexema += self.itr.cur
return self.stringState()
elif self.itr.cur == "/":
return self.commentState()
elif self.delimitadores.__contains__(self.itr.cur):
return self.delimiterState()
elif self.operadoresAritmeticos.__contains__(self.itr.cur):
return self.opaState()
elif self.itr.cur in {"=", "!", ">", "<"}:
return self.oprState()
elif self.itr.cur in {"&", "|"}: # OP.
return self.oplState()
else:
self.itr.next()
return Error_Token(SYMBOL_ERROR, self.itr.prv, self.line)
def stringState(self) -> Token:
"""
Estado de Strings, criando tokens de Cadeia de Caracteres,
retornando para o estado inicial pós-identificação de token.
Returns:
Token(): Token de Cadeia de Caracteres
Error_Token(): Token de Erro
"""
contain_no_ascii = False
self.itr.next()
while self.itr.cur not in {'"', "\n", None}:
self.lexema += self.itr.cur
self.itr.next()
if self.itr.cur == None:
break
elif not self.isAscii(self.itr.cur):
contain_no_ascii = True
elif self.itr.cur == "\\" and self.itr.nxt == '"':
self.lexema += self.itr.cur + self.itr.nxt
self.itr.next()
self.itr.next()
if self.itr.cur == "\"":
self.lexema += self.itr.cur
self.itr.next()
if contain_no_ascii:
return Error_Token(STRING_NO_ASCII, self.lexema, self.line)
else:
return Token(STRING_TOKEN, self.lexema, self.line)
else:
self.line += 1 #REVIEW
self.itr.next()
return Error_Token(STRING_ERROR, self.lexema, self.line - 1)
def commentState(self) -> Token:
"""
Estado de Comentários, criando tokens de comentários,
retornando para o estado inicial pós-identificação de token.
Returns:
Error_Token(): Token de Erro
"""
self.itr.next()
if self.itr.cur == "/":
while self.itr.cur != "\n":
self.itr.next()
if self.itr.cur == None:
break
if self.itr.cur == "\n":
self.line += 1
self.itr.next()
elif self.itr.cur == "*":
skipped_lines = 0
self.lexema += self.itr.prv + self.itr.cur
self.itr.next()
while self.itr.cur != "*" and self.itr.nxt != "/":
if self.itr.cur == "\n":
skipped_lines += 1
else:
self.lexema += self.itr.cur
self.itr.next()
if self.itr.cur == None:
break
if self.itr.nxt == None:
return Error_Token(COMMENT_ERROR, self.lexema, self.line)
self.itr.next() # Para pular o */ final
self.itr.next()
self.line += skipped_lines
else:
return Token(OP_A_TOKEN, self.itr.prv, self.line)
def delimiterState(self) -> Token:
"""
Estado de Delimitadores, criando tokens de delimitadores,
retornando para o estado inicial pós-identificação de token.
Returns:
Token(): Token de Delimitador
"""
self.itr.next()
return Token(DELIMITER_TOKEN, self.itr.prv, self.line)
def opaState(self) -> Token:
"""
Estado de Operador Aritmético, criando tokens de OP. Aritmético,
retornando para o estado inicial pós-identificação de token.
Returns:
Token(): Token de Operador Aritmético
"""
if self.itr.cur in {"*", "/"}: #REVIEW / já é pego no comentário
self.itr.next()
return Token(OP_A_TOKEN, self.itr.prv, self.line)
else:
if self.itr.cur == self.itr.nxt:
cur, nxt = self.itr.cur, self.itr.nxt
self.itr.next(
) # Pulando os 2 elementos de ++ ou -- e indo para o próximo
self.itr.next()
return Token(OP_A_TOKEN, cur + nxt, self.line)
else:
self.itr.next()
return Token(OP_A_TOKEN, self.itr.prv, self.line)
def oprState(self) -> Token:
"""
Estado de Operador Relacional, criando tokens de OP. Relacional,
retornando para o estado inicial pós-identificação de token.
Returns:
Token(): Token de Operador Relacional
"""
if self.itr.nxt == "=":
cur, nxt = self.itr.cur, self.itr.nxt
self.itr.next()
self.itr.next()
return Token(OP_R_TOKEN, cur + nxt, self.line)
else:
if self.itr.cur == "!":
self.itr.next()
return Token(OP_L_TOKEN, self.itr.prv, self.line)
else:
self.itr.next()
return Token(OP_R_TOKEN, self.itr.prv, self.line)
def oplState(self) -> Token:
"""
Estado de Operador Lógico, criando tokens de OP. Lógico,
retornando para o estado inicial pós-identificação de token.
Returns:
Token(): Token de Operador Lógico
"""
if self.itr.cur == self.itr.nxt:
cur, nxt = self.itr.cur, self.itr.nxt
self.itr.next(
) # Pulando os 2 elementos de ++ ou -- e indo para o próximo
self.itr.next()
return Token(OP_L_TOKEN, cur + nxt, self.line)
else:
self.itr.next()
return Error_Token(OP_ERROR, self.itr.prv, self.line)
def isAscii(self, char) -> bool:
"""
Verifica se o caractere está presente no intervalo do alfabeto aceito pelo
Analisador Léxico
Returns:
32 <= ord(char) <= 126
"""
return 32 <= ord(char) <= 126
def getErrorTokens(self) -> list:
'''
Retorna a lista de tokens de erro
Returns:
self.error_tokens: Lista de Error_Tokens
'''
return self.error_tokens
def getTokens(self) -> list:
return self.tokens
class Parser():
typeOf = {"int", "real", "string", "boolean"}
variable = {"const", "var"}
def __init__(self, tokens: list):
self.itr = MyIterator(tokens)
self.sintax_analisys = [] # guarda os erros e sucessos do analisador sintático
self.brackets_stack = [] # balanceamento de { }
self.notDeclaration = False
self.statement_dict = {
"read": self.readProduction,
"print": self.printStatement,
"read":self.readStatement,
"local": self.varScoped,
"global": self.varScoped,
"typedef": self.structProduction,
"if": self.ifProduction,
"while": self.whileProduction,
}
self.global_dict = {
"var": self.varProduction, #
"const": self.varProduction, #
"function": self.functionProcedure, #
"procedure": self.functionProcedure, #
}
self.main = False
self.scope = 0
self.var_tree = []
self.const_tree = []
self.function_tree = []
self.procedure_tree = []
self.struct_tree = []
self.data ={"lexema": "-", "type":"-", "initialized":"-", "scope":"-", "params":"-"}
def sintaxParser(self) -> list:
self.initProduction()
return self.getSintaxAnalisys()
def getTokens(self)->list:
# tokens = [item for item in self.sintax_analisys if type(item)==Token]
tokens = []
for item in self.sintax_analisys:
if type(item)==Token:
tokens.append(item)
return tokens
def initProduction(self) -> None: # Funcionando corretamente
while self.itr.cur.lexema in self.global_dict:
statement = self.global_dict[self.itr.cur.lexema]
statement()
if self.itr.cur == None:
break
if self.main == False:
self.sintax_analisys.append("Erro de sintaxe no final do arquivo: Missing procedure start.")
def statementProduction(self) -> None: # Funcionando corretamente
self.statementList()
def statementList(self) -> None: # Funcionando corretamente
if self.itr.cur != None:
if self.itr.cur.type == 'IDE':
if self.itr.nxt.lexema == '(':
self.callFunction()
self.nextToken(';')
else:
self.varUsage()
self.statementList()
elif self.itr.cur.lexema in self.statement_dict:
statement = self.statement_dict[self.itr.cur.lexema]
statement()
self.statementList()
def structProduction(self) -> None: # Funcionando corretamente
self.nextToken('typedef')
if self.nextToken('struct'):
if self.itr.cur.lexema == 'extends':
self.nextToken()
if self.itr.cur.type == "IDE":
self.nextToken()
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Identifier"))
if self.nextToken('{'):
self.scope += 1
self.varProduction()
self.nextToken('}')
if self.itr.cur.type == 'IDE':
self.data['lexema'] = self.itr.cur.lexema
self.data['scope'] = f"local {self.scope}"
self.nextToken()
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Identifier"))
self.nextToken(';')
try:
self.data['type'] = '-'
self.data['initialized'] = '-'
for item in self.struct_tree:
if item.ide == self.data['lexema']:
raise OSError
self.struct_tree.append(DataToken(self.data))
except OSError:
pass
def whileProduction(self) -> None: # Funcionando corretamente
self.nextToken('while')
if self.nextToken('('):
self.expressionProduction()
self.nextToken(')')
if self.nextToken('{'):
self.statementProduction()
self.nextToken('}')
def printStatement(self)->None: # Funcionando corretamente
self.nextToken('print')
if self.nextToken('('):
self.printProduction()
self.nextToken(')')
self.nextToken(";")
def printProduction(self)->None: # Funcionando corretamente
if self.itr.cur.type == "IDE":
self.nextToken()
if self.itr.cur.lexema == '.':
self.structUsage()
self.moreExpressions()
elif self.itr.cur.lexema == '[':
self.arrayUsage()
self.moreExpressions()
else:
self.moreExpressions()
elif self.itr.cur.type == "CAD":
self.nextToken()
self.moreExpressions()
elif self.itr.cur.lexema ==")":
return
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Valid arguments"))
self.itr.next()
def moreExpressions(self)->None: # Funcionando corretamente
if self.itr.cur.lexema==",":
self.nextToken()
self.printProduction()
def structUsage(self)-> None: # Funcionando corretamente
if self.itr.cur.lexema == '.':
self.nextToken()
if self.itr.cur.type == "IDE":
self.nextToken()
def arrayUsage(self)-> None: # Funcionando corretamente
exp = {"IDE","NRO","CAD","true","false"}
if self.nextToken('['):
if self.itr.cur.type in exp or self.itr.cur.lexema in exp:
self.nextToken()
self.nextToken(']')
if self.itr.cur.lexema == '[':
self.nextToken()
if self.itr.cur.type in exp or self.itr.cur.lexema in exp:
self.nextToken()
self.nextToken(']')
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Valid expressions"))
self.itr.next()
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Valid expressions"))
self.itr.next()
def readStatement(self)->None: # Funcionando corretamente
self.nextToken('read')
if self.nextToken('('):
self.readProduction()
self.nextToken(')')
self.nextToken(";")
def readProduction(self)->None: # Funcionando corretamente
if self.itr.cur.type == "IDE":
self.nextToken()
if self.itr.cur.lexema == '.':
self.structUsage()
self.moreReadings()
elif self.itr.cur.lexema == '[':
self.arrayUsage()
self.moreReadings()
else:
self.moreReadings()
elif self.itr.cur.lexema ==")":
return
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Valid read"))
self.itr.next()
def moreReadings(self)->None: # Funcionando corretamente
if self.itr.cur.lexema==",":
self.nextToken()
self.readProduction()
def ifProduction(self) -> None: # Funcionando corretamente
self.nextToken('if')
if self.nextToken('('):
self.expressionProduction()
self.nextToken(')')
self.nextToken('then')
if self.nextToken('{'):
self.statementProduction()
self.nextToken('}')
if self.itr.cur.lexema == 'else':
self.elseStatement()
def elseStatement(self) -> None: # Funcionando corretamente
self.nextToken()
if self.nextToken('{'):
self.statementProduction()
self.nextToken('}')
def functionProcedure(self) -> None: # Funcionando corretamente
self.data['initialized'] = '-'
if self.itr.cur.lexema == 'procedure':
self.nextToken()
self.procedureBody()
elif self.itr.cur.lexema == 'function':
self.nextToken()
if self.itr.cur.lexema in self.typeOf:
self.data['type'] = self.itr.cur.lexema
self.nextToken()
self.functionBody()
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Valid Type"))
self.data ={"lexema": "-", "type":"-", "initialized":"-", "scope":"-", "params":"-"}
def procedureBody(self) -> None: # Funcionando corretamente
self.notDeclaration = True
if self.itr.cur.lexema == "start":
self.main = True
self.nextToken()
if self.nextToken('{'):
self.scope += 1
while self.itr.cur.lexema in {'var','const'}:
statement = self.global_dict[self.itr.cur.lexema]
statement()
self.statementProduction()
self.nextToken('}')
self.notDeclaration = False
elif self.itr.cur.type == "IDE":
self.data['lexema'] = self.itr.cur.lexema
self.nextToken()
self.paramsProduction()
try:
self.data['scope'] = f"local {self.scope + 1}"
for item in self.procedure_tree:
if item.ide == self.data['lexema']:
raise OSError
self.procedure_tree.append(DataToken(self.data))
except OSError:
pass
if self.nextToken('{'):
self.scope += 1
while self.itr.cur.lexema in {'var','const'}:
statement = self.global_dict[self.itr.cur.lexema]
statement()
self.statementProduction()
self.nextToken('}')
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Identifier or start"))
self.itr.next()
self.notDeclaration = False
def functionBody(self) -> None: # Funcionando corretamente
self.notDeclaration = True
if self.itr.cur.type == "IDE":
self.data['lexema'] = self.itr.cur.lexema
self.nextToken()
self.paramsProduction()
try:
self.data['scope'] = f"local {self.scope + 1}"
for item in self.function_tree:
if item.ide == self.data['lexema']:
raise OSError
self.function_tree.append(DataToken(self.data))
except OSError:
pass
if self.nextToken('{'):
self.scope += 1
while self.itr.cur.lexema in {'var','const'}:
statement = self.global_dict[self.itr.cur.lexema]
statement()
self.statementProduction()
self.returnProduction()
self.nextToken('}')
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Identifier"))
self.itr.next()
self.notDeclaration = False
def expressionProduction(self) -> None:
self.orExpression()
def orExpression(self) -> None:
self.andExpression()
if self.itr.cur.lexema=="||":
self.nextToken()
self.orExpression()
def andExpression(self) -> None:
self.equalityExpression()
if self.itr.cur.lexema=="&&":
self.nextToken()
self.andExpression()
def equalityExpression(self) -> None:
equality = {"==", "!="}
self.compareExpression()
if self.itr.cur.lexema in equality:
self.nextToken()
self.equalityExpression()
def compareExpression(self) -> None:
compare = {">", "<",">=","<="}
self.addExpression()
if self.itr.cur.lexema in compare:
self.nextToken()
self.compareExpression()
def addExpression(self) -> None:
add = {"+", "-"}
self.multiplicationExpression()
if self.itr.cur.lexema in add:
self.nextToken()
self.addExpression()
def multiplicationExpression(self) -> None:
exp = {"*", "/"}
self.notExpression()
if self.itr.cur.lexema in exp:
self.nextToken()
self.multiplicationExpression()
def notExpression(self) -> None:
exp = {"IDE","NRO","CAD","true","false"}
if self.itr.cur.lexema == "!":
self.nextToken()
self.notExpression()
elif self.itr.cur.lexema == "(":
self.nextToken()
self.expressionProduction()
self.nextToken(')')
elif self.itr.cur.type in exp or self.itr.cur.lexema in exp:
self.nextToken()
elif self.itr.cur.type in {'global','local'}:
self.nextToken()
self.nextToken('.')
if self.itr.cur.type == 'IDE':
self.nextToken()
self.expressionProduction()
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Valid expression"))
self.itr.next()
def paramsProduction(self) -> None: # Funcionando corretamente
if self.nextToken('('):
self.data['params'] = []
self.params()
self.nextToken(')')
def params(self) -> None: # Funcionando corretamente
if self.itr.cur.lexema in self.typeOf:
self.data['params'].append(self.itr.cur.lexema)
self.nextToken()
if self.itr.cur.type == 'IDE':
self.nextToken()
if self.itr.cur.lexema == ',':
self.nextToken()
self.params()
def callFunction(self) -> None: # Funcionando corretamente
if self.itr.cur.type == 'IDE':
self.nextToken()
if self.nextToken('('):
self.args()
self.nextToken(')')
def args(self) -> None: # Funcionado corretamente
exp = {"IDE","NRO","CAD","true","false"}
if self.itr.cur.type in exp or self.itr.cur.lexema in exp:
self.nextToken()
if self.itr.cur.lexema == ",":
self.nextToken()
self.args()
def returnProduction(self) -> None: # Funcionando corretamente
exp = {"NRO","CAD","true","false"}
if self.nextToken('return'):
if self.itr.cur.type in exp or self.itr.cur.lexema in exp:
self.nextToken()
self.nextToken(';')
elif self.itr.cur.type == 'IDE':
if self.itr.nxt.lexema == "(":
self.callFunction()
else:
self.expressionProduction()
self.nextToken(';')
elif self.itr.cur.lexema == '(':
self.nextToken()
self.expressionProduction()
self.nextToken(')')
self.nextToken(';')
elif self.itr.cur.lexema in {'global','local'}:
self.varScoped()
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Valid return"))
self.itr.next()
def varProduction(self) -> None: # Funcionando corretamente
if self.itr.cur == None:
return
elif self.itr.cur.lexema == 'var':
self.nextToken()
if self.nextToken('{'):
self.varDeclaration()
self.nextToken('}')
self.varProduction()
elif self.itr.cur.lexema == 'const':
self.nextToken()
if self.nextToken('{'):
self.constDeclaration()
self.nextToken('}')
self.varProduction()
def varDeclaration(self) -> None: # Funcionando corretamente
if self.itr.cur.lexema in self.typeOf:
self.data["type"] = self.itr.cur.lexema #pegamos o tipo
self.nextToken()
self.variables()
self.nextToken(';')
self.varDeclaration()
elif self.itr.cur.lexema == '}':
return
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Valid type"))
def variables(self) -> None: # Funcionando corretamente
if self.itr.cur.type == 'IDE':
self.data["lexema"] = self.itr.cur.lexema #pegamos o token
self.nextToken()
if self.itr.cur.lexema == '=':
self.data["t"] = True
self.nextToken()
if self.itr.cur.type == 'IDE':
if self.itr.nxt.lexema == '(':
self.callFunction()
elif self.itr.nxt.lexema == '.':
self.nextToken()
self.structUsage()
elif self.itr.nxt.lexema == '[':
self.nextToken()
self.arrayUsage()
else:
self.expressionProduction()
elif self.itr.cur.lexema in {'global', 'local'}:
self.nextToken()
self.nextToken('.')
if self.itr.cur.type == 'IDE':
if self.itr.cur.lexema == '[':
self.nextToken()
self.arrayUsage()
else:
self.expressionProduction()
else:
self.expressionProduction()
elif self.itr.cur.lexema == '[':
self.arrayUsage()
if self.itr.cur.lexema == '=':
self.nextToken()
if self.itr.cur.lexema == '{':
self.nextToken()
self.varArg()
self.nextToken('}')
elif self.itr.cur.lexema in {'local','global'}:
self.nextToken()
self.nextToken('.')
if self.itr.cur.type == 'IDE':
self.nextToken()
if self.notDeclaration == False:
self.data["scope"] = "global"
else:
self.data["scope"] = f"local {self.scope}"
self.data["params"] = '-'
if self.data['initialized'] == '-':
self.data['initialized'] = False
try:
for item in self.var_tree:
if item.scope == self.data['scope'] and item.ide == self.data['lexema']:
raise OSError
self.var_tree.append(DataToken(self.data))
except OSError:
pass
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Identifier"))
self.itr.next()
if self.itr.cur.lexema == ',':
self.nextToken()
self.variables()
def varArg(self) -> None: # Funcionando corretamente
exp = {'IDE','NRO','CAD','true','false'}
if self.itr.cur.type in exp or self.itr.cur.lexema in exp:
self.nextToken()
if self.itr.cur.lexema == ',':
self.nextToken()
self.varArg()
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Valid values"))
self.itr.next()
def varUsage(self) -> None: # Funcionando corretamente
exp = {'IDE','NRO','CAD','true','false'}
if self.itr.cur.type == 'IDE':
if self.itr.nxt.lexema == '.':
self.nextToken()
self.structUsage()
if self.itr.cur.lexema == '=':
self.nextToken()
if self.itr.cur.type == 'IDE':
if self.itr.nxt.lexema == '(':
self.callFunction()
elif self.itr.nxt.lexema == '.':
self.nextToken()
self.structUsage()
elif self.itr.nxt.lexema == '[':
self.nextToken()
self.arrayUsage()
else:
self.expressionProduction()
elif self.itr.cur.lexema in {'global', 'local'}:
self.nextToken()
self.nextToken('.')
if self.itr.cur.type == 'IDE':
if self.itr.cur.lexema == '[':
self.nextToken()
self.arrayUsage()
else:
self.expressionProduction()
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Identifier"))
else:
self.expressionProduction()
elif self.itr.nxt.lexema == '[':
self.nextToken()
self.arrayUsage()
if self.itr.cur.lexema == '=':
self.nextToken()
if self.itr.cur.type == 'IDE':
if self.itr.nxt.lexema == '.':
self.nextToken()
self.structUsage()
elif self.itr.nxt.lexema == '[':
self.nextToken()
self.arrayUsage()
if self.itr.cur.type in exp or self.itr.cur.lexema in exp:
self.nextToken()
elif self.itr.cur.lexema in {'global', 'local'}:
self.nextToken()
self.nextToken('.')
if self.itr.cur.type == 'IDE':
self.nextToken()
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Identifier"))
else:
self.variables()
self.nextToken(';')
def varScoped(self) -> None: # Funcionando corretamente
self.nextToken()
self.nextToken('.')
self.variables()
self.nextToken(';')
def constDeclaration(self) -> None: # Funcionando corretamente
if self.itr.cur.lexema in self.typeOf:
self.data["type"] = self.itr.cur.lexema #pegamos o tipo
self.nextToken()
self.constants()
self.nextToken(';')
self.constDeclaration()
def constants(self) -> None: # Funcionando corretamente
exp = {'IDE','NRO','CAD','true','false'}
if self.itr.cur.type == 'IDE':
self.data["lexema"] = self.itr.cur.lexema #pegamos o token
self.nextToken()
if self.nextToken('='):
self.data["t"] = True
if self.itr.cur.type in exp or self.itr.cur.lexema in exp:
self.nextToken()
if self.notDeclaration == False:
self.data["scope"] = "global"
else:
self.data["scope"] = f"local {self.scope}"
self.data["params"] = '-'
try:
for item in self.const_tree:
if item.scope == self.data['scope'] and item.ide == self.data['lexema']:
raise OSError
self.const_tree.append(DataToken(self.data))
except OSError:
pass
if self.itr.cur.lexema == ',':
self.nextToken()
self.constants()
else:
self.sintax_analisys.append(SintaxError(self.itr.cur,"Identifier"))
def nextToken(self, lexema = None) -> bool:
# balanceamento de {}, para indicar se ficou faltando fechar algo
if self.itr.cur != None:
# self.bracketsBalance()
if self.itr.cur.lexema == lexema or lexema == None:
self.sintax_analisys.append(self.itr.cur)
self.itr.next()
return True
else:
self.sintax_analisys.append(SintaxError(self.itr.cur, lexema))
self.itr.next()
return False
else:
self.sintax_analisys.append(f'Erro de sintaxe no final do arquivo: Expected:"{lexema}", got "None"')
def bracketsBalance(self) -> None:
if self.itr.cur.lexema == '{':
self.brackets_stack.append(self.itr.cur)
elif self.itr.cur.lexema == '}':
self.brackets_stack.pop()
def getSintaxAnalisys(self) -> list:
return self.sintax_analisys
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument("--batch_size", default=16, type=int)
parser.add_argument("--lr", default=0.01, type=float)
parser.add_argument("--num_workers", default=8, type=int)
parser.add_argument("--wt_dec", default=5e-4, type=float)
parser.add_argument('--gpu', '-g', type=int, default=0, help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out', '-o', default='result', help='Directory to output the result')
args = parser.parse_args()
config=Config()
train_dataset, _, _, identityn = celebA_load(config)
train_iter = MyIterator(config, train_dataset, args.batchsize)
opts = {}
encoder=InceptionResNetV2()
serializers.load_npz(config.pretrainmodel_path, encoder)
d2ae=network.D2AE(encoder, identityn).to_gpu()
ip=network.Identity(identityn).to_gpu()
models = [d2ae,ip]
updater_args = {
"iterator": {'main': train_iter},
"device": args.gpu
}
opts["opt_d2ae"] = make_sgd_optimizer(d2ae, args.lr)
opts["opt_ip"] = make_sgd_optimizer(ip, args.lr)