private void resetValidators()
{
tokenCount = 0;
hasEndedTokens = false;
errorToken = null;
actualToken = null;
tokenList = null;
Semantico.resetStack();
parentesisCount = 0;
analyzeExpressionStarterLine = 0;
returnType = "";
tokenAtribuicao = null;
rotulo = 1;
functionReturnsExpected = 0;
functionLine.Clear();
structReceivedForAssignment = null;
returnMade = false;
returnsMade = 0;
actualFunctionName.Clear();
returnAlreadyMade = false;
totalVariables = 0;
CodeGenerator.cleanCommands();
totalVarsCreatedLocally.Clear();
declaredVar = 0;
}
public void executeSintatico(List <Token> tokens)
{
resetValidators();
tokenList = tokens;
if (tokenList.Count() > 0)
{
updateToken();
if (!hasEndedTokens && isSimbol(PROGRAMA))
{
updateToken();
if (!hasEndedTokens && isSimbol(IDENTIFICADOR))
{
Semantico.insereTabela(actualToken.lexem, NOME_PROGRAMA, 0);
CodeGenerator.gera(EMPTY_STRING, START, EMPTY_STRING, EMPTY_STRING);
CodeGenerator.gera(EMPTY_STRING, ALLOC, "0", "1");
totalVariables++;
updateToken();
if (!hasEndedTokens && isSimbol(PONTO_VIRGULA))
{
analisaBloco();
if (isSimbol(PONTO))
{
updateToken();
if (!hasEndedTokens)
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_FALTA);
}
CodeGenerator.gera(EMPTY_STRING, DALLOC, "0", "1");
CodeGenerator.gera(EMPTY_STRING, HLT, EMPTY_STRING, EMPTY_STRING);
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_PONTO_FALTA);
}
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_PV);
}
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_FALTA);
}
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_NOME);
}
}
}
private void analisaTermo()
{
analisaFator();
while (!hasEndedTokens && (isSimbol(MULTI) || isSimbol(DIV) || isSimbol(E)))
{
Semantico.addCharToExpression(actualToken);
updateToken();
analisaFator();
}
}
private void analisaTipo()
{
if (!hasEndedTokens && !isSimbol(INTEIRO) && !isSimbol(BOOLEANO))
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_TIPO);
}
else
{
Semantico.colocaTipoTabela(isSimbol(INTEIRO) ? TIPO_INTEIRO : TIPO_BOOLEANO);
updateToken();
}
}
private void analisaEscreva()
{
updateToken();
if (!hasEndedTokens && isSimbol(ABRE_PARENTESES))
{
updateToken();
if (!hasEndedTokens && isSimbol(IDENTIFICADOR))
{
if (Semantico.pesquisaDeclVarFuncTabela(actualToken.lexem))
{
Struct identifierStruct = Semantico.pesquisaTabela(actualToken.lexem, 0);
if (identifierStruct.nome.Equals(NOME_FUNCAO))
{
CodeGenerator.gera(EMPTY_STRING, CALL, identifierStruct.rotulo.ToString(), EMPTY_STRING);
CodeGenerator.gera(EMPTY_STRING, LDV, FUNCTION_RETURN_LABEL, EMPTY_STRING);
}
else
{
CodeGenerator.gera(EMPTY_STRING, LDV, identifierStruct.rotulo.ToString(), EMPTY_STRING);
}
CodeGenerator.gera(EMPTY_STRING, PRN, EMPTY_STRING, EMPTY_STRING);
updateToken();
if (!hasEndedTokens && isSimbol(FECHA_PARENTESES))
{
updateToken();
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_PARENTESIS);
}
}
else
{
throwError(new CompiladorException(ERRO_SEMANTICO), DECL_VAR_FUNC_ERROR);
}
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_NOME);
}
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_PARENTESIS);
}
}
private void analisaVariaveis()
{
int varsCreated = 0;
do
{
if (!hasEndedTokens && isSimbol(IDENTIFICADOR))
{
if (!Semantico.pesquisaDuplicVarTabela(actualToken.lexem))
{
Semantico.insereTabela(actualToken.lexem, NOME_VARIAVEL, totalVariables + varsCreated);
varsCreated++;
updateToken();
if (!hasEndedTokens && (isSimbol(VIRGULA) || isSimbol(DOIS_PONTOS)))
{
if (!hasEndedTokens && isSimbol(VIRGULA))
{
updateToken();
if (!hasEndedTokens && !isSimbol(IDENTIFICADOR))
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_VAR);
}
}
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_DOIS_PONTOS);
}
}
else
{
throwError(new CompiladorException(ERRO_SEMANTICO), DUPLIC_VAR_ERROR);
}
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_NOME);
}
} while (!hasEndedTokens && !isSimbol(DOIS_PONTOS));
updateToken();
declaredVar++;
totalVarsCreatedLocally.Push(varsCreated);
CodeGenerator.gera(EMPTY_STRING, ALLOC, totalVariables.ToString(), varsCreated.ToString());
totalVariables += varsCreated;
analisaTipo();
}
public Sintatico(Lexico lx)
{
this.inVar = false;
this.inConst = false;
this.tempVars = new List <string>();
this.Sem = new Semantico();
this.Lex = lx;
this.tk = lx.NextToken();
if (tk == null)
{
Console.WriteLine("Arquivo vazio");
}
}
private void analisaEnquanto()
{
int auxrot1, auxrot2;
auxrot1 = rotulo;
CodeGenerator.gera(auxrot1.ToString(), NULL, EMPTY_STRING, EMPTY_STRING);
rotulo++;
updateToken();
Semantico.cleanExpression();
analisaExpressao();
try
{
returnType = Semantico.analyzeExpression();
}
catch (CompiladorException e)
{
throwError(e, ANALYZING_EXPRESSION_ERROR, analyzeExpressionStarterLine);
}
if (!returnType.Equals(TIPO_BOOLEANO))
{
throwError(new CompiladorException(ERRO_SEMANTICO), EXPRESSION_MUST_BE_BOOL, analyzeExpressionStarterLine);
}
else
{
CodeGenerator.geraCodeExpression(Semantico.getPosFixExpression());
}
if (!hasEndedTokens && isSimbol(FACA))
{
auxrot2 = rotulo;
CodeGenerator.gera(EMPTY_STRING, JMPF, auxrot2.ToString(), EMPTY_STRING);
rotulo++;
updateToken();
analisaComandoSimples();
returnMade = false;
CodeGenerator.gera(EMPTY_STRING, JMP, auxrot1.ToString(), EMPTY_STRING);
CodeGenerator.gera(auxrot2.ToString(), NULL, EMPTY_STRING, EMPTY_STRING);
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_FALTA);
}
}
private void analisaExpressaoSimples()
{
if (!hasEndedTokens && (isSimbol(MAIS) || isSimbol(MENOS)))
{
Semantico.addCharToExpression(new Token(actualToken.simbol, actualToken.lexem + "u", actualToken.line));
updateToken();
}
analisaTermo();
while (!hasEndedTokens && (isSimbol(MAIS) || isSimbol(MENOS) || isSimbol(OU)))
{
Semantico.addCharToExpression(actualToken);
updateToken();
analisaTermo();
}
}
private void analisaExpressao()
{
if (parentesisCount == 0)
{
analyzeExpressionStarterLine = actualToken.line;
}
analisaExpressaoSimples();
while (!hasEndedTokens &&
(isSimbol(MAIOR) || isSimbol(MAIORIG) || isSimbol(IGUAL) || isSimbol(MENOR) || isSimbol(MENORIG) || isSimbol(DIF)))
{
Semantico.addCharToExpression(actualToken);
updateToken();
analisaExpressaoSimples();
}
}
private void analisaAtribuicao()
{
updateToken();
Semantico.cleanExpression();
analisaExpressao();
try
{
returnType = Semantico.analyzeExpression();
}
catch (CompiladorException e)
{
throwError(e, ANALYZING_EXPRESSION_ERROR, analyzeExpressionStarterLine);
}
if (!returnType.Equals(structReceivedForAssignment.tipo))
{
if (structReceivedForAssignment.tipo.Equals(TIPO_BOOLEANO))
{
throwError(new CompiladorException(ERRO_SEMANTICO), ASSIGNMENT_EXPRESSION_MUST_BE_BOOL, analyzeExpressionStarterLine);
}
else
{
throwError(new CompiladorException(ERRO_SEMANTICO), ASSIGNMENT_EXPRESSION_MUST_BE_INT, analyzeExpressionStarterLine);
}
}
else
{
CodeGenerator.geraCodeExpression(Semantico.getPosFixExpression());
}
if (structReceivedForAssignment.nome.Equals(NOME_FUNCAO))
{
CodeGenerator.gera(EMPTY_STRING, STR, FUNCTION_RETURN_LABEL, EMPTY_STRING);
}
else
{
CodeGenerator.gera(EMPTY_STRING, STR, structReceivedForAssignment.rotulo.ToString(), EMPTY_STRING);
}
}
private void analisaLeia()
{
updateToken();
if (!hasEndedTokens && isSimbol(ABRE_PARENTESES))
{
updateToken();
if (!hasEndedTokens && isSimbol(IDENTIFICADOR))
{
if (Semantico.pesquisaDeclVarTabela(actualToken.lexem))
{
CodeGenerator.gera(EMPTY_STRING, RD, EMPTY_STRING, EMPTY_STRING);
CodeGenerator.gera(EMPTY_STRING, STR, Semantico.pesquisaTabela(actualToken.lexem, 0).rotulo.ToString(), EMPTY_STRING);
updateToken();
if (!hasEndedTokens && isSimbol(FECHA_PARENTESES))
{
updateToken();
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_PARENTESIS);
}
}
else
{
throwError(new CompiladorException(ERRO_SEMANTICO), DECL_VAR_ERROR);
}
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_NOME);
}
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_PARENTESIS);
}
}
private void analisaDeclaracaoProcedimento()
{
updateToken();
if (!hasEndedTokens && isSimbol(IDENTIFICADOR))
{
if (!Semantico.pesquisaDeclProcTabela(actualToken.lexem))
{
Semantico.insereTabela(actualToken.lexem, NOME_PROCEDIMENTO, rotulo);
CodeGenerator.gera(rotulo.ToString(), NULL, EMPTY_STRING, EMPTY_STRING);
rotulo++;
Semantico.increaseLevel();
updateToken();
if (!hasEndedTokens && isSimbol(PONTO_VIRGULA))
{
analisaBloco();
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_PV);
}
}
else
{
throwError(new CompiladorException(ERRO_SEMANTICO), DECL_PROC_ERROR);
}
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_FALTA);
}
Semantico.voltaNivel();
}
public static void geraCodeExpression(List <string> posFixExpression)
{
foreach (String field in posFixExpression)
{
switch (field)
{
case "*":
gera(EMPTY_STRING, MULT, EMPTY_STRING, EMPTY_STRING);
break;
case "div":
gera(EMPTY_STRING, DIVI, EMPTY_STRING, EMPTY_STRING);
break;
case "=":
gera(EMPTY_STRING, CEQ, EMPTY_STRING, EMPTY_STRING);
break;
case "!=":
gera(EMPTY_STRING, DIF, EMPTY_STRING, EMPTY_STRING);
break;
case ">":
gera(EMPTY_STRING, CMA, EMPTY_STRING, EMPTY_STRING);
break;
case ">=":
gera(EMPTY_STRING, CMAQ, EMPTY_STRING, EMPTY_STRING);
break;
case "<":
gera(EMPTY_STRING, CME, EMPTY_STRING, EMPTY_STRING);
break;
case "<=":
gera(EMPTY_STRING, CMEQ, EMPTY_STRING, EMPTY_STRING);
break;
case "e":
gera(EMPTY_STRING, AND, EMPTY_STRING, EMPTY_STRING);
break;
case "ou":
gera(EMPTY_STRING, OR, EMPTY_STRING, EMPTY_STRING);
break;
case "nao":
gera(EMPTY_STRING, NEG, EMPTY_STRING, EMPTY_STRING);
break;
case "+":
gera(EMPTY_STRING, ADD, EMPTY_STRING, EMPTY_STRING);
break;
case "+u":
break;
case "-u":
gera(EMPTY_STRING, INV, EMPTY_STRING, EMPTY_STRING);
break;
case "-":
gera(EMPTY_STRING, SUB, EMPTY_STRING, EMPTY_STRING);
break;
case "verdadeiro":
gera(EMPTY_STRING, LDC, "1", EMPTY_STRING);
break;
case "falso":
gera(EMPTY_STRING, LDC, "0", EMPTY_STRING);
break;
default:
if (field.All(char.IsDigit))
{
gera(EMPTY_STRING, LDC, field, EMPTY_STRING);
}
else
{
Struct structField = Semantico.pesquisaTabela(field, 0);
if (structField.nome.Equals(NOME_FUNCAO))
{
CodeGenerator.gera(EMPTY_STRING, CALL, structField.rotulo.ToString(), EMPTY_STRING);
CodeGenerator.gera(EMPTY_STRING, LDV, FUNCTION_RETURN_LABEL, EMPTY_STRING);
}
else
{
CodeGenerator.gera(EMPTY_STRING, LDV, structField.rotulo.ToString(), EMPTY_STRING);
}
}
break;
}
}
}
private void analisaFator()
{
if (!hasEndedTokens && isSimbol(IDENTIFICADOR))
{
Struct actualItem = Semantico.pesquisaTabela(actualToken.lexem, 0);
if (actualItem != null)
{
Semantico.addCharToExpression(actualToken);
if (actualItem.tipo == TIPO_INTEIRO || actualItem.tipo == TIPO_BOOLEANO)
{
analisaChamadaFuncao();
}
else
{
updateToken();
}
}
else
{
throwError(new CompiladorException(ERRO_SEMANTICO), ITEM_NOT_FOUND);
}
}
else if (!hasEndedTokens && isSimbol(NUMERO))
{
Semantico.addCharToExpression(actualToken);
updateToken();
}
else if (!hasEndedTokens && isSimbol(NAO))
{
Semantico.addCharToExpression(actualToken);
updateToken();
analisaFator();
}
else if (!hasEndedTokens && isSimbol(ABRE_PARENTESES))
{
parentesisCount++;
Semantico.addCharToExpression(actualToken);
updateToken();
analisaExpressao();
if (!hasEndedTokens && isSimbol(FECHA_PARENTESES))
{
parentesisCount--;
Semantico.addCharToExpression(actualToken);
updateToken();
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_PARENTESIS);
}
}
else if (!hasEndedTokens && (isSimbol(VERDADEIRO) || isSimbol(FALSO)))
{
Semantico.addCharToExpression(actualToken);
updateToken();
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_CARACTER);
}
}
private void analisaDeclaracaoFuncao()
{
updateToken();
if (!hasEndedTokens && isSimbol(IDENTIFICADOR))
{
actualFunctionName.Push(actualToken.lexem);
if (!Semantico.pesquisaDeclFuncTabela(actualToken.lexem))
{
Semantico.insereTabela(actualToken.lexem, NOME_FUNCAO, rotulo);
CodeGenerator.gera(rotulo.ToString(), NULL, EMPTY_STRING, EMPTY_STRING);
rotulo++;
Semantico.increaseLevel();
functionLine.Push(actualToken.line);
updateToken();
if (!hasEndedTokens && isSimbol(DOIS_PONTOS))
{
updateToken();
if (!hasEndedTokens && (isSimbol(INTEIRO) || isSimbol(BOOLEANO)))
{
string type = isSimbol(INTEIRO) ? TIPO_INTEIRO : TIPO_BOOLEANO;
Semantico.colocaTipoTabela(type);
updateToken();
if (!hasEndedTokens && isSimbol(PONTO_VIRGULA))
{
functionReturnsExpected++;
analisaBloco();
functionReturnsExpected--;
if (!returnMade)
{
throwError(new CompiladorException(ERRO_SEMANTICO, new CompiladorException(actualFunctionName.Peek())), returnsMade > 0 ? FUNCTION_LAST_LINE_NOT_RETURN : EXPECTED_FUNCTION_RETURN, functionLine.Peek());
}
actualFunctionName.Pop();
functionLine.Pop();
}
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_TIPO);
}
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_FALTA);
}
}
else
{
throwError(new CompiladorException(ERRO_SEMANTICO), DECL_FUNC_ERROR);
}
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_NOME);
}
Semantico.voltaNivel();
}
private void analisaAtribChamadaProc()
{
tokenAtribuicao = actualToken;
structReceivedForAssignment = Semantico.pesquisaTabela(tokenAtribuicao.lexem, 0);
if (structReceivedForAssignment == null)
{
throwError(new CompiladorException(ERRO_SEMANTICO), ITEM_NOT_FOUND);
}
updateToken();
bool hasSameName;
try
{
if (structReceivedForAssignment != null && structReceivedForAssignment.nome.Equals(NOME_FUNCAO))
{
hasSameName = structReceivedForAssignment.lexema.Equals(actualFunctionName.Peek());
}
else
{
hasSameName = false;
}
}
catch (Exception)
{
hasSameName = false;
}
if (!hasEndedTokens && isSimbol(ATRIBUICAO))
{
if (structReceivedForAssignment.nome.Equals(NOME_VARIAVEL))
{
analisaAtribuicao();
}
else if (hasSameName && structReceivedForAssignment.nome.Equals(NOME_FUNCAO) && functionReturnsExpected > 0)
{
analisaAtribuicao();
returnsMade++;
returnMade = true;
returnAlreadyMade = true;
}
else
{
if (!hasSameName && structReceivedForAssignment.nome.Equals(NOME_FUNCAO))
{
throwError(new CompiladorException(ERRO_SEMANTICO), INVALID_FUNCTION_NAME, tokenAtribuicao.line);
}
else
{
if (structReceivedForAssignment.tipo.Equals(TIPO_BOOLEANO))
{
throwError(new CompiladorException(ERRO_SEMANTICO), ASSIGNMENT_EXPRESSION_MUST_BE_BOOL, tokenAtribuicao.line);
}
else
{
throwError(new CompiladorException(ERRO_SEMANTICO), ASSIGNMENT_EXPRESSION_MUST_BE_INT, tokenAtribuicao.line);
}
}
}
}
else
{
if (structReceivedForAssignment.nome.Equals(NOME_PROCEDIMENTO))
{
analisaChamadaProcedimento(structReceivedForAssignment);
}
else
{
throwError(new CompiladorException(ERRO_SEMANTICO), INVALID_PROC_CALL);
}
}
}
private void analisaSe()
{
int auxrot1 = 0, auxrot2 = 0;
updateToken();
Semantico.cleanExpression();
analisaExpressao();
try
{
returnType = Semantico.analyzeExpression();
}
catch (CompiladorException e)
{
throwError(e, ANALYZING_EXPRESSION_ERROR, analyzeExpressionStarterLine);
}
if (!returnType.Equals(TIPO_BOOLEANO))
{
throwError(new CompiladorException(ERRO_SEMANTICO), EXPRESSION_MUST_BE_BOOL, analyzeExpressionStarterLine);
}
else
{
CodeGenerator.geraCodeExpression(Semantico.getPosFixExpression());
auxrot1 = rotulo;
CodeGenerator.gera(EMPTY_STRING, JMPF, auxrot1.ToString(), EMPTY_STRING);
rotulo++;
}
if (!hasEndedTokens && isSimbol(ENTAO))
{
bool entaoReturnMade = false;
bool senaoReturnMade = false;
updateToken();
analisaComandoSimples();
if (functionReturnsExpected > 0)
{
entaoReturnMade = returnMade;
if (!hasEndedTokens && isSimbol(SENAO))
{
auxrot2 = rotulo;
CodeGenerator.gera(EMPTY_STRING, JMP, auxrot2.ToString(), EMPTY_STRING);
CodeGenerator.gera(auxrot1.ToString(), NULL, EMPTY_STRING, EMPTY_STRING);
rotulo++;
returnAlreadyMade = false;
updateToken();
analisaComandoSimples();
CodeGenerator.gera(auxrot2.ToString(), NULL, EMPTY_STRING, EMPTY_STRING);
senaoReturnMade = returnMade;
}
else
{
CodeGenerator.gera(auxrot1.ToString(), NULL, EMPTY_STRING, EMPTY_STRING);
}
returnMade = entaoReturnMade && senaoReturnMade;
returnAlreadyMade = returnMade;
}
else
{
if (!hasEndedTokens && isSimbol(SENAO))
{
auxrot2 = rotulo;
CodeGenerator.gera(EMPTY_STRING, JMP, auxrot2.ToString(), EMPTY_STRING);
CodeGenerator.gera(auxrot1.ToString(), NULL, EMPTY_STRING, EMPTY_STRING);
rotulo++;
updateToken();
analisaComandoSimples();
CodeGenerator.gera(auxrot2.ToString(), NULL, EMPTY_STRING, EMPTY_STRING);
}
else
{
CodeGenerator.gera(auxrot1.ToString(), NULL, EMPTY_STRING, EMPTY_STRING);
}
}
}
else
{
throwError(new CompiladorException(ERRO_SINTATICO), ERRO_FALTA);
}
}
