예제 #1
0
        private void L_COLUMNAS_1(NodoAST raiz)
        {
            /*L_COLUMNAS_1	⇒	I_COMO L_COLUMNAS_2
             *              |	. ID I_COMO L_COLUMNAS_2
             *
             * primeros de (L_COLUMNAS_1) ⇒ primeros de (I_COMO) U primeros de (L_COLUMNAS_2) ⇒ {COMO, ,, . }
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.CL_PUNTO:     // punto (.)
                match(TokenSQL.CL_PUNTO, raiz);

                I_COMO(raiz);

                L_COLUMNAS_2(raiz);
                break;

            case TokenSQL.PR_COMO:     //Palabra reservada COMO -> primeros de I_COMO
                I_COMO(raiz);
                L_COLUMNAS_2(raiz);
                break;

            case TokenSQL.CL_COMA:     // Coma (,) -> primeros de L_COLUMNA_2
                //I_COMO(raiz);
                L_COLUMNAS_2(raiz);
                break;

            default:
                //Error
                insertarError(" (COMO|,|.)", preanalisis);
                panico();
                break;
            }
        }
예제 #2
0
        private void I_ELIMINAR_1(NodoAST raiz)
        {
            /*I_ELIMINAR_1	⇒	DONDE CONDICION I_ELIMINAR_2
             *              |
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.PR_DONDE:     // Palabra reservada DONDE
                NodoAST nodoA = new NodoAST(id, "DONDE");
                sumarID();

                match(TokenSQL.PR_DONDE, nodoA);

                CONDICION(nodoA);

                I_ELIMINAR_2(nodoA);

                raiz.insertarHijo(nodoA);
                break;

            default:
                //No hacer nada
                break;
            }
        }
예제 #3
0
        private void TIPO_DATO(NodoAST raiz)
        {
            /*TIPO_DATO		⇒	ENTERO
             *              |	CADENA
             *              |	FLOTANTE
             *              |	FECHA
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.PR_ENTERO:     // Palabra reservada Entero
                match(TokenSQL.PR_ENTERO, raiz);
                break;

            case TokenSQL.PR_CADENA:     // Palabra reservada Cadena
                match(TokenSQL.PR_CADENA, raiz);
                break;

            case TokenSQL.PR_FLOTANTE:     // Palabra reservada Flotante
                match(TokenSQL.PR_FLOTANTE, raiz);
                break;

            case TokenSQL.PR_FECHA:     // Palabra reservada Fecha
                match(TokenSQL.PR_FECHA, raiz);
                break;

            default:
                insertarError("un tipo de dato", preanalisis);
                panico();
                break;
            }
        }
예제 #4
0
        private void VALOR(NodoAST raiz)
        {
            /*VALOR         ⇒	ENTERO
             *              |	CADENA
             *              |	FLOTANTE
             *              |	FECHA
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.ENTERO:     // Tipo de dato Entero
                match(TokenSQL.ENTERO, raiz);
                break;

            case TokenSQL.CADENA:     // Tipo de dato Cadena
                match(TokenSQL.CADENA, raiz);
                break;

            case TokenSQL.FLOTANTE:     // Tipo de dato Flotante
                match(TokenSQL.FLOTANTE, raiz);
                break;

            case TokenSQL.FECHA:     // Tipo de dato Fecha
                match(TokenSQL.FECHA, raiz);
                break;

            default:
                insertarError("un valor de dato", preanalisis);
                //panico();
                break;
            }
        }
예제 #5
0
        private void L_YO(NodoAST raiz)
        {
            /*L_YO			⇒	Y CONDICION
             *              |	O CONDICION
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.PR_Y:     // Palabra reservada Y
                match(TokenSQL.PR_Y, raiz);

                CONDICION(raiz);
                break;

            case TokenSQL.PR_O:     // Palabra reservada O
                match(TokenSQL.PR_O, raiz);

                CONDICION(raiz);
                break;

            default:
                //Error
                insertarError("(Y | O)", preanalisis);
                panico();
                break;
            }
        }
예제 #6
0
        private void I_ACTUALIZAR(NodoAST raiz)
        {
            /*I_ACTUALIZAR	⇒	ACTUALIZAR ID ESTABLECER ( L_ESTABLECER ) I_ACTUALIZAR_1 ;*/
            NodoAST nodo = new NodoAST(id, "INSTRUCCION ACTUALIZAR");

            sumarID();

            match(TokenSQL.PR_ACTUALIZAR, nodo);
            match(TokenSQL.ID, nodo);
            match(TokenSQL.PR_ESTABLECER, nodo);
            match(TokenSQL.CL_PARENTESIS_1, nodo);

            NodoAST nodoA = new NodoAST(id, "LISTA ESTABLECER");

            sumarID();
            L_ESTABLECER(nodoA);
            nodo.insertarHijo(nodoA);

            match(TokenSQL.CL_PARENTESIS_2, nodo);

            I_ACTUALIZAR_1(nodo);

            match(TokenSQL.CL_FL, nodo);

            raiz.insertarHijo(nodo);
        }
예제 #7
0
        private void I_SELECCIONAR(NodoAST raiz)
        {
            /*I_SELECCIONAR	⇒	SELECCIONAR OP_SELECT DE L_TABLAS I_SELECCIONAR_1 ;*/
            NodoAST nodo = new NodoAST(id, "INSTRUCCION SELECCIONAR");

            sumarID();

            match(TokenSQL.PR_SELECCIONAR, nodo);

            NodoAST nodoA = new NodoAST(id, "COLUMNAS");

            sumarID();
            OP_SELECT(nodoA);
            nodo.insertarHijo(nodoA);

            match(TokenSQL.PR_DE, nodo);

            NodoAST nodoB = new NodoAST(id, "TABLAS");

            sumarID();
            L_TABLAS(nodoB);
            nodo.insertarHijo(nodoB);

            NodoAST nodoC = new NodoAST(id, "DONDE");

            sumarID();
            I_SELECCIONAR_1(nodoC);
            nodo.insertarHijo(nodoC);

            match(TokenSQL.CL_FL, nodo);

            raiz.insertarHijo(nodo);
        }
예제 #8
0
        ///

        private void AREA_CONSULTAS(NodoAST raiz)
        {
            /*AREA_CONSULTAS	⇒	I_SELECCIONAR AREA_CONSULTA
             *                  |	I_ELIMINAR AREA_CONSULTA
             *                  |	I_ACTUALIZAR AREA_CONSULTA
             *                  |
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.PR_SELECCIONAR:     // Palabra reservada SELECCIONAR -> Primeros de I_SELECCIONAR
                I_SELECCIONAR(raiz);
                AREA_CONSULTAS(raiz);
                break;

            case TokenSQL.PR_ELIMINAR:     // Palabra reservada ELIMINAR -> primeros de I_ELIMINAR
                I_ELIMINAR(raiz);
                AREA_CONSULTAS(raiz);
                break;

            case TokenSQL.PR_ACTUALIZAR:     // Palabra reservada ACTUALIZAR -> primeros de I_ACTUALIZAR
                I_ACTUALIZAR(raiz);
                AREA_CONSULTAS(raiz);
                break;

            default:
                //No hacer nada
                break;
            }
        }
예제 #9
0
        private void L_VALORES(NodoAST raiz)
        {
            /*L_VALORES         ⇒	VALOR L_VALORES_1*/
            switch (preanalisis.getToken())
            {
            case TokenSQL.ENTERO:     // Tipo de dato Entero -> primeros de VALOR
                VALOR(raiz);
                L_VALORES_1(raiz);
                break;

            case TokenSQL.CADENA:     // Tipo de dato Cadena -> primeros de VALOR
                VALOR(raiz);
                L_VALORES_1(raiz);
                break;

            case TokenSQL.FLOTANTE:     // Tipo de dato Flotante -> primeros de VALOR
                VALOR(raiz);
                L_VALORES_1(raiz);
                break;

            case TokenSQL.FECHA:     // Tipo de dato Fecha -> primeros de VALOR
                VALOR(raiz);
                L_VALORES_1(raiz);
                break;

            default:
                insertarError("un valor de dato", preanalisis);
                panico();
                break;
            }
        }
예제 #10
0
        private void L_TABLAS(NodoAST raiz)
        {
            /*L_TABLAS		⇒	ID L_TABLAS_1*/
            match(TokenSQL.ID, raiz);

            L_TABLAS_1(raiz);
        }
예제 #11
0
        private void L_CAMPOS(NodoAST raiz)
        {
            /*L_CAMPOS		⇒	ID TIPO_DATO L_CAMPOS_1*/
            match(TokenSQL.ID, raiz);

            TIPO_DATO(raiz);

            L_CAMPOS_1(raiz);
        }
예제 #12
0
        private void L_ESTABLECER(NodoAST raiz)
        {
            /*L_ESTABLECER  ⇒	ID = VALOR L_ESTABLECER_1*/

            match(TokenSQL.ID, raiz);
            match(TokenSQL.CL_IGUAL, raiz);

            VALOR(raiz);

            L_ESTABLECER_1(raiz);
        }
예제 #13
0
        private void getDot(NodoAST padre)
        {
            nodos += padre.getNodoGraphviz();
            rutas += padre.getRutaGraphviz();
            //Console.WriteLine(padre.imprimir());
            foreach (NodoAST n in padre.getHijos())
            {
                //rutas += n.getRutaGraphviz();

                getDot(n);
            }
        }
예제 #14
0
        private void CONDICION(NodoAST raiz)
        {
            /*CONDICION		⇒	ID OPERADOR VALOR*/
            NodoAST nodo = new NodoAST(id, "CONDICION");

            sumarID();

            match(TokenSQL.ID, nodo);

            OPERADOR(nodo);

            VALOR(nodo);

            raiz.insertarHijo(nodo);
        }
예제 #15
0
 private void accion(int e, NodoAST padre)
 {
     if (padre.getTipo() == TokenSQL.NO_TERMINAL)
     {   //El nodo es un No terminal
         estado = getEstado(padre.getValor());
     }
     else
     {   //El nodo es un terminal
         ejecutar(e, padre.getTipo(), padre.getToken());
     }
     foreach (NodoAST h in padre.getHijos())
     {
         accion(estado, h);
     }
 }
예제 #16
0
        private void L_COLUMNAS_2(NodoAST raiz)
        {
            /*L_COLUMNAS_2  ⇒	, L_COLUMNAS
             *              |
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.CL_COMA:     // Coma (,)
                match(TokenSQL.CL_COMA, raiz);
                L_COLUMNAS(raiz);
                break;

            default:
                //No hacer nada
                break;
            }
        }
예제 #17
0
        private void I_COMO(NodoAST raiz)
        {
            /*I_COMO		⇒   COMO ID
             *              |
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.PR_COMO:     // Palabra reservada COMO
                match(TokenSQL.PR_COMO, raiz);
                match(TokenSQL.ID, raiz);
                break;

            default:
                //No hacer nada
                break;
            }
        }
예제 #18
0
        private void L_ESTABLECER_1(NodoAST raiz)
        {
            /*L_ESTABLECER_1	⇒	, L_ESTABLECER
             *                  |
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.CL_COMA:     // Coma (,)
                match(TokenSQL.CL_COMA, raiz);

                L_ESTABLECER(raiz);

                break;

            default:
                //No hacer nada
                break;
            }
        }
예제 #19
0
        private void I_SELECCIONAR_1(NodoAST raiz)
        {
            /*I_SELECCIONAR_1	⇒	DONDE CONDICION I_SELECCIONAR_2
             *                  |
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.PR_DONDE:     // Palabra reservada DONDE
                match(TokenSQL.PR_DONDE, raiz);

                CONDICION(raiz);

                I_SELECCIONAR_2(raiz);
                break;

            default:
                //No hace nada
                break;
            }
        }
예제 #20
0
        private void I_ACTUALIZAR_2(NodoAST raiz)
        {
            /*I_ACTUALIZAR_2	⇒	L_YO
             *                  |
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.PR_Y:     // Palabra reservada Y
                L_YO(raiz);
                break;

            case TokenSQL.PR_O:     // Palabra reservada O
                L_YO(raiz);
                break;

            default:
                //No hacer nada
                break;
            }
        }
예제 #21
0
        private void analisisSintactico()
        {
            escribirLinea(" - Ejecutando análisis Sintáctico...");
            //Limpiar lista de comentarios
            List <Token> tempList = new List <Token>();

            foreach (Token t in listaTokens)
            {
                if (t.getToken() != TokenSQL.COMENTARIO_BLOQUE && t.getToken() != TokenSQL.COMENTARIO_LINEA)
                {
                    tempList.Add(t);
                }
            }
            Parser ps = new Parser(tempList);

            raiz = ps.Pars();
            listaErroresSintacticos = ps.getErroes();

            escribirLinea("\t* Errores sintácticos: " + listaErroresSintacticos.Count());
        }
예제 #22
0
        private void OPERADOR(NodoAST raiz)
        {
            /*OPERADOR		⇒	<
             *              |	<=
             *              |	>
             *              |	>=
             *              |	=
             *              |	!=
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.CL_MENOR:     //<
                match(TokenSQL.CL_MENOR, raiz);
                break;

            case TokenSQL.CL_MENOR_IGUAL:     //<=
                match(TokenSQL.CL_MENOR_IGUAL, raiz);
                break;

            case TokenSQL.CL_MAYOR:     //>
                match(TokenSQL.CL_MAYOR, raiz);
                break;

            case TokenSQL.CL_MAYOR_IGUAL:     //>=
                match(TokenSQL.CL_MAYOR_IGUAL, raiz);
                break;

            case TokenSQL.CL_IGUAL:     // =
                match(TokenSQL.CL_IGUAL, raiz);
                break;

            case TokenSQL.CL_DIFERENTE:     // !=
                match(TokenSQL.CL_DIFERENTE, raiz);
                break;

            default:
                insertarError("un operador aritmético", preanalisis);
                panico();
                break;
            }
        }
예제 #23
0
        private void match(TokenSQL terminal, NodoAST raiz)
        {
            /* si preanalisis = terminal
             * entonces preanalisis = siguiente toekn
             * sino error sintactico
             */
            Console.WriteLine("Match: " + terminal + " == " + preanalisis.getToken());
            if (preanalisis.getToken() == terminal)
            {
                raiz.insertarHijo(new NodoAST(preanalisis)); // Insertamos token en el árbol AST
                preanalisis = getToken();
                index++;
            }
            else
            {
                //Error

                insertarError("un token[" + terminal.ToString() + "]", preanalisis);
                panico();
            }
        }
예제 #24
0
        private void I_ELIMINAR(NodoAST raiz)
        {
            /*I_ELIMINAR		⇒	ELIMINAR DE ID I_ELIMINAR_1 ;*/
            NodoAST nodo = new NodoAST(id, "INSTRUCCION ELIMINAR");

            sumarID();

            match(TokenSQL.PR_ELIMINAR, nodo);
            match(TokenSQL.PR_DE, nodo);
            match(TokenSQL.ID, nodo);

            //NodoAST nodoA = new NodoAST(id, "DONDE");
            //sumarID();
            //I_ELIMINAR_1(nodoA);
            //nodo.insertarHijo(nodoA);
            I_ELIMINAR_1(nodo);

            match(TokenSQL.CL_FL, nodo);

            raiz.insertarHijo(nodo);
        }
예제 #25
0
        private void CARGAR_TABLAS(NodoAST raiz)
        {
            /*CARGAR_TABLAS     ⇒	CREAR_TABLA  CARGA_TABLAS
             *                  |	I_INSERTAR  CARGAR_TABLAS
             *                  |
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.PR_CREAR:     // Palabra reservada CREAR -> primeros de CREAR_TABLA
                CREAR_TABLA(raiz);
                CARGAR_TABLAS(raiz);
                break;

            case TokenSQL.PR_INSERTAR:     //Palabra reservada INSERTAR -> primeros de I_INSERTAR
                I_INSERTAR(raiz);
                CARGAR_TABLAS(raiz);
                break;

            default:
                //No hacer nada
                break;
            }
        }
예제 #26
0
        private void OP_SELECT(NodoAST raiz)
        {
            /*OP_SELECT		⇒	L_COLUMNAS
             *              |	*
             *
             * primeros de (OP_SELECT) ⇒ primeros de (L_COLUMNAS) ⇒ {ID, *}
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.CL_POR:     // Por (*)
                match(TokenSQL.CL_POR, raiz);
                break;

            case TokenSQL.ID:     //ID -> primeros de L_COLUMNAS
                L_COLUMNAS(raiz);
                break;

            default:     //Error
                insertarError(" un ID o *", preanalisis);
                panico();
                break;
            }
        }
예제 #27
0
        private void CREAR_TABLA(NodoAST raiz)
        {
            /*CREAR TABLA ID ( L_CAMPOS ) ; */
            NodoAST nodo = new NodoAST(id, "INSTRUCCION CREAR TABLA");

            sumarID();

            match(TokenSQL.PR_CREAR, nodo);
            match(TokenSQL.PR_TABLA, nodo);
            match(TokenSQL.ID, nodo);
            match(TokenSQL.CL_PARENTESIS_1, nodo);

            NodoAST nodoB = new NodoAST(id, "LISTA DE CAMPOS");

            sumarID();
            L_CAMPOS(nodoB);
            nodo.insertarHijo(nodoB);

            match(TokenSQL.CL_PARENTESIS_2, nodo);
            match(TokenSQL.CL_FL, nodo);

            raiz.insertarHijo(nodo);
        }
예제 #28
0
        private void I_INSERTAR(NodoAST raiz)
        {
            /*I_INSERTAR        ⇒	INSERTAR EN ID VALORES ( L_VALORES ) ;*/
            NodoAST nodo = new NodoAST(id, "INSTRUCCION INSERTAR");

            sumarID();

            match(TokenSQL.PR_INSERTAR, nodo);
            match(TokenSQL.PR_EN, nodo);
            match(TokenSQL.ID, nodo);
            match(TokenSQL.PR_VALORES, nodo);
            match(TokenSQL.CL_PARENTESIS_1, nodo);

            NodoAST nodoA = new NodoAST(id, "LISTA DE VALORES");

            sumarID();
            L_VALORES(nodoA);
            nodo.insertarHijo(nodoA);

            match(TokenSQL.CL_PARENTESIS_2, nodo);
            match(TokenSQL.CL_FL, nodo);

            raiz.insertarHijo(nodo);
        }
예제 #29
0
        ///
        private void INICIO(NodoAST raiz)
        {
            /* INICIO   ⇒	CARGAR_TABLAS
             *          |	AREA_CONSULTAS
             * primeros de (INICIO) ⇒ primeros de (CARGAR_TABLAS) U primeros de (AREA_CONSULTAS)
             *          ⇒ {CREAR, INSERTAR, SELECCIONAR, ELIMINAR, ACTUALIZAR}
             */
            switch (preanalisis.getToken())
            {
            case TokenSQL.PR_CREAR:
                CARGAR_TABLAS(raiz);
                break;

            case TokenSQL.PR_INSERTAR:
                CARGAR_TABLAS(raiz);
                break;

            case TokenSQL.PR_SELECCIONAR:
                AREA_CONSULTAS(raiz);
                break;

            case TokenSQL.PR_ELIMINAR:
                AREA_CONSULTAS(raiz);
                break;

            case TokenSQL.PR_ACTUALIZAR:
                AREA_CONSULTAS(raiz);
                break;

            default:
                //Error 1
                insertarError("una instrucción a ejecutar", preanalisis);
                panico();
                break;
            }
        }
예제 #30
0
 public void insertarHijo(NodoAST nodo)
 {
     this.hijos.Add(nodo);
 }