Librairie dynamique - Page 9

Zephyr (./242) :
heu oui en fait c'est cohérent avec ce que disait Sally, donc j'ai rien dit

(c'est même carrément un

Sasume (./245) :
Et en ce qui concerne les variables globales, Zephyr a effectivement raison, ne diabolisons par leur usage. Cependant pour des raisons évidentes de lisibilité, maintenabilité et modularité c'est une très bonne chose de ne pas prendre l'habitude d'utiliser systématiquement des variables globales mais de réfléchir à ce qui a réellement besoin d'être global.

Kevin Kofler (./235) :
Un code qui mélange toutes les variables dans une structure globale, c'est un code de porcs

Sasume (./245) :
CONSTANTE
NomDeType
nomDeVariable ou nom_de_variable nomOperatio

Folco (./248) :
Quand vous faites des opérations mathématiques, mettez-vous un espace entre les opérateurs et les variables/constantes ?

Godzil (./241) :
Il me semble que tu peux pas faire un

void*malloc(size_t size);


char *blabla = malloc(1024);
sans au moins te prendre un warning...

Folco (./247) :
Ma structure est locale à main, je passe juste un pointeur. Et du code de porc, que veux-tu, je début. Je vais pas m'amuser à faire 10 structures redondantes pour passer le pointeur de celle kivabien à telle ou telle fonction. C'est là que j'arriverais aux problèmes.

Ce que je fais, c'est la même chose qu'en assembleur

Folco (./248) :
Vous précisez toujour "return" à la fin de vos fonctions ?

Et écrivez-vous fonction(arg1, arg2)ou fonction (arg1, arg2) ? (avec un espace avant la parenthèse)

Quand vous faites des opérations mathématiques, mettez-vous un espace entre les opérateurs et les variables/constantes ?

Kevin Kofler (./251) :
L'idée, c'est de ne pas avoir de structure du tout (sauf pour les trucs comme SCR_RECT qui vont vraiment ensemble, évidemment), mais de passer les paramètres un par un. Regarde un peu les prototypes des ROM_CALLs: dans la plupart des cas, ce n'est pas void fonction(STRUCTURE_ENORME*);, mais quelque chose de type int fonction(int a, int b, SCR_RECT *c, int d);. Le deuxième prototype fait nettement plus "C".

typedef struct {
  word        *stack;
  byte        *prog_block_ptr;
  word        *stack_var_ptr; /* Ça c'est le « frame pointer » */
  word        pc_page;
  print_buf_t *pbf_p;

  char        *ti_location;
  char        *ti_status;
  
  pg_table_t   *pg_table;
  byte         *pg_start;
  
  word         pg_count;
  word         cur_page;
  word         MRU_pg_p;
  
  word font_style;
  int ligne_courante; 
  int position_x;
  
  /* Deuxième fenêtre (upper window) */
  
  Bool upper_win_active;
  word pos_x_upper_win;
  word pos_y_upper_win;
  word taille_up_win;
  
  /* print.c */
  print_buf_t text, room, stream3;
  Bool stream3_active;
  Bool output_disabled;
  
} structure_magique_t;

register word *stack_base asm ("a4");
register byte *base_ptr asm ("a3");
register long pc_offset asm ("d7");

#define structure_magique ((structure_magique_t*)stack_base)
#define stack (structure_magique->stack)
#define prog_block_ptr (structure_magique->prog_block_ptr)
#define stack_var_ptr (structure_magique->stack_var_ptr) /* Ça c'est le « frame pointer » */
#define pc_page (structure_magique->pc_page)
#define ti_location (structure_magique->ti_location)
#define ti_status (structure_magique->ti_status)
#define pbf_p (structure_magique->pbf_p)

#define pg_table (structure_magique->pg_table)
#define pg_start (structure_magique->pg_start)
#define pg_count (structure_magique->pg_count)
#define cur_page (structure_magique->cur_page)
#define MRU_pg_p (structure_magique->MRU_pg_p)

#define font_style (structure_magique->font_style)
#define ligne_courante (structure_magique->ligne_courante) 
#define position_x (structure_magique->position_x)

/* Deuxième fenêtre (upper window) */
#define upper_win_active (structure_magique->upper_win_active)
#define pos_x_upper_win (structure_magique->pos_x_upper_win)
#define pos_y_upper_win (structure_magique->pos_y_upper_win)
#define taille_up_win (structure_magique->taille_up_win)

  /* print.c */
#define text (structure_magique->text)
#define room (structure_magique->room)
#define stream3 (structure_magique->stream3)
#define stream3_active (structure_magique->stream3_active)
#define output_disabled (structure_magique->output_disabled)

stack_base = malloc(STACK_SIZE + sizeof (structure_magique_t));
if (!stack_base) {
ST_helpMsg (FRENCH ? "pas assez de mémoire" : "not enough memory");
return;
}
stack_base += STACK_SIZE / 2;
memset (stack_base, 0, sizeof (structure_magique_t));

{
// Global data
  SCR_RECT Clip;

// Sprites data
  SPRITE_16* SprTable;
  HANDLE SprHd;
  unsigned short SprLock;

// Map Data
  BOOL OpenedMap;
  unsigned char MapName[22];
  unsigned short MapWidth;
  unsigned short MapHeight;
  unsigned short Gravity;
  signed short Wind;
  unsigned char* MapPtr;
  unsigned char* MapDataPtr;

// Genlib Data
  BOOL OpenedGL;
  DSCREEN* DscPtr[2];
  HANDLE DscHd[2];
  unsigned short Tempo;
  PLANE* PlanePtr;
  unsigned short PlaneXS;
  unsigned short PlaneYS;

} DATA;

tChez * moi
    (
    int    inOn,
    char * outFait
    )
    {
    int x    = comme(inOn);
    *outFait = ça();
    return NULL;
    }

GoldenCrystal (./260) :
Sinon pour les valeurs de retour multiple, c'est de bêtes pointeurs dans l'appel de fonction, et y'a aucune autre solution.