mv gs/ DataDesc/ ; change the prefix of parsing functions from gs_parse to gras_datad...

[simgrid.git] / src / gras / DataDesc / parse.c

diff --git a/src/gras/DataDesc/parse.c b/src/gras/DataDesc/parse.c
index 20b9cb5..66b3bca 100644 (file)
--- a/src/gras/DataDesc/parse.c
+++ b/src/gras/DataDesc/parse.c
@@ -4,8 +4,8 @@
 
 /* Authors: Arnaud Legrand, Martin Quinson            */
 
-#include "gs/gs_private.h"
-#include "gs/parse.yy.h"
+#include "DataDesc/gs_private.h"
+#include "DataDesc/parse.yy.h"
 
 GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(NDR_parse,NDR);
 
@@ -21,7 +21,7 @@ typedef struct s_type_modifier{
   short is_ref;
 } type_modifier_t;
  
-extern char *gs_parse_text;
+extern char *gras_datadesc_parse_text;
 
 /* prototypes */
 static void parse_type_modifier(type_modifier_t        *type_modifier);
@@ -38,31 +38,31 @@ static gras_type_t * parse_typedef(gras_type_bag_t  *p_bag,
 /* local functions */
 static void parse_type_modifier(type_modifier_t        *type_modifier)  {
   do {
-    if (gs_parse_tok_num == GS_PARSE_TOKEN_STAR) {
+    if (gras_datadesc_parse_tok_num == GRAS_DATADESC_PARSE_TOKEN_STAR) {
       DEBUG0("This is a reference");
       type_modifier->is_ref++;
 
-    } else if (!strcmp(gs_parse_text,"unsigned")) {
+    } else if (!strcmp(gras_datadesc_parse_text,"unsigned")) {
       DEBUG0("This is an unsigned");
       type_modifier->is_unsigned = 1;
 
-    } else if (!strcmp(gs_parse_text,"short")) {
+    } else if (!strcmp(gras_datadesc_parse_text,"short")) {
       DEBUG0("This is short");
       type_modifier->is_short = 1;
 
-    } else if (!strcmp(gs_parse_text,"long")) {
+    } else if (!strcmp(gras_datadesc_parse_text,"long")) {
       DEBUG0("This is long");
       type_modifier->is_long++; /* "long long" needs love */
 
-    } else if (!strcmp(gs_parse_text,"struct")) {
+    } else if (!strcmp(gras_datadesc_parse_text,"struct")) {
       DEBUG0("This is a struct");
       type_modifier->is_struct = 1;
 
-    } else if (!strcmp(gs_parse_text,"union")) {
+    } else if (!strcmp(gras_datadesc_parse_text,"union")) {
       DEBUG0("This is an union");
       type_modifier->is_union = 1;
 
-    } else if (!strcmp(gs_parse_text,"enum")) {
+    } else if (!strcmp(gras_datadesc_parse_text,"enum")) {
       DEBUG0("This is an enum");
       type_modifier->is_enum = 1;
 
@@ -71,9 +71,9 @@ static void parse_type_modifier(type_modifier_t       *type_modifier)  {
     }
     
 
-    gs_parse_tok_num = gs_parse_lex_n_dump();
-    if((gs_parse_tok_num != GS_PARSE_TOKEN_WORD) && 
-       (gs_parse_tok_num != GS_PARSE_TOKEN_STAR)) 
+    gras_datadesc_parse_tok_num = gras_datadesc_parse_lex_n_dump();
+    if((gras_datadesc_parse_tok_num != GRAS_DATADESC_PARSE_TOKEN_WORD) && 
+       (gras_datadesc_parse_tok_num != GRAS_DATADESC_PARSE_TOKEN_STAR)) 
       break;
   } while(1);
 }
@@ -112,17 +112,17 @@ static gras_error_t parse_statement(gras_type_bag_t       *bag,
   gras_dynar_reset(*dynar);
   memset(&tm,0,sizeof(tm));
     
-  gs_parse_tok_num = gs_parse_lex_n_dump();
-  if(gs_parse_tok_num == GS_PARSE_TOKEN_RP) {
+  gras_datadesc_parse_tok_num = gras_datadesc_parse_lex_n_dump();
+  if(gras_datadesc_parse_tok_num == GRAS_DATADESC_PARSE_TOKEN_RP) {
     return mismatch_error; /* end of the englobing structure or union */
   }
   DEBUG0("Parse a new statement.");
 
 
-  if(gs_parse_tok_num != GS_PARSE_TOKEN_WORD) {
+  if(gras_datadesc_parse_tok_num != GRAS_DATADESC_PARSE_TOKEN_WORD) {
     fprintf(stderr,
            "Unparsable symbol: found a typeless statement (got '%s' instead). Definition was:\n%s\n",
-           gs_parse_text, definition);
+           gras_datadesc_parse_text, definition);
     abort();
   }
 
@@ -144,18 +144,18 @@ static gras_error_t parse_statement(gras_type_bag_t       *bag,
 
       (tm.is_short || tm.is_long || tm.is_unsigned) &&
 
-      strcmp(gs_parse_text,"char") && 
-      strcmp(gs_parse_text,"float") && 
-      strcmp(gs_parse_text,"double") && 
-      strcmp(gs_parse_text,"int") ) {
+      strcmp(gras_datadesc_parse_text,"char") && 
+      strcmp(gras_datadesc_parse_text,"float") && 
+      strcmp(gras_datadesc_parse_text,"double") && 
+      strcmp(gras_datadesc_parse_text,"int") ) {
 
     /* bastard user, they omited "int" ! */
     base_type=strdup("int");
     DEBUG0("the base type is 'int', which were omited");
   } else {
-    base_type=strdup(gs_parse_text);
+    base_type=strdup(gras_datadesc_parse_text);
     DEBUG1("the base type is '%s'",base_type);
-    gs_parse_tok_num = gs_parse_lex_n_dump(); 
+    gras_datadesc_parse_tok_num = gras_datadesc_parse_lex_n_dump(); 
   }
 
   /**** build the base type for latter use ****/
@@ -194,7 +194,7 @@ static gras_error_t parse_statement(gras_type_bag_t *bag,
     }
 
     /* Let's code like Alvin ;) */
-#define gs_parse_get_or_create(name,func)               \
+#define gras_datadesc_parse_get_or_create(name,func)               \
    (bag->bag_ops->get_type_by_name(bag, NULL, #name) ?  \
     bag->bag_ops->get_type_by_name(bag, NULL, #name) :  \
     gs_type_new_##func##_elemental(bag, NULL,           \
@@ -204,17 +204,17 @@ static gras_error_t parse_statement(gras_type_bag_t       *bag,
   } else if (tm.is_unsigned) {
     if (!strcmp(base_type,"int")) {
       if (tm.is_long == 2) {
-       res = gs_parse_get_or_create(unsigned long long int,unsigned_integer);
+       res = gras_datadesc_parse_get_or_create(unsigned long long int,unsigned_integer);
       } else if (tm.is_long) {
-       res = gs_parse_get_or_create(unsigned long int,unsigned_integer);
+       res = gras_datadesc_parse_get_or_create(unsigned long int,unsigned_integer);
       } else if (tm.is_short) {
-       res = gs_parse_get_or_create(unsigned short int,unsigned_integer);
+       res = gras_datadesc_parse_get_or_create(unsigned short int,unsigned_integer);
       } else {
-       res = gs_parse_get_or_create(unsigned int,unsigned_integer);
+       res = gras_datadesc_parse_get_or_create(unsigned int,unsigned_integer);
       }
 
     } else if (!strcmp(base_type, "char")) {
-      res = gs_parse_get_or_create(unsigned char,unsigned_integer);
+      res = gras_datadesc_parse_get_or_create(unsigned char,unsigned_integer);
 
     } else { /* impossible, gcc parses this shit before us */
       abort(); 
@@ -222,22 +222,22 @@ static gras_error_t parse_statement(gras_type_bag_t       *bag,
     
   } else if (!strcmp(base_type, "float")) {
     /* no modificator allowed by gcc */
-    res = gs_parse_get_or_create(float,floating_point);
+    res = gras_datadesc_parse_get_or_create(float,floating_point);
 
   } else { /* signed integer elemental */
     if (!strcmp(base_type,"int")) {
       if (tm.is_long == 2) {
-       res = gs_parse_get_or_create(signed long long int,signed_integer);
+       res = gras_datadesc_parse_get_or_create(signed long long int,signed_integer);
       } else if (tm.is_long) {
-       res = gs_parse_get_or_create(signed long int,signed_integer);
+       res = gras_datadesc_parse_get_or_create(signed long int,signed_integer);
       } else if (tm.is_short) {
-       res = gs_parse_get_or_create(signed short int,signed_integer);
+       res = gras_datadesc_parse_get_or_create(signed short int,signed_integer);
       } else {
-       res = gs_parse_get_or_create(int,unsigned_integer);
+       res = gras_datadesc_parse_get_or_create(int,unsigned_integer);
       }
 
     } else if (!strcmp(base_type, "char")) {
-      res = gs_parse_get_or_create(char,unsigned_integer);
+      res = gras_datadesc_parse_get_or_create(char,unsigned_integer);
 
     } else { /* impossible */
       abort(); 
@@ -257,34 +257,34 @@ static gras_error_t parse_statement(gras_type_bag_t       *bag,
   expect_a_colon = 0;
   for(          /* no initialization */                 ; 
 
-      ((gs_parse_tok_num != GS_PARSE_TOKEN_EMPTY) &&
-       (gs_parse_tok_num != GS_PARSE_TOKEN_SEMI_COLON)) ; 
+      ((gras_datadesc_parse_tok_num != GRAS_DATADESC_PARSE_TOKEN_EMPTY) &&
+       (gras_datadesc_parse_tok_num != GRAS_DATADESC_PARSE_TOKEN_SEMI_COLON)) ; 
 
-      gs_parse_tok_num = gs_parse_lex_n_dump()          ) {   
+      gras_datadesc_parse_tok_num = gras_datadesc_parse_lex_n_dump()          ) {   
 
     if(expect_a_colon) {
-      if(gs_parse_tok_num == GS_PARSE_TOKEN_COLON) {
+      if(gras_datadesc_parse_tok_num == GRAS_DATADESC_PARSE_TOKEN_COLON) {
         expect_a_colon = 0;
         continue;
       } else {
        fprintf(stderr,
                "Unparsable symbol: Expected a comma (','), got '%s' instead. Definition was:\n%s\n",
-               gs_parse_text, definition);
+               gras_datadesc_parse_text, definition);
        abort();
       }
-    } else if(gs_parse_tok_num == GS_PARSE_TOKEN_COLON) {
+    } else if(gras_datadesc_parse_tok_num == GRAS_DATADESC_PARSE_TOKEN_COLON) {
       fprintf(stderr,
              "Unparsable symbol: Unexpected comma (','). Definition was:\n%s\n",
              definition);
       abort();
     }
 
-    if(gs_parse_tok_num == GS_PARSE_TOKEN_STAR) {
+    if(gras_datadesc_parse_tok_num == GRAS_DATADESC_PARSE_TOKEN_STAR) {
       starred = 1;
     }
 
     /* found a symbol name. Build the type and push it to dynar */
-    if(gs_parse_tok_num == GS_PARSE_TOKEN_WORD) {
+    if(gras_datadesc_parse_tok_num == GRAS_DATADESC_PARSE_TOKEN_WORD) {
       if (starred) {
        /* FIXME: Build a ref or array on the base type */
        fprintf(stderr,
@@ -292,7 +292,7 @@ static gras_error_t parse_statement(gras_type_bag_t *bag,
                definition);
        abort();
       }
-      DEBUG1("Encountered the variable (field?) %s",gs_parse_text);
+      DEBUG1("Encountered the variable (field?) %s",gras_datadesc_parse_text);
 
       TRY(gras_dynar_push(*dynar, &gs_type_copy(base_type)));
       starred = 0;
@@ -332,20 +332,20 @@ static gras_type_t *parse_struct(gras_type_bag_t  *bag,
   */
 
   /* Create the struct descriptor */
-  if (gs_parse_tok_num == GS_PARSE_TOKEN_WORD) {
-    struct_type = gs_type_new_struct(bag,NULL, gs_parse_text);
-    DEBUG1("Parse the struct '%s'", gs_parse_text);
-    gs_parse_tok_num = gs_parse_lex_n_dump();
+  if (gras_datadesc_parse_tok_num == GRAS_DATADESC_PARSE_TOKEN_WORD) {
+    struct_type = gs_type_new_struct(bag,NULL, gras_datadesc_parse_text);
+    DEBUG1("Parse the struct '%s'", gras_datadesc_parse_text);
+    gras_datadesc_parse_tok_num = gras_datadesc_parse_lex_n_dump();
   } else {
     sprintf(buffname,"anonymous struct %d",anonymous_struct++); 
     DEBUG1("Parse the anonymous struct nb %d", anonymous_struct);
     struct_type = gs_type_new_struct(bag,NULL,buffname);
   }
 
-  if (gs_parse_tok_num != GS_PARSE_TOKEN_LP) {
+  if (gras_datadesc_parse_tok_num != GRAS_DATADESC_PARSE_TOKEN_LP) {
     fprintf(stderr,
            "Unparasable symbol: I looked for a struct definition, but got %s instead of '{'. The definition was:\n%s\n",
-           gs_parse_text,definition);
+           gras_datadesc_parse_text,definition);
     abort();
   }
 
@@ -367,14 +367,14 @@ static gras_type_t *parse_struct(gras_type_bag_t  *bag,
     return NULL; /* FIXME: LEAK! */
 
   /* terminates */
-  if (gs_parse_tok_num != GS_PARSE_TOKEN_RP) {
+  if (gras_datadesc_parse_tok_num != GRAS_DATADESC_PARSE_TOKEN_RP) {
     fprintf(stderr,
            "Unparasable symbol: Expected '}' at the end of struct definition, got '%s'. The definition was:\n%s\n",
-           gs_parse_text,definition);
+           gras_datadesc_parse_text,definition);
     abort();
   } 
 
-  gs_parse_tok_num = gs_parse_lex_n_dump();
+  gras_datadesc_parse_tok_num = gras_datadesc_parse_lex_n_dump();
 
   gras_dynar_free(fields);
   return struct_type;
@@ -407,10 +407,10 @@ static gras_type_t * parse_typedef(gras_type_bag_t        *bag,
   }    
 
   /* get the aliasing name */
-  if (gs_parse_tok_num != GS_PARSE_TOKEN_WORD) {
+  if (gras_datadesc_parse_tok_num != GRAS_DATADESC_PARSE_TOKEN_WORD) {
     fprintf(stderr,
            "Unparsable typedef: Expected the alias name, and got '%s'.\n%s\n",
-           gs_parse_text,definition);
+           gras_datadesc_parse_text,definition);
     abort();
   }
   
@@ -418,7 +418,7 @@ static gras_type_t * parse_typedef(gras_type_bag_t  *bag,
   fprintf(stderr, "Cannot handle typedef yet (need love from grassouillet), sorry. Definition was: \n%s\n",definition);
   abort();
 
-  //  res=gs_type_new_typedef(bag, NULL, strdup(gs_parse_text) );
+  //  res=gs_type_new_typedef(bag, NULL, strdup(gras_datadesc_parse_text) );
   
   return typedef_desc;
 }
@@ -432,17 +432,17 @@ _gs_type_parse(gras_type_bag_t    *bag,
 
   /* init */ 
   DEBUG1("_gs_type_parse(%s)",definition);
-  gs_parse_pointer_string_init(definition);
+  gras_datadesc_parse_pointer_string_init(definition);
 
   /* Do I have a typedef, or a raw struct ?*/
-  gs_parse_tok_num = gs_parse_lex_n_dump();
+  gras_datadesc_parse_tok_num = gras_datadesc_parse_lex_n_dump();
   
-  if ((gs_parse_tok_num == GS_PARSE_TOKEN_WORD) && (!strcmp(gs_parse_text,"struct"))) {
-    gs_parse_tok_num = gs_parse_lex_n_dump();
+  if ((gras_datadesc_parse_tok_num == GRAS_DATADESC_PARSE_TOKEN_WORD) && (!strcmp(gras_datadesc_parse_text,"struct"))) {
+    gras_datadesc_parse_tok_num = gras_datadesc_parse_lex_n_dump();
     res = parse_struct(bag,definition);
       
-  } else if ((gs_parse_tok_num == GS_PARSE_TOKEN_WORD) && (!strcmp(gs_parse_text,"typedef"))) {
-    gs_parse_tok_num = gs_parse_lex_n_dump();
+  } else if ((gras_datadesc_parse_tok_num == GRAS_DATADESC_PARSE_TOKEN_WORD) && (!strcmp(gras_datadesc_parse_text,"typedef"))) {
+    gras_datadesc_parse_tok_num = gras_datadesc_parse_lex_n_dump();
     res = parse_typedef(bag,definition);
 
   } else {
@@ -450,7 +450,7 @@ _gs_type_parse(gras_type_bag_t      *bag,
     abort();
   }
 
-  gs_parse_pointer_string_close();
+  gras_datadesc_parse_pointer_string_close();
   DEBUG1("end of _gs_type_parse(%s)",definition);
 
   return res;