Autor Tema: Avances, Diario de...  (Leído 569411 veces)

0 Usuarios y 6 Visitantes están viendo este tema.

Desconectado SplinterGU

  • Hero Member
  • *****
  • Mensajes: 12442
  • Karma: 366
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #30 en: Abril 28, 2008, 07:37:28 pm »
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
« última modificación: Abril 28, 2008, 07:39:14 pm por SplinterGU »
Download Lastest BennuGD Release: http://www.bennugd.org/node/2

Desconectado DCelso

  • Hero Member
  • *****
  • Mensajes: 3708
  • Karma: 180
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #31 en: Abril 29, 2008, 05:14:11 am »
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.
Monstruos Diabólicos

"A PAck of classic GAMEs For BennuGD" en desarrollo
http://code.google.com/p/apagame4be/

Desconectado SplinterGU

  • Hero Member
  • *****
  • Mensajes: 12442
  • Karma: 366
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #32 en: Abril 29, 2008, 07:59:14 am »
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...
Download Lastest BennuGD Release: http://www.bennugd.org/node/2

Desconectado TYCO

  • Sr. Member
  • ****
  • Mensajes: 283
  • Karma: 8
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #33 en: Abril 29, 2008, 08:47:47 am »
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???
Programador, Escritor/Guionista y Deportista.

Todo Modo Gráfico tiene por detrás una Línea de Comandos.

SnowCraft Remake (100%)
Rally Mortal (87%)

Desconectado SplinterGU

  • Hero Member
  • *****
  • Mensajes: 12442
  • Karma: 366
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #34 en: Abril 29, 2008, 11:25:55 am »
no entendi

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

Pero si, hay que probar...
Download Lastest BennuGD Release: http://www.bennugd.org/node/2

Desconectado TYCO

  • Sr. Member
  • ****
  • Mensajes: 283
  • Karma: 8
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #35 en: Abril 29, 2008, 01: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.
« última modificación: Abril 29, 2008, 01:37:42 pm por TYCO »
Programador, Escritor/Guionista y Deportista.

Todo Modo Gráfico tiene por detrás una Línea de Comandos.

SnowCraft Remake (100%)
Rally Mortal (87%)

Desconectado SplinterGU

  • Hero Member
  • *****
  • Mensajes: 12442
  • Karma: 366
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #36 en: Abril 29, 2008, 04:53:22 pm »
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...
Download Lastest BennuGD Release: http://www.bennugd.org/node/2

Desconectado SplinterGU

  • Hero Member
  • *****
  • Mensajes: 12442
  • Karma: 366
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #37 en: Abril 29, 2008, 04:55:27 pm »
A mi me da 30, tanto en el viejo como en el nuevo Bennu.
Download Lastest BennuGD Release: http://www.bennugd.org/node/2

Desconectado DCelso

  • Hero Member
  • *****
  • Mensajes: 3708
  • Karma: 180
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #38 en: Abril 30, 2008, 08:56:01 am »
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.

Monstruos Diabólicos

"A PAck of classic GAMEs For BennuGD" en desarrollo
http://code.google.com/p/apagame4be/

Desconectado SplinterGU

  • Hero Member
  • *****
  • Mensajes: 12442
  • Karma: 366
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #39 en: Abril 30, 2008, 09:03:29 am »
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.
Download Lastest BennuGD Release: http://www.bennugd.org/node/2

Conectado l1nk3rn3l

  • Hero Member
  • *****
  • Mensajes: 1849
  • Karma: 248
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #40 en: Mayo 01, 2008, 12: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 ,





Desconectado SplinterGU

  • Hero Member
  • *****
  • Mensajes: 12442
  • Karma: 366
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #41 en: Mayo 01, 2008, 12:56:53 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
Download Lastest BennuGD Release: http://www.bennugd.org/node/2

Desconectado SplinterGU

  • Hero Member
  • *****
  • Mensajes: 12442
  • Karma: 366
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #42 en: Mayo 08, 2008, 04:46:19 am »
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

Código: [Seleccionar]
-----------
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]

Código: [Seleccionar]
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
« última modificación: Mayo 08, 2008, 05:04:51 am por SplinterGU »
Download Lastest BennuGD Release: http://www.bennugd.org/node/2

Conectado l1nk3rn3l

  • Hero Member
  • *****
  • Mensajes: 1849
  • Karma: 248
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #43 en: Mayo 08, 2008, 05:05:30 pm »
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

Desconectado SplinterGU

  • Hero Member
  • *****
  • Mensajes: 12442
  • Karma: 366
  • Sexo: Masculino
    • Ver Perfil
Re: Avances
« Respuesta #44 en: Mayo 08, 2008, 08:33:55 pm »
Download Lastest BennuGD Release: http://www.bennugd.org/node/2