示例#1
0
        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);
        }
示例#2
0
        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());
        }
示例#3
0
 private void VerificarMultiplicacionOculta(StringBuilder salida, Stack <string> operadores, TipoCaracter last)
 {
     if (last == TipoCaracter.Constante || last == TipoCaracter.Operando || last == TipoCaracter.ParentesisB)
     {
         ApilarOperador(salida, operadores, "*");
     }
 }
示例#4
0
        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());
        }
示例#5
0
 public CaracterClassificado(char caracter)
 {
     Caracter = caracter;
     Funcao   = ClassificarFuncao(Caracter);
     Tipo     = ClassificarTipo(Caracter);
 }