sprinft a base de tableau

sprinft a base de tableau - C - Programmation

Marsh Posté le 03-03-2008 à 21:55:57    

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
Reply

Marsh Posté le 03-03-2008 à 21:55:57   

Reply

Marsh Posté le 04-03-2008 à 11:56:54    

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

Reply

Marsh Posté le 04-03-2008 à 23:28:59    

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
Reply

Marsh Posté le 05-03-2008 à 01:16:11    

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
Reply

Marsh Posté le 05-03-2008 à 11:09:44    

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

Reply

Marsh Posté le 05-03-2008 à 11:49:40    

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
Reply

Marsh Posté le 05-03-2008 à 11:57:04    

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.

Reply

Marsh Posté le 05-03-2008 à 12:16:23    

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
Reply

Marsh Posté le 05-03-2008 à 12:18:50    

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.

Reply

Marsh Posté le 05-03-2008 à 18:37:26    

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
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed