ltt/branches/poly/ltt/parser.c

   1 /*
   2
   3 parser.c: Generate helper declarations and functions to trace events
   4   from an event description file.
   5
   6             Copyright (C) 2005, Mathieu Desnoyers
   7       Copyright (C) 2002, Xianxiu Yang
   8       Copyright (C) 2002, Michel Dagenais
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; version 2 of the License.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21 */
  22
  23 /* This program reads the ".xml" event definitions input files
  24    and constructs structure for each event.
  25
  26    The program uses a very simple tokenizer, called from a hand written
  27    recursive descent parser to fill a data structure describing the events.
  28    The result is a sequence of events definitions which refer to type
  29    definitions.
  30
  31    A table of named types is maintained to allow refering to types by name
  32    when the same type is used at several places. Finally a sequence of
  33    all types is maintained to facilitate the freeing of all type
  34    information when the processing of an ".xml" file is finished. */
  35
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <stdio.h>
  39 #include <stdarg.h>
  40 #include <linux/errno.h>
  41 #include <assert.h>
  42 #include <ctype.h>
  43
  44 #include "parser.h"
  45
  46
  47 char *intOutputTypes[] = {
  48   "int8_t", "int16_t", "int32_t", "int64_t" };
  49
  50 char *uintOutputTypes[] = {
  51   "uint8_t", "uint16_t", "uint32_t", "uint64_t" };
  52
  53 char *floatOutputTypes[] = {
  54   "undef", "undef", "float", "double" };
  55
  56
  57
  58
  59 /* helper function  */
  60 void strupper(char *string)
  61 {
  62   char *ptr = string;
  63
  64   while(*ptr != '\0') {
  65     *ptr = toupper(*ptr);
  66                 ptr++;
  67   }
  68 }
  69
  70
  71 int getSizeindex(unsigned int value)
  72 {
  73   switch(value) {
  74     case 1:
  75       return 0;
  76     case 2:
  77       return 1;
  78     case 4:
  79       return 2;
  80     case 8:
  81       return 3;
  82     default:
  83       printf("Error : unknown value size %d\n", value);
  84       exit(-1);
  85   }
  86 }
  87
  88 /*****************************************************************************
  89  *Function name
  90  *    getSize    : translate from string to integer
  91  *Input params
  92  *    in         : input file handle
  93  *Return values
  94  *    size
  95  *****************************************************************************/
  96
  97 unsigned long long int getSize(parse_file_t *in)
  98 {
  99   char *token, *token2;
 100   unsigned long long int ret;
 101
 102   token = getToken(in);
 103
 104
 105   if(in->type == QUOTEDSTRING) {
 106     in->type = NUMBER;
 107     token2 = token;
 108     do {
 109        if (!isdigit(*token2)) {
 110           in->type = QUOTEDSTRING;
 111           break;
 112                                 }
 113     } while (*(++token2) != '\0');
 114   }
 115
 116   if(in->type == NUMBER) {
 117                 ret = strtoull(token, NULL, 0);
 118   } else {
 119                 goto error;
 120         }
 121
 122         return ret;
 123 error:
 124   in->error(in,"incorrect size specification");
 125   return -1;
 126 }
 127
 128 /*****************************************************************************
 129  *Function name
 130  *    error_callback  : print out error info
 131  *Input params
 132  *    in              : input file handle
 133  *    msg             : message to be printed
 134  ****************************************************************************/
 135
 136 void error_callback(parse_file_t *in, char *msg)
 137 {
 138   if(in)
 139     printf("Error in file %s, line %d: %s\n", in->name, in->lineno, msg);
 140   else
 141     printf("%s\n",msg);
 142   assert(0);
 143   exit(1);
 144 }
 145
 146 /*****************************************************************************
 147  *Function name
 148  *    memAlloc  : allocate memory
 149  *Input params
 150  *    size      : required memory size
 151  *return value
 152  *    void *    : pointer to allocate memory or NULL
 153  ****************************************************************************/
 154
 155 void * memAlloc(int size)
 156 {
 157   void * addr;
 158   if(size == 0) return NULL;
 159   addr = malloc(size);
 160   if(!addr){
 161     printf("Failed to allocate memory");
 162     exit(1);
 163   }
 164   return addr;
 165 }
 166
 167 /*****************************************************************************
 168  *Function name
 169  *    allocAndCopy : allocate memory and initialize it
 170  *Input params
 171  *    str          : string to be put in memory
 172  *return value
 173  *    char *       : pointer to allocate memory or NULL
 174  ****************************************************************************/
 175
 176 char *allocAndCopy(char *str)
 177 {
 178   char * addr;
 179   if(str == NULL) return NULL;
 180   addr = (char *)memAlloc(strlen(str)+1);
 181   strcpy(addr,str);
 182   return addr;
 183 }
 184
 185 /**************************************************************************
 186  * Function :
 187  *    getTypeAttributes
 188  * Description :
 189  *    Read the attribute from the input file.
 190  *
 191  * Parameters :
 192  *    in , input file handle.
 193  *    t , the type descriptor to fill.
 194  *
 195  **************************************************************************/
 196
 197 void getTypeAttributes(parse_file_t *in, type_descriptor_t *t,
 198          sequence_t * unnamed_types, table_t * named_types)
 199 {
 200   char * token;
 201   int car;
 202
 203   t->fmt = NULL;
 204   t->size = 0;
 205   t->custom_write = 0;
 206   t->network = 0;
 207
 208   while(1) {
 209     token = getToken(in);
 210     if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
 211       ungetToken(in);
 212       break;
 213     }
 214
 215     if(!strcmp("format",token)) {
 216       getEqual(in);
 217       t->fmt = allocAndCopy(getQuotedString(in));
 218     //} else if(!strcmp("name",token)) {
 219      // getEqual(in);
 220      // car = seekNextChar(in);
 221      // if(car == EOF) in->error(in,"name was expected");
 222      // else if(car == '\"') t->type_name = allocAndCopy(getQuotedString(in));
 223      // else t->type_name = allocAndCopy(getName(in));
 224     } else if(!strcmp("size",token)) {
 225       getEqual(in);
 226       t->size = getSize(in);
 227     } else if(!strcmp("custom_write", token)) {
 228       t->custom_write = 1;
 229     } else if(!strcmp("byte_order",token)) {
 230        getEqual(in);
 231        car = seekNextChar(in);
 232        if(car == EOF) in->error(in,"byte order was expected (network?)");
 233        else if(car == '\"') token = getQuotedString(in);
 234        else token = getName(in);
 235        if(!strcmp("network", token)) {
 236          t->network = 1;
 237        }
 238     } else if(!strcmp("write",token)) {
 239        getEqual(in);
 240        car = seekNextChar(in);
 241        if(car == EOF) in->error(in,"write type was expected (custom?)");
 242        else if(car == '\"') token = getQuotedString(in);
 243        else token = getName(in);
 244        if(!strcmp("custom", token)) {
 245          t->custom_write = 1;
 246        }
 247     }
 248   }
 249 }
 250
 251 /**************************************************************************
 252  * Function :
 253  *    getEventAttributes
 254  * Description :
 255  *    Read the attribute from the input file.
 256  *
 257  * Parameters :
 258  *    in , input file handle.
 259  *    ev , the event to fill.
 260  *
 261  **************************************************************************/
 262
 263 void getEventAttributes(parse_file_t *in, event_t *ev)
 264 {
 265   char * token;
 266   int car;
 267
 268   ev->name = NULL;
 269   ev->per_trace = 0;
 270   ev->per_tracefile = 0;
 271   ev->param_buffer = 0;
 272   ev->no_instrument_function = 0;
 273   ev->high_priority = 0;
 274   ev->force = 0;
 275   ev->compact_data = 0;
 276
 277   while(1) {
 278     token = getToken(in);
 279     if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
 280       ungetToken(in);
 281       break;
 282     }
 283
 284     if(!strcmp("name",token)) {
 285       getEqual(in);
 286       car = seekNextChar(in);
 287       if(car == EOF) in->error(in,"name was expected");
 288       else if(car == '\"') ev->name = allocAndCopy(getQuotedString(in));
 289       else ev->name = allocAndCopy(getName(in));
 290     } else if(!strcmp("scope", token)) {
 291       getEqual(in);
 292       car = seekNextChar(in);
 293       if(car == EOF) in->error(in,"scope was expected");
 294       else if(car == '\"') token = getQuotedString(in);
 295       else token = getName(in);
 296       if(!strcmp(token, "trace")) ev->per_trace = 1;
 297       else if(!strcmp(token, "tracefile")) ev->per_tracefile = 1;
 298     } else if(!strcmp("param", token)) {
 299       getEqual(in);
 300       car = seekNextChar(in);
 301       if(car == EOF) in->error(in,"parameter type was expected");
 302       else if(car == '\"') token = getQuotedString(in);
 303       else token = getName(in);
 304       if(!strcmp(token, "buffer")) ev->param_buffer = 1;
 305     } else if(!strcmp("attribute", token)) {
 306       getEqual(in);
 307       car = seekNextChar(in);
 308       if(car == EOF) in->error(in,"attribute was expected");
 309       else if(car == '\"') token = getQuotedString(in);
 310       else token = getName(in);
 311       if(!strcmp(token, "no_instrument_function"))
 312         ev->no_instrument_function = 1;
 313       else if(!strcmp(token, "high_priority"))
 314         ev->high_priority = 1;
 315       else if(!strcmp(token, "force"))
 316         ev->force = 1;
 317       else if(!strcmp(token, "compact_data"))
 318         ev->compact_data = 1;
 319     }
 320   }
 321 }
 322
 323 /**************************************************************************
 324  * Function :
 325  *    getFacilityAttributes
 326  * Description :
 327  *    Read the attribute from the input file.
 328  *
 329  * Parameters :
 330  *    in , input file handle.
 331  *    fac , the facility to fill.
 332  *
 333  **************************************************************************/
 334
 335 void getFacilityAttributes(parse_file_t *in, facility_t *fac)
 336 {
 337   char * token;
 338   int car;
 339
 340   fac->name = NULL;
 341   fac->arch = NULL;
 342   fac->align = 1;
 343   fac->user = 0;
 344
 345   while(1) {
 346     token = getToken(in);
 347     if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
 348       ungetToken(in);
 349       break;
 350     }
 351
 352     if(!strcmp("name",token)) {
 353       getEqual(in);
 354       car = seekNextChar(in);
 355       if(car == EOF) in->error(in,"name was expected");
 356       else if(car == '\"') fac->name = allocAndCopy(getQuotedString(in));
 357       else fac->name = allocAndCopy(getName(in));
 358                         if(!strncmp(fac->name, "user_", sizeof("user_")-1))
 359                                 fac->user = 1;
 360     } else if(!strcmp("arch", token)) {
 361       getEqual(in);
 362       car = seekNextChar(in);
 363       if(car == '\"') fac->arch = allocAndCopy(getQuotedString(in));
 364       else fac->arch = allocAndCopy(getName(in));
 365     } else if(!strcmp("align", token)) {
 366       getEqual(in);
 367       fac->align = getSize(in);
 368     }
 369
 370   }
 371 }
 372
 373 /**************************************************************************
 374  * Function :
 375  *    getFieldAttributes
 376  * Description :
 377  *    Read the attribute from the input file.
 378  *
 379  * Parameters :
 380  *    in , input file handle.
 381  *    f , the field to fill.
 382  *
 383  **************************************************************************/
 384
 385 void getFieldAttributes(parse_file_t *in, field_t *f)
 386 {
 387   char * token;
 388   int car;
 389
 390   f->name = NULL;
 391
 392   while(1) {
 393     token = getToken(in);
 394     if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
 395       ungetToken(in);
 396       break;
 397     }
 398
 399     if(!strcmp("name",token)) {
 400       getEqual(in);
 401       car = seekNextChar(in);
 402       if(car == EOF) in->error(in,"name was expected");
 403       else if(car == '\"') f->name = allocAndCopy(getQuotedString(in));
 404       else f->name = allocAndCopy(getName(in));
 405     }
 406         }
 407 }
 408
 409 char *getNameAttribute(parse_file_t *in)
 410 {
 411   char * token;
 412   char *name = NULL;
 413   int car;
 414
 415   while(1) {
 416     token = getToken(in);
 417     if(!strcmp("name",token)) {
 418       getEqual(in);
 419       car = seekNextChar(in);
 420       if(car == EOF) in->error(in,"name was expected");
 421       else if(car == '\"') name = allocAndCopy(getQuotedString(in));
 422       else name = allocAndCopy(getName(in));
 423     } else {
 424       ungetToken(in);
 425       break;
 426     }
 427
 428   }
 429   if(name == NULL) in->error(in, "Name was expected");
 430   return name;
 431 }
 432
 433
 434
 435 //for <label name=label_name value=n format="...">, value is an option
 436 //Return value : 0 : no value,   1 : has a value
 437 int getValueAttribute(parse_file_t *in, long long *value)
 438 {
 439   char * token, *token2;
 440
 441   token = getToken(in);
 442
 443   if(strcmp("/",token) == 0 || strcmp(">", token) == 0){
 444     ungetToken(in);
 445     return 0;
 446   }
 447   if(strcmp("value",token))in->error(in,"value was expected");
 448
 449   getEqual(in);
 450   token = getToken(in);
 451
 452   if(in->type == QUOTEDSTRING) {
 453     in->type = NUMBER;
 454     token2 = token;
 455     do {
 456        if (!isdigit(*token2)) {
 457           in->type = QUOTEDSTRING;
 458           break;
 459                          }
 460     } while (*(++token2) != '\0');
 461   }
 462
 463   if(in->type == NUMBER)
 464                 *value = strtoll(token, NULL, 0);
 465         else
 466                 goto error;
 467   return 1;
 468 error:
 469   in->error(in,"incorrect size specification");
 470   return 0;
 471 }
 472
 473 char * getDescription(parse_file_t *in)
 474 {
 475   long int pos;
 476   char * token, *str;
 477   int car;
 478
 479   pos = ftell(in->fp);
 480
 481   getLAnglebracket(in);
 482   token = getName(in);
 483   if(strcmp("description",token)){
 484     fseek(in->fp, pos, SEEK_SET);
 485     return NULL;
 486   }
 487
 488   getRAnglebracket(in);
 489
 490   pos = 0;
 491   while((car = getc(in->fp)) != EOF) {
 492     if(car == '<') break;
 493     if(car == '\0') continue;
 494     in->buffer[pos] = car;
 495     pos++;
 496   }
 497   if(car == EOF)in->error(in,"not a valid description");
 498   in->buffer[pos] = '\0';
 499
 500   str = allocAndCopy(in->buffer);
 501
 502   getForwardslash(in);
 503   token = getName(in);
 504   if(strcmp("description", token))in->error(in,"not a valid description");
 505   getRAnglebracket(in);
 506
 507   return str;
 508 }
 509
 510 /*****************************************************************************
 511  *Function name
 512  *    parseFacility : generate event list
 513  *Input params
 514  *    in            : input file handle
 515  *    fac           : empty facility
 516  *Output params
 517  *    fac           : facility filled with event list
 518  ****************************************************************************/
 519
 520 void parseFacility(parse_file_t *in, facility_t * fac)
 521 {
 522   char * token;
 523   event_t *ev;
 524
 525   getFacilityAttributes(in, fac);
 526   if(fac->name == NULL) in->error(in, "Attribute not named");
 527
 528   fac->capname = allocAndCopy(fac->name);
 529         strupper(fac->capname);
 530   getRAnglebracket(in);
 531
 532   fac->description = getDescription(in);
 533
 534   while(1){
 535     getLAnglebracket(in);
 536
 537     token = getToken(in);
 538     if(in->type == ENDFILE)
 539       in->error(in,"the definition of the facility is not finished");
 540
 541     if(strcmp("event",token) == 0){
 542       ev = (event_t*) memAlloc(sizeof(event_t));
 543       sequence_push(&(fac->events),ev);
 544       parseEvent(fac, in, ev, &(fac->unnamed_types), &(fac->named_types));
 545     }else if(strcmp("type",token) == 0){
 546       parseTypeDefinition(fac, in, &(fac->unnamed_types), &(fac->named_types));
 547     }else if(in->type == FORWARDSLASH){
 548       break;
 549     }else in->error(in,"event or type token expected\n");
 550   }
 551
 552   token = getName(in);
 553   if(strcmp("facility",token)) in->error(in,"not the end of the facility");
 554   getRAnglebracket(in); //</facility>
 555 }
 556
 557 /*****************************************************************************
 558  *Function name
 559  *    parseEvent    : generate event from event definition
 560  *Input params
 561  *    fac           : facility holding the event
 562  *    in            : input file handle
 563  *    ev            : new event
 564  *    unnamed_types : array of unamed types
 565  *    named_types   : array of named types
 566  *Output params
 567  *    ev            : new event (parameters are passed to it)
 568  ****************************************************************************/
 569
 570 void parseEvent(facility_t *fac, parse_file_t *in, event_t * ev, sequence_t * unnamed_types,
 571                 table_t * named_types)
 572 {
 573   char *token;
 574         field_t *f;
 575
 576   ev->fac = fac;
 577         sequence_init(&(ev->fields));
 578   //<event name=eventtype_name>
 579   getEventAttributes(in, ev);
 580   if(ev->name == NULL) in->error(in, "Event not named");
 581   getRAnglebracket(in);
 582
 583   //<description>...</description>
 584   ev->description = getDescription(in);
 585
 586         int got_end = 0;
 587         /* Events can have multiple fields. each field form at least a function
 588          * parameter of the logging function. */
 589         while(!got_end) {
 590                 getLAnglebracket(in);
 591                 token = getToken(in);
 592
 593                 switch(in->type) {
 594                 case FORWARDSLASH:      /* </event> */
 595                         token = getName(in);
 596                         if(strcmp("event",token))in->error(in,"not an event definition");
 597                         getRAnglebracket(in);  //</event>
 598                         got_end = 1;
 599                         break;
 600                 case NAME: /* a field */
 601                         if(strcmp("field",token))in->error(in,"expecting a field");
 602                         f = (field_t *)memAlloc(sizeof(field_t));
 603                         sequence_push(&(ev->fields),f);
 604                         parseFields(fac, in, f, unnamed_types, named_types, 1);
 605                         break;
 606                 default:
 607                         in->error(in, "expecting </event> or <field >");
 608                         break;
 609                 }
 610         }
 611 #if 0
 612                 if(in->type == FORWARDSLASH){ //</event> NOTHING
 613                         ev->type = NULL;
 614                 }else if(in->type == NAME){
 615                         if(strcmp("struct",token)==0 || strcmp("typeref",token)==0){
 616                                 ungetToken(in);
 617                                 ev->type = parseType(in,NULL, unnamed_types, named_types);
 618                                 if(ev->type->type != STRUCT && ev->type->type != NONE)
 619                 in->error(in,"type must be a struct");
 620                         }else in->error(in, "not a valid type");
 621
 622                         getLAnglebracket(in);
 623                         getForwardslash(in);
 624                 }else in->error(in,"not a struct type");
 625                 getLAnglebracket(in);
 626                 getForwardslash(in);
 627                 token = getName(in);
 628                 if(strcmp("event",token))in->error(in,"not an event definition");
 629                 getRAnglebracket(in);  //</event>
 630 #endif //0
 631 }
 632
 633 /*****************************************************************************
 634  *Function name
 635  *    parseField    : get field infomation from buffer
 636  *Input params
 637  *    fac           : facility holding the field
 638  *    in            : input file handle
 639  *    f             : field
 640  *    unnamed_types : array of unamed types
 641  *    named_types   : array of named types
 642  *    tag                                               : is field surrounded by a <field> </field> tag ?
 643  ****************************************************************************/
 644
 645 void parseFields(facility_t *fac, parse_file_t *in, field_t *f,
 646     sequence_t * unnamed_types,
 647                 table_t * named_types,
 648                 int tag)
 649 {
 650   char * token;
 651   f->fac = fac;
 652         if(tag) {
 653                 //<field name=field_name> <description> <type> </field>
 654                 getFieldAttributes(in, f);
 655                 if(f->name == NULL) in->error(in, "Field not named");
 656                 getRAnglebracket(in);
 657
 658                 f->description = getDescription(in);
 659         } else {
 660                 f->description = NULL;
 661         }
 662
 663   //<int size=...>
 664   getLAnglebracket(in);
 665   f->type = parseType(fac, in,NULL, unnamed_types, named_types);
 666
 667         if(tag) {
 668                 getLAnglebracket(in);
 669                 getForwardslash(in);
 670                 token = getName(in);
 671                 if(strcmp("field",token))in->error(in,"not a valid field definition");
 672                 getRAnglebracket(in); //</field>
 673         }
 674 }
 675
 676
 677 /*****************************************************************************
 678  *Function name
 679  *    parseType      : get type information, type can be :
 680  *                     Primitive:
 681  *                        int(size,fmt); uint(size,fmt); float(size,fmt);
 682  *                        string(fmt); enum(size,fmt,(label1,label2...))
 683  *                     Compound:
 684  *                        array(arraySize, type); sequence(lengthSize,type)
 685  *                        struct(field(name,type,description)...)
 686  *                     type name:
 687  *                        type(name,type)
 688  *Input params
 689  *    fac              : facility
 690  *    in               : input file handle
 691  *    inType           : a type descriptor
 692  *    unnamed_types    : array of unamed types
 693  *    named_types      : array of named types
 694  *Return values
 695  *    type_descriptor* : a type descriptor
 696  ****************************************************************************/
 697
 698 type_descriptor_t *parseType(facility_t *fac, parse_file_t *in, type_descriptor_t *inType,
 699                            sequence_t * unnamed_types, table_t * named_types)
 700 {
 701   char *token;
 702   type_descriptor_t *t;
 703         field_t *f;
 704
 705   if(inType == NULL) {
 706     t = (type_descriptor_t *) memAlloc(sizeof(type_descriptor_t));
 707     t->type_name = NULL;
 708     t->type = NONE;
 709     t->fmt = NULL;
 710     sequence_push(unnamed_types,t);
 711   }
 712   else t = inType;
 713   t->fac = fac;
 714
 715   token = getName(in);
 716
 717   if(strcmp(token,"struct") == 0) {
 718     t->type = STRUCT;
 719     getTypeAttributes(in, t, unnamed_types, named_types);
 720     getRAnglebracket(in); //<struct>
 721     getLAnglebracket(in); //<field name=..>
 722     token = getToken(in);
 723     sequence_init(&(t->fields));
 724     while(strcmp("field",token) == 0){
 725                         f = (field_t *)memAlloc(sizeof(field_t));
 726                         sequence_push(&(t->fields),f);
 727
 728       parseFields(fac, in, f, unnamed_types, named_types, 1);
 729
 730       //next field
 731       getLAnglebracket(in);
 732       token = getToken(in);
 733     }
 734     if(strcmp("/",token))in->error(in,"not a valid structure definition");
 735     token = getName(in);
 736     if(strcmp("struct",token)!=0)
 737       in->error(in,"not a valid structure definition");
 738     getRAnglebracket(in); //</struct>
 739   }
 740   else if(strcmp(token,"union") == 0) {
 741     t->type = UNION;
 742     getTypeAttributes(in, t, unnamed_types, named_types);
 743     getRAnglebracket(in); //<union>
 744
 745     getLAnglebracket(in); //<field name=..>
 746     token = getToken(in);
 747     sequence_init(&(t->fields));
 748     while(strcmp("field",token) == 0){
 749                         f = (field_t *)memAlloc(sizeof(field_t));
 750                         sequence_push(&(t->fields),f);
 751       parseFields(fac, in, f, unnamed_types, named_types, 1);
 752
 753       //next field
 754       getLAnglebracket(in);
 755       token = getToken(in);
 756     }
 757     if(strcmp("/",token))in->error(in,"not a valid union definition");
 758     token = getName(in);
 759     if(strcmp("union",token)!=0)
 760       in->error(in,"not a valid union definition");
 761     getRAnglebracket(in); //</union>
 762   }
 763   else if(strcmp(token,"array") == 0) {
 764     t->type = ARRAY;
 765     sequence_init(&(t->fields));
 766     getTypeAttributes(in, t, unnamed_types, named_types);
 767     if(t->size == 0) in->error(in, "Array has empty size");
 768     getForwardslash(in);
 769     getRAnglebracket(in); //<array size=n>
 770
 771     //getLAnglebracket(in); //<subtype>
 772                 /* subfield */
 773     f = (field_t *)memAlloc(sizeof(field_t));
 774
 775     f->name = NULL;
 776     sequence_push(&(t->fields),f);
 777     parseFields(fac, in, f, unnamed_types, named_types, 0);
 778
 779     //getLAnglebracket(in); //<type struct>
 780     //t->nested_type = parseType(in, NULL, unnamed_types, named_types);
 781
 782     getLAnglebracket(in); //</array>
 783     getForwardslash(in);
 784     token = getName(in);
 785     if(strcmp("array",token))in->error(in,"not a valid array definition");
 786     getRAnglebracket(in);  //</array>
 787   }
 788   else if(strcmp(token,"sequence") == 0) {
 789     t->type = SEQUENCE;
 790     sequence_init(&(t->fields));
 791     getTypeAttributes(in, t, unnamed_types, named_types);
 792     getForwardslash(in);
 793     getRAnglebracket(in); //<sequence>
 794
 795     //getLAnglebracket(in); //<sequence size type>
 796                 /* subfield */
 797     f = (field_t *)memAlloc(sizeof(field_t));
 798     f->name = NULL;
 799     sequence_push(&(t->fields),f);
 800     parseFields(fac, in, f, unnamed_types, named_types, 0);
 801
 802     //getLAnglebracket(in); //<subtype>
 803                 /* subfield */
 804     f = (field_t *)memAlloc(sizeof(field_t));
 805     f->name = NULL;
 806     sequence_push(&(t->fields),f);
 807     parseFields(fac, in, f, unnamed_types, named_types, 0);
 808
 809     //getLAnglebracket(in); //<type sequence>
 810     //t->length_type = parseType(in, NULL, unnamed_types, named_types);
 811
 812     //getLAnglebracket(in); //<type sequence>
 813
 814     //t->nested_type = parseType(in, NULL, unnamed_types, named_types);
 815
 816     if(t->fields.position < 1) in->error(in, "Sequence has no length type");
 817     if(t->fields.position < 2) in->error(in, "Sequence has no subtype");
 818                 switch(((field_t*)t->fields.array[0])->type->type) {
 819                         case UINT_FIXED :
 820                         case UCHAR :
 821                         case USHORT :
 822                         case UINT :
 823                         case ULONG :
 824                         case SIZE_T :
 825                         case OFF_T :
 826                                 break;
 827                         default:
 828                                 in->error(in, "Wrong length type for sequence");
 829                 }
 830
 831     getLAnglebracket(in); //</sequence>
 832     getForwardslash(in);
 833     token = getName(in);
 834     if(strcmp("sequence",token))in->error(in,"not a valid sequence definition");
 835     getRAnglebracket(in); //</sequence>
 836   }
 837   else if(strcmp(token,"enum") == 0) {
 838     char * str;
 839     long long value = -1;
 840
 841     t->type = ENUM;
 842     sequence_init(&(t->labels));
 843     sequence_init(&(t->labels_values));
 844     sequence_init(&(t->labels_description));
 845                 t->already_printed = 0;
 846     getTypeAttributes(in, t, unnamed_types, named_types);
 847     //if(t->size == 0) in->error(in, "Sequence has empty size");
 848                 //Mathieu : we fix enum size to target int size. GCC is always like this.
 849                 //fox copy optimisation.
 850     if(t->size != 0) in->error(in, "Enum has fixed size of target int.");
 851                 t->size = 0;
 852     getRAnglebracket(in);
 853
 854     //<label name=label1 value=n/>
 855     getLAnglebracket(in);
 856     token = getToken(in); //"label" or "/"
 857     while(strcmp("label",token) == 0){
 858       int *label_value = malloc(sizeof(int));
 859                         int has_value = 0;
 860                         long long loc_value;
 861
 862       str   = allocAndCopy(getNameAttribute(in));
 863       has_value = getValueAttribute(in, &loc_value);
 864
 865       sequence_push(&(t->labels),str);
 866
 867       if(has_value) value = loc_value;
 868       else value++;
 869
 870       *label_value = value;
 871       sequence_push(&(t->labels_values), label_value);
 872
 873       getForwardslash(in);
 874       getRAnglebracket(in);
 875
 876       //read description if any. May be NULL.
 877       str = allocAndCopy(getDescription(in));
 878                         sequence_push(&(t->labels_description),str);
 879
 880       //next label definition
 881       getLAnglebracket(in);
 882       token = getToken(in); //"label" or "/"
 883     }
 884     if(strcmp("/",token))in->error(in, "not a valid enum definition");
 885     token = getName(in);
 886     if(strcmp("enum",token))in->error(in, "not a valid enum definition");
 887       getRAnglebracket(in); //</label>
 888   }
 889   else if(strcmp(token,"int_fixed") == 0) {
 890     t->type = INT_FIXED;
 891     getTypeAttributes(in, t, unnamed_types, named_types);
 892     if(t->size == 0) in->error(in, "int has empty size");
 893     getForwardslash(in);
 894     getRAnglebracket(in);
 895   }
 896   else if(strcmp(token,"uint_fixed") == 0) {
 897     t->type = UINT_FIXED;
 898     getTypeAttributes(in, t, unnamed_types, named_types);
 899     if(t->size == 0) in->error(in, "uint has empty size");
 900     getForwardslash(in);
 901     getRAnglebracket(in);
 902   }
 903   else if(strcmp(token,"char") == 0) {
 904     t->type = CHAR;
 905     getTypeAttributes(in, t, unnamed_types, named_types);
 906                 t->size = 1;
 907     getForwardslash(in);
 908     getRAnglebracket(in);
 909   }
 910   else if(strcmp(token,"uchar") == 0) {
 911     t->type = UCHAR;
 912     getTypeAttributes(in, t, unnamed_types, named_types);
 913                 t->size = 1;
 914     getForwardslash(in);
 915     getRAnglebracket(in);
 916   }
 917   else if(strcmp(token,"short") == 0) {
 918     t->type = SHORT;
 919     getTypeAttributes(in, t, unnamed_types, named_types);
 920                 t->size = 2;
 921     getForwardslash(in);
 922     getRAnglebracket(in);
 923   }
 924   else if(strcmp(token,"ushort") == 0) {
 925     t->type = USHORT;
 926     getTypeAttributes(in, t, unnamed_types, named_types);
 927                 t->size = 2;
 928     getForwardslash(in);
 929     getRAnglebracket(in);
 930   }
 931   else if(strcmp(token,"int") == 0) {
 932     t->type = INT;
 933     getTypeAttributes(in, t, unnamed_types, named_types);
 934     getForwardslash(in);
 935     getRAnglebracket(in);
 936   }
 937   else if(strcmp(token,"uint") == 0) {
 938     t->type = UINT;
 939     getTypeAttributes(in, t, unnamed_types, named_types);
 940     getForwardslash(in);
 941     getRAnglebracket(in);
 942   }
 943
 944   else if(strcmp(token,"pointer") == 0) {
 945     t->type = POINTER;
 946     getTypeAttributes(in, t, unnamed_types, named_types);
 947     getForwardslash(in);
 948     getRAnglebracket(in);
 949   }
 950   else if(strcmp(token,"long") == 0) {
 951     t->type = LONG;
 952     getTypeAttributes(in, t, unnamed_types, named_types);
 953     getForwardslash(in);
 954     getRAnglebracket(in);
 955   }
 956   else if(strcmp(token,"ulong") == 0) {
 957     t->type = ULONG;
 958     getTypeAttributes(in, t, unnamed_types, named_types);
 959     getForwardslash(in);
 960     getRAnglebracket(in);
 961   }
 962   else if(strcmp(token,"size_t") == 0) {
 963     t->type = SIZE_T;
 964     getTypeAttributes(in, t, unnamed_types, named_types);
 965     getForwardslash(in);
 966     getRAnglebracket(in);
 967   }
 968   else if(strcmp(token,"ssize_t") == 0) {
 969     t->type = SSIZE_T;
 970     getTypeAttributes(in, t, unnamed_types, named_types);
 971     getForwardslash(in);
 972     getRAnglebracket(in);
 973   }
 974   else if(strcmp(token,"off_t") == 0) {
 975     t->type = OFF_T;
 976     getTypeAttributes(in, t, unnamed_types, named_types);
 977     getForwardslash(in);
 978     getRAnglebracket(in);
 979   }
 980   else if(strcmp(token,"float") == 0) {
 981     t->type = FLOAT;
 982     getTypeAttributes(in, t, unnamed_types, named_types);
 983     getForwardslash(in);
 984     getRAnglebracket(in);
 985   }
 986   else if(strcmp(token,"string") == 0) {
 987     t->type = STRING;
 988     getTypeAttributes(in, t, unnamed_types, named_types);
 989     getForwardslash(in);
 990     getRAnglebracket(in);
 991   }
 992   else if(strcmp(token,"typeref") == 0){
 993     // Must be a named type
 994                 free(t);
 995                 sequence_pop(unnamed_types);
 996                 token = getNameAttribute(in);
 997                 t = find_named_type(token, named_types);
 998                 if(t == NULL) in->error(in,"Named referred to must be pre-declared.");
 999                 getForwardslash(in);  //<typeref name=type_name/>
1000                 getRAnglebracket(in);
1001                 return t;
1002   }else in->error(in,"not a valid type");
1003
1004   return t;
1005 }
1006
1007 /*****************************************************************************
1008  *Function name
1009  *    find_named_type     : find a named type from hash table
1010  *Input params
1011  *    name                : type name
1012  *    named_types         : array of named types
1013  *Return values
1014  *    type_descriptor *   : a type descriptor
1015  *****************************************************************************/
1016
1017 type_descriptor_t * find_named_type(char *name, table_t * named_types)
1018 {
1019   type_descriptor_t *t;
1020
1021   t = (type_descriptor_t*)table_find(named_types,name);
1022
1023   return t;
1024 }
1025
1026 type_descriptor_t * create_named_type(char *name, table_t * named_types)
1027 {
1028   type_descriptor_t *t;
1029
1030         t = (type_descriptor_t *)memAlloc(sizeof(type_descriptor_t));
1031         t->type_name = allocAndCopy(name);
1032         t->type = NONE;
1033         t->fmt = NULL;
1034         table_insert(named_types,t->type_name,t);
1035         //    table_insert(named_types,allocAndCopy(name),t);
1036         return t;
1037 }
1038
1039 /*****************************************************************************
1040  *Function name
1041  *    parseTypeDefinition : get type information from type definition
1042  *Input params
1043  *    fac                 : facility
1044  *    in                  : input file handle
1045  *    unnamed_types       : array of unamed types
1046  *    named_types         : array of named types
1047  *****************************************************************************/
1048
1049 void parseTypeDefinition(facility_t *fac, parse_file_t * in, sequence_t * unnamed_types,
1050                          table_t * named_types)
1051 {
1052   char *token;
1053   type_descriptor_t *t;
1054
1055   token = getNameAttribute(in);
1056   if(token == NULL) in->error(in, "Type has empty name");
1057   t = create_named_type(token, named_types);
1058
1059   if(t->type != NONE) in->error(in,"redefinition of named type");
1060   getRAnglebracket(in); //<type name=type_name>
1061   getLAnglebracket(in); //<
1062   token = getName(in);
1063   //MD ??if(strcmp("struct",token))in->error(in,"not a valid type definition");
1064   ungetToken(in);
1065   parseType(fac, in,t, unnamed_types, named_types);
1066
1067   //</type>
1068   getLAnglebracket(in);
1069   getForwardslash(in);
1070   token = getName(in);
1071   if(strcmp("type",token))in->error(in,"not a valid type definition");
1072   getRAnglebracket(in); //</type>
1073 }
1074
1075 /**************************************************************************
1076  * Function :
1077  *    getComa, getName, getNumber, getEqual
1078  * Description :
1079  *    Read a token from the input file, check its type, return it scontent.
1080  *
1081  * Parameters :
1082  *    in , input file handle.
1083  *
1084  * Return values :
1085  *    address of token content.
1086  *
1087  **************************************************************************/
1088
1089 char *getName(parse_file_t * in)
1090 {
1091   char *token;
1092
1093   token = getToken(in);
1094   // Optional descriptions
1095         // if(in->type != NAME) in->error(in,"Name token was expected");
1096   return token;
1097 }
1098
1099 int getNumber(parse_file_t * in)
1100 {
1101   char *token;
1102
1103   token = getToken(in);
1104   if(in->type != NUMBER) in->error(in, "Number token was expected");
1105   return atoi(token);
1106 }
1107
1108 char *getForwardslash(parse_file_t * in)
1109 {
1110   char *token;
1111
1112   token = getToken(in);
1113   //if(in->type != FORWARDSLASH) in->error(in, "forward slash token was expected");
1114         /* Mathieu : final / is optional now. */
1115   if(in->type != FORWARDSLASH) ungetToken(in);
1116
1117   return token;
1118 }
1119
1120 char *getLAnglebracket(parse_file_t * in)
1121 {
1122   char *token;
1123
1124   token = getToken(in);
1125   if(in->type != LANGLEBRACKET) in->error(in, "Left angle bracket was expected");
1126   return token;
1127 }
1128
1129 char *getRAnglebracket(parse_file_t * in)
1130 {
1131   char *token;
1132
1133   token = getToken(in);
1134   if(in->type != RANGLEBRACKET) in->error(in, "Right angle bracket was expected");
1135   return token;
1136 }
1137
1138 char *getQuotedString(parse_file_t * in)
1139 {
1140   char *token;
1141
1142   token = getToken(in);
1143   if(in->type != QUOTEDSTRING) in->error(in, "quoted string was expected");
1144   return token;
1145 }
1146
1147 char * getEqual(parse_file_t *in)
1148 {
1149   char *token;
1150
1151   token = getToken(in);
1152   if(in->type != EQUAL) in->error(in, "equal was expected");
1153   return token;
1154 }
1155
1156 int seekNextChar(parse_file_t *in)
1157 {
1158   int car;
1159   while((car = getc(in->fp)) != EOF) {
1160     if(!isspace(car)){
1161       ungetc(car,in->fp);
1162       return car;
1163     }
1164   }
1165   return EOF;
1166 }
1167
1168 /******************************************************************
1169  * Function :
1170  *    getToken, ungetToken
1171  * Description :
1172  *    Read a token from the input file and return its type and content.
1173  *    Line numbers are accounted for and whitespace/comments are skipped.
1174  *
1175  * Parameters :
1176  *    in, input file handle.
1177  *
1178  * Return values :
1179  *    address of token content.
1180  *
1181  ******************************************************************/
1182
1183 void ungetToken(parse_file_t * in)
1184 {
1185   in->unget = 1;
1186 }
1187
1188 char *getToken(parse_file_t * in)
1189 {
1190   FILE *fp = in->fp;
1191   int car, car1;
1192   int pos = 0, escaped;
1193
1194   if(in->unget == 1) {
1195     in->unget = 0;
1196     return in->buffer;
1197   }
1198
1199   /* skip whitespace and comments */
1200
1201   while((car = getc(fp)) != EOF) {
1202     if(car == '/') {
1203       car1 = getc(fp);
1204       if(car1 == '*') skipComment(in);
1205       else if(car1 == '/') skipEOL(in);
1206       else {
1207         car1 = ungetc(car1,fp);
1208         break;
1209       }
1210     }
1211     else if(car == '\n') in->lineno++;
1212     else if(!isspace(car)) break;
1213   }
1214
1215   switch(car) {
1216     case EOF:
1217       in->type = ENDFILE;
1218       break;
1219     case '/':
1220       in->type = FORWARDSLASH;
1221       in->buffer[pos] = car;
1222       pos++;
1223       break;
1224     case '<':
1225       in->type = LANGLEBRACKET;
1226       in->buffer[pos] = car;
1227       pos++;
1228       break;
1229     case '>':
1230       in->type = RANGLEBRACKET;
1231       in->buffer[pos] = car;
1232       pos++;
1233       break;
1234     case '=':
1235       in->type = EQUAL;
1236       in->buffer[pos] = car;
1237       pos++;
1238       break;
1239     case '"':
1240       escaped = 0;
1241       while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
1242         if(car == '\\' && escaped == 0) {
1243                                 in->buffer[pos] = car;
1244                                   pos++;
1245           escaped = 1;
1246           continue;
1247         }
1248         if(car == '"' && escaped == 0) break;
1249         if(car == '\n' && escaped == 0) {
1250           in->error(in, "non escaped newline inside quoted string");
1251         }
1252         if(car == '\n') in->lineno++;
1253         in->buffer[pos] = car;
1254         pos++;
1255         escaped = 0;
1256       }
1257       if(car == EOF) in->error(in,"no ending quotemark");
1258       if(pos == BUFFER_SIZE) in->error(in, "quoted string token too large");
1259       in->type = QUOTEDSTRING;
1260       break;
1261     default:
1262       if(isdigit(car)) {
1263         in->buffer[pos] = car;
1264         pos++;
1265         while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
1266           if(!isdigit(car)) {
1267             ungetc(car,fp);
1268             break;
1269           }
1270           in->buffer[pos] = car;
1271           pos++;
1272         }
1273                                 if(car == EOF) ungetc(car,fp);
1274         if(pos == BUFFER_SIZE) in->error(in, "number token too large");
1275         in->type = NUMBER;
1276       }
1277       else if(isalnum(car) || car == '_' || car == '-') {
1278         in->buffer[0] = car;
1279         pos = 1;
1280         while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
1281           if(!(isalnum(car) || car == '_' || car == '-')) {
1282             ungetc(car,fp);
1283             break;
1284           }
1285           in->buffer[pos] = car;
1286           pos++;
1287         }
1288                         if(car == EOF) ungetc(car,fp);
1289         if(pos == BUFFER_SIZE) in->error(in, "name token too large");
1290         in->type = NAME;
1291       } else if(car == '?') {
1292                                 in->buffer[0] = car;
1293                                 pos++;
1294                         }
1295       else in->error(in, "invalid character, unrecognized token");
1296   }
1297   in->buffer[pos] = 0;
1298   return in->buffer;
1299 }
1300
1301 void skipComment(parse_file_t * in)
1302 {
1303   int car;
1304   while((car = getc(in->fp)) != EOF) {
1305     if(car == '\n') in->lineno++;
1306     else if(car == '*') {
1307       car = getc(in->fp);
1308       if(car ==EOF) break;
1309       if(car == '/') return;
1310       ungetc(car,in->fp);
1311     }
1312   }
1313   if(car == EOF) in->error(in,"comment begining with '/*' has no ending '*/'");
1314 }
1315
1316 void skipEOL(parse_file_t * in)
1317 {
1318   int car;
1319   while((car = getc(in->fp)) != EOF) {
1320     if(car == '\n') {
1321       ungetc(car,in->fp);
1322       break;
1323     }
1324   }
1325   if(car == EOF)ungetc(car, in->fp);
1326 }
1327
1328 /*****************************************************************************
1329  *Function name
1330  *    checkNamedTypesImplemented : check if all named types have definition
1331  ****************************************************************************/
1332
1333 void checkNamedTypesImplemented(table_t * named_types)
1334 {
1335   type_descriptor_t *t;
1336   int pos;
1337   char str[256];
1338
1339   for(pos = 0 ; pos < named_types->values.position; pos++) {
1340     t = (type_descriptor_t *) named_types->values.array[pos];
1341     if(t->type == NONE){
1342       sprintf(str,"named type '%s' has no definition",
1343           (char*)named_types->keys.array[pos]);
1344       error_callback(NULL,str);
1345     }
1346   }
1347 }
1348
1349
1350 /*****************************************************************************
1351  *Function name
1352  *    generateChecksum  : generate checksum for the facility
1353  *Input Params
1354  *    facName           : name of facility
1355  *Output Params
1356  *    checksum          : checksum for the facility
1357  ****************************************************************************/
1358
1359 void generateChecksum(char* facName,
1360     unsigned int * checksum, sequence_t * events)
1361 {
1362   unsigned long crc ;
1363   int pos;
1364   event_t * ev;
1365   unsigned int i;
1366
1367   crc = crc32(facName);
1368   for(pos = 0; pos < events->position; pos++){
1369     ev = (event_t *)(events->array[pos]);
1370     crc = partial_crc32(ev->name, crc);
1371                 for(i = 0; i < ev->fields.position; i++) {
1372                         field_t *f = (field_t*)ev->fields.array[i];
1373       crc = partial_crc32(f->name, crc);
1374       crc = getTypeChecksum(crc, f->type);
1375                 }
1376   }
1377   *checksum = crc;
1378 }
1379
1380 /*****************************************************************************
1381  *Function name
1382  *   getTypeChecksum    : generate checksum by type info
1383  *Input Params
1384  *    crc               : checksum generated so far
1385  *    type              : type descriptor containing type info
1386  *Return value
1387  *    unsigned long     : checksum
1388  *****************************************************************************/
1389
1390 unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor_t * type)
1391 {
1392   unsigned long crc = aCrc;
1393   char * str = NULL, buf[16];
1394   int flag = 0, pos;
1395   field_t * fld;
1396
1397   switch(type->type){
1398     case INT_FIXED:
1399       str = intOutputTypes[getSizeindex(type->size)];
1400       break;
1401     case UINT_FIXED:
1402       str = uintOutputTypes[getSizeindex(type->size)];
1403       break;
1404     case POINTER:
1405       str = allocAndCopy("void *");
1406                         flag = 1;
1407       break;
1408     case CHAR:
1409       str = allocAndCopy("signed char");
1410                         flag = 1;
1411       break;
1412     case UCHAR:
1413       str = allocAndCopy("unsigned char");
1414                         flag = 1;
1415       break;
1416     case SHORT:
1417       str = allocAndCopy("short");
1418                         flag = 1;
1419       break;
1420     case USHORT:
1421       str = allocAndCopy("unsigned short");
1422                         flag = 1;
1423       break;
1424     case INT:
1425       str = allocAndCopy("int");
1426                         flag = 1;
1427       break;
1428     case UINT:
1429       str = allocAndCopy("uint");
1430                         flag = 1;
1431       break;
1432     case LONG:
1433       str = allocAndCopy("long");
1434                         flag = 1;
1435       break;
1436     case ULONG:
1437       str = allocAndCopy("unsigned long");
1438                         flag = 1;
1439       break;
1440     case SIZE_T:
1441       str = allocAndCopy("size_t");
1442                         flag = 1;
1443       break;
1444     case SSIZE_T:
1445       str = allocAndCopy("ssize_t");
1446                         flag = 1;
1447       break;
1448     case OFF_T:
1449       str = allocAndCopy("off_t");
1450                         flag = 1;
1451       break;
1452     case FLOAT:
1453       str = floatOutputTypes[getSizeindex(type->size)];
1454       break;
1455     case STRING:
1456       str = allocAndCopy("string");
1457       flag = 1;
1458       break;
1459     case ENUM:
1460       //str = appendString("enum ", uintOutputTypes[getSizeindex(type->size)]);
1461       str = allocAndCopy("enum");
1462       flag = 1;
1463       break;
1464     case ARRAY:
1465       sprintf(buf,"%zu", type->size);
1466       str = appendString("array ",buf);
1467       flag = 1;
1468       break;
1469     case SEQUENCE:
1470       str = allocAndCopy("sequence ");
1471       flag = 1;
1472       break;
1473     case STRUCT:
1474       str = allocAndCopy("struct");
1475       flag = 1;
1476       break;
1477     case UNION:
1478       str = allocAndCopy("union");
1479       flag = 1;
1480       break;
1481     default:
1482       error_callback(NULL, "named type has no definition");
1483       break;
1484   }
1485
1486   crc = partial_crc32(str,crc);
1487   if(flag) free(str);
1488
1489   if(type->fmt) crc = partial_crc32(type->fmt,crc);
1490
1491   if(type->type == ARRAY){
1492     crc = getTypeChecksum(crc,((field_t*)type->fields.array[0])->type);
1493   } else if(type->type ==SEQUENCE) {
1494     crc = getTypeChecksum(crc,((field_t*)type->fields.array[0])->type);
1495     crc = getTypeChecksum(crc,((field_t*)type->fields.array[1])->type);
1496         } else if(type->type == STRUCT || type->type == UNION){
1497     for(pos =0; pos < type->fields.position; pos++){
1498       fld = (field_t *) type->fields.array[pos];
1499       crc = partial_crc32(fld->name,crc);
1500       crc = getTypeChecksum(crc, fld->type);
1501     }
1502   }else if(type->type == ENUM){
1503     for(pos = 0; pos < type->labels.position; pos++)
1504       crc = partial_crc32((char*)type->labels.array[pos],crc);
1505   }
1506
1507   return crc;
1508 }
1509
1510
1511 /* Event type descriptors */
1512 void freeType(type_descriptor_t * tp)
1513 {
1514   int pos2;
1515   field_t *f;
1516
1517   if(tp->fmt != NULL) free(tp->fmt);
1518   if(tp->type == ENUM) {
1519     for(pos2 = 0; pos2 < tp->labels.position; pos2++) {
1520       free(tp->labels.array[pos2]);
1521     }
1522     sequence_dispose(&(tp->labels));
1523     for(pos2 = 0; pos2 < tp->labels_values.position; pos2++) {
1524       free(tp->labels_values.array[pos2]);
1525     }
1526     sequence_dispose(&(tp->labels_values));
1527   }
1528   if(tp->type == STRUCT) {
1529     for(pos2 = 0; pos2 < tp->fields.position; pos2++) {
1530       f = (field_t *) tp->fields.array[pos2];
1531       free(f->name);
1532       free(f->description);
1533       free(f);
1534     }
1535     sequence_dispose(&(tp->fields));
1536   }
1537 }
1538
1539 void freeNamedType(table_t * t)
1540 {
1541   int pos;
1542   type_descriptor_t * td;
1543
1544   for(pos = 0 ; pos < t->keys.position; pos++) {
1545     free((char *)t->keys.array[pos]);
1546     td = (type_descriptor_t*)t->values.array[pos];
1547     freeType(td);
1548     free(td);
1549   }
1550 }
1551
1552 void freeTypes(sequence_t *t)
1553 {
1554   int pos;
1555   type_descriptor_t *tp;
1556
1557   for(pos = 0 ; pos < t->position; pos++) {
1558     tp = (type_descriptor_t *)t->array[pos];
1559     freeType(tp);
1560     free(tp);
1561   }
1562 }
1563
1564 void freeEvents(sequence_t *t)
1565 {
1566   int pos;
1567   event_t *ev;
1568
1569   for(pos = 0 ; pos < t->position; pos++) {
1570     ev = (event_t *) t->array[pos];
1571     free(ev->name);
1572     free(ev->description);
1573                 sequence_dispose(&ev->fields);
1574     free(ev);
1575   }
1576
1577 }
1578
1579
1580 /* Extensible array */
1581
1582 void sequence_init(sequence_t *t)
1583 {
1584   t->size = 10;
1585   t->position = 0;
1586   t->array = (void **)memAlloc(t->size * sizeof(void *));
1587 }
1588
1589 void sequence_dispose(sequence_t *t)
1590 {
1591   t->size = 0;
1592   free(t->array);
1593   t->array = NULL;
1594 }
1595
1596 void sequence_push(sequence_t *t, void *elem)
1597 {
1598   void **tmp;
1599
1600   if(t->position >= t->size) {
1601     tmp = t->array;
1602     t->array = (void **)memAlloc(t->size * 2 * sizeof(void *));
1603     memcpy(t->array, tmp, t->size * sizeof(void *));
1604     t->size = t->size * 2;
1605     free(tmp);
1606   }
1607   t->array[t->position] = elem;
1608   t->position++;
1609 }
1610
1611 void *sequence_pop(sequence_t *t)
1612 {
1613         if(t->position == 0) printf("Error : trying to pop an empty sequence");
1614   return t->array[--t->position];
1615 }
1616
1617
1618 /* Hash table API, implementation is just linear search for now */
1619
1620 void table_init(table_t *t)
1621 {
1622   sequence_init(&(t->keys));
1623   sequence_init(&(t->values));
1624 }
1625
1626 void table_dispose(table_t *t)
1627 {
1628   sequence_dispose(&(t->keys));
1629   sequence_dispose(&(t->values));
1630 }
1631
1632 void table_insert(table_t *t, char *key, void *value)
1633 {
1634   sequence_push(&(t->keys),key);
1635   sequence_push(&(t->values),value);
1636 }
1637
1638 void *table_find(table_t *t, char *key)
1639 {
1640   int pos;
1641   for(pos = 0 ; pos < t->keys.position; pos++) {
1642     if(strcmp((char *)key,(char *)t->keys.array[pos]) == 0)
1643       return(t->values.array[pos]);
1644   }
1645   return NULL;
1646 }
1647
1648 void table_insert_int(table_t *t, int *key, void *value)
1649 {
1650   sequence_push(&(t->keys),key);
1651   sequence_push(&(t->values),value);
1652 }
1653
1654 void *table_find_int(table_t *t, int *key)
1655 {
1656   int pos;
1657   for(pos = 0 ; pos < t->keys.position; pos++) {
1658     if(*key == *(int *)t->keys.array[pos])
1659       return(t->values.array[pos]);
1660   }
1661   return NULL;
1662 }
1663
1664
1665 /* Concatenate strings */
1666
1667 char *appendString(char *s, char *suffix)
1668 {
1669   char *tmp;
1670   if(suffix == NULL) return s;
1671
1672   tmp = (char *)memAlloc(strlen(s) + strlen(suffix) + 1);
1673   strcpy(tmp,s);
1674   strcat(tmp,suffix);
1675   return tmp;
1676 }