public void ExpY()
{
AnalisadorLexico.Analisar();
Int32 opType = TokenManager.Instance.TokenCode;
bool is_valid_flag = false;
if (opType == LexMap.Consts["MULTIPLICACAO"])
{
is_valid_flag = true;
}
if (opType == LexMap.Consts["DIVISAO"])
{
is_valid_flag = true;
}
if (opType == LexMap.Consts["MODC"])
{
is_valid_flag = true;
}
if (is_valid_flag)
{
this.ExpK();
this.ExpY();
}
}
private void While()
{
if (TokenManager.Instance.TokenCode == LexMap.Consts["WHILE"])
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ABREPAR"])
{
throw new AnalisadorException("O token ( era esperado");
}
this.Exp();
if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHAPAR"])
{
throw new AnalisadorException("O token ) era esperado");
}
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ABRECHAVES"])
{
throw new AnalisadorException("O token { era esperado");
}
this.ListaComandos();
if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHACHAVES"])
{
throw new AnalisadorException("O token } era esperado");
}
}
}
private void DecC()
{
//AnalisadorLexico.Analisar();
this.ListaDecParm();
if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHAPAR"])
{
throw new AnalisadorException("O token ) era esperado.");
}
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ABRECHAVES"])
{
throw new AnalisadorException("O token { era esperado.");
}
this.ListaComandos();
this.Retorno();
//AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHACHAVES"])
{
throw new AnalisadorException("O token } era esperado.");
}
}
private void Switch()
{
if (TokenManager.Instance.TokenCode == LexMap.Consts["SWITCH"])
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ABREPAR"])
{
throw new AnalisadorException("O token ( era esperado");
}
this.Exp();
if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHAPAR"])
{
throw new AnalisadorException("O token ) era esperado");
}
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ABRECHAVES"])
{
throw new AnalisadorException("O token { era esperado");
}
this.ListaCase();
this.SwitchDefault();
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHACHAVES"])
{
throw new AnalisadorException("O token } era esperado");
}
}
}
private void DecB()
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode == LexMap.Consts["PONTOVIRGULA"])
{
return;
}
else if (TokenManager.Instance.TokenCode == LexMap.Consts["VIRGULA"])
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
{
throw new AnalisadorException("Um identificador era esperado.");
}
this.ListaVar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["PONTOVIRGULA"])
{
throw new AnalisadorException("O Token ; era esperado.");
}
}
else if (TokenManager.Instance.TokenCode == LexMap.Consts["ABREPAR"])
{
this.DecC();
}
else
{
throw new AnalisadorException("O token ; , ( era esperado.");
}
}
private void ListaCase()
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode == LexMap.Consts["CASE"])
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["CONSTINTEIRO"])
{
throw new AnalisadorException("O token constante inteiro era esperado");
}
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["DOISPONTOS"])
{
throw new AnalisadorException("O token : era esperado");
}
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ABRECHAVES"])
{
throw new AnalisadorException("O token { era esperado");
}
this.ListaComandos();
this.CaseEnd();
this.ListaCase();
}
else
{
LineManager.Instance.ResetToLastPos();
}
}
private void Funcao()
{
//if (TokenManager.Instance.TokenCode == LexMap.Consts["ID"])
//{
// AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode == LexMap.Consts["PONTO"])
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
{
throw new AnalisadorException("O token id era esperado, id.id()");
}
AnalisadorLexico.Analisar();
}
if (TokenManager.Instance.TokenCode != LexMap.Consts["ABREPAR"])
{
throw new AnalisadorException("O token ( era esperado");
}
AnalisadorLexico.Analisar();
//se for sem parametro
if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHAPAR"])
{
LineManager.Instance.ResetToLastPos();
this.ListaParam();
}
if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHAPAR"])
{
throw new AnalisadorException("O token ) era esperado");
}
//}
}
private void SwitchDefault()
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode == LexMap.Consts["DEFAULT"])
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["DOISPONTOS"])
{
throw new AnalisadorException("O token : era esperado");
}
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ABRECHAVES"])
{
throw new AnalisadorException("O token { era esperado");
}
this.ListaComandos();
this.CaseEnd();
}
else
{
LineManager.Instance.ResetToLastPos();
}
}
public void Atribuicao()
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode == LexMap.Consts["ATRIBUICAO"])
{
this.Exp();
}
}
private void ListaAtrib()
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
{
throw new AnalisadorException("O token identificador era esperado");
}
this.Atribuicao();
this.ListaAtribA();
}
public void TipoVar()
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["INTEIRO"] &&
TokenManager.Instance.TokenCode != LexMap.Consts["FLOAT"] &&
TokenManager.Instance.TokenCode != LexMap.Consts["BYTE"] &&
TokenManager.Instance.TokenCode != LexMap.Consts["LONG"])
{
throw new AnalisadorException("Tipo de variável não pode ser identificado.");
}
}
public void ExpK()
{
AnalisadorLexico.Analisar();
int tkc = TokenManager.Instance.TokenCode;
if (tkc == LexMap.Consts["CONSTINTEIRO"] ||
tkc == LexMap.Consts["CONSTFLOAT"] ||
tkc == LexMap.Consts["CONSTFLOATPONTO"] ||
tkc == LexMap.Consts["CONSTFLOATPONTONUM"] ||
tkc == LexMap.Consts["CONSTFLOATNUME"] ||
tkc == LexMap.Consts["CONSTFLOATNUMPONTO"] ||
tkc == LexMap.Consts["CONSTFLOATE"] ||
tkc == LexMap.Consts["TRUE"] ||
tkc == LexMap.Consts["FALSE"] ||
tkc == LexMap.Consts["HIGH"] ||
tkc == LexMap.Consts["LOW"] ||
tkc == LexMap.Consts["INPUT"] ||
tkc == LexMap.Consts["OUTPUT"] ||
tkc == LexMap.Consts["ID"])
{
if (tkc == LexMap.Consts["ID"])
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode == LexMap.Consts["ABREPAR"] || TokenManager.Instance.TokenCode == LexMap.Consts["PONTO"])
{
this.Funcao();
}
else
{
LineManager.Instance.ResetToLastPos();
}
}
return;
}
if (TokenManager.Instance.TokenCode == LexMap.Consts["ABREPAR"])
{
this.Exp();
if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHAPAR"])
{
throw new AnalisadorException(
String.Format("Era esperado o token {0}", LexMap.TokenGetNome(LexMap.Consts["FECHAPAR"]))
);
}
return;
}
throw new AnalisadorException("O valor da expressão (K) não é válido");
}
public static void Analisar()
{
String nome;
StringBuilder sb = new StringBuilder();
sb.AppendLine(String.Format("Token: {0}", TokenManager.Instance.TokenSymbol));
sb.AppendLine(String.Format("Token Anterior: {0}", TokenManager.Instance.TokenSymbolAnt));
sb.AppendLine(String.Format("Código do Token: {0}", TokenManager.Instance.TokenCode));
sb.AppendLine(String.Format("Código do Token Anterior: {0}", TokenManager.Instance.TokenCodeAnt));
sb.AppendLine(String.Format("Posição do Caracter de parada: {0}", LineManager.Instance.PosCurrentCaracter));
sb.AppendLine(String.Format("Posição de início de leitura do Token: {0}", LineManager.Instance.PosStartToken));
if (AnalisadorLexico.Reconhecedor())
{
if (TokenManager.Instance.TokenCode == LexMap.Consts["ID"])
{
try
{
TokenManager.Instance.TokenCode = LexMap.PalavraReservada[TokenManager.Instance.TokenSymbol];
}
catch (Exception) { }
}
try
{
nome = LexMap.TokenNome[TokenManager.Instance.TokenCode];
LineManager.Instance.LinesOut.Add(
String.Format("Cod: {0}\tLinha: {1}\tColuna: {2}\tTipo: {3}\tLexema: {4}\n",
TokenManager.Instance.TokenCode,
LineManager.Instance.LineIndex,
LineManager.Instance.PosStartToken,
nome,
TokenManager.Instance.TokenSymbol));
}
catch (Exception)
{
throw new AnalisadorException(String.Format("O Token -{0}- não foi encontrado", TokenManager.Instance.TokenSymbol));
}
}
else
{
TokenManager.Instance.TokenCode = 0;
//TokenManager.Instance.TokenCodeAnt = 0;
TokenManager.Instance.TokenSymbol = "Provável fim de arquivo";
//TokenManager.Instance.TokenSymbolAnt = "Provável fim de arquivo";
//throw new AnalisadorFimArquivoException("O reconhecedor encontrou uma sintaxe não finalizada" + Environment.NewLine + sb.ToString());
}
}
private void ListaDecParmB()
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode == LexMap.Consts["VIRGULA"])
{
this.TipoVar();
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
{
throw new AnalisadorException("Um identificador era esperado");
}
this.ListaDecParmB();
}
}
/*
* Declaracao -> TipoVar id DecB | void id ( DecC
* DecB -> ; | , id ListaVar ; | ( DecC
* DecC -> ListaParm) {ListaComandos}
*/
private void Declaracao()
{
int gramatica = 0;
try
{
this.TipoVar();
}
catch (AnalisadorException) //o tipo ainda pode ser void
{
gramatica = 1;
}
if (gramatica == 0)
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
{
throw new AnalisadorException("Um identificador era esperado.");
}
this.DecB();
}
else
{
if (TokenManager.Instance.TokenCode != LexMap.Consts["VOID"])
{
throw new AnalisadorException("Tipo de variável não pode ser identificado.");
}
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
{
throw new AnalisadorException("Um identificador era esperado.");
}
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ABREPAR"])
{
throw new AnalisadorException("O token ( era esperado.");
}
this.DecC();
}
}
private void DeclaraVar()
{
this.TipoVar();
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
{
throw new AnalisadorException("Um identificador era esperado");
}
this.ListaVar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["PONTOVIRGULA"])
{
throw new AnalisadorException("O Token ; era esperado.");
}
}
public void ListaVar()
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode == LexMap.Consts["VIRGULA"])
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode == LexMap.Consts["ID"])
{
this.ListaVar();
}
else
{
throw new AnalisadorException("Tipo de variável não pode ser identificado.");
}
}
}
public void ExpU()
{
AnalisadorLexico.Analisar();
Int32 opType = TokenManager.Instance.TokenCode;
bool is_valid_flag = false;
if (opType == LexMap.Consts["E"])
{
is_valid_flag = true;
}
if (is_valid_flag)
{
this.ExpF();
this.ExpU();
}
}
private void For()
{
if (TokenManager.Instance.TokenCode == LexMap.Consts["FOR"])
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ABREPAR"])
{
throw new AnalisadorException("O token ( era esperado");
}
this.ListaAtrib();
if (TokenManager.Instance.TokenCode != LexMap.Consts["PONTOVIRGULA"])
{
throw new AnalisadorException("O token ; era esperado");
}
this.Exp();
if (TokenManager.Instance.TokenCode != LexMap.Consts["PONTOVIRGULA"])
{
throw new AnalisadorException("O token ; era esperado");
}
// falta o i++
this.ListaAtrib();
if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHAPAR"])
{
throw new AnalisadorException("O token ) era esperado");
}
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ABRECHAVES"])
{
throw new AnalisadorException("O token { era esperado");
}
this.ListaComandos();
if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHACHAVES"])
{
throw new AnalisadorException("O token } era esperado");
}
}
}
public void ExpV()
{
AnalisadorLexico.Analisar();
Int32 opType = TokenManager.Instance.TokenCode;
bool is_valid_flag = false;
if (opType == LexMap.Consts["MAIOR"])
{
is_valid_flag = true;
}
if (opType == LexMap.Consts["IGUAL"])
{
is_valid_flag = true;
}
if (opType == LexMap.Consts["MENOR"])
{
is_valid_flag = true;
}
if (opType == LexMap.Consts["MAIORIGUAL"])
{
is_valid_flag = true;
}
if (opType == LexMap.Consts["DIFERENTE"])
{
is_valid_flag = true;
}
if (opType == LexMap.Consts["MENORIGUAL"])
{
is_valid_flag = true;
}
if (is_valid_flag)
{
this.ExpH();
this.ExpV();
}
}
public void ExpG()
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode == LexMap.Consts["NAO"])
{
this.ExpG();
}
else
{
//ACHO
LineManager.Instance.ResetToLastPos();
this.ExpH();
this.ExpV();
LineManager.Instance.ResetToLastPos();
}
}
private void CaseEnd()
{
if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHACHAVES"])
{
throw new AnalisadorException("O token } era esperado");
}
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode == LexMap.Consts["BREAK"])
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["PONTOVIRGULA"])
{
throw new AnalisadorException("O token ; era esperado");
}
}
else
{
LineManager.Instance.ResetToLastPos();
}
}
/*
* ListaDecParm -> TipoVar id ListaDecParmB | {}
* ListaDecParmB -> , TipoVar id ListaDecParmB | {}
*/
private void ListaDecParm()
{
try
{
this.TipoVar();
}
catch (AnalisadorException) {
//vazio
return;
}
//se TipoVar não causou uma exception, então estou dando parse nos parametros
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode != LexMap.Consts["ID"])
{
throw new AnalisadorException("Um identificador era esperado");
}
this.ListaDecParmB();
}
private void Retorno()
{
if (TokenManager.Instance.TokenCode == LexMap.Consts["RETURN"])
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode == LexMap.Consts["PONTOVIRGULA"])
{
AnalisadorLexico.Analisar();
return;
}
else
{
LineManager.Instance.ResetToLastPos();
this.Exp();
if (TokenManager.Instance.TokenCode != LexMap.Consts["PONTOVIRGULA"])
{
throw new AnalisadorException("O token ; era esperado.");
}
AnalisadorLexico.Analisar();
}
}
}
private void IfEnd()
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode == LexMap.Consts["ELSE"])
{
AnalisadorLexico.Analisar();
if (TokenManager.Instance.TokenCode == LexMap.Consts["ABRECHAVES"])
{
this.ListaComandos();
if (TokenManager.Instance.TokenCode != LexMap.Consts["FECHACHAVES"])
{
throw new AnalisadorException("O token } era esperado");
}
}
else if (TokenManager.Instance.TokenCode == LexMap.Consts["IF"])
{
// quebra de linha entre else e if da erro:
// if(a){ if(a){}else
// if(1){} }
// no case tbm:
// switch(1){
// case
// }
this.If();
}
else
{
throw new AnalisadorException("O token ( ou if era esperado");
}
}
else
{
LineManager.Instance.ResetToLastPos();
}
}
private void ListaComandosX()
{
bool recur_flag = false;
AnalisadorLexico.Analisar();
//declaração variaveis
if (TokenManager.Instance.TokenCode == LexMap.Consts["INTEIRO"] ||
TokenManager.Instance.TokenCode == LexMap.Consts["FLOAT"] ||
TokenManager.Instance.TokenCode == LexMap.Consts["BYTE"] ||
TokenManager.Instance.TokenCode == LexMap.Consts["LONG"] ||
TokenManager.Instance.TokenCode == LexMap.Consts["VOID"])
{
LineManager.Instance.ResetToLastPos();
this.Declaracao();
recur_flag = true;
}
else
//if
if (TokenManager.Instance.TokenCode == LexMap.Consts["IF"])
{
this.If();
recur_flag = true;
}
else
//while
if (TokenManager.Instance.TokenCode == LexMap.Consts["WHILE"])
{
this.While();
recur_flag = true;
}
else
//do while
if (TokenManager.Instance.TokenCode == LexMap.Consts["DO"])
{
this.DoWhile();
recur_flag = true;
}
else
//for
if (TokenManager.Instance.TokenCode == LexMap.Consts["FOR"])
{
this.For();
recur_flag = true;
}
else
//switch
if (TokenManager.Instance.TokenCode == LexMap.Consts["SWITCH"])
{
this.Switch();
recur_flag = true;
}
else
if (TokenManager.Instance.TokenCode == LexMap.Consts["ID"])
{
//atribuição
this.Atribuicao();
recur_flag = true;
//funcao
if (TokenManager.Instance.TokenCode == LexMap.Consts["ABREPAR"] || TokenManager.Instance.TokenCode == LexMap.Consts["PONTO"])
{
//LineManager.Instance.ResetToLastPos(); // nao retrocede por causa da Atribuicao
this.Funcao();
AnalisadorLexico.Analisar();
}
if (TokenManager.Instance.TokenCode != LexMap.Consts["PONTOVIRGULA"])
{
throw new AnalisadorException("O Token ; era esperado");
}
}
//recursão
if (recur_flag == true)
{
this.ListaComandosX();
}
}