05:16 Mot de passe oublié ?

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

2

nan, d'après moi, y' pas grin

on va voir ce qu'en pensent les autres smile
avatar

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

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
avatar

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!
avatar

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.
avatar
— Zeroblog —

« 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

10

À 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" "
avatar
— Zeroblog —

« 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

11

#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;

12

./8 non, là tu fais un tableau de pointeurs, chacun pointant sur une chaine.
avatar

13

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

14

(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)
avatar
— Zeroblog —

« 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

15

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

16

./14 y'a pas forcément de garantie de contiguité.
avatar

17

cf ./9 grin
avatar
— Zeroblog —

« 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

18

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 ^^

19

hehe
avatar
— Zeroblog —

« 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

20

#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;
So much code to write, so little time.

21

Pas mal smile
avatar
— Zeroblog —

« 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

22

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;
avatar

23

Ça inclurait les espaces à la fin dans la chaîne, non ?
avatar
— Zeroblog —

« 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

24

Par ailleurs, const char x[] serait plus approprié que char *x.
So much code to write, so little time.

25

Superbe Nitro, je connaissais pas la stringification avec # ^^

26

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.

27

pencil
avatar

28

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

29

Ben dans ce cas là, il faut faire de l'assembleur.

30

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
Aide Charte Contacts Crédits Réalisé avec yAronet 51 ms