Compare commits
10 commits
03fec6e101
...
d2577da4dd
Author | SHA256 | Date | |
---|---|---|---|
![]() |
d2577da4dd | ||
|
bef39999a6 | ||
|
3c592e1d1c | ||
|
71dd8b2a46 | ||
|
fcac8d32ae | ||
|
a892a5f5d8 | ||
|
335422f077 | ||
|
3b65888eb1 | ||
|
b5f45a61eb | ||
|
8922339050 |
|
@ -1,13 +1,13 @@
|
|||
edivc
|
||||
=====
|
||||
|
||||
eDivc was an attempt to make a DIV language compiler started in 2000 and publicly released in 2002. After many years and a very unstable 0.1 version, it was left on SourceForge mostly abandoned. The code was written while all of us were about between 14-17 y/o and it had parts of the DIV Games Studio original compiler written in C for MS-DOS using Watcom C/C++. The quality is poor.
|
||||
eDivc was an attempt to make a DIV language compiler started in 2000 and publicly released in 2002. After many years and an unstable 0.1 version, it was left on [SourceForge](https://sf.net/projects/edivc) mostly abandoned. The code was written while all of us were about between 14-17 y/o and it had parts of the DIV Games Studio original compiler written in C for MS-DOS using Watcom C/C++. The quality is poor.
|
||||
|
||||
I took the work we (the eDiv Team at that time) did and moved into GitHub just for historical and nostalgic tracking. The commit history from CVS has been keept. At sometimes I will send some changes for fun, maybe I release a working (at that time state) version which can run the included test programs but this is not a promise nor a thing I may do soon.
|
||||
I took the work we (the eDiv Team at that time) did and moved into GitHub just for historical and nostalgic tracking, keeping the CVS commit history. At sometimes I may send some changes for fun, maybe I release a working (at that time state) version which can run the included test programs, but this is not a promise nor a thing I may do soon.
|
||||
|
||||
I don't have plans to maintain this, so feel free to fork and send pull requests if you want your changes merged.
|
||||
|
||||
You must known this thing won't compile nowadays with current versions of GCC, LLVM or Visual C++. I have sent some changes to build it on OS X 10.9 Mavericks, but it fails at runtime and needs many fixes. The code is not commented and variables/functions are in spanish. You have been warned :-).
|
||||
You must know this thing won't compile nowadays with current versions of GCC, LLVM or Visual C++. I have sent some changes to build it on latest macOS builds, but it fails at runtime and needs many fixes. The code is not commented, and variables/functions are in Spanish. You have been warned :-).
|
||||
|
||||
textshot
|
||||
========
|
||||
|
@ -35,6 +35,3 @@ Lista de opciones:
|
|||
|
||||
macbookair:bin vroman$
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
|
|
@ -66,11 +66,11 @@ zoomSurfaceRGBA (SDL_Surface * src, SDL_Surface * dst, int smooth)
|
|||
}
|
||||
|
||||
/* Allocate memory for row increments */
|
||||
if ((sax = (int *) malloc ((dst->w + 1) * sizeof (Uint32))) == NULL)
|
||||
if ((sax = malloc ((dst->w + 1) * sizeof (Uint32))) == NULL)
|
||||
{
|
||||
return (-1);
|
||||
}
|
||||
if ((say = (int *) malloc ((dst->h + 1) * sizeof (Uint32))) == NULL)
|
||||
if ((say = malloc ((dst->h + 1) * sizeof (Uint32))) == NULL)
|
||||
{
|
||||
free (sax);
|
||||
return (-1);
|
||||
|
@ -213,11 +213,11 @@ zoomSurfaceY (SDL_Surface * src, SDL_Surface * dst)
|
|||
sy = (Uint32) (65536.0 * (float) src->h / (float) dst->h);
|
||||
|
||||
/* Allocate memory for row increments */
|
||||
if ((sax = (Uint32 *) malloc (dst->w * sizeof (Uint32))) == NULL)
|
||||
if ((sax = malloc (dst->w * sizeof (Uint32))) == NULL)
|
||||
{
|
||||
return (-1);
|
||||
}
|
||||
if ((say = (Uint32 *) malloc (dst->h * sizeof (Uint32))) == NULL)
|
||||
if ((say = malloc (dst->h * sizeof (Uint32))) == NULL)
|
||||
{
|
||||
if (sax != NULL)
|
||||
{
|
||||
|
@ -554,21 +554,24 @@ transformSurfaceY (SDL_Surface * src, SDL_Surface * dst, int cx, int cy,
|
|||
|
||||
*/
|
||||
|
||||
/*XPUT/* Sanity check */
|
||||
/* Determine if source surface is 32bit or 8bit */
|
||||
/* New source surface is 32bit with a defined RGBA ordering */
|
||||
/* Sanity check zoom factor */
|
||||
/* Check if we have a rotozoom or just a zoom */
|
||||
/* Angle!=0: full rotozoom *
|
||||
//* ----------------------- */
|
||||
/* Calculate target factors from sin/cos and zoom
|
||||
/*
|
||||
Sanity check
|
||||
Determine if source surface is 32bit or 8bit
|
||||
New source surface is 32bit with a defined RGBA ordering
|
||||
Sanity check zoom factor
|
||||
Check if we have a rotozoom or just a zoom
|
||||
Angle!=0: full rotozoom
|
||||
Calculate target factors from sin/cos and zoom
|
||||
*/
|
||||
|
||||
/*
|
||||
Determine destination width and height by rotating a centered source box
|
||||
Alloc space to completely contain the rotated surface
|
||||
Target surface is 32bit with source RGBA/ABGR ordering
|
||||
Lock source surface
|
||||
Check which kind of surface we have
|
||||
Call the 32bit transformation routine to do the rotation (using alpha)
|
||||
*/
|
||||
/* Determine destination width and height by rotating a centered source box */
|
||||
/* Alloc space to completely contain the rotated surface */
|
||||
/* Target surface is 32bit with source RGBA/ABGR ordering */
|
||||
/* Lock source surface */
|
||||
/* Check which kind of surface we have */
|
||||
/* Call the 32bit transformation routine to do the rotation (using alpha) */
|
||||
|
||||
#define VALUE_LIMIT 0.001
|
||||
|
||||
|
|
|
@ -136,7 +136,7 @@ int eDIV_LOAD_FPG(FUNCTION_PARAMS)
|
|||
fread(files[0].mapa[num].cpoint,2,2*infomapa.number_of_points,f) ;
|
||||
}
|
||||
|
||||
graphic = (char*)malloc(infomapa.wide*infomapa.height*bpp/8);
|
||||
graphic = malloc(infomapa.wide*infomapa.height*bpp/8);
|
||||
fread(graphic,1,infomapa.wide*infomapa.height*bpp/8,f);
|
||||
|
||||
files[0].mapa[num].Surface = SDL_CreateRGBSurfaceFrom(graphic,infomapa.wide,infomapa.height,bpp,infomapa.wide*bpp/8,0,0,0,0) ;
|
||||
|
|
|
@ -177,20 +177,26 @@ FILE * memo ;
|
|||
* nombre.
|
||||
* @param nombre_program Nombre del programa, obtenido de fp->nombre_program
|
||||
*/
|
||||
void guarda_pantallazo(char* nombre_program)
|
||||
void guarda_pantallazo(unsigned char *nombre_program)
|
||||
{
|
||||
char capturef[256];
|
||||
int c=0;
|
||||
FILE* f;
|
||||
|
||||
sprintf(capturef,"%s%04d.bmp",nombre_program,c);
|
||||
while(f=fopen(capturef,"rb")) {
|
||||
fclose(f);
|
||||
c++;
|
||||
sprintf(capturef,"%s%04d.bmp",nombre_program,c);
|
||||
if(c==0)
|
||||
while(1) {
|
||||
/* 256 son mas que suficientes */
|
||||
if (c >= 256)
|
||||
break;
|
||||
|
||||
sprintf(capturef,"%s%04d.bmp",nombre_program,c);
|
||||
f = fopen(capturef, "rb");
|
||||
|
||||
if (f == NULL)
|
||||
c++;
|
||||
|
||||
fclose(f);
|
||||
}
|
||||
|
||||
SDL_SaveBMP(screen,capturef);
|
||||
}
|
||||
|
||||
|
@ -344,25 +350,6 @@ void frame(FUNCTION_PARAMS)
|
|||
{
|
||||
if ( draws[i].existe )
|
||||
{
|
||||
|
||||
/* if ( draws[i].x + draws[i].Surface->w >= fp->regions[0].x && draws[i].x < fp->regions[0].x + fp->regions[0].w &&
|
||||
draws[i].y + draws[i].Surface->h >= fp->regions[0].y && draws[i].y < fp->regions[0].y + fp->regions[0].h )
|
||||
{
|
||||
if ( draws[i].x >= fp->regions[0].x && draws[i].x + draws[i].Surface->w < fp->regions[0].x + fp->regions[0].w &&
|
||||
draws[i].y >= fp->regions[0].y && draws[i].y + draws[i].Surface->h < fp->regions[0].y + fp->regions[0].h )
|
||||
{
|
||||
srcrect.x = 0 ;
|
||||
srcrect.y = 0 ;
|
||||
srcrect.w = draws[i].Surface->w ;
|
||||
srcrect.h = draws[i].Surface->h ;
|
||||
|
||||
dstrect.x = draws[i].x ;
|
||||
dstrect.y = draws[i].y ;
|
||||
dstrect.w = 0 ; /* Se ignora *//*
|
||||
dstrect.h = 0 ; /* Se ignora *//*
|
||||
Dibuja( draws[i].Surface , srcrect , dstrect , z , draws[i].t,100,0) ;
|
||||
}
|
||||
}*/
|
||||
Dibuja(draws[i].Surface,draws[i].x,draws[i].y,0,0,draws[i].region,z,0,draws[i].t,100,0);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -344,7 +344,7 @@ int DIV_strdel(FUNCTION_PARAMS)
|
|||
int DIV_itoa(FUNCTION_PARAMS)
|
||||
{
|
||||
int n=getparm();
|
||||
itoa(n,(char*)&fp->mem[fp->nullstring[*fp->nstring]],10);
|
||||
sprintf((char*)&fp->mem[fp->nullstring[*fp->nstring]], "%d", n);
|
||||
n=fp->nullstring[*fp->nstring];
|
||||
*fp->nstring=(((*fp->nstring)+1)&3);
|
||||
return n;
|
||||
|
|
0
ediv/bin/makelib.sh
Normal file → Executable file
0
ediv/bin/makelib.sh
Normal file → Executable file
File diff suppressed because it is too large
Load diff
|
@ -34,18 +34,16 @@ char* buffer;
|
|||
int linea;
|
||||
char cfg[256];
|
||||
|
||||
/*void cfg_error(int error)
|
||||
void salta_spc()
|
||||
{
|
||||
printf(translate(41),cfg,linea,translate_cfg_error(error));
|
||||
printf(translate(42));
|
||||
exit(1);
|
||||
}*/
|
||||
|
||||
void salta_spc() {
|
||||
while(lower[buffer[i]]==0 && i<tamano) {
|
||||
if(buffer[i]=='\n') linea++;
|
||||
else if(buffer[i]=='\'') {
|
||||
while(buffer[i]!='\n' && i<tamano) i++;
|
||||
while (lower[buffer[i]] == 0 && i < tamano)
|
||||
{
|
||||
if (buffer[i] == '\n')
|
||||
linea++;
|
||||
else if (buffer[i] == '\'')
|
||||
{
|
||||
while (buffer[i] != '\n' && i < tamano)
|
||||
i++;
|
||||
linea++;
|
||||
}
|
||||
i++;
|
||||
|
@ -71,30 +69,35 @@ void lee_ediv_cfg(char* ediv_cfg)
|
|||
hacer_strfix = 1;
|
||||
optimizar = 1;
|
||||
|
||||
if((f=fopen(ediv_cfg,"r"))==NULL) {
|
||||
if ((f = fopen(ediv_cfg, "r")) == NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
fseek(f, 0, SEEK_END);
|
||||
tamano = ftell(f);
|
||||
fseek(f, 0, SEEK_SET);
|
||||
buffer=(char*)e_malloc(tamano);
|
||||
buffer = e_malloc(tamano);
|
||||
|
||||
fread(buffer, 1, tamano, f);
|
||||
fclose(f);
|
||||
|
||||
for(i=0;i<tamano;i++) {
|
||||
for (i = 0; i < tamano; i++)
|
||||
{
|
||||
salta_spc();
|
||||
c = 0;
|
||||
while (lower[buffer[i]] != 0 && c < 20 && i < tamano)
|
||||
tag[c++] = lower[buffer[i++]];
|
||||
tag[c] = 0;
|
||||
|
||||
if(!strcmp(tag,"max_process")) {
|
||||
if (!strcmp(tag, "max_process"))
|
||||
{
|
||||
salta_spc();
|
||||
if(buffer[i]!='=') cfg_error(1); /* se esperaba '=' */
|
||||
if (buffer[i] != '=')
|
||||
cfg_error(1); /* se esperaba '=' */
|
||||
salta_spc();
|
||||
if(buffer[i]<'0' || buffer[i]>'9') cfg_error(2); /* se esperaba un dato numerico */
|
||||
if (buffer[i] < '0' || buffer[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++];
|
||||
|
@ -155,7 +158,6 @@ void lee_ediv_cfg(char* ediv_cfg)
|
|||
lexico();
|
||||
comprueba_null=0;
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
free(buffer);
|
||||
|
|
|
@ -125,7 +125,7 @@ static int AddDLLReference(void *pImageBase, char *svName, DWORD dwFlags)
|
|||
}
|
||||
|
||||
// Add new dll to list
|
||||
cur=(IMAGE_PARAMETERS *)e_malloc(sizeof(IMAGE_PARAMETERS));
|
||||
cur = e_malloc(sizeof(IMAGE_PARAMETERS));
|
||||
if(cur==NULL) {
|
||||
LeaveCriticalSection(&g_DLLCrit);
|
||||
return -1;
|
||||
|
|
|
@ -75,12 +75,14 @@ int main(int argc, char *argv[])
|
|||
noexe = 0;
|
||||
|
||||
/* Sistemas */
|
||||
#ifdef _WIN32
|
||||
#if defined(_WIN32)
|
||||
strcpy(sistema, "win32");
|
||||
#endif
|
||||
|
||||
#ifdef __linux__
|
||||
#elif defined(__linux__)
|
||||
strcpy(sistema, "linux");
|
||||
#elif defined(__APPLE__)
|
||||
strcpy(sistema, "osx");
|
||||
#else
|
||||
strcpy(sistema, "unknown");
|
||||
#endif
|
||||
|
||||
ini = iniparser_load("ediv.cfg");
|
||||
|
@ -88,35 +90,40 @@ int main(int argc, char *argv[])
|
|||
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],"--help")==0 || strcmp(argv[1],"-h")==0) {
|
||||
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));
|
||||
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<argc;i++) {
|
||||
if(argv[i][0]=='-') {
|
||||
if(argv[i][1]=='-') {
|
||||
for (i = 1; i < argc; i++)
|
||||
{
|
||||
if (argv[i][0] == '-')
|
||||
{
|
||||
if (argv[i][1] == '-')
|
||||
{
|
||||
if (strcmp(argv[i] + 2, "debug") == 0)
|
||||
debug = 1;
|
||||
else if (strcmp(argv[i] + 2, "list") == 0)
|
||||
|
@ -126,26 +133,34 @@ int main(int argc, char *argv[])
|
|||
else if (strcmp(argv[i] + 2, "check") == 0)
|
||||
noexe = 1;
|
||||
else if (strcmp(argv[i] + 2, "system") == 0)
|
||||
if(++i<argc) {
|
||||
if (++i < argc)
|
||||
{
|
||||
strcpy(sistema, argv[i]);
|
||||
} else {
|
||||
printf(translate(12)); /* se debe indicar un sistema para --system */
|
||||
}
|
||||
else
|
||||
{
|
||||
print_translate(12); /* se debe indicar un sistema para --system */
|
||||
exit(1);
|
||||
}
|
||||
#ifdef _WIN32
|
||||
else if(strcmp(argv[i]+2,"news")==0) {
|
||||
else if (strcmp(argv[i] + 2, "news") == 0)
|
||||
{
|
||||
muestra_motd();
|
||||
}
|
||||
#endif
|
||||
else {
|
||||
printf(translate(13),argv[i]); /* parámetro erróneo */
|
||||
else
|
||||
{
|
||||
print_translate(13, argv[i]); /* parámetro erróneo */
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
else {
|
||||
else
|
||||
{
|
||||
j = 1;
|
||||
while(argv[i][j]!=0) {
|
||||
switch(argv[i][j]) {
|
||||
while (argv[i][j] != 0)
|
||||
{
|
||||
switch (argv[i][j])
|
||||
{
|
||||
case 'd':
|
||||
debug = 1;
|
||||
break;
|
||||
|
@ -159,17 +174,21 @@ int main(int argc, char *argv[])
|
|||
noexe = 1;
|
||||
break;
|
||||
case 's':
|
||||
if(argv[i][j+1]!=0) {
|
||||
if (argv[i][j + 1] != 0)
|
||||
{
|
||||
strcpy(sistema, argv[i] + j + 1);
|
||||
j = strlen(argv[i]) - 1;
|
||||
}
|
||||
else {
|
||||
if(++i<argc) {
|
||||
else
|
||||
{
|
||||
if (++i < argc)
|
||||
{
|
||||
strcpy(sistema, argv[i]);
|
||||
j = strlen(argv[i]) - 1;
|
||||
}
|
||||
else {
|
||||
printf(translate(14)); /* se debe indicar un sistema para -s */
|
||||
else
|
||||
{
|
||||
print_translate(14); /* se debe indicar un sistema para -s */
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
@ -180,14 +199,16 @@ int main(int argc, char *argv[])
|
|||
exit(0);
|
||||
#endif
|
||||
default:
|
||||
printf(translate(15),argv[i][j]); /* parámetro erróneo */
|
||||
print_translate(15, argv[i][j]); /* parámetro erróneo */
|
||||
exit(1);
|
||||
}
|
||||
j++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else switch (hayprog) {
|
||||
else
|
||||
switch (hayprog)
|
||||
{
|
||||
case 0:
|
||||
fichero_prg = argv[i];
|
||||
hayprog = 1;
|
||||
|
@ -197,84 +218,97 @@ int main(int argc, char *argv[])
|
|||
hayprog = 2;
|
||||
break;
|
||||
default:
|
||||
printf(translate(13),argv[i]); /* parámetro erróneo */
|
||||
print_translate(13, argv[i]); /* parámetro erróneo */
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
if(hayprog==0) {
|
||||
printf(translate(16)); /* no se ha especificado un archivo */
|
||||
if (hayprog == 0)
|
||||
{
|
||||
print_translate(16); /* no se ha especificado un archivo */
|
||||
exit(1);
|
||||
}
|
||||
|
||||
for (i=0;i<=strlen(fichero_prg);i++) {
|
||||
for (i = 0; i <= strlen(fichero_prg); i++)
|
||||
{
|
||||
if (*(fichero_prg + i) == '.')
|
||||
break;
|
||||
nombreprog[i] = *(fichero_prg + i);
|
||||
}
|
||||
nombreprog[i] = 0;
|
||||
|
||||
if(!(fp = fopen(fichero_prg, "rb"))) {
|
||||
if(!strcmp(nombreprog,fichero_prg)) {
|
||||
if (!(fp = fopen(fichero_prg, "rb")))
|
||||
{
|
||||
if (!strcmp(nombreprog, fichero_prg))
|
||||
{
|
||||
strcpy(fichero_prg, nombreprog);
|
||||
strcat(fichero_prg, ".prg");
|
||||
if(!(fp = fopen(fichero_prg, "rb"))) {
|
||||
if (!(fp = fopen(fichero_prg, "rb")))
|
||||
{
|
||||
strcpy(fichero_prg, nombreprog);
|
||||
strcat(fichero_prg, ".PRG");
|
||||
if(!(fp = fopen(fichero_prg, "rb"))) {
|
||||
printf(translate(17),nombreprog); /* error al abrir archivo */
|
||||
if (!(fp = fopen(fichero_prg, "rb")))
|
||||
{
|
||||
print_translate(17, nombreprog); /* error al abrir archivo */
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
printf(translate(17),argv[1]); /* error al abrir archivo */
|
||||
else
|
||||
{
|
||||
print_translate(17, argv[1]); /* error al abrir archivo */
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
/* Componemos el nombre del ejecutable */
|
||||
if(hayprog<2) {
|
||||
if (hayprog < 2)
|
||||
{
|
||||
strcpy(outfilename, nombreprog);
|
||||
if (!strcmp(sistema, "win32"))
|
||||
strcat(outfilename, ".exe");
|
||||
}
|
||||
|
||||
printf(translate(18),fichero_prg); /* compilando... */
|
||||
|
||||
print_translate(18, fichero_prg); /* compilando... */
|
||||
|
||||
/* mete el PRG en el buffer prog */
|
||||
fseek(fp, 0, SEEK_END);
|
||||
progsize = ftell(fp);
|
||||
prog = (unsigned char *)e_malloc(progsize+1);
|
||||
prog = e_malloc(progsize + 1);
|
||||
fseek(fp, 0, SEEK_SET);
|
||||
p = (char *)prog;
|
||||
do {
|
||||
do
|
||||
{
|
||||
*p = getc(fp);
|
||||
p++;
|
||||
} while (!feof(fp));
|
||||
fclose(fp);
|
||||
|
||||
/* Comprueba si existe la edivrun.lib */
|
||||
if(!noexe) {
|
||||
if (!noexe)
|
||||
{
|
||||
strcpy(edivrun_lib, sistema);
|
||||
if (debug)
|
||||
strcat(edivrun_lib, ".dbg");
|
||||
else
|
||||
strcat(edivrun_lib, ".rel");
|
||||
|
||||
if((fp = fopen(edivrun_lib, "rb"))==NULL) {
|
||||
printf(translate(19),edivrun_lib); /* no se encuentra el fichero */
|
||||
if ((fp = fopen(edivrun_lib, "rb")) == NULL)
|
||||
{
|
||||
print_translate(19, edivrun_lib); /* no se encuentra el fichero */
|
||||
exit(1);
|
||||
}
|
||||
else {
|
||||
else
|
||||
{
|
||||
fread(libmagic, 1, 14, fp);
|
||||
if(strcmp(libmagic,magic)) {
|
||||
printf(translate(20),edivrun_lib); /* formato incorrecto de edivrun.lib */
|
||||
if (strcmp(libmagic, magic))
|
||||
{
|
||||
print_translate(20, edivrun_lib); /* formato incorrecto de edivrun.lib */
|
||||
fclose(fp);
|
||||
exit(1);
|
||||
}
|
||||
else {
|
||||
else
|
||||
{
|
||||
fread(&stub_size, 1, 4, fp);
|
||||
fclose(fp);
|
||||
#ifdef _DEBUG
|
||||
|
@ -284,7 +318,8 @@ int main(int argc, char *argv[])
|
|||
}
|
||||
}
|
||||
|
||||
if(!ini) {
|
||||
if (!ini)
|
||||
{
|
||||
/* Valores de las opciones por defecto */
|
||||
max_process = 0;
|
||||
ignore_errors = 0;
|
||||
|
@ -297,7 +332,9 @@ int main(int argc, char *argv[])
|
|||
hacer_strfix = 1;
|
||||
optimizar = 1;
|
||||
case_sensitive = 0;
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
max_process = iniparser_getint(ini, "default_compiler_options:max_process", 0);
|
||||
ignore_errors = iniparser_getboolean(ini, "default_compiler_options:ignore_errors", 0);
|
||||
free_sintax = iniparser_getboolean(ini, "default_compiler_options:free_sintax", 0);
|
||||
|
@ -312,7 +349,6 @@ int main(int argc, char *argv[])
|
|||
case_sensitive = iniparser_getboolean(ini, "default_compiler_options:case_sensitive", 0);
|
||||
if (iniparser_getboolean(ini, "default_compiler_options:no_check", 0))
|
||||
comprueba_rango = comprueba_id = comprueba_null = 0;
|
||||
|
||||
}
|
||||
|
||||
prepara_compilacion();
|
||||
|
@ -324,21 +360,20 @@ int main(int argc, char *argv[])
|
|||
printf("edivc: Finalizado - %d advertencias, %d errores\n", n_warnings, n_errors);
|
||||
#else
|
||||
if (n_errors)
|
||||
printf(translate(21),n_warnings);
|
||||
print_translate(21, n_warnings);
|
||||
else
|
||||
printf(translate(22),n_warnings);
|
||||
print_translate(22, n_warnings);
|
||||
#endif
|
||||
|
||||
if (n_errors == 0)
|
||||
return 0;
|
||||
else {
|
||||
printf(translate(23));
|
||||
else
|
||||
{
|
||||
print_translate(23);
|
||||
return 2;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* void *e_malloc(size_t size)
|
||||
* Idéntico a malloc, pero con errormsg automático
|
||||
|
@ -350,8 +385,9 @@ void* e_malloc(size_t size)
|
|||
{
|
||||
void *ret;
|
||||
|
||||
if(!(ret = malloc(size))) {
|
||||
printf(translate(24)); /* memoria insuficiente */
|
||||
if (!(ret = malloc(size)))
|
||||
{
|
||||
print_translate(24); /* memoria insuficiente */
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
@ -360,7 +396,8 @@ void* e_malloc(size_t size)
|
|||
|
||||
void e_free(void *puntero)
|
||||
{
|
||||
if (puntero) {
|
||||
if (puntero)
|
||||
{
|
||||
free(puntero);
|
||||
puntero = NULL;
|
||||
}
|
||||
|
@ -368,24 +405,38 @@ void e_free(void *puntero)
|
|||
|
||||
void errormem()
|
||||
{
|
||||
printf(translate(24));
|
||||
print_translate(24);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Gestión de errores
|
||||
*/
|
||||
int _le, _t;
|
||||
byte *_ie;
|
||||
|
||||
void save_error(word tipo) { /* Guarda una posicion de error (de 0 .. 3) */
|
||||
switch(tipo) {
|
||||
case 0: _le=linea; _ie=ierror; break;
|
||||
case 1: _le=old_linea; _ie=old_ierror_end; break;
|
||||
case 2: _le=old_linea; _ie=old_ierror; break;
|
||||
case 3: _le=old_linea; _ie=old_ierror_end; break;
|
||||
} _t=tipo;
|
||||
void save_error(word tipo)
|
||||
{ /* Guarda una posicion de error (de 0 .. 3) */
|
||||
switch (tipo)
|
||||
{
|
||||
case 0:
|
||||
_le = linea;
|
||||
_ie = ierror;
|
||||
break;
|
||||
case 1:
|
||||
_le = old_linea;
|
||||
_ie = old_ierror_end;
|
||||
break;
|
||||
case 2:
|
||||
_le = old_linea;
|
||||
_ie = old_ierror;
|
||||
break;
|
||||
case 3:
|
||||
_le = old_linea;
|
||||
_ie = old_ierror_end;
|
||||
break;
|
||||
}
|
||||
_t = tipo;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -402,28 +453,54 @@ void error(word tipo, word num, ...)
|
|||
byte *_p, *p;
|
||||
va_list opparam;
|
||||
|
||||
switch(tipo) {
|
||||
case 0: linea_error=linea; p=ierror; break;
|
||||
case 1: linea_error=old_linea; _p=p=old_ierror_end; break;
|
||||
case 2: linea_error=old_linea; p=old_ierror; break;
|
||||
case 3: linea_error=old_linea; _p=p=old_ierror_end; break;
|
||||
case 4: linea_error=_le; _p=p=_ie; tipo=_t; break;
|
||||
switch (tipo)
|
||||
{
|
||||
case 0:
|
||||
linea_error = linea;
|
||||
p = ierror;
|
||||
break;
|
||||
case 1:
|
||||
linea_error = old_linea;
|
||||
_p = p = old_ierror_end;
|
||||
break;
|
||||
case 2:
|
||||
linea_error = old_linea;
|
||||
p = old_ierror;
|
||||
break;
|
||||
case 3:
|
||||
linea_error = old_linea;
|
||||
_p = p = old_ierror_end;
|
||||
break;
|
||||
case 4:
|
||||
linea_error = _le;
|
||||
_p = p = _ie;
|
||||
tipo = _t;
|
||||
break;
|
||||
}
|
||||
|
||||
if (num!=2 && num!=6) {
|
||||
while (--p>=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 (p<prog) columna++;
|
||||
if (p < prog)
|
||||
columna++;
|
||||
}
|
||||
|
||||
if (tipo==1) {
|
||||
if (*(_p+1)==' ' || *(_p+1)==cr || *(_p+1)==lf) columna++; columna++;
|
||||
} else if (tipo==3) columna++;
|
||||
if (tipo == 1)
|
||||
{
|
||||
if (*(_p + 1) == ' ' || *(_p + 1) == cr || *(_p + 1) == lf)
|
||||
columna++;
|
||||
columna++;
|
||||
}
|
||||
else if (tipo == 3)
|
||||
columna++;
|
||||
|
||||
va_start(opparam, num);
|
||||
printf(translate(25), fichero_prg, linea_error, columna, num);
|
||||
print_translate(25, fichero_prg, linea_error, columna, num);
|
||||
vprintf(translate_error(num), opparam);
|
||||
printf("\n");
|
||||
|
||||
|
@ -433,12 +510,13 @@ void error(word tipo, word num, ...)
|
|||
if (n_errors > 20)
|
||||
printf("Demasiados errores. Compilación interrumpida.\n");
|
||||
|
||||
if(num==1 || num==2 || num==6 || n_errors>20) {
|
||||
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);
|
||||
print_translate(21, n_warnings);
|
||||
#endif
|
||||
printf(translate(23));
|
||||
print_translate(23);
|
||||
exit(2);
|
||||
#ifdef MULTI_ERROR
|
||||
}
|
||||
|
@ -450,7 +528,7 @@ void warning(int num, ...)
|
|||
va_list opparam;
|
||||
|
||||
va_start(opparam, num);
|
||||
printf(translate(26), fichero_prg, linea);
|
||||
print_translate(26, fichero_prg, linea);
|
||||
vprintf(translate_warning(num), opparam);
|
||||
printf("\n");
|
||||
n_warnings++;
|
||||
|
@ -465,18 +543,23 @@ void muestra_motd()
|
|||
char *motdserver = NULL;
|
||||
char *motdpath = NULL;
|
||||
|
||||
if(ini) {
|
||||
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 (!motdserver)
|
||||
{
|
||||
print_translate(49); /* el servidor de motd debe estar en ediv.cfg */
|
||||
exit(1);
|
||||
}
|
||||
if(!motdpath) motdpath="/ediv/actual/motd.txt";
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
@ -497,14 +580,16 @@ void conecta(char *servidor, char *archivo)
|
|||
else
|
||||
htent = gethostbyaddr((const char *)&iahost, sizeof(struct in_addr), AF_INET);
|
||||
|
||||
if (htent==NULL) {
|
||||
if (htent == NULL)
|
||||
{
|
||||
sock_error("gethostbyname()");
|
||||
return;
|
||||
}
|
||||
|
||||
sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
||||
|
||||
if (sock==INVALID_SOCKET) {
|
||||
if (sock == INVALID_SOCKET)
|
||||
{
|
||||
sock_error("socket()");
|
||||
return;
|
||||
}
|
||||
|
@ -519,7 +604,8 @@ void conecta(char *servidor, char *archivo)
|
|||
sin.sin_addr = *(struct in_addr *)*htent->h_addr_list;
|
||||
|
||||
status = connect(sock, (struct sockaddr *)&sin, sizeof(sin));
|
||||
if (status==SOCKET_ERROR) {
|
||||
if (status == SOCKET_ERROR)
|
||||
{
|
||||
sock_error("connect()");
|
||||
closesocket(sock);
|
||||
return;
|
||||
|
@ -531,8 +617,8 @@ void conecta(char *servidor, char *archivo)
|
|||
"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);
|
||||
"\n",
|
||||
archivo, servidor);
|
||||
|
||||
#ifdef DEBUG_HTTP
|
||||
printf("GET %s HTTP/1.1\n"
|
||||
|
@ -541,59 +627,68 @@ void conecta(char *servidor, char *archivo)
|
|||
"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);
|
||||
"\n",
|
||||
archivo, servidor);
|
||||
#endif
|
||||
|
||||
status = send(sock, buffer, strlen(buffer), 0);
|
||||
if (status==SOCKET_ERROR) {
|
||||
if (status == SOCKET_ERROR)
|
||||
{
|
||||
sock_error("send()");
|
||||
closesocket(sock);
|
||||
return;
|
||||
}
|
||||
|
||||
status = recv(sock, buffer, sizeof(buffer), 0);
|
||||
if (status == SOCKET_ERROR) {
|
||||
if (status == SOCKET_ERROR)
|
||||
{
|
||||
sock_error("recv()");
|
||||
}
|
||||
|
||||
closesocket(sock);
|
||||
|
||||
if(*(buffer+9)!='2' || *(buffer+10)!='0' || *(buffer+10)!='0') {
|
||||
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));
|
||||
if (!size)
|
||||
{
|
||||
print_translate(50);
|
||||
exit(1);
|
||||
}
|
||||
size += 14;
|
||||
*(ras = strchr(size, 0x0d)) = 0;
|
||||
if(strcmp(size,"text/plain")) {
|
||||
printf(translate(50));
|
||||
if (strcmp(size, "text/plain"))
|
||||
{
|
||||
print_translate(50);
|
||||
exit(1);
|
||||
}
|
||||
*ras = 0x0d;
|
||||
|
||||
size = strstr(buffer, "Content-Length: ");
|
||||
if(!size) {
|
||||
printf(translate(50));
|
||||
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--) {
|
||||
tam = 0;
|
||||
inc = 1;
|
||||
for (; ras >= size; ras--)
|
||||
{
|
||||
if (*ras >= '0' && *ras <= '9')
|
||||
tam += (*ras - '0') * inc;
|
||||
else
|
||||
break;
|
||||
inc *= 10;
|
||||
}
|
||||
if(tam>1024) tam=1024;
|
||||
if (tam > 1024)
|
||||
tam = 1024;
|
||||
|
||||
fwrite(content, tam, 1, stdout);
|
||||
}
|
||||
|
|
|
@ -41,29 +41,28 @@ 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 */
|
||||
|
||||
|
||||
/* 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);
|
||||
print_translate(35, fichdll);
|
||||
vprintf(translate_dll_error(error - 1), opparam);
|
||||
printf("\n");
|
||||
n_errors++;
|
||||
}
|
||||
|
||||
|
||||
|
||||
int EDIV_Export(char *cadena, int nparam, void *hfuncion)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if(nparam<0) {
|
||||
if (nparam < 0)
|
||||
{
|
||||
dll_error(5, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -74,17 +73,20 @@ int EDIV_Export(char* cadena, int nparam, void* hfuncion)
|
|||
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);
|
||||
"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;
|
||||
}
|
||||
|
||||
ob = o;
|
||||
|
||||
if (ob->tipo!=tnone) {
|
||||
if (ob->tipo != tnone)
|
||||
{
|
||||
dll_error(5, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -98,7 +100,6 @@ int EDIV_Export(char* cadena, int nparam, void* hfuncion)
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Entrypoint(int ep, void *hfuncion)
|
||||
{
|
||||
entrypoints[n_entrypoints].tipo = ep;
|
||||
|
@ -107,17 +108,16 @@ int EDIV_Export_Entrypoint(int ep, void* hfuncion)
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Priority(int priority)
|
||||
{
|
||||
dlls[numdlls].prioridad = priority;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Const(char *cadena, int valor)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -128,17 +128,20 @@ int EDIV_Export_Const(char* cadena, int valor)
|
|||
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);
|
||||
"export_const:\tOffset del objeto: 0x%X\n",
|
||||
num_obj - 1, cadena, valor, (unsigned int)o);
|
||||
#endif
|
||||
|
||||
if(creaobj) {
|
||||
if (creaobj)
|
||||
{
|
||||
dll_error(creaobj, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ob = o;
|
||||
|
||||
if (ob->tipo!=tnone) {
|
||||
if (ob->tipo != tnone)
|
||||
{
|
||||
dll_error(5, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -150,10 +153,10 @@ int EDIV_Export_Const(char* cadena, int valor)
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Global(char *cadena, int valor)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -164,17 +167,20 @@ int EDIV_Export_Global(char* cadena, int valor)
|
|||
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);
|
||||
"export_global:\tOffset del objeto: 0x%X\n",
|
||||
num_obj - 1, cadena, valor, (unsigned int)o);
|
||||
#endif
|
||||
|
||||
if(creaobj) {
|
||||
if (creaobj)
|
||||
{
|
||||
dll_error(creaobj, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ob = o;
|
||||
|
||||
if (ob->tipo!=tnone) {
|
||||
if (ob->tipo != tnone)
|
||||
{
|
||||
dll_error(5, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -188,10 +194,10 @@ int EDIV_Export_Global(char* cadena, int valor)
|
|||
return imem++;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Global_Tab(char *cadena, int numregs)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -202,17 +208,20 @@ int EDIV_Export_Global_Tab(char* cadena, int numregs)
|
|||
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);
|
||||
"export_global_tab:\tOffset del objeto: 0x%X\n",
|
||||
num_obj - 1, cadena, numregs, (unsigned int)o);
|
||||
#endif
|
||||
|
||||
if(creaobj) {
|
||||
if (creaobj)
|
||||
{
|
||||
dll_error(creaobj, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ob = o;
|
||||
|
||||
if (ob->tipo!=tnone) {
|
||||
if (ob->tipo != tnone)
|
||||
{
|
||||
dll_error(5, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -227,17 +236,18 @@ int EDIV_Export_Global_Tab(char* cadena, int numregs)
|
|||
ob->tglo.totalen = len + 1;
|
||||
|
||||
/* Inicializamos la tabla a 0 */
|
||||
do {
|
||||
do
|
||||
{
|
||||
mem[imem++] = 0;
|
||||
} while (len--);
|
||||
|
||||
return ob->tglo.offset;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Global_Struct(char *cadena, int numregs)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -248,17 +258,20 @@ int EDIV_Export_Global_Struct(char* cadena, int numregs)
|
|||
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);
|
||||
"export_global_struct:\tOffset del objeto: 0x%X\n",
|
||||
num_obj - 1, cadena, numregs, (unsigned int)o);
|
||||
#endif
|
||||
|
||||
if(creaobj) {
|
||||
if (creaobj)
|
||||
{
|
||||
dll_error(creaobj, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ob = o;
|
||||
|
||||
if (ob->tipo!=tnone) {
|
||||
if (ob->tipo != tnone)
|
||||
{
|
||||
dll_error(5, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -279,10 +292,10 @@ int EDIV_Export_Global_Struct(char* cadena, int numregs)
|
|||
return imem;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Member_Int(char *cadena, int valor)
|
||||
{
|
||||
if(!decl_struct) {
|
||||
if (!decl_struct)
|
||||
{
|
||||
dll_error(7, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -293,29 +306,34 @@ int EDIV_Export_Member_Int(char* cadena, int valor)
|
|||
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);
|
||||
"export_member_int:\tOffset del objeto: 0x%X\n",
|
||||
num_obj - 1, cadena, valor, (unsigned int)o);
|
||||
#endif
|
||||
|
||||
if(creaobj) {
|
||||
if (creaobj)
|
||||
{
|
||||
dll_error(creaobj, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ob2 = o;
|
||||
|
||||
if ((*ob2).tipo!=tnone) {
|
||||
if ((*ob2).tipo != tnone)
|
||||
{
|
||||
dll_error(5, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if(ob->tipo==tsglo) { /* int miembro de struct global */
|
||||
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 */
|
||||
else
|
||||
{ /* int miembro de struct local */
|
||||
if (struct_reserved)
|
||||
indexa_variable(v_reserved, cadena, iloc);
|
||||
(*ob2).tipo = tvloc;
|
||||
|
@ -326,10 +344,10 @@ int EDIV_Export_Member_Int(char* cadena, int valor)
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Member_Str(char *cadena, int tamano)
|
||||
{
|
||||
if(!decl_struct) {
|
||||
if (!decl_struct)
|
||||
{
|
||||
dll_error(7, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -340,31 +358,37 @@ int EDIV_Export_Member_Str(char* cadena, int tamano)
|
|||
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);
|
||||
"export_member_str:\tOffset del objeto: 0x%X\n",
|
||||
num_obj - 1, cadena, tamano, (unsigned int)o);
|
||||
#endif
|
||||
|
||||
if(creaobj) {
|
||||
if (creaobj)
|
||||
{
|
||||
dll_error(creaobj, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ob2 = o;
|
||||
|
||||
if ((*ob2).tipo!=tnone) {
|
||||
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;
|
||||
|
||||
if (((*ob2).cglo.totalen=tamano)<0) {
|
||||
if (((*ob2).cglo.totalen = tamano) < 0)
|
||||
{
|
||||
dll_error(8, cadena);
|
||||
return 0;
|
||||
}
|
||||
if ((*ob2).cglo.totalen>0xFFFFF) {
|
||||
if ((*ob2).cglo.totalen > 0xFFFFF)
|
||||
{
|
||||
dll_error(8, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -377,16 +401,19 @@ int EDIV_Export_Member_Str(char* cadena, int tamano)
|
|||
|
||||
return (*ob2).cglo.offset;
|
||||
}
|
||||
else { /* string miembro de struct local */
|
||||
else
|
||||
{ /* string miembro de struct local */
|
||||
|
||||
(*ob2).tipo = tcloc;
|
||||
(*ob2).cloc.offset = len + 1;
|
||||
|
||||
if (((*ob2).cloc.totalen=tamano)<0) {
|
||||
if (((*ob2).cloc.totalen = tamano) < 0)
|
||||
{
|
||||
dll_error(8, cadena);
|
||||
return 0;
|
||||
}
|
||||
if ((*ob2).cloc.totalen>0xFFFFF) {
|
||||
if ((*ob2).cloc.totalen > 0xFFFFF)
|
||||
{
|
||||
dll_error(8, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -401,10 +428,10 @@ int EDIV_Export_Member_Str(char* cadena, int tamano)
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Member_Tab(char *cadena, int numregs)
|
||||
{
|
||||
if(!decl_struct) {
|
||||
if (!decl_struct)
|
||||
{
|
||||
dll_error(7, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -415,22 +442,26 @@ int EDIV_Export_Member_Tab(char* cadena, int numregs)
|
|||
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);
|
||||
"export_member_tab:\tOffset del objeto: 0x%X\n",
|
||||
num_obj - 1, cadena, numregs, (unsigned int)o);
|
||||
#endif
|
||||
|
||||
if(creaobj) {
|
||||
if (creaobj)
|
||||
{
|
||||
dll_error(creaobj, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ob2 = o;
|
||||
|
||||
if ((*ob2).tipo!=tnone) {
|
||||
if ((*ob2).tipo != tnone)
|
||||
{
|
||||
dll_error(5, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if(ob->tipo==tsglo) { /* array miembro de struct global */
|
||||
if (ob->tipo == tsglo)
|
||||
{ /* array miembro de struct global */
|
||||
(*ob2).tipo = ttglo;
|
||||
(*ob2).tglo.offset = len;
|
||||
(*ob2).tglo.len1 = numregs;
|
||||
|
@ -444,7 +475,8 @@ int EDIV_Export_Member_Tab(char* cadena, int numregs)
|
|||
|
||||
return (*ob2).tglo.offset;
|
||||
}
|
||||
else { /* array miembro de struct local */
|
||||
else
|
||||
{ /* array miembro de struct local */
|
||||
if (struct_reserved)
|
||||
indexa_variable(v_reserved, cadena, iloc);
|
||||
(*ob2).tipo = ttloc;
|
||||
|
@ -462,10 +494,10 @@ int EDIV_Export_Member_Tab(char* cadena, int numregs)
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_EndStruct()
|
||||
{
|
||||
if(!decl_struct) {
|
||||
if (!decl_struct)
|
||||
{
|
||||
dll_error(9);
|
||||
return 0;
|
||||
}
|
||||
|
@ -476,27 +508,35 @@ int EDIV_Export_EndStruct()
|
|||
|
||||
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) {
|
||||
if (ob->sglo.totalitems > 1)
|
||||
{
|
||||
len = (ob->sglo.totalitems - 1) * ob->sglo.len_item - 1;
|
||||
do {
|
||||
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) {
|
||||
if (ob->sloc.totalitems > 1)
|
||||
{
|
||||
len = (ob->sloc.totalitems - 1) * ob->sloc.len_item - 1;
|
||||
do {
|
||||
do
|
||||
{
|
||||
loc[iloc] = loc[iloc - ob->sloc.len_item];
|
||||
iloc++;
|
||||
} while (len--);
|
||||
|
@ -509,10 +549,10 @@ int EDIV_Export_EndStruct()
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Local(char *cadena, int valor)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -523,17 +563,20 @@ int EDIV_Export_Local(char* cadena, int valor)
|
|||
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);
|
||||
"export_local:\tOffset del objeto: 0x%X\n",
|
||||
num_obj - 1, cadena, valor, (unsigned int)o);
|
||||
#endif
|
||||
|
||||
if(creaobj) {
|
||||
if (creaobj)
|
||||
{
|
||||
dll_error(creaobj, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ob = o;
|
||||
|
||||
if (ob->tipo!=tnone) {
|
||||
if (ob->tipo != tnone)
|
||||
{
|
||||
dll_error(5, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -547,10 +590,10 @@ int EDIV_Export_Local(char* cadena, int valor)
|
|||
return iloc++;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Local_Tab(char *cadena, int numregs)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -561,17 +604,20 @@ int EDIV_Export_Local_Tab(char* cadena, int numregs)
|
|||
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);
|
||||
"export_local_tab:\tOffset del objeto: 0x%X\n",
|
||||
num_obj - 1, cadena, numregs, (unsigned int)o);
|
||||
#endif
|
||||
|
||||
if(creaobj) {
|
||||
if (creaobj)
|
||||
{
|
||||
dll_error(creaobj, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ob = o;
|
||||
|
||||
if (ob->tipo!=tnone) {
|
||||
if (ob->tipo != tnone)
|
||||
{
|
||||
dll_error(5, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -586,17 +632,18 @@ int EDIV_Export_Local_Tab(char* cadena, int numregs)
|
|||
ob->tloc.totalen = len + 1;
|
||||
|
||||
/* Inicializamos la tabla a 0 */
|
||||
do {
|
||||
do
|
||||
{
|
||||
loc[iloc++] = 0;
|
||||
} while (len--);
|
||||
|
||||
return ob->tloc.offset;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Local_Struct(char *cadena, int numregs)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -607,26 +654,31 @@ int EDIV_Export_Local_Struct(char* cadena, int numregs)
|
|||
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);
|
||||
"export_local_struct:\tOffset del objeto: 0x%X\n",
|
||||
num_obj - 1, cadena, numregs, (unsigned int)o);
|
||||
#endif
|
||||
|
||||
if(creaobj) {
|
||||
if (creaobj)
|
||||
{
|
||||
dll_error(creaobj, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ob = o;
|
||||
|
||||
if (ob->tipo!=tnone) {
|
||||
if (ob->tipo != tnone)
|
||||
{
|
||||
dll_error(5, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
||||
decl_struct = 1;
|
||||
if(!strcmp(cadena,"reserved")) {
|
||||
if (!strcmp(cadena, "reserved"))
|
||||
{
|
||||
struct_reserved = 1;
|
||||
}
|
||||
else {
|
||||
else
|
||||
{
|
||||
indexa_variable(v_local, cadena, iloc);
|
||||
}
|
||||
|
||||
|
|
|
@ -110,7 +110,7 @@ void _encriptar(int encode, char * fichero, char * clave)
|
|||
fseek(f,0,SEEK_END);
|
||||
size=ftell(f);
|
||||
|
||||
if ((ptr=(byte *)malloc(size))!=NULL) {
|
||||
if ((ptr=malloc(size))!=NULL) {
|
||||
fseek(f,0,SEEK_SET);
|
||||
if(fread(ptr,1,size,f) ==(unsigned int) size) {
|
||||
fclose(f);
|
||||
|
@ -181,7 +181,7 @@ void _comprimir(int encode, char *fichero) {
|
|||
fseek(f,0,SEEK_END);
|
||||
size=ftell(f);
|
||||
|
||||
if ((ptr=(byte *)malloc(size))!=NULL) {
|
||||
if ((ptr=malloc(size))!=NULL) {
|
||||
fseek(f,0,SEEK_SET);
|
||||
|
||||
if(fread(ptr,1,size,f) == size) {
|
||||
|
@ -203,7 +203,7 @@ void _comprimir(int encode, char *fichero) {
|
|||
return;
|
||||
size2=size+size/100+256;
|
||||
|
||||
if ((ptr_dest=(byte *)malloc(size2))==NULL) {
|
||||
if ((ptr_dest=malloc(size2))==NULL) {
|
||||
e_free(ptr);
|
||||
return;
|
||||
}
|
||||
|
@ -226,7 +226,7 @@ void _comprimir(int encode, char *fichero) {
|
|||
|
||||
size2=*(int*)(ptr+8);
|
||||
|
||||
if ((ptr_dest=(byte *)malloc(size2))==NULL) {
|
||||
if ((ptr_dest=malloc(size2))==NULL) {
|
||||
e_free(ptr);
|
||||
return;
|
||||
}
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -18,18 +18,19 @@
|
|||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdarg.h>
|
||||
#endif
|
||||
|
||||
#include "shared.h"
|
||||
#include "language.h"
|
||||
#include "edivcfg/iniparser.h"
|
||||
|
||||
static char *ediv_strlwr(char *str);
|
||||
|
||||
int detecta_idioma_iso(char *lang)
|
||||
{
|
||||
|
@ -42,23 +43,27 @@ int detecta_idioma_iso(char* lang)
|
|||
"ca", /* catalán */
|
||||
"eu" /* euskera */
|
||||
};
|
||||
if(lang==NULL) return DEFAULT_LANGUAGE;
|
||||
if(strlen(lang)>2) lang[2]=0;
|
||||
strlwr(lang);
|
||||
if (lang == NULL)
|
||||
return DEFAULT_LANGUAGE;
|
||||
if (strlen(lang) > 2)
|
||||
lang[2] = 0;
|
||||
ediv_strlwr(lang);
|
||||
for (i = 0; i < NUM_LANGUAGES; i++)
|
||||
if (lang[0] == getid[i][0])
|
||||
if (lang[1] == getid[i][1])
|
||||
break;
|
||||
if(i==NUM_LANGUAGES) i=DEFAULT_LANGUAGE;
|
||||
if (i == NUM_LANGUAGES)
|
||||
i = DEFAULT_LANGUAGE;
|
||||
return i;
|
||||
}
|
||||
|
||||
|
||||
int detecta_idioma()
|
||||
{
|
||||
char *langcfg = NULL;
|
||||
if (ini!=NULL) langcfg=iniparser_getstr(ini,"general:lang");
|
||||
if(langcfg==NULL) {
|
||||
if (ini != NULL)
|
||||
langcfg = iniparser_getstr(ini, "general:lang");
|
||||
if (langcfg == NULL)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
int i;
|
||||
static int getid[NUM_LANGUAGES] = {
|
||||
|
@ -73,19 +78,23 @@ int detecta_idioma()
|
|||
|
||||
lang = GetSystemDefaultLangID() & 0xff;
|
||||
for (i = 0; i < NUM_LANGUAGES; i++)
|
||||
if(lang==getid[i]) break;
|
||||
if(i==NUM_LANGUAGES) i=DEFAULT_LANGUAGE;
|
||||
if (lang == getid[i])
|
||||
break;
|
||||
if (i == NUM_LANGUAGES)
|
||||
i = DEFAULT_LANGUAGE;
|
||||
return i;
|
||||
#else
|
||||
langcfg = getenv("LANG");
|
||||
if(langcfg==NULL) return DEFAULT_LANGUAGE;
|
||||
else return detecta_idioma_iso(langcfg);
|
||||
if (langcfg == NULL)
|
||||
return DEFAULT_LANGUAGE;
|
||||
else
|
||||
return detecta_idioma_iso(langcfg);
|
||||
#endif
|
||||
}
|
||||
else return detecta_idioma_iso(langcfg);
|
||||
else
|
||||
return detecta_idioma_iso(langcfg);
|
||||
}
|
||||
|
||||
|
||||
char *translate_error(int num)
|
||||
{
|
||||
|
||||
|
@ -134,7 +143,6 @@ char* translate_ltlex_error(int num)
|
|||
return e[idioma][num];
|
||||
}
|
||||
|
||||
|
||||
char *translate(int num)
|
||||
{
|
||||
static char *e[NUM_LANGUAGES][74] = {
|
||||
|
@ -145,3 +153,45 @@ 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;
|
||||
|
||||
while (*p)
|
||||
{
|
||||
*p = tolower((unsigned char)*p);
|
||||
p++;
|
||||
}
|
||||
|
||||
return str;
|
||||
}
|
|
@ -36,174 +36,275 @@ void listado_objetos (void)
|
|||
FILE *sta;
|
||||
char nombretab[256];
|
||||
int n, o, l;
|
||||
char *msg_37 = get_translate(27, fichero_prg);
|
||||
|
||||
strcpy(nombretab, nombreprog);
|
||||
strcat(nombretab, ".tab");
|
||||
|
||||
if((sta=fopen(nombretab,"w"))==NULL) {
|
||||
printf(translate(36),nombretab);
|
||||
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<num_obj;n++) {
|
||||
switch(obj[n].tipo) {
|
||||
case tnone: fprintf(sta,"%5u\ttnone: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
for (n = 0; n < num_obj; n++)
|
||||
{
|
||||
switch (obj[n].tipo)
|
||||
{
|
||||
case tnone:
|
||||
fprintf(sta, "%5u\ttnone: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
break;
|
||||
case tcons: fprintf(sta,"%5u\ttcons: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case tcons:
|
||||
fprintf(sta, "%5u\ttcons: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\tvalor=%u\n", obj[n].cons.valor);
|
||||
break;
|
||||
case tvglo: fprintf(sta,"%5u\ttvglo: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case tvglo:
|
||||
fprintf(sta, "%5u\ttvglo: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\toffset=%u\n", o = obj[n].vglo.offset);
|
||||
if (obj[n].member) fprintf(sta,"\tmember of %s\n",(*obj[n].member).name);
|
||||
else fprintf(sta,"\tvalor=%u\n",mem[o]);
|
||||
if (obj[n].member)
|
||||
fprintf(sta, "\tmember of %s\n", (*obj[n].member).name);
|
||||
else
|
||||
fprintf(sta, "\tvalor=%u\n", mem[o]);
|
||||
break;
|
||||
case ttglo: fprintf(sta,"%5u\tttglo: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case ttglo:
|
||||
fprintf(sta, "%5u\tttglo: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\toffset=%u\n", o = obj[n].tglo.offset);
|
||||
fprintf(sta, "\tlen1=%u\n", obj[n].tglo.len1);
|
||||
fprintf(sta, "\tlen2=%u\n", obj[n].tglo.len2);
|
||||
fprintf(sta, "\tlen3=%u\n", obj[n].tglo.len3);
|
||||
fprintf(sta, "\ttotalen=%u\n", obj[n].tglo.totalen);
|
||||
if (obj[n].member) fprintf(sta,"\tmember of %s\n",(*obj[n].member).name);
|
||||
if (obj[n].member)
|
||||
fprintf(sta, "\tmember of %s\n", (*obj[n].member).name);
|
||||
break;
|
||||
case tpbgl: case tpwgl: case tpcgl:
|
||||
case tpigl: fprintf(sta,"%5u\ttp?gl: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case tpbgl:
|
||||
case tpwgl:
|
||||
case tpcgl:
|
||||
case tpigl:
|
||||
fprintf(sta, "%5u\ttp?gl: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\toffset=%u\n", o = obj[n].tglo.offset);
|
||||
fprintf(sta, "\tlen1=%u\n", obj[n].tglo.len1);
|
||||
fprintf(sta, "\tlen2=%u\n", obj[n].tglo.len2);
|
||||
fprintf(sta, "\tlen3=%u\n", obj[n].tglo.len3);
|
||||
fprintf(sta, "\ttotalen=%u\n", obj[n].tglo.totalen);
|
||||
if (obj[n].member) fprintf(sta,"\tmember of %s\n",(*obj[n].member).name);
|
||||
if (obj[n].member)
|
||||
fprintf(sta, "\tmember of %s\n", (*obj[n].member).name);
|
||||
break;
|
||||
case tsglo: fprintf(sta,"%5u\ttsglo: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case tsglo:
|
||||
fprintf(sta, "%5u\ttsglo: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\toffset=%u\n", o = obj[n].sglo.offset);
|
||||
fprintf(sta, "\titems1=%u\n", obj[n].sglo.items1);
|
||||
fprintf(sta, "\titems2=%u\n", obj[n].sglo.items2);
|
||||
fprintf(sta, "\titems3=%u\n", obj[n].sglo.items3);
|
||||
fprintf(sta, "\ttotalitems=%u\n", l = obj[n].sglo.totalitems);
|
||||
fprintf(sta, "\tlen_item=%u\n", obj[n].sglo.len_item);
|
||||
if (obj[n].member) fprintf(sta,"\tmember of %s\n",(*obj[n].member).name);
|
||||
if (obj[n].member)
|
||||
fprintf(sta, "\tmember of %s\n", (*obj[n].member).name);
|
||||
break;
|
||||
case tpsgl: fprintf(sta,"%5u\ttpsgl: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case tpsgl:
|
||||
fprintf(sta, "%5u\ttpsgl: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\toffset=%u\n", o = obj[n].sglo.offset);
|
||||
fprintf(sta, "\titems1=%u\n", obj[n].sglo.items1);
|
||||
fprintf(sta, "\titems2=%u\n", obj[n].sglo.items2);
|
||||
fprintf(sta, "\titems3=%u\n", obj[n].sglo.items3);
|
||||
fprintf(sta, "\ttotalitems=%u\n", l = obj[n].sglo.totalitems);
|
||||
fprintf(sta, "\tlen_item=%u\n", obj[n].sglo.len_item);
|
||||
if (obj[n].member) fprintf(sta,"\tmember of %s\n",(*obj[n].member).name);
|
||||
if (obj[n].member)
|
||||
fprintf(sta, "\tmember of %s\n", (*obj[n].member).name);
|
||||
break;
|
||||
case tvloc: fprintf(sta,"%5u\ttvloc: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case tvloc:
|
||||
fprintf(sta, "%5u\ttvloc: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\toffset=%u\n", o = obj[n].vloc.offset);
|
||||
if (obj[n].member) fprintf(sta,"\tmember of %s\n",(*obj[n].member).name);
|
||||
else fprintf(sta,"\tvalor=%u\n",loc[o]);
|
||||
if (obj[n].member)
|
||||
fprintf(sta, "\tmember of %s\n", (*obj[n].member).name);
|
||||
else
|
||||
fprintf(sta, "\tvalor=%u\n", loc[o]);
|
||||
break;
|
||||
case ttloc: fprintf(sta,"%5u\tttloc: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case ttloc:
|
||||
fprintf(sta, "%5u\tttloc: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\toffset=%u\n", o = obj[n].tloc.offset);
|
||||
fprintf(sta, "\tlen1=%u\n", obj[n].tloc.len1);
|
||||
fprintf(sta, "\tlen2=%u\n", obj[n].tloc.len2);
|
||||
fprintf(sta, "\tlen3=%u\n", obj[n].tloc.len3);
|
||||
fprintf(sta, "\ttotalen=%u\n", obj[n].tloc.totalen);
|
||||
if (obj[n].member) fprintf(sta,"\tmember of %s\n",(*obj[n].member).name);
|
||||
if (obj[n].member)
|
||||
fprintf(sta, "\tmember of %s\n", (*obj[n].member).name);
|
||||
break;
|
||||
case tpblo: case tpwlo: case tpclo:
|
||||
case tpilo: fprintf(sta,"%5u\ttp?lo: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case tpblo:
|
||||
case tpwlo:
|
||||
case tpclo:
|
||||
case tpilo:
|
||||
fprintf(sta, "%5u\ttp?lo: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\toffset=%u\n", o = obj[n].tloc.offset);
|
||||
fprintf(sta, "\tlen1=%u\n", obj[n].tloc.len1);
|
||||
fprintf(sta, "\tlen2=%u\n", obj[n].tloc.len2);
|
||||
fprintf(sta, "\tlen3=%u\n", obj[n].tloc.len3);
|
||||
fprintf(sta, "\ttotalen=%u\n", obj[n].tloc.totalen);
|
||||
if (obj[n].member) fprintf(sta,"\tmember of %s\n",(*obj[n].member).name);
|
||||
if (obj[n].member)
|
||||
fprintf(sta, "\tmember of %s\n", (*obj[n].member).name);
|
||||
break;
|
||||
case tsloc: fprintf(sta,"%5u\ttsloc: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case tsloc:
|
||||
fprintf(sta, "%5u\ttsloc: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\toffset=%u\n", o = obj[n].sloc.offset);
|
||||
fprintf(sta, "\titems1=%u\n", obj[n].sloc.items1);
|
||||
fprintf(sta, "\titems2=%u\n", obj[n].sloc.items2);
|
||||
fprintf(sta, "\titems3=%u\n", obj[n].sloc.items3);
|
||||
fprintf(sta, "\ttotalitems=%u\n", l = obj[n].sloc.totalitems);
|
||||
fprintf(sta, "\tlen_item=%u\n", obj[n].sloc.len_item);
|
||||
if (obj[n].member) fprintf(sta,"\tmember of %s\n",(*obj[n].member).name);
|
||||
if (obj[n].member)
|
||||
fprintf(sta, "\tmember of %s\n", (*obj[n].member).name);
|
||||
break;
|
||||
case tpslo: fprintf(sta,"%5u\ttpslo: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case tpslo:
|
||||
fprintf(sta, "%5u\ttpslo: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\toffset=%u\n", o = obj[n].sloc.offset);
|
||||
fprintf(sta, "\titems1=%u\n", obj[n].sloc.items1);
|
||||
fprintf(sta, "\titems2=%u\n", obj[n].sloc.items2);
|
||||
fprintf(sta, "\titems3=%u\n", obj[n].sloc.items3);
|
||||
fprintf(sta, "\ttotalitems=%u\n", l = obj[n].sloc.totalitems);
|
||||
fprintf(sta, "\tlen_item=%u\n", obj[n].sloc.len_item);
|
||||
if (obj[n].member) fprintf(sta,"\tmember of %s\n",(*obj[n].member).name);
|
||||
if (obj[n].member)
|
||||
fprintf(sta, "\tmember of %s\n", (*obj[n].member).name);
|
||||
break;
|
||||
case tproc: fprintf(sta,"%5u\ttproc: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case tproc:
|
||||
fprintf(sta, "%5u\ttproc: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\ttipo=%u\n", (int)(obj[n].proc.bloque));
|
||||
fprintf(sta, "\toffset=%u\n", obj[n].proc.offset);
|
||||
fprintf(sta, "\tnum_par=%u\n", obj[n].proc.num_par);
|
||||
break;
|
||||
case tfext: fprintf(sta,"%5u\ttfext: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case tfext:
|
||||
fprintf(sta, "%5u\ttfext: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\tcodigo=%u\n", obj[n].fext.codigo);
|
||||
fprintf(sta, "\tnum_par=%u\n", obj[n].fext.num_par);
|
||||
break;
|
||||
case tbglo: fprintf(sta,"%5u\ttbglo: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case tbglo:
|
||||
fprintf(sta, "%5u\ttbglo: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\toffset=%u\n", o = obj[n].bglo.offset);
|
||||
fprintf(sta, "\tlen1=%u\n", obj[n].bglo.len1);
|
||||
fprintf(sta, "\tlen2=%u\n", obj[n].bglo.len2);
|
||||
fprintf(sta, "\tlen3=%u\n", obj[n].bglo.len3);
|
||||
fprintf(sta, "\ttotalen=%u\n", obj[n].bglo.totalen);
|
||||
if (obj[n].member) fprintf(sta,"\tmember of %s\n",(*obj[n].member).name);
|
||||
if (obj[n].member)
|
||||
fprintf(sta, "\tmember of %s\n", (*obj[n].member).name);
|
||||
break;
|
||||
case tbloc: fprintf(sta,"%5u\ttbloc: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case tbloc:
|
||||
fprintf(sta, "%5u\ttbloc: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\toffset=%u\n", o = obj[n].bglo.offset);
|
||||
fprintf(sta, "\tlen1=%u\n", obj[n].bglo.len1);
|
||||
fprintf(sta, "\tlen2=%u\n", obj[n].bglo.len2);
|
||||
fprintf(sta, "\tlen3=%u\n", obj[n].bglo.len3);
|
||||
fprintf(sta, "\ttotalen=%u\n", obj[n].bglo.totalen);
|
||||
if (obj[n].member) fprintf(sta,"\tmember of %s\n",(*obj[n].member).name);
|
||||
if (obj[n].member)
|
||||
fprintf(sta, "\tmember of %s\n", (*obj[n].member).name);
|
||||
break;
|
||||
case twglo: fprintf(sta,"%5u\ttwglo: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case twglo:
|
||||
fprintf(sta, "%5u\ttwglo: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\toffset=%u\n", o = obj[n].bglo.offset);
|
||||
fprintf(sta, "\tlen1=%u\n", obj[n].bglo.len1);
|
||||
fprintf(sta, "\tlen2=%u\n", obj[n].bglo.len2);
|
||||
fprintf(sta, "\tlen3=%u\n", obj[n].bglo.len3);
|
||||
fprintf(sta, "\ttotalen=%u\n", obj[n].bglo.totalen);
|
||||
if (obj[n].member) fprintf(sta,"\tmember of %s\n",(*obj[n].member).name);
|
||||
if (obj[n].member)
|
||||
fprintf(sta, "\tmember of %s\n", (*obj[n].member).name);
|
||||
break;
|
||||
case twloc: fprintf(sta,"%5u\ttwloc: %s",n,obj[n].name);
|
||||
if (obj[n].usado) fprintf(sta," (*) usado\n"); else fprintf(sta,"\n");
|
||||
case twloc:
|
||||
fprintf(sta, "%5u\ttwloc: %s", n, obj[n].name);
|
||||
if (obj[n].usado)
|
||||
fprintf(sta, " (*) usado\n");
|
||||
else
|
||||
fprintf(sta, "\n");
|
||||
fprintf(sta, "\toffset=%u\n", o = obj[n].bglo.offset);
|
||||
fprintf(sta, "\tlen1=%u\n", obj[n].bglo.len1);
|
||||
fprintf(sta, "\tlen2=%u\n", obj[n].bglo.len2);
|
||||
fprintf(sta, "\tlen3=%u\n", obj[n].bglo.len3);
|
||||
fprintf(sta, "\ttotalen=%u\n", obj[n].bglo.totalen);
|
||||
if (obj[n].member) fprintf(sta,"\tmember of %s\n",(*obj[n].member).name);
|
||||
if (obj[n].member)
|
||||
fprintf(sta, "\tmember of %s\n", (*obj[n].member).name);
|
||||
break;
|
||||
}
|
||||
fprintf(sta,translate(38),(unsigned int)obj[n].bloque,(unsigned int)obj[n].anterior);
|
||||
|
||||
char *msg_38 = get_translate(38, (unsigned int)obj[n].bloque, (unsigned int)obj[n].anterior);
|
||||
fprintf(sta, msg_38);
|
||||
free(msg_38);
|
||||
fprintf(sta, "\n");
|
||||
}
|
||||
|
||||
fclose(sta);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Graba el fichero ensamblador
|
||||
*/
|
||||
|
@ -216,150 +317,448 @@ void listado_ensamblador (void)
|
|||
strcpy(nombreeml, nombreprog);
|
||||
strcat(nombreeml, ".eml");
|
||||
|
||||
if((sta=fopen(nombreeml,"w"))==NULL) {
|
||||
printf(translate(36),nombreeml);
|
||||
if ((sta = fopen(nombreeml, "w")) == NULL)
|
||||
{
|
||||
print_translate(36, nombreeml);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
fprintf(sta,translate(39),fichero_prg);
|
||||
char *msg_39 = get_translate(39, fichero_prg);
|
||||
fprintf(sta, msg_39);
|
||||
free(msg_39);
|
||||
|
||||
while (i<imem) { switch ((byte)mem[i]) {
|
||||
case lnop: fprintf(sta,"%5u\tnop",i); break;
|
||||
case lcar: fprintf(sta,"%5u\tcar %u",i,mem[i+1]); i++; break;
|
||||
case lasi: fprintf(sta,"%5u\tasi",i); break;
|
||||
case lori: fprintf(sta,"%5u\tori",i); break;
|
||||
case lxor: fprintf(sta,"%5u\txor",i); break;
|
||||
case land: fprintf(sta,"%5u\tand",i); break;
|
||||
case ligu: fprintf(sta,"%5u\tigu",i); break;
|
||||
case ldis: fprintf(sta,"%5u\tdis",i); break;
|
||||
case lmay: fprintf(sta,"%5u\tmay",i); break;
|
||||
case lmen: fprintf(sta,"%5u\tmen",i); break;
|
||||
case lmei: fprintf(sta,"%5u\tmei",i); break;
|
||||
case lmai: fprintf(sta,"%5u\tmai",i); break;
|
||||
case ladd: fprintf(sta,"%5u\tadd",i); break;
|
||||
case lsub: fprintf(sta,"%5u\tsub",i); break;
|
||||
case lmul: fprintf(sta,"%5u\tmul",i); break;
|
||||
case ldiv: fprintf(sta,"%5u\tdiv",i); break;
|
||||
case lmod: fprintf(sta,"%5u\tmod",i); break;
|
||||
case lneg: fprintf(sta,"%5u\tneg",i); break;
|
||||
case lptr: fprintf(sta,"%5u\tptr",i); break;
|
||||
case lnot: fprintf(sta,"%5u\tnot",i); break;
|
||||
case laid: fprintf(sta,"%5u\taid",i); break;
|
||||
case lcid: fprintf(sta,"%5u\tcid",i); break;
|
||||
case lrng: fprintf(sta,"%5u\trng %u",i,mem[i+1]); i++; break;
|
||||
case ljmp: fprintf(sta,"%5u\tjmp %u",i,mem[i+1]); i++; break;
|
||||
case ljpf: fprintf(sta,"%5u\tjpf %u",i,mem[i+1]); i++; break;
|
||||
case lfun: fprintf(sta,"%5u\tfun %u",i,mem[i+1]); i++; break;
|
||||
case lcal: fprintf(sta,"%5u\tcal %u",i,mem[i+1]); i++; break;
|
||||
case lret: fprintf(sta,"%5u\tret",i); break;
|
||||
case lasp: fprintf(sta,"%5u\tasp",i); break;
|
||||
case lfrm: fprintf(sta,"%5u\tfrm",i); break;
|
||||
case lcbp: fprintf(sta,"%5u\tcbp %u",i,mem[i+1]); i++; break;
|
||||
case lcpa: fprintf(sta,"%5u\tcpa",i); break;
|
||||
case ltyp: fprintf(sta,"\n%5u\ttyp %u",i,mem[i+1]); i++; break;
|
||||
case lpri: fprintf(sta,"%5u\tpri %u",i,mem[i+1]); i++; break;
|
||||
case lcse: fprintf(sta,"%5u\tcse %u",i,mem[i+1]); i++; break;
|
||||
case lcsr: fprintf(sta,"%5u\tcsr %u",i,mem[i+1]); i++; break;
|
||||
case lshr: fprintf(sta,"%5u\tshr",i); break;
|
||||
case lshl: fprintf(sta,"%5u\tshl",i); break;
|
||||
case lipt: fprintf(sta,"%5u\tipt",i); break;
|
||||
case lpti: fprintf(sta,"%5u\tpti",i); break;
|
||||
case ldpt: fprintf(sta,"%5u\tdpt",i); break;
|
||||
case lptd: fprintf(sta,"%5u\tptd",i); break;
|
||||
case lada: fprintf(sta,"%5u\tada",i); break;
|
||||
case lsua: fprintf(sta,"%5u\tsua",i); break;
|
||||
case lmua: fprintf(sta,"%5u\tmua",i); break;
|
||||
case ldia: fprintf(sta,"%5u\tdia",i); break;
|
||||
case lmoa: fprintf(sta,"%5u\tmoa",i); break;
|
||||
case lana: fprintf(sta,"%5u\tana",i); break;
|
||||
case lora: fprintf(sta,"%5u\tora",i); break;
|
||||
case lxoa: fprintf(sta,"%5u\txoa",i); break;
|
||||
case lsra: fprintf(sta,"%5u\tsra",i); break;
|
||||
case lsla: fprintf(sta,"%5u\tsla",i); break;
|
||||
case lpar: fprintf(sta,"%5u\tpar %u",i,mem[i+1]); i++; break;
|
||||
case lrtf: fprintf(sta,"%5u\trtf",i); break;
|
||||
case lclo: fprintf(sta,"%5u\tclo %u",i,mem[i+1]); i++; break;
|
||||
case lfrf: fprintf(sta,"%5u\tfrf",i); break;
|
||||
case limp: fprintf(sta,"%5u\timp %u",i,mem[i+1]); i++; break;
|
||||
case lext: fprintf(sta,"%5u\text %u",i,mem[i+1]); i++; break;
|
||||
case lchk: fprintf(sta,"%5u\tchk",i); break;
|
||||
case ldbg: fprintf(sta,"%5u\tdbg",i); break;
|
||||
while (i < imem)
|
||||
{
|
||||
switch ((byte)mem[i])
|
||||
{
|
||||
case lnop:
|
||||
fprintf(sta, "%5u\tnop", i);
|
||||
break;
|
||||
case lcar:
|
||||
fprintf(sta, "%5u\tcar %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lasi:
|
||||
fprintf(sta, "%5u\tasi", i);
|
||||
break;
|
||||
case lori:
|
||||
fprintf(sta, "%5u\tori", i);
|
||||
break;
|
||||
case lxor:
|
||||
fprintf(sta, "%5u\txor", i);
|
||||
break;
|
||||
case land:
|
||||
fprintf(sta, "%5u\tand", i);
|
||||
break;
|
||||
case ligu:
|
||||
fprintf(sta, "%5u\tigu", i);
|
||||
break;
|
||||
case ldis:
|
||||
fprintf(sta, "%5u\tdis", i);
|
||||
break;
|
||||
case lmay:
|
||||
fprintf(sta, "%5u\tmay", i);
|
||||
break;
|
||||
case lmen:
|
||||
fprintf(sta, "%5u\tmen", i);
|
||||
break;
|
||||
case lmei:
|
||||
fprintf(sta, "%5u\tmei", i);
|
||||
break;
|
||||
case lmai:
|
||||
fprintf(sta, "%5u\tmai", i);
|
||||
break;
|
||||
case ladd:
|
||||
fprintf(sta, "%5u\tadd", i);
|
||||
break;
|
||||
case lsub:
|
||||
fprintf(sta, "%5u\tsub", i);
|
||||
break;
|
||||
case lmul:
|
||||
fprintf(sta, "%5u\tmul", i);
|
||||
break;
|
||||
case ldiv:
|
||||
fprintf(sta, "%5u\tdiv", i);
|
||||
break;
|
||||
case lmod:
|
||||
fprintf(sta, "%5u\tmod", i);
|
||||
break;
|
||||
case lneg:
|
||||
fprintf(sta, "%5u\tneg", i);
|
||||
break;
|
||||
case lptr:
|
||||
fprintf(sta, "%5u\tptr", i);
|
||||
break;
|
||||
case lnot:
|
||||
fprintf(sta, "%5u\tnot", i);
|
||||
break;
|
||||
case laid:
|
||||
fprintf(sta, "%5u\taid", i);
|
||||
break;
|
||||
case lcid:
|
||||
fprintf(sta, "%5u\tcid", i);
|
||||
break;
|
||||
case lrng:
|
||||
fprintf(sta, "%5u\trng %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case ljmp:
|
||||
fprintf(sta, "%5u\tjmp %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case ljpf:
|
||||
fprintf(sta, "%5u\tjpf %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lfun:
|
||||
fprintf(sta, "%5u\tfun %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lcal:
|
||||
fprintf(sta, "%5u\tcal %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lret:
|
||||
fprintf(sta, "%5u\tret", i);
|
||||
break;
|
||||
case lasp:
|
||||
fprintf(sta, "%5u\tasp", i);
|
||||
break;
|
||||
case lfrm:
|
||||
fprintf(sta, "%5u\tfrm", i);
|
||||
break;
|
||||
case lcbp:
|
||||
fprintf(sta, "%5u\tcbp %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lcpa:
|
||||
fprintf(sta, "%5u\tcpa", i);
|
||||
break;
|
||||
case ltyp:
|
||||
fprintf(sta, "\n%5u\ttyp %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lpri:
|
||||
fprintf(sta, "%5u\tpri %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lcse:
|
||||
fprintf(sta, "%5u\tcse %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lcsr:
|
||||
fprintf(sta, "%5u\tcsr %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lshr:
|
||||
fprintf(sta, "%5u\tshr", i);
|
||||
break;
|
||||
case lshl:
|
||||
fprintf(sta, "%5u\tshl", i);
|
||||
break;
|
||||
case lipt:
|
||||
fprintf(sta, "%5u\tipt", i);
|
||||
break;
|
||||
case lpti:
|
||||
fprintf(sta, "%5u\tpti", i);
|
||||
break;
|
||||
case ldpt:
|
||||
fprintf(sta, "%5u\tdpt", i);
|
||||
break;
|
||||
case lptd:
|
||||
fprintf(sta, "%5u\tptd", i);
|
||||
break;
|
||||
case lada:
|
||||
fprintf(sta, "%5u\tada", i);
|
||||
break;
|
||||
case lsua:
|
||||
fprintf(sta, "%5u\tsua", i);
|
||||
break;
|
||||
case lmua:
|
||||
fprintf(sta, "%5u\tmua", i);
|
||||
break;
|
||||
case ldia:
|
||||
fprintf(sta, "%5u\tdia", i);
|
||||
break;
|
||||
case lmoa:
|
||||
fprintf(sta, "%5u\tmoa", i);
|
||||
break;
|
||||
case lana:
|
||||
fprintf(sta, "%5u\tana", i);
|
||||
break;
|
||||
case lora:
|
||||
fprintf(sta, "%5u\tora", i);
|
||||
break;
|
||||
case lxoa:
|
||||
fprintf(sta, "%5u\txoa", i);
|
||||
break;
|
||||
case lsra:
|
||||
fprintf(sta, "%5u\tsra", i);
|
||||
break;
|
||||
case lsla:
|
||||
fprintf(sta, "%5u\tsla", i);
|
||||
break;
|
||||
case lpar:
|
||||
fprintf(sta, "%5u\tpar %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lrtf:
|
||||
fprintf(sta, "%5u\trtf", i);
|
||||
break;
|
||||
case lclo:
|
||||
fprintf(sta, "%5u\tclo %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lfrf:
|
||||
fprintf(sta, "%5u\tfrf", i);
|
||||
break;
|
||||
case limp:
|
||||
fprintf(sta, "%5u\timp %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lext:
|
||||
fprintf(sta, "%5u\text %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lchk:
|
||||
fprintf(sta, "%5u\tchk", i);
|
||||
break;
|
||||
case ldbg:
|
||||
fprintf(sta, "%5u\tdbg", i);
|
||||
break;
|
||||
|
||||
case lcar2: fprintf(sta,"%5u\tcar2 %u %u",i,mem[i+1],mem[i+2]); i+=2; break;
|
||||
case lcar3: fprintf(sta,"%5u\tcar3 %u %u %u",i,mem[i+1],mem[i+2],mem[i+3]); i+=3; break;
|
||||
case lcar4: fprintf(sta,"%5u\tcar4 %u %u %u %u",i,mem[i+1],mem[i+2],mem[i+3],mem[i+4]); i+=4; break;
|
||||
case lasiasp: fprintf(sta,"%5u\tasiasp",i); break;
|
||||
case lcaraid: fprintf(sta,"%5u\tcaraid %u",i,mem[i+1]); i++; break;
|
||||
case lcarptr: fprintf(sta,"%5u\tcarptr %u",i,mem[i+1]); i++; break;
|
||||
case laidptr: fprintf(sta,"%5u\taidptr",i); break;
|
||||
case lcaraidptr: fprintf(sta,"%5u\tcaraidptr %u",i,mem[i+1]); i++; break;
|
||||
case lcaraidcpa: fprintf(sta,"%5u\tcaraidcpa %u",i,mem[i+1]); i++; break;
|
||||
case laddptr: fprintf(sta,"%5u\taddptr",i); break;
|
||||
case lfunasp: fprintf(sta,"%5u\tfunasp %u",i,mem[i+1]); i++; break;
|
||||
case lcaradd: fprintf(sta,"%5u\tcaradd %u",i,mem[i+1]); i++; break;
|
||||
case lcaraddptr: fprintf(sta,"%5u\tcaraddptr %u",i,mem[i+1]); i++; break;
|
||||
case lcarmul: fprintf(sta,"%5u\tcarmul %u",i,mem[i+1]); i++; break;
|
||||
case lcarmuladd: fprintf(sta,"%5u\tcarmuladd %u",i,mem[i+1]); i++; break;
|
||||
case lcarasiasp: fprintf(sta,"%5u\tcarasiasp %u",i,mem[i+1]); i++; break;
|
||||
case lcarsub: fprintf(sta,"%5u\tcarsub %u",i,mem[i+1]); i++; break;
|
||||
case lcardiv: fprintf(sta,"%5u\tcardiv %u",i,mem[i+1]); i++; break;
|
||||
case lcar2:
|
||||
fprintf(sta, "%5u\tcar2 %u %u", i, mem[i + 1], mem[i + 2]);
|
||||
i += 2;
|
||||
break;
|
||||
case lcar3:
|
||||
fprintf(sta, "%5u\tcar3 %u %u %u", i, mem[i + 1], mem[i + 2], mem[i + 3]);
|
||||
i += 3;
|
||||
break;
|
||||
case lcar4:
|
||||
fprintf(sta, "%5u\tcar4 %u %u %u %u", i, mem[i + 1], mem[i + 2], mem[i + 3], mem[i + 4]);
|
||||
i += 4;
|
||||
break;
|
||||
case lasiasp:
|
||||
fprintf(sta, "%5u\tasiasp", i);
|
||||
break;
|
||||
case lcaraid:
|
||||
fprintf(sta, "%5u\tcaraid %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lcarptr:
|
||||
fprintf(sta, "%5u\tcarptr %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case laidptr:
|
||||
fprintf(sta, "%5u\taidptr", i);
|
||||
break;
|
||||
case lcaraidptr:
|
||||
fprintf(sta, "%5u\tcaraidptr %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lcaraidcpa:
|
||||
fprintf(sta, "%5u\tcaraidcpa %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case laddptr:
|
||||
fprintf(sta, "%5u\taddptr", i);
|
||||
break;
|
||||
case lfunasp:
|
||||
fprintf(sta, "%5u\tfunasp %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lcaradd:
|
||||
fprintf(sta, "%5u\tcaradd %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lcaraddptr:
|
||||
fprintf(sta, "%5u\tcaraddptr %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lcarmul:
|
||||
fprintf(sta, "%5u\tcarmul %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lcarmuladd:
|
||||
fprintf(sta, "%5u\tcarmuladd %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lcarasiasp:
|
||||
fprintf(sta, "%5u\tcarasiasp %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lcarsub:
|
||||
fprintf(sta, "%5u\tcarsub %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
case lcardiv:
|
||||
fprintf(sta, "%5u\tcardiv %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
|
||||
case lptrwor: fprintf(sta,"%5u\tptrwor",i); break;
|
||||
case lasiwor: fprintf(sta,"%5u\tasiwor",i); break;
|
||||
case liptwor: fprintf(sta,"%5u\tiptwor",i); break;
|
||||
case lptiwor: fprintf(sta,"%5u\tptiwor",i); break;
|
||||
case ldptwor: fprintf(sta,"%5u\tdptwor",i); break;
|
||||
case lptdwor: fprintf(sta,"%5u\tptdwor",i); break;
|
||||
case ladawor: fprintf(sta,"%5u\tadawor",i); break;
|
||||
case lsuawor: fprintf(sta,"%5u\tsuawor",i); break;
|
||||
case lmuawor: fprintf(sta,"%5u\tmuawor",i); break;
|
||||
case ldiawor: fprintf(sta,"%5u\tdiawor",i); break;
|
||||
case lmoawor: fprintf(sta,"%5u\tmoawor",i); break;
|
||||
case lanawor: fprintf(sta,"%5u\tanawor",i); break;
|
||||
case lorawor: fprintf(sta,"%5u\torawor",i); break;
|
||||
case lxoawor: fprintf(sta,"%5u\txoawor",i); break;
|
||||
case lsrawor: fprintf(sta,"%5u\tsrawor",i); break;
|
||||
case lslawor: fprintf(sta,"%5u\tslawor",i); break;
|
||||
case lcpawor: fprintf(sta,"%5u\tcpawor",i); break;
|
||||
case lptrwor:
|
||||
fprintf(sta, "%5u\tptrwor", i);
|
||||
break;
|
||||
case lasiwor:
|
||||
fprintf(sta, "%5u\tasiwor", i);
|
||||
break;
|
||||
case liptwor:
|
||||
fprintf(sta, "%5u\tiptwor", i);
|
||||
break;
|
||||
case lptiwor:
|
||||
fprintf(sta, "%5u\tptiwor", i);
|
||||
break;
|
||||
case ldptwor:
|
||||
fprintf(sta, "%5u\tdptwor", i);
|
||||
break;
|
||||
case lptdwor:
|
||||
fprintf(sta, "%5u\tptdwor", i);
|
||||
break;
|
||||
case ladawor:
|
||||
fprintf(sta, "%5u\tadawor", i);
|
||||
break;
|
||||
case lsuawor:
|
||||
fprintf(sta, "%5u\tsuawor", i);
|
||||
break;
|
||||
case lmuawor:
|
||||
fprintf(sta, "%5u\tmuawor", i);
|
||||
break;
|
||||
case ldiawor:
|
||||
fprintf(sta, "%5u\tdiawor", i);
|
||||
break;
|
||||
case lmoawor:
|
||||
fprintf(sta, "%5u\tmoawor", i);
|
||||
break;
|
||||
case lanawor:
|
||||
fprintf(sta, "%5u\tanawor", i);
|
||||
break;
|
||||
case lorawor:
|
||||
fprintf(sta, "%5u\torawor", i);
|
||||
break;
|
||||
case lxoawor:
|
||||
fprintf(sta, "%5u\txoawor", i);
|
||||
break;
|
||||
case lsrawor:
|
||||
fprintf(sta, "%5u\tsrawor", i);
|
||||
break;
|
||||
case lslawor:
|
||||
fprintf(sta, "%5u\tslawor", i);
|
||||
break;
|
||||
case lcpawor:
|
||||
fprintf(sta, "%5u\tcpawor", i);
|
||||
break;
|
||||
|
||||
case lptrchr: fprintf(sta,"%5u\tptrchr",i); break;
|
||||
case lasichr: fprintf(sta,"%5u\tasichr",i); break;
|
||||
case liptchr: fprintf(sta,"%5u\tiptchr",i); break;
|
||||
case lptichr: fprintf(sta,"%5u\tptichr",i); break;
|
||||
case ldptchr: fprintf(sta,"%5u\tdptchr",i); break;
|
||||
case lptdchr: fprintf(sta,"%5u\tptdchr",i); break;
|
||||
case ladachr: fprintf(sta,"%5u\tadachr",i); break;
|
||||
case lsuachr: fprintf(sta,"%5u\tsuachr",i); break;
|
||||
case lmuachr: fprintf(sta,"%5u\tmuachr",i); break;
|
||||
case ldiachr: fprintf(sta,"%5u\tdiachr",i); break;
|
||||
case lmoachr: fprintf(sta,"%5u\tmoachr",i); break;
|
||||
case lanachr: fprintf(sta,"%5u\tanachr",i); break;
|
||||
case lorachr: fprintf(sta,"%5u\torachr",i); break;
|
||||
case lxoachr: fprintf(sta,"%5u\txoachr",i); break;
|
||||
case lsrachr: fprintf(sta,"%5u\tsrachr",i); break;
|
||||
case lslachr: fprintf(sta,"%5u\tslachr",i); break;
|
||||
case lcpachr: fprintf(sta,"%5u\tcpachr",i); break;
|
||||
case lptrchr:
|
||||
fprintf(sta, "%5u\tptrchr", i);
|
||||
break;
|
||||
case lasichr:
|
||||
fprintf(sta, "%5u\tasichr", i);
|
||||
break;
|
||||
case liptchr:
|
||||
fprintf(sta, "%5u\tiptchr", i);
|
||||
break;
|
||||
case lptichr:
|
||||
fprintf(sta, "%5u\tptichr", i);
|
||||
break;
|
||||
case ldptchr:
|
||||
fprintf(sta, "%5u\tdptchr", i);
|
||||
break;
|
||||
case lptdchr:
|
||||
fprintf(sta, "%5u\tptdchr", i);
|
||||
break;
|
||||
case ladachr:
|
||||
fprintf(sta, "%5u\tadachr", i);
|
||||
break;
|
||||
case lsuachr:
|
||||
fprintf(sta, "%5u\tsuachr", i);
|
||||
break;
|
||||
case lmuachr:
|
||||
fprintf(sta, "%5u\tmuachr", i);
|
||||
break;
|
||||
case ldiachr:
|
||||
fprintf(sta, "%5u\tdiachr", i);
|
||||
break;
|
||||
case lmoachr:
|
||||
fprintf(sta, "%5u\tmoachr", i);
|
||||
break;
|
||||
case lanachr:
|
||||
fprintf(sta, "%5u\tanachr", i);
|
||||
break;
|
||||
case lorachr:
|
||||
fprintf(sta, "%5u\torachr", i);
|
||||
break;
|
||||
case lxoachr:
|
||||
fprintf(sta, "%5u\txoachr", i);
|
||||
break;
|
||||
case lsrachr:
|
||||
fprintf(sta, "%5u\tsrachr", i);
|
||||
break;
|
||||
case lslachr:
|
||||
fprintf(sta, "%5u\tslachr", i);
|
||||
break;
|
||||
case lcpachr:
|
||||
fprintf(sta, "%5u\tcpachr", i);
|
||||
break;
|
||||
|
||||
case lstrcpy: fprintf(sta,"%5u\tstrcpy",i); break;
|
||||
case lstrfix: fprintf(sta,"%5u\tstrfix",i); break;
|
||||
case lstrcat: fprintf(sta,"%5u\tstrcat",i); break;
|
||||
case lstradd: fprintf(sta,"%5u\tstradd",i); break;
|
||||
case lstrdec: fprintf(sta,"%5u\tstrdec",i); break;
|
||||
case lstrsub: fprintf(sta,"%5u\tstrsub",i); break;
|
||||
case lstrlen: fprintf(sta,"%5u\tstrlen",i); break;
|
||||
case lstrigu: fprintf(sta,"%5u\tstrigu",i); break;
|
||||
case lstrdis: fprintf(sta,"%5u\tstrdis",i); break;
|
||||
case lstrmay: fprintf(sta,"%5u\tstrmay",i); break;
|
||||
case lstrmen: fprintf(sta,"%5u\tstrmen",i); break;
|
||||
case lstrmei: fprintf(sta,"%5u\tstrmei",i); break;
|
||||
case lstrmai: fprintf(sta,"%5u\tstrmai",i); break;
|
||||
case lcpastr: fprintf(sta,"%5u\tcpastr",i); break;
|
||||
case lstrcpy:
|
||||
fprintf(sta, "%5u\tstrcpy", i);
|
||||
break;
|
||||
case lstrfix:
|
||||
fprintf(sta, "%5u\tstrfix", i);
|
||||
break;
|
||||
case lstrcat:
|
||||
fprintf(sta, "%5u\tstrcat", i);
|
||||
break;
|
||||
case lstradd:
|
||||
fprintf(sta, "%5u\tstradd", i);
|
||||
break;
|
||||
case lstrdec:
|
||||
fprintf(sta, "%5u\tstrdec", i);
|
||||
break;
|
||||
case lstrsub:
|
||||
fprintf(sta, "%5u\tstrsub", i);
|
||||
break;
|
||||
case lstrlen:
|
||||
fprintf(sta, "%5u\tstrlen", i);
|
||||
break;
|
||||
case lstrigu:
|
||||
fprintf(sta, "%5u\tstrigu", i);
|
||||
break;
|
||||
case lstrdis:
|
||||
fprintf(sta, "%5u\tstrdis", i);
|
||||
break;
|
||||
case lstrmay:
|
||||
fprintf(sta, "%5u\tstrmay", i);
|
||||
break;
|
||||
case lstrmen:
|
||||
fprintf(sta, "%5u\tstrmen", i);
|
||||
break;
|
||||
case lstrmei:
|
||||
fprintf(sta, "%5u\tstrmei", i);
|
||||
break;
|
||||
case lstrmai:
|
||||
fprintf(sta, "%5u\tstrmai", i);
|
||||
break;
|
||||
case lcpastr:
|
||||
fprintf(sta, "%5u\tcpastr", i);
|
||||
break;
|
||||
|
||||
case lnul: fprintf(sta,"%5u\tnul",i); break;
|
||||
case lnul:
|
||||
fprintf(sta, "%5u\tnul", i);
|
||||
break;
|
||||
|
||||
case lextasp: fprintf(sta,"%5u\textasp %u",i,mem[i+1]); i++; break;
|
||||
case lextasp:
|
||||
fprintf(sta, "%5u\textasp %u", i, mem[i + 1]);
|
||||
i++;
|
||||
break;
|
||||
|
||||
default: fprintf(sta,"***"); break;
|
||||
} fprintf(sta,"\n"); i++; }
|
||||
default:
|
||||
fprintf(sta, "***");
|
||||
break;
|
||||
}
|
||||
fprintf(sta, "\n");
|
||||
i++;
|
||||
}
|
||||
fclose(sta);
|
||||
}
|
||||
|
|
|
@ -34,14 +34,15 @@
|
|||
void ltlex_error(int error)
|
||||
{
|
||||
if (error == 1)
|
||||
printf(translate(40),translate_ltlex_error(error));
|
||||
print_translate(40, translate_ltlex_error(error));
|
||||
else
|
||||
printf(translate(41),"ltlex.def",linea,translate_ltlex_error(error));
|
||||
printf(translate(42));
|
||||
print_translate(41, "ltlex.def", linea, translate_ltlex_error(error));
|
||||
print_translate(42);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
void analiza_ltlex(void){
|
||||
void analiza_ltlex(void)
|
||||
{
|
||||
|
||||
byte *_buf, *buf; /* Buffer del texto y puntero al carácter actual */
|
||||
byte cont = 1; /* 0 indica final del archivo */
|
||||
|
@ -61,7 +62,7 @@ void analiza_ltlex(void){
|
|||
/* Lo lee */
|
||||
fseek(def, 0, SEEK_END);
|
||||
len = ftell(def);
|
||||
_buf=buf=(byte *) e_malloc(len+1);
|
||||
_buf = buf = e_malloc(len + 1);
|
||||
fseek(def, 0, SEEK_SET);
|
||||
len = fread(buf, 1, len, def);
|
||||
|
||||
|
@ -74,52 +75,71 @@ void analiza_ltlex(void){
|
|||
|
||||
linea = 1;
|
||||
|
||||
do {
|
||||
switch (*buf++) {
|
||||
do
|
||||
{
|
||||
switch (*buf++)
|
||||
{
|
||||
/* Fin de fichero */
|
||||
case 0:
|
||||
cont=0; break;
|
||||
cont = 0;
|
||||
break;
|
||||
/* Ignoramos los espacios */
|
||||
case ' ':
|
||||
case tab:
|
||||
break;
|
||||
/* Salta de linea */
|
||||
case cr:
|
||||
if(*buf==lf) buf++;
|
||||
if (*buf == lf)
|
||||
buf++;
|
||||
case lf:
|
||||
linea++;
|
||||
break;
|
||||
/* Los ; indican línea de comentario */
|
||||
case ';':
|
||||
while (*buf!=cr && *buf!=lf) buf++; break;
|
||||
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 (*buf>='a' && *buf<='f')
|
||||
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')
|
||||
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 */
|
||||
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) {
|
||||
}
|
||||
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++;
|
||||
|
@ -127,26 +147,38 @@ void analiza_ltlex(void){
|
|||
}
|
||||
else
|
||||
buf++;
|
||||
while (*buf!=' ' && *buf!=tab && *buf!=cr) {
|
||||
if (lower[*buf]) ltlex_error(4);
|
||||
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 {
|
||||
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++;
|
||||
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_free(_buf); _buf=NULL;
|
||||
fclose(def); def=NULL;
|
||||
}
|
||||
break;
|
||||
}
|
||||
} while (cont);
|
||||
|
||||
e_free(_buf);
|
||||
_buf = NULL;
|
||||
fclose(def);
|
||||
def = NULL;
|
||||
}
|
||||
|
|
|
@ -45,7 +45,8 @@ void get_rawname(char* completo, char* rawname)
|
|||
int i;
|
||||
|
||||
for (i = strlen(completo) - 1; i > 0; i--)
|
||||
if(completo[i]=='\\' || completo[i]=='/') {
|
||||
if (completo[i] == '\\' || completo[i] == '/')
|
||||
{
|
||||
p = &completo[i + 1];
|
||||
break;
|
||||
}
|
||||
|
@ -54,21 +55,17 @@ void get_rawname(char* completo, char* rawname)
|
|||
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'))
|
||||
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;
|
||||
|
||||
#else
|
||||
if(rawname[i-3]=='.' && (rawname[i-2]=='s' || rawname[i-2]=='S')
|
||||
&& (rawname[i-1]=='o' || rawname[i-1]=='O'))
|
||||
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)
|
||||
{
|
||||
|
@ -84,7 +81,6 @@ int compara2(const void* _a, const void* _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:";
|
||||
|
@ -124,8 +120,7 @@ void dll_func()
|
|||
/* Busca las DLLs que hay en el directorio */
|
||||
buscafich = _findfirst(mask, &fichero_dll);
|
||||
if (buscafich == -1)
|
||||
printf(translate(43)); /* no hay dlls */
|
||||
|
||||
print_translate(43); /* no hay dlls */
|
||||
|
||||
#ifdef _DEBUG
|
||||
printf("dbg: DLL encontrada: %s\n", fichero_dll.name);
|
||||
|
@ -141,10 +136,11 @@ void dll_func()
|
|||
carga = 0;
|
||||
|
||||
if (carga)
|
||||
if(!leedll()) {
|
||||
if (!leedll())
|
||||
{
|
||||
dlls[numdlls].prioridad = 0;
|
||||
/* guarda el nombre de fichero en la tabla de DLLs */
|
||||
dlls[0].nombre=(char*)e_malloc(strlen(rawname)+1);
|
||||
dlls[0].nombre = e_malloc(strlen(rawname) + 1);
|
||||
strcpy(dlls[0].nombre, rawname);
|
||||
|
||||
/* importa las funciones de la DLL */
|
||||
|
@ -155,8 +151,10 @@ void dll_func()
|
|||
}
|
||||
|
||||
/* hace lo mismo con el resto */
|
||||
while(1) {
|
||||
if(_findnext(buscafich,&fichero_dll)==0) {
|
||||
while (1)
|
||||
{
|
||||
if (_findnext(buscafich, &fichero_dll) == 0)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
printf("dbg: DLL encontrada: %s\n", fichero_dll.name);
|
||||
#endif
|
||||
|
@ -166,12 +164,17 @@ void dll_func()
|
|||
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=(char*)e_malloc(strlen(rawname)+1);
|
||||
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 (ini)
|
||||
dlls[numdlls].prioridad = iniparser_getint(ini, dllkey, dlls[numdlls].prioridad);
|
||||
numdlls++;
|
||||
}
|
||||
}
|
||||
|
@ -181,17 +184,21 @@ void dll_func()
|
|||
|
||||
#else /* si estamos en Linux */
|
||||
|
||||
if(ini) dir=iniparser_getstr(ini,"dll:nixdll");
|
||||
if(!dir) dir="so";
|
||||
if (ini)
|
||||
dir = iniparser_getstr(ini, "dll:nixdll");
|
||||
if (!dir)
|
||||
dir = "so";
|
||||
|
||||
directorio = opendir(dir);
|
||||
if(!directorio) {
|
||||
printf(translate(44),dir); /* no hay directorio so/ */
|
||||
if (!directorio)
|
||||
{
|
||||
print_translate(44, dir); /* no hay directorio so/ */
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/* Busca las .so */
|
||||
while ((fichero_dll = readdir(directorio)) != 0) {
|
||||
while ((fichero_dll = readdir(directorio)) != 0)
|
||||
{
|
||||
/* Salta los directorios actual '.' y padre ".." */
|
||||
if (strcmp(fichero_dll->d_name, ".") == 0)
|
||||
continue;
|
||||
|
@ -199,7 +206,8 @@ void dll_func()
|
|||
if (strcmp(fichero_dll->d_name, "..") == 0)
|
||||
continue;
|
||||
|
||||
if(fichero_dll->d_type==DT_REG) {
|
||||
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);
|
||||
|
@ -211,14 +219,17 @@ void dll_func()
|
|||
strcpy(dllkey, "dll_priority:");
|
||||
strcat(dllkey, rawname);
|
||||
|
||||
if (ini) {
|
||||
if (ini)
|
||||
{
|
||||
if (iniparser_getint(ini, dllkey, 0) <= P_NUNCA)
|
||||
carga = 0;
|
||||
}
|
||||
|
||||
if(carga) {
|
||||
if(!leedll()) {
|
||||
dlls[numdlls].nombre=(char*)e_malloc(strlen(rawname)+1);
|
||||
if (carga)
|
||||
{
|
||||
if (!leedll())
|
||||
{
|
||||
dlls[numdlls].nombre = e_malloc(strlen(rawname) + 1);
|
||||
strcpy(dlls[numdlls].nombre, rawname);
|
||||
dlls[numdlls].usado = 0;
|
||||
|
||||
|
@ -234,7 +245,7 @@ void dll_func()
|
|||
#endif
|
||||
|
||||
if (numdlls == 0)
|
||||
printf(translate(43)); /* no hay librerias */
|
||||
print_translate(43); /* no hay librerias */
|
||||
|
||||
nuevo_orden = e_malloc(numdlls * 4);
|
||||
for (i = 0; i < numdlls; i++)
|
||||
|
@ -247,10 +258,8 @@ void dll_func()
|
|||
for (i = 0; i < numdlls; i++)
|
||||
printf("dbg: %d - %s - prioridad: %d\n", i, dlls[i].nombre, dlls[i].prioridad);
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
|
||||
void dll_func2()
|
||||
{
|
||||
int i = numdlls;
|
||||
|
@ -261,30 +270,36 @@ void dll_func2()
|
|||
for (i = 0; i < numdlls; i++)
|
||||
nuevo_orden[i] = i;
|
||||
|
||||
for(numdlls=0;numdlls<i;numdlls++) {
|
||||
if((dlls[numdlls].prioridad>P_NUNCA) && (dlls[numdlls].usado || dlls[numdlls].prioridad>=P_SIEMPRE)) {
|
||||
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";
|
||||
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";
|
||||
if (ini)
|
||||
dir = iniparser_getstr(ini, "dll:nixdll");
|
||||
if (!dir)
|
||||
dir = "so";
|
||||
sprintf(fichdll, "%s/%s.so", dir, dlls[numdlls].nombre);
|
||||
#endif
|
||||
|
||||
if(leedll()) {
|
||||
printf(translate(45),dlls[numdlls].nombre); /* error al cargar libreria */
|
||||
if (leedll())
|
||||
{
|
||||
print_translate(45, dlls[numdlls].nombre); /* error al cargar libreria */
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int leedll()
|
||||
{
|
||||
TYPEOF_ExportaFuncs *ExportaFuncs;
|
||||
|
@ -294,8 +309,9 @@ int leedll()
|
|||
/* Carga la DLL */
|
||||
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;
|
||||
}
|
||||
|
||||
|
@ -303,8 +319,9 @@ int leedll()
|
|||
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;
|
||||
}
|
||||
|
@ -324,8 +341,9 @@ int leedll()
|
|||
/* Carga la DLL */
|
||||
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;
|
||||
}
|
||||
|
||||
|
@ -335,8 +353,9 @@ int leedll()
|
|||
|
||||
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;
|
||||
}
|
||||
|
|
|
@ -137,10 +137,10 @@ void indexa_variable(tipo_t tipo, char* nombre, int ptr)
|
|||
#endif
|
||||
|
||||
if(varindex) {
|
||||
varindex=(varindex_t*)realloc(varindex,sizeof(varindex_t)*(num_indexed_vars+1));
|
||||
varindex=realloc(varindex,sizeof(varindex_t)*(num_indexed_vars+1));
|
||||
}
|
||||
else {
|
||||
varindex=(varindex_t*)e_malloc(sizeof(varindex_t)*(num_indexed_vars+1));
|
||||
varindex=e_malloc(sizeof(varindex_t)*(num_indexed_vars+1));
|
||||
}
|
||||
varindex[num_indexed_vars].hash=h;
|
||||
varindex[num_indexed_vars].tipo=tipo;
|
||||
|
|
|
@ -137,7 +137,7 @@ void _encriptar(int encode, char * fichero, char * clave)
|
|||
if ((f=fopen(fichero,"rb"))!=NULL) {
|
||||
fseek(f,0,SEEK_END);
|
||||
size=ftell(f);
|
||||
if ((ptr=(byte *)malloc(size))!=NULL) {
|
||||
if ((ptr=malloc(size))!=NULL) {
|
||||
fseek(f,0,SEEK_SET);
|
||||
if(fread(ptr,1,size,f) ==(unsigned int) size) {
|
||||
fclose(f);
|
||||
|
@ -224,7 +224,7 @@ void _comprimir(int encode, char *fichero)
|
|||
if ((f=fopen(fichero,"rb"))!=NULL) {
|
||||
fseek(f,0,SEEK_END);
|
||||
size=ftell(f);
|
||||
if ((ptr=(byte *)malloc(size))!=NULL) {
|
||||
if ((ptr=malloc(size))!=NULL) {
|
||||
fseek(f,0,SEEK_SET);
|
||||
if(fread(ptr,1,size,f) == size) {
|
||||
fclose(f);
|
||||
|
@ -245,7 +245,7 @@ void _comprimir(int encode, char *fichero)
|
|||
return;
|
||||
stub_size=(int)size;
|
||||
size2=size+size/100+256;
|
||||
if ((ptr_dest=(byte *)malloc(size2))==NULL) {
|
||||
if ((ptr_dest=malloc(size2))==NULL) {
|
||||
free(ptr);
|
||||
return;
|
||||
}
|
||||
|
@ -268,7 +268,7 @@ void _comprimir(int encode, char *fichero)
|
|||
return;
|
||||
size2=*(int*)(ptr+8);
|
||||
stub_size=(int)size2;
|
||||
if ((ptr_dest=(byte *)malloc(size2))==NULL) {
|
||||
if ((ptr_dest=malloc(size2))==NULL) {
|
||||
free(ptr);
|
||||
return;
|
||||
}
|
||||
|
|
|
@ -124,7 +124,7 @@ static int AddDLLReference(void *pImageBase, char *svName, DWORD dwFlags)
|
|||
}
|
||||
|
||||
// Add new dll to list
|
||||
cur=(IMAGE_PARAMETERS *)malloc(sizeof(IMAGE_PARAMETERS));
|
||||
cur=malloc(sizeof(IMAGE_PARAMETERS));
|
||||
if(cur==NULL) {
|
||||
LeaveCriticalSection(&g_DLLCrit);
|
||||
return -1;
|
||||
|
|
|
@ -49,13 +49,14 @@
|
|||
#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);
|
||||
const char *get_translate(int num, ...);
|
||||
void print_translate(int num, ...);
|
||||
|
||||
/* compilador */
|
||||
char *translate_error(int num);
|
||||
|
|
|
@ -124,7 +124,7 @@ static int AddDLLReference(void *pImageBase, char *svName, DWORD dwFlags)
|
|||
}
|
||||
|
||||
// Add new dll to list
|
||||
cur=(IMAGE_PARAMETERS *)malloc(sizeof(IMAGE_PARAMETERS));
|
||||
cur=malloc(sizeof(IMAGE_PARAMETERS));
|
||||
if(cur==NULL) {
|
||||
LeaveCriticalSection(&g_DLLCrit);
|
||||
return -1;
|
||||
|
|
|
@ -79,9 +79,7 @@ int offset;
|
|||
return 0;
|
||||
}*/
|
||||
|
||||
|
||||
// Errores específicos en la ejecución de una DLL
|
||||
|
||||
void dll_error(int error, ...)
|
||||
{
|
||||
va_list opparam;
|
||||
|
@ -89,11 +87,11 @@ void dll_error(int 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);
|
||||
MessageBox(0,mensaje,print_translate((4),MB_ICONERROR);
|
||||
#else
|
||||
printf("%s\n", mensaje);
|
||||
#endif
|
||||
|
@ -104,11 +102,10 @@ void dll_error(int error, ...)
|
|||
exit(-1);
|
||||
}
|
||||
|
||||
|
||||
|
||||
int EDIV_Export(char *cadena, int nparam, void *hfuncion)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -119,7 +116,8 @@ int EDIV_Export(char* cadena, int nparam, void* hfuncion)
|
|||
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);
|
||||
"export_function:\tOffset de la funcion: 0x%X\n",
|
||||
n_externs, cadena, nparam, (unsigned int)hfuncion);
|
||||
#endif
|
||||
|
||||
/* if(creaobj) {
|
||||
|
@ -150,7 +148,7 @@ int EDIV_Export(char* cadena, int nparam, void* hfuncion)
|
|||
|
||||
/*#define actfunc dlls[numdlls-1].ext_funcs[dlls[numdlls-1].nfuncs]
|
||||
|
||||
actfunc.cadena=(char*)e_malloc(strlen(cadena)+1);
|
||||
actfunc.cadena=e_malloc(strlen(cadena)+1);
|
||||
strcpy(actfunc.cadena,cadena);
|
||||
actfunc.nparam = nparam;
|
||||
actfunc.hfuncion = hfuncion;*/
|
||||
|
@ -161,7 +159,6 @@ int EDIV_Export(char* cadena, int nparam, void* hfuncion)
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Entrypoint(int ep, void *hfuncion)
|
||||
{
|
||||
entrypoints[n_entrypoints].tipo = ep;
|
||||
|
@ -170,17 +167,16 @@ int EDIV_Export_Entrypoint(int ep, void* hfuncion)
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Priority(int priority)
|
||||
{
|
||||
dlls[numdlls].prioridad = priority;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Const(char *cadena, int valor)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -215,10 +211,10 @@ int EDIV_Export_Const(char* cadena, int valor)
|
|||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Global(char *cadena, int valor)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -251,10 +247,10 @@ int EDIV_Export_Global(char* cadena, int valor)
|
|||
return dimem++;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Global_Tab(char *cadena, int numregs)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -298,10 +294,10 @@ int EDIV_Export_Global_Tab(char* cadena, int numregs)
|
|||
return offset;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Global_Struct(char *cadena, int numregs)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -345,10 +341,10 @@ int EDIV_Export_Global_Struct(char* cadena, int numregs)
|
|||
return dimem;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Member_Int(char *cadena, int valor)
|
||||
{
|
||||
if(!decl_struct) {
|
||||
if (!decl_struct)
|
||||
{
|
||||
dll_error(7, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -393,10 +389,10 @@ int EDIV_Export_Member_Int(char* cadena, int valor)
|
|||
return len++;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Member_Str(char *cadena, int tamano)
|
||||
{
|
||||
if(!decl_struct) {
|
||||
if (!decl_struct)
|
||||
{
|
||||
dll_error(7, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -471,13 +467,12 @@ int EDIV_Export_Member_Str(char* cadena, int tamano)
|
|||
len += tamano;
|
||||
|
||||
return offset;
|
||||
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Member_Tab(char *cadena, int numregs)
|
||||
{
|
||||
if(!decl_struct) {
|
||||
if (!decl_struct)
|
||||
{
|
||||
dll_error(7, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -537,10 +532,10 @@ int EDIV_Export_Member_Tab(char* cadena, int numregs)
|
|||
return offset;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_EndStruct()
|
||||
{
|
||||
if(!decl_struct) {
|
||||
if (!decl_struct)
|
||||
{
|
||||
dll_error(9);
|
||||
return 0;
|
||||
}
|
||||
|
@ -579,20 +574,23 @@ int EDIV_Export_EndStruct()
|
|||
// iloc+=ob->sloc.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;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Local(char *cadena, int valor)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -625,10 +623,10 @@ int EDIV_Export_Local(char* cadena, int valor)
|
|||
return diloc++;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Local_Tab(char *cadena, int numregs)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -673,10 +671,10 @@ int EDIV_Export_Local_Tab(char* cadena, int numregs)
|
|||
return offset;
|
||||
}
|
||||
|
||||
|
||||
int EDIV_Export_Local_Struct(char *cadena, int numregs)
|
||||
{
|
||||
if(decl_struct) {
|
||||
if (decl_struct)
|
||||
{
|
||||
dll_error(6, cadena);
|
||||
return 0;
|
||||
}
|
||||
|
@ -721,7 +719,6 @@ int EDIV_Export_Local_Struct(char* cadena, int numregs)
|
|||
return diloc;
|
||||
}
|
||||
|
||||
|
||||
////////////////
|
||||
/// Call_Entrypoint
|
||||
//////////////
|
||||
|
@ -730,11 +727,14 @@ int Call_Entrypoint(int ep, ...)
|
|||
{
|
||||
va_list opparam;
|
||||
int i, c = 0;
|
||||
for(i=0;i<n_entrypoints;i++) {
|
||||
if(entrypoints[i].tipo==ep) {
|
||||
for (i = 0; i < n_entrypoints; i++)
|
||||
{
|
||||
if (entrypoints[i].tipo == ep)
|
||||
{
|
||||
c++;
|
||||
va_start(opparam, ep);
|
||||
switch(ep) {
|
||||
switch (ep)
|
||||
{
|
||||
|
||||
// void funcion(void)
|
||||
case EDIV_set_video_mode:
|
||||
|
@ -812,7 +812,6 @@ int Call_Entrypoint(int ep, ...)
|
|||
funcion_ep(_imem, _nombreprg, _lin, _dbg);
|
||||
}
|
||||
#endif /* DBG */
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -63,13 +63,13 @@ void error(int num, ...)
|
|||
char mensaje[256];
|
||||
|
||||
va_start(opparam, num);
|
||||
sprintf(mensaje,translate(0), 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);
|
||||
MessageBox(ventanuka, mensaje, print_translate(1), MB_ICONERROR);
|
||||
#else
|
||||
printf("%s\n", mensaje);
|
||||
#endif
|
||||
|
@ -77,7 +77,6 @@ void error(int num, ...)
|
|||
stub_quit(num);
|
||||
}
|
||||
|
||||
|
||||
/* critical_error ( numero, parametros [...] )
|
||||
*
|
||||
* Interrumpe el programa con un mensaje de error. No es posible trazar.
|
||||
|
@ -91,11 +90,11 @@ void critical_error(int num, ...)
|
|||
char mensaje[256];
|
||||
|
||||
va_start(opparam, num);
|
||||
sprintf(mensaje,translate(0), num);
|
||||
sprintf(mensaje, get_translate(0), num);
|
||||
vsprintf(mensaje, translate_critical_error(num), opparam);
|
||||
|
||||
#ifdef WIN32
|
||||
MessageBox(0,mensaje,translate(2),MB_ICONERROR);
|
||||
MessageBox(0, mensaje, print_translate(2), MB_ICONERROR);
|
||||
#else
|
||||
printf("%s\n", mensaje);
|
||||
#endif
|
||||
|
@ -103,7 +102,6 @@ void critical_error(int num, ...)
|
|||
stub_quit(num);
|
||||
}
|
||||
|
||||
|
||||
/* custom_error (tipo, mensaje)
|
||||
*
|
||||
* Permite a las DLLs generar sus propios errores, para que no dependan de los
|
||||
|
@ -122,7 +120,7 @@ void critical_error(int num, ...)
|
|||
void custom_error(tipoerror tipo, char *mensaje)
|
||||
{
|
||||
#ifdef WIN32
|
||||
MessageBox(0,mensaje,translate(tipo),MB_ICONERROR);
|
||||
MessageBox(0, mensaje, print_translate(tipo), MB_ICONERROR);
|
||||
#else
|
||||
printf("%s\n", mensaje);
|
||||
#endif
|
||||
|
|
|
@ -25,13 +25,11 @@
|
|||
*/
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
//#include <SDL/SDL.h>
|
||||
|
||||
#include "extern.h"
|
||||
#include "edivfont.h"
|
||||
//#include "kernel.h"
|
||||
#include "inte.h"
|
||||
#include "main.h"
|
||||
|
@ -48,7 +46,7 @@ int ini_interprete()
|
|||
first_loaded = 1 ;
|
||||
|
||||
pila_max = 1024 ;
|
||||
if ((pila=(int*)malloc(4*pila_max))==NULL)
|
||||
if ((pila=malloc(4*pila_max))==NULL)
|
||||
critical_error(4); // no se pudo reservar memoria para la pila
|
||||
|
||||
sp = 0 ; //por si acaso
|
||||
|
|
|
@ -18,21 +18,19 @@
|
|||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
|
||||
/**** ¡¡¡ OJO CON LAS COMAS !!! ****/
|
||||
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdarg.h>
|
||||
#endif
|
||||
|
||||
#include "shared.h"
|
||||
#include "language.h"
|
||||
|
||||
|
||||
int detecta_idioma_iso(char *lang)
|
||||
{
|
||||
int i;
|
||||
|
@ -44,18 +42,20 @@ int detecta_idioma_iso(char* lang)
|
|||
"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 < NUM_LANGUAGES; i++)
|
||||
if (lang[0] == getid[i][0])
|
||||
if (lang[1] == getid[i][1])
|
||||
break;
|
||||
if(i==NUM_LANGUAGES) i=DEFAULT_LANGUAGE;
|
||||
if (i == NUM_LANGUAGES)
|
||||
i = DEFAULT_LANGUAGE;
|
||||
return i;
|
||||
}
|
||||
|
||||
|
||||
int detecta_idioma()
|
||||
{
|
||||
#ifdef _WIN32
|
||||
|
@ -72,17 +72,20 @@ int detecta_idioma()
|
|||
|
||||
lang = GetSystemDefaultLangID() & 0xff;
|
||||
for (i = 0; i < NUM_LANGUAGES; i++)
|
||||
if(lang==getid[i]) break;
|
||||
if(i==NUM_LANGUAGES) i=DEFAULT_LANGUAGE;
|
||||
if (lang == getid[i])
|
||||
break;
|
||||
if (i == NUM_LANGUAGES)
|
||||
i = DEFAULT_LANGUAGE;
|
||||
return i;
|
||||
#else
|
||||
char *langcfg = getenv("LANG");
|
||||
if(langcfg==NULL) return DEFAULT_LANGUAGE;
|
||||
else return detecta_idioma_iso(langcfg);
|
||||
if (langcfg == NULL)
|
||||
return DEFAULT_LANGUAGE;
|
||||
else
|
||||
return detecta_idioma_iso(langcfg);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
char *translate(int id_cadena)
|
||||
{
|
||||
static char *msg[NUM_LANGUAGES][5] = {
|
||||
|
@ -94,7 +97,6 @@ char* translate(int id_cadena)
|
|||
return msg[idioma][id_cadena];
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* NOTA: los huecos vacíos (184..199) son de errores no usados en DIV2, por favor
|
||||
* aprovechadlos para añadir nuevos errores.
|
||||
|
@ -110,10 +112,8 @@ char* translate_runtime_error(int num)
|
|||
};
|
||||
|
||||
return e[idioma][num];
|
||||
|
||||
}
|
||||
|
||||
|
||||
char *translate_critical_error(int num)
|
||||
{
|
||||
static char *e[NUM_LANGUAGES][10] = {
|
||||
|
@ -126,7 +126,6 @@ char* translate_critical_error(int num)
|
|||
return e[idioma][num];
|
||||
}
|
||||
|
||||
|
||||
char *translate_dll_error(int num)
|
||||
{
|
||||
static char *e[NUM_LANGUAGES][10] = {
|
||||
|
@ -138,3 +137,31 @@ char* translate_dll_error(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;
|
||||
}
|
||||
|
|
|
@ -68,7 +68,7 @@ void dll_func() // ke original, no? XD
|
|||
|
||||
// guarda el nombre de fichero en la tabla de DLLs
|
||||
printf("\nGuardando el nombre de la dll...");
|
||||
dlls[0].nombre=(char*)e_malloc(strlen(fichero_dll.name)+1);
|
||||
dlls[0].nombre=e_malloc(strlen(fichero_dll.name)+1);
|
||||
strcpy(dlls[0].nombre,fichero_dll.name);
|
||||
printf("\nGuardado el nombre de la dll...");
|
||||
|
||||
|
@ -86,7 +86,7 @@ void dll_func() // ke original, no? XD
|
|||
strcat(fichdll,fichero_dll.name);
|
||||
// dlls[numdlls].nfuncs=0;
|
||||
if(!leedll()) {
|
||||
dlls[numdlls].nombre=(char*)e_malloc(strlen(fichero_dll.name)+1);
|
||||
dlls[numdlls].nombre=e_malloc(strlen(fichero_dll.name)+1);
|
||||
strcpy(dlls[numdlls].nombre,fichero_dll.name);
|
||||
dlls[numdlls].usado=0;
|
||||
numdlls++;
|
||||
|
@ -126,7 +126,7 @@ void dll_func() // ke original, no? XD
|
|||
strcat(fichdll,fichero_dll->d_name);
|
||||
// dlls[numdlls].nfuncs=0;
|
||||
if(!leedll()) {
|
||||
dlls[numdlls].nombre=(char*)e_malloc(strlen(fichero_dll->d_name)+1);
|
||||
dlls[numdlls].nombre=e_malloc(strlen(fichero_dll->d_name)+1);
|
||||
strcpy(dlls[numdlls].nombre,fichero_dll->d_name);
|
||||
dlls[numdlls].usado=0;
|
||||
numdlls++;
|
||||
|
|
|
@ -155,7 +155,7 @@ int main(int argc, char* argv[])
|
|||
}
|
||||
|
||||
|
||||
if ((mem=(int*)malloc(4*imem_max+1032*5+16*1025+3))!=NULL){
|
||||
if ((mem=malloc(4*imem_max+1032*5+16*1025+3))!=NULL){
|
||||
|
||||
mem=(int*)((((int)mem+3)/4)*4);
|
||||
|
||||
|
@ -169,7 +169,7 @@ int main(int argc, char* argv[])
|
|||
nullstring[3]=imem_max+1+258*3; mem[nullstring[3]-1]=0xDAD00402;
|
||||
memcpy(mem,mimem,40);
|
||||
|
||||
if ((ptr=(byte*)malloc(len))!=NULL) {
|
||||
if ((ptr=malloc(len))!=NULL) {
|
||||
|
||||
read(f,ptr,len);
|
||||
|
||||
|
@ -205,9 +205,9 @@ int main(int argc, char* argv[])
|
|||
read(f,&num_indexed_vars,4);
|
||||
read(f,&len_descomp,4);
|
||||
read(f,&len,4);
|
||||
ptr=(byte*)e_malloc(len);
|
||||
ptr=e_malloc(len);
|
||||
read(f,ptr,len);
|
||||
vartemp=(byte*)e_malloc(len_descomp);
|
||||
vartemp=e_malloc(len_descomp);
|
||||
if(uncompress(vartemp,&len_descomp,ptr,len)) {
|
||||
free(ptr);
|
||||
free(vartemp);
|
||||
|
@ -215,7 +215,7 @@ int main(int argc, char* argv[])
|
|||
critical_error(1); // error leyendo el código del programa
|
||||
}
|
||||
|
||||
varindex=(varindex_t*)e_malloc(num_indexed_vars*sizeof(varindex_t));
|
||||
varindex=e_malloc(num_indexed_vars*sizeof(varindex_t));
|
||||
ptr=vartemp;
|
||||
|
||||
for(i=0;i<num_indexed_vars;i++) {
|
||||
|
@ -244,9 +244,9 @@ int main(int argc, char* argv[])
|
|||
lseek(f,start_lin,SEEK_SET);
|
||||
read(f,&descomp_size,4);
|
||||
read(f,&comp_size,4);
|
||||
progcomp=(char*)e_malloc(comp_size);
|
||||
progcomp=e_malloc(comp_size);
|
||||
read(f,progcomp,comp_size);
|
||||
prog=(char*)e_malloc(descomp_size);
|
||||
prog=e_malloc(descomp_size);
|
||||
if(uncompress(prog,&descomp_size,progcomp,comp_size)) {
|
||||
close(f);
|
||||
free(prog);
|
||||
|
@ -255,7 +255,7 @@ int main(int argc, char* argv[])
|
|||
}
|
||||
free(progcomp);
|
||||
read(f,&linsize,4);
|
||||
lin=(int*)e_malloc(linsize*4*4+4);
|
||||
lin=e_malloc(linsize*4*4+4);
|
||||
lin[0]=linsize;
|
||||
|
||||
for(i=0;i<linsize;i++) {
|
||||
|
|
|
@ -88,7 +88,7 @@ int main(int argc, char* argv[])
|
|||
fseek(f,0,SEEK_END);
|
||||
tamano=ftell(f);
|
||||
fseek(f,0,SEEK_SET);
|
||||
if((buffer=(char*)malloc(tamano))==NULL) {
|
||||
if((buffer=malloc(tamano))==NULL) {
|
||||
printf("Error: memoria insuficiente\n");
|
||||
exit(3);
|
||||
}
|
||||
|
@ -140,7 +140,7 @@ int main(int argc, char* argv[])
|
|||
tamano=ftell(f);
|
||||
fseek(f,0,SEEK_SET);
|
||||
|
||||
if((buffer=(char*)malloc(tamano+1))==NULL) {
|
||||
if((buffer=malloc(tamano+1))==NULL) {
|
||||
printf("Error: memoria insuficiente\n");
|
||||
exit(5);
|
||||
}
|
||||
|
@ -253,7 +253,7 @@ void situame(char* actual, char* ant, char* sig, char* sup)
|
|||
tam=ftell(fi);
|
||||
fseek(fi,0,SEEK_SET);
|
||||
|
||||
if((buf=(char*)malloc(tam+1))==NULL) {
|
||||
if((buf=malloc(tam+1))==NULL) {
|
||||
printf("Error: memoria insuficiente\n");
|
||||
exit(14);
|
||||
}
|
||||
|
@ -363,7 +363,7 @@ void lee_titulo(char* fixero1, char* titulo)
|
|||
tam=ftell(fi);
|
||||
fseek(fi,0,SEEK_SET);
|
||||
|
||||
if((buf=(char*)malloc(tam+1))==NULL) {
|
||||
if((buf=malloc(tam+1))==NULL) {
|
||||
printf("Error: memoria insuficiente\n");
|
||||
exit(11);
|
||||
}
|
||||
|
@ -477,7 +477,7 @@ void procesa_subindice(char* actual)
|
|||
tam=ftell(fi);
|
||||
fseek(fi,0,SEEK_SET);
|
||||
|
||||
if((buf=(char*)malloc(tam+1))==NULL) {
|
||||
if((buf=malloc(tam+1))==NULL) {
|
||||
printf("Error: memoria insuficiente\n");
|
||||
exit(20);
|
||||
}
|
||||
|
|
|
@ -79,7 +79,7 @@ int main(int argc, char* argv[])
|
|||
exit(4);
|
||||
}
|
||||
|
||||
ico=(unsigned char*)e_malloc(tamanyo);
|
||||
ico=e_malloc(tamanyo);
|
||||
fseek(f,0,SEEK_SET);
|
||||
fread(ico,tamanyo,1,f);
|
||||
fclose(f);
|
||||
|
@ -92,7 +92,7 @@ int main(int argc, char* argv[])
|
|||
fseek(f,0,SEEK_END);
|
||||
tamanyo=ftell(f);
|
||||
fseek(f,0,SEEK_SET);
|
||||
exe=(unsigned char*)e_malloc(tamanyo); /* no creo ke pase nada por unos 125 kb...
|
||||
exe=e_malloc(tamanyo); /* no creo ke pase nada por unos 125 kb...
|
||||
eso si, cuando se puedan meter el PAK y
|
||||
las DLL's en el exe, va a haber ke cambiar
|
||||
esto... */
|
||||
|
|
Loading…
Reference in a new issue