예제 #1
0
 private void playFile(int index)
 {
     if (Registry.LocalMachine.OpenSubKey("Software\\Wow6432Node\\VideoLAN\\VLC") != null)
     {
         string vlcLocation = (string)Registry.LocalMachine.OpenSubKey("Software\\Wow6432Node\\VideoLAN\\VLC").GetValue("");
         var selectedVideoFile = '"' + "file:///" + _folder + "\\" + listBox1.SelectedItem + '"';
         selectedVideoFile = selectedVideoFile.Replace('\\', '/');
         Process.Start(vlcLocation, selectedVideoFile);
     }
     else if (Registry.LocalMachine.OpenSubKey("Software\\VideoLAN\\VLC") != null)
     {
         string vlcLocation = (string)Registry.LocalMachine.OpenSubKey("Software\\VideoLAN\\VLC").GetValue("");
         var selectedVideoFile = '"' + "file:///" + _folder + "\\" + listBox1.SelectedItem + '"';
         selectedVideoFile = selectedVideoFile.Replace('\\', '/');
         Process.Start(vlcLocation, selectedVideoFile);
     }
     else
     {
         var dialog = new error();
         dialog.ShowDialog();
     }
     this.WindowState = FormWindowState.Minimized;
 }
예제 #2
0
        private void metodoAnalizar(string textoAnalizar)
        {
            int    fila     = 0;
            int    columna  = 0;
            int    eInicial = 0;
            int    eActual  = 0;
            char   actual;
            string token     = "";
            string cadenaAux = "";

            for (eInicial = 0; eInicial < textoAnalizar.Length; eInicial++)
            {
                actual = textoAnalizar[eInicial];

                switch (eActual)
                {
                case 0:    //                                           ESTADO 0

                    switch (validarCaracter(actual))
                    {
                    case 3:        //EB
                        columna++;
                        eActual = 0;
                        break;

                    case 4:        //SL
                        fila++;
                        eActual = 0;
                        break;

                    case 5:        //{
                        columna++;
                        token tk = new token("llave abre", "" + actual, fila, columna);
                        listaToken.AddLast(tk);
                        eActual = 1;
                        break;

                    default:
                        rtbConsola.AppendText("Error caracter no reconocido " + actual + " se esperaba { \n");
                        error er = new error(actual + " ", "se esperaba {", fila, columna);
                        listaErrores.AddLast(er);
                        eActual = -1;
                        break;
                    }
                    break;

                case 1:    //                                           ESTADO 1
                    columna = 0;
                    switch (validarCaracter(actual))
                    {
                    case 3:        //EB
                        columna++;
                        eActual = 1;
                        break;

                    case 4:        //SL
                        fila++;
                        eActual = 1;
                        break;

                    case 6:        // /
                        columna++;
                        eActual = 2;
                        break;

                    case 7:        // <
                        columna++;
                        eActual = 4;
                        break;

                    case 2:        // L
                        columna++;
                        eActual = 8;
                        token  += actual;
                        break;

                    case 15:        //}
                        token tk = new token("llave cierra", "" + actual, fila, columna);
                        listaToken.AddLast(tk);
                        break;

                    default:
                        rtbConsola.AppendText("Error caracter no reconocido " + actual + " se esperaba L|<|/ \n");
                        error er = new error(actual + " ", "se esperaba L|<|/ ", fila, columna);
                        listaErrores.AddLast(er);
                        eActual = -1;
                        break;
                    }
                    break;

                case 2:    //                                            ESTADO 2
                    switch (validarCaracter(actual))
                    {
                    case 6:        // /
                        columna++;
                        eActual = 3;
                        break;

                    default:
                        rtbConsola.AppendText("Error caracter no reconocido " + actual + " se esperaba / \n");
                        error er = new error(actual + " ", "se esperaba /", fila, columna);
                        listaErrores.AddLast(er);
                        eActual = -1;
                        break;
                    }
                    break;

                case 3:    //                                           ESTADO 3
                    switch (validarCaracter(actual))
                    {
                    case 4:        //SL
                        fila++;
                        eActual = 1;
                        rtbConsola.AppendText("Comentario de una linea aceptado\n");
                        break;

                    default:        //CUALQUIER COSA
                        eActual = 3;
                        break;
                    }
                    break;

                case 4:    //                                           ESTADO 4
                    switch (validarCaracter(actual))
                    {
                    case 9:        //!
                        columna++;
                        eActual = 5;
                        break;

                    default:
                        rtbConsola.AppendText("Error caracter no reconocido " + actual + " se esperaba ! \n");
                        error er = new error(actual + " ", "se esperaba !", fila, columna);
                        listaErrores.AddLast(er);
                        eActual = -1;
                        break;
                    }
                    break;

                case 5:    //                                           ESTADO 5
                    switch (validarCaracter(actual))
                    {
                    case 9:        //!
                        columna++;
                        eActual = 6;
                        break;

                    case 4:        //SL
                        fila++;
                        eActual = 5;
                        break;

                    default:
                        eActual = 5;
                        break;
                    }
                    break;

                case 6:    //                                           ESTADO 6
                    switch (validarCaracter(actual))
                    {
                    case 8:        //>
                        columna++;
                        eActual = 1;
                        rtbConsola.AppendText("Comentario multilinea aceptado\n");
                        break;
                    }
                    break;

                case 7:    //                                           ESTADO 7
                    break;

                case 8:    //                                           ESTADO 8
                    switch (validarCaracter(actual))
                    {
                    case 1:        //N
                        token += actual;
                        columna++;
                        eActual = 8;
                        break;

                    case 2:        //L
                        token += actual;
                        columna++;
                        eActual = 8;
                        break;

                    case 18:        //_
                        token += actual;
                        columna++;
                        eActual = 8;
                        break;

                    case 3:        //EB
                        cadenaAux = token;
                        //Console.WriteLine("Guardar token ID: "+cadenaAux);
                        token  += actual;
                        eActual = 8;
                        break;

                    case 11:        //:
                        token    += actual;
                        cadenaAux = token;
                        token tk = new token("ID", cadenaAux, fila, columna);
                        listaToken.AddLast(tk);

                        token tk1 = new token("dos puntos", "" + actual, fila, columna);
                        listaToken.AddLast(tk1);

                        columna++;
                        eActual = 9;
                        break;

                    case 10:        //-
                        token += actual;
                        columna++;
                        token tk2 = new token("ID", "" + cadenaAux, fila, columna);
                        listaToken.AddLast(tk2);

                        token tk3 = new token("guion", "" + actual, fila, columna);
                        listaToken.AddLast(tk3);
                        cadenaAux = "";
                        eActual   = 20;
                        break;

                    default:
                        rtbConsola.AppendText("Error caracter no reconocido " + actual + " se esperaba L|N|_|: \n");
                        error er = new error(actual + " ", "se esperaba L|N|_|:", fila, columna);
                        listaErrores.AddLast(er);
                        eActual = -1;
                        break;
                    }
                    break;

                case 9:    //                                           ESTADO 9
                    switch (validarCaracter(actual))
                    {
                    case 2:        //L
                        cadenaAux  = "";
                        token     += actual;
                        cadenaAux += actual;
                        columna++;
                        eActual = 10;
                        break;

                    case 16:        //"
                        cadenaAux = "";
                        token    += actual;
                        columna++;
                        token tk = new token("comillas", "" + actual, fila, columna);
                        listaToken.AddLast(tk);
                        eActual = 18;
                        break;

                    case 3:        //EB
                        token += actual;
                        columna++;
                        eActual = 9;
                        break;

                    default:
                        rtbConsola.AppendText("Error caracter no reconocido " + actual + " se esperaba L|\" \n");
                        error er = new error(actual + " ", "se esperaba L|\"", fila, columna);
                        listaErrores.AddLast(er);
                        eActual = -1;
                        break;
                    }
                    break;

                case 10:    //                                              ESTADO 10
                    switch (validarCaracter(actual))
                    {
                    case 1:        //N
                        token     += actual;
                        cadenaAux += actual;
                        columna++;
                        eActual = 10;
                        break;

                    case 2:        //L
                        token     += actual;
                        cadenaAux += actual;
                        columna++;
                        eActual = 10;
                        break;

                    case 18:        //_
                        token     += actual;
                        cadenaAux += actual;
                        columna++;
                        eActual = 10;
                        break;

                    case 3:        //EB
                        columna++;
                        token  += actual;
                        eActual = 10;
                        break;

                    case 10:        //-
                        token += actual;
                        columna++;
                        token tk0 = new token("ID", cadenaAux, fila, columna);
                        listaToken.AddLast(tk0);

                        token tk1 = new token("guion", "" + actual, fila, columna);
                        listaToken.AddLast(tk1);
                        eActual = 11;
                        break;

                    default:
                        rtbConsola.AppendText("Error caracter no reconocido " + actual + " se esperaba L|N|_|- \n");
                        error er = new error(actual + " ", "se esperaba L|N|_|-", fila, columna);
                        listaErrores.AddLast(er);
                        eActual = -1;
                        break;
                    }
                    break;

                case 11:    //                                              ESTADO 11
                    switch (validarCaracter(actual))
                    {
                    case 8:        //>
                        token += actual;
                        columna++;
                        token tk = new token("mayor que", "" + actual, fila, columna);
                        listaToken.AddLast(tk);
                        eActual = 12;
                        break;

                    default:
                        rtbConsola.AppendText("Error caracter no reconocido " + actual + " se esperaba > \n");
                        error er = new error(actual + " ", "se esperaba >", fila, columna);
                        listaErrores.AddLast(er);
                        break;
                    }
                    break;

                case 12:    //                                              ESTADO 12
                    switch (validarCaracter(actual))
                    {
                    case 1:        //N
                        token += actual;
                        columna++;
                        token tk = new token("NUMERO", "" + actual, fila, columna);
                        listaToken.AddLast(tk);
                        columna++;
                        eActual = 13;
                        break;

                    case 2:        //L
                        token += actual;
                        columna++;

                        token tk1 = new token("ID", "" + actual, fila, columna);
                        listaToken.AddLast(tk1);
                        eActual = 13;
                        break;

                        //aqui idear como hacer lo del ascii de caracteres
                    }
                    break;

                case 13:    //                                              ESTADO 13
                    switch (validarCaracter(actual))
                    {
                    case 13:        //~
                        token += actual;
                        token tk = new token("guion especial", "" + actual, fila, columna);
                        listaToken.AddLast(tk);
                        columna++;
                        eActual = 14;
                        break;

                    case 14:        //,
                        token += actual;
                        token tk1 = new token("coma", "" + actual, fila, columna);
                        listaToken.AddLast(tk1);
                        columna++;
                        eActual = 16;
                        break;

                    default:
                        rtbConsola.AppendText("Error caracter no reconocido " + actual + " se esperaba ~|, \n");
                        error er = new error(actual + " ", "se esperaba ~|,", fila, columna);
                        listaErrores.AddLast(er);
                        eActual = -1;
                        break;
                    }
                    break;

                case 14:    //                                              ESTADO 14
                    switch (validarCaracter(actual))
                    {
                    case 1:        //N
                        token += actual;
                        columna++;
                        token tk = new token("ID", "" + actual, fila, columna);
                        listaToken.AddLast(tk);
                        eActual = 15;
                        break;

                    case 2:        //L
                        token += actual;
                        token tk1 = new token("LETRA", "" + actual, fila, columna);
                        listaToken.AddLast(tk1);
                        columna++;
                        eActual = 15;
                        break;

                        //aqui idear como hacer lo del ascii de caracteres
                    }
                    break;

                case 15:    //                                              ESTADO 15
                    switch (validarCaracter(actual))
                    {
                    case 12:        //;
                        token += actual;
                        columna++;
                        token tk = new token("punto y coma", "" + actual, fila, columna);
                        listaToken.AddLast(tk);
                        Console.WriteLine("\tConjunto: " + token);
                        token     = "";
                        cadenaAux = "";
                        eActual   = 1;
                        break;

                    default:
                        rtbConsola.AppendText("Error caracter no reconocido " + actual + " se esperaba ; \n");
                        error er = new error(actual + " ", "se esperaba ;", fila, columna);
                        listaErrores.AddLast(er);
                        eActual = -1;
                        break;
                    }
                    break;

                case 16:    //                                                      ESTADO 16
                    switch (validarCaracter(actual))
                    {
                    case 1:        //N
                        token += actual;
                        columna++;
                        token tk = new token("NUMERO", "" + actual, fila, columna);
                        listaToken.AddLast(tk);
                        eActual = 17;
                        break;

                    case 2:
                        token += actual;
                        columna++;

                        token tk1 = new token("LETRA", "" + actual, fila, columna);
                        listaToken.AddLast(tk1);
                        eActual = 17;
                        break;

                    default:
                        rtbConsola.AppendText("Error caracter no reconocido " + actual + " se esperaba L|N \n");
                        error er = new error(actual + " ", "se esperaba L|N", fila, columna);
                        listaErrores.AddLast(er);
                        eActual = -1;
                        break;
                    }
                    break;

                case 17:    //                                                      ESTADO 17
                    switch (validarCaracter(actual))
                    {
                    case 14:        //,
                        token += actual;
                        columna++;

                        token tk = new token("coma", "" + actual, fila, columna);
                        listaToken.AddLast(tk);
                        columna++;
                        eActual = 16;
                        break;

                    case 12:        //;
                        token += actual;
                        columna++;

                        token tk1 = new token("punto y coma", "" + actual, fila, columna);
                        listaToken.AddLast(tk1);
                        eActual = 1;
                        Console.WriteLine("\tConjunto: " + token);
                        token     = "";
                        cadenaAux = "";
                        break;

                    default:
                        rtbConsola.AppendText("Error caracter no reconocido " + actual + " se esperaba ,|; \n");
                        error er = new error(actual + " ", "se esperaba ,|;", fila, columna);
                        listaErrores.AddLast(er);
                        eActual = -1;
                        break;
                    }
                    break;

                case 18:    //                                  ESTADO 18
                    //cadenaAux = "";
                    switch (validarCaracter(actual))
                    {
                    case 16:        //"
                        token += actual;
                        columna++;

                        token tk = new token("CADENA", "" + cadenaAux, fila, columna);
                        listaToken.AddLast(tk);

                        token tk1 = new token("comillas", "" + actual, fila, columna);
                        listaToken.AddLast(tk1);
                        eActual = 19;
                        break;

                    default:
                        token     += actual;
                        cadenaAux += actual;
                        columna++;
                        eActual = 18;
                        break;
                    }
                    break;

                case 19:    //                                  ESTADO 19
                    switch (validarCaracter(actual))
                    {
                    case 3:        //EB
                        token += actual;
                        columna++;
                        eActual = 19;
                        break;

                    case 12:        //;
                        token += actual;
                        columna++;

                        token tk = new token("punto y coma", "" + actual, fila, columna);
                        listaToken.AddLast(tk);
                        Console.WriteLine("\tExpresion: " + token);
                        eActual   = 1;
                        cadenaAux = "";
                        token     = "";
                        break;
                    }
                    break;

                case 20:
                    switch (validarCaracter(actual))
                    {
                    case 8:        //>
                        token += actual;
                        columna++;
                        token tk = new token("mayor que", "" + actual, fila, columna);
                        listaToken.AddLast(tk);

                        eActual = 21;
                        break;

                    default:
                        rtbConsola.AppendText("Error caracter no reconocido " + actual + " se esperaba > \n");
                        error er = new error(actual + " ", "se esperaba >", fila, columna);
                        listaErrores.AddLast(er);
                        eActual = -1;
                        break;
                    }
                    break;

                case 21:    //                                      ESTADO 21
                    switch (validarCaracter(actual))
                    {
                    case 3:        //EB
                        token += actual;
                        columna++;
                        eActual = 21;
                        break;

                    case 17:        //OP
                        token += actual;
                        columna++;
                        token tk = new token("operador", "" + actual, fila, columna);
                        listaToken.AddLast(tk);
                        eActual = 21;
                        break;

                    case 5:        //{
                        token += actual;

                        token tk1 = new token("llave abre", "" + actual, fila, columna);
                        listaToken.AddLast(tk1);
                        columna++;
                        eActual = 22;
                        break;

                    case 16:        //"
                        token += actual;
                        columna++;
                        token tk2 = new token("comillas", "" + actual, fila, columna);
                        listaToken.AddLast(tk2);

                        eActual = 23;
                        break;

                    case 12:        //;
                        token += actual;
                        columna++;

                        token tk3 = new token("punto y coma", "" + actual, fila, columna);
                        listaToken.AddLast(tk3);
                        Console.WriteLine("\tER: " + token);
                        eActual = 1;
                        token   = "";
                        break;

                    default:
                        rtbConsola.AppendText("Error caracter no reconocido " + actual + " se esperaba OP|{|\"|; \n");
                        error er = new error(actual + " ", "se esperaba OP|{|\"|;", fila, columna);
                        listaErrores.AddLast(er);
                        eActual = -1;
                        break;
                    }
                    break;

                case 22:            //                              ESTADO 22
                    switch (validarCaracter(actual))
                    {
                    case 1:        //N
                        token     += actual;
                        cadenaAux += actual;
                        columna++;
                        eActual = 22;
                        break;

                    case 2:        //L
                        //cadenaAux = "";
                        token     += actual;
                        cadenaAux += actual;
                        columna++;
                        eActual = 22;
                        break;

                    case 18:        //_
                        token     += actual;
                        cadenaAux += actual;
                        columna++;
                        eActual = 22;
                        break;

                    case 3:        //EB
                        //Console.WriteLine("Guardar token ID: " + cadenaAux);
                        token  += actual;
                        eActual = 22;
                        break;

                    case 15:        //}
                        token += actual;
                        //cadenaAux = token;
                        columna++;

                        token tk = new token("ID", "" + cadenaAux, fila, columna);
                        listaToken.AddLast(tk);

                        token tk1 = new token("llaves cierra", "" + actual, fila, columna);
                        listaToken.AddLast(tk1);

                        eActual   = 21;
                        cadenaAux = "";
                        break;
                    }
                    break;

                case 23:
                    switch (validarCaracter(actual))
                    {
                    case 16:        //"
                        token += actual;
                        columna++;

                        token tk = new token("comillas", "" + actual, fila, columna);
                        listaToken.AddLast(tk);

                        token tk1 = new token("CADENA", "" + cadenaAux, fila, columna);
                        listaToken.AddLast(tk1);
                        eActual   = 21;
                        cadenaAux = "";
                        break;

                    default:
                        token     += actual;
                        cadenaAux += actual;
                        columna++;
                        eActual = 23;
                        break;
                    }
                    break;

                case -1:    //Estado de error
                    switch (validarCaracter(actual))
                    {
                    case 4:        //SL
                        fila++;
                        eActual = 1;
                        break;

                    case 12:        //;
                        eActual = 1;
                        break;

                    default:
                        eActual = -1;
                        break;
                    }
                    break;

                default:
                    rtbConsola.AppendText("Error caracter no reconocido \n");
                    error er1 = new error(actual + " ", "caracter no reconocido", fila, columna);
                    listaErrores.AddLast(er1);
                    eActual = -1;
                    break;
                }
            }
        }