Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Some more debuging message, allowing to catch and destroy a bug showing at full debug...
[simgrid.git] / src / gras / DataDesc / ddt_parse.c
1 /* $Id$ */
2
3 /* DataDesc/ddt_parse.c -- automatic parsing of data structures */
4
5 /* Authors: Arnaud Legrand, Martin Quinson            */
6 /* Copyright (C) 2003, 2004 Martin Quinson.                                 */
7
8 /* This program is free software; you can redistribute it and/or modify it
9    under the terms of the license (GNU LGPL) which comes with this package. */
10
11 #include "DataDesc/datadesc_private.h"
12 #include "DataDesc/ddt_parse.yy.h"
13
14 GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(parse,datadesc);
15
16 typedef struct s_type_modifier{
17   short is_unsigned;
18   short is_short;
19   short is_long;
20
21   short is_struct;
22   short is_union;
23   short is_enum;
24
25   short is_ref;
26 } type_modifier_t;
27
28 typedef struct s_field {
29   gras_datadesc_type_t *type;
30   char *type_name;
31   char *name;
32 } identifier_t;
33  
34 extern char *gras_ddt_parse_text; /* text being considered in the parser */
35
36 /* prototypes */
37 static void parse_type_modifier(type_modifier_t         *type_modifier);
38 static void print_type_modifier(type_modifier_t          type_modifier);
39
40 static gras_error_t parse_statement(char                *definition,
41                                     gras_dynar_t        **dynar);
42 static gras_datadesc_type_t * parse_struct(char *definition);
43 static gras_datadesc_type_t * parse_typedef(char        *definition);
44
45 /* local functions */
46 static void parse_type_modifier(type_modifier_t         *type_modifier)  {
47   DEBUG0("Parse the modifiers");
48   do {
49     if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_STAR) {
50       DEBUG0("This is a reference");
51       type_modifier->is_ref++;
52       
53     } else if (!strcmp(gras_ddt_parse_text,"unsigned")) {
54       DEBUG0("This is an unsigned");
55       type_modifier->is_unsigned = 1;
56       
57     } else if (!strcmp(gras_ddt_parse_text,"short")) {
58       DEBUG0("This is short");
59       type_modifier->is_short = 1;
60       
61     } else if (!strcmp(gras_ddt_parse_text,"long")) {
62       DEBUG0("This is long");
63       type_modifier->is_long++; /* handle "long long" */
64       
65     } else if (!strcmp(gras_ddt_parse_text,"struct")) {
66       DEBUG0("This is a struct");
67       type_modifier->is_struct = 1;
68       
69     } else if (!strcmp(gras_ddt_parse_text,"union")) {
70       DEBUG0("This is an union");
71       type_modifier->is_union = 1;
72       
73     } else if (!strcmp(gras_ddt_parse_text,"enum")) {
74       DEBUG0("This is an enum");
75       type_modifier->is_enum = 1;
76       
77     } else {
78       DEBUG1("Done with modifiers (got %s)",gras_ddt_parse_text);
79       break;
80     }
81
82     gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump();
83     if((gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_WORD) && 
84        (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_STAR)) {
85       DEBUG1("Done with modifiers (got %s)",gras_ddt_parse_text);      
86       break;
87     }
88   } while(1);
89 }
90
91 static void print_type_modifier(type_modifier_t tm) {
92   int i;
93
94   if (tm.is_unsigned)             printf("(unsigned) ");
95   if (tm.is_short)                printf("(short) ");
96   for (i=0 ; i<tm.is_long ; i++)  printf("(long) ");
97
98   if(tm.is_struct)                printf("(struct) ");
99   if(tm.is_enum)                  printf("(enum) ");
100   if(tm.is_union)                 printf("(union) ");
101
102   for (i=0 ; i<tm.is_ref ; i++)   printf("(ref) ");
103 }
104
105 static gras_error_t parse_statement(char                *definition,
106                                     gras_dynar_t        **dynar) {
107   gras_error_t errcode;
108   char buffname[512];
109
110   identifier_t identifier;
111   type_modifier_t tm;
112
113   int starred = 0;
114   int expect_id_separator = 0;
115
116   gras_dynar_reset(*dynar);
117   memset(&identifier,0,sizeof(identifier));
118   memset(&tm,0,sizeof(tm));
119     
120   gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump();
121   if(gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_RP) {
122     return mismatch_error; /* end of the englobing structure or union */
123   }
124   
125   if (GRAS_LOG_ISENABLED(parse,gras_log_priority_debug)) {
126     int colon_pos;
127     for (colon_pos = gras_ddt_parse_col_pos;
128          definition[colon_pos] != ';';
129          colon_pos++);
130     definition[colon_pos] = '\0';
131     DEBUG3("Parse the statement \"%s%s;\" (col_pos=%d)",
132            gras_ddt_parse_text,
133            definition+gras_ddt_parse_col_pos,
134            gras_ddt_parse_col_pos);
135     definition[colon_pos] = ';';
136   }
137
138   if(gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_WORD) {
139     ERROR2("Unparsable symbol: found a typeless statement (got '%s' instead). Definition was:\n%s",
140            gras_ddt_parse_text, definition);
141     gras_abort();
142   }
143
144   /**** get the type modifier of this statement ****/
145   parse_type_modifier(&tm);
146
147   /*  FIXME: This does not detect recursive definitions at all? */
148   if (tm.is_union || tm.is_enum || tm.is_struct) {
149     ERROR1("Cannot handle recursive type definition yet. Definition was:\n%s",
150            definition);
151     gras_abort();
152   }
153
154   /**** get the base type, giving "short a" the needed love ****/
155   if (!tm.is_union &&
156       !tm.is_enum  && 
157       !tm.is_struct &&
158
159       (tm.is_short || tm.is_long || tm.is_unsigned) &&
160
161       strcmp(gras_ddt_parse_text,"char") && 
162       strcmp(gras_ddt_parse_text,"float") && 
163       strcmp(gras_ddt_parse_text,"double") && 
164       strcmp(gras_ddt_parse_text,"int") ) {
165
166     /* bastard user, they omited "int" ! */
167     identifier.type_name=strdup("int");
168     DEBUG0("the base type is 'int', which were omited");
169   } else {
170     identifier.type_name=strdup(gras_ddt_parse_text);
171     DEBUG1("the base type is '%s'",identifier.type_name);
172     gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump(); 
173   }
174
175   /**** build the base type for latter use ****/
176   if (tm.is_union) {
177     ERROR1("Cannot handle union yet (need annotation to get the callback). Definition was:\n%s",
178             definition);
179     gras_abort();
180
181   } else if (tm.is_enum) {
182     ERROR1("Cannot handle enum yet. Definition was:\n%s",
183            definition);
184     gras_abort();
185
186   } else if (tm.is_struct) {
187     sprintf(buffname,"struct %s",identifier.type_name);
188     identifier.type = gras_datadesc_by_name(buffname);
189     if (!identifier.type) {
190       TRY(gras_datadesc_declare_struct(buffname,&identifier.type));
191     }
192
193   } else if (tm.is_unsigned) {
194     if (!strcmp(identifier.type_name,"int")) {
195       if (tm.is_long == 2) {
196         identifier.type = gras_datadesc_by_name("unsigned long long int");
197       } else if (tm.is_long) {
198         identifier.type = gras_datadesc_by_name("unsigned long int");
199       } else if (tm.is_short) {
200         identifier.type = gras_datadesc_by_name("unsigned short int");
201       } else {
202         identifier.type = gras_datadesc_by_name("unsigned int");
203       }
204
205     } else if (!strcmp(identifier.type_name, "char")) {
206       identifier.type = gras_datadesc_by_name("unsigned char");
207
208     } else { /* impossible, gcc parses this shit before us */
209       RAISE_IMPOSSIBLE;
210     }
211     
212   } else if (!strcmp(identifier.type_name, "float")) {
213     /* no modificator allowed by gcc */
214     identifier.type = gras_datadesc_by_name("float");
215
216   } else if (!strcmp(identifier.type_name, "double")) {
217     if (tm.is_long) {
218       ERROR0("long double not portable and thus not handled");
219       gras_abort();
220     }
221     identifier.type = gras_datadesc_by_name("double");
222
223   } else { /* signed integer elemental */
224     if (!strcmp(identifier.type_name,"int")) {
225       if (tm.is_long == 2) {
226         identifier.type = gras_datadesc_by_name("signed long long int");
227       } else if (tm.is_long) {
228         identifier.type = gras_datadesc_by_name("signed long int");
229       } else if (tm.is_short) {
230         identifier.type = gras_datadesc_by_name("signed short int");
231       } else {
232         identifier.type = gras_datadesc_by_name("int");
233       }
234
235     } else if (!strcmp(identifier.type_name, "char")) {
236       identifier.type = gras_datadesc_by_name("char");
237
238     } else { /* impossible */
239       ERROR3("The Impossible did happen at %d:%d of :\n%s",
240              gras_ddt_parse_line_pos,gras_ddt_parse_char_pos,definition);
241       gras_abort();
242     }
243     
244   } 
245
246   if (tm.is_ref) {
247     ERROR1("Cannot handle references yet (need annotations), sorry. Definition was:\n%s",
248            definition);
249     gras_abort();
250     /* Should build ref on the current identifier.type (beware of int****) */
251   }
252   
253   /**** look for the symbols of this type ****/
254   for(expect_id_separator = 0;
255
256       ((gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_EMPTY) &&
257        (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_SEMI_COLON)) ; 
258
259       gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump()          ) {   
260
261     if(expect_id_separator) {
262       if(gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_COLON) {
263         expect_id_separator = 0;
264         continue;
265
266       } else if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_LB) {
267         /* Handle fixed size arrays */
268         gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump();
269         if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_RB) {
270           ERROR3("Cannot dynamically sized array at %d:%d of %s",
271                  gras_ddt_parse_line_pos,gras_ddt_parse_char_pos,
272                  definition);
273           gras_abort();
274         } else if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_WORD) {
275           char *end;
276           long int size=strtol(gras_ddt_parse_text, &end, 10);
277           identifier_t array;
278
279           if (end == gras_ddt_parse_text ||
280               *end != '\0') {
281             ERROR4("Unparsable size of array at %d:%d of %s. Found '%c', expected '\\0'",
282                    gras_ddt_parse_line_pos,gras_ddt_parse_char_pos,
283                    definition,*end);
284             gras_abort();
285           }
286           /* replace the previously pushed type to an array of it */
287           gras_dynar_pop(*dynar,&identifier.type);
288           array.type_name=malloc(strlen(identifier.type->name)+20);
289           DEBUG2("Array specification (size=%ld, elm='%s'), change pushed type",
290                  size,identifier.type_name);
291           sprintf(array.type_name,"%s[%ld]",identifier.type_name,size);
292           free(identifier.type_name);
293           array.type = gras_datadesc_by_name(array.type_name);
294           if (array.type==NULL) {
295             TRY(gras_datadesc_declare_array_fixed(array.type_name,
296                                                   identifier.type,
297                                                   size, &array.type));
298           }
299           array.name = identifier.name;
300           TRY(gras_dynar_push(*dynar,&array));
301
302           /* eat the closing bracket */
303           gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump();
304           if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_RB) {
305             ERROR3("Unparsable size of array at %d:%d of %s",
306                    gras_ddt_parse_line_pos,gras_ddt_parse_char_pos,
307                    definition);
308             gras_abort();
309           }
310         DEBUG1("Fixed size array, size=%ld",size);
311         continue;
312         } else {
313           ERROR3("Unparsable size of array at %d:%d of %s",
314                  gras_ddt_parse_line_pos,gras_ddt_parse_char_pos,
315                  definition);
316           gras_abort();
317         }
318       } else {
319         ERROR2("Unparsable symbol: Expected a comma (','), got '%s' instead. Definition was:\n%s",
320                 gras_ddt_parse_text, definition);
321         gras_abort();
322       }
323     } else if(gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_COLON) {
324       ERROR1("Unparsable symbol: Unexpected comma (','). Definition was:\n%s",
325              definition);
326       gras_abort();
327     }
328
329     if(gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_STAR) {
330       starred = 1;
331     }
332
333     /* found a symbol name. Build the type and push it to dynar */
334     if(gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_WORD) {
335       if (starred) {
336         /* FIXME: Build a ref or array on the base type */
337         ERROR1("Cannot handle references yet (need annotations), sorry. Definition was:\n%s",
338                definition);
339         gras_abort();
340       }
341       identifier.name=strdup(gras_ddt_parse_text);
342       DEBUG1("Found the identifier \"%s\"",identifier.name);
343       
344       TRY(gras_dynar_push(*dynar, &identifier));
345       starred = 0;
346       expect_id_separator = 1;
347       continue;
348     } 
349
350     ERROR3("Unparasable symbol (maybe a def struct in a def struct or so) at %d:%d of\n%s",
351            gras_ddt_parse_line_pos,gras_ddt_parse_char_pos,
352            definition);
353     gras_abort();
354   }
355
356   DEBUG0("End of this statement");
357   return no_error;
358 }
359
360 static gras_datadesc_type_t *parse_struct(char *definition) {
361
362   gras_error_t errcode;
363   char buffname[32];
364   static int anonymous_struct=0;
365
366   gras_dynar_t *fields;
367
368   identifier_t field;
369   int i;
370
371   gras_datadesc_type_t *struct_type;
372
373   errcode=gras_dynar_new(&fields,sizeof(identifier_t),NULL);
374   if (errcode != no_error) 
375     return NULL;
376
377   /* Create the struct descriptor */
378   if (gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_WORD) {
379     TRYFAIL(gras_datadesc_declare_struct(gras_ddt_parse_text,&struct_type));
380     DEBUG1("Parse the struct '%s'", gras_ddt_parse_text);
381     gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump();
382   } else {
383     sprintf(buffname,"anonymous struct %d",anonymous_struct++); 
384     DEBUG1("Parse the anonymous struct nb %d", anonymous_struct);
385     TRYFAIL(gras_datadesc_declare_struct(buffname,&struct_type));
386   }
387
388   if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_LP) {
389     ERROR2("Unparasable symbol: Expecting struct definition, but got %s instead of '{'. The definition was:\n%s",
390             gras_ddt_parse_text,definition);
391     gras_abort();
392   }
393
394   /* Parse the fields */
395   for (errcode=parse_statement(definition,&fields);
396        errcode == no_error                            ;
397        errcode=parse_statement(definition,&fields)) {
398     
399     DEBUG1("This statement contained %d fields",gras_dynar_length(fields));
400     gras_dynar_foreach(fields,i, field) {
401       DEBUG1("Append field %s",field.name);      
402       TRYFAIL(gras_datadesc_declare_struct_append(struct_type,field.name,
403                                                   field.type));
404       free(field.name);
405       free(field.type_name);
406     }
407   }
408   gras_datadesc_declare_struct_close(struct_type);
409   if (errcode != mismatch_error)
410     return NULL; /* FIXME: LEAK! */
411
412   /* terminates */
413   if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_RP) {
414     ERROR2("Unparasable symbol: Expected '}' at the end of struct definition, got '%s'. The definition was:\n%s",
415            gras_ddt_parse_text,definition);
416     gras_abort();
417   } 
418
419   gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump();
420
421   gras_dynar_free(fields);
422   return struct_type;
423 }
424
425 static gras_datadesc_type_t * parse_typedef(char *definition) {
426
427   type_modifier_t tm;
428
429   gras_datadesc_type_t *struct_desc=NULL;
430   gras_datadesc_type_t *typedef_desc=NULL;
431
432   memset(&tm,0,sizeof(tm));
433
434   /* get the aliased type */
435   parse_type_modifier(&tm);
436
437   if (tm.is_struct) {
438     struct_desc = parse_struct(definition);
439   }
440
441   parse_type_modifier(&tm);
442
443   if (tm.is_ref) {
444     ERROR1("Cannot handle reference without annotation. Definition was:\n%s",
445            definition);
446     gras_abort();
447   }    
448
449   /* get the aliasing name */
450   if (gras_ddt_parse_tok_num != GRAS_DDT_PARSE_TOKEN_WORD) {
451     ERROR2("Unparsable typedef: Expected the alias name, and got '%s'.\n%s",
452            gras_ddt_parse_text,definition);
453     gras_abort();
454   }
455   
456   /* (FIXME: should) build the alias */
457   ERROR1("Cannot handle typedef yet. Definition was: \n%s",definition);
458   gras_abort();
459
460   //  identifier.type=gras_ddt_type_new_typedef(bag, NULL, strdup(gras_ddt_parse_text) );
461   
462   return typedef_desc;
463 }
464
465
466 /**
467  * gras_datadesc_declare_parse:
468  *
469  * Create a datadescription from the result of parsing the C type description
470  */
471 gras_datadesc_type_t *
472 gras_datadesc_parse(const char            *name,
473                     const char            *C_statement) {
474
475   gras_datadesc_type_t * res=NULL;
476   char *definition;
477   int semicolon_count=0;
478   int def_count,C_count;
479   /* reput the \n in place for debug */
480   for (C_count=0; C_statement[C_count] != '\0'; C_count++)
481     if (C_statement[C_count] == ';' || C_statement[C_count] == '{')
482       semicolon_count++;
483   definition = malloc(C_count + semicolon_count + 1);
484   for (C_count=0,def_count=0; C_statement[C_count] != '\0'; C_count++) {
485     definition[def_count++] = C_statement[C_count];
486     if (C_statement[C_count] == ';' || C_statement[C_count] == '{') {
487       definition[def_count++] = '\n';
488     }
489   }
490   definition[def_count] = '\0';
491
492   /* init */ 
493   VERB2("_gras_ddt_type_parse(%s) -> %d chars",definition, def_count);
494   gras_ddt_parse_pointer_string_init(definition);
495
496   /* Do I have a typedef, or a raw struct ?*/
497   gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump();
498   
499   if ((gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_WORD) && (!strcmp(gras_ddt_parse_text,"struct"))) {
500     gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump();
501     res = parse_struct(definition);
502       
503   } else if ((gras_ddt_parse_tok_num == GRAS_DDT_PARSE_TOKEN_WORD) && (!strcmp(gras_ddt_parse_text,"typedef"))) {
504     gras_ddt_parse_tok_num = gras_ddt_parse_lex_n_dump();
505     res = parse_typedef(definition);
506
507   } else {
508     ERROR1("Failed to parse the following symbol (not a struct neither a typedef) :\n%s",definition);    
509     gras_abort();
510   }
511
512   gras_ddt_parse_pointer_string_close();
513   VERB0("end of _gras_ddt_type_parse()");
514   free(definition);
515   /* register it under the name provided as symbol */
516   if (strcmp(res->name,name)) {
517     ERROR2("In GRAS_DEFINE_TYPE, the provided symbol (here %s) must be the C type name (here %s)",
518            name,res->name);
519     gras_abort();
520   }    
521   return res;
522 }
523
524