/// <summary>
/// Funcion que identifica a que tipo de componente lexico pertenece el
/// caracter leido de la cadena de entrada
/// </summary>
/// <param name="parRes">Siguiente caracter leido de la cadena de entrada</param>
/// <returns>Retorna un tipo entero indicando el Id de la tabla al que pertenece
/// el carcater leido</returns>
public int tipoDeSimbolo(char parRes)
{
char cCar = parRes;
CBuscarConcordancia objCBuscarConcordancia = new CBuscarConcordancia();
if (objCBuscarConcordancia.IsCaracterEspecial(cCar) == true)
{
if (objCBuscarConcordancia.IsopAritmetico(cCar) == true)
{
return(4);
}
else if (objCBuscarConcordancia.IsopLogico(cCar) == true)
{
return(5);
}
else if (objCBuscarConcordancia.IsopRelacional(cCar) == true)
{
return(6);
}
else if (objCBuscarConcordancia.IsopAsignacion(cCar) == true)
{
return(7);
}
else if (objCBuscarConcordancia.IsParentesisCircular(cCar) == true)
{
return(8);
}
else if (objCBuscarConcordancia.IsParentesisCuadrado(cCar) == true)
{
return(9);
}
else if (objCBuscarConcordancia.IsLlaves(cCar) == true)
{
return(10);
}
}
else if (objCBuscarConcordancia.IsCaracterAlfabeto(cCar) == true)
{
return(2);
}
else if (WindowsApplication1.CBuscarConcordancia.IsDigito(cCar) == true)
{
return(3);
}
else if (cCar == '\n') //Caracter Fin de linea
{
return(11);
}
else if (cCar == '\x0')
{
return(12); //Caracter Fin de Archivo
}
return(-1); //Simbolo no reconocido
}
public string analizadorLexico()
{
int iAm = 0;
int iAf = 0;
bool bConcordancia = false;
string sCadEntrada = this.txtCadena.Text;
string sLexema = string.Empty;
string sToken = string.Empty;
string sRes = string.Empty;
string sRes2 = string.Empty;
CBuscarConcordancia objCBuscarConcordancia = new CBuscarConcordancia();
CAnalizadorLexico objAnalizadorLexico = new CAnalizadorLexico();
lstvInfo.Items.Clear();
if (this.txtCadena.Text != string.Empty)
{
while (sRes != "EOF")
{
bConcordancia = objAnalizadorLexico.buscarConcordancia(sCadEntrada + "\x0", ref iAf, ref iAm, out sRes, out sRes2);
if (bConcordancia)
{
sLexema = string.Empty;
sLexema = CAnalizadorLexico.extraerLexema(sCadEntrada, ref iAf, ref iAm);
switch (sRes)
{
//Token Lexema Numeros
case "Numero":
sToken = objAnalizadorLexico.tokenLexema(sLexema, sRes, sRes2, "Numeros");
break;
//Token Lexema Identificador
case "Identificador":
sToken = objAnalizadorLexico.tokenLexema(sLexema, "Identificador");
break;
default:
sToken = "";
break;
}
if (sToken == string.Empty)
{
sToken = objAnalizadorLexico.tokenLexema(sCadEntrada, sLexema, ref iAf, ref iAm);
//Token de un Simbolo Reconocido
mostrarTokenLexema(lstvInfo, sLexema, sToken);
}
else
{
//Token de un Simbolo Reconocido
mostrarTokenLexema(lstvInfo, sLexema, sToken);
}
bConcordancia = true;
iAf = iAm; //Igualar la posicion de los dos apuntadores
}
else
{
}
} //Fin While
//Regresar Token Fin de Archivo
mostrarTokenLexema(lstvInfo, "EOF", "(0,0)");
}
else
{
MessageBox.Show("Cadena Vacia intentelo otra vez");
}
sToken = "Cadena Vacia";
return(sToken);
}
/// <summary>
/// Ejecuta el diagrama de transicion correspondiente para identificar
/// Palabras Reservadas o Identificadores
/// </summary>
/// <param name="parCar">Caracter de entrada al diagrama de transicion</param>
/// <param name="parAf">Apuntador Fijo</param>
/// <param name="parAm">Apuntador Movil</param>
/// <returns>True si encuetra una concordancia, False en caso contrario</returns>
public bool IsEstadoTerminalPalabraReservada(string parCadEntrada, char parCar, ref int iAm)
{
char cCar = parCar;
string sCadEntrada = parCadEntrada;
CAnalizadorLexico objAnalizadorLexico = new CAnalizadorLexico();
int iEstado = 0;
bool bError = false;
bool bEstadoFinal = false;
CBuscarConcordancia objCBuscarConcordancia = new CBuscarConcordancia();
while (!bEstadoFinal)
{
switch (iEstado)
{
case 0:
if (objCBuscarConcordancia.IsCaracterMin(cCar) == true)
{
iEstado = 1;
cCar = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
}
else if (objCBuscarConcordancia.IsCaracterMay(cCar) == true)
{
iEstado = 2;
cCar = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
}
else
{
bError = true;
bEstadoFinal = true;
}
break;
case 1:
if (objCBuscarConcordancia.IsCaracterMin(cCar) == true)
{
iEstado = 1;
cCar = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
}
else if (IsDigito(cCar) == true)
{
iEstado = 2;
cCar = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
}
else if (objCBuscarConcordancia.IsCaracterMay(cCar) == true)
{
iEstado = 2;
cCar = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
}
else
{
iEstado = 4;
}
break;
case 2:
if (IsDigito(cCar) == true)
{
iEstado = 2;
cCar = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
}
else if (objCBuscarConcordancia.IsCaracterMin(cCar) == true)
{
iEstado = 2;
cCar = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
}
else if (objCBuscarConcordancia.IsCaracterMay(cCar) == true)
{
iEstado = 2;
cCar = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
}
else
{
iEstado = 3;
}
break;
case 3:
bEstadoFinal = true;
break;
case 4:
bEstadoFinal = true;
break;
default:
break;
}
} //Fin while
if (bError == false)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Token Lexema General
/// </summary>
/// <param name="parsCadEntrada">Cadena de entrada dada por el usuario</param>
/// <param name="parsLexema">Lexema extraido de la cadena de entrada</param>
/// <param name="iAf">Apuntador Fijo</param>
/// <param name="iAm">Apuntador Movil</param>
/// <returns></returns>
public string tokenLexema(string parsCadEntrada, string parsLexema, ref int iAf, ref int iAm)
{
string sLexema = parsLexema;
string sToken = string.Empty;
string sCadEntrada = parsCadEntrada;
char cCar = sLexema[0];
int i = 0;
CCompoLex objCCompoLex = new CCompoLex();
CBuscarConcordancia objCBuscarConcordancia = new CBuscarConcordancia();
for ( ; i <= objCCompoLex.sPalReservadas.Length - 1; i++)
{
if (sLexema.Equals(objCCompoLex.sPalReservadas[i]))
{
return("(1," + i.ToString() + ")");
}
else
{
continue;
}
}
for (i = 0; i <= objCCompoLex.sOpAritmeticos.Length - 1; i++)
{
if (sLexema.Equals(objCCompoLex.sOpAritmeticos[i]))
{
return("(2," + i.ToString() + ")");
}
else
{
continue;
}
}
for (i = 0; i <= objCCompoLex.sOpRelacionales.Length - 1; i++)
{
if (sLexema.Equals(objCCompoLex.sOpRelacionales[i]))
{
return("(3," + i.ToString() + ")");
}
else
{
continue;
}
}
for (i = 0; i <= objCCompoLex.sOpLogicos.Length - 1; i++)
{
if (sLexema.Equals(objCCompoLex.sOpLogicos[i]))
{
return("(4," + i.ToString() + ")");
}
}
for (i = 0; i <= objCCompoLex.sParCircular.Length - 1; i++)
{
if (sLexema.Equals(objCCompoLex.sParCircular[i]))
{
return("(5," + i.ToString() + ")");
}
}
for (i = 0; i <= objCCompoLex.sParCuadrado.Length - 1; i++)
{
if (sLexema.Equals(objCCompoLex.sParCuadrado[i]))
{
return("(6," + i.ToString() + ")");
}
}
for (i = 0; i <= objCCompoLex.sLlaves.Length - 1; i++)
{
if (sLexema.Equals(objCCompoLex.sLlaves[i]))
{
return("(7," + i.ToString() + ")");
}
}
if (sLexema.Equals("="))
{
return("(12,1)");
}
else
{
return("");
}
}
/// <summary>
/// Identifica cual es el patron de concordancia con el que encaja la cadena leida
/// de la cadena de entrada
/// </summary>
/// <param name="parCadena">Cadena de Entrada proporcionada por el usuario</param>
/// <param name="iAf">Apuntador Fijo en la cadena de entrada</param>
/// <param name="iAm">Apuntador Movil en la cadena de entrada</param>
/// <param name="sRes">Variable de control entre funciones</param>
/// <param name="sRes2">Variable de control entre funciones</param>
/// <returns>True si encontro una concordancia, FALSE en caso contrario</returns>
public bool buscarConcordancia(string parCadena, ref int iAf, ref int iAm, out string sRes, out string sRes2)
{
string sCadena = parCadena;
string sLexema = string.Empty;
bool bConcordancia = false;
sRes = string.Empty;
sRes2 = string.Empty;
char cCar = sCadena[iAm];
CBuscarConcordancia objCBuscarConcordancia = new CBuscarConcordancia();
CAnalizadorLexico objCAnalizadorLexico = new CAnalizadorLexico();
//Espacios
if (cCar == ' ')
{
cCar = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
bConcordancia = true;
} //Identificadores,Palabras Reservadas
else if (objCBuscarConcordancia.IsEstadoTerminalPalabraReservada(sCadena, cCar, ref iAm) == true)
{
sLexema = CAnalizadorLexico.extraerLexema(sCadena, ref iAf, ref iAm);
if (objCBuscarConcordancia.IsPalabraReservada(sLexema) == false)
{
//Verificar si el Identificador ya existe para no agregarlo
if (objCBuscarConcordancia.IsExistsIdentificador(sLexema) == true)
{
sRes = "Identificador";
} //Identificador Nuevo
else
{
CCompoLex.iIdentificador.Add(sLexema);
sRes = "Identificador";
}
}
bConcordancia = true;
}
else if (objCBuscarConcordancia.IsNumero(sCadena, cCar, ref iAm, out sRes))
{
switch (sRes)
{
case "NumEntero":
bConcordancia = true;
//Agregar simbolo a la tabla
sLexema = extraerLexema(sCadena, ref iAf, ref iAm);
CCompoLex.NumerosEnteros.Add(sLexema);
sRes = "Numero";
sRes2 = "Entero";
break;
case "NumReal":
bConcordancia = true;
//Agregar simbolo a la tabla
sLexema = extraerLexema(sCadena, ref iAf, ref iAm);
CCompoLex.NumerosFlotantes.Add(sLexema);
sRes = "Numero";
sRes2 = "Real";
break;
case "NumExpCientifica":
bConcordancia = true;
//Agregar simbolo a la tabla
sLexema = extraerLexema(sCadena, ref iAf, ref iAm);
CCompoLex.NumerosNotacionCientifica.Add(sLexema);
sRes = "Numero";
sRes2 = "NotacionCientifica";
break;
default:
sRes = "";
sRes2 = "";
break;
}
}
//Operador Aritmetico
else if (objCBuscarConcordancia.IsEstadoTerminalOpAritmetico(sCadena, cCar, ref iAf, ref iAm) == true)
{
bConcordancia = true;
} //Operador Logico
else if (objCBuscarConcordancia.IsEstadoTerminalOpLogico(sCadena, cCar, ref iAf, ref iAm) == true)
{
bConcordancia = true;
} //Operador Relacional
else if (objCBuscarConcordancia.IsEstadoTerminalOpRelacional(sCadena, cCar, ref iAf, ref iAm) == true)
{
bConcordancia = true;
} //Operador Asignacion
else if (objCBuscarConcordancia.IsopAsignacion(cCar) == true)
{
bConcordancia = true;
cCar = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
} //Parentesis Circular
else if (objCBuscarConcordancia.IsParentesisCircular(cCar) == true)
{
bConcordancia = true;
cCar = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
} //Parentesis Cuadrado
else if (objCBuscarConcordancia.IsParentesisCuadrado(cCar) == true)
{
bConcordancia = true;
cCar = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
} //Llaves
else if (objCBuscarConcordancia.IsLlaves(cCar) == true)
{
bConcordancia = true;
cCar = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
} //Algun otro caracter especial
else if (objCBuscarConcordancia.IsCaracterEspecial(cCar))
{
bConcordancia = true;
cCar = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
} //Fin de Linea
else if (cCar == '\n')
{
bConcordancia = true;
cCar = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
} //Fin de Archivo
else if (cCar == '\x0')
{
bConcordancia = false;
sRes = "EOF";
} //Simbolo no reconocido
else
{
bConcordancia = true;
cCar = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
}
return(bConcordancia);
}
