/*-----------------------------------------------*/
 public void addtoken(token.Tipo tipo)
 {
     Out.AddLast(new token(tipo, auxL));
     ntokens++;
     auxL   = "";
     estado = 0;
 }
 public void addErrortoken(token.Tipo tipo, String au)
 {
     Errores.AddLast(new token(tipo, au));
     auxL   = "";
     estado = 0;
 }
        public LinkedList <token> escanear(String entrada)
        {
            nErrores = 0;

            entrada.ToLower();
            entrada    += "#";
            Out         = new LinkedList <token>();
            Errores     = new LinkedList <token>();
            expresiones = new LinkedList <expresion>();
            arboles     = new LinkedList <metodoArbol> ();
            nodo n;

            for (int i = 0; i < entrada.Length; i++)
            {
                c = entrada.ElementAt(i);

                switch (estado)
                {
                case 0:
                    auxL += entrada.ElementAt(i);
                    if (Char.IsLetter(c))
                    {
                        estado = 1;
                    }
                    else if (Char.IsDigit(c))
                    {
                        estado = 2;
                    }
                    else
                    {
                        switch (c)
                        {
                        case '{':
                            addtoken(token.Tipo.S_abrirLlaves);
                            break;

                        case '}':
                            addtoken(token.Tipo.S_cerrarLlaves);
                            break;

                        case ',':
                            addtoken(token.Tipo.S_coma);
                            break;

                        case ';':
                            esConjunto = false;
                            addtoken(token.Tipo.S_puntoComa);
                            break;

                        case '/':
                            estado = 3;
                            break;

                        case '%':
                            lexemas = true;
                            addtoken(token.Tipo.S_porcentaje);
                            break;

                        case ':':
                            addtoken(token.Tipo.S_dosPuntos);
                            break;

                        case '"':
                            //addtoken(token.Tipo.S_comillas);
                            estado = 4;
                            break;

                        case '<':
                            estado = 5;
                            break;

                        case '\\':
                            estado = 14;
                            break;

                        case '[':
                            estado = 15;
                            break;

                        case '-':
                            estado = 6;
                            break;

                        case '~':
                            addtoken(token.Tipo.conj);
                            break;

                        default:
                            if (EsSeparador(i, c, entrada.Length))
                            {
                                estado = 0;
                                auxL   = "";
                            }
                            else
                            {
                                Console.WriteLine("Caracter no reconcido" + c.ToString());
                                addErrortoken(token.Tipo.ERROR, c.ToString());
                                error  = true;
                                estado = 0;
                                nErrores++;
                            }
                            break;
                        }
                    }
                    break;

                case 1:

                    if (Char.IsLetter(c))
                    {
                        auxL  += entrada.ElementAt(i);
                        estado = 1;
                    }
                    else if (Char.IsDigit(c))
                    {
                        auxL  += entrada.ElementAt(i);
                        estado = 1;
                    }
                    else
                    {
                        if (entrada.ElementAt(i + 1).Equals(':') || entrada.ElementAt(i + 2).Equals(':'))
                        {
                            pyc = true;
                        }
                        token.Tipo tipoA = verificarPalabra();
                        addtoken(tipoA);
                        i--;
                    }

                    break;

                case 2:

                    if (Char.IsLetter(c))
                    {
                        auxL  += entrada.ElementAt(i);
                        estado = 1;
                    }
                    else if (Char.IsDigit(c))
                    {
                        auxL  += entrada.ElementAt(i);
                        estado = 2;
                    }
                    else
                    {
                        addtoken(token.Tipo.Numero);
                        i--;
                    }

                    break;

                case 3:
                    if (!(c == 10 || c == 13 || c == 11 || i == entrada.Length - 1))
                    {
                        auxL += entrada.ElementAt(i);
                    }
                    else
                    {
                        addtoken(token.Tipo.Comentario);
                        i--;
                    }
                    break;

                case 4:

                    if (!(c == '"'))
                    {
                        auxL += entrada.ElementAt(i);
                    }
                    else
                    {
                        auxL += entrada.ElementAt(i);
                        addtoken(token.Tipo.Cadena);
                    }
                    break;

                case 5:
                    if (c == '!')
                    {
                        auxL  += entrada.ElementAt(i);
                        estado = 12;
                    }
                    else
                    {
                        if (EsSeparador(i, c, entrada.Length))
                        {
                            estado = 0;
                            auxL   = "";
                        }
                        else
                        {
                            Console.WriteLine("Caracter no reconcido" + c);
                            addErrortoken(token.Tipo.ERROR, c.ToString());
                            error  = true;
                            estado = 0;
                            nErrores++;
                        }
                    }
                    break;

                case 6:
                    if (c == '-')
                    {
                        auxL  += entrada.ElementAt(i);
                        estado = 6;
                    }
                    else if (c == '>')
                    {
                        auxL += entrada.ElementAt(i);
                        addtoken(token.Tipo.flechita);
                        primUlt = 1;
                        estado  = 6;
                    }
                    else
                    {
                        if (esConjunto == true && lexemas == false)
                        {                                 //Def conjuntos
                            i--;
                            estado = 7;
                        }
                        else if (esConjunto == false && lexemas == true)
                        {                                 //Def Lexemas
                            i--;
                            estado = 8;
                        }
                        else
                        {                                  //Def expresiones
                            i--;
                            estado = 9;
                        }

                        break;
                    }
                    break;

                case 7:
                    if (Char.IsLetter(c))
                    {
                        auxL  += entrada.ElementAt(i);
                        estado = 7;
                    }
                    else if (Char.IsDigit(c))
                    {
                        auxL  += entrada.ElementAt(i);
                        estado = 7;
                    }
                    else
                    {
                        switch (c)
                        {
                        case ',':
                            auxL  += entrada.ElementAt(i);
                            estado = 7;
                            break;

                        case '~':
                            auxL  += entrada.ElementAt(i);
                            estado = 7;
                            break;

                        case ';':
                            addtoken(token.Tipo.conjunto);
                            auxL += entrada.ElementAt(i);
                            addtoken(token.Tipo.S_puntoComa);
                            esConjunto = false;
                            primUlt    = 1;
                            estado     = 0;
                            break;

                        default:
                            if (EsSeparador(i, c, entrada.Length))
                            {
                                estado = 7;
                                auxL   = "";
                            }
                            else
                            {
                                Console.WriteLine("Caracter no reconcido" + c);
                                addErrortoken(token.Tipo.ERROR, c.ToString());
                                error  = true;
                                estado = 0;
                                nErrores++;
                            }
                            break;
                        }
                    }
                    break;

                case 8:
                    if ((c == '"'))
                    {
                        estado = 13;
                    }
                    else
                    {
                        if (EsSeparador(i, c, entrada.Length))
                        {
                            estado = 8;
                            auxL   = "";
                        }
                        else
                        {
                            Console.WriteLine("Caracter no reconcido" + c);
                            addErrortoken(token.Tipo.ERROR, c.ToString());
                            error  = true;
                            estado = 0;
                            nErrores++;
                        }
                    }
                    break;

                case 9:

                    switch (c)
                    {
                    case '.':
                        auxL += entrada.ElementAt(i);
                        n     = new nodo(auxL, false, false, false);
                        expresiones.Last().getLista().AddLast(n);

                        addtoken(token.Tipo.concatenar);

                        estado = 9;
                        break;

                    case '*':
                        auxL += entrada.ElementAt(i);
                        n     = new nodo(auxL, false, true, true);
                        expresiones.Last().getLista().AddLast(n);

                        addtoken(token.Tipo.ceroMas);
                        estado = 9;
                        break;

                    case '+':
                        auxL += entrada.ElementAt(i);
                        n     = new nodo(auxL, false, true, false);
                        expresiones.Last().getLista().AddLast(n);

                        addtoken(token.Tipo.unoMas);
                        estado = 9;
                        break;

                    case '|':
                        auxL += entrada.ElementAt(i);
                        n     = new nodo(auxL, false, false, false);
                        expresiones.Last().getLista().AddLast(n);

                        addtoken(token.Tipo.disyun);

                        estado = 9;
                        break;

                    case '?':
                        auxL += entrada.ElementAt(i);
                        n     = new nodo(auxL, false, true, true);
                        expresiones.Last().getLista().AddLast(n);

                        addtoken(token.Tipo.ceroUno);
                        estado = 9;
                        break;

                    case '{':
                        auxL += entrada.ElementAt(i);
                        addtoken(token.Tipo.S_abrirLlaves);
                        estado = 11;
                        break;

                    case '}':
                        auxL += entrada.ElementAt(i);
                        addtoken(token.Tipo.S_cerrarLlaves);
                        estado = 11;
                        break;

                    case '"':

                        estado = 10;
                        break;

                    case ';':
                        auxL += entrada.ElementAt(i);
                        addtoken(token.Tipo.S_puntoComa);
                        estado = 0;
                        break;

                    default:
                        if (EsSeparador(i, c, entrada.Length))
                        {
                            estado = 9;
                            auxL   = "";
                        }
                        else
                        {
                            auxL += entrada.ElementAt(i);
                            Console.WriteLine("Caracter no reconcido" + c);
                            addErrortoken(token.Tipo.ERROR, c.ToString());
                            error  = true;
                            estado = 0;
                            nErrores++;
                        }
                        break;
                    }
                    break;

                case 10:
                    if (!(c == '"'))
                    {
                        auxL += entrada.ElementAt(i);
                    }
                    else
                    {
                        n = new nodo(auxL, true, false, false);
                        String t = "";
                        t += primUlt;
                        primUlt++;
                        n.setPrimeros(t);
                        n.setUltimos(t);
                        expresiones.Last().getLista().AddLast(n);
                        addtoken(token.Tipo.Terminal);
                        estado = 9;
                    }
                    break;

                case 11:
                    if (!(c == '}'))
                    {
                        auxL += entrada.ElementAt(i);
                    }
                    else
                    {
                        n = new nodo(auxL, true, false, false);
                        String t = "";
                        t += primUlt;
                        primUlt++;
                        n.setPrimeros(t);
                        n.setUltimos(t);
                        expresiones.Last().getLista().AddLast(n);
                        addtoken(token.Tipo.Terminal);
                        auxL += entrada.ElementAt(i);
                        addtoken(token.Tipo.S_cerrarLlaves);
                        estado = 9;
                    }
                    break;

                case 12:
                    if (!(c == '!'))
                    {
                        auxL += entrada.ElementAt(i);
                    }
                    else if (i == entrada.Length)
                    {
                        break;
                    }
                    else
                    {
                        auxL += entrada.ElementAt(i);
                        auxL += entrada.ElementAt(i + 1);
                        addtoken(token.Tipo.Comentario);
                        i += 2;
                    }
                    break;

                case 13:
                    if (!(c == '"'))
                    {
                        auxL += entrada.ElementAt(i);
                    }
                    else
                    {
                        addtoken(token.Tipo.lexema);
                        estado = 0;
                    }
                    break;

                case 14:
                    if (c == 'n')
                    {
                        auxL += entrada.ElementAt(i);
                        addtoken(token.Tipo.saltolinea);
                        estado = 0;
                    }
                    else
                    if (c == '\'')
                    {
                        auxL += entrada.ElementAt(i);
                        addtoken(token.Tipo.comillasimple);
                        estado = 0;
                    }
                    else
                    if (c == '\"')
                    {
                        auxL += entrada.ElementAt(i);
                        addtoken(token.Tipo.comilladoble);
                        estado = 0;
                    }
                    else
                    if (c == '\t')
                    {
                        auxL += entrada.ElementAt(i);
                        addtoken(token.Tipo.tabulacion);
                        estado = 0;
                    }
                    else
                    {
                        addtoken(token.Tipo.ERROR);
                        estado = 0;
                    }
                    break;

                case 15:
                    if (!(c == ':' && entrada.ElementAt(i + 1).Equals(']')))
                    {
                        auxL += entrada.ElementAt(i);
                    }
                    else if (c == ':')
                    {
                        auxL = "";
                    }

                    else
                    {
                        addtoken(token.Tipo.todo);
                        estado = 0;
                    }
                    break;

                default:
                    break;
                }

                /* public void imprimir() {
                 * System.out.print(entrada);
                 * }*/
            }

            return(Out);
        }