SYMSTR - Page 1

Voilà je me pose une question:

Pourquoi quand je fait ceci:

unsigned char *file="test";

void _main (void)
{
SYM_ENTRY *sym_entry;
sym_entry=SymFind(SYMSTR(file));
}

Ca fonctionne pas, avec ce que j'ai compris il faut transformer ma châine de caractère en 0+test+strlen(test)?

Mais alors pourquoi cette fonction fonctionne:

char b_1[20]="main\aglm\0";
HANDLE ha = DialogNewSimple (160, 40);
DialogAddTitle (ha,"Agenda",BT_OK,BT_CANCEL);
DialogAddRequest (ha,3,15,RB_INI,0,17,12);
retour=DialogDo (ha, CENTER, CENTER, b_1, NULL);
HeapFree (ha);

if(KEY_ESC==retour) {ST_showHelp(ST_BYE); return;}
HS_v=SymFind(SYMSTR(b_1));
HE_v=DerefSym(HS_v);
HA_v=SE_v->handle;

J'avoue que je suis perdus. La macro SYMSTR fonctionne dans tout les cas donc, est-ce que je peux trouver le pointeur du ficher que je veux dont le nom ce trouve dans une liste: lsitfile[]={"tetris","sma"...};? En passant pas SymFind (SYMSTR (lstfile[0]));
A savoir que cette liste change dans le programme.

Je n'ai pas regardé tes deux fonctions, mais apparament le problème est que les chaines de caractères contenues dans lsitfile sont de longueurs variables. comment tu as déclaré lsitfile?

unsigned char *lstfile[]={"test","sma",...};

SYMSTR devrait marcher dans tous tes exemples. Si ton premier exemple ne marche pas, alors il y a vraiment quelque chose qui ne va pas.

Hmm c'est bizarre. SYMSTR(lstfile[i]) devrait marcher..
[Edit: croisé ]

Je suis étonné, j'avoue. Je pensais que SYMSTR était une macro et quelle n'avait aucun effet dans des pogrammes ou une variable du type string change.
moins qui me cassé la tête avec des fonctions:
/*----------------------------------------------------------
Crée un nom du tios à partir d'une chaîne de cractères en C
Retourne le pointeur de fin du nom du fichier
-----------------------------------------------------------*/
char* GenerateTIOSName(char* cname,char* buffer) {
buffer[0] = 0;
return (strcpy(buffer + 1, cname) + strlen(cname));
}


/*-----------------------------------------------------
Renvoie un SYM_ENTRY à partir d'une chaîne de caractère
-------------------------------------------------------*/
SYM_ENTRY* GetSymByName(char* name) {
char buf[50];
HSym hs;

if (*name) hs = SymFind(GenerateTIOSName(name,buf)); /* cname */
else hs = SymFind(name); /* tiosname */

if (!hs.folder) return NULL;
else return DerefSym(hs);
}

Donc cela signifie que je peux faire ça:
void FindAudioFile(struct ListAudio *lst)
{
SYM_ENTRY *entry_folder;
SYM_ENTRY *entry_file;
char buffer[50];
unsigned char **lst_folder;
unsigned char **lst_file;
unsigned char nbr_folder=0;
unsigned char nbr_file=0;
unsigned char tempfile[17];
unsigned char *ptr;

int i=0;

lst_folder=malloc(sizeof(char)*8*50);

entry_folder=SymFindFirst(NULL,FO_SKIP_TEMPS);
while (entry_folder != NULL)
{
lst_folder[nbr_folder++]=entry_folder->name;
entry_folder=SymFindNext();
}

lst_file=malloc(sizeof(char)*18*50);
for (i=0;i<nbr_folder;i++)
{
entry_file=SymFindFirst(GenerateTIOSName(lst_folder[i],buffer),9);
while (entry_file != NULL)
{
memset(tempfile,0,17);
memcpy(tempfile,lst_folder[i],strlen(lst_folder[i]));
strcat(tempfile,"\");
strcat(tempfile,entry_file->name);

if ((unsigned char)(peek(HToESI(entry_file->handle)))==OTH_TAG)
{
ptr=HeapDeref(entry_file->handle);

if (*Get_OtherExt(ptr)==*"mus") memcpy (lst->ptr+18*nbr_file++,tempfile,18);
}

entry_file=SymFindNext();
}
}

lst->size=nbr_file;

free(lst_folder);
free(lst_file);
}
Et remplacer if (*name) hs = SymFind(GenerateTIOSName(name,buf)); par if (*name) hs=SymFind(SYMSTR(name));

J'avoue que je suis surpris.

C'est une macro, mais ça ne l'empêche pas de fonctionner comme voulu.
Plus précisément, ce sont 2 macros: une pour les chaînes variables, et une pour les chaînes constantes. Nous avons patché le préprocesseur de GCC pour qu'il choisisse automatiquement la bonne.

Comment ça marche pour les 2 caractères nuls aux extrémités de la chaîne?

C'est une macro, mais ça ne l'empêche pas de fonctionner comme voulu. Plus précisément, ce sont 2 macros: une pour les chaînes variables, et une pour les chaînes constantes. Nous avons patché le préprocesseur de GCC pour qu'il choisisse automatiquement la bonne.

Depuis quelle version?

Nerick
: Comment ça marche pour les 2 caractères nuls aux extrémités de la chaîne?

Ça alloue un buffer avec alloca.

geogeo
:

C'est une macro, mais ça ne l'empêche pas de fonctionner comme voulu. Plus précisément, ce sont 2 macros: une pour les chaînes variables, et une pour les chaînes constantes. Nous avons patché le préprocesseur de GCC pour qu'il choisisse automatiquement la bonne.

Depuis quelle version?

0.94 bêta 7 (GCC 3.0.4)

Je suis vraiment content de savoir ça, car avant je me suis fait avoir.
Je créer une foncton identique à SYMSTR.
Je suis bien heureux d'avoir crée ce topic.

merci kevin.