Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1093 connectés 

  FORUM HardWare.fr
  Programmation
  C

  sprinft a base de tableau

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

sprinft a base de tableau

n°1696598
dreameddea​th
Posté le 03-03-2008 à 21:55:57  profilanswer
 

Bonjour à tous,
 
je souhaiterais faire un petit module de generation de fichier configurable. En fait j'ai un structure de donnée de type liste chainée qui contient une structure de type (ce n'est pas le vrai code, car c'est une structure de donnée fournie par un progiciel qui est un type abstrait, mais c'est juste pour l'exemple.)
 

Code :
  1. typedef struct __maillon {
  2.      char * name;
  3.      char * value;
  4.      struct __maillon * m_nextp;
  5. } maillon;


 
Structurellement les "name" sont uniques dans une liste donnée...
 
Ensuite je souhaite faire un génarateur de fichier configurable qui contient dans la conf :
- le format au format printf (avec des %s "toutes options", avec les -, padding à droite, etc...)
- la liste des paramètres (les "names" des maillons) pour remplacer les %s avec la valeur correspondante de maillons de chaine
- la taille max resultante (pour ne pas avoir à me faire chier avec des realloc)
 
Pour cela j'avais pensé à un moyen relativement générique de passer d'une fonction de type :

Code :
  1. int my_sprintf_array(char * buf, char * fmt, int nb_params,char ** params_array)

 
qui appellerait comme il faut (v)sprintf, mais je ne vois pas trop comment faire sans me taper un redécoupage de mon chaine de formattage : mais je ne vois pas comment faire pour passer de ce tableau de chaines à un va_list ou tout autres choses, et je suis à cours d'idées
 
Merci d'avance pour toute idée


Message édité par dreameddeath le 03-03-2008 à 22:23:36
mood
Publicité
Posté le 03-03-2008 à 21:55:57  profilanswer
 

n°1696883
Taz
bisounours-codeur
Posté le 04-03-2008 à 11:56:54  profilanswer
 

__ sont des identifiants réservés. Tu ne dois pas les utiliser.

n°1697253
dreameddea​th
Posté le 04-03-2008 à 23:28:59  profilanswer
 

Merci pour le conseil, je le saurais pour la prochaine fois...
 
Mais je ne présentais la struct (que j'ai écris à la volée) que pour le principe, sachant que mon vrai problème, c'est de partir d'une liste de chaine (récupérée depuis les valeurs de la liste chainée) en utilisant un formattage à la sauce sprintf...
 
par exemple, un fichier de conf  contenant

Code :
  1. fields=NAME_1|NAME_2|NAME_TEST1
  2. fmt=%-20.20s,%10s\n%15s
  3. taille=500


 
et un liste chainée du type (pseudo code)

Code :
  1. void main(){
  2.     maillon maillon1,maillon2,maillon3,maillon4;
  3.     char ** list_values;
  4.     int nb_params;
  5.     int taille_buf;
  6.     char ** fields;
  7.     char * fmt;
  8.     char * buffer;
  10.     if(!read_conf_file(&fields,&nb_params, &fmt,&taille_buf){
  11.         /* gestion erreur */
  12.     }
  14.     list_values = malloc(nb_params*sizeof(char *));
  16.     if(list_values == NULL){
  17.         /* gestion d'erreur */
  18.     }
  19.     /*  
  20.        mes malloc des strings des maillons, du buffer de sortie
  21.     ...
  22.     */
  24.    /* init maillon 1*/
  25.    strcpy(maillon1.name,"NAME1" );
  26.    strcpy(maillon1.value,"test" );
  27.    maillon1.m_nextp = &maillon2;
  29.    /* init maillon 2*/
  30.    strcpy(maillon2.name,"NAMETOTO1" );
  31.    strcpy(maillon2.value,"test_toto1" );
  32.    maillon2.m_nextp = &maillon3;
  34.    /* init maillon 3*/
  35.    strcpy(maillon3.name,"NAME_TEST1" );
  36.    strcpy(maillon3.value,"test_name1" );
  37.    maillon3.m_nextp = &maillon4;
  39.    /* init maillon 4*/
  40.    strcpy(maillon4.name,"NAME_2" );
  41.    strcpy(maillon4.value,"test" );
  42.    maillon4.m_nextp = NULL;
  44.    /*  
  45.    remplissage de list values en fonction de "fields" et des maillons
  46.    ...
  47.    */
  48.  
  49.    my_sprinft_array(buffer, fmt,nb_params,list_values);
  50.    printf(buffer);


 
par contre je ne vois pas trop comment faire pour passer de my_sprintf_array à (v)sprintf sans faire de parsing sioux du contenu de la chaine fmt lu dans la conf...
 
A moins que vous ayez une autre approche + simple...
 
J'espère que je suis assez clair


Message édité par dreameddeath le 04-03-2008 à 23:41:06
n°1697278
dreameddea​th
Posté le 05-03-2008 à 01:16:11  profilanswer
 

Bon bah finalement, j'ai fait un petit truc qui est finalement plus simple que prévu, et ça marche pas mal...
 
En fait je par le format en faisant :
- boucle sur les '%'
- je copie dans le buffer de sortie tout ce que j'ai "sauté" en faisant ma recherche du % suivant
- si le caractère suivant est % (donc je suis en train de traiter un %%) j'affiche %, j'avance et je boucle
- sinon je cherche le prochain "s" (assumption, le format est correct), et j'appelle sprinft dessus (certes un peu sioux en faisant un décalage sur le buf de la longueur courante de ce que j'ai déjà écris)
- j'avance d'un caractère (par rapport à la fin du format de string et je boucle
- en sortant de boucle je copie le résiduel s'il existe
- je checke que j'ai bien "consommé" tout mes paramètres sinon j'affiche un warning...
 
Voilà le code :

Code :
  1. int my_sprintf_array(char * buf,char * fmt, int nb_params, char ** array_values){
  2.     char *fmt_curr_p = fmt;
  3.     char *last_pos_fmt = fmt;
  4.     char sub_fmt_p[10]="";/*assumption not more than 10 char for the %[fmt]s string format*/
  5.     int curr_param_pos = 0;
  6.    
  7.    
  8. #ifdef DEBUG
  9.     printf("starting to process\n" );
  10. #endif
  12.     /*clean the buffer*/
  13.     strcpy(buf,"" );
  14.     /*start loop on % chars*/
  15.     while(fmt_curr_p=strpbrk(fmt_curr_p,"%" )){
  16.         /*copy all the char from last pos to the new one excepted*/
  17.         strncat(buf,last_pos_fmt,fmt_curr_p-last_pos_fmt);
  18.         last_pos_fmt=fmt_curr_p;
  19. #ifdef DEBUG       
  20.         printf("new buffer is '%s'\n",buf);
  21. #endif       
  22.         /*if next char is a %, it's a protection */
  23.         if(strncmp((fmt_curr_p+1),"%",1)==0){
  24.             /*add % in the buf and move forward to skip those two*/
  25.             strcat(buf,"%" );
  26. #ifdef DEBUG
  27.             printf("append '%%', new buffer is '%s'\n",buf);
  28. #endif
  29.             fmt_curr_p+=2;   
  30.             last_pos_fmt = fmt_curr_p;
  31.             continue;
  32.         }
  33.        
  34.         /*try to find the end of the formatting*/
  35.         fmt_curr_p=strpbrk(fmt_curr_p,"s" );
  36.        
  37.         /*end of string not found*/
  38.         if(fmt_curr_p==NULL){
  39.             fprintf(stderr,"Error wrong format in fmt :\n'%s'.\n The char %% found without s after. Please put a %%%% for the %% char\n",fmt);
  40.             return 1;
  41.         }
  42.        
  43.         /*not enough parameters*/
  44.         if(curr_param_pos >= nb_params){
  45.             fprintf(stderr,"Not enough strings at least %d required and %d found\n",curr_param_pos,nb_params);
  46.             return 1;
  47.         }
  49.         /*clean and copy the %s format into the string*/
  50.         strcpy(sub_fmt_p,"" );
  51.         strncat(sub_fmt_p,last_pos_fmt,fmt_curr_p-last_pos_fmt+1);
  52. #ifdef DEBUG
  53.         printf("the found format is '%s'\n",sub_fmt_p);
  54. #endif           
  55.         /*sprintf to the end of the current buffer (pos = strlen(buf))*/
  56.         sprintf(buf+strlen(buf),sub_fmt_p,array_values[curr_param_pos]);
  57.        
  58. #ifdef DEBUG
  59.         printf("the new buffer is '%s'\n",buf);
  60. #endif       
  61.         /*change of input string param*/
  62.         curr_param_pos++;
  63.         /*move to the next char of the input fmt*/
  64.         fmt_curr_p++;
  65.         last_pos_fmt=fmt_curr_p;
  66.     }/*end loop while % are found*/
  67.    
  68.    
  69.     /*copy the last part of the format if not empty*/
  70.     if(strlen(last_pos_fmt)!=0){
  71.         strcat(buf,last_pos_fmt);
  72.     }
  73.    
  74.     /*checking the consumption of all params consumption*/
  75.     if(curr_param_pos!=nb_params){
  76.         fprintf(stderr, "Warning : All parameters not consumed (%d on %d)\n",curr_param_pos,nb_params);
  77.     }
  78.    
  79.     /*say that everything was ok*/
  80.     return 0;
  81. }/*end of my_sprintf_array*/


 
Voilà, si ça peut aider,intéresser d'autres,
 
Je suis preneur de remarques/autres idées...


Message édité par dreameddeath le 05-03-2008 à 01:23:13
n°1697441
Taz
bisounours-codeur
Posté le 05-03-2008 à 11:09:44  profilanswer
 

bah t'es .name et .value ne sont pas alloués ...

n°1697472
dreameddea​th
Posté le 05-03-2008 à 11:49:40  profilanswer
 

je sais : c'est "caché" dans les commentaires (je voulais pas écrire tous les mallocs)...
 
Le code en question n'était qu'un exemple de ce que je voulais faire, ma vrai problématique étant la fonction my_sprintf_array, qui s'est avérée plus simple que prévue (en fait je me battais avec les strtok, alors que mon vrai besoin était la fonction strpbrk)...


Message édité par dreameddeath le 05-03-2008 à 11:50:26
n°1697479
Taz
bisounours-codeur
Posté le 05-03-2008 à 11:57:04  profilanswer
 

strncmp((fmt_curr_p+1),"%",1) c'est une sacré façon de faire un ==
 
Dans tous les cas, croisons les doigts pour que buf soit assez grand.

n°1697490
dreameddea​th
Posté le 05-03-2008 à 12:16:23  profilanswer
 

ce sont les risques du métier en C : je voulais surtout faire un sprintf non basé sur un nombre de params variables, mais un tableau de valeur construit par l'appelant

Message cité 1 fois
n°1697491
Taz
bisounours-codeur
Posté le 05-03-2008 à 12:18:50  profilanswer
 

dreameddeath a écrit :

ce sont les risques du métier en C

C'est pas parce que ton métier est risqué qu'il faut aller sur le chantier en slip-chaussettes.

n°1697822
dreameddea​th
Posté le 05-03-2008 à 18:37:26  profilanswer
 

Donc pour éviter le slip chaussette, j'ai modifié mon code pour checker la taille au fur et à mesure, j'en ai profité pour assouplir le passage de paramètre en pouvant passer 3 types (int, float et string) et des codes retours normalisés ...
 
Je pense (j'espère?) que c'est bon maintenant
 
Taz, je te laisse seul juge :)
 

Code :
  1. /* Return Code Definition */
  2. typedef enum  {
  3.     MY_SPRINTF_OK=0,
  4.     MY_SPRINTF_ERR_BUF_SIZE=1,
  5.     MY_SPRINTF_ERR_SYNTAX=2,
  6.     MY_SPRINTF_ERR_PARAMS=3,
  7.     MY_SPRINTF_ERR_FMT_SIZE=4
  8. } my_sprintf_errcode ;
  11. my_sprintf_errcode my_sprintf_array(char * buf,int buf_max_len, char * fmt, int nb_params, void ** array_values){
  12.     char *fmt_curr_p = fmt;
  13.     char *last_pos_fmt = fmt;
  14.     char sub_fmt_p[MAX_FMT_STATEMENT_LEN+1]="";
  15.     my_sprintf_errcode ret_code = MY_SPRINTF_OK;
  16.     int curr_param_pos = 0;
  17.     int remaining_len = buf_max_len - 1; //already take into account the \0
  18.     int appened_str_len = 0;
  19.     int fmt_str_len = 0;
  20.    
  21.     /*clean the buffer*/
  22.     strcpy(buf,"" );
  23.    
  24.     /*start loop on % chars if buffer has still place */
  25.     while((remaining_len>=0) && (fmt_curr_p=strpbrk(fmt_curr_p,"%" ))){
  26.         /*determine the part len to copy*/
  27.         appened_str_len = fmt_curr_p-last_pos_fmt;
  28.         /*compute the future remaining len*/
  29.         remaining_len -= appened_str_len;
  30.         /*check buf remaining size*/
  31.         if((remaining_len)<0){
  32.             ret_code = MY_SPRINTF_ERR_BUF_SIZE;
  33.             break;
  34.         }
  35.        
  36.         /*copy all the char from last pos to the new one excepted*/
  37.         strncat(buf,last_pos_fmt,appened_str_len);
  38.         last_pos_fmt=fmt_curr_p;
  40.         /*if next char is a %, it's a protection */
  41.         if(*(fmt_curr_p+1)=='%'){
  42.             remaining_len-=1;
  43.             /*check remaining len minus one char (%)*/
  44.             if((remaining_len)<0){
  45.                 ret_code = MY_SPRINTF_ERR_BUF_SIZE;
  46.                 break;
  47.             }
  48.             /*add % in the buf*/
  49.             strcat(buf,"%" );
  50.             /*move forward to skip the %% */
  51.             fmt_curr_p+=2;
  52.             last_pos_fmt = fmt_curr_p;
  53.             continue;
  54.         }
  55.         /*it is a format*/
  56.         else{
  57.             /*try to find the end of the formatting*/
  58.             fmt_curr_p=strpbrk(fmt_curr_p,"sdf" );
  59.            
  60.             /*end of parameter not found*/
  61.             if(fmt_curr_p==NULL){
  62.                 fprintf(stderr,"Error wrong format in fmt :\n'%s'.\n The char %% found without s or f or d after. Please put a %%%% for the %% char\n",fmt);
  63.                 ret_code = MY_SPRINTF_ERR_SYNTAX;
  64.                 break;
  65.             }
  66.            
  67.             /*not enough parameters*/
  68.             if(curr_param_pos >= nb_params){
  69.                 fprintf(stderr,"Not enough strings at least %d required and %d found\n",curr_param_pos,nb_params);
  70.                 ret_code = MY_SPRINTF_ERR_PARAMS;
  71.                 break;
  72.             }
  73.            
  74.             /*clean and copy the %s format into the string*/
  75.             strcpy(sub_fmt_p,"" );
  76.             /*check the format size*/
  77.             fmt_str_len = fmt_curr_p-last_pos_fmt+1;
  78.             if(fmt_str_len > MAX_FMT_STATEMENT_LEN){
  79.                 fprintf(stderr,"A format rule '%*.*s' is two big\n",fmt_str_len,fmt_str_len,last_pos_fmt);
  80.                 ret_code = MY_SPRINTF_ERR_FMT_SIZE;
  81.                 break;
  82.             }
  83.             strncat(sub_fmt_p,last_pos_fmt,fmt_str_len);
  84.        
  85.             /*snprintf to the end of the current buffer (pos = strlen(buf))*/
  86.             /*the max size is the remaining size +1 (due to count of \n)*/
  87.             switch(*fmt_curr_p){
  88.                 case 's':
  89.                     appened_str_len = snprintf(buf+strlen(buf),remaining_len+1,sub_fmt_p,(char*)array_values[curr_param_pos]);
  90.                     break;
  91.                 case 'd' :
  92.                     appened_str_len = snprintf(buf+strlen(buf),remaining_len+1,sub_fmt_p,*((int*)array_values[curr_param_pos]));
  93.                     break;
  94.                 case 'f' :
  95.                     appened_str_len = snprintf(buf+strlen(buf),remaining_len+1,sub_fmt_p,*((float*)array_values[curr_param_pos]));
  96.                     break;
  97.             }
  98.            
  99.             /*check the snprinft max size reached */
  100.             if(appened_str_len < 0){
  101.                 ret_code = MY_SPRINTF_ERR_BUF_SIZE;
  102.                 break;
  103.             }
  104.             else{
  105.                 remaining_len-=appened_str_len;
  106.             }
  107.            
  108.             /*change of input string param*/
  109.             curr_param_pos++;
  110.             /*move to the next char of the input fmt*/
  111.             fmt_curr_p++;
  112.             last_pos_fmt=fmt_curr_p;
  113.         }/*end of fmt string par management*/
  114.        
  115.     }/*end loop while % are found*/
  116.    
  117.     /* If no errors print the residual part if any*/
  118.     if(ret_code == MY_SPRINTF_OK){
  119.         /*copy the last part of the format if not empty*/
  120.         appened_str_len = strlen(last_pos_fmt);
  121.         remaining_len -= appened_str_len;
  122.         /*size check*/
  123.         if(remaining_len<0){
  124.             ret_code = MY_SPRINTF_ERR_BUF_SIZE;
  125.         }
  126.         else if(appened_str_len!=0){
  127.             strcat(buf,last_pos_fmt);
  128.         }
  129.     }
  130.    
  131.    
  132.     /*Errors management*/
  133.     if(ret_code != MY_SPRINTF_OK){
  134.         switch(ret_code){
  135.             case MY_SPRINTF_ERR_BUF_SIZE :
  136.                 fprintf(stderr, "Error MY_SPRINTF_ERR_BUF_SIZE occurs.\n" );
  137.                 break;
  138.             case MY_SPRINTF_ERR_PARAMS :
  139.                 fprintf(stderr, "Error MY_SPRINTF_ERR_PARAMS occurs.\n" );
  140.                 break;
  141.             case MY_SPRINTF_ERR_SYNTAX :
  142.                 fprintf(stderr, "Error MY_SPRINTF_ERR_SYNTAX occurs.\n" );
  143.                 break;
  144.             case MY_SPRINTF_ERR_FMT_SIZE :
  145.                 fprintf(stderr, "Error MY_SPRINTF_ERR_FMT_SIZE occurs.\n" );
  146.                 break;
  147.             default:
  148.                 fprintf(stderr, "An unknown Error occurs.\n" );
  149.                
  150.         }
  151.         fprintf(stderr, "The full format was : %s.\n",fmt);
  152.         fprintf(stderr, "The real processed format is '%*.*s'\n",last_pos_fmt-fmt,last_pos_fmt-fmt,fmt);
  153.     }
  154.     /*if no errors checking the consumption of all params consumption*/
  155.     else if(curr_param_pos!=nb_params){
  156.         fprintf(stderr, "Warning : All parameters not used (%d used on %d)\n",curr_param_pos,nb_params);
  157.     }
  158.    
  159.     /*teel the final result*/
  160.     return ret_code;
  161. }/*end of my_sprintf_array*/


 
J'espère n'avoir rien oublié cette fois ;p


Message édité par dreameddeath le 05-03-2008 à 18:38:43

Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  sprinft a base de tableau

 

Sujets relatifs
tableau d'une chaine de caractereprobleme tri par fusion de tableau
Fond cellule tableauRécupérer des données de word pour les archiver dans un tableau excel
[Base OpenOffice & SQL] SELECT imbriqué[RESOLU] Faire un tableau avec retour dés 4 cellules de suite
modifier une table mysql a l'aide d'un tableau sur une formulaire[ASP] Connexion sur une base Access située sur un autre serveur
Authentification HTTP au moyen d'une base de donnéespeut on choisir un tableau préci avec CSS ?
Plus de sujets relatifs à : sprinft a base de tableau

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.153 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR