diff --git a/ediv/src/ediv/compiler.c b/ediv/src/ediv/compiler.c index 9e909a2..10d6762 100644 --- a/ediv/src/ediv/compiler.c +++ b/ediv/src/ediv/compiler.c @@ -18,7 +18,6 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ - #include #include @@ -38,220 +37,255 @@ #include "varindex.h" #include "language.h" -void analiza_ltlex(void); /* en ltlex.c */ - +void analiza_ltlex(void); /* en ltlex.c */ void prepara_compilacion() { - int n; + int n; - vnom=NULL; + vnom = NULL; - mem_ory=NULL; - frm=NULL; - mem=NULL; - loc=NULL; + mem_ory = NULL; + frm = NULL; + mem = NULL; + loc = NULL; - itbreak=0; itcont=0; itelseif=0; - coment=0; cero=0; error_25=25; - - memset(vhash,0,256*sizeof(byte*)); - - inicializa_lower(); + itbreak = 0; + itcont = 0; + itelseif = 0; + coment = 0; + cero = 0; + error_25 = 25; - /* Inicializamos la tabla de objetos */ - memset(obj,0,sizeof(obj[0])*max_obj); - iobj=obj; - num_obj=0; + memset(vhash, 0, 256 * sizeof(byte *)); - /* Inicializamos la tabla de símbolos */ - memset(lex_simb,0,sizeof(lex_simb)); - ilex_simb=lex_simb; - num_nodos=0; + inicializa_lower(); + /* Inicializamos la tabla de objetos */ + memset(obj, 0, sizeof(obj[0]) * max_obj); + iobj = obj; + num_obj = 0; - /* Inicializamos los caracteres básicos en lex_case */ - for (n=0;n<256;n++) - if (lower[n]) { - if (n>='0' && n<='9') - lex_case[n]=(struct lex_ele *)l_num; - else - lex_case[n]=(struct lex_ele *)l_id; - } - else - lex_case[n]=(struct lex_ele *)l_err; + /* Inicializamos la tabla de símbolos */ + memset(lex_simb, 0, sizeof(lex_simb)); + ilex_simb = lex_simb; + num_nodos = 0; + /* Inicializamos los caracteres básicos en lex_case */ + for (n = 0; n < 256; n++) + if (lower[n]) + { + if (n >= '0' && n <= '9') + lex_case[n] = (struct lex_ele *)l_num; + else + lex_case[n] = (struct lex_ele *)l_id; + } + else + lex_case[n] = (struct lex_ele *)l_err; - /* Inicializamos el vector de nombres */ - vnom = e_malloc(max_obj*long_med_id+1024); - ivnom.b=vnom; + /* Inicializamos el vector de nombres */ + vnom = e_malloc(max_obj * long_med_id + 1024); + ivnom.b = vnom; + /* Leemos los símbolos y palabras reservadas de ltlex.def */ + analiza_ltlex(); - /* Leemos los símbolos y palabras reservadas de ltlex.def */ - analiza_ltlex(); + /* Terminamos de inicializar lex_case */ + lex_case[' '] = (struct lex_ele *)l_spc; + lex_case[tab] = (struct lex_ele *)l_spc; + lex_case[cr] = (struct lex_ele *)l_cr; + lex_case[lf] = (struct lex_ele *)l_cr; + lex_case[0] = (struct lex_ele *)l_eof; + /* Buffer para el bytecode */ + imem_max = default_buffer; + imem = 0; + mem_ory = mem = e_malloc(imem_max * sizeof(int)); + memset(mem, 0, imem_max * sizeof(int)); - /* Terminamos de inicializar lex_case */ - lex_case[' ']=(struct lex_ele *)l_spc; - lex_case[tab]=(struct lex_ele *)l_spc; - lex_case[cr]=(struct lex_ele *)l_cr; - lex_case[lf]=(struct lex_ele *)l_cr; - lex_case[0]=(struct lex_ele *)l_eof; + /* Buffer para variables locales y privadas */ + iloc_max = default_buffer / 2; + iloc = 0; + iloc_len = 0; + loc = e_malloc(iloc_max * sizeof(int)); + memset(loc, 0, iloc_max * sizeof(int)); - /* Buffer para el bytecode */ - imem_max=default_buffer; imem=0; - mem_ory = mem = e_malloc(imem_max*sizeof(int)); - memset(mem,0,imem_max*sizeof(int)); + /* ¿Que es esto? */ + ifrm_max = default_buffer / 2; + frm = e_malloc(ifrm_max * sizeof(int)); + memset(frm, 0, ifrm_max * sizeof(int)); - /* Buffer para variables locales y privadas */ - iloc_max=default_buffer/2; iloc=0; iloc_len=0; - loc = e_malloc(iloc_max*sizeof(int)); - memset(loc,0,iloc_max*sizeof(int)); + imem = long_header; - /* ¿Que es esto? */ - ifrm_max=default_buffer/2; - frm = e_malloc(ifrm_max*sizeof(int)); - memset(frm,0,ifrm_max*sizeof(int)); + *(prog + progsize) = 0; - imem=long_header; + _source = NULL; - *(prog+progsize)=0; - - _source=NULL; - - linsize=0; + linsize = 0; } void compila() { - struct objeto * i; - FILE *f; - int n,l; - unsigned long m; - byte * q, * p; - int start_lin, start_dbg; - byte* varptr; /* variables indexadas */ - FILE* fvar; - - ultima_linea=prog; - acceso_remoto=0; parametros=0; linea=1; - linf=NULL; - - printf(translate(27)); - - /* inicio_textos debe ser como mínimo 256 */ - if(imem<256) imem=256; - itxt=inicio_textos=imem; - psintactico(); /* Para obtener "longitud_textos" */ - imem+=longitud_textos; - #ifdef _DEBUG - printf("dbg: longitud_textos: %d\n",longitud_textos); - #endif + struct objeto *i; + FILE *f; + int n, l; + unsigned long m; + byte *q, *p; + int start_lin, start_dbg; + byte *varptr; /* variables indexadas */ + FILE *fvar; - test_buffer(&mem,&imem_max,imem); - - if(n_errors>0) return; + ultima_linea = prog; + acceso_remoto = 0; + parametros = 0; + linea = 1; + linf = NULL; - num_obj_predefinidos=num_obj; + print_translate(27); - ultima_linea=source; - acceso_remoto=0; parametros=0; linea=1; + /* inicio_textos debe ser como mínimo 256 */ + if (imem < 256) + imem = 256; + itxt = inicio_textos = imem; + psintactico(); /* Para obtener "longitud_textos" */ + imem += longitud_textos; +#ifdef _DEBUG + printf("dbg: longitud_textos: %d\n", longitud_textos); +#endif - sintactico(); + test_buffer(&mem, &imem_max, imem); - i=obj; - while (iusado) { - linea=i->linea; - ierror=i->ierror; - error(0,34,i->name); /* nombre desconocido */ - } - i++; - } - - if(n_errors>0) return; - - /* Borra todo y comienza de nuevo :P */ - - printf(translate(28)); - - if (frm!=NULL) { free(frm); frm=NULL; } - if (loc!=NULL) { free(loc); loc=NULL; } - if (mem!=NULL) { free(mem); mem=mem_ory=NULL; } - if (vnom!=NULL) { free(vnom); vnom=NULL; } - - prepara_compilacion(); - source=prog; - - inicializa_index(); /* ahora toca construir el indice de variables */ - dll_func2(); /* recarga sólo las dlls necesarias */ - - if(debug) { - if((linf=tmpfile())==NULL) { - printf(translate(29)); - exit(1); - } - } + if (n_errors > 0) + return; - /* inicio_textos debe ser como mínimo 256 */ - if(imem<256) imem=256; - itxt=inicio_textos=imem; - imem+=longitud_textos; - test_buffer(&mem,&imem_max,imem); - num_obj_predefinidos=num_obj; - acceso_remoto=0; parametros=0; linea=1; - - sintactico(); - - /* + num_obj_predefinidos = num_obj; + + ultima_linea = source; + acceso_remoto = 0; + parametros = 0; + linea = 1; + + sintactico(); + + i = obj; + while (i < iobj) + { + if (i->usado) + { + linea = i->linea; + ierror = i->ierror; + error(0, 34, i->name); /* nombre desconocido */ + } + i++; + } + + if (n_errors > 0) + return; + + /* Borra todo y comienza de nuevo :P */ + + print_translate(28); + + if (frm != NULL) + { + free(frm); + frm = NULL; + } + if (loc != NULL) + { + free(loc); + loc = NULL; + } + if (mem != NULL) + { + free(mem); + mem = mem_ory = NULL; + } + if (vnom != NULL) + { + free(vnom); + vnom = NULL; + } + + prepara_compilacion(); + source = prog; + + inicializa_index(); /* ahora toca construir el indice de variables */ + dll_func2(); /* recarga sólo las dlls necesarias */ + + if (debug) + { + if ((linf = tmpfile()) == NULL) + { + print_translate(29); + exit(1); + } + } + + /* inicio_textos debe ser como mínimo 256 */ + if (imem < 256) + imem = 256; + itxt = inicio_textos = imem; + imem += longitud_textos; + test_buffer(&mem, &imem_max, imem); + num_obj_predefinidos = num_obj; + acceso_remoto = 0; + parametros = 0; + linea = 1; + + sintactico(); + + /* * Ahora que estamos en el final del bytecode, añadiremos la rutina que carga * las DLLs. Lo primero es guardar las cadenas con los nombres: */ - for(n=0;n=P_SIEMPRE) { - dlls[n].mem_nombre=imem; - l=strlen(dlls[n].nombre); - memcpy(&mem[imem],dlls[n].nombre,l+1); - imem+=(l+4)/4; - test_buffer(&mem,&imem_max,imem); - } + for (n = 0; n < numdlls; n++) + if (dlls[n].usado || dlls[n].prioridad >= P_SIEMPRE) + { + dlls[n].mem_nombre = imem; + l = strlen(dlls[n].nombre); + memcpy(&mem[imem], dlls[n].nombre, l + 1); + imem += (l + 4) / 4; + test_buffer(&mem, &imem_max, imem); + } - /* Si estamos compilando en modo debug, añadimos tambien la debug.dll */ - if(debug) { - dlls[numdlls].mem_nombre=imem; - memcpy(&mem[imem],"debug",6); - imem+=2; - test_buffer(&mem,&imem_max,imem); - } - - /* + /* Si estamos compilando en modo debug, añadimos tambien la debug.dll */ + if (debug) + { + dlls[numdlls].mem_nombre = imem; + memcpy(&mem[imem], "debug", 6); + imem += 2; + test_buffer(&mem, &imem_max, imem); + } + + /* * Ahora estamos en la posición donde comienza la rutina, por lo que tenemos * que guardar la posición actual en el offset que guardamos en salto_import */ - mem[salto_import]=imem; - - /* Escribimos la rutina de carga de DLLs */ - for(n=0;n=P_SIEMPRE) - g2(limp,dlls[n].mem_nombre); + mem[salto_import] = imem; - if(debug) - g2(limp,dlls[numdlls].mem_nombre); + /* Escribimos la rutina de carga de DLLs */ + for (n = 0; n < numdlls; n++) + if (dlls[n].usado || dlls[n].prioridad >= P_SIEMPRE) + g2(limp, dlls[n].mem_nombre); - g2(ljmp,salto_import+1); - - /* Ya está !! :) */ - - /* Preparamos la cabecera del bytecode */ - mem[2]=imem; - mem[3]=max_process; /* Antes long_header, ahora no se utiliza */ - mem[4]=0; /* Antes mem[1]-mem[3] (long datos globales), ahora no se utiliza */ - mem[5]=iloc_len-iloc; - mem[6]=iloc; - mem[7]=0; /* Antes imem+iloc (inicio textos), ahora no se utiliza */ - mem[8]=imem+iloc; /* Número de elementos ocupados en mem[] */ + if (debug) + g2(limp, dlls[numdlls].mem_nombre); - /* + g2(ljmp, salto_import + 1); + + /* Ya está !! :) */ + + /* Preparamos la cabecera del bytecode */ + mem[2] = imem; + mem[3] = max_process; /* Antes long_header, ahora no se utiliza */ + mem[4] = 0; /* Antes mem[1]-mem[3] (long datos globales), ahora no se utiliza */ + mem[5] = iloc_len - iloc; + mem[6] = iloc; + mem[7] = 0; /* Antes imem+iloc (inicio textos), ahora no se utiliza */ + mem[8] = imem + iloc; /* Número de elementos ocupados en mem[] */ + + /* * mem[0] se usa para almacenar flags para el ejecutable. En el caso de DIV 2, * éstas eran: * +1 = El programa es un setup de sonido (setup_program) @@ -261,7 +295,7 @@ void compila() * "VERSIÓN DE DEMOSTRACIÓN") */ - /* + /* * nosotros usaremos las siguientes: * +16 = El exe lleva incluidas las DLL's * A ver como lo hacemos en Linux.. 1) con temporales o 2) hurgando en el codigo @@ -272,753 +306,1228 @@ void compila() * ha usado la orden "trazar programa" en el IDE) * +512 = ignore_errors, igual que en DIV2 */ - - mem[0]=0; - if (debug) mem[0]+=64; - if (ignore_errors) mem[0]+=512; - /* + mem[0] = 0; + if (debug) + mem[0] += 64; + if (ignore_errors) + mem[0] += 512; + + /* * Generamos los listados (debe hacerse ahora porque en el listado de objetos guardamos * los valores de mem[1..8]) */ - if(listados) { - printf(translate(30)); - if(listados & 1) listado_ensamblador(); - if(listados & 2) listado_objetos(); - } + if (listados) + { + print_translate(30); + if (listados & 1) + listado_ensamblador(); + if (listados & 2) + listado_objetos(); + } - if(noexe) return; + if (noexe) + return; - printf(translate(31)); + print_translate(31); - /* descomprime la edivrun.lib y guarda una copia con el nombre temp.dj! */ - _encriptar(0,edivrun_lib,la_clave); - _comprimir(0,"temp.dj!"); + /* descomprime la edivrun.lib y guarda una copia con el nombre temp.dj! */ + _encriptar(0, edivrun_lib, la_clave); + _comprimir(0, "temp.dj!"); - /* si el archivo de salida ya existe, lo borra */ - if((f = fopen(outfilename, "rb"))!=NULL) { - fclose(f); - remove(outfilename); - } + /* si el archivo de salida ya existe, lo borra */ + if ((f = fopen(outfilename, "rb")) != NULL) + { + fclose(f); + remove(outfilename); + } - /* renombra temp.dj! al nombre del exe */ - if(rename("temp.dj!",outfilename)) { - printf(translate(33)); /* error escribiendo ejecutable */ - remove("temp.dj!"); - exit(1); - } + /* renombra temp.dj! al nombre del exe */ + if (rename("temp.dj!", outfilename)) + { + print_translate(33); /* error escribiendo ejecutable */ + remove("temp.dj!"); + exit(1); + } - /* ordenamos varindex */ - ordena_varindex(); + /* ordenamos varindex */ + ordena_varindex(); - /* escribimos en un temporal todo el indice de variables */ - fvar=tmpfile(); - for(n=0;n2*1000*1000) errormem(); + if (n + buffer_grow > 2 * 1000 * 1000) + errormem(); - if (n>*maximo-security_distance) { - max=*maximo; - *maximo=n+buffer_grow; - max=*maximo-max; - if (*buffer==mem) { - if ((*buffer=mem_ory=(int *)realloc(*buffer,*maximo*sizeof(int)))==NULL) - errormem(); - } else { - if ((*buffer=(int *)realloc(*buffer,*maximo*sizeof(int)))==NULL) - errormem(); - } - memset((byte*)*buffer+(*maximo-max)*sizeof(int),0,max*sizeof(int)); - } + if (n > *maximo - security_distance) + { + max = *maximo; + *maximo = n + buffer_grow; + max = *maximo - max; + if (*buffer == mem) + { + if ((*buffer = mem_ory = (int *)realloc(*buffer, *maximo * sizeof(int))) == NULL) + errormem(); + } + else + { + if ((*buffer = (int *)realloc(*buffer, *maximo * sizeof(int))) == NULL) + errormem(); + } + memset((byte *)*buffer + (*maximo - max) * sizeof(int), 0, max * sizeof(int)); + } } - /* * void sentencia(void) * Analiza un bloque de sentencias */ -void sentencia(void) { +void sentencia(void) +{ - int im1,im2,im3,im4; - int dir,from,to,step; + int im1, im2, im3, im4; + int dir, from, to, step; - while (pieza>=p_return) { - test_buffer(&mem,&imem_max,imem); - switch (pieza) { - case p_return: - inicio_sentencia(); - lexico(); if (pieza==p_abrir) { - lexico(); if (pieza!=p_cerrar) { - expresion(); if (pieza!=p_cerrar) error(3,18); /* esperando ')' */ - g1(lrtf); - } else { - g1(lret); - } lexico(); - } else { + while (pieza >= p_return) + { + test_buffer(&mem, &imem_max, imem); + switch (pieza) + { + case p_return: + inicio_sentencia(); + lexico(); + if (pieza == p_abrir) + { + lexico(); + if (pieza != p_cerrar) + { + expresion(); + if (pieza != p_cerrar) + error(3, 18); /* esperando ')' */ + g1(lrtf); + } + else + { g1(lret); } - if (!free_sintax) if (pieza!=p_ptocoma) error(3,9); /* esperando ';' */ - while (pieza==p_ptocoma || pieza==p_coma) lexico(); - final_sentencia(); grabar_sentencia(); break; - case p_if: - telseif[itelseif++]=0; + lexico(); + } + else + { + g1(lret); + } + if (!free_sintax) + if (pieza != p_ptocoma) + error(3, 9); /* esperando ';' */ + while (pieza == p_ptocoma || pieza == p_coma) + lexico(); + final_sentencia(); + grabar_sentencia(); + break; + case p_if: + telseif[itelseif++] = 0; + inicio_sentencia(); + lexico(); + if (!free_sintax) + if (pieza != p_abrir) + error(3, 22); /* esperando '(' */ + if (pieza == p_abrir) + lexico(); + condicion(); + if (!free_sintax) + if (pieza != p_cerrar) + error(3, 18); /* esperando ')' */ + if (pieza == p_cerrar) + lexico(); + g2(ljpf, 0); + im1 = imem - 1; + final_sentencia(); + grabar_sentencia(); + if1: + sentencia(); + if (pieza == p_else) + { inicio_sentencia(); lexico(); - if (!free_sintax) if (pieza!=p_abrir) error(3,22); /* esperando '(' */ - if (pieza==p_abrir) lexico(); - condicion(); - if (!free_sintax) if (pieza!=p_cerrar) error(3,18); /* esperando ')' */ - if (pieza==p_cerrar) lexico(); - g2(ljpf,0); im1=imem-1; - final_sentencia(); grabar_sentencia(); - if1: + g2(ljmp, 0); + mem[im1] = imem; + im1 = imem - 1; + final_sentencia(); + grabar_sentencia(); sentencia(); - if (pieza==p_else) { - inicio_sentencia(); + } + else if (pieza == p_elseif) + { + if (itelseif == 0) + error(0, 73); /* elseif fuera de bloque if */ + inicio_sentencia(); + g2(ljmp, 0); + telseif[itelseif++] = imem - 1; + mem[im1] = imem; + lexico(); + if (!free_sintax) + if (pieza != p_abrir) + error(3, 22); /* esperando '(' */ + if (pieza == p_abrir) lexico(); - g2(ljmp,0); mem[im1]=imem; im1=imem-1; - final_sentencia(); grabar_sentencia(); - sentencia(); - }else if (pieza==p_elseif) { - if (itelseif==0) error(0,73); /* elseif fuera de bloque if */ - inicio_sentencia(); - g2(ljmp,0); telseif[itelseif++]=imem-1; - mem[im1]=imem; - lexico(); - if (!free_sintax) if (pieza!=p_abrir) error(3,22); /* esperando '(' */ - if (pieza==p_abrir) lexico(); - condicion(); - if (!free_sintax) if (pieza!=p_cerrar) error(3,18); /* esperando ')' */ - if (pieza==p_cerrar) lexico(); - g2(ljpf,0); im1=imem-1; - final_sentencia(); grabar_sentencia(); - goto if1; - } - mem[im1]=imem; if (pieza!=p_end) error(0,57); lexico(); /* esperando END */ - while (telseif[--itelseif]!=0) mem[telseif[itelseif]]=imem; - break; - case p_loop: - tbreak[itbreak++]=0; tcont[itcont++]=0; - lexico(); - im1=imem; sentencia(); - if (pieza!=p_end) error(0,57); /* esperando END */ - inicio_sentencia(); lexico(); - g2(ljmp,im1); - while (tbreak[--itbreak]!=0) mem[tbreak[itbreak]]=imem; - while (tcont[--itcont]!=0) mem[tcont[itcont]]=im1; - final_sentencia(); grabar_sentencia(); - break; - case p_while: - inicio_sentencia(); - tbreak[itbreak++]=0; tcont[itcont++]=0; im1=imem; - lexico(); - if (!free_sintax) if (pieza!=p_abrir) error(3,22); /* esperando '(' */ - if (pieza==p_abrir) lexico(); condicion(); - if (!free_sintax) if (pieza!=p_cerrar) error(3,18); /* esperando ')' */ - if (pieza==p_cerrar) lexico(); - g2(ljpf,0); im2=imem-1; - final_sentencia(); grabar_sentencia(); - sentencia(); - if (pieza!=p_end) error(0,57); inicio_sentencia(); /* esperando END */ - lexico(); - g2(ljmp,im1); mem[im2]=imem; - while (tbreak[--itbreak]!=0) mem[tbreak[itbreak]]=imem; - while (tcont[--itcont]!=0) mem[tcont[itcont]]=im1; - final_sentencia(); grabar_sentencia(); - break; - case p_repeat: - tbreak[itbreak++]=0; tcont[itcont++]=0; - lexico(); - im1=imem; sentencia(); - if (pieza!=p_until) error(0,58); /* esperando UNTIL */ - inicio_sentencia(); - lexico(); - if (!free_sintax) if (pieza!=p_abrir) error(3,22); /* esperando '(' */ - if (pieza==p_abrir) lexico(); - condicion(); - if (!free_sintax) if (pieza!=p_cerrar) error(3,18); /* esperando ')' */ - if (pieza==p_cerrar) lexico(); - g2(ljpf,im1); - while (tbreak[--itbreak]!=0) mem[tbreak[itbreak]]=imem; - while (tcont[--itcont]!=0) mem[tcont[itcont]]=im1; - final_sentencia(); grabar_sentencia(); - break; - case p_from: - inicio_sentencia(); - tbreak[itbreak++]=0; tcont[itcont++]=0; - lexico(); - if (pieza!=p_id) error(0,59); /* esperando una variable */ - - if (o->tipo==tvglo) { - dir=o->vglo.offset; g2(lcar,dir); - } else if (o->tipo==tvloc && (!o->bloque || o->bloque==bloque_actual)) { - dir=-o->vloc.offset; - g2(lcar,-dir); g1(laid); - } else error(0,59); /* esperando una variable */ - - lexico(); - if (pieza!=p_asig) error(3,7); lexico(); /* esperando '=' */ - from=constante(); - if (pieza!=p_to) error(1,60); lexico(); /* esperando TO */ - to=constante(); - if (from==to) error(4,61); /* sentencia FROM incorrecta */ - if (pieza==p_step) { + if (!free_sintax) + if (pieza != p_cerrar) + error(3, 18); /* esperando ')' */ + if (pieza == p_cerrar) lexico(); - step=constante(); - if (fromto && step>=0) error(4,62); - } else { - if (fromtipo == tvglo) + { + dir = o->vglo.offset; + g2(lcar, dir); + } + else if (o->tipo == tvloc && (!o->bloque || o->bloque == bloque_actual)) + { + dir = -o->vloc.offset; + g2(lcar, -dir); + g1(laid); + } + else + error(0, 59); /* esperando una variable */ - if (dir>=0) { /* Comparación de la condición de permanencia */ - g2(lcar,dir); - } else { - g2(lcar,-dir); g1(laid); - } - g1(lptr); g2(lcar,to); - if (step>0) g1(lmei); else g1(lmai); - g2(ljpf,0); im2=imem-1; + lexico(); + if (pieza != p_asig) + error(3, 7); + lexico(); /* esperando '=' */ + from = constante(); + if (pieza != p_to) + error(1, 60); + lexico(); /* esperando TO */ + to = constante(); + if (from == to) + error(4, 61); /* sentencia FROM incorrecta */ + if (pieza == p_step) + { + lexico(); + step = constante(); + if (from < to && step <= 0) + error(4, 62); /* el valor step no es válido */ + if (from > to && step >= 0) + error(4, 62); + } + else + { + if (from < to) + step = 1; + else + step = -1; + } + g2(lcar, from); /* Asignación del from */ + g1(lasi); + g1(lasp); - final_sentencia(); grabar_sentencia(); - if (!free_sintax) if (pieza!=p_ptocoma) error(3,9); /* esperando ';' */ - while (pieza==p_ptocoma || pieza==p_coma) lexico(); + im1 = imem; /* Inicio del bucle */ - sentencia(); - if (pieza!=p_end) error(0,57); inicio_sentencia(); /* esperando END */ + if (dir >= 0) + { /* Comparación de la condición de permanencia */ + g2(lcar, dir); + } + else + { + g2(lcar, -dir); + g1(laid); + } + g1(lptr); + g2(lcar, to); + if (step > 0) + g1(lmei); + else + g1(lmai); + g2(ljpf, 0); + im2 = imem - 1; + + final_sentencia(); + grabar_sentencia(); + if (!free_sintax) + if (pieza != p_ptocoma) + error(3, 9); /* esperando ';' */ + while (pieza == p_ptocoma || pieza == p_coma) lexico(); - im3=imem; /* Posición del continue */ + sentencia(); + if (pieza != p_end) + error(0, 57); + inicio_sentencia(); /* esperando END */ + lexico(); - if (dir>=0) { /* Incremento y vuelta al inicio del bucle */ - g2(lcar,dir); - } else { - g2(lcar,-dir); g1(laid); - } - g2(lcar,step); - g1(lada); g1(lasp); - g2(ljmp,im1); mem[im2]=imem; + im3 = imem; /* Posición del continue */ - while (tbreak[--itbreak]!=0) mem[tbreak[itbreak]]=imem; - while (tcont[--itcont]!=0) mem[tcont[itcont]]=im3; - final_sentencia(); grabar_sentencia(); + if (dir >= 0) + { /* Incremento y vuelta al inicio del bucle */ + g2(lcar, dir); + } + else + { + g2(lcar, -dir); + g1(laid); + } + g2(lcar, step); + g1(lada); + g1(lasp); + g2(ljmp, im1); + mem[im2] = imem; - break; + while (tbreak[--itbreak] != 0) + mem[tbreak[itbreak]] = imem; + while (tcont[--itcont] != 0) + mem[tcont[itcont]] = im3; + final_sentencia(); + grabar_sentencia(); - case p_for: - inicio_sentencia(); - tbreak[itbreak++]=0; tcont[itcont++]=0; - lexico(); - if (pieza!=p_abrir) error(3,22); lexico(); /* esperando '(' */ - if (pieza!=p_ptocoma) { - expresion(); g1(lasp); - while (pieza==p_coma) { lexico(); expresion(); g1(lasp); } - } im1=imem; - if (pieza!=p_ptocoma) error(3,9); lexico(); /* esperando ';' */ - if (pieza==p_ptocoma) { - g2(lcar,1); - } else expresion(); - g2(ljpf,0); im2=imem-1; - while (pieza==p_coma) { lexico(); expresion(); - g2(ljpf,im2); im2=imem-1; } - g2(ljmp,0); im3=imem-1; - if (pieza!=p_ptocoma) error(3,9); lexico(); /* esperando ';' */ - if (pieza!=p_cerrar) { - expresion(); g1(lasp); - while (pieza==p_coma) { lexico(); expresion(); g1(lasp); } - } - g2(ljmp,im1); - if (pieza!=p_cerrar) error(3,18); lexico(); /* esperando ')' */ - final_sentencia(); grabar_sentencia(); - mem[im3++]=imem; sentencia(); - if (pieza!=p_end) error(0,57); /* esperando END */ - inicio_sentencia(); lexico(); - g2(ljmp,im3); - do { im1=mem[im2]; mem[im2]=imem; im2=im1; } while(im2); - while (tbreak[--itbreak]!=0) mem[tbreak[itbreak]]=imem; - while (tcont[--itcont]!=0) mem[tcont[itcont]]=im3; - final_sentencia(); grabar_sentencia(); - break; - case p_switch: - inicio_sentencia(); - lexico(); - if (!free_sintax) if (pieza!=p_abrir) error(3,22); /* esperando '(' */ - if (pieza==p_abrir) lexico(); - condicion(); - if (!free_sintax) if (pieza!=p_cerrar) error(3,18); /* esperando ')' */ - if (pieza==p_cerrar) lexico(); - while (pieza==p_ptocoma) { + break; + + case p_for: + inicio_sentencia(); + tbreak[itbreak++] = 0; + tcont[itcont++] = 0; + lexico(); + if (pieza != p_abrir) + error(3, 22); + lexico(); /* esperando '(' */ + if (pieza != p_ptocoma) + { + expresion(); + g1(lasp); + while (pieza == p_coma) + { lexico(); - } - final_sentencia(); grabar_sentencia(); - im1=0; im2=0; - while (pieza!=p_end) { - inicio_sentencia(); - if (pieza==p_case) { - im3=0; do { - - lexico(); - if (im1) mem[im1]=imem; - expresion(); if (pieza!=p_rango) { - g2(lcse,0); im1=imem-1; - } else { - lexico(); expresion(); - g2(lcsr,0); im1=imem-1; - } - - if (pieza==p_coma) { - g2(ljmp,im3); im3=imem-1; - } - - } while (pieza==p_coma); - - while(im3) { im4=mem[im3]; mem[im3]=imem; im3=im4; } - - } else if (pieza==p_default) { - lexico(); - if (im1) mem[im1]=imem; im1=0; - } else error(0,63); /* esperando case, default o end */ - if (!free_sintax) if (pieza!=p_ptocoma) error(3,64); /* esperando ':' */ - while (pieza==p_ptocoma || pieza==p_coma) lexico(); + expresion(); g1(lasp); - final_sentencia(); grabar_sentencia(); - sentencia(); - if (pieza!=p_end) error(0,57); /* esperando END */ - inicio_sentencia(); - g2(ljmp,im2); im2=imem-1; - pasa_ptocoma(); - final_sentencia(); grabar_sentencia(); - } inicio_sentencia(); - if (im1) mem[im1]=imem; g1(lasp); - while(im2) { im1=mem[im2]; mem[im2]=imem; im2=im1; } + } + } + im1 = imem; + if (pieza != p_ptocoma) + error(3, 9); + lexico(); /* esperando ';' */ + if (pieza == p_ptocoma) + { + g2(lcar, 1); + } + else + expresion(); + g2(ljpf, 0); + im2 = imem - 1; + while (pieza == p_coma) + { lexico(); - final_sentencia(); grabar_sentencia(); break; - case p_frame: + expresion(); + g2(ljpf, im2); + im2 = imem - 1; + } + g2(ljmp, 0); + im3 = imem - 1; + if (pieza != p_ptocoma) + error(3, 9); + lexico(); /* esperando ';' */ + if (pieza != p_cerrar) + { + expresion(); + g1(lasp); + while (pieza == p_coma) + { + lexico(); + expresion(); + g1(lasp); + } + } + g2(ljmp, im1); + if (pieza != p_cerrar) + error(3, 18); + lexico(); /* esperando ')' */ + final_sentencia(); + grabar_sentencia(); + mem[im3++] = imem; + sentencia(); + if (pieza != p_end) + error(0, 57); /* esperando END */ + inicio_sentencia(); + lexico(); + g2(ljmp, im3); + do + { + im1 = mem[im2]; + mem[im2] = imem; + im2 = im1; + } while (im2); + while (tbreak[--itbreak] != 0) + mem[tbreak[itbreak]] = imem; + while (tcont[--itcont] != 0) + mem[tcont[itcont]] = im3; + final_sentencia(); + grabar_sentencia(); + break; + case p_switch: + inicio_sentencia(); + lexico(); + if (!free_sintax) + if (pieza != p_abrir) + error(3, 22); /* esperando '(' */ + if (pieza == p_abrir) + lexico(); + condicion(); + if (!free_sintax) + if (pieza != p_cerrar) + error(3, 18); /* esperando ')' */ + if (pieza == p_cerrar) + lexico(); + while (pieza == p_ptocoma) + { + lexico(); + } + final_sentencia(); + grabar_sentencia(); + im1 = 0; + im2 = 0; + while (pieza != p_end) + { inicio_sentencia(); - lexico(); if (pieza==p_abrir) { - lexico(); if (pieza!=p_cerrar) { - expresion(); if (pieza!=p_cerrar) error(3,18); /* esperando ')' */ - g1(lfrf); - } else { - g1(lfrm); - } lexico(); - } else { + if (pieza == p_case) + { + im3 = 0; + do + { + + lexico(); + if (im1) + mem[im1] = imem; + expresion(); + if (pieza != p_rango) + { + g2(lcse, 0); + im1 = imem - 1; + } + else + { + lexico(); + expresion(); + g2(lcsr, 0); + im1 = imem - 1; + } + + if (pieza == p_coma) + { + g2(ljmp, im3); + im3 = imem - 1; + } + + } while (pieza == p_coma); + + while (im3) + { + im4 = mem[im3]; + mem[im3] = imem; + im3 = im4; + } + } + else if (pieza == p_default) + { + lexico(); + if (im1) + mem[im1] = imem; + im1 = 0; + } + else + error(0, 63); /* esperando case, default o end */ + if (!free_sintax) + if (pieza != p_ptocoma) + error(3, 64); /* esperando ':' */ + while (pieza == p_ptocoma || pieza == p_coma) + lexico(); + g1(lasp); + final_sentencia(); + grabar_sentencia(); + sentencia(); + if (pieza != p_end) + error(0, 57); /* esperando END */ + inicio_sentencia(); + g2(ljmp, im2); + im2 = imem - 1; + pasa_ptocoma(); + final_sentencia(); + grabar_sentencia(); + } + inicio_sentencia(); + if (im1) + mem[im1] = imem; + g1(lasp); + while (im2) + { + im1 = mem[im2]; + mem[im2] = imem; + im2 = im1; + } + lexico(); + final_sentencia(); + grabar_sentencia(); + break; + case p_frame: + inicio_sentencia(); + lexico(); + if (pieza == p_abrir) + { + lexico(); + if (pieza != p_cerrar) + { + expresion(); + if (pieza != p_cerrar) + error(3, 18); /* esperando ')' */ + g1(lfrf); + } + else + { g1(lfrm); } - if (!free_sintax) if (pieza!=p_ptocoma) error(3,9); /* esperando ';' */ - while (pieza==p_ptocoma || pieza==p_coma) lexico(); - final_sentencia(); grabar_sentencia(); break; - case p_debug: - inicio_sentencia(); - g1(ldbg); lexico(); - if (!free_sintax) if (pieza!=p_ptocoma) error(3,9); /* esperando ';' */ - while (pieza==p_ptocoma || pieza==p_coma) lexico(); - final_sentencia(); grabar_sentencia(); + lexico(); + } + else + { + g1(lfrm); + } + if (!free_sintax) + if (pieza != p_ptocoma) + error(3, 9); /* esperando ';' */ + while (pieza == p_ptocoma || pieza == p_coma) + lexico(); + final_sentencia(); + grabar_sentencia(); + break; + case p_debug: + inicio_sentencia(); + g1(ldbg); + lexico(); + if (!free_sintax) + if (pieza != p_ptocoma) + error(3, 9); /* esperando ';' */ + while (pieza == p_ptocoma || pieza == p_coma) + lexico(); + final_sentencia(); + grabar_sentencia(); + break; + case p_break: + inicio_sentencia(); + if (itbreak == 0) + error(0, 65); + lexico(); /* break fuera de un bucle */ + if (!free_sintax) + if (pieza != p_ptocoma) + error(3, 9); /* esperando ';' */ + while (pieza == p_ptocoma || pieza == p_coma) + lexico(); + g2(ljmp, 0); + tbreak[itbreak++] = imem - 1; + final_sentencia(); + grabar_sentencia(); + break; + case p_continue: + inicio_sentencia(); + if (itcont == 0) + error(0, 66); + lexico(); /* continue fuera de un bucle */ + if (!free_sintax) + if (pieza != p_ptocoma) + error(3, 9); /* esperando ';' */ + while (pieza == p_ptocoma || pieza == p_coma) + lexico(); + g2(ljmp, 0); + tcont[itcont++] = imem - 1; + final_sentencia(); + grabar_sentencia(); + break; + case p_clone: + inicio_sentencia(); + lexico(); + g2(lclo, 0); + im1 = imem - 1; + final_sentencia(); + grabar_sentencia(); + sentencia(); + if (pieza != p_end) + error(0, 57); + lexico(); /* esperando END */ + mem[im1] = imem; + break; + case p_ptocoma: + lexico(); + break; + default: + inicio_sentencia(); + error_25 = 67; + expresion(); + do + { + _exp--; + } while ((*_exp).tipo == eoper && (*_exp).token == p_string); + error_25 = 25; + switch ((*_exp).tipo) + { + case ecall: break; - case p_break: - inicio_sentencia(); - if (itbreak==0) error(0,65); lexico(); /* break fuera de un bucle */ - if (!free_sintax) if (pieza!=p_ptocoma) error(3,9); /* esperando ';' */ - while (pieza==p_ptocoma || pieza==p_coma) lexico(); - g2(ljmp,0); tbreak[itbreak++]=imem-1; - final_sentencia(); grabar_sentencia(); break; - case p_continue: - inicio_sentencia(); - if (itcont==0) error(0,66); lexico(); /* continue fuera de un bucle */ - if (!free_sintax) if (pieza!=p_ptocoma) error(3,9); /* esperando ';' */ - while (pieza==p_ptocoma || pieza==p_coma) lexico(); - g2(ljmp,0); tcont[itcont++]=imem-1; - final_sentencia(); grabar_sentencia(); break; - case p_clone: - inicio_sentencia(); - lexico(); g2(lclo,0); im1=imem-1; - final_sentencia(); grabar_sentencia(); - sentencia(); - if (pieza!=p_end) error(0,57); lexico(); /* esperando END */ - mem[im1]=imem; break; - case p_ptocoma: - lexico(); break; - default: - inicio_sentencia(); - error_25=67; - expresion(); - do { - _exp--; - } while ((*_exp).tipo==eoper && (*_exp).token==p_string); - error_25=25; - switch((*_exp).tipo) { - case ecall: break; - case efext: break; - case eoper: - switch((*_exp).token) { - case p_asig: case p_inc: case p_suma: case p_dec: case p_resta: - case p_add_asig: case p_sub_asig: case p_mul_asig: - case p_div_asig: case p_mod_asig: case p_and_asig: - case p_or_asig: case p_xor_asig: case p_shr_asig: case p_shl_asig: + case efext: + break; + case eoper: + switch ((*_exp).token) + { + case p_asig: + case p_inc: + case p_suma: + case p_dec: + case p_resta: + case p_add_asig: + case p_sub_asig: + case p_mul_asig: + case p_div_asig: + case p_mod_asig: + case p_and_asig: + case p_or_asig: + case p_xor_asig: + case p_shr_asig: + case p_shl_asig: - case p_asigword: case p_incword: case p_sumaword: case p_decword: case p_restaword: - case p_add_asigword: case p_sub_asigword: case p_mul_asigword: - case p_div_asigword: case p_mod_asigword: case p_and_asigword: - case p_or_asigword: case p_xor_asigword: case p_shr_asigword: case p_shl_asigword: + case p_asigword: + case p_incword: + case p_sumaword: + case p_decword: + case p_restaword: + case p_add_asigword: + case p_sub_asigword: + case p_mul_asigword: + case p_div_asigword: + case p_mod_asigword: + case p_and_asigword: + case p_or_asigword: + case p_xor_asigword: + case p_shr_asigword: + case p_shl_asigword: - case p_asigchar: case p_incchar: case p_sumachar: case p_decchar: case p_restachar: - case p_add_asigchar: case p_sub_asigchar: case p_mul_asigchar: - case p_div_asigchar: case p_mod_asigchar: case p_and_asigchar: - case p_or_asigchar: case p_xor_asigchar: case p_shr_asigchar: case p_shl_asigchar: + case p_asigchar: + case p_incchar: + case p_sumachar: + case p_decchar: + case p_restachar: + case p_add_asigchar: + case p_sub_asigchar: + case p_mul_asigchar: + case p_div_asigchar: + case p_mod_asigchar: + case p_and_asigchar: + case p_or_asigchar: + case p_xor_asigchar: + case p_shr_asigchar: + case p_shl_asigchar: - case p_strcpy: case p_strcat: case p_strsub: break; - default: error(4,68); break; /* expresion sin sentido */ - } break; - default: error(4,68); /* expresion sin sentido */ + case p_strcpy: + case p_strcat: + case p_strsub: + break; + default: + error(4, 68); + break; /* expresion sin sentido */ } - if (!free_sintax) if (pieza!=p_ptocoma) error(3,9); /* esperando ';' */ - while (pieza==p_ptocoma || pieza==p_coma) lexico(); - g1(lasp); - final_sentencia(); grabar_sentencia(); break; + default: + error(4, 68); /* expresion sin sentido */ + } + if (!free_sintax) + if (pieza != p_ptocoma) + error(3, 9); /* esperando ';' */ + while (pieza == p_ptocoma || pieza == p_coma) + lexico(); + g1(lasp); + final_sentencia(); + grabar_sentencia(); + break; } } } - /* * Funciones de generación de código */ -void g1(int op) { - if (optimizar) gen(0,op,0); else mem[imem++]=op; +void g1(int op) +{ + if (optimizar) + gen(0, op, 0); + else + mem[imem++] = op; } -void g2(int op, int pa) { - if (optimizar) gen(1,op,pa); else { mem[imem++]=op; mem[imem++]=pa; } +void g2(int op, int pa) +{ + if (optimizar) + gen(1, op, pa); + else + { + mem[imem++] = op; + mem[imem++] = pa; + } } /* * Optimización peephole de código intermedio EML */ -void gen(int param, int op, int pa) +void gen(int param, int op, int pa) { - optimizado=0; + optimizado = 0; - switch(op) { - case lcar: - if (code[15].op==lcar) { - code[15].op=mem[imem-2]=lcar2; - code[15].param=2; - mem[imem++]=pa; optimizado=1; - } else if (code[15].op==lcar2) { - code[15].op=mem[imem-3]=lcar3; - code[15].param=3; - mem[imem++]=pa; optimizado=1; - } else if (code[15].op==lcar3) { - code[15].op=mem[imem-4]=lcar4; - code[15].param=4; - mem[imem++]=pa; optimizado=1; - } break; - case lasp: - if (code[15].op==lasi) { - if (code[14].op==lcar) { - remove_code(1); - code[15].op=mem[imem-2]=lcarasiasp; - } else { - code[15].op=mem[imem-1]=lasiasp; - optimizado=1; - } - } else if (code[15].op==lfun) { - code[15].op=mem[imem-2]=lfunasp; - optimizado=1; - } else if (code[15].op==lext) { - code[15].op=mem[imem-2]=lextasp; - optimizado=1; - } break; - case laid: - if (code[15].op==lcar) { - code[15].op=mem[imem-2]=lcaraid; - optimizado=1; - } break; - case lptr: - if (code[15].op==lcar) { - code[15].op=mem[imem-2]=lcarptr; - optimizado=1; - } else if (code[15].op==lcaradd) { - code[15].op=mem[imem-2]=lcaraddptr; - optimizado=1; - } else if (code[15].op==laid) { - code[15].op=mem[imem-1]=laidptr; - optimizado=1; - } else if (code[15].op==ladd) { - code[15].op=mem[imem-1]=laddptr; - optimizado=1; - } else if (code[15].op==lcaraid) { - code[15].op=mem[imem-2]=lcaraidptr; - optimizado=1; - } break; - case lcpa: - if (code[15].op==lcaraid) { - code[15].op=mem[imem-2]=lcaraidcpa; - optimizado=1; - } break; - case ladd: - if (code[15].op==lcar2){ - code[15].op=mem[imem-3]=lcar; - code[15].param=1; - mem[imem-2]+=mem[imem-1]; - imem--; optimizado=1; - } else if (code[15].op==lcar3){ - code[15].op=mem[imem-4]=lcar2; - code[15].param=2; - mem[imem-2]+=mem[imem-1]; - imem--; optimizado=1; - } else if (code[15].op==lcar4){ - code[15].op=mem[imem-5]=lcar3; - code[15].param=3; - mem[imem-2]+=mem[imem-1]; - imem--; optimizado=1; - } else if (code[15].op==lcar){ - if (mem[imem-1]==0) remove_code(1); else { - code[15].op=mem[imem-2]=lcaradd; - optimizado=1; - } - } else if (code[15].op==lcarmul){ - code[15].op=mem[imem-2]=lcarmuladd; - optimizado=1; - } break; - case lmul: - if (code[15].op==lcar2){ - code[15].op=mem[imem-3]=lcar; - code[15].param=1; - mem[imem-2]*=mem[imem-1]; - imem--; optimizado=1; - } else if (code[15].op==lcar3){ - code[15].op=mem[imem-4]=lcar2; - code[15].param=2; - mem[imem-2]*=mem[imem-1]; - imem--; optimizado=1; - } else if (code[15].op==lcar4){ - code[15].op=mem[imem-5]=lcar3; - code[15].param=3; - mem[imem-2]*=mem[imem-1]; - imem--; optimizado=1; - } else if (code[15].op==lcar){ - if (mem[imem-1]==1) remove_code(1); else { - code[15].op=mem[imem-2]=lcarmul; - optimizado=1; - } - } break; - case lsub: - if (code[15].op==lcar2){ - code[15].op=mem[imem-3]=lcar; - code[15].param=1; - mem[imem-2]-=mem[imem-1]; - imem--; optimizado=1; - } else if (code[15].op==lcar3){ - code[15].op=mem[imem-4]=lcar2; - code[15].param=2; - mem[imem-2]-=mem[imem-1]; - imem--; optimizado=1; - } else if (code[15].op==lcar4){ - code[15].op=mem[imem-5]=lcar3; - code[15].param=3; - mem[imem-2]-=mem[imem-1]; - imem--; optimizado=1; - } else if (code[15].op==lcar){ - if (mem[imem-1]==0) remove_code(1); else { - code[15].op=mem[imem-2]=lcarsub; - optimizado=1; - } - } break; - case ldiv: - if (code[15].op==lcar2){ - if (mem[imem-1]!=0) { - code[15].op=mem[imem-3]=lcar; - code[15].param=1; - mem[imem-2]/=mem[imem-1]; - imem--; optimizado=1; - } - } else if (code[15].op==lcar3){ - if (mem[imem-1]!=0) { - code[15].op=mem[imem-4]=lcar2; - code[15].param=2; - mem[imem-2]/=mem[imem-1]; - imem--; optimizado=1; - } - } else if (code[15].op==lcar4){ - if (mem[imem-1]!=0) { - code[15].op=mem[imem-5]=lcar3; - code[15].param=3; - mem[imem-2]/=mem[imem-1]; - imem--; optimizado=1; - } - } else if (code[15].op==lcar){ - if (mem[imem-1]==1) remove_code(1); - else if (mem[imem-1]!=0) { - code[15].op=mem[imem-2]=lcardiv; /* Un cardiv nunca será "cardiv 0" */ - optimizado=1; - } - } break; - case lneg: - if (code[15].op==lcar || code[15].op==lcar2 || code[15].op==lcar3 || code[15].op==lcar4) { - mem[imem-1]=-mem[imem-1]; optimizado=1; + switch (op) + { + case lcar: + if (code[15].op == lcar) + { + code[15].op = mem[imem - 2] = lcar2; + code[15].param = 2; + mem[imem++] = pa; + optimizado = 1; + } + else if (code[15].op == lcar2) + { + code[15].op = mem[imem - 3] = lcar3; + code[15].param = 3; + mem[imem++] = pa; + optimizado = 1; + } + else if (code[15].op == lcar3) + { + code[15].op = mem[imem - 4] = lcar4; + code[15].param = 4; + mem[imem++] = pa; + optimizado = 1; + } + break; + case lasp: + if (code[15].op == lasi) + { + if (code[14].op == lcar) + { + remove_code(1); + code[15].op = mem[imem - 2] = lcarasiasp; } - break; - case lnot: - if (code[15].op==lcar || code[15].op==lcar2 || code[15].op==lcar3 || code[15].op==lcar4) { - mem[imem-1]=mem[imem-1]^-1; optimizado=1; + else + { + code[15].op = mem[imem - 1] = lasiasp; + optimizado = 1; } - break; + } + else if (code[15].op == lfun) + { + code[15].op = mem[imem - 2] = lfunasp; + optimizado = 1; + } + else if (code[15].op == lext) + { + code[15].op = mem[imem - 2] = lextasp; + optimizado = 1; + } + break; + case laid: + if (code[15].op == lcar) + { + code[15].op = mem[imem - 2] = lcaraid; + optimizado = 1; + } + break; + case lptr: + if (code[15].op == lcar) + { + code[15].op = mem[imem - 2] = lcarptr; + optimizado = 1; + } + else if (code[15].op == lcaradd) + { + code[15].op = mem[imem - 2] = lcaraddptr; + optimizado = 1; + } + else if (code[15].op == laid) + { + code[15].op = mem[imem - 1] = laidptr; + optimizado = 1; + } + else if (code[15].op == ladd) + { + code[15].op = mem[imem - 1] = laddptr; + optimizado = 1; + } + else if (code[15].op == lcaraid) + { + code[15].op = mem[imem - 2] = lcaraidptr; + optimizado = 1; + } + break; + case lcpa: + if (code[15].op == lcaraid) + { + code[15].op = mem[imem - 2] = lcaraidcpa; + optimizado = 1; + } + break; + case ladd: + if (code[15].op == lcar2) + { + code[15].op = mem[imem - 3] = lcar; + code[15].param = 1; + mem[imem - 2] += mem[imem - 1]; + imem--; + optimizado = 1; + } + else if (code[15].op == lcar3) + { + code[15].op = mem[imem - 4] = lcar2; + code[15].param = 2; + mem[imem - 2] += mem[imem - 1]; + imem--; + optimizado = 1; + } + else if (code[15].op == lcar4) + { + code[15].op = mem[imem - 5] = lcar3; + code[15].param = 3; + mem[imem - 2] += mem[imem - 1]; + imem--; + optimizado = 1; + } + else if (code[15].op == lcar) + { + if (mem[imem - 1] == 0) + remove_code(1); + else + { + code[15].op = mem[imem - 2] = lcaradd; + optimizado = 1; + } + } + else if (code[15].op == lcarmul) + { + code[15].op = mem[imem - 2] = lcarmuladd; + optimizado = 1; + } + break; + case lmul: + if (code[15].op == lcar2) + { + code[15].op = mem[imem - 3] = lcar; + code[15].param = 1; + mem[imem - 2] *= mem[imem - 1]; + imem--; + optimizado = 1; + } + else if (code[15].op == lcar3) + { + code[15].op = mem[imem - 4] = lcar2; + code[15].param = 2; + mem[imem - 2] *= mem[imem - 1]; + imem--; + optimizado = 1; + } + else if (code[15].op == lcar4) + { + code[15].op = mem[imem - 5] = lcar3; + code[15].param = 3; + mem[imem - 2] *= mem[imem - 1]; + imem--; + optimizado = 1; + } + else if (code[15].op == lcar) + { + if (mem[imem - 1] == 1) + remove_code(1); + else + { + code[15].op = mem[imem - 2] = lcarmul; + optimizado = 1; + } + } + break; + case lsub: + if (code[15].op == lcar2) + { + code[15].op = mem[imem - 3] = lcar; + code[15].param = 1; + mem[imem - 2] -= mem[imem - 1]; + imem--; + optimizado = 1; + } + else if (code[15].op == lcar3) + { + code[15].op = mem[imem - 4] = lcar2; + code[15].param = 2; + mem[imem - 2] -= mem[imem - 1]; + imem--; + optimizado = 1; + } + else if (code[15].op == lcar4) + { + code[15].op = mem[imem - 5] = lcar3; + code[15].param = 3; + mem[imem - 2] -= mem[imem - 1]; + imem--; + optimizado = 1; + } + else if (code[15].op == lcar) + { + if (mem[imem - 1] == 0) + remove_code(1); + else + { + code[15].op = mem[imem - 2] = lcarsub; + optimizado = 1; + } + } + break; + case ldiv: + if (code[15].op == lcar2) + { + if (mem[imem - 1] != 0) + { + code[15].op = mem[imem - 3] = lcar; + code[15].param = 1; + mem[imem - 2] /= mem[imem - 1]; + imem--; + optimizado = 1; + } + } + else if (code[15].op == lcar3) + { + if (mem[imem - 1] != 0) + { + code[15].op = mem[imem - 4] = lcar2; + code[15].param = 2; + mem[imem - 2] /= mem[imem - 1]; + imem--; + optimizado = 1; + } + } + else if (code[15].op == lcar4) + { + if (mem[imem - 1] != 0) + { + code[15].op = mem[imem - 5] = lcar3; + code[15].param = 3; + mem[imem - 2] /= mem[imem - 1]; + imem--; + optimizado = 1; + } + } + else if (code[15].op == lcar) + { + if (mem[imem - 1] == 1) + remove_code(1); + else if (mem[imem - 1] != 0) + { + code[15].op = mem[imem - 2] = lcardiv; /* Un cardiv nunca será "cardiv 0" */ + optimizado = 1; + } + } + break; + case lneg: + if (code[15].op == lcar || code[15].op == lcar2 || code[15].op == lcar3 || code[15].op == lcar4) + { + mem[imem - 1] = -mem[imem - 1]; + optimizado = 1; + } + break; + case lnot: + if (code[15].op == lcar || code[15].op == lcar2 || code[15].op == lcar3 || code[15].op == lcar4) + { + mem[imem - 1] = mem[imem - 1] ^ -1; + optimizado = 1; + } + break; } - if (!optimizado) { - if (imem-code[15].dir>2) delete_code(); - add_code(imem,param,op); - if (param) { mem[imem++]=op; mem[imem++]=pa; } else mem[imem++]=op; + if (!optimizado) + { + if (imem - code[15].dir > 2) + delete_code(); + add_code(imem, param, op); + if (param) + { + mem[imem++] = op; + mem[imem++] = pa; + } + else + mem[imem++] = op; } - } -void remove_code(int i) { +void remove_code(int i) +{ int n; - optimizado=1; - while (i--) { - imem-=code[15].param+1; - for (n=15;n>0;n--) { - code[n].dir=code[n-1].dir; - code[n].param=code[n-1].param; - code[n].op=code[n-1].op; - } code[0].dir=0; code[0].param=0; code[0].op=0; + optimizado = 1; + while (i--) + { + imem -= code[15].param + 1; + for (n = 15; n > 0; n--) + { + code[n].dir = code[n - 1].dir; + code[n].param = code[n - 1].param; + code[n].op = code[n - 1].op; + } + code[0].dir = 0; + code[0].param = 0; + code[0].op = 0; } } -void delete_code(void) { +void delete_code(void) +{ int n; - for (n=0;n<16;n++) { - code[n].dir=0; code[n].param=0; code[n].op=0; + for (n = 0; n < 16; n++) + { + code[n].dir = 0; + code[n].param = 0; + code[n].op = 0; } } -void add_code(int dir, int param, int op) { +void add_code(int dir, int param, int op) +{ int n; - for (n=0;n<15;n++) { - code[n].dir=code[n+1].dir; - code[n].param=code[n+1].param; - code[n].op=code[n+1].op; - } code[15].dir=dir; code[15].param=param; code[15].op=op; + for (n = 0; n < 15; n++) + { + code[n].dir = code[n + 1].dir; + code[n].param = code[n + 1].param; + code[n].op = code[n + 1].op; + } + code[15].dir = dir; + code[15].param = param; + code[15].op = op; } - /* * Con el primer token leido guarda el inicio de una sentencia */ void inicio_sentencia(void) { - inicio=imem; - inicio_prg=(int)(ierror-prog); + inicio = imem; + inicio_prg = (int)(ierror - prog); } /* @@ -1026,8 +1535,8 @@ void inicio_sentencia(void) */ void final_sentencia(void) { - final=imem-1; - final_prg=(int)(old_ierror_end-prog); + final = imem - 1; + final_prg = (int)(old_ierror_end - prog); } /* @@ -1036,7 +1545,7 @@ void final_sentencia(void) void grabar_sentencia(void) { - /*if(debug && linf!=NULL) { + /*if(debug && linf!=NULL) { fwrite(&inicio,4,1,linf); fwrite(&final,4,1,linf); fwrite(&linea1,4,1,linf); @@ -1044,127 +1553,134 @@ void grabar_sentencia(void) fwrite(&linea2,4,1,linf); fwrite(&columna2,4,1,linf); }*/ - if(debug && linf!=NULL) { - fwrite(&inicio,4,1,linf); - fwrite(&final,4,1,linf); - fwrite(&inicio_prg,4,1,linf); - fwrite(&final_prg,4,1,linf); - linsize++; - } + if (debug && linf != NULL) + { + fwrite(&inicio, 4, 1, linf); + fwrite(&final, 4, 1, linf); + fwrite(&inicio_prg, 4, 1, linf); + fwrite(&final_prg, 4, 1, linf); + linsize++; + } } /* * Agrega información de depurado al ejecutable */ -void escribe_lin(FILE* f) +void escribe_lin(FILE *f) { - int b=0; - int l; - byte* progcomp; + int b = 0; + int l; + byte *progcomp; #ifdef _DEBUG - FILE* ediv_lin; - int j; + FILE *ediv_lin; + int j; #endif - /* comprimimos el codigo fuente */ - while(prog[b]!=0) b++; - b++; - progcomp=e_malloc(b*2); - l=b*2; - if(compress(progcomp,(unsigned long*)&l,prog,b)) { - fclose(linf); - fclose(f); - errormem(); - } - /* escribe el tamaño del codigo descomprimido */ - fwrite(&b,1,4,f); - /* escribe el tamaño del codigo comprimido */ - fwrite(&l,1,4,f); - /* escribe el codigo comprimido */ - fwrite(progcomp,1,l,f); - free(progcomp); - - /* Escribe el tamaño del LIN */ - #ifdef _DEBUG - printf("dbg: linsize: %d\n",linsize); - #endif - fwrite(&linsize,1,4,f); - #ifdef _DEBUG - ediv_lin=fopen("ediv.lin","w"); - fprintf(ediv_lin,"linsize: %d\n",linsize); - #endif - /* Escribe la información LIN (offset de cada sentencia en el prg y en el bytecode) */ - fseek(linf,0,SEEK_SET); - while((b=fgetc(linf))!=EOF) { - fputc(b,f); - } - #ifdef _DEBUG - j=0; - fseek(linf,0,SEEK_SET); - while(!feof(linf)) { - fread(&b,1,4,linf); - fprintf(ediv_lin,"[%d] eml_start\t%d\n",j,b); - fread(&b,1,4,linf); - fprintf(ediv_lin,"[%d] eml_end \t%d\n",j,b); - fread(&b,1,4,linf); - fprintf(ediv_lin,"[%d] prg_start\t\t%d\n",j,b); - fread(&b,1,4,linf); - fprintf(ediv_lin,"[%d] prg_end \t\t%d\n",j++,b); - } - fclose(ediv_lin); - #endif - - fclose(linf); -} + /* comprimimos el codigo fuente */ + while (prog[b] != 0) + b++; + b++; + progcomp = e_malloc(b * 2); + l = b * 2; + if (compress(progcomp, (unsigned long *)&l, prog, b)) + { + fclose(linf); + fclose(f); + errormem(); + } + /* escribe el tamaño del codigo descomprimido */ + fwrite(&b, 1, 4, f); + /* escribe el tamaño del codigo comprimido */ + fwrite(&l, 1, 4, f); + /* escribe el codigo comprimido */ + fwrite(progcomp, 1, l, f); + free(progcomp); +/* Escribe el tamaño del LIN */ +#ifdef _DEBUG + printf("dbg: linsize: %d\n", linsize); +#endif + fwrite(&linsize, 1, 4, f); +#ifdef _DEBUG + ediv_lin = fopen("ediv.lin", "w"); + fprintf(ediv_lin, "linsize: %d\n", linsize); +#endif + /* Escribe la información LIN (offset de cada sentencia en el prg y en el bytecode) */ + fseek(linf, 0, SEEK_SET); + while ((b = fgetc(linf)) != EOF) + { + fputc(b, f); + } +#ifdef _DEBUG + j = 0; + fseek(linf, 0, SEEK_SET); + while (!feof(linf)) + { + fread(&b, 1, 4, linf); + fprintf(ediv_lin, "[%d] eml_start\t%d\n", j, b); + fread(&b, 1, 4, linf); + fprintf(ediv_lin, "[%d] eml_end \t%d\n", j, b); + fread(&b, 1, 4, linf); + fprintf(ediv_lin, "[%d] prg_start\t\t%d\n", j, b); + fread(&b, 1, 4, linf); + fprintf(ediv_lin, "[%d] prg_end \t\t%d\n", j++, b); + } + fclose(ediv_lin); +#endif + + fclose(linf); +} /* * Escribe información sobre los objetos */ -void escribe_dbg(FILE* f) +void escribe_dbg(FILE *f) { - int n; - - /* Datos comunes de cada objeto */ - struct { - int tipo; - int nombre; - int bloque; - int miembro; - int v0,v1,v2,v3,v4,v5; - } ob; - - /* Cabecera de sección DBG */ - fwrite(&num_obj,4,1,f); - fwrite(&num_obj_predefinidos,4,1,f); - n=(int)&obj[0]; - fwrite(&n,4,1,f); - n=sizeof(struct objeto); - fwrite(&n,4,1,f); - - /* Escribe los datos de cada objeto */ - for (n=0;n'9') cfg_error(2); /* se esperaba un dato numerico */ - c=0; - while(buffer[i]>='0' && buffer[i]<='9' && i '9') + cfg_error(2); /* se esperaba un dato numerico */ + c = 0; + while (buffer[i] >= '0' && buffer[i] <= '9' && i < tamano) + tag[c++] = buffer[i++]; + tag[c] = 0; itoa( max_process=constante(); if (max_process<0) max_process=0; - #ifdef _DEBUG +#ifdef _DEBUG printf("dbg: max_process=%d\n",max_process); - #endif +#endif break; case 1: /* _extended_conditions */ lexico(); @@ -155,8 +158,7 @@ void lee_ediv_cfg(char* ediv_cfg) lexico(); comprueba_null=0; break; - - } + } - free(buffer); -} + free(buffer); + } diff --git a/ediv/src/ediv/ediv.c b/ediv/src/ediv/ediv.c index eb437cf..cbb7958 100644 --- a/ediv/src/ediv/ediv.c +++ b/ediv/src/ediv/ediv.c @@ -19,8 +19,8 @@ */ #ifdef _WIN32 -# include -# include "dll_load.h" +#include +#include "dll_load.h" struct in_addr iahost; struct hostent *htent; struct servent *svent; @@ -28,14 +28,14 @@ int status; char buffer[1024]; SOCKET sock; -#define sock_error(s) fprintf(stderr,"\nerror: %d\n", WSAGetLastError()) +#define sock_error(s) fprintf(stderr, "\nerror: %d\n", WSAGetLastError()) void muestra_motd(); void conecta(char *servidor, char *archivo); #else -# include /* ¿será igual en BeOS? */ -# include +#include /* ¿será igual en BeOS? */ +#include #endif #include @@ -59,288 +59,321 @@ void conecta(char *servidor, char *archivo); int main(int argc, char *argv[]) { - FILE *fp; /* stream del PRG */ + FILE *fp; /* stream del PRG */ char *p; - char libmagic[14]; /* cabecera "magic" de EDIVRUN.LIB */ - - int i,j; - byte hayprog=0; + char libmagic[14]; /* cabecera "magic" de EDIVRUN.LIB */ + + int i, j; + byte hayprog = 0; char sistema[20]; - n_errors=0; - n_warnings=0; - debug=0; - listados=0; - noexe=0; + n_errors = 0; + n_warnings = 0; + debug = 0; + listados = 0; + noexe = 0; - /* Sistemas */ - #if defined(_WIN32) - strcpy(sistema,"win32"); - #elif defined(__linux__) - strcpy(sistema,"linux"); - #elif defined(__APPLE__) - strcpy(sistema, "osx"); - #else - strcpy(sistema, "unknown"); - #endif +/* Sistemas */ +#if defined(_WIN32) + strcpy(sistema, "win32"); +#elif defined(__linux__) + strcpy(sistema, "linux"); +#elif defined(__APPLE__) + strcpy(sistema, "osx"); +#else + strcpy(sistema, "unknown"); +#endif - ini=iniparser_load("ediv.cfg"); + ini = iniparser_load("ediv.cfg"); - idioma=detecta_idioma(); + idioma = detecta_idioma(); /* mensaje de cabecera */ - printf(translate(0)); - printf(translate(1)); + print_translate(0); + print_translate(1); printf("\n"); - if(argc<2) goto ayuda; + if (argc < 2) + goto ayuda; - if(strcmp(argv[1],"--version")==0 || strcmp(argv[1],"-v")==0) - exit(0); + if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-v") == 0) + exit(0); - if(strcmp(argv[1],"--help")==0 || strcmp(argv[1],"-h")==0) { - ayuda: + if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0) + { + ayuda: /* pantalla de ayuda */ - printf(translate(2)); - printf(translate(3),argv[0]); - printf(translate(4)); - printf(translate(5)); - printf(translate(6)); - printf(translate(7)); - printf(translate(8)); - printf(translate(9)); - printf(translate(10),sistema); - printf(translate(48)); - printf(translate(11)); - exit(0); - } + print_translate(2); + print_translate(3, argv[0]); + print_translate(4); + print_translate(5); + print_translate(6); + print_translate(7); + print_translate(8); + print_translate(9); + print_translate(10, sistema); + print_translate(48); + print_translate(11); + exit(0); + } - for(i=1;i=prog) { - if (*p==lf || (*p==cr && *(p+1)==lf)) break; + if (num != 2 && num != 6) + { + while (--p >= prog) + { + if (*p == lf || (*p == cr && *(p + 1) == lf)) + break; columna++; } - if (p20) +#ifdef MULTI_ERROR + if (n_errors > 20) printf("Demasiados errores. Compilación interrumpida.\n"); - - if(num==1 || num==2 || num==6 || n_errors>20) { - printf("edivc: Finalizado - %d advertencias, %d errores\n",n_warnings,n_errors); + + if (num == 1 || num == 2 || num == 6 || n_errors > 20) + { + printf("edivc: Finalizado - %d advertencias, %d errores\n", n_warnings, n_errors); #else - printf(translate(21),n_warnings); -#endif - printf(translate(23)); + print_translate(21, n_warnings); +#endif + print_translate(23); exit(2); #ifdef MULTI_ERROR } @@ -451,9 +527,9 @@ void warning(int num, ...) { va_list opparam; - va_start(opparam,num); - printf(translate(26), fichero_prg, linea); - vprintf(translate_warning(num),opparam); + va_start(opparam, num); + print_translate(26, fichero_prg, linea); + vprintf(translate_warning(num), opparam); printf("\n"); n_warnings++; } @@ -464,21 +540,26 @@ void warning(int num, ...) #ifdef _WIN32 void muestra_motd() { - char* motdserver=NULL; - char* motdpath=NULL; + char *motdserver = NULL; + char *motdpath = NULL; - if(ini) { - motdserver=iniparser_getstr(ini,"general:motd_host"); - motdpath=iniparser_getstr(ini,"general:motd_path"); - if(!motdserver) { - printf(translate(49)); /* el servidor de motd debe estar en ediv.cfg */ + if (ini) + { + motdserver = iniparser_getstr(ini, "general:motd_host"); + motdpath = iniparser_getstr(ini, "general:motd_path"); + if (!motdserver) + { + print_translate(49); /* el servidor de motd debe estar en ediv.cfg */ exit(1); } - if(!motdpath) motdpath="/ediv/actual/motd.txt"; - conecta(motdserver,motdpath); + if (!motdpath) + motdpath = "/ediv/actual/motd.txt"; + conecta(motdserver, motdpath); exit(0); - } else { - printf(translate(49)); /* el servidor de motd debe estar en ediv.cfg */ + } + else + { + print_translate(49); /* el servidor de motd debe estar en ediv.cfg */ exit(1); } } @@ -487,116 +568,128 @@ void conecta(char *servidor, char *archivo) { struct sockaddr_in sin; - char *size, *content,*ras; - int tam,inc; + char *size, *content, *ras; + int tam, inc; WSADATA wsaData; - WSAStartup(MAKEWORD(2,2),&wsaData); - - iahost.s_addr=inet_addr(servidor); + WSAStartup(MAKEWORD(2, 2), &wsaData); - if (iahost.s_addr==INADDR_NONE) - htent=gethostbyname(servidor); + iahost.s_addr = inet_addr(servidor); + + if (iahost.s_addr == INADDR_NONE) + htent = gethostbyname(servidor); else - htent=gethostbyaddr((const char *)&iahost,sizeof(struct in_addr),AF_INET); - - if (htent==NULL) { + htent = gethostbyaddr((const char *)&iahost, sizeof(struct in_addr), AF_INET); + + if (htent == NULL) + { sock_error("gethostbyname()"); return; } - sock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); - - if (sock==INVALID_SOCKET) { - sock_error("socket()"); + sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + + if (sock == INVALID_SOCKET) + { + sock_error("socket()"); return; } - svent=getservbyname("http", "tcp"); - if (svent==NULL) - sin.sin_port=htons((u_short)80); + svent = getservbyname("http", "tcp"); + if (svent == NULL) + sin.sin_port = htons((u_short)80); else - sin.sin_port=svent->s_port; + sin.sin_port = svent->s_port; - sin.sin_family=AF_INET; - sin.sin_addr=*(struct in_addr *)*htent->h_addr_list; + sin.sin_family = AF_INET; + sin.sin_addr = *(struct in_addr *)*htent->h_addr_list; - status=connect(sock,(struct sockaddr *)&sin,sizeof(sin)); - if (status==SOCKET_ERROR) { + status = connect(sock, (struct sockaddr *)&sin, sizeof(sin)); + if (status == SOCKET_ERROR) + { sock_error("connect()"); closesocket(sock); return; } - sprintf(buffer,"GET %s HTTP/1.1\n" - "User-Agent: Mozilla/4.76 (Windows 2000; U) Opera 5.12 [es]\n" - "Host: %s\n" - "Accept: text/html, image/png, image/jpeg, image/gif, image/x-xbitmap, */*\n" - "Accept-Language: es\nAccept-Encoding: deflate, gzip, x-gzip, identity, *;q=0\n" - "Connection: Keep-Alive\n" - "\n" - ,archivo,servidor); + sprintf(buffer, "GET %s HTTP/1.1\n" + "User-Agent: Mozilla/4.76 (Windows 2000; U) Opera 5.12 [es]\n" + "Host: %s\n" + "Accept: text/html, image/png, image/jpeg, image/gif, image/x-xbitmap, */*\n" + "Accept-Language: es\nAccept-Encoding: deflate, gzip, x-gzip, identity, *;q=0\n" + "Connection: Keep-Alive\n" + "\n", + archivo, servidor); #ifdef DEBUG_HTTP printf("GET %s HTTP/1.1\n" - "User-Agent: Mozilla/4.76 (Windows 2000; U) Opera 5.12 [es]\n" - "Host: %s\n" - "Accept: text/html, image/png, image/jpeg, image/gif, image/x-xbitmap, */*\n" - "Accept-Language: es\nAccept-Encoding: deflate, gzip, x-gzip, identity, *;q=0\n" - "Connection: Keep-Alive\n" - "\n" - ,archivo,servidor); + "User-Agent: Mozilla/4.76 (Windows 2000; U) Opera 5.12 [es]\n" + "Host: %s\n" + "Accept: text/html, image/png, image/jpeg, image/gif, image/x-xbitmap, */*\n" + "Accept-Language: es\nAccept-Encoding: deflate, gzip, x-gzip, identity, *;q=0\n" + "Connection: Keep-Alive\n" + "\n", + archivo, servidor); #endif - status=send(sock,buffer,strlen(buffer),0); - if (status==SOCKET_ERROR) { + status = send(sock, buffer, strlen(buffer), 0); + if (status == SOCKET_ERROR) + { sock_error("send()"); - closesocket(sock); + closesocket(sock); return; } - status=recv(sock,buffer,sizeof(buffer),0); - if (status == SOCKET_ERROR) { + status = recv(sock, buffer, sizeof(buffer), 0); + if (status == SOCKET_ERROR) + { sock_error("recv()"); } closesocket(sock); - if(*(buffer+9)!='2' || *(buffer+10)!='0' || *(buffer+10)!='0') { - *strchr(buffer,0x0d)=0; - printf("%s\n",buffer); + if (*(buffer + 9) != '2' || *(buffer + 10) != '0' || *(buffer + 10) != '0') + { + *strchr(buffer, 0x0d) = 0; + printf("%s\n", buffer); exit(1); } - size=strstr(buffer,"Content-Type: "); - if(!size) { - printf(translate(50)); + size = strstr(buffer, "Content-Type: "); + if (!size) + { + print_translate(50); exit(1); } - size+=14; - *(ras=strchr(size,0x0d))=0; - if(strcmp(size,"text/plain")) { - printf(translate(50)); + size += 14; + *(ras = strchr(size, 0x0d)) = 0; + if (strcmp(size, "text/plain")) + { + print_translate(50); exit(1); } - *ras=0x0d; + *ras = 0x0d; - size=strstr(buffer,"Content-Length: "); - if(!size) { - printf(translate(50)); + size = strstr(buffer, "Content-Length: "); + if (!size) + { + print_translate(50); exit(1); } - size+=16; - ras=strchr(size,0x0d)-1; - content=strstr(size,"\x0d\x0a\x0d\x0a")+4; - tam=0; inc=1; - for(;ras>=size;ras--) { - if (*ras>='0' && *ras<='9') - tam+=(*ras-'0')*inc; + size += 16; + ras = strchr(size, 0x0d) - 1; + content = strstr(size, "\x0d\x0a\x0d\x0a") + 4; + tam = 0; + inc = 1; + for (; ras >= size; ras--) + { + if (*ras >= '0' && *ras <= '9') + tam += (*ras - '0') * inc; else break; - inc*=10; + inc *= 10; } - if(tam>1024) tam=1024; + if (tam > 1024) + tam = 1024; - fwrite(content, tam, 1, stdout); + fwrite(content, tam, 1, stdout); } #endif diff --git a/ediv/src/ediv/ediv_export.c b/ediv/src/ediv/ediv_export.c index b527200..f60ad5c 100644 --- a/ediv/src/ediv/ediv_export.c +++ b/ediv/src/ediv/ediv_export.c @@ -32,612 +32,664 @@ #include "language.h" int len; -struct objeto * ob; -struct objeto * ob2; +struct objeto *ob; +struct objeto *ob2; int creaobj; int numparams; -byte decl_struct=0; /* 1 si se está declarando un struct */ -byte struct_reserved=0; /* 1 si se está declarando la estructura reserved */ - +byte decl_struct = 0; /* 1 si se está declarando un struct */ +byte struct_reserved = 0; /* 1 si se está declarando la estructura reserved */ /* Errores específicos en la ejecución de una DLL */ void dll_error(int error, ...) { va_list opparam; - va_start(opparam,error); - printf(translate(35), fichdll); - vprintf(translate_dll_error(error-1),opparam); + va_start(opparam, error); + print_translate(35, fichdll); + vprintf(translate_dll_error(error - 1), opparam); printf("\n"); n_errors++; } - - -int EDIV_Export(char* cadena, int nparam, void* hfuncion) +int EDIV_Export(char *cadena, int nparam, void *hfuncion) { - if(decl_struct) { - dll_error(6,cadena); + if (decl_struct) + { + dll_error(6, cadena); return 0; } - if(nparam<0) { - dll_error(5,cadena); + if (nparam < 0) + { + dll_error(5, cadena); return 0; } - creaobj=crea_objeto((byte*)cadena,nparam); + creaobj = crea_objeto((byte *)cadena, nparam); - #ifdef DEBUG_DLL - printf("export_function:\t-- ID FUNCION: %d\n" - "export_function:\tCadena exportada: %s\n" - "export_function:\tN. parametros: %d\n" - "export_function:\tOffset de la funcion: 0x%X\n",n_externs,cadena,nparam,(unsigned int)hfuncion); - #endif +#ifdef DEBUG_DLL + printf("export_function:\t-- ID FUNCION: %d\n" + "export_function:\tCadena exportada: %s\n" + "export_function:\tN. parametros: %d\n" + "export_function:\tOffset de la funcion: 0x%X\n", + n_externs, cadena, nparam, (unsigned int)hfuncion); +#endif - if(creaobj) { - dll_error(creaobj,cadena); + if (creaobj) + { + dll_error(creaobj, cadena); return 0; } - ob=o; + ob = o; - if (ob->tipo!=tnone) { - dll_error(5,cadena); + if (ob->tipo != tnone) + { + dll_error(5, cadena); return 0; } - ob->tipo=tfext; - ob->fext.codigo=n_externs; - ob->fext.num_par=nparam; + ob->tipo = tfext; + ob->fext.codigo = n_externs; + ob->fext.num_par = nparam; n_externs++; return 1; } - -int EDIV_Export_Entrypoint(int ep, void* hfuncion) +int EDIV_Export_Entrypoint(int ep, void *hfuncion) { - entrypoints[n_entrypoints].tipo=ep; - entrypoints[n_entrypoints].hfuncion=hfuncion; - entrypoints[n_entrypoints].dll=numdlls; + entrypoints[n_entrypoints].tipo = ep; + entrypoints[n_entrypoints].hfuncion = hfuncion; + entrypoints[n_entrypoints].dll = numdlls; return 0; } - int EDIV_Export_Priority(int priority) { - dlls[numdlls].prioridad=priority; + dlls[numdlls].prioridad = priority; return 0; } - -int EDIV_Export_Const(char* cadena, int valor) +int EDIV_Export_Const(char *cadena, int valor) { - if(decl_struct) { - dll_error(6,cadena); + if (decl_struct) + { + dll_error(6, cadena); return 0; } - creaobj=crea_objeto((byte*)cadena,-1); + creaobj = crea_objeto((byte *)cadena, -1); - #ifdef DEBUG_DLL - printf("export_const:\t-- ID OBJETO: %d\n" - "export_const:\tCadena exportada: %s\n" - "export_const:\tValor: %d\n" - "export_const:\tOffset del objeto: 0x%X\n",num_obj-1,cadena,valor,(unsigned int)o); - #endif +#ifdef DEBUG_DLL + printf("export_const:\t-- ID OBJETO: %d\n" + "export_const:\tCadena exportada: %s\n" + "export_const:\tValor: %d\n" + "export_const:\tOffset del objeto: 0x%X\n", + num_obj - 1, cadena, valor, (unsigned int)o); +#endif - if(creaobj) { - dll_error(creaobj,cadena); + if (creaobj) + { + dll_error(creaobj, cadena); return 0; } - ob=o; + ob = o; - if (ob->tipo!=tnone) { - dll_error(5,cadena); + if (ob->tipo != tnone) + { + dll_error(5, cadena); return 0; } - ob->tipo=tcons; - ob->cons.valor=valor; - ob->cons.literal=0; + ob->tipo = tcons; + ob->cons.valor = valor; + ob->cons.literal = 0; return 1; } - -int EDIV_Export_Global(char* cadena, int valor) +int EDIV_Export_Global(char *cadena, int valor) { - if(decl_struct) { - dll_error(6,cadena); + if (decl_struct) + { + dll_error(6, cadena); return 0; } - creaobj=crea_objeto((byte*)cadena,-1); + creaobj = crea_objeto((byte *)cadena, -1); - #ifdef DEBUG_DLL - printf("export_global:\t-- ID OBJETO: %d\n" - "export_global:\tCadena exportada: %s\n" - "export_global:\tValor: %d\n" - "export_global:\tOffset del objeto: 0x%X\n",num_obj-1,cadena,valor,(unsigned int)o); - #endif +#ifdef DEBUG_DLL + printf("export_global:\t-- ID OBJETO: %d\n" + "export_global:\tCadena exportada: %s\n" + "export_global:\tValor: %d\n" + "export_global:\tOffset del objeto: 0x%X\n", + num_obj - 1, cadena, valor, (unsigned int)o); +#endif - if(creaobj) { - dll_error(creaobj,cadena); + if (creaobj) + { + dll_error(creaobj, cadena); return 0; } - ob=o; + ob = o; - if (ob->tipo!=tnone) { - dll_error(5,cadena); + if (ob->tipo != tnone) + { + dll_error(5, cadena); return 0; } - indexa_variable(v_global,cadena,imem); + indexa_variable(v_global, cadena, imem); - ob->tipo=tvglo; - ob->vglo.offset=imem; - mem[imem]=valor; + ob->tipo = tvglo; + ob->vglo.offset = imem; + mem[imem] = valor; return imem++; } - -int EDIV_Export_Global_Tab(char* cadena, int numregs) +int EDIV_Export_Global_Tab(char *cadena, int numregs) { - if(decl_struct) { - dll_error(6,cadena); + if (decl_struct) + { + dll_error(6, cadena); return 0; } - creaobj=crea_objeto((byte*)cadena,-1); + creaobj = crea_objeto((byte *)cadena, -1); - #ifdef DEBUG_DLL - printf("export_global_tab:\t-- ID OBJETO: %d\n" - "export_global_tab:\tCadena exportada: %s\n" - "export_global_tab:\tN.regs: %d\n" - "export_global_tab:\tOffset del objeto: 0x%X\n",num_obj-1,cadena,numregs,(unsigned int)o); - #endif +#ifdef DEBUG_DLL + printf("export_global_tab:\t-- ID OBJETO: %d\n" + "export_global_tab:\tCadena exportada: %s\n" + "export_global_tab:\tN.regs: %d\n" + "export_global_tab:\tOffset del objeto: 0x%X\n", + num_obj - 1, cadena, numregs, (unsigned int)o); +#endif - if(creaobj) { - dll_error(creaobj,cadena); + if (creaobj) + { + dll_error(creaobj, cadena); return 0; } - ob=o; + ob = o; - if (ob->tipo!=tnone) { - dll_error(5,cadena); + if (ob->tipo != tnone) + { + dll_error(5, cadena); return 0; } - indexa_variable(v_global,cadena,imem); + indexa_variable(v_global, cadena, imem); - ob->tipo=ttglo; - ob->tglo.offset=imem; - ob->tglo.len1=len=numregs; - ob->tglo.len2=-1; - ob->tglo.len3=-1; - ob->tglo.totalen=len+1; + ob->tipo = ttglo; + ob->tglo.offset = imem; + ob->tglo.len1 = len = numregs; + ob->tglo.len2 = -1; + ob->tglo.len3 = -1; + ob->tglo.totalen = len + 1; /* Inicializamos la tabla a 0 */ - do { - mem[imem++]=0; + do + { + mem[imem++] = 0; } while (len--); return ob->tglo.offset; } - -int EDIV_Export_Global_Struct(char* cadena, int numregs) +int EDIV_Export_Global_Struct(char *cadena, int numregs) { - if(decl_struct) { - dll_error(6,cadena); + if (decl_struct) + { + dll_error(6, cadena); return 0; } - creaobj=crea_objeto((byte*)cadena,-1); + creaobj = crea_objeto((byte *)cadena, -1); - #ifdef DEBUG_DLL - printf("export_global_struct:\t-- ID OBJETO: %d\n" - "export_global_struct:\tCadena exportada: %s\n" - "export_global_struct:\tN.regs: %d\n" - "export_global_struct:\tOffset del objeto: 0x%X\n",num_obj-1,cadena,numregs,(unsigned int)o); - #endif +#ifdef DEBUG_DLL + printf("export_global_struct:\t-- ID OBJETO: %d\n" + "export_global_struct:\tCadena exportada: %s\n" + "export_global_struct:\tN.regs: %d\n" + "export_global_struct:\tOffset del objeto: 0x%X\n", + num_obj - 1, cadena, numregs, (unsigned int)o); +#endif - if(creaobj) { - dll_error(creaobj,cadena); + if (creaobj) + { + dll_error(creaobj, cadena); return 0; } - ob=o; + ob = o; - if (ob->tipo!=tnone) { - dll_error(5,cadena); + if (ob->tipo != tnone) + { + dll_error(5, cadena); return 0; } - indexa_variable(v_global,cadena,imem); + indexa_variable(v_global, cadena, imem); - decl_struct=1; + decl_struct = 1; - ob->tipo=tsglo; - ob->sglo.offset=imem; - ob->sglo.items1=numregs; - ob->sglo.items2=ob->sglo.items3=-1; - ob->sglo.totalitems=numregs+1; - ob->sglo.len_item=0; - member=ob; - len=0; + ob->tipo = tsglo; + ob->sglo.offset = imem; + ob->sglo.items1 = numregs; + ob->sglo.items2 = ob->sglo.items3 = -1; + ob->sglo.totalitems = numregs + 1; + ob->sglo.len_item = 0; + member = ob; + len = 0; return imem; } - -int EDIV_Export_Member_Int(char* cadena, int valor) +int EDIV_Export_Member_Int(char *cadena, int valor) { - if(!decl_struct) { - dll_error(7,cadena); + if (!decl_struct) + { + dll_error(7, cadena); return 0; } - creaobj=crea_objeto((byte*)cadena,-1); + creaobj = crea_objeto((byte *)cadena, -1); - #ifdef DEBUG_DLL - printf("export_member_int:\t-- ID OBJETO: %d\n" - "export_member_int:\tCadena exportada: %s\n" - "export_member_int:\tValor: %d\n" - "export_member_int:\tOffset del objeto: 0x%X\n",num_obj-1,cadena,valor,(unsigned int)o); - #endif +#ifdef DEBUG_DLL + printf("export_member_int:\t-- ID OBJETO: %d\n" + "export_member_int:\tCadena exportada: %s\n" + "export_member_int:\tValor: %d\n" + "export_member_int:\tOffset del objeto: 0x%X\n", + num_obj - 1, cadena, valor, (unsigned int)o); +#endif - if(creaobj) { - dll_error(creaobj,cadena); + if (creaobj) + { + dll_error(creaobj, cadena); return 0; } - ob2=o; + ob2 = o; - if ((*ob2).tipo!=tnone) { - dll_error(5,cadena); + if ((*ob2).tipo != tnone) + { + dll_error(5, cadena); return 0; } - if(ob->tipo==tsglo) { /* int miembro de struct global */ - (*ob2).tipo=tvglo; - (*ob2).vglo.offset=len++; - mem[imem]=valor; + if (ob->tipo == tsglo) + { /* int miembro de struct global */ + (*ob2).tipo = tvglo; + (*ob2).vglo.offset = len++; + mem[imem] = valor; ob->sglo.len_item++; return imem++; } - else { /* int miembro de struct local */ - if(struct_reserved) - indexa_variable(v_reserved,cadena,iloc); - (*ob2).tipo=tvloc; - (*ob2).vloc.offset=len++; - loc[iloc]=valor; - ob->sloc.len_item++; - return iloc++; + else + { /* int miembro de struct local */ + if (struct_reserved) + indexa_variable(v_reserved, cadena, iloc); + (*ob2).tipo = tvloc; + (*ob2).vloc.offset = len++; + loc[iloc] = valor; + ob->sloc.len_item++; + return iloc++; } } - -int EDIV_Export_Member_Str(char* cadena, int tamano) +int EDIV_Export_Member_Str(char *cadena, int tamano) { - if(!decl_struct) { - dll_error(7,cadena); + if (!decl_struct) + { + dll_error(7, cadena); return 0; } - creaobj=crea_objeto((byte*)cadena,-1); + creaobj = crea_objeto((byte *)cadena, -1); - #ifdef DEBUG_DLL - printf("export_member_str:\t-- ID OBJETO: %d\n" - "export_member_str:\tCadena exportada: %s\n" - "export_member_str:\tTamano: %d\n" - "export_member_str:\tOffset del objeto: 0x%X\n",num_obj-1,cadena,tamano,(unsigned int)o); - #endif +#ifdef DEBUG_DLL + printf("export_member_str:\t-- ID OBJETO: %d\n" + "export_member_str:\tCadena exportada: %s\n" + "export_member_str:\tTamano: %d\n" + "export_member_str:\tOffset del objeto: 0x%X\n", + num_obj - 1, cadena, tamano, (unsigned int)o); +#endif - if(creaobj) { - dll_error(creaobj,cadena); + if (creaobj) + { + dll_error(creaobj, cadena); return 0; } - ob2=o; + ob2 = o; - if ((*ob2).tipo!=tnone) { - dll_error(5,cadena); + if ((*ob2).tipo != tnone) + { + dll_error(5, cadena); return 0; } - if(ob->tipo==tsglo) { /* string miembro de struct global */ + if (ob->tipo == tsglo) + { /* string miembro de struct global */ - (*ob2).tipo=tcglo; - (*ob2).cglo.offset=len+1; + (*ob2).tipo = tcglo; + (*ob2).cglo.offset = len + 1; - if (((*ob2).cglo.totalen=tamano)<0) { - dll_error(8,cadena); + if (((*ob2).cglo.totalen = tamano) < 0) + { + dll_error(8, cadena); return 0; } - if ((*ob2).cglo.totalen>0xFFFFF) { - dll_error(8,cadena); + if ((*ob2).cglo.totalen > 0xFFFFF) + { + dll_error(8, cadena); return 0; } - mem[imem]=0xDAD00000|(*ob2).cglo.totalen; - len+=1+((*ob2).cglo.totalen+5)/4; - mem[imem+1]=0; - imem+=1+((*ob2).cglo.totalen+5)/4; - ob->sglo.len_item+=1+((*ob2).cglo.totalen+5)/4; - + mem[imem] = 0xDAD00000 | (*ob2).cglo.totalen; + len += 1 + ((*ob2).cglo.totalen + 5) / 4; + mem[imem + 1] = 0; + imem += 1 + ((*ob2).cglo.totalen + 5) / 4; + ob->sglo.len_item += 1 + ((*ob2).cglo.totalen + 5) / 4; + return (*ob2).cglo.offset; } - else { /* string miembro de struct local */ + else + { /* string miembro de struct local */ - (*ob2).tipo=tcloc; - (*ob2).cloc.offset=len+1; + (*ob2).tipo = tcloc; + (*ob2).cloc.offset = len + 1; - if (((*ob2).cloc.totalen=tamano)<0) { - dll_error(8,cadena); + if (((*ob2).cloc.totalen = tamano) < 0) + { + dll_error(8, cadena); return 0; } - if ((*ob2).cloc.totalen>0xFFFFF) { - dll_error(8,cadena); + if ((*ob2).cloc.totalen > 0xFFFFF) + { + dll_error(8, cadena); return 0; } - loc[iloc]=0xDAD00000|(*ob2).cloc.totalen; - len+=1+((*ob2).cloc.totalen+5)/4; - loc[iloc+1]=0; - iloc+=1+((*ob2).cloc.totalen+5)/4; - ob->sloc.len_item+=1+((*ob2).cloc.totalen+5)/4; - + loc[iloc] = 0xDAD00000 | (*ob2).cloc.totalen; + len += 1 + ((*ob2).cloc.totalen + 5) / 4; + loc[iloc + 1] = 0; + iloc += 1 + ((*ob2).cloc.totalen + 5) / 4; + ob->sloc.len_item += 1 + ((*ob2).cloc.totalen + 5) / 4; + return (*ob2).cloc.offset; } } - -int EDIV_Export_Member_Tab(char* cadena, int numregs) +int EDIV_Export_Member_Tab(char *cadena, int numregs) { - if(!decl_struct) { - dll_error(7,cadena); + if (!decl_struct) + { + dll_error(7, cadena); return 0; } - creaobj=crea_objeto((byte*)cadena,-1); + creaobj = crea_objeto((byte *)cadena, -1); - #ifdef DEBUG_DLL - printf("export_member_tab:\t-- ID OBJETO: %d\n" - "export_member_tab:\tCadena exportada: %s\n" - "export_member_tab:\tN.regs: %d\n" - "export_member_tab:\tOffset del objeto: 0x%X\n",num_obj-1,cadena,numregs,(unsigned int)o); - #endif +#ifdef DEBUG_DLL + printf("export_member_tab:\t-- ID OBJETO: %d\n" + "export_member_tab:\tCadena exportada: %s\n" + "export_member_tab:\tN.regs: %d\n" + "export_member_tab:\tOffset del objeto: 0x%X\n", + num_obj - 1, cadena, numregs, (unsigned int)o); +#endif - if(creaobj) { - dll_error(creaobj,cadena); + if (creaobj) + { + dll_error(creaobj, cadena); return 0; } - ob2=o; + ob2 = o; - if ((*ob2).tipo!=tnone) { - dll_error(5,cadena); + if ((*ob2).tipo != tnone) + { + dll_error(5, cadena); return 0; } - if(ob->tipo==tsglo) { /* array miembro de struct global */ - (*ob2).tipo=ttglo; - (*ob2).tglo.offset=len; - (*ob2).tglo.len1=numregs; - (*ob2).tglo.len2=-1; - (*ob2).tglo.len3=-1; - (*ob2).tglo.totalen=numregs+1; - len+=numregs+1; - memset(&mem[imem],0,(numregs+1)*4); - imem+=numregs+1; - ob->sglo.len_item+=numregs+1; - + if (ob->tipo == tsglo) + { /* array miembro de struct global */ + (*ob2).tipo = ttglo; + (*ob2).tglo.offset = len; + (*ob2).tglo.len1 = numregs; + (*ob2).tglo.len2 = -1; + (*ob2).tglo.len3 = -1; + (*ob2).tglo.totalen = numregs + 1; + len += numregs + 1; + memset(&mem[imem], 0, (numregs + 1) * 4); + imem += numregs + 1; + ob->sglo.len_item += numregs + 1; + return (*ob2).tglo.offset; } - else { /* array miembro de struct local */ - if(struct_reserved) - indexa_variable(v_reserved,cadena,iloc); - (*ob2).tipo=ttloc; - (*ob2).tloc.offset=len; - (*ob2).tloc.len1=numregs; - (*ob2).tloc.len2=-1; - (*ob2).tloc.len3=-1; - (*ob2).tloc.totalen=numregs+1; - len+=numregs+1; - memset(&loc[iloc],0,(numregs+1)*4); - iloc+=numregs+1; - ob->sloc.len_item+=numregs+1; - + else + { /* array miembro de struct local */ + if (struct_reserved) + indexa_variable(v_reserved, cadena, iloc); + (*ob2).tipo = ttloc; + (*ob2).tloc.offset = len; + (*ob2).tloc.len1 = numregs; + (*ob2).tloc.len2 = -1; + (*ob2).tloc.len3 = -1; + (*ob2).tloc.totalen = numregs + 1; + len += numregs + 1; + memset(&loc[iloc], 0, (numregs + 1) * 4); + iloc += numregs + 1; + ob->sloc.len_item += numregs + 1; + return (*ob2).tloc.offset; } } - int EDIV_Export_EndStruct() { - if(!decl_struct) { + if (!decl_struct) + { dll_error(9); return 0; } - #ifdef DEBUG_DLL - printf("export_endstruct:\t--- estructura cerrada\n"); - #endif +#ifdef DEBUG_DLL + printf("export_endstruct:\t--- estructura cerrada\n"); +#endif - member=NULL; + member = NULL; - if(ob->tipo==tsglo) { /* cierra estructura global */ - if (ob->sglo.len_item==0) { + if (ob->tipo == tsglo) + { /* cierra estructura global */ + if (ob->sglo.len_item == 0) + { dll_error(10); return 0; } - if (ob->sglo.totalitems>1) { - len=(ob->sglo.totalitems-1)*ob->sglo.len_item-1; - do { - mem[imem]=mem[imem-ob->sglo.len_item]; + if (ob->sglo.totalitems > 1) + { + len = (ob->sglo.totalitems - 1) * ob->sglo.len_item - 1; + do + { + mem[imem] = mem[imem - ob->sglo.len_item]; imem++; } while (len--); } } - else { /* cierra estructura local */ - if (ob->sloc.len_item==0) { + else + { /* cierra estructura local */ + if (ob->sloc.len_item == 0) + { dll_error(10); return 0; } - if (ob->sloc.totalitems>1) { - len=(ob->sloc.totalitems-1)*ob->sloc.len_item-1; - do { - loc[iloc]=loc[iloc-ob->sloc.len_item]; + if (ob->sloc.totalitems > 1) + { + len = (ob->sloc.totalitems - 1) * ob->sloc.len_item - 1; + do + { + loc[iloc] = loc[iloc - ob->sloc.len_item]; iloc++; } while (len--); } } - decl_struct=0; - struct_reserved=0; + decl_struct = 0; + struct_reserved = 0; return 1; } - -int EDIV_Export_Local(char* cadena, int valor) +int EDIV_Export_Local(char *cadena, int valor) { - if(decl_struct) { - dll_error(6,cadena); + if (decl_struct) + { + dll_error(6, cadena); return 0; } - creaobj=crea_objeto((byte*)cadena,-1); + creaobj = crea_objeto((byte *)cadena, -1); - #ifdef DEBUG_DLL - printf("export_local:\t-- ID OBJETO: %d\n" - "export_local:\tCadena exportada: %s\n" - "export_local:\tValor: %d\n" - "export_local:\tOffset del objeto: 0x%X\n",num_obj-1,cadena,valor,(unsigned int)o); - #endif +#ifdef DEBUG_DLL + printf("export_local:\t-- ID OBJETO: %d\n" + "export_local:\tCadena exportada: %s\n" + "export_local:\tValor: %d\n" + "export_local:\tOffset del objeto: 0x%X\n", + num_obj - 1, cadena, valor, (unsigned int)o); +#endif - if(creaobj) { - dll_error(creaobj,cadena); + if (creaobj) + { + dll_error(creaobj, cadena); return 0; } - ob=o; + ob = o; - if (ob->tipo!=tnone) { - dll_error(5,cadena); + if (ob->tipo != tnone) + { + dll_error(5, cadena); return 0; } - indexa_variable(v_local,cadena,iloc); + indexa_variable(v_local, cadena, iloc); - ob->tipo=tvloc; - ob->vloc.offset=iloc; - loc[iloc]=valor; + ob->tipo = tvloc; + ob->vloc.offset = iloc; + loc[iloc] = valor; - return iloc++; + return iloc++; } - -int EDIV_Export_Local_Tab(char* cadena, int numregs) +int EDIV_Export_Local_Tab(char *cadena, int numregs) { - if(decl_struct) { - dll_error(6,cadena); + if (decl_struct) + { + dll_error(6, cadena); return 0; } - creaobj=crea_objeto((byte*)cadena,-1); + creaobj = crea_objeto((byte *)cadena, -1); - #ifdef DEBUG_DLL - printf("export_local_tab:\t-- ID OBJETO: %d\n" - "export_local_tab:\tCadena exportada: %s\n" - "export_local_tab:\tN.regs: %d\n" - "export_local_tab:\tOffset del objeto: 0x%X\n",num_obj-1,cadena,numregs,(unsigned int)o); - #endif +#ifdef DEBUG_DLL + printf("export_local_tab:\t-- ID OBJETO: %d\n" + "export_local_tab:\tCadena exportada: %s\n" + "export_local_tab:\tN.regs: %d\n" + "export_local_tab:\tOffset del objeto: 0x%X\n", + num_obj - 1, cadena, numregs, (unsigned int)o); +#endif - if(creaobj) { - dll_error(creaobj,cadena); + if (creaobj) + { + dll_error(creaobj, cadena); return 0; } - ob=o; + ob = o; - if (ob->tipo!=tnone) { - dll_error(5,cadena); + if (ob->tipo != tnone) + { + dll_error(5, cadena); return 0; } - indexa_variable(v_local,cadena,iloc); + indexa_variable(v_local, cadena, iloc); - ob->tipo=ttloc; - ob->tloc.offset=iloc; - ob->tloc.len1=len=numregs; - ob->tloc.len2=-1; - ob->tloc.len3=-1; - ob->tloc.totalen=len+1; + ob->tipo = ttloc; + ob->tloc.offset = iloc; + ob->tloc.len1 = len = numregs; + ob->tloc.len2 = -1; + ob->tloc.len3 = -1; + ob->tloc.totalen = len + 1; /* Inicializamos la tabla a 0 */ - do { - loc[iloc++]=0; + do + { + loc[iloc++] = 0; } while (len--); return ob->tloc.offset; } - -int EDIV_Export_Local_Struct(char* cadena, int numregs) +int EDIV_Export_Local_Struct(char *cadena, int numregs) { - if(decl_struct) { - dll_error(6,cadena); + if (decl_struct) + { + dll_error(6, cadena); return 0; } - creaobj=crea_objeto((byte*)cadena,-1); + creaobj = crea_objeto((byte *)cadena, -1); - #ifdef DEBUG_DLL - printf("export_local_struct:\t-- ID OBJETO: %d\n" - "export_local_struct:\tCadena exportada: %s\n" - "export_local_struct:\tN.regs: %d\n" - "export_local_struct:\tOffset del objeto: 0x%X\n",num_obj-1,cadena,numregs,(unsigned int)o); - #endif +#ifdef DEBUG_DLL + printf("export_local_struct:\t-- ID OBJETO: %d\n" + "export_local_struct:\tCadena exportada: %s\n" + "export_local_struct:\tN.regs: %d\n" + "export_local_struct:\tOffset del objeto: 0x%X\n", + num_obj - 1, cadena, numregs, (unsigned int)o); +#endif - if(creaobj) { - dll_error(creaobj,cadena); + if (creaobj) + { + dll_error(creaobj, cadena); return 0; } - ob=o; + ob = o; - if (ob->tipo!=tnone) { - dll_error(5,cadena); + if (ob->tipo != tnone) + { + dll_error(5, cadena); return 0; } - decl_struct=1; - if(!strcmp(cadena,"reserved")) { - struct_reserved=1; + decl_struct = 1; + if (!strcmp(cadena, "reserved")) + { + struct_reserved = 1; } - else { - indexa_variable(v_local,cadena,iloc); + else + { + indexa_variable(v_local, cadena, iloc); } - ob->tipo=tsloc; - ob->sloc.offset=iloc; - ob->sloc.items1=numregs; - ob->sloc.items2=ob->sloc.items3=-1; - ob->sloc.totalitems=numregs+1; - ob->sloc.len_item=0; - member=ob; - len=0; + ob->tipo = tsloc; + ob->sloc.offset = iloc; + ob->sloc.items1 = numregs; + ob->sloc.items2 = ob->sloc.items3 = -1; + ob->sloc.totalitems = numregs + 1; + ob->sloc.len_item = 0; + member = ob; + len = 0; - return iloc; + return iloc; } diff --git a/ediv/src/ediv/language.c b/ediv/src/ediv/language.c index c34b8b6..ac1701a 100644 --- a/ediv/src/ediv/language.c +++ b/ediv/src/ediv/language.c @@ -23,6 +23,7 @@ #else #include #include +#include #endif #include "shared.h" @@ -153,6 +154,35 @@ char *translate(int num) return e[idioma][num]; } +void print_translate(int num, ...) +{ + va_list arg_ptr; + const char *message = translate(num); + size_t msglen = strlen(message); + char *strbuf = malloc(msglen + 1); + + va_start(arg_ptr, message); + vsprintf(strbuf, message, arg_ptr); + va_end(arg_ptr); + + printf("%s", strbuf); + free(strbuf); +} + +const char *get_translate(int num, ...) +{ + va_list arg_ptr; + const char *message = translate(num); + size_t msglen = strlen(message); + char *strbuf = malloc(msglen + 1); + + va_start(arg_ptr, message); + vsprintf(strbuf, message, arg_ptr); + va_end(arg_ptr); + + return strbuf; +} + static char *ediv_strlwr(char *str) { unsigned char *p = (unsigned char *)str; diff --git a/ediv/src/ediv/listados.c b/ediv/src/ediv/listados.c index f5d7c38..3a92c76 100644 --- a/ediv/src/ediv/listados.c +++ b/ediv/src/ediv/listados.c @@ -31,335 +31,734 @@ * Graba el fichero de la tabla de objetos */ -void listado_objetos (void) +void listado_objetos(void) { - FILE * sta; + FILE *sta; char nombretab[256]; - int n,o,l; + int n, o, l; + char *msg_37 = get_translate(27, fichero_prg); - strcpy(nombretab,nombreprog); - strcat(nombretab,".tab"); + strcpy(nombretab, nombreprog); + strcat(nombretab, ".tab"); - if((sta=fopen(nombretab,"w"))==NULL) { - printf(translate(36),nombretab); - exit(1); + if ((sta = fopen(nombretab, "w")) == NULL) + { + print_translate(36, nombretab); + exit(1); } - fprintf(sta,translate(37),fichero_prg); + fprintf(sta, msg_37); + free(msg_37); - for (n=1;n<=8;n++) fprintf(sta,"[%u]: %u\n",n,mem[n]); fprintf(sta,"\n"); + for (n = 1; n <= 8; n++) + fprintf(sta, "[%u]: %u\n", n, mem[n]); + fprintf(sta, "\n"); - for (n=0;n= '0' && *buf <= '9') + t = (*buf++ - '0') << 4; + else if (*buf >= 'a' && *buf <= 'f') + t = (*buf++ - 'a' + 10) << 4; + else + ltlex_error(2); + *buf = lower[*buf]; + if (*buf >= '0' && *buf <= '9') + t += (*buf++ - '0'); + else if (*buf >= 'a' && *buf <= 'f') + t += (*buf++ - 'a' + 10); + else + ltlex_error(2); + if (*buf == cr || *buf == lf || *buf == ' ' || *buf == tab) break; - /* Salta de linea */ - case cr: - if(*buf==lf) buf++; - case lf: - linea++; - break; - /* Los ; indican línea de comentario */ - case ';': - while (*buf!=cr && *buf!=lf) buf++; break; - /* El símbolo & indica definición de token */ - case '&': - *buf=lower[*buf]; - if (*buf>='0' && *buf<='9') - t=(*buf++-'0')<<4; + else if (lower[*buf]) + { /* Analiza una palabra reservada */ + _ivnom = ivnom.b; + *ivnom.p++ = 0; + *ivnom.p++ = (unsigned char *)t; + h = 0; + while ((*ivnom.b = lower[*buf++])) + h = ((byte)(h << 1) + (h >> 7)) ^ (*ivnom.b++); + ptr = &vhash[h]; + while (*ptr) + ptr = (unsigned char **)*ptr; + *ptr = _ivnom; + buf--; + ivnom.b++; + } + else if (t >= 0x78 && t <= 0x7b) + { /* Analiza un delimitador de literal */ + lex_case[*buf] = (struct lex_ele *)l_lit; + } + else + { /* Analiza un nuevo símbolo */ + if ((e = lex_case[*buf]) == 0) + { + if (num_nodos++ == max_nodos) + ltlex_error(3); + e = lex_case[*buf] = ilex_simb++; + e->caracter = *buf++; + } else - if (*buf>='a' && *buf<='f') - t=(*buf++-'a'+10)<<4; - else - ltlex_error(2); - *buf=lower[*buf]; - if (*buf>='0' && *buf<='9') - t+=(*buf++-'0'); - else - if (*buf>='a' && *buf<='f') - t+=(*buf++-'a'+10); - else - ltlex_error(2); - if (*buf==cr || *buf==lf || *buf==' ' || *buf==tab) break; - else if (lower[*buf]) { /* Analiza una palabra reservada */ - _ivnom=ivnom.b; *ivnom.p++=0; *ivnom.p++=(unsigned char*)t; h=0; - while ((*ivnom.b=lower[*buf++])) h=((byte)(h<<1)+(h>>7))^(*ivnom.b++); - ptr=&vhash[h]; while (*ptr) ptr=(unsigned char * *)*ptr; *ptr=_ivnom; - buf--; ivnom.b++; - } else if (t>=0x78 && t<=0x7b) { /* Analiza un delimitador de literal */ - lex_case[*buf]=(struct lex_ele*)l_lit; - } else { /* Analiza un nuevo símbolo */ - if ((e=lex_case[*buf])==0) { - if (num_nodos++==max_nodos) + buf++; + while (*buf != ' ' && *buf != tab && *buf != cr) + { + if (lower[*buf]) + ltlex_error(4); + if (e->siguiente == 0) + if (num_nodos++ == max_nodos) ltlex_error(3); - e=lex_case[*buf]=ilex_simb++; - e->caracter=*buf++; - } + else + e = e->siguiente = ilex_simb++; else - buf++; - while (*buf!=' ' && *buf!=tab && *buf!=cr) { - if (lower[*buf]) ltlex_error(4); - if (e->siguiente==0) - if (num_nodos++==max_nodos) ltlex_error(3); - else e=e->siguiente=ilex_simb++; - else { - e=e->siguiente; - while (e->caracter!=*buf && e->alternativa) - e=e->alternativa; - if (e->caracter!=*buf) { - if (num_nodos++==max_nodos) ltlex_error(3); - else e=e->alternativa=ilex_simb++; - } + { + e = e->siguiente; + while (e->caracter != *buf && e->alternativa) + e = e->alternativa; + if (e->caracter != *buf) + { + if (num_nodos++ == max_nodos) + ltlex_error(3); + else + e = e->alternativa = ilex_simb++; } - e->caracter=*buf++; } - e->token=t; - } break; - }} while (cont); + e->caracter = *buf++; + } + e->token = t; + } + break; + } + } while (cont); - e_free(_buf); _buf=NULL; - fclose(def); def=NULL; + e_free(_buf); + _buf = NULL; + fclose(def); + def = NULL; } diff --git a/ediv/src/ediv/modulos.c b/ediv/src/ediv/modulos.c index 8638589..780db37 100644 --- a/ediv/src/ediv/modulos.c +++ b/ediv/src/ediv/modulos.c @@ -19,12 +19,12 @@ */ #ifdef _WIN32 - #include "dll_load.h" - #include +#include "dll_load.h" +#include #else - #include - #include - #include +#include +#include +#include #endif #include @@ -39,252 +39,267 @@ int imem_temp; int iloc_temp; /* obtiene el nombre esencial de la libreria (sin extension ni path) */ -void get_rawname(char* completo, char* rawname) +void get_rawname(char *completo, char *rawname) { - char* p=completo; + char *p = completo; int i; - for(i=strlen(completo)-1;i>0;i--) - if(completo[i]=='\\' || completo[i]=='/') { - p=&completo[i+1]; + for (i = strlen(completo) - 1; i > 0; i--) + if (completo[i] == '\\' || completo[i] == '/') + { + p = &completo[i + 1]; break; } - strcpy(rawname,p); - i=strlen(rawname); + strcpy(rawname, p); + i = strlen(rawname); - #ifdef _WIN32 - if (rawname[i-4]=='.' && (rawname[i-3]=='d' || rawname[i-3]=='D') - && (rawname[i-2]=='l' || rawname[i-2]=='L') - && (rawname[i-1]=='l' || rawname[i-1]=='L')) - - rawname[i-4]=0; +#ifdef _WIN32 + if (rawname[i - 4] == '.' && (rawname[i - 3] == 'd' || rawname[i - 3] == 'D') && (rawname[i - 2] == 'l' || rawname[i - 2] == 'L') && (rawname[i - 1] == 'l' || rawname[i - 1] == 'L')) - #else - if(rawname[i-3]=='.' && (rawname[i-2]=='s' || rawname[i-2]=='S') - && (rawname[i-1]=='o' || rawname[i-1]=='O')) - - rawname[i-3]=0; - #endif + rawname[i - 4] = 0; + +#else + if (rawname[i - 3] == '.' && (rawname[i - 2] == 's' || rawname[i - 2] == 'S') && (rawname[i - 1] == 'o' || rawname[i - 1] == 'O')) + + rawname[i - 3] = 0; +#endif } - /* compara prioridades de dos dlls, para el qsort descendente */ -int compara(const void* _a, const void* _b) +int compara(const void *_a, const void *_b) { - struct _dlls a=*(struct _dlls*)_a; - struct _dlls b=*(struct _dlls*)_b; - return a.prioridadb.prioridad?-1:0); + struct _dlls a = *(struct _dlls *)_a; + struct _dlls b = *(struct _dlls *)_b; + return a.prioridad < b.prioridad ? 1 : (a.prioridad > b.prioridad ? -1 : 0); } -int compara2(const void* _a, const void* _b) +int compara2(const void *_a, const void *_b) { - int a=*(int*)_a; - int b=*(int*)_b; - return dlls[a].prioridaddlls[b].prioridad?-1:0); + int a = *(int *)_a; + int b = *(int *)_b; + return dlls[a].prioridad < dlls[b].prioridad ? 1 : (dlls[a].prioridad > dlls[b].prioridad ? -1 : 0); } - void dll_func() { - char dllkey[256]="dll_priority:"; + char dllkey[256] = "dll_priority:"; char rawname[256]; - int carga=1; - char *dir=NULL; + int carga = 1; + char *dir = NULL; int i; - #ifdef _WIN32 - int buscafich; - struct _finddata_t fichero_dll; /* busqueda de DLLs */ - char mask[256]; - #else - DIR *directorio; - struct dirent *fichero_dll; - #endif +#ifdef _WIN32 + int buscafich; + struct _finddata_t fichero_dll; /* busqueda de DLLs */ + char mask[256]; +#else + DIR *directorio; + struct dirent *fichero_dll; +#endif - numdlls=0; - n_externs=0; - - #ifdef _WIN32 - /* Inicializa la carga de DLLs */ - CheckWindowsVersion(); - InitializeDLLLoad(); - #endif + numdlls = 0; + n_externs = 0; - #ifdef _WIN32 - if (ini) - dir=iniparser_getstr(ini,"dll:windll"); - - if (!dir) - dir="dll"; - - strcpy(mask,dir); - strcat(mask,"\\*.dll"); +#ifdef _WIN32 + /* Inicializa la carga de DLLs */ + CheckWindowsVersion(); + InitializeDLLLoad(); +#endif - /* Busca las DLLs que hay en el directorio */ - buscafich = _findfirst(mask, &fichero_dll); - if (buscafich==-1) - printf(translate(43)); /* no hay dlls */ - +#ifdef _WIN32 + if (ini) + dir = iniparser_getstr(ini, "dll:windll"); - #ifdef _DEBUG - printf("dbg: DLL encontrada: %s\n",fichero_dll.name); - #endif + if (!dir) + dir = "dll"; - sprintf(fichdll,"%s\\%s",dir,fichero_dll.name); + strcpy(mask, dir); + strcat(mask, "\\*.dll"); - get_rawname(fichero_dll.name,rawname); - strcat(dllkey,rawname); + /* Busca las DLLs que hay en el directorio */ + buscafich = _findfirst(mask, &fichero_dll); + if (buscafich == -1) + print_translate(43); /* no hay dlls */ - if (ini) - if (iniparser_getint(ini,dllkey,0)<=P_NUNCA) - carga=0; +#ifdef _DEBUG + printf("dbg: DLL encontrada: %s\n", fichero_dll.name); +#endif - if (carga) - if(!leedll()) { - dlls[numdlls].prioridad=0; + sprintf(fichdll, "%s\\%s", dir, fichero_dll.name); + + get_rawname(fichero_dll.name, rawname); + strcat(dllkey, rawname); + + if (ini) + if (iniparser_getint(ini, dllkey, 0) <= P_NUNCA) + carga = 0; + + if (carga) + if (!leedll()) + { + dlls[numdlls].prioridad = 0; /* guarda el nombre de fichero en la tabla de DLLs */ - dlls[0].nombre=e_malloc(strlen(rawname)+1); - strcpy(dlls[0].nombre,rawname); + dlls[0].nombre = e_malloc(strlen(rawname) + 1); + strcpy(dlls[0].nombre, rawname); /* importa las funciones de la DLL */ - if (ini) - dlls[numdlls].prioridad=iniparser_getint(ini,dllkey,dlls[numdlls].prioridad); + if (ini) + dlls[numdlls].prioridad = iniparser_getint(ini, dllkey, dlls[numdlls].prioridad); - numdlls=1; + numdlls = 1; + } + + /* hace lo mismo con el resto */ + while (1) + { + if (_findnext(buscafich, &fichero_dll) == 0) + { +#ifdef _DEBUG + printf("dbg: DLL encontrada: %s\n", fichero_dll.name); +#endif + carga = 1; + sprintf(fichdll, "%s\\%s", dir, fichero_dll.name); + dlls[numdlls].prioridad = 0; + get_rawname(fichero_dll.name, rawname); + strcpy(dllkey, "dll_priority:"); + strcat(dllkey, rawname); + if (ini) + if (iniparser_getint(ini, dllkey, 0) <= P_NUNCA) + carga = 0; + if (carga) + if (!leedll()) + { + dlls[numdlls].nombre = e_malloc(strlen(rawname) + 1); + strcpy(dlls[numdlls].nombre, rawname); + dlls[numdlls].usado = 0; + if (ini) + dlls[numdlls].prioridad = iniparser_getint(ini, dllkey, dlls[numdlls].prioridad); + numdlls++; + } + } + else + break; + } + +#else /* si estamos en Linux */ + + if (ini) + dir = iniparser_getstr(ini, "dll:nixdll"); + if (!dir) + dir = "so"; + + directorio = opendir(dir); + if (!directorio) + { + print_translate(44, dir); /* no hay directorio so/ */ + exit(1); + } + + /* Busca las .so */ + while ((fichero_dll = readdir(directorio)) != 0) + { + /* Salta los directorios actual '.' y padre ".." */ + if (strcmp(fichero_dll->d_name, ".") == 0) + continue; + + if (strcmp(fichero_dll->d_name, "..") == 0) + continue; + + if (fichero_dll->d_type == DT_REG) + { + char dllkey[256] = "dll_priority:"; +#ifdef _DEBUG + printf("dbg: Librería encontrada: %s/%s\n", dir, fichero_dll->d_name); +#endif + carga = 1; + sprintf(fichdll, "%s/%s", dir, fichero_dll->d_name); + dlls[numdlls].prioridad = 0; + get_rawname(fichero_dll->d_name, rawname); + strcpy(dllkey, "dll_priority:"); + strcat(dllkey, rawname); + + if (ini) + { + if (iniparser_getint(ini, dllkey, 0) <= P_NUNCA) + carga = 0; } - /* hace lo mismo con el resto */ - while(1) { - if(_findnext(buscafich,&fichero_dll)==0) { - #ifdef _DEBUG - printf("dbg: DLL encontrada: %s\n",fichero_dll.name); - #endif - carga=1; - sprintf(fichdll,"%s\\%s",dir,fichero_dll.name); - dlls[numdlls].prioridad=0; - get_rawname(fichero_dll.name,rawname); - strcpy(dllkey,"dll_priority:"); - strcat(dllkey,rawname); - if(ini) if(iniparser_getint(ini,dllkey,0)<=P_NUNCA) carga=0; - if(carga) if(!leedll()) { - dlls[numdlls].nombre=e_malloc(strlen(rawname)+1); - strcpy(dlls[numdlls].nombre,rawname); - dlls[numdlls].usado=0; - if(ini) dlls[numdlls].prioridad=iniparser_getint(ini,dllkey,dlls[numdlls].prioridad); + if (carga) + { + if (!leedll()) + { + dlls[numdlls].nombre = e_malloc(strlen(rawname) + 1); + strcpy(dlls[numdlls].nombre, rawname); + dlls[numdlls].usado = 0; + + if (ini) + dlls[numdlls].prioridad = iniparser_getint(ini, dllkey, dlls[numdlls].prioridad); + numdlls++; } } - else - break; } + } - #else /* si estamos en Linux */ +#endif - if(ini) dir=iniparser_getstr(ini,"dll:nixdll"); - if(!dir) dir="so"; + if (numdlls == 0) + print_translate(43); /* no hay librerias */ - directorio=opendir(dir); - if(!directorio) { - printf(translate(44),dir); /* no hay directorio so/ */ - exit(1); - } + nuevo_orden = e_malloc(numdlls * 4); + for (i = 0; i < numdlls; i++) + nuevo_orden[i] = i; - /* Busca las .so */ - while ((fichero_dll = readdir(directorio)) != 0) { - /* Salta los directorios actual '.' y padre ".." */ - if (strcmp(fichero_dll->d_name, ".") == 0) - continue; - - if (strcmp(fichero_dll->d_name, "..") == 0) - continue; - - if(fichero_dll->d_type==DT_REG) { - char dllkey[256]="dll_priority:"; - #ifdef _DEBUG - printf("dbg: Librería encontrada: %s/%s\n",dir,fichero_dll->d_name); - #endif - carga=1; - sprintf(fichdll,"%s/%s",dir,fichero_dll->d_name); - dlls[numdlls].prioridad=0; - get_rawname(fichero_dll->d_name,rawname); - strcpy(dllkey,"dll_priority:"); - strcat(dllkey,rawname); - - if (ini) { - if (iniparser_getint(ini,dllkey,0) <= P_NUNCA) - carga=0; - } - - if(carga) { - if(!leedll()) { - dlls[numdlls].nombre=e_malloc(strlen(rawname)+1); - strcpy(dlls[numdlls].nombre,rawname); - dlls[numdlls].usado=0; - - if (ini) - dlls[numdlls].prioridad=iniparser_getint(ini,dllkey,dlls[numdlls].prioridad); - - numdlls++; - } - } - } - } - - #endif - - if(numdlls==0) - printf(translate(43)); /* no hay librerias */ - - nuevo_orden=e_malloc(numdlls*4); - for(i=0;iP_NUNCA) && (dlls[numdlls].usado || dlls[numdlls].prioridad>=P_SIEMPRE)) { - #ifdef _DEBUG - printf("dbg: Se requiere %s (id=%d)\n",dlls[numdlls].nombre,numdlls); - #endif - #ifdef _WIN32 - if(ini) dir=iniparser_getstr(ini,"dll:windll"); - if(!dir) dir="dll"; - sprintf(fichdll,"%s\\%s.dll",dir,dlls[numdlls].nombre); - #else - if(ini) dir=iniparser_getstr(ini,"dll:nixdll"); - if(!dir) dir="so"; - sprintf(fichdll,"%s/%s.so",dir,dlls[numdlls].nombre); - #endif + for (i = 0; i < numdlls; i++) + nuevo_orden[i] = i; - if(leedll()) { - printf(translate(45),dlls[numdlls].nombre); /* error al cargar libreria */ + for (numdlls = 0; numdlls < i; numdlls++) + { + if ((dlls[numdlls].prioridad > P_NUNCA) && (dlls[numdlls].usado || dlls[numdlls].prioridad >= P_SIEMPRE)) + { +#ifdef _DEBUG + printf("dbg: Se requiere %s (id=%d)\n", dlls[numdlls].nombre, numdlls); +#endif +#ifdef _WIN32 + if (ini) + dir = iniparser_getstr(ini, "dll:windll"); + if (!dir) + dir = "dll"; + sprintf(fichdll, "%s\\%s.dll", dir, dlls[numdlls].nombre); +#else + if (ini) + dir = iniparser_getstr(ini, "dll:nixdll"); + if (!dir) + dir = "so"; + sprintf(fichdll, "%s/%s.so", dir, dlls[numdlls].nombre); +#endif + + if (leedll()) + { + print_translate(45, dlls[numdlls].nombre); /* error al cargar libreria */ exit(1); } } } } - int leedll() { TYPEOF_ExportaFuncs *ExportaFuncs; @@ -292,58 +307,62 @@ int leedll() HINSTANCE hDLL; /* Carga la DLL */ - hDLL=LoadDLL(fichdll); + hDLL = LoadDLL(fichdll); - if(hDLL==NULL) { - printf(translate(46),fichdll); /* no puedo cargar libreria */ + if (hDLL == NULL) + { + print_translate(46, fichdll); /* no puedo cargar libreria */ return 1; } /* Inicializa y ejecuta la funcion ExportaFuncs de la DLL */ - ExportaFuncs=NULL; - ExportaFuncs=(TYPEOF_ExportaFuncs *)GetDLLProcAddress(hDLL,"ExportaFuncs"); + ExportaFuncs = NULL; + ExportaFuncs = (TYPEOF_ExportaFuncs *)GetDLLProcAddress(hDLL, "ExportaFuncs"); - if(ExportaFuncs==NULL) { - printf(translate(47),fichdll); /* exportafuncs no encontrado */ + if (ExportaFuncs == NULL) + { + print_translate(47, fichdll); /* exportafuncs no encontrado */ FreeDLL(hDLL); return 1; } - #ifdef DEBUG_DLL - printf("dbg: ExportaFuncs encontrado!! :D\n"); - #endif +#ifdef DEBUG_DLL + printf("dbg: ExportaFuncs encontrado!! :D\n"); +#endif ExportaFuncs(EXPORTAFUNCS_PARAMS); FreeDLL(hDLL); -#else /* Linux */ - void *hDLL; - char *errordll; +#else /* Linux */ + void *hDLL; + char *errordll; /* Carga la DLL */ - hDLL=dlopen(fichdll,RTLD_NOW); + hDLL = dlopen(fichdll, RTLD_NOW); - if(!hDLL) { - printf(translate(46),fichdll,dlerror()); /* no puedo cargar libreria */ + if (!hDLL) + { + print_translate(46, fichdll, dlerror()); /* no puedo cargar libreria */ return 1; } /* Inicializa y ejecuta la funcion ExportaFuncs de la DLL */ - ExportaFuncs=NULL; + ExportaFuncs = NULL; - ExportaFuncs=(TYPEOF_ExportaFuncs *) dlsym(hDLL,"ExportaFuncs"); + ExportaFuncs = (TYPEOF_ExportaFuncs *)dlsym(hDLL, "ExportaFuncs"); - if((errordll=dlerror())!=NULL) { - printf(translate(47),fichdll,errordll); /* exportafuncs no encontrado */ + if ((errordll = dlerror()) != NULL) + { + print_translate(47, fichdll, errordll); /* exportafuncs no encontrado */ dlclose(hDLL); return 1; } - #ifdef DEBUG_DLL - printf("dbg: ExportaFuncs encontrado!! :D\n"); - #endif +#ifdef DEBUG_DLL + printf("dbg: ExportaFuncs encontrado!! :D\n"); +#endif ExportaFuncs(EXPORTAFUNCS_PARAMS); dlclose(hDLL); diff --git a/ediv/src/shared/language.h b/ediv/src/shared/language.h index 5fb4b2d..fa2b39e 100644 --- a/ediv/src/shared/language.h +++ b/ediv/src/shared/language.h @@ -40,30 +40,31 @@ #undef TRANSLATE #endif -#define TRANSLATE_ERROR 1 -#define TRANSLATE_WARNING 2 -#define TRANSLATE_DLL_ERROR 3 -#define TRANSLATE_LTLEX_ERROR 4 -#define TRANSLATE_COMPILER 5 -#define TRANSLATE_STUB 6 -#define TRANSLATE_RUNTIME_ERROR 7 -#define TRANSLATE_CRITICAL_ERROR 8 - +#define TRANSLATE_ERROR 1 +#define TRANSLATE_WARNING 2 +#define TRANSLATE_DLL_ERROR 3 +#define TRANSLATE_LTLEX_ERROR 4 +#define TRANSLATE_COMPILER 5 +#define TRANSLATE_STUB 6 +#define TRANSLATE_RUNTIME_ERROR 7 +#define TRANSLATE_CRITICAL_ERROR 8 int idioma; /* comunes */ int detecta_idioma(); -char* translate(int num); -char* translate_dll_error(int num); +char *translate(int num); +char *translate_dll_error(int num); +const char *get_translate(int num, ...); +void print_translate(int num, ...); /* compilador */ -char* translate_error(int num); -char* translate_warning(int num); -char* translate_ltlex_error(int num); +char *translate_error(int num); +char *translate_warning(int num); +char *translate_ltlex_error(int num); /* stub */ -char* translate_runtime_error(int num); -char* translate_critical_error(int num); +char *translate_runtime_error(int num); +char *translate_critical_error(int num); #endif /* __EDIV_LANGUAGE_H_ */ diff --git a/ediv/src/stub/ediv_export.c b/ediv/src/stub/ediv_export.c index a8e1b06..d718857 100644 --- a/ediv/src/stub/ediv_export.c +++ b/ediv/src/stub/ediv_export.c @@ -19,7 +19,7 @@ */ #ifdef _WIN32 -# include +#include #endif #include @@ -44,9 +44,9 @@ struct objeto * ob2;*/ int creaobj; -byte decl_struct=0; // 1 si se está declarando un struct +byte decl_struct = 0; // 1 si se está declarando un struct -byte slocal=0; // para las structs. 0=global, 1=local +byte slocal = 0; // para las structs. 0=global, 1=local int nregs; int offset; @@ -79,24 +79,22 @@ int offset; return 0; }*/ - // Errores específicos en la ejecución de una DLL - void dll_error(int error, ...) { va_list opparam; char mensaje[256]; - va_start(opparam,error); + va_start(opparam, error); - sprintf(mensaje,translate(3), fichdll); - vsprintf(mensaje,translate_dll_error(error),opparam); + sprintf(mensaje, get_translate(3, fichdll)); + vsprintf(mensaje, get_translate(translate_dll_error(error)), opparam); - #ifdef _WIN32 - MessageBox(0,mensaje,translate(4),MB_ICONERROR); - #else - printf("%s\n",mensaje); - #endif +#ifdef _WIN32 + MessageBox(0,mensaje,print_translate((4),MB_ICONERROR); +#else + printf("%s\n", mensaje); +#endif //printf("\n"); //n_errors++; @@ -104,25 +102,25 @@ void dll_error(int error, ...) exit(-1); } - - -int EDIV_Export(char* cadena, int nparam, void* hfuncion) +int EDIV_Export(char *cadena, int nparam, void *hfuncion) { - if(decl_struct) { - dll_error(6,cadena); + if (decl_struct) + { + dll_error(6, cadena); return 0; } -// creaobj=crea_objeto((byte*)cadena); + // creaobj=crea_objeto((byte*)cadena); - #ifdef DEBUG_DLL - printf("export_function:\t-- ID FUNCION: %d\n" - "export_function:\tCadena exportada: %s\n" - "export_function:\tN. parametros: %d\n" - "export_function:\tOffset de la funcion: 0x%X\n",n_externs,cadena,nparam,(unsigned int)hfuncion); - #endif +#ifdef DEBUG_DLL + printf("export_function:\t-- ID FUNCION: %d\n" + "export_function:\tCadena exportada: %s\n" + "export_function:\tN. parametros: %d\n" + "export_function:\tOffset de la funcion: 0x%X\n", + n_externs, cadena, nparam, (unsigned int)hfuncion); +#endif -/* if(creaobj) { + /* if(creaobj) { dll_error(creaobj,cadena); return 0; } @@ -138,56 +136,54 @@ int EDIV_Export(char* cadena, int nparam, void* hfuncion) ob->fext.codigo=n_externs; ob->fext.num_par=nparam; // es necesario?*/ - extfuncs[n_externs]=hfuncion; - extparms[n_externs]=nparam; + extfuncs[n_externs] = hfuncion; + extparms[n_externs] = nparam; -/* for(i=0;isloc.totalitems*ob->sloc.len_item; } */ - if(len==0) dll_error(10); + if (len == 0) + dll_error(10); - if(slocal) diloc+=len*nregs; - else dimem+=len*nregs; + if (slocal) + diloc += len * nregs; + else + dimem += len * nregs; - decl_struct=0; + decl_struct = 0; return 1; } - -int EDIV_Export_Local(char* cadena, int valor) +int EDIV_Export_Local(char *cadena, int valor) { - if(decl_struct) { - dll_error(6,cadena); + if (decl_struct) + { + dll_error(6, cadena); return 0; } -/* creaobj=crea_objeto((byte*)cadena); + /* creaobj=crea_objeto((byte*)cadena); #ifdef DEBUG_DLL printf("export_local:\t-- ID OBJETO: %d\n" @@ -622,18 +620,18 @@ int EDIV_Export_Local(char* cadena, int valor) ob->vloc.offset=iloc; loc[iloc]=valor; */ - return diloc++; + return diloc++; } - -int EDIV_Export_Local_Tab(char* cadena, int numregs) +int EDIV_Export_Local_Tab(char *cadena, int numregs) { - if(decl_struct) { - dll_error(6,cadena); + if (decl_struct) + { + dll_error(6, cadena); return 0; } -/* creaobj=crea_objeto((byte*)cadena); + /* creaobj=crea_objeto((byte*)cadena); #ifdef DEBUG_DLL printf("export_local_tab:\t-- ID OBJETO: %d\n" @@ -668,23 +666,23 @@ int EDIV_Export_Local_Tab(char* cadena, int numregs) return ob->tloc.offset;*/ - offset=diloc; - diloc+=numregs; + offset = diloc; + diloc += numregs; return offset; } - -int EDIV_Export_Local_Struct(char* cadena, int numregs) +int EDIV_Export_Local_Struct(char *cadena, int numregs) { - if(decl_struct) { - dll_error(6,cadena); + if (decl_struct) + { + dll_error(6, cadena); return 0; } - nregs=numregs; - slocal=1; + nregs = numregs; + slocal = 1; -/* creaobj=crea_objeto((byte*)cadena); + /* creaobj=crea_objeto((byte*)cadena); #ifdef DEBUG_DLL printf("export_local_struct:\t-- ID OBJETO: %d\n" @@ -716,12 +714,11 @@ int EDIV_Export_Local_Struct(char* cadena, int numregs) member=ob; len=0; */ - decl_struct=1; - len=0; - return diloc; + decl_struct = 1; + len = 0; + return diloc; } - //////////////// /// Call_Entrypoint ////////////// @@ -729,90 +726,92 @@ int EDIV_Export_Local_Struct(char* cadena, int numregs) int Call_Entrypoint(int ep, ...) { va_list opparam; - int i,c=0; - for(i=0;i +#include #else #include #endif @@ -55,29 +55,28 @@ void error(int num, ...) { - #ifdef _WIN32 - HWND ventanuka; - #endif +#ifdef _WIN32 + HWND ventanuka; +#endif va_list opparam; char mensaje[256]; - va_start(opparam,num); - sprintf(mensaje,translate(0), num); - vsprintf(mensaje,translate_runtime_error(num-100),opparam); + va_start(opparam, num); + sprintf(mensaje, get_translate(0), num); + vsprintf(mensaje, translate_runtime_error(num - 100), opparam); - #ifdef _WIN32 - ventanuka=GetActiveWindow(); - //MessageBox( - MessageBox(ventanuka,mensaje,translate(1),MB_ICONERROR); - #else - printf("%s\n",mensaje); - #endif +#ifdef _WIN32 + ventanuka = GetActiveWindow(); + //MessageBox( + MessageBox(ventanuka, mensaje, print_translate(1), MB_ICONERROR); +#else + printf("%s\n", mensaje); +#endif stub_quit(num); } - /* critical_error ( numero, parametros [...] ) * * Interrumpe el programa con un mensaje de error. No es posible trazar. @@ -90,20 +89,19 @@ void critical_error(int num, ...) va_list opparam; char mensaje[256]; - va_start(opparam,num); - sprintf(mensaje,translate(0), num); - vsprintf(mensaje,translate_critical_error(num),opparam); + va_start(opparam, num); + sprintf(mensaje, get_translate(0), num); + vsprintf(mensaje, translate_critical_error(num), opparam); - #ifdef WIN32 - MessageBox(0,mensaje,translate(2),MB_ICONERROR); - #else - printf("%s\n",mensaje); - #endif +#ifdef WIN32 + MessageBox(0, mensaje, print_translate(2), MB_ICONERROR); +#else + printf("%s\n", mensaje); +#endif stub_quit(num); } - /* custom_error (tipo, mensaje) * * Permite a las DLLs generar sus propios errores, para que no dependan de los @@ -119,13 +117,13 @@ void critical_error(int num, ...) * DESVENTAJA: se pierde la capacidad multilingüe, a menos que la incluya la propia DLL. */ -void custom_error(tipoerror tipo, char* mensaje) +void custom_error(tipoerror tipo, char *mensaje) { - #ifdef WIN32 - MessageBox(0,mensaje,translate(tipo),MB_ICONERROR); - #else - printf("%s\n",mensaje); - #endif +#ifdef WIN32 + MessageBox(0, mensaje, print_translate(tipo), MB_ICONERROR); +#else + printf("%s\n", mensaje); +#endif - stub_quit(500+tipo); + stub_quit(500 + tipo); } diff --git a/ediv/src/stub/language.c b/ediv/src/stub/language.c index ed21a87..3f17735 100644 --- a/ediv/src/stub/language.c +++ b/ediv/src/stub/language.c @@ -18,74 +18,77 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ - /**** ¡¡¡ OJO CON LAS COMAS !!! ****/ - #ifdef _WIN32 -# include +#include #else -# include -# include +#include +#include +#include #endif #include "shared.h" #include "language.h" - -int detecta_idioma_iso(char* lang) +int detecta_idioma_iso(char *lang) { int i; static char getid[NUM_LANGUAGES][3] = { - "es", // español - "it", // italiano - "pt", // portugués - "en", // inglés - "ca", // catalán - "eu" // euskera + "es", // español + "it", // italiano + "pt", // portugués + "en", // inglés + "ca", // catalán + "eu" // euskera }; - if(lang==NULL) return DEFAULT_LANGUAGE; - if(strlen(lang)>2) lang[2]=0; + if (lang == NULL) + return DEFAULT_LANGUAGE; + if (strlen(lang) > 2) + lang[2] = 0; strlwr(lang); - for(i=0;i