Avances, Diario de...

SplinterGU · April 29, 2008, 03:37:28 AM

Acabo de subir una nueva WIP4... corrigiendo completamente (eso creo) la precendencia de los operadores... pediria que por favor me ayuden a depurarlo...

En el paquete agregue, un programa de ejemplo llamado "precedencias.prg" con algunos test de precedencia, pero necesitaria probar todas las combinaciones posibles... o hasta donde se pueda... fui probando contra lo mismo en C... hasta obtener los mismos resultados...
Tambien inclui un directori DOC, con un html (basado en el del link que puse unos posts atras, pero corregido en base a Bennu) con la referencia de el orden de precendencia de los operadores.

Realmente en Fenix todo el tema de la precedencia de operadores estaba funcionando mal, y es por eso que a veces nos encontramos con errores ilogicos en nuestros codigos... ahora se supone que ya se acabaran... pero necesito que me ayuden a depurarlo...

Aca les dejo el link (solo compile windows, si alguien en verdad quiere ayudar y solo tiene linux, le genero una version, pero por favor no me lo pidan solo querer una version linux que ni siquieran van a probar...)

http://betatester.bennugd.org/20080429/

Desde ya, muchas gracias.

EDIT: dcelso, no olvides ver la respuesta que te puse http://forum.bennugd.org/index.php?topic=102.msg907#msg907

DCelso · April 29, 2008, 01:14:11 PM

Ah, es verdad, vi que respondiste a ello en este mismo "topic" a TYCO.
Creía que en mi caso podría ser otra cosa.

Voy a intentar probar las precedencias. Ya te comentaré si encuentro alguna mal. De todas formas usando paréntesis para obligar un orden irá bien, digo yo :D.

Por cierto he intentado compilar un dll con una función que hace un simple fprinft(stdout,"%s", cadena) y resulta que no consigo que me lo reconozca como un dll válido ni para fenix ni para bennugd.
Sigo los pasos de los tutoriales de hacer dlls para fenix pero nada, creo que algo configuro mal en el IDE codeblocks.
A ver si alguien sabe que pasos hay que seguir en este IDE. O, simplemente, SplinterGU ¿que comandos pongo para compilar y enlazar el .c usando GCC?
Gracias de antemano.

SplinterGU · April 29, 2008, 03:59:14 PM

Busca en este foro dllkit... o algo asi... no hay muchos temas en el foro, asi que no te va a costar mucho navegar y encontrar el tema...

TYCO · April 29, 2008, 04:47:47 PM

Si he entendido bien, hay que probar los distintos OPERADORES, y comprobar que cada uno de ellos se va ejecutando segun la tabla de precedencia no?? aunque estos OPERADORES este casi al final de la instruccion, es asi???

SplinterGU · April 29, 2008, 07:25:55 PM

no entendi

"aunque estos OPERADORES este casi al final de la instruccion, es asi???"

Pero si, hay que probar...

TYCO · April 29, 2008, 09:35:15 PM

Queria decir que al haber OPERADADORES que tienen mas PRECEDENCIA que otros en un IF (15+3*5 == 30), el "*" esta casi al final de la instruccion, aun asi se ejecutaria antes que el "+", cierto?

Y a todo esto el resultado de:
15+3*5 deberia ser 30 y no 90. No es un buen ejemplo pero es sencillo de entender.

SplinterGU · April 30, 2008, 12:53:22 AM

No, ahi el + no es un operador de signo, sino un operador de adicion... o sea, que de nivel 4, y la multiplicacion de nivel 3... o sea, que la multiplicacion se ejecuta primero...

SplinterGU · April 30, 2008, 12:55:27 AM

A mi me da 30, tanto en el viejo como en el nuevo Bennu.

DCelso · April 30, 2008, 04:56:01 PM

Sasto, aplicando las matemáticas escritas de toda la vida también da ese resultado :D.

Creo que quiere decir que ti te referias tu a que había probar ese tipo de preferencias.
Asi que la respuesta debería ser sí, hay que hacer operaciones más complejas y ver si se aplica correctamente el orden viendo como lo hacer C o simplemente viendo tu documento adjunto.

SplinterGU · April 30, 2008, 05:03:29 PM

Si, probarlo, yo ya encontre errores del sizeof([puntero].elemento) o &((cast *)0).elemento o sizeof(((cast *)0).elemento), estoy corrigiendo esas cosas... y probando tambien varias.

l1nk3rn3l · May 01, 2008, 08:15:14 PM

que paso con la mod_draw y faltan otras?

es que intento compilar el test que viene con el fenix ,

note que no tiene dependencias a otras dlls solo requiere la runtime estilo NET o VB

esta genial ,

SplinterGU · May 01, 2008, 08:56:53 PM

Quote from: l1nk3rn3l on May 01, 2008, 08:15:14 PM
que paso con la mod_draw y faltan otras?

es que intento compilar el test que viene con el fenix ,

note que no tiene dependencias a otras dlls solo requiere la runtime estilo NET o VB

esta genial ,

http://forum.bennugd.org/index.php?topic=102.msg867#msg867

SplinterGU · May 08, 2008, 12:46:19 PM

Correcciones importantisimas en el core, bugs transmitidos desde Fenix, se detallan a continuacion:

- Se corrige y se completa el soporte de casteo, direccionamiento(&) y sizeof. (al final adjunto ejemplo y resultados)
- Se corrige precedencia de operadores.
- Se corrige tamaño de arrays asignados en la declaracion.
1) El error consistia en 2, si el tamaño era especificado pero se le incluian valores, el tamaño del array era modificado con respecto a la cantidad de valores que se ingresaban. Tambien el calculo de dichos valores era incorrecto, con lo que el tamaño para esa area de memoria era menor que el necesario.
2) Cuando no se especificaba dimension, el tamaño era calculado erroneamente (mismo caso que el punto 1)
- Se mejora y acelera el switcheo y ejecucion de procesos. Ahora cada proceso tiene su propio stack, no hay un stack global. Ahora todo deberia ir mucho mas rapido, con muchos procesos deberia notarse la mejora.

[code language="bennu"]
global
a;
f;
i;
array[10]=10,9,8,7,6,5,4,3,2,1,0;
char carray[10]=10,9,8,7,6,5,4,3,2,1,0;
char * pcarray;
char ** ppcarray;
pointer p;
v = 7;
float d;

begin

say("-----------");

for (i=0;i<=10;i++)
say("array["+i+"]="+array[ i ]);
end

say("-----------");

p = &array[2];
for (i=0;i<=5;i++)
say("p["+i+"]="+p[ i ]);
end

say("-----------");
p = &array[2];
for (i=0;i<=5;i++)
say("p["+i+"]="+ *++p);
end

say("-----------");
p = &array[0];
say("p[0]="+ *p);

say("-----------");
say("sizeof(carray)="+ sizeof(carray));
say("sizeof(carray[0])="+ sizeof(carray[0]));
say("sizeof(*pcarray)="+ sizeof(*pcarray));
say("sizeof(pcarray[0])="+ sizeof(pcarray[0]));
say("sizeof(ppcarray)="+ sizeof(ppcarray));
say("sizeof(*ppcarray)="+ sizeof(*ppcarray));
say("sizeof(**ppcarray)="+ sizeof(**ppcarray));
say("sizeof(*p)="+ sizeof(*p));
say("sizeof(p[0])="+ sizeof(p[0]));
say("sizeof(p)="+ sizeof(p));
say("sizeof(array)="+ sizeof(array));
say("sizeof(array[0])="+ sizeof(array[0]));

say("-----------");

say("1 && 2 & 1 = "+(1 && 2 & 1));
say("(1 && 2) & 1 = "+((1 && 2) & 1));
say("1 & 2 && 1 = "+(1 & 2 && 1));
say("1 & (2 && 1) = "+(1 & (2 && 1)));

say("-----------");

say("1 || 2 && 0 = "+(1 || 2 && 0));
say("1 || (2 && 0) = "+(1 || (2 && 0)));
say("(1 || 2) && 0 = "+((1 || 2) && 0));

say("-----------");

say("0 && 1 || 2 = "+(0 && 1 || 2));
say("0 && (1 || 2) = "+(0 && (1 || 2)));
say("(0 && 1) || 2 = "+((0 && 1) || 2));

say("-----------");

say("1 ^ 2 & 3 ^ 5 = "+(1 ^ 2 & 3 ^ 5));
say("1 ^ (2 & 3) ^ 5 = "+(1 ^ (2 & 3) ^ 5));
say("(1 ^ 2) & (3 ^ 5) = "+((1 ^ 2) & (3 ^ 5)));

say("-----------");

say("1 == 3 == 3 = "+(1 == 3 == 3));
say("(1 == 3) == 3 = "+((1 == 3) == 3));
say("1 == (3 == 3) = "+(1 == (3 == 3)));
say("1 == 2 > 1 == 3 = "+(1 == 2 > 1 == 3));
say("1 == (2 > 1) == 3 = "+(1 == (2 > 1) == 3));
say("1 == 2 > 1 == 1 = "+(1 == 2 > 1 == 1));
say("1 == (2 > 1) == 1 = "+(1 == (2 > 1) == 1));

say("1<<2+3 = "+(1<<2+3));

say("-----------");

say("15.0 / 3.0 / 2.0 = "+(15.0 / 3.0 / 2.0));
say("(15.0 / 3.0) / 2.0 = "+((15.0 / 3.0) / 2.0));
say("15.0 / (3.0 / 2.0) = "+(15.0 / (3.0 / 2.0)));
say("15+3*5=" + (15+3*5));

end
[/code]

Resultados

Code Select


-----------
array[0]=10
array[1]=9
array[2]=8
array[3]=7
array[4]=6
array[5]=5
array[6]=4
array[7]=3
array[8]=2
array[9]=1
array[10]=0
-----------
p[0]=8
p[1]=7
p[2]=6
p[3]=5
p[4]=4
p[5]=3
-----------
p[0]=7
p[1]=6
p[2]=5
p[3]=4
p[4]=3
p[5]=2
-----------
p[0]=10
-----------
sizeof(carray)=11
sizeof(carray[0])=1
sizeof(*pcarray)=1
sizeof(pcarray[0])=1
sizeof(ppcarray)=4
sizeof(*ppcarray)=4
sizeof(**ppcarray)=1
sizeof(*p)=4
sizeof(p[0])=4
sizeof(p)=4
sizeof(array)=44
sizeof(array[0])=4
-----------
1 && 2 & 1 = 0
(1 && 2) & 1 = 1
1 & 2 && 1 = 0
1 & (2 && 1) = 1
-----------
1 || 2 && 0 = 1
1 || (2 && 0) = 1
(1 || 2) && 0 = 0
-----------
0 && 1 || 2 = 1
0 && (1 || 2) = 0
(0 && 1) || 2 = 1
-----------
1 ^ 2 & 3 ^ 5 = 6
1 ^ (2 & 3) ^ 5 = 6
(1 ^ 2) & (3 ^ 5) = 2
-----------
1 == 3 == 3 = 0
(1 == 3) == 3 = 0
1 == (3 == 3) = 1
1 == 2 > 1 == 3 = 0
1 == (2 > 1) == 3 = 0
1 == 2 > 1 == 1 = 1
1 == (2 > 1) == 1 = 1
1<<2+3 = 32
-----------
15.0 / 3.0 / 2.0 = 2.5
(15.0 / 3.0) / 2.0 = 2.5
15.0 / (3.0 / 2.0) = 10
15+3*5=30

[code language="bennu"]
program prueba;

type struct3 // 4 + 1 + 4 = 9
char *var0;
char var1;
float var2;
end;

type struct2 // 1 + 4 + 4 + 4 = 13
char status;
float flags;
struct3 * s3;
float * f;
end;

type struct1 // 4 + 2 + 4 + 4 + 13 = 27
string name;
short score;
struct2 * s;
struct2 ** s1;
struct2 s2;
end;

global
struct1 st[6] = "Jugador 1", 10, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 2", 5, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 3", 210, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 4", 3, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 5", 33, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 6", 12, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 7", 210, 0, 0, (0, 0.0, NULL, NULL);
struct1 st2[6][10];

struct1 st3[] = "Jugador 1", 10, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 2", 5, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 3", 210, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 4", 3, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 5", 33, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 6", 12, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 7", 210, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 8", 3, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 9", 33, 0, 0, (0, 0.0, NULL, NULL),
"Jugador 10", 12, 0, 0, (0, 0.0, NULL, NULL);

int array[15] = 1,2,3,4,5,6,7,8;

int array1[] = 1,2,3,4,5,6,7,8,9,10,11,12;
short array2[] = 1,2,3,4,5,6,7,8,9,10,11,12,13,14;

struct2 fill = ( 'A', 2.3, NULL, NULL);

char ** ch;
char carr[10][10];
string str[10][10];
string str1[10];
string str2;
string pstr;
i;
struct1 * pst = NULL; // Auxiliar
struct1 ** ppst = NULL;
struct1 *** pppst = NULL;
int total;
int o;
float f;

#define OFFS(s,m) &((s *)0.m)

process test()
public
n;
struct1 m;
begin
say("offset(struct2, flags)=" + OFFS(struct2,flags));
say("offset(struct1, s)=" + OFFS(struct1,s));

say("-----------");
say("sizeof(n)=" + sizeof(n));
say("sizeof(m.score)=" + sizeof(m.score));

quicksort(&st, sizeof(st[0]), total, OFFS(struct1,score), sizeof(pst.score), 0);
for (i = 0; i < total; i++)
say("st["+i+"].name="+st[ i ].name+" - score=" + st[ i ].score);
end

say("-----------");

say("&[pst].score=" + &[pst].score);
say("&pst.score=" + &pst.score);
say("&[ppst].score=" + &[ppst].score);
say("&[[ppst]].score=" + &[[ppst]].score);
say("&[[pppst]].score=" + &[[pppst]].score);
say("&(**pppst).score=" + &(**pppst).score);
say("&(struct1 *)pst.score=" + &(struct1 *)pst.score);
say("&(struct1 *)pst.s=" + &(struct1 *)pst.s);
say("offset=" + &((struct1 *)0).score);
say("sizeof(float)=" + sizeof(float));
say("sizeof(*pst)=" + sizeof(*pst));
say("sizeof(*pst.score)=" + sizeof((*pst).score));
say("sizeof(pst.score)=" + sizeof(pst.score));
say("sizeof(pst.s.status)=" + sizeof(pst.s.status));
say("sizeof([pst])=" + sizeof([pst]));
say("sizeof([ch])=" + sizeof([ch]));
say("sizeof([[ch]])=" + sizeof([[ch]]));
say("sizeof(*ch)=" + sizeof(*ch));
say("sizeof(**ch)=" + sizeof(**ch));

while(1)
frame;
end

end

local
test t;

begin

say("sizeof(dword) =" + sizeof(dword) );
say("sizeof(int) =" + sizeof(int) );
say("sizeof(string)=" + sizeof(string));
say("sizeof(float) =" + sizeof(float) );
say("sizeof(short) =" + sizeof(short) );
say("sizeof(word) =" + sizeof(word) );
say("sizeof(char) =" + sizeof(char) );
say("sizeof(byte) =" + sizeof(byte) );

say("sizeof(dword *) =" + sizeof(dword *) );
say("sizeof(int *) =" + sizeof(int *) );
say("sizeof(string *)=" + sizeof(string *));
say("sizeof(float *) =" + sizeof(float *) );
say("sizeof(short *) =" + sizeof(short *) );
say("sizeof(word *) =" + sizeof(word *) );
say("sizeof(char *) =" + sizeof(char *) );
say("sizeof(byte *) =" + sizeof(byte *) );

say("sizeof(pst.score)=" + sizeof(pst.score));
say("sizeof((pst).score)=" + sizeof((pst).score));
say("sizeof((*pst).score)=" + sizeof((*pst).score));
say("sizeof([*ppst].score)=" + sizeof([*ppst].score));
// say("sizeof([**ppst].score)=" + sizeof([**ppst].score)); // error - pointer required
// say("sizeof([*ppst.score])=" + sizeof([*ppst.score])); // error - pointer required

say("sizeof((*pst.s).s3)=" + sizeof((*pst.s).s3));
say("sizeof(*(*pst.s).s3)=" + sizeof(*(*pst.s).s3));

say("sizeof(pst.s)=" + sizeof(pst.s));
say("sizeof([pst].s)=" + sizeof([pst].s));
say("sizeof([[pst].s])=" + sizeof([[pst].s]));
say("sizeof([ppst].s)=" + sizeof([ppst].s));
say("sizeof([[[ppst]].s])=" + sizeof([[[ppst]].s]));
say("sizeof([[ppst]].)=" + sizeof([[ppst]].));
say("sizeof(pst.s)=" + sizeof([pst].s));
say("sizeof([pst].)=" + sizeof([pst].));
say("sizeof([[*ppst].s])=" + sizeof([[*ppst].s]));
say("sizeof([*ppst.s])=" + sizeof([[ppst]].));

say ("sizeof([pst].s)="+ sizeof([pst].s));
say ("sizeof(*[pst].s)="+ sizeof(*[pst].s));
say ("sizeof([[pst].s])="+ sizeof([[pst].s]));
say ("sizeof([pst].)="+ sizeof([pst].));

say("sizeof(pst[0])=" + sizeof(pst[0]));
say("sizeof(pst[0].score)=" + sizeof(pst[0].score));

say("sizeof(ppst)=" + sizeof(ppst));
say("sizeof(ppst[0])=" + sizeof(ppst[0]));
say("sizeof(*ppst)=" + sizeof(*ppst));
say("sizeof(**ppst)=" + sizeof(**ppst));
say("sizeof(*ppst[0])=" + sizeof(*ppst[0]));
// say("sizeof(ppst[0][0])=" + sizeof(ppst[0][0])); // error - exceded array access from pointer
// say("sizeof(***ppst)=" + sizeof(***ppst)); // error - exceded pointer reference
// say("sizeof(pst[0][0].score)=" + sizeof(pst[0][0].score)); // error - exceded array access from pointer
say("sizeof(ppst[0].score)=" + sizeof(ppst[0].score));
// say("sizeof(ppst.score)=" + sizeof(ppst.score)); // error - requiere estructura
say("sizeof([[ppst]].score)=" + sizeof([[ppst]].score));
say("sizeof([ppst].score)=" + sizeof([ppst].score));
say("sizeof([ppst[0]].score)=" + sizeof([ppst[0]].score));
// say("sizeof(ppst[0][0].score)=" + sizeof(ppst[0][0].score)); // error - exceded array access from pointer

// say("sizeof([st[0]].score)=" + sizeof([st[0]].score)); // error - pointer required
say("sizeof(st[0].score)=" + sizeof(st[0].score));
say("sizeof(pst.s)=" + sizeof(pst.s));
say("sizeof(*pst.s)=" + sizeof(*pst.s));
say("sizeof(*pst[0].s)=" + sizeof(*pst[0].s));
say("sizeof(pst.s[0])=" + sizeof(pst.s[0]));
say("sizeof(*pst.s1)=" + sizeof(*pst.s1));
say("sizeof(**pst.s1)=" + sizeof(**pst.s1));
// say("sizeof(***pst.s1)=" + sizeof(***pst.s1)); // error - exceded pointer reference
say("sizeof(pst.score)=" + sizeof(pst.score));
say("sizeof(pst[0].score)=" + sizeof(pst[0].score));
say("sizeof(pst.s.s3)=" + sizeof(pst.s.s3));
say("sizeof(pst[0].s[0].s3)=" + sizeof(pst[0].s[0].s3));
say("sizeof(*pst.s.s3)=" + sizeof(*pst.s.s3));
// say("sizeof(**pst.s.s3)=" + sizeof(**pst.s.s3)); // error - exceded pointer reference
say("sizeof(pst[0].s[0].s3[0])=" + sizeof(pst[0].s[0].s3[0]));
// say("sizeof(*pst.score)=" + sizeof(*pst.score)); // error - no es puntero
// say("sizeof(st[0][0].score)=" + sizeof(st[0][0].score)); // error - Excede dimensiones de array
// say("sizeof(st2[0].score)=" + sizeof(st2[0].score)); // error - Referencia array no es correcta, falta un indice
say("sizeof(st2[0][0].score)=" + sizeof(st2[0][0].score));
// say("sizeof(st2[0][0][0].score)=" + sizeof(st2[0][0][0].score)); // error - Excede dimensiones de array

say("sizeof(struct1)=" + sizeof(struct1));
say("sizeof(struct2)=" + sizeof(struct2));
say("sizeof(struct3)=" + sizeof(struct3));

say("sizeof(*pst)=" + sizeof(*pst));
say("sizeof((*pst).score)=" + sizeof((*pst).score));
say("sizeof(*pst.s)=" + sizeof(*pst.s));
say("sizeof(*(pst.s))=" + sizeof(*(pst.s)));

say("sizeof(carr[0])=" + sizeof(carr[0]));
say("sizeof(carr[0][0])=" + sizeof(carr[0][0]));
say("sizeof(pstr[0])=" + sizeof(pstr[0]));
say("sizeof(str2[0])=" + sizeof(str2[0]));

say("sizeof(str[0])=" + sizeof(str[0]));
say("sizeof(str[0][0])=" + sizeof(str[0][0]));
say("sizeof(str[0][0][0])=" + sizeof(str[0][0][0]));

// say("sizeof(str[0][0][0][0])=" + sizeof(str[0][0][0][0])); // error - array dimension error

say("sizeof(str1[0])=" + sizeof(str1[0]));
say("sizeof(str1[0][0])=" + sizeof(str1[0][0]));

say("sizeof(st)="+sizeof(st));
say("sizeof(st[0])="+sizeof(st[0]));

say("sizeof(st3)="+sizeof(st3));
say("sizeof(st3[0])="+sizeof(st3[0]));

say("sizeof(array)="+sizeof(array));
say("sizeof(array1)="+sizeof(array1));
say("sizeof(array2)="+sizeof(array2));

say("sizeof(t.m.score)=" + sizeof(t.m.score));
say("sizeof(t.m)=" + sizeof(t.m));
say("sizeof(t)=" + sizeof(t));

pst = alloc(sizeof(struct1));
[pst].s = alloc(sizeof(struct2));
memset([pst].s, 126, sizeof([[pst].s]));

ppst = &pst;
pppst = &ppst;

total = sizeof(st)/sizeof(st[0]);

t = test();

say("&t.m.score=" + &t.m.score);
say("&t.m=" + &t.m);
say("&t=" + &t);

say("sizeof(st)="+sizeof(st)+" sizeof(st[0])="+sizeof(st[0]) +" total="+total);

say("[pst].s="+ [pst].s + " [pst].s.status=" + [pst].s.status);
say("[pst].s="+ [pst].s + " [[pst].s].status=" + [[pst].s].status);

[[pst].s] = fill;

say("&fill="+ &fill);

say("[pst].s="+ [pst].s + " [pst].s.status=" + [pst].s.status);
say("[pst].s="+ [pst].s + " [[pst].s].status=" + [[pst].s].status);

say ("memset("+[pst].s+", 35, "+sizeof([pst.s])+")");
memset([pst].s, 35, sizeof([pst.s]));

say("[pst].s="+ [pst].s + " [pst].s.status=" + [pst].s.status);
say("[pst].s="+ [pst].s + " [[pst].s].status=" + [[pst].s].status);

[[pst].s] = fill;

say("[pst].s="+ [pst].s + " [pst].s.status=" + [pst].s.status);
say("[pst].s="+ [pst].s + " [[pst].s].status=" + [[pst].s].status);

let_me_alone();

end
[/code]

Code Select


sizeof(dword) =4
sizeof(int)   =4
sizeof(string)=4
sizeof(float) =4
sizeof(short) =2
sizeof(word)  =2
sizeof(char)  =1
sizeof(byte)  =1
sizeof(dword *) =4
sizeof(int *)   =4
sizeof(string *)=4
sizeof(float *) =4
sizeof(short *) =4
sizeof(word *)  =4
sizeof(char *)  =4
sizeof(byte *)  =4
sizeof(pst.score)=2
sizeof((pst).score)=2
sizeof((*pst).score)=2
sizeof([*ppst].score)=2
sizeof((*pst.s).s3)=4
sizeof(*(*pst.s).s3)=9
sizeof(pst.s)=4
sizeof([pst].s)=4
sizeof([[pst].s])=13
sizeof([ppst].s)=4
sizeof([[[ppst]].s])=13
sizeof([[ppst]].[s])=13
sizeof(pst.s)=4
sizeof([pst].[s])=13
sizeof([[*ppst].s])=13
sizeof([*ppst.s])=13
sizeof([pst].s)=4
sizeof(*[pst].s)=13
sizeof([[pst].s])=13
sizeof([pst].[s])=13
sizeof(pst[0])=27
sizeof(pst[0].score)=2
sizeof(ppst)=4
sizeof(ppst[0])=4
sizeof(*ppst)=4
sizeof(**ppst)=27
sizeof(*ppst[0])=4
sizeof(ppst[0].score)=2
sizeof([[ppst]].score)=2
sizeof([ppst].score)=2
sizeof([ppst[0]].score)=2
sizeof(st[0].score)=2
sizeof(pst.s)=4
sizeof(*pst.s)=13
sizeof(*pst[0].s)=13
sizeof(pst.s[0])=13
sizeof(*pst.s1)=4
sizeof(**pst.s1)=13
sizeof(pst.score)=2
sizeof(pst[0].score)=2
sizeof(pst.s.s3)=4
sizeof(pst[0].s[0].s3)=4
sizeof(*pst.s.s3)=9
sizeof(pst[0].s[0].s3[0])=9
sizeof(st2[0][0].score)=2
sizeof(struct1)=27
sizeof(struct2)=13
sizeof(struct3)=9
sizeof(*pst)=27
sizeof((*pst).score)=2
sizeof(*pst.s)=13
sizeof(*(pst.s))=13
sizeof(carr[0])=11
sizeof(carr[0][0])=1
sizeof(pstr[0])=1
sizeof(str2[0])=1
sizeof(str[0])=44
sizeof(str[0][0])=4
sizeof(str[0][0][0])=1
sizeof(str1[0])=4
sizeof(str1[0][0])=1
sizeof(st)=189
sizeof(st[0])=27
sizeof(st3)=270
sizeof(st3[0])=27
sizeof(array)=64
sizeof(array1)=48
sizeof(array2)=28
sizeof(t.m.score)=2
sizeof(t.m)=27
sizeof(t)=4
offset(struct2, flags)=00000001
offset(struct1, s)=00000006
-----------
sizeof(n)=4
sizeof(m.score)=2
st[0].name=Jugador 4 - score=3
st[1].name=Jugador 2 - score=5
st[2].name=Jugador 1 - score=10
st[3].name=Jugador 6 - score=12
st[4].name=Jugador 5 - score=33
st[5].name=Jugador 7 - score=210
st[6].name=Jugador 3 - score=210
-----------
&[pst].score=00592A54
&pst.score=00592A54
&[ppst].score=00592A54
&[[ppst]].score=00592A54
&[[pppst]].score=00592A54
&(**pppst).score=00592A54
&(struct1 *)pst.score=00592A54
&(struct1 *)pst.s=00592A56
offset=00000004
sizeof(float)=4
sizeof(*pst)=27
sizeof(*pst.score)=2
sizeof(pst.score)=2
sizeof(pst.s.status)=1
sizeof([pst])=27
sizeof([ch])=4
sizeof([[ch]])=1
sizeof(*ch)=4
sizeof(**ch)=1
&t.m.score=00592B00
&t.m=00592AFC
&t=005917CC
sizeof(st)=189 sizeof(st[0])=27 total=7
[pst].s=00592A38 [pst].s.status=~
[pst].s=00592A38 [[pst].s].status=~
&fill=003FED46
[pst].s=00592A38 [pst].s.status=A
[pst].s=00592A38 [[pst].s].status=A
memset(00592A38, 35, 13)
[pst].s=00592A38 [pst].s.status=#
[pst].s=00592A38 [[pst].s].status=#
[pst].s=00592A38 [pst].s.status=A
[pst].s=00592A38 [[pst].s].status=A

l1nk3rn3l · May 09, 2008, 01:05:30 AM

Es que pienso adicionar al flamebird la opcion de incluir todo en el dcb
osease mochila(exe) y por fuera las dlls lo normal..

cual es la opcion para decirle a bennu que incluya todos los recursos
referenciados en el codigo fuente...

gracias

SplinterGU · May 09, 2008, 04:33:55 AM

http://forum.bennugd.org/index.php?topic=53.0