private TipoCaracter ClassificarTipo(char caracter)
{
TipoCaracter tipo = TipoCaracter.NA;
if (LETRAS_MINUSCULAS.Contains(caracter))
{
tipo = TipoCaracter.LETRA;
}
if (LETRAS_MAIUSCULAS.Contains(caracter))
{
tipo = TipoCaracter.LETRA;
}
else if (DIGITOS.Contains(caracter))
{
tipo = TipoCaracter.DIGITO;
}
else if (ESPACADORES.Contains(caracter))
{
tipo = TipoCaracter.DELIMITADOR;
}
else if (ESPECIAIS.Contains(caracter))
{
tipo = TipoCaracter.ESPECIAL;
}
else if (QUEBRA_LINHA.Contains(caracter))
{
tipo = TipoCaracter.CONTROLE;
}
return(tipo);
}
public decimal EvaluarPostfija(string expresion)
{
if (hayError)
{
return(0);
}
Stack <decimal> pila = new Stack <decimal>();
string[] tokens = expresion.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
decimal operando = 0;
foreach (string token in tokens)
{
TipoCaracter tipo = GetTipo(token, 0);
//expresion = expresionConNotacionCientifica(expresion);
if (tipo == TipoCaracter.Operador)
{
EjecutarOperacion(pila, token);
}
else if (decimal.TryParse(token, out operando))
{
pila.Push(operando);
}
else if (token == "A")
{
pila.Push(a);
}
else if (token == "B")
{
pila.Push(b);
}
else if (token == "C")
{
pila.Push(c);
}
else
{
error = ("Error formato numerico no valido"); hayError = true;
}
}
if (pila.Count != 1)
{
error = ("No se ha podido evaluar la expresion");
hayError = true;
}
return(pila.Pop());
}
private void VerificarMultiplicacionOculta(StringBuilder salida, Stack <string> operadores, TipoCaracter last)
{
if (last == TipoCaracter.Constante || last == TipoCaracter.Operando || last == TipoCaracter.ParentesisB)
{
ApilarOperador(salida, operadores, "*");
}
}
public string ConvertirInfija(string expresion)
{
StringBuilder salida = new StringBuilder();
Stack <string> operadores = new Stack <string>();
string token = string.Empty;
TipoCaracter tipo = TipoCaracter.Invalido;
TipoCaracter last = TipoCaracter.Invalido;
int contOperando = 0;
bool faltaOperando = false;
int posicionUltimoOperador = 0;
int operacion = 0;
int digitos = 0;
for (int i = 0; i < expresion.Length; i++)
{
token = expresion[i].ToString();
if (string.IsNullOrWhiteSpace(token))
{
continue;
}
tipo = GetTipo(token, i);
if (tipo == TipoCaracter.Operando)
{
if (i > 0)
{
if (expresion[i - 1] == '.' && token == ".")
{
error = ("Error en la posicion " + i + Environment.NewLine + "No se puede poner dos puntos seguidos"); hayError = true;
}
}
//if (digitos >= 8) { }
//else
//{
if (last == TipoCaracter.Constante || last == TipoCaracter.ParentesisB)
{
ApilarOperador(salida, operadores, "*");
}
salida.Append(token);
contOperando++;
faltaOperando = false;
if (token != ".")
{
digitos++;
}
//}
}
else if (tipo == TipoCaracter.Constante)
{
VerificarMultiplicacionOculta(salida, operadores, last);
salida.Append(" " + token + " ");
contOperando++;
faltaOperando = false;
digitos = 0;
}
else if (tipo == TipoCaracter.Operador)
{
if (contOperando == 0 && Prioridad(token) != 1)
{
error = ("Error en la posicion " + i + Environment.NewLine + "No se puede comenzar la expresion con este operador"); hayError = true;
}
if (contOperando == 0 && token == "+")
{
continue;
}
if (last == TipoCaracter.Operador && token != "-")
{
error = ("Error despues de la posicion " + i + Environment.NewLine + "Falta operando");
hayError = true;
}
if ((last == TipoCaracter.Operador && token == "-") ||
(last == TipoCaracter.Invalido && token == "-") ||
(last == TipoCaracter.ParentesisA && token == "-"))
{
salida.Append(" -1 ");
operadores.Push("*");
}
else
{
ApilarOperador(salida, operadores, token);
faltaOperando = true;
posicionUltimoOperador = i;
operacion++;
}
digitos = 0;
}
else if (tipo == TipoCaracter.ParentesisA)
{
VerificarMultiplicacionOculta(salida, operadores, last);
operadores.Push("(");
digitos = 0;
}
else if (tipo == TipoCaracter.ParentesisB)
{
DesapilarParentesis(salida, operadores);
digitos = 0;
}
else
{
int index = expresion.IndexOf('(', i);
if (index < 0)
{
error = ("Error en sintaxis");
hayError = true;
}
else
{
string newtoken = expresion.Substring(i, index - i);
i = index - 1;
tipo = GetTipo(newtoken, i);
}
digitos = 0;
}
last = tipo;
}
if (faltaOperando)
{
error = ("Error despues de la posicion " + posicionUltimoOperador + Environment.NewLine + "Falta operando");
hayError = true;
}
if (operacion > 8)
{
error = ("Error" + Environment.NewLine + "Sobrepasa el limite de 8 operaciones"); hayError = true;
}
VaciarOperandos(salida, operadores);
RemoverEspaciosVacios(salida);
return(salida.ToString());
}
public CaracterClassificado(char caracter)
{
Caracter = caracter;
Funcao = ClassificarFuncao(Caracter);
Tipo = ClassificarTipo(Caracter);
}
