Posté le 22/09/2014 à 19:02 Membre depuis le 18/06/2001, -26239 message
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) !
Posté le 22/09/2014 à 19:06 Membre depuis le 16/06/2001, 69242 messages
nan, d'après moi, y' pas grin

on va voir ce qu'en pensent les autres smile
Posté le 22/09/2014 à 19:08 Membre depuis le 10/06/2001, 44321 messages
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";
Posté le 22/09/2014 à 19:21 Membre depuis le 18/06/2001, -26239 message
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) !
Posté le 22/09/2014 à 19:27 Membre depuis le 16/06/2001, 69242 messages
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
Posté le 22/09/2014 à 19:28Edité par Pen^2 le 22/09/2014 à 19:40 Membre depuis le 10/06/2001, 44321 messages
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.
Posté le 22/09/2014 à 19:33 Membre depuis le 16/06/2001, 69242 messages
ou tu inclus un .s dans ton projet et roule poupoune!
Posté le 22/09/2014 à 19:38 Membre depuis le 10/06/2001, 44321 messages
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)
Posté le 22/09/2014 à 19:53 Membre depuis le 27/04/2006, 59488 messages
Ç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
Posté le 22/09/2014 à 19:57Edité par Zerosquare le 22/09/2014 à 20:05 Membre depuis le 27/04/2006, 59488 messages
À 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
Posté le 22/09/2014 à 20:00 Membre depuis le 18/06/2004, 268 messages
#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;
Posté le 22/09/2014 à 20:07 Membre depuis le 16/06/2001, 69242 messages
./8 non, là tu fais un tableau de pointeurs, chacun pointant sur une chaine.
Posté le 22/09/2014 à 20:11 Membre depuis le 18/06/2001, -26239 message
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) !
Posté le 22/09/2014 à 20:12 Membre depuis le 27/04/2006, 59488 messages
(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
Posté le 22/09/2014 à 20:15 Membre depuis le 18/06/2001, -26239 message
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) !
Posté le 22/09/2014 à 20:17 Membre depuis le 16/06/2001, 69242 messages
./14 y'a pas forcément de garantie de contiguité.
Posté le 22/09/2014 à 20:19 Membre depuis le 27/04/2006, 59488 messages
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
Posté le 22/09/2014 à 20:20 Membre depuis le 18/06/2001, -26239 message
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) !
Posté le 22/09/2014 à 20:40 Membre depuis le 27/04/2006, 59488 messages
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
Posté le 22/09/2014 à 23:19 Membre depuis le 10/06/2001, 2213 messages
#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;
Posté le 22/09/2014 à 23:20 Membre depuis le 27/04/2006, 59488 messages
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
Posté le 22/09/2014 à 23:24 Membre depuis le 16/06/2001, 69242 messages
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;
Posté le 22/09/2014 à 23:27 Membre depuis le 27/04/2006, 59488 messages
Ç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
Posté le 22/09/2014 à 23:30 Membre depuis le 10/06/2001, 2213 messages
Par ailleurs, const char x[] serait plus approprié que char *x.
Posté le 22/09/2014 à 23:39 Membre depuis le 18/06/2001, -26239 message
Superbe Nitro, je connaissais pas la stringification avec # ^^
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !
Posté le 23/09/2014 à 01:49 Membre depuis le 10/06/2001, 44321 messages
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.
Posté le 23/09/2014 à 08:00 Membre depuis le 16/06/2001, 69242 messages
pencil
Posté le 23/09/2014 à 15:34 Membre depuis le 18/06/2001, -26239 message
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) !
Posté le 23/09/2014 à 15:39 Membre depuis le 10/06/2001, 44321 messages
Ben dans ce cas là, il faut faire de l'assembleur.
Posté le 23/09/2014 à 17:13 Membre depuis le 18/06/2001, -26239 message
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) !