1
yop,

en assembleur, pour faire un tableau de chaines de caractères, on écrit ça :
	dc.b	"strict",0
	dc.b	"adda",0
	dc.b	"lea",0
	dc.b	"movem",0
	dc.b	"xan",0
	dc.b	"cmp",0
	dc.b	"dc",0
	dc.b	"ds",0
	dc.b	"dcb",0
	dc.b	"full-log",0
	dc.b	0		; EOT 

En C, j'obtiens un truc immonde et illisible pour avoir la même structure :
char* x = "strict\0adda\0lea\0movem\0xan\0cmp\0dc\0ds\0dcb\0full log\0";
Ya pas un moyen plus joli d'écrire, parce que là c'est vraiment gerbant...

Merci d'avance. smile
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !
2
nan, d'après moi, y' pas grin

on va voir ce qu'en pensent les autres smile
3
Déjà tu peux le formater comme ça :
char* x = "strict\0"  \
"adda\0" \
"lea\0" \
"movem\0" \
"xan\0 \
"cmp\0" \
"dc\0" \
"ds\0" \
"dcb\0" \
"#full log\0";
4
Oui, merci bien, j'ai déjà utilise cette manière de faire. Ca reste plus moche qu'en assembleur. Normal me direz-vous, mais c'est quand même bien plus lisible, notamment pour vérifier la cohérence de la liste avec une autre.

Ok. smile
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !
5
asm(
"x:\n"
"\tdc.b	\"strict\",0\n"
"\tdc.b	\"adda\",0\n"
"\tdc.b	\"lea\",0\n"
"\tdc.b	\"movem\",0\n"
"\tdc.b	\"xan\",0\n"
"\tdc.b	\"cmp\",0\n"
"\tdc.b	\"dc\",0\n"
"\tdc.b	\"ds\",0\n"
"\tdc.b	\"dcb\",0\n"
"\tdc.b	\"full-log\",0\n"
"\tdc.b	0		; EOT\n"
); 

trioui
6
grin

Plus moche c'est vite dit, ça remplace les virgules par des anti-slashs, et ça supprime les dc.b.
C'est pas tellement différent.
7
ou tu inclus un .s dans ton projet et roule poupoune!
8
Et sinon,
char* a[]= {
      "strict",
      "adda",
      "lea",
      "movem",
      "xan",
      "cmp",
      "dc",
      "ds",
      "dcb",
      "#full log",
      ""
} ;
est équivalent, non ? (pas certain que le C garantisse que tout soit contigu)
9
Ça me paraît dangereux. Je ne sais pas ce que ça donne avec des char *, mais avec des const char *, le compilateur peut par exemple fusionner la chaîne avec une chaîne identique présente ailleurs dans le programme, du coup pour la contiguïté c'est mort.

Perso, j'aurais utilisé la méthode du post ./3.
avatarZeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo
À noter qu'on peut faire ça, pour être sûr de ne pas avoir oublié de \0 (et comme je sais que Folco aime bien les trucs esthétiques... hehe\0";
) : char* x = "strict"    "\0" \
          "adda"      "\0" \
          "lea"       "\0" \
          "movem"     "\0" \
          "xan"       "\0" \
          "cmp"       "\0" \
          "dc"        "\0" \
          "ds"        "\0" \
          "dcb"       "\0" \
          "#full log" "
avatarZeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo
#define NB "\0"
#define EOT "\0"

char* x = "strict" NB "adda" NB "lea" NB "movem" NB "xan" NB "cmp" NB "dc" NB "ds" NB "dcb" NB "full log" NB EOT;
./8 non, là tu fais un tableau de pointeurs, chacun pointant sur une chaine.
Exact, ce qui veut dire autant de relocs en asm TI.

Nalfus -> c'est une idée, en effet, mais je vais préférer la solution de Zerosquare en ./10, qui allie l'esthétique au contrôle visuel de l'absence de problème. C'es très lisible et très sûr, merci chef chinois
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !
(squalyl : je pense que l'idée de Pen² était que, si les chaînes sont contiguës en mémoire, il suffit d'utiliser le pointeur contenu dans le premier élément)
avatarZeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo
Pen^2 (./6) :

Plus moche c'est vite dit, ça remplace les virgules par des anti-slashs, et ça supprime les dc.b.C'est pas tellement différent.

Ca participe au contraire notablement à la beauté du code, je dirais même que ça l'ennoblit tripo
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !
./14 y'a pas forcément de garantie de contiguité.
cf ./9 grin
avatarZeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo
pencil Les pointeurs seront contigus avec l'attribut GNU packed, sinon je vois pas ce qui devrait l'être nécessairement. Les chaines pourront être un peu partout dans le binaire.

Sinon, pour faire plaisir à Zerosquare, la table en corrélation est la suivante :
    bool Status [] =
    {
        STRICT,
        ADDA,
        LEA,
        MOVEM,
        XAN,
        CMP,
        DC,
        DS,
        DCB,
        FULL_LOG
    };

Voilà, c'est mieux qu'un champs de bits dans une union avec un int, int qu'on rotatione ensuite pour en lire les bits grin

erf, cross-cf-edit ^^
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !
hehe
avatarZeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo
#define str(s) #s "\0"
#define eot "\0"

char *x =
  str(strict)
  str(adda)
  str(lea)
  str(movem)
  str(xan)
  str(cmp)
  str(dc)
  str(ds)
  str(dcb)
  str(full log)
  eot;
Pas mal smile
avatarZeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo
Certes, bieng!

voire même:

#define str(s) #s "\0"
#define eot "\0"

char *x =
  str(strict  )
  str(adda    )
  str(lea     )
  str(movem   )
  str(xan     )
  str(cmp     )
  str(dc      )
  str(ds      )
  str(dcb     )
  str(full log)
  eot;
Ça inclurait les espaces à la fin dans la chaîne, non ?
avatarZeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo
Par ailleurs, const char x[] serait plus approprié que char *x.
Superbe Nitro, je connaissais pas la stringification avec # ^^
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !
Reste que c'est assez moche en C, parce que tu fais de l'assembleur en C. Si tu faisais du C en assembleur ce serait moche aussi.
Sauf que c'est le moyen le plus efficace de faire ce que j'ai à faire en 68k. Pas de ma faute si le C est mal adapté cheeky
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !
Ben dans ce cas là, il faut faire de l'assembleur.
Quand je code, c'est pas à coup de "il faut", mais de "j'ai envie", donc voilà, ce qui compte c'est de me faire plaisir tongue
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !