parsero.C

Ir a la documentación de este archivo.

//===========================================================================
//= parsero.cc                                                Julio de 1998 =
//=-------------------------------------------------------------------------=
//= Analizador sintactico de proposito general en el alcance del proyecto   =
//=-------------------------------------------------------------------------=
//= ADVERTENCIA: ESTE SOFTWARE NO ESTA CONCEBIDO NI DISENNADO PARA EL USO   =
//= EN EQUIPO DE CONTROL EN LINEA EN ENTORNOS PELIGROSOS QUE REQUIERAN UN   =
//= DESEMPENNO LIBRE DE FALLAS, COMO LA OPERACION DE PLANTAS NUCLEARES,     = 
//= SISTEMAS DE NAVEGACION O COMUNICACION EN AVIONES, TRAFICO AEREO,        =
//= EQUIPO MEDICO DEL CUAL DEPENDAN VIDAS HUMANAS O SISTEMAS DE ARMAMENTO,  =
//= EN LOS CUALES UNA FALLA EN EL SOFTWARE PUEDA IMPLICAR DIRECTAMENTE LA   =
//= MUERTE, DANNOS PERSONALES O DANNOS FISICOS Y/O AMBIENTALES GRAVES       =
//= ("ACTIVIDADES DE ALGO RIESGO").                                         =
//=-------------------------------------------------------------------------=
//= Autor original: Oscar J. Chavarro G.  A.K.A. JEDILINK. Copyright (c),   =
//= 1997 - 2003, oscarchavarro@hotmail.com                                  =
//= AQUYNZA es software libre, y se rige bajo los terminos de la licencia   =
//= LGPL de GNU (http://www.gnu.org). Para mayor informacion respecto a la  =
//= licencia de uso, consulte el archivo ./doc/LICENCIA en la distribucion. =
//===========================================================================

#include "jed_defs.h"  // Incluir antes que nada, en ese modulo se definen 
                       // aspectos importantes para la portabilidad del sistema

#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "toolkits/util/parsero.h"
#include "lista.cc"

#define MAX_BUFFER 3000
char THE_buffer[MAX_BUFFER];

//===========================================================================
//= Funciones auxiliares                                                    =
//===========================================================================

void
des_punte(char *cad)
{
    int tam = strlen(cad), i;

    cad[tam-1] = '\0';
    for ( i = 0; cad[i]; i++ ) cad[i] = cad[i+1];
}

void
des_comille(char *cad)
{
    int tam = strlen(cad), i;

    if ( cad[tam-1] == '\"') cad[tam-1] = '\0';

    if ( cad[0] == '\"' ) {
        for ( i = 0; cad[i]; i++ ) cad[i] = cad[i+1];
    }
}

void
simplifique_real(char *cad)
{
    int i;

    if ( !strchr(cad, '.') ) return;

    for ( i = strlen(cad) - 1; i >= 0 && cad[i] == '0'; i-- );
    if ( cad[i] == '.' ) i--;
    cad[i + 1] = '\0';
}

void
inserte_espacios(char *cad, int i)
{
    int j;

    // Inserte un separador antes del '{'
    for ( j = strlen(cad); j >= i; j-- ) {
        cad[j + 1] = cad[j];
    }
    cad[i] = ' ';
    i++;
    // Inserte un separador despues del '{'
    for ( j = strlen(cad); j > i; j-- ) {
        cad[j + 1] = cad[j];
    }
    cad[i+1] = ' ';
}

//===========================================================================
//= CLASE PARSERO                                                           =
//===========================================================================

PARSERO::PARSERO()
{
    nivel_comentario = 0;
    nivel_bloque = 0;
    primer_pasada = TRUE;
    Remanente = NULL;
    index_fd = 0;
}

PARSERO::~PARSERO()
{
    int i;

    for ( i = 0; i < fds.tam(); i++ ) {
        fclose(fds[i]);
    }
    fds.elim();
    if ( Remanente ) delete Remanente;
}

BOOLEAN
PARSERO::leer_linea(void)
{
    char *ptr, *qtr;
    FILE *fd;

    if ( !fgets(THE_buffer, MAX_BUFFER/2, fds[index_fd]) ) {
        fclose(fds[index_fd]);
        fds.elimElem(index_fd);
        index_fd--;
        if ( !fds.tam() ) return FALSE;
        else return leer_linea();
    }
    ptr = strstr(THE_buffer, "#include");
    if ( ptr ) {
        qtr = strtok(ptr, " \t\n");
        qtr = strtok(NULL, " \t\n");
        des_punte(qtr);
        fd = fopen(qtr, "rt");
        if ( !fd ) {
            fprintf(stderr, "<PARSERO> ERROR: No encuentro el archivo "
              "\"%s\"\n    referenciado en un #include!\n", qtr);
            fflush(stderr);
            //return FALSE;
            exit(1);
        }
        fds.anx(fd);
        index_fd++;
        return leer_linea();
    }
    return TRUE;
}

BOOLEAN
PARSERO::init(char *nombre_archivo)
{
    FILE *fd = fopen(nombre_archivo, "rt");

    if ( !fd ) {
        //fprintf(stderr, "<PARSERO> ERROR: No se puede abrir el archivo "
        //    "\"%s\"\n", nombre_archivo);
        //fflush(stderr);
        return FALSE;
    }

    fds.anx(fd);

    return TRUE;
}

void
PARSERO::colapse_espacios(char *linea)
{
    int i, j;

    // Evite espacios seguidos
    for ( i = 0, j = 0; linea[i] != '\0'; i++, j++ ) {
        if ( isspace(linea[i]) ) linea[i] = ' ';
        linea[j] = linea[i];
        if ( isspace(linea[i]) && isspace(linea[i+1]) ) j--;
    }
    linea[j] = '\0';

    // Quite el primero si es espacio
    if ( isspace(linea[0]) ) {
        for ( i = 0; linea[i+1] != '\0'; i++ ) linea[i] = linea[i+1];
        linea[i] = '\0';
    }
}


BOOLEAN
PARSERO::preprocese_linea(char *linea)
{
    BOOLEAN esta_vacia = TRUE;
    int i = 0;

    //- Procesamiento de comentarios tipo C --------------------------------
    for ( i = 0; nivel_comentario == 0 && linea[i] != '\0'; i++ ) {
        if ( linea[i] == '/' && linea[i+1] == '*' ) {
            nivel_comentario++;
            linea[i] = linea[i+1] = ' ';
        }
    }

    if ( nivel_comentario > 0 ) {
        while ( linea[i] != '\0' ) {
            if ( linea[i] == '/' && linea[i+1] == '*' ) {
                nivel_comentario++;
                linea[i] = linea[i+1] = ' ';
              }
              else if ( linea[i] == '*' && linea[i+1] == '/' ) {
                nivel_comentario--;
                linea[i] = linea[i+1] = ' ';
              }
              else {
                if ( nivel_comentario > 0 ) linea[i] = ' ';
            }
            i++;
        }
    }

    //- Procesamiento de comentarios tipo C++ ------------------------------
    if ( nivel_comentario == 0 ) {
        // Los comentarios de linea solo se dan si no estan anidados.  De
        // otra manera el que se tiene en cuenta es el comentario que lo
        // contiene.
        for ( i = 0; linea[i] != '\0'; i++ ) {
            if ( linea[i] == '/' && linea[i+1] == '/' ) {
                linea[i] = '\n'; i++;
                linea[i] = '\0'; i++;
                while ( linea[i] != '\0' ) {
                    linea[i] = ' ';
                    i++;
                }
            }
        }
    }

    //- Mire si es una linea vacia------------------------------------------
    for ( i = 0; linea[i] != '\0'; i++ ) {
        if ( !isspace(linea[i]) ) {
            esta_vacia = FALSE;
            break;
        }
    }
    if ( esta_vacia ) return FALSE;

    //- Notese que varios separadores seguidos hacen un solo separador -----
    colapse_espacios(linea);

    if ( linea[strlen(linea)-1] == '\n' ) linea[strlen(linea)-1] = '\0';

    return TRUE;
}

char *
PARSERO::procese_linea(char *linea)
{
    int i;
    char *ptr = &linea[strlen(linea)];

    for ( i = 0; linea[i] != 0; i++ ) {
        if ( linea[i] == '=' ) {
            inserte_espacios(linea, i);
            i++;
        }
        if ( linea[i] == '{' ) {
            inserte_espacios(linea, i);
            nivel_bloque++;
            ptr = &(linea[i+2]);
            primer_pasada = FALSE;
            i++;
        }
        if ( linea[i] == '}' ) {
            inserte_espacios(linea, i);
            nivel_bloque--;
            ptr = &(linea[i+2]);
            primer_pasada = FALSE;
            i++;
        }
#ifdef NONONO
        if ( linea[i] == '<' ) {
            // Quite los separadores que le siguen
            for ( j = k = i+1; linea[k] != '0'; j++, k++ ) {
                while ( j == i+1 && isspace(linea[k]) ) k++; 
                linea[j] = linea[k];
            }
        }
#endif
    }

    return ptr;
}

int
PARSERO::siguiente_segmento(LISTA<char*> **LIneas)
{
    LISTA<char *> *Lineas;
    int i, j;
    char *cad, *ptr;

    primer_pasada = TRUE;

    if ( !fds.tam() ) return 0;

    //----------------------------------------------------------------------
    Lineas = new LISTA<char *>;
    if ( !Lineas ) {
        (*LIneas) = NULL;
        return -1;
    }

    for ( i = 0; leer_linea(); i++ ) {
        if ( Remanente ) {
            for ( j = strlen(THE_buffer); j >= 0; j-- ) {
                THE_buffer[j+strlen(Remanente)] = THE_buffer[j];
            }
            for ( j = strlen(Remanente) - 1; j >= 0; j-- ) {
                THE_buffer[j] = Remanente[j];
            }
            delete Remanente;
            Remanente = NULL;
        }

        if ( !preprocese_linea(THE_buffer) ) continue;

        ptr = procese_linea(THE_buffer);
        if ( !primer_pasada && nivel_bloque == 0 ) {
            // Acabo de terminar la vaina!
            if ( strlen(ptr) > 0 && !(strlen(ptr)==1 && ptr[0]==' ') ) {
                Remanente = new char[strlen(ptr) + 1];
                strcpy(Remanente, ptr);
            }
            ptr[0] = '\0';
        }

        //- Asigne espacio para la cadena
        cad = new char[strlen(THE_buffer) + 1];
        if ( !cad ) {
            for ( j = 0; j < Lineas->tam(); j++ ) {
                delete (*Lineas)[j];
            }
            Lineas->elim();
            delete Lineas;
            (*LIneas) = NULL;
            return -1;
        }
        strcpy(cad, THE_buffer);

        //- Anexe la linea a la estructura preprocesada
        Lineas->anx(cad);

        //- Reporte de bloques cada que se detecta un "}" de primer nivel
        if ( !primer_pasada && nivel_bloque == 0 ) {
            (*LIneas) = Lineas;
            return 1;
        }
    }

    // OJO: AQUI HAY UN PROBLEMA:
    //      Si el archivo ya se acabo, pero quedo un remanente de antes,
    //      es importante reportar ese remanente!  (Para probar, procese
    //      un .h donde se defina una clase... vea que el ";" despues de
    //      el ultimo "}" se desaparece si el "};" resulta ser la ultima
    //      linea!

    //- Aqui se acaba el archivo -------------------------------------------
    (*LIneas) = Lineas;
    return 1;
}

//===========================================================================
//= CLASE TOKENIZADOR                                                       =
//===========================================================================

TOKENIZADOR::TOKENIZADOR()
{
    Lineas = NULL;
    strcpy(separadores, " \n\t,;:");
}

void
TOKENIZADOR::cambiar_lista(LISTA<char *> *lst)
{
    Lineas = lst;
}

BOOLEAN
TOKENIZADOR::empiezo_con_cadena(char *cad)
{
    int i, j;
    BOOLEAN bueno;
    char *ptr;

    for ( i = 0; cad[i]; i++ ) {
        if ( cad[i] == '\"' ) break;
        for ( bueno = FALSE, j = 0; separadores[j]; j++ ) {
            if ( cad[i] == separadores[j] ) bueno = TRUE;
        }
        if ( !bueno )return FALSE;
    }

    // Empiezo con cadena, me dispongo a quitar la basura de antes de la
    // cadena.
    ptr = strchr(cad, '\"');
    for ( i = 0; cad[i] && ptr; i++, ptr++ ) {
        cad[i] = (*ptr);
    }
    cad[i] = '\0';
    return TRUE;
}

int
TOKENIZADOR::siguiente_token(char *cad)
{
    char *ptr, *qtr, mi_cad[MAX_BUFFER];
    unsigned int i;
    BOOLEAN listo;

    if ( !Lineas || Lineas->tam() < 1 ) return TK_FIN;

    do {
        //- Aisle el siguiente token ---------------------------------------
        strcpy(mi_cad, (*Lineas)[0]);
        if ( empiezo_con_cadena(mi_cad) && strlen(mi_cad) > 0 ) {
            //- Separacion de un token de tipo cadena -
            for ( listo = FALSE, i = 1; mi_cad[i]; i++ ) {
                if ( mi_cad[i] == '\"' ) {
                    mi_cad[i+1] = '\0';
                    listo = TRUE;
                    break;
                }
            }
            if ( !listo ) {
                // Quiere decir que no encontro el fin de cadena
                fprintf(stderr, "<TOKENIZER> - ERROR DE SINTAXIS, cadena no "
                    "terminada en la siguiente linea:\n%s\n", (*Lineas)[0] );
                fflush(stderr);
                exit(1);
            }
            ptr = mi_cad;
          }
          else {
            //- Separacion de un token normal -
            ptr = strtok(mi_cad, separadores);
        }

        //- Avance ----------------------------------------------------------
        if ( !ptr || !strlen(ptr) ) {
            delete (*Lineas)[0];
            Lineas->elimElem(0);
          }
          else {
            //- Quitele el primer token a la cadena -
            qtr = strstr((*Lineas)[0], ptr);
            for ( i = 0; qtr && i < strlen(ptr); i++, qtr++ ) {
                qtr[0] = ' ';
            }
            break;
        }
    }
    while( Lineas->tam() > 0 && (!ptr || !strlen(ptr)) );

    //- Determine el tipo de token adquirido ---------------------------------
    if ( ptr ) {
        strcpy(cad, ptr);
        //printf("[%s]\n", cad); fflush(stdout);
        if ( cad[0] == '\"' ) {
            return TK_CADENA;
          }
          else if ( cad[0] == '<' && isdigit(cad[1]) ||
                    cad[0] == '<' && isdigit(cad[2]) && cad[1] == '-' ) {
            return TK_VECTOR_INICIO;
          }
          else if ( cad[strlen(cad)-1]=='>' && isdigit(cad[strlen(cad)-2]) ) {
            return TK_VECTOR_FIN;
          }
          else if ( isdigit(cad[0]) ||
                    isdigit(cad[1]) && cad[0] == '-' ) {
            return TK_NUMERO;
          }
          else if ( cad[0] == '{' || cad[0] == '(' ) {
            return TK_ABRIR;
          }
          else if ( cad[0] == '}' || cad[0] == ')') {
            return TK_CERRAR;
          }
          else {
            return TK_IDENTIFICADOR;
        }
        ;
    }

    //- Borre la linea que acabo de procesar ---------------------------------
    cad[0] = '\0';
    if ( Lineas->tam() > 0 ) {
        delete (*Lineas)[0];
        Lineas->elimElem(0);
    }
    return TK_DESCONOCIDO;
}


//===========================================================================
//= EOF                                                                     =
//===========================================================================

---

Este archivo HTML ha sido generado automáticamente a partir del código fuente AQUYNZA. NO LO EDITE. Para mayor información contacte al autor.