diff --git a/ediv/src/ediv/compiler.c b/ediv/src/ediv/compiler.c index f9281e7..ad5843e 100644 --- a/ediv/src/ediv/compiler.c +++ b/ediv/src/ediv/compiler.c @@ -1,7 +1,7 @@ /* * eDiv Compiler - * Copyleft (C) 2000-2002 Sion Entertainment - * http://www.sion-e.com + * Copyright (C) 2000-2002 Sion Entertainment + * http://www.sionhq.com * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -21,10 +21,6 @@ #include #include -//#include -//#ifdef __linux__ -//# include -//#endif #include @@ -42,7 +38,7 @@ #include "varindex.h" #include "language.h" -void analiza_ltlex(void); // en ltlex.c +void analiza_ltlex(void); /* en ltlex.c */ void prepara_compilacion() @@ -63,18 +59,18 @@ void prepara_compilacion() inicializa_lower(); - // Inicializamos la tabla de objetos + /* Inicializamos la tabla de objetos */ memset(obj,0,sizeof(obj[0])*max_obj); iobj=obj; num_obj=0; - // Inicializamos la tabla de símbolos + /* 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 + /* Inicializamos los caracteres básicos en lex_case */ for (n=0;n<256;n++) if (lower[n]) { if (n>='0' && n<='9') @@ -86,33 +82,33 @@ void prepara_compilacion() lex_case[n]=(struct lex_ele *)l_err; - // Inicializamos el vector de nombres + /* Inicializamos el vector de nombres */ vnom=(byte *) e_malloc(max_obj*long_med_id+1024); ivnom.b=vnom; - // Leemos los símbolos y palabras reservadas de ltlex.def + /* Leemos los símbolos y palabras reservadas de ltlex.def */ analiza_ltlex(); - // Terminamos de inicializar lex_case + /* 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 + /* Buffer para el bytecode */ imem_max=default_buffer; imem=0; mem_ory=mem=(int*)e_malloc(imem_max*sizeof(int)); memset(mem,0,imem_max*sizeof(int)); - // Buffer para variables locales y privadas + /* Buffer para variables locales y privadas */ iloc_max=default_buffer/2; iloc=0; iloc_len=0; loc=(int*)e_malloc(iloc_max*sizeof(int)); memset(loc,0,iloc_max*sizeof(int)); - // No se lo que es + /* ¿Que es esto? */ ifrm_max=default_buffer/2; frm=(int*)e_malloc(ifrm_max*sizeof(int)); memset(frm,0,ifrm_max*sizeof(int)); @@ -132,7 +128,7 @@ void compila() unsigned long m; byte * q, * p; int start_lin, start_dbg; - byte* varptr; // variables indexadas + byte* varptr; /* variables indexadas */ FILE* fvar; ultima_linea=prog; @@ -142,7 +138,7 @@ void compila() printf(translate(27)); itxt=inicio_textos=imem; - psintactico(); // Para obtener "longitud_textos" + psintactico(); /* Para obtener "longitud_textos" */ imem+=longitud_textos; #ifdef _DEBUG printf("dbg: longitud_textos: %d\n",longitud_textos); @@ -154,7 +150,7 @@ void compila() num_obj_predefinidos=num_obj; - ultima_linea=source; //fwrite(&cero,1,1,lprg); + ultima_linea=source; acceso_remoto=0; parametros=0; linea=1; sintactico(); @@ -164,14 +160,14 @@ void compila() if (i->usado) { linea=i->linea; ierror=i->ierror; - error(0,34,i->name); // nombre desconocido + error(0,34,i->name); /* nombre desconocido */ } i++; } if(n_errors>0) return; - // Borra todo y comienza de nuevo :P + /* Borra todo y comienza de nuevo :P */ printf(translate(28)); @@ -183,8 +179,8 @@ void compila() prepara_compilacion(); source=prog; - inicializa_index(); // ahora toca construir el indice de variables - dll_func2(); // recarga sólo las dlls necesarias + inicializa_index(); /* ahora toca construir el indice de variables */ + dll_func2(); /* recarga sólo las dlls necesarias */ if(debug) { if((linf=tmpfile())==NULL) { @@ -201,8 +197,10 @@ void compila() 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: + /* + * 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; @@ -212,7 +210,7 @@ void compila() test_buffer(&mem,&imem_max,imem); } - // Si estamos compilando en modo debug, añadimos tambien la debug.dll + /* Si estamos compilando en modo debug, añadimos tambien la debug.dll */ if(debug) { dlls[numdlls].mem_nombre=imem; memcpy(&mem[imem],"debug",6); @@ -220,11 +218,13 @@ void compila() 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 + /* + * 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 + /* Escribimos la rutina de carga de DLLs */ for(n=0;n=P_SIEMPRE) g2(limp,dlls[n].mem_nombre); @@ -234,41 +234,47 @@ void compila() g2(ljmp,salto_import+1); - // Ya está !! :) + /* Ya está !! :) */ - // Preparamos la cabecera del bytecode + /* 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[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[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) - // +128 = El programa invoca al trazador nada más ejecutarse (compilado con F12) - // +512 = Se ignoran los errores de ejecución (ignore_errors) - // +1024= Modo DEMO (mensaje en el centro de la pantalla parpadeando diciendo - // "VERSIÓN DE DEMOSTRACIÓN") + /* + * 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) + * +128 = El programa invoca al trazador nada más ejecutarse (compilado con F12) + * +512 = Se ignoran los errores de ejecución (ignore_errors) + * +1024= Modo DEMO (mensaje en el centro de la pantalla parpadeando diciendo + * "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 - // de dlopen y demas y haciendonos una pekeña lib (esto es mas aconsejable) - // +32 = El exe lleva incluido el PAK - // +64 = Compilado en modo debug - // +128 = Igual que en DIV2, el programa invoca al trazador nada más ejecutarse (se - // ha usado la orden "trazar programa" en el IDE) - // +512 = ignore_errors, igual que en DIV2 + /* + * 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 + * de dlopen y demas y haciendonos una pekeña lib (esto es mas aconsejable) + * +32 = El exe lleva incluido el PAK + * +64 = Compilado en modo debug + * +128 = Igual que en DIV2, el programa invoca al trazador nada más ejecutarse (se + * 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; - // Generamos los listados - // (debe hacerse ahora porque en el listado de objetos guardamos los valores de mem[1..8]) + /* + * 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(); @@ -279,23 +285,23 @@ void compila() printf(translate(31)); - // descomprime la edivrun.lib y guarda una copia con el nombre 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 + /* 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 + /* renombra temp.dj! al nombre del exe */ rename("temp.dj!",outfilename); - // ordenamos varindex + /* ordenamos varindex */ ordena_varindex(); - // escribimos en un temporal todo el indice de variables + /* escribimos en un temporal todo el indice de variables */ fvar=tmpfile(); for(n=0;nto && step>=0) error(4,62); } else { if (from=0) { // Comparación de la condición de permanencia + if (dir>=0) { /* Comparación de la condición de permanencia */ g2(lcar,dir); } else { g2(lcar,-dir); g1(laid); @@ -571,16 +576,16 @@ void sentencia() { g2(ljpf,0); im2=imem-1; final_sentencia(); grabar_sentencia(); - if (!free_sintax) if (pieza!=p_ptocoma) error(3,9); // esperando ';' + if (!free_sintax) if (pieza!=p_ptocoma) error(3,9); /* esperando ';' */ while (pieza==p_ptocoma || pieza==p_coma) lexico(); sentencia(); - if (pieza!=p_end) error(0,57); inicio_sentencia(); // esperando END + if (pieza!=p_end) error(0,57); inicio_sentencia(); /* esperando END */ lexico(); - im3=imem; // Posición del continue + im3=imem; /* Posición del continue */ - if (dir>=0) { // Incremento y vuelta al inicio del bucle + if (dir>=0) { /* Incremento y vuelta al inicio del bucle */ g2(lcar,dir); } else { g2(lcar,-dir); g1(laid); @@ -599,12 +604,12 @@ void sentencia() { inicio_sentencia(); tbreak[itbreak++]=0; tcont[itcont++]=0; lexico(); - if (pieza!=p_abrir) error(3,22); lexico(); // esperando '(' + 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) error(3,9); lexico(); /* esperando ';' */ if (pieza==p_ptocoma) { g2(lcar,1); } else expresion(); @@ -612,16 +617,16 @@ void sentencia() { 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_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 ')' + 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 + 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); @@ -632,10 +637,10 @@ void sentencia() { case p_switch: inicio_sentencia(); lexico(); - if (!free_sintax) if (pieza!=p_abrir) error(3,22); // esperando '(' + 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 (!free_sintax) if (pieza!=p_cerrar) error(3,18); /* esperando ')' */ if (pieza==p_cerrar) lexico(); while (pieza==p_ptocoma) { lexico(); @@ -667,13 +672,13 @@ void sentencia() { } 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 ':' + } 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 + if (pieza!=p_end) error(0,57); /* esperando END */ inicio_sentencia(); g2(ljmp,im2); im2=imem-1; pasa_ptocoma(); @@ -687,7 +692,7 @@ void sentencia() { inicio_sentencia(); lexico(); if (pieza==p_abrir) { lexico(); if (pieza!=p_cerrar) { - expresion(); if (pieza!=p_cerrar) error(3,18); // esperando ')' + expresion(); if (pieza!=p_cerrar) error(3,18); /* esperando ')' */ g1(lfrf); } else { g1(lfrm); @@ -695,27 +700,27 @@ void sentencia() { } else { g1(lfrm); } - if (!free_sintax) if (pieza!=p_ptocoma) error(3,9); // esperando ';' + 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 ';' + 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 ';' + 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 ';' + 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; @@ -724,7 +729,7 @@ void sentencia() { lexico(); g2(lclo,0); im1=imem-1; final_sentencia(); grabar_sentencia(); sentencia(); - if (pieza!=p_end) error(0,57); lexico(); // esperando END + if (pieza!=p_end) error(0,57); lexico(); /* esperando END */ mem[im1]=imem; break; case p_ptocoma: lexico(); break; @@ -738,7 +743,6 @@ void sentencia() { error_25=25; switch((*_exp).tipo) { case ecall: break; - //case efunc: break; case efext: break; case eoper: switch((*_exp).token) { @@ -758,11 +762,11 @@ void sentencia() { 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 + default: error(4,68); break; /* expresion sin sentido */ } break; - default: error(4,68); // expresion sin sentido + default: error(4,68); /* expresion sin sentido */ } - if (!free_sintax) if (pieza!=p_ptocoma) error(3,9); // esperando ';' + 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(); @@ -772,29 +776,9 @@ void sentencia() { } -//----------------------------------------------------------------------------- -// Funciones de generación de código -//----------------------------------------------------------------------------- - -// void g1(int op) { mem[imem++]=op; } -// void g2(int op, int pa) { mem[imem++]=op; mem[imem++]=pa; } - -//----------------------------------------------------------------------------- -// Optimización peephole de código intermedio EML -//----------------------------------------------------------------------------- - -// *** OJO!!! *** quizá se pueda quitar "dir" y esa comprobación absurda ... - -//struct { // Peephole, "mirilla" de optimizacion -// int dir; // Dirección -// int param; // Indica el número de parametros de la instruccion -// int op; // Opcode -//} code[16]; // En code[15] debe quedar siempre la última instrucción generada - -void gen(int param, int op, int pa); -void remove_code(int i); -void delete_code(void); -void add_code(int dir, int param, int op); +/* + * Funciones de generación de código + */ void g1(int op) { if (optimizar) gen(0,op,0); else mem[imem++]=op; @@ -804,11 +788,19 @@ 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 remove_code(int i); +void delete_code(void); +void add_code(int dir, int param, int op); + int optimizado; -void gen(int param, int op, int pa) { -// int n; - +void gen(int param, int op, int pa) +{ optimizado=0; switch(op) { @@ -960,7 +952,7 @@ void gen(int param, int op, int pa) { } 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" + code[15].op=mem[imem-2]=lcardiv; /* Un cardiv nunca será "cardiv 0" */ optimizado=1; } } break; @@ -1014,10 +1006,9 @@ void add_code(int dir, int param, int op) { } -//----------------------------------------------------------------------------- -// Con el primer token leido guarda el inicio de una sentencia -//----------------------------------------------------------------------------- - +/* + * Con el primer token leido guarda el inicio de una sentencia + */ void inicio_sentencia(void) { byte * p=ierror-1; @@ -1029,10 +1020,9 @@ void inicio_sentencia(void) } } -//----------------------------------------------------------------------------- -// Con el primer token que no es de la sentecia guarda el fin de una sentencia -//----------------------------------------------------------------------------- - +/* + * Con el primer token que no es de la sentecia guarda el fin de una sentencia + */ void final_sentencia(void) { byte * p=old_ierror_end-1; @@ -1044,9 +1034,9 @@ void final_sentencia(void) } } -//----------------------------------------------------------------------------- -// Guarda un registro (inicio,final,linea1,...) en el temporal (linf) -//----------------------------------------------------------------------------- +/* + * Guarda un registro (inicio,final,linea1,...) en el temporal (linf) + */ void grabar_sentencia(void) { @@ -1060,31 +1050,17 @@ void grabar_sentencia(void) } } -//----------------------------------------------------------------------------- -// Agrega información de depurado al ejecutable -//----------------------------------------------------------------------------- +/* + * Agrega información de depurado al ejecutable + */ void escribe_lin(FILE* f) { int b=0; int l; byte* progcomp; - - /*#ifdef WIN32 - // Resuelve la ruta del PRG - char resolved_path[_MAX_PATH]; - _fullpath(resolved_path,fichero_prg,_MAX_PATH); - #else - // Lo mismo pero en Linux - char resolved_path[PATH_MAX]; - realpath(fichero_prg,resolved_path); - #endif - // Escribe la ruta resuelta - fputs(resolved_path,f); - fputc(0,f);*/ - - // comprimimos el codigo fuente + /* comprimimos el codigo fuente */ while(prog[b]!=0) b++; progcomp=e_malloc(b*2); l=b*2; @@ -1093,22 +1069,22 @@ void escribe_lin(FILE* f) fclose(f); errormem(); } - // escribe el tamaño del codigo descomprimido + /* escribe el tamaño del codigo descomprimido */ fwrite(&b,1,4,f); - // escribe el tamaño del codigo comprimido + /* escribe el tamaño del codigo comprimido */ fwrite(&l,1,4,f); - // escribe el codigo comprimido + /* escribe el codigo comprimido */ fwrite(progcomp,1,l,f); free(progcomp); - // Escribe el tamaño del LIN + /* Escribe el tamaño del LIN */ b=ftell(linf); #ifdef _DEBUG printf("dbg: TAMANO LIN: %d\n",b); #endif fwrite(&b,1,4,f); - // Escribe la información LIN (offset de cada sentencia en el prg y en el bytecode) + /* 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); @@ -1117,13 +1093,14 @@ void escribe_lin(FILE* f) } -// Escribe información sobre los objetos - +/* + * Escribe información sobre los objetos + */ void escribe_dbg(FILE* f) { int n; - // Datos comunes de cada objeto + /* Datos comunes de cada objeto */ struct { int tipo; int nombre; @@ -1132,7 +1109,7 @@ void escribe_dbg(FILE* f) int v0,v1,v2,v3,v4,v5; } ob; - // Cabecera de sección DBG + /* Cabecera de sección DBG */ fwrite(&num_obj,4,1,f); fwrite(&num_obj_predefinidos,4,1,f); n=(int)&obj[0]; @@ -1140,10 +1117,10 @@ void escribe_dbg(FILE* f) n=sizeof(struct objeto); fwrite(&n,4,1,f); - // Escribe los datos de cada objeto + /* Escribe los datos de cada objeto */ for (n=0;n add rng ptr - -//vloc &vloc aid ptr -//tloc[_exp] &tloc <_exp> add rng aid ptr - -//proc.vloc &proc ptr &vloc add ptr -//proc.tloc[_exp] &proc ptr &tloc <_exp> add rng add ptr +/* + * Inserción en la tabla de expresiones, acceso a variables: + * + * vglo &vglo ptr + * tglo[_exp] &tglo <_exp> add rng ptr + * vloc &vloc aid ptr + * tloc[_exp] &tloc <_exp> add rng aid ptr + * proc.vloc &proc ptr &vloc add ptr + * proc.tloc[_exp] &proc ptr &tloc <_exp> add rng add ptr + */ FILE * fin, * fout; @@ -80,75 +83,71 @@ int optimizar; int case_sensitive; -//----------------------------------------------------------------------------- -// MNEMÓNICOS BYTECODE EML -//----------------------------------------------------------------------------- - -//Mnemónico-Códg.-Operandos (Generación de código EML, "*" = "aún no usado") - -#define lnop 0 // * No operación -#define lcar 1 // valor Carga una constante en pila -#define lasi 2 // Saca valor, offset y mete el valor en [offset] -#define lori 3 // Or lógico -#define lxor 4 // Xor, or exclusivo -#define land 5 // And lógico, operador sobre condiciones -#define ligu 6 // Igual, operador logico de comparación -#define ldis 7 // Distinto, true si los 2 valores son diferentes -#define lmay 8 // Mayor, comparación con signo -#define lmen 9 // Menor, idem -#define lmei 10 // Menor o igual -#define lmai 11 // Mayor o igual -#define ladd 12 // Suma dos constantes -#define lsub 13 // Resta, operación binaria -#define lmul 14 // Multiplicación -#define ldiv 15 // División de enteros -#define lmod 16 // Módulo, resto de la división -#define lneg 17 // Negación, cambia de signo una constante -#define lptr 18 // Pointer, saca offset y mete [offset] -#define lnot 19 // Negación binaria, bit a bit -#define laid 20 // Suma id a la constante de la pila -#define lcid 21 // Carga id en la pila -#define lrng 22 // rango Realiza una comparación de rango -#define ljmp 23 // offset Salta a una dirección de mem[] -#define ljpf 24 // offset Salta si un valor es falso a una dirección -#define lfun 25 // código Llamada a un proceso interno, ej. signal() -#define lcal 26 // offset Crea un nuevo proceso en el programa -#define lret 27 // Auto-eliminación del proceso -#define lasp 28 // Desecha un valor apilado -#define lfrm 29 // Detiene por este frame la ejecución del proceso -#define lcbp 30 // num_par Inicializa el puntero a los parámetros locales -#define lcpa 31 // Saca offset, lee parámetro [offset] y bp++ -#define ltyp 32 // bloque Define el tipo de proceso actual (colisiones) -#define lpri 33 // offset Salta a la dirección, y carga var. privadas -#define lcse 34 // offset Si switch <> expresión, salta al offset -#define lcsr 35 // offset Si switch no esta en el rango, salta al offset -#define lshr 36 // Rotacion a la derecha (modo C, >>) -#define lshl 37 // Rotacion a la izquierda (modo C, <<) -#define lipt 38 // Incremento y pointer -#define lpti 39 // Pointer e incremento -#define ldpt 40 // Decremento y pointer -#define lptd 41 // Pointer y decremento -#define lada 42 // Add-asignación -#define lsua 43 // Sub-asignación -#define lmua 44 // Mul-asignación -#define ldia 45 // Div-asignación -#define lmoa 46 // Mod-asignación -#define lana 47 // And-asignación -#define lora 48 // Or-asignación -#define lxoa 49 // Xor-asignación -#define lsra 50 // Shr-asignación -#define lsla 51 // Shl-asignación -#define lpar 52 // num_par_pri Define el número de parámetros privados -#define lrtf 53 // Auto-eliminación del proceso, devuelve un valor -#define lclo 54 // offset Crea un clon del proceso actual -#define lfrf 55 // Pseudo-Frame (frame a un porcentaje, frame(100)==frame) -#define limp 56 // offset text Importa una DLL externa -#define lext 57 // código Llama a una función externa -#define lchk 58 // Comprueba la validez de un identificador -#define ldbg 59 // Invoca al debugger - -// Instrucciones añadidas para la optimización (DIV 2.0) +/* + * MNEMÓNICOS BYTECODE EML + */ +#define lnop 0 /* * No operación */ +#define lcar 1 /* valor Carga una constante en pila */ +#define lasi 2 /* Saca valor, offset y mete el valor en [offset] */ +#define lori 3 /* Or lógico */ +#define lxor 4 /* Xor, or exclusivo */ +#define land 5 /* And lógico, operador sobre condiciones */ +#define ligu 6 /* Igual, operador logico de comparación */ +#define ldis 7 /* Distinto, true si los 2 valores son diferentes */ +#define lmay 8 /* Mayor, comparación con signo */ +#define lmen 9 /* Menor, idem */ +#define lmei 10 /* Menor o igual */ +#define lmai 11 /* Mayor o igual */ +#define ladd 12 /* Suma dos constantes */ +#define lsub 13 /* Resta, operación binaria */ +#define lmul 14 /* Multiplicación */ +#define ldiv 15 /* División de enteros */ +#define lmod 16 /* Módulo, resto de la división */ +#define lneg 17 /* Negación, cambia de signo una constante */ +#define lptr 18 /* Pointer, saca offset y mete [offset] */ +#define lnot 19 /* Negación binaria, bit a bit */ +#define laid 20 /* Suma id a la constante de la pila */ +#define lcid 21 /* Carga id en la pila */ +#define lrng 22 /* rango Realiza una comparación de rango */ +#define ljmp 23 /* offset Salta a una dirección de mem[] */ +#define ljpf 24 /* offset Salta si un valor es falso a una dirección */ +#define lfun 25 /* código Llamada a un proceso interno, ej. signal() */ +#define lcal 26 /* offset Crea un nuevo proceso en el programa */ +#define lret 27 /* Auto-eliminación del proceso */ +#define lasp 28 /* Desecha un valor apilado */ +#define lfrm 29 /* Detiene por este frame la ejecución del proceso */ +#define lcbp 30 /* num_par Inicializa el puntero a los parámetros locales */ +#define lcpa 31 /* Saca offset, lee parámetro [offset] y bp++ */ +#define ltyp 32 /* bloque Define el tipo de proceso actual (colisiones) */ +#define lpri 33 /* offset Salta a la dirección, y carga var. privadas */ +#define lcse 34 /* offset Si switch <> expresión, salta al offset */ +#define lcsr 35 /* offset Si switch no esta en el rango, salta al offset */ +#define lshr 36 /* Rotacion a la derecha (modo C, >>) */ +#define lshl 37 /* Rotacion a la izquierda (modo C, <<) */ +#define lipt 38 /* Incremento y pointer */ +#define lpti 39 /* Pointer e incremento */ +#define ldpt 40 /* Decremento y pointer */ +#define lptd 41 /* Pointer y decremento */ +#define lada 42 /* Add-asignación */ +#define lsua 43 /* Sub-asignación */ +#define lmua 44 /* Mul-asignación */ +#define ldia 45 /* Div-asignación */ +#define lmoa 46 /* Mod-asignación */ +#define lana 47 /* And-asignación */ +#define lora 48 /* Or-asignación */ +#define lxoa 49 /* Xor-asignación */ +#define lsra 50 /* Shr-asignación */ +#define lsla 51 /* Shl-asignación */ +#define lpar 52 /* num_par_pri Define el número de parámetros privados */ +#define lrtf 53 /* Auto-eliminación del proceso, devuelve un valor */ +#define lclo 54 /* offset Crea un clon del proceso actual */ +#define lfrf 55 /* Pseudo-Frame (frame a un porcentaje) */ +#define limp 56 /* offset text Importa una DLL externa */ +#define lext 57 /* código Llama a una función externa */ +#define lchk 58 /* Comprueba la validez de un identificador */ +#define ldbg 59 /* Invoca al debugger */ +/* Instrucciones añadidas para la optimización (DIV 2.0) */ #define lcar2 60 #define lcar3 61 #define lcar4 62 @@ -168,68 +167,63 @@ int case_sensitive; #define lcarsub 76 #define lcardiv 77 -// Instrucciones añadidas para el manejo de caracteres +/* Instrucciones añadidas para el manejo de caracteres */ +#define lptrchr 78 /* Pointer, saca (index, offset) y mete [offset+byte index] */ +#define lasichr 79 /* Saca (valor, index, offset) y mete el valor en [offset+byte index] */ +#define liptchr 80 /* Incremento y pointer */ +#define lptichr 81 /* Pointer e incremento */ +#define ldptchr 82 /* Decremento y pointer */ +#define lptdchr 83 /* Pointer y decremento */ +#define ladachr 84 /* Add-asignación */ +#define lsuachr 85 /* Sub-asignación */ +#define lmuachr 86 /* Mul-asignación */ +#define ldiachr 87 /* Div-asignación */ +#define lmoachr 88 /* Mod-asignación */ +#define lanachr 89 /* And-asignación */ +#define lorachr 90 /* Or-asignación */ +#define lxoachr 91 /* Xor-asignación */ +#define lsrachr 92 /* Shr-asignación */ +#define lslachr 93 /* Shl-asignación */ +#define lcpachr 94 /* Saca offset, lee parámetro [offset] y bp++ */ -#define lptrchr 78 // Pointer, saca (index, offset) y mete [offset+byte index] -#define lasichr 79 // Saca (valor, index, offset) y mete el valor en [offset+byte index] -#define liptchr 80 // Incremento y pointer -#define lptichr 81 // Pointer e incremento -#define ldptchr 82 // Decremento y pointer -#define lptdchr 83 // Pointer y decremento -#define ladachr 84 // Add-asignación -#define lsuachr 85 // Sub-asignación -#define lmuachr 86 // Mul-asignación -#define ldiachr 87 // Div-asignación -#define lmoachr 88 // Mod-asignación -#define lanachr 89 // And-asignación -#define lorachr 90 // Or-asignación -#define lxoachr 91 // Xor-asignación -#define lsrachr 92 // Shr-asignación -#define lslachr 93 // Shl-asignación -#define lcpachr 94 // Saca offset, lee parámetro [offset] y bp++ +/* Instrucciones añadidas para el manejo de cadenas */ +#define lstrcpy 95 /* Saca si, di, y hace strcpy(mem[di],[si]) (deja di en pila) */ +#define lstrfix 96 /* Amplia una cadena antes de meter un char en ella */ +#define lstrcat 97 /* Concatena dos cadenas (opera como strcpy) */ +#define lstradd 98 /* Suma dos strings "en el aire" y deja en pila el puntero al aire */ +#define lstrdec 99 /* Añade o quita caracteres a una cadena */ +#define lstrsub 100 /* Quita caracteres a una cadena (-=) */ +#define lstrlen 101 /* Sustituye una cadena por su longitud */ +#define lstrigu 102 /* Comparacion de igualdad de dos cadenas */ +#define lstrdis 103 /* Cadenas distintas */ +#define lstrmay 104 /* Cadena mayor */ +#define lstrmen 105 /* Cadena menor */ +#define lstrmei 106 /* Cadena mayor o igual */ +#define lstrmai 107 /* Cadena menor o igual */ +#define lcpastr 108 /* Carga un parámetro en una cadena */ -// Instrucciones añadidas para el manejo de cadenas +/* Instrucciones añadidas para el manejo de Words */ +#define lptrwor 109 /* Pointer, saca (index, offset) y mete [offset+byte index] */ +#define lasiwor 110 /* Saca (valor, index, offset) y mete el valor en [offset+byte index] */ +#define liptwor 111 /* Incremento y pointer */ +#define lptiwor 112 /* Pointer e incremento */ +#define ldptwor 113 /* Decremento y pointer */ +#define lptdwor 114 /* Pointer y decremento */ +#define ladawor 115 /* Add-asignación */ +#define lsuawor 116 /* Sub-asignación */ +#define lmuawor 117 /* Mul-asignación */ +#define ldiawor 118 /* Div-asignación */ +#define lmoawor 119 /* Mod-asignación */ +#define lanawor 120 /* And-asignación */ +#define lorawor 121 /* Or-asignación */ +#define lxoawor 122 /* Xor-asignación */ +#define lsrawor 123 /* Shr-asignación */ +#define lslawor 124 /* Shl-asignación */ +#define lcpawor 125 /* Saca offset, lee parámetro [offset] y bp++ */ -#define lstrcpy 95 // Saca si, di, y hace strcpy(mem[di],[si]) (deja di en pila) -#define lstrfix 96 // Amplia una cadena antes de meter un char en ella -#define lstrcat 97 // Concatena dos cadenas (opera como strcpy) -#define lstradd 98 // Suma dos strings "en el aire" y deja en pila el puntero al aire -#define lstrdec 99 // Añade o quita caracteres a una cadena -#define lstrsub 100 // Quita caracteres a una cadena (-=) -#define lstrlen 101 // Sustituye una cadena por su longitud -#define lstrigu 102 // Comparacion de igualdad de dos cadenas -#define lstrdis 103 // Cadenas distintas -#define lstrmay 104 // Cadena mayor -#define lstrmen 105 // Cadena menor -#define lstrmei 106 // Cadena mayor o igual -#define lstrmai 107 // Cadena menor o igual -#define lcpastr 108 // Carga un parámetro en una cadena +/* Miscelánea */ +#define lnul 126 /* Comprueba que un puntero no sea NULL */ -// Instrucciones añadidas para el manejo de Words - -#define lptrwor 109 // Pointer, saca (index, offset) y mete [offset+byte index] -#define lasiwor 110 // Saca (valor, index, offset) y mete el valor en [offset+byte index] -#define liptwor 111 // Incremento y pointer -#define lptiwor 112 // Pointer e incremento -#define ldptwor 113 // Decremento y pointer -#define lptdwor 114 // Pointer y decremento -#define ladawor 115 // Add-asignación -#define lsuawor 116 // Sub-asignación -#define lmuawor 117 // Mul-asignación -#define ldiawor 118 // Div-asignación -#define lmoawor 119 // Mod-asignación -#define lanawor 120 // And-asignación -#define lorawor 121 // Or-asignación -#define lxoawor 122 // Xor-asignación -#define lsrawor 123 // Shr-asignación -#define lslawor 124 // Shl-asignación -#define lcpawor 125 // Saca offset, lee parámetro [offset] y bp++ - -// Miscelánea - -#define lnul 126 // Comprueba que un puntero no sea NULL - -//----------------------------------------------------------------------------- struct { // Peephole, "mirilla" para el optimizador int dir; // Dirección @@ -237,29 +231,25 @@ struct { // Peephole, "mirilla" para el optimizador int op; // Opcode } code[16]; // En code[15] debe quedar siempre la última instrucción generada -//----------------------------------------------------------------------------- +/* Informacion para temporal de debug (posicion en mem y fuente de cada sentencia) */ +FILE * linf; /* En este temporal guardamos la info y luego lo agregamos al exe */ -// Informacion para temporal de debug (posicion en mem y fuente de cada sentencia) +int inicio,final; /* Direcciones inicial y final de mem[] de la sentencia */ +int linea1,columna1; /* Posicion en la que comienza la sentencia en el fuente */ +int linea2,columna2; /* Posicion en la que acaba la sentencia en el fuente */ -FILE * linf; // En este temporal guardamos la info y luego lo agregamos al exe - -int inicio,final; // Direcciones inicial y final de mem[] de la sentencia -int linea1,columna1; // Posicion en la que comienza la sentencia en el fuente -int linea2,columna2; // Posicion en la que acaba la sentencia en el fuente - -void inicio_sentencia(void); // Fija inicio, linea1, columna1 -void final_sentencia(void); // Fija final, linea2, columna2 -void grabar_sentencia(void); // Guarda las seis variables en el fichero +void inicio_sentencia(void); /* Fija inicio, linea1, columna1 */ +void final_sentencia(void); /* Fija final, linea2, columna2 */ +void grabar_sentencia(void); /* Guarda las seis variables en el fichero */ void escribe_lin(FILE* f); void escribe_dbg(FILE* f); -//----------------------------------------------------------------------------- -int salto_import; // offset donde guardaremos el offset del ljmp que salta - // a la rutina de carga de DLLs +int salto_import; /* offset donde guardaremos el offset del ljmp que salta + * a la rutina de carga de DLLs. + */ -//----------------------------------------------------------------------------- #define max_break 512 int tbreak[max_break]; @@ -274,10 +264,9 @@ int telseif[max_elseif]; int itelseif; -//----------------------------------------------------------------------------- -// PROTOTIPOS -//----------------------------------------------------------------------------- - +/* + * PROTOTIPOS + */ void prepara_compilacion(); void compila(); void test_buffer(int * * ,int * ,int); @@ -286,4 +275,4 @@ void sentencia(); void g1(int op); void g2(int op, int pa); -#endif // __COMPILER_H \ No newline at end of file +#endif /* __COMPILER_H */ \ No newline at end of file