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, * endptr;
 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   *value = strtoll(token, &endptr, 0);
 453   if(*endptr != '\0')
 454     goto error;
 455   return 1;
 456 error:
 457   in->error(in,"invalid number specified");
 458   return 0;
 459 }
 460
 461 char * getDescription(parse_file_t *in)
 462 {
 463   long int pos;
 464   char * token, *str;
 465   int car;
 466
 467   pos = ftell(in->fp);
 468
 469   getLAnglebracket(in);
 470   token = getName(in);
 471   if(strcmp("description",token)){
 472     fseek(in->fp, pos, SEEK_SET);
 473     return NULL;
 474   }
 475
 476   getRAnglebracket(in);
 477
 478   pos = 0;
 479   while((car = getc(in->fp)) != EOF) {
 480     if(car == '<') break;
 481     if(car == '\0') continue;
 482     in->buffer[pos] = car;
 483     pos++;
 484   }
 485   if(car == EOF)in->error(in,"not a valid description");
 486   in->buffer[pos] = '\0';
 487
 488   str = allocAndCopy(in->buffer);
 489
 490   getForwardslash(in);
 491   token = getName(in);
 492   if(strcmp("description", token))in->error(in,"not a valid description");
 493   getRAnglebracket(in);
 494
 495   return str;
 496 }
 497
 498 /*****************************************************************************
 499  *Function name
 500  *    parseFacility : generate event list
 501  *Input params
 502  *    in            : input file handle
 503  *    fac           : empty facility
 504  *Output params
 505  *    fac           : facility filled with event list
 506  ****************************************************************************/
 507
 508 void parseFacility(parse_file_t *in, facility_t * fac)
 509 {
 510   char * token;
 511   event_t *ev;
 512
 513   getFacilityAttributes(in, fac);
 514   if(fac->name == NULL) in->error(in, "Attribute not named");
 515
 516   fac->capname = allocAndCopy(fac->name);
 517   strupper(fac->capname);
 518   getRAnglebracket(in);
 519
 520   fac->description = getDescription(in);
 521
 522   while(1){
 523     getLAnglebracket(in);
 524
 525     token = getToken(in);
 526     if(in->type == ENDFILE)
 527       in->error(in,"the definition of the facility is not finished");
 528
 529     if(strcmp("event",token) == 0){
 530       ev = (event_t*) memAlloc(sizeof(event_t));
 531       sequence_push(&(fac->events),ev);
 532       parseEvent(fac, in, ev, &(fac->unnamed_types), &(fac->named_types));
 533     }else if(strcmp("type",token) == 0){
 534       parseTypeDefinition(fac, in, &(fac->unnamed_types), &(fac->named_types));
 535     }else if(in->type == FORWARDSLASH){
 536       break;
 537     }else in->error(in,"event or type token expected\n");
 538   }
 539
 540   token = getName(in);
 541   if(strcmp("facility",token)) in->error(in,"not the end of the facility");
 542   getRAnglebracket(in); //</facility>
 543 }
 544
 545 /*****************************************************************************
 546  *Function name
 547  *    parseEvent    : generate event from event definition
 548  *Input params
 549  *    fac           : facility holding the event
 550  *    in            : input file handle
 551  *    ev            : new event
 552  *    unnamed_types : array of unamed types
 553  *    named_types   : array of named types
 554  *Output params
 555  *    ev            : new event (parameters are passed to it)
 556  ****************************************************************************/
 557
 558 void parseEvent(facility_t *fac, parse_file_t *in, event_t * ev, sequence_t * unnamed_types,
 559                 table_t * named_types)
 560 {
 561   char *token;
 562   field_t *f;
 563
 564   ev->fac = fac;
 565   sequence_init(&(ev->fields));
 566   //<event name=eventtype_name>
 567   getEventAttributes(in, ev);
 568   if(ev->name == NULL) in->error(in, "Event not named");
 569   getRAnglebracket(in);
 570
 571   //<description>...</description>
 572   ev->description = getDescription(in);
 573
 574   int got_end = 0;
 575   /* Events can have multiple fields. each field form at least a function
 576    * parameter of the logging function. */
 577   while(!got_end) {
 578     getLAnglebracket(in);
 579     token = getToken(in);
 580
 581     switch(in->type) {
 582     case FORWARDSLASH:  /* </event> */
 583       token = getName(in);
 584       if(strcmp("event",token))in->error(in,"not an event definition");
 585       getRAnglebracket(in);  //</event>
 586       got_end = 1;
 587       break;
 588     case NAME: /* a field */
 589       if(strcmp("field",token))in->error(in,"expecting a field");
 590       f = (field_t *)memAlloc(sizeof(field_t));
 591       sequence_push(&(ev->fields),f);
 592       parseFields(fac, in, f, unnamed_types, named_types, 1);
 593       break;
 594     default:
 595       in->error(in, "expecting </event> or <field >");
 596       break;
 597     }
 598   }
 599 #if 0
 600     if(in->type == FORWARDSLASH){ //</event> NOTHING
 601       ev->type = NULL;
 602     }else if(in->type == NAME){
 603       if(strcmp("struct",token)==0 || strcmp("typeref",token)==0){
 604         ungetToken(in);
 605         ev->type = parseType(in,NULL, unnamed_types, named_types);
 606         if(ev->type->type != STRUCT && ev->type->type != NONE)
 607     in->error(in,"type must be a struct");
 608       }else in->error(in, "not a valid type");
 609
 610       getLAnglebracket(in);
 611       getForwardslash(in);
 612     }else in->error(in,"not a struct type");
 613     getLAnglebracket(in);
 614     getForwardslash(in);
 615     token = getName(in);
 616     if(strcmp("event",token))in->error(in,"not an event definition");
 617     getRAnglebracket(in);  //</event>
 618 #endif //0
 619 }
 620
 621 /*****************************************************************************
 622  *Function name
 623  *    parseField    : get field infomation from buffer
 624  *Input params
 625  *    fac           : facility holding the field
 626  *    in            : input file handle
 627  *    f             : field
 628  *    unnamed_types : array of unamed types
 629  *    named_types   : array of named types
 630  *    tag           : is field surrounded by a <field> </field> tag ?
 631  ****************************************************************************/
 632
 633 void parseFields(facility_t *fac, parse_file_t *in, field_t *f,
 634     sequence_t * unnamed_types,
 635     table_t * named_types,
 636     int tag)
 637 {
 638   char * token;
 639   f->fac = fac;
 640   if(tag) {
 641     //<field name=field_name> <description> <type> </field>
 642     getFieldAttributes(in, f);
 643     if(f->name == NULL) in->error(in, "Field not named");
 644     getRAnglebracket(in);
 645
 646     f->description = getDescription(in);
 647   } else {
 648     f->description = NULL;
 649   }
 650
 651   //<int size=...>
 652   getLAnglebracket(in);
 653   f->type = parseType(fac, in,NULL, unnamed_types, named_types);
 654
 655   if(tag) {
 656     getLAnglebracket(in);
 657     getForwardslash(in);
 658     token = getName(in);
 659     if(strcmp("field",token))in->error(in,"not a valid field definition");
 660     getRAnglebracket(in); //</field>
 661   }
 662 }
 663
 664
 665 /*****************************************************************************
 666  *Function name
 667  *    parseType      : get type information, type can be :
 668  *                     Primitive:
 669  *                        int(size,fmt); uint(size,fmt); float(size,fmt);
 670  *                        string(fmt); enum(size,fmt,(label1,label2...))
 671  *                     Compound:
 672  *                        array(arraySize, type); sequence(lengthSize,type)
 673  *                        struct(field(name,type,description)...)
 674  *                     type name:
 675  *                        type(name,type)
 676  *Input params
 677  *    fac              : facility
 678  *    in               : input file handle
 679  *    inType           : a type descriptor
 680  *    unnamed_types    : array of unamed types
 681  *    named_types      : array of named types
 682  *Return values
 683  *    type_descriptor* : a type descriptor
 684  ****************************************************************************/
 685
 686 type_descriptor_t *parseType(facility_t *fac, parse_file_t *in, type_descriptor_t *inType,
 687                              sequence_t * unnamed_types, table_t * named_types)
 688 {
 689   char *token;
 690   type_descriptor_t *t;
 691   field_t *f;
 692
 693   if(inType == NULL) {
 694     t = (type_descriptor_t *) memAlloc(sizeof(type_descriptor_t));
 695     t->type_name = NULL;
 696     t->type = NONE;
 697     t->fmt = NULL;
 698     sequence_push(unnamed_types,t);
 699   }
 700   else t = inType;
 701   t->fac = fac;
 702
 703   token = getName(in);
 704
 705   if(strcmp(token,"struct") == 0) {
 706     t->type = STRUCT;
 707     getTypeAttributes(in, t, unnamed_types, named_types);
 708     getRAnglebracket(in); //<struct>
 709     getLAnglebracket(in); //<field name=..>
 710     token = getToken(in);
 711     sequence_init(&(t->fields));
 712     while(strcmp("field",token) == 0){
 713       f = (field_t *)memAlloc(sizeof(field_t));
 714       sequence_push(&(t->fields),f);
 715
 716       parseFields(fac, in, f, unnamed_types, named_types, 1);
 717
 718       //next field
 719       getLAnglebracket(in);
 720       token = getToken(in);
 721     }
 722     if(strcmp("/",token))in->error(in,"not a valid structure definition");
 723     token = getName(in);
 724     if(strcmp("struct",token)!=0)
 725       in->error(in,"not a valid structure definition");
 726     getRAnglebracket(in); //</struct>
 727   }
 728   else if(strcmp(token,"union") == 0) {
 729     t->type = UNION;
 730     getTypeAttributes(in, t, unnamed_types, named_types);
 731     getRAnglebracket(in); //<union>
 732
 733     getLAnglebracket(in); //<field name=..>
 734     token = getToken(in);
 735     sequence_init(&(t->fields));
 736     while(strcmp("field",token) == 0){
 737       f = (field_t *)memAlloc(sizeof(field_t));
 738       sequence_push(&(t->fields),f);
 739       parseFields(fac, in, f, unnamed_types, named_types, 1);
 740
 741       //next field
 742       getLAnglebracket(in);
 743       token = getToken(in);
 744     }
 745     if(strcmp("/",token))in->error(in,"not a valid union definition");
 746     token = getName(in);
 747     if(strcmp("union",token)!=0)
 748       in->error(in,"not a valid union definition");
 749     getRAnglebracket(in); //</union>
 750   }
 751   else if(strcmp(token,"array") == 0) {
 752     t->type = ARRAY;
 753     sequence_init(&(t->fields));
 754     getTypeAttributes(in, t, unnamed_types, named_types);
 755     if(t->size == 0) in->error(in, "Array has empty size");
 756     getForwardslash(in);
 757     getRAnglebracket(in); //<array size=n>
 758
 759     //getLAnglebracket(in); //<subtype>
 760     /* subfield */
 761     f = (field_t *)memAlloc(sizeof(field_t));
 762
 763     f->name = NULL;
 764     sequence_push(&(t->fields),f);
 765     parseFields(fac, in, f, unnamed_types, named_types, 0);
 766
 767     //getLAnglebracket(in); //<type struct>
 768     //t->nested_type = parseType(in, NULL, unnamed_types, named_types);
 769
 770     getLAnglebracket(in); //</array>
 771     getForwardslash(in);
 772     token = getName(in);
 773     if(strcmp("array",token))in->error(in,"not a valid array definition");
 774     getRAnglebracket(in);  //</array>
 775   }
 776   else if(strcmp(token,"sequence") == 0) {
 777     t->type = SEQUENCE;
 778     sequence_init(&(t->fields));
 779     getTypeAttributes(in, t, unnamed_types, named_types);
 780     getForwardslash(in);
 781     getRAnglebracket(in); //<sequence>
 782
 783     //getLAnglebracket(in); //<sequence size type>
 784     /* subfield */
 785     f = (field_t *)memAlloc(sizeof(field_t));
 786     f->name = NULL;
 787     sequence_push(&(t->fields),f);
 788     parseFields(fac, in, f, unnamed_types, named_types, 0);
 789
 790     //getLAnglebracket(in); //<subtype>
 791     /* subfield */
 792     f = (field_t *)memAlloc(sizeof(field_t));
 793     f->name = NULL;
 794     sequence_push(&(t->fields),f);
 795     parseFields(fac, in, f, unnamed_types, named_types, 0);
 796
 797     //getLAnglebracket(in); //<type sequence>
 798     //t->length_type = parseType(in, NULL, unnamed_types, named_types);
 799
 800     //getLAnglebracket(in); //<type sequence>
 801
 802     //t->nested_type = parseType(in, NULL, unnamed_types, named_types);
 803
 804     if(t->fields.position < 1) in->error(in, "Sequence has no length type");
 805     if(t->fields.position < 2) in->error(in, "Sequence has no subtype");
 806     switch(((field_t*)t->fields.array[0])->type->type) {
 807       case UINT_FIXED :
 808       case UCHAR :
 809       case USHORT :
 810       case UINT :
 811       case ULONG :
 812       case SIZE_T :
 813       case OFF_T :
 814         break;
 815       default:
 816         in->error(in, "Wrong length type for sequence");
 817     }
 818
 819     getLAnglebracket(in); //</sequence>
 820     getForwardslash(in);
 821     token = getName(in);
 822     if(strcmp("sequence",token))in->error(in,"not a valid sequence definition");
 823     getRAnglebracket(in); //</sequence>
 824   }
 825   else if(strcmp(token,"enum") == 0) {
 826     char * str;
 827     long long value = -1;
 828
 829     t->type = ENUM;
 830     sequence_init(&(t->labels));
 831     sequence_init(&(t->labels_values));
 832     sequence_init(&(t->labels_description));
 833     t->already_printed = 0;
 834     getTypeAttributes(in, t, unnamed_types, named_types);
 835     //if(t->size == 0) in->error(in, "Sequence has empty size");
 836     //Mathieu : we fix enum size to target int size. GCC is always like this.
 837     //fox copy optimisation.
 838     if(t->size != 0) in->error(in, "Enum has fixed size of target int.");
 839     t->size = 0;
 840     getRAnglebracket(in);
 841
 842     //<label name=label1 value=n/>
 843     getLAnglebracket(in);
 844     token = getToken(in); //"label" or "/"
 845     while(strcmp("label",token) == 0){
 846       int *label_value = malloc(sizeof(int));
 847       int has_value = 0;
 848       long long loc_value;
 849
 850       str   = allocAndCopy(getNameAttribute(in));
 851       has_value = getValueAttribute(in, &loc_value);
 852
 853       sequence_push(&(t->labels),str);
 854
 855       if(has_value) value = loc_value;
 856       else value++;
 857
 858       *label_value = value;
 859       sequence_push(&(t->labels_values), label_value);
 860
 861       getForwardslash(in);
 862       getRAnglebracket(in);
 863
 864       //read description if any. May be NULL.
 865       str = allocAndCopy(getDescription(in));
 866       sequence_push(&(t->labels_description),str);
 867
 868       //next label definition
 869       getLAnglebracket(in);
 870       token = getToken(in); //"label" or "/"
 871     }
 872     if(strcmp("/",token))in->error(in, "not a valid enum definition");
 873     token = getName(in);
 874     if(strcmp("enum",token))in->error(in, "not a valid enum definition");
 875       getRAnglebracket(in); //</label>
 876   }
 877   else if(strcmp(token,"int_fixed") == 0) {
 878     t->type = INT_FIXED;
 879     getTypeAttributes(in, t, unnamed_types, named_types);
 880     if(t->size == 0) in->error(in, "int has empty size");
 881     getForwardslash(in);
 882     getRAnglebracket(in);
 883   }
 884   else if(strcmp(token,"uint_fixed") == 0) {
 885     t->type = UINT_FIXED;
 886     getTypeAttributes(in, t, unnamed_types, named_types);
 887     if(t->size == 0) in->error(in, "uint has empty size");
 888     getForwardslash(in);
 889     getRAnglebracket(in);
 890   }
 891   else if(strcmp(token,"char") == 0) {
 892     t->type = CHAR;
 893     getTypeAttributes(in, t, unnamed_types, named_types);
 894     t->size = 1;
 895     getForwardslash(in);
 896     getRAnglebracket(in);
 897   }
 898   else if(strcmp(token,"uchar") == 0) {
 899     t->type = UCHAR;
 900     getTypeAttributes(in, t, unnamed_types, named_types);
 901     t->size = 1;
 902     getForwardslash(in);
 903     getRAnglebracket(in);
 904   }
 905   else if(strcmp(token,"short") == 0) {
 906     t->type = SHORT;
 907     getTypeAttributes(in, t, unnamed_types, named_types);
 908     t->size = 2;
 909     getForwardslash(in);
 910     getRAnglebracket(in);
 911   }
 912   else if(strcmp(token,"ushort") == 0) {
 913     t->type = USHORT;
 914     getTypeAttributes(in, t, unnamed_types, named_types);
 915     t->size = 2;
 916     getForwardslash(in);
 917     getRAnglebracket(in);
 918   }
 919   else if(strcmp(token,"int") == 0) {
 920     t->type = INT;
 921     getTypeAttributes(in, t, unnamed_types, named_types);
 922     getForwardslash(in);
 923     getRAnglebracket(in);
 924   }
 925   else if(strcmp(token,"uint") == 0) {
 926     t->type = UINT;
 927     getTypeAttributes(in, t, unnamed_types, named_types);
 928     getForwardslash(in);
 929     getRAnglebracket(in);
 930   }
 931
 932   else if(strcmp(token,"pointer") == 0) {
 933     t->type = POINTER;
 934     getTypeAttributes(in, t, unnamed_types, named_types);
 935     getForwardslash(in);
 936     getRAnglebracket(in);
 937   }
 938   else if(strcmp(token,"long") == 0) {
 939     t->type = LONG;
 940     getTypeAttributes(in, t, unnamed_types, named_types);
 941     getForwardslash(in);
 942     getRAnglebracket(in);
 943   }
 944   else if(strcmp(token,"ulong") == 0) {
 945     t->type = ULONG;
 946     getTypeAttributes(in, t, unnamed_types, named_types);
 947     getForwardslash(in);
 948     getRAnglebracket(in);
 949   }
 950   else if(strcmp(token,"size_t") == 0) {
 951     t->type = SIZE_T;
 952     getTypeAttributes(in, t, unnamed_types, named_types);
 953     getForwardslash(in);
 954     getRAnglebracket(in);
 955   }
 956   else if(strcmp(token,"ssize_t") == 0) {
 957     t->type = SSIZE_T;
 958     getTypeAttributes(in, t, unnamed_types, named_types);
 959     getForwardslash(in);
 960     getRAnglebracket(in);
 961   }
 962   else if(strcmp(token,"off_t") == 0) {
 963     t->type = OFF_T;
 964     getTypeAttributes(in, t, unnamed_types, named_types);
 965     getForwardslash(in);
 966     getRAnglebracket(in);
 967   }
 968   else if(strcmp(token,"float") == 0) {
 969     t->type = FLOAT;
 970     getTypeAttributes(in, t, unnamed_types, named_types);
 971     getForwardslash(in);
 972     getRAnglebracket(in);
 973   }
 974   else if(strcmp(token,"string") == 0) {
 975     t->type = STRING;
 976     getTypeAttributes(in, t, unnamed_types, named_types);
 977     getForwardslash(in);
 978     getRAnglebracket(in);
 979   }
 980   else if(strcmp(token,"typeref") == 0){
 981     // Must be a named type
 982     free(t);
 983     sequence_pop(unnamed_types);
 984     token = getNameAttribute(in);
 985     t = find_named_type(token, named_types);
 986     if(t == NULL) in->error(in,"Named referred to must be pre-declared.");
 987     getForwardslash(in);  //<typeref name=type_name/>
 988     getRAnglebracket(in);
 989     return t;
 990   }else in->error(in,"not a valid type");
 991
 992   return t;
 993 }
 994
 995 /*****************************************************************************
 996  *Function name
 997  *    find_named_type     : find a named type from hash table
 998  *Input params
 999  *    name                : type name
1000  *    named_types         : array of named types
1001  *Return values
1002  *    type_descriptor *   : a type descriptor
1003  *****************************************************************************/
1004
1005 type_descriptor_t * find_named_type(char *name, table_t * named_types)
1006 {
1007   type_descriptor_t *t;
1008
1009   t = (type_descriptor_t*)table_find(named_types,name);
1010
1011   return t;
1012 }
1013
1014 type_descriptor_t * create_named_type(char *name, table_t * named_types)
1015 {
1016   type_descriptor_t *t;
1017
1018   t = (type_descriptor_t *)memAlloc(sizeof(type_descriptor_t));
1019   t->type_name = allocAndCopy(name);
1020   t->type = NONE;
1021   t->fmt = NULL;
1022   table_insert(named_types,t->type_name,t);
1023   //    table_insert(named_types,allocAndCopy(name),t);
1024   return t;
1025 }
1026
1027 /*****************************************************************************
1028  *Function name
1029  *    parseTypeDefinition : get type information from type definition
1030  *Input params
1031  *    fac                 : facility
1032  *    in                  : input file handle
1033  *    unnamed_types       : array of unamed types
1034  *    named_types         : array of named types
1035  *****************************************************************************/
1036
1037 void parseTypeDefinition(facility_t *fac, parse_file_t * in, sequence_t * unnamed_types,
1038                          table_t * named_types)
1039 {
1040   char *token;
1041   type_descriptor_t *t;
1042
1043   token = getNameAttribute(in);
1044   if(token == NULL) in->error(in, "Type has empty name");
1045   t = create_named_type(token, named_types);
1046
1047   if(t->type != NONE) in->error(in,"redefinition of named type");
1048   getRAnglebracket(in); //<type name=type_name>
1049   getLAnglebracket(in); //<
1050   token = getName(in);
1051   //MD ??if(strcmp("struct",token))in->error(in,"not a valid type definition");
1052   ungetToken(in);
1053   parseType(fac, in,t, unnamed_types, named_types);
1054
1055   //</type>
1056   getLAnglebracket(in);
1057   getForwardslash(in);
1058   token = getName(in);
1059   if(strcmp("type",token))in->error(in,"not a valid type definition");
1060   getRAnglebracket(in); //</type>
1061 }
1062
1063 /**************************************************************************
1064  * Function :
1065  *    getComa, getName, getNumber, getEqual
1066  * Description :
1067  *    Read a token from the input file, check its type, return it scontent.
1068  *
1069  * Parameters :
1070  *    in , input file handle.
1071  *
1072  * Return values :
1073  *    address of token content.
1074  *
1075  **************************************************************************/
1076
1077 char *getName(parse_file_t * in)
1078 {
1079   char *token;
1080
1081   token = getToken(in);
1082   // Optional descriptions
1083   // if(in->type != NAME) in->error(in,"Name token was expected");
1084   return token;
1085 }
1086
1087 int getNumber(parse_file_t * in)
1088 {
1089   char *token;
1090
1091   token = getToken(in);
1092   if(in->type != NUMBER) in->error(in, "Number token was expected");
1093   return atoi(token);
1094 }
1095
1096 char *getForwardslash(parse_file_t * in)
1097 {
1098   char *token;
1099
1100   token = getToken(in);
1101   //if(in->type != FORWARDSLASH) in->error(in, "forward slash token was expected");
1102   /* Mathieu : final / is optional now. */
1103   if(in->type != FORWARDSLASH) ungetToken(in);
1104
1105   return token;
1106 }
1107
1108 char *getLAnglebracket(parse_file_t * in)
1109 {
1110   char *token;
1111
1112   token = getToken(in);
1113   if(in->type != LANGLEBRACKET) in->error(in, "Left angle bracket was expected");
1114   return token;
1115 }
1116
1117 char *getRAnglebracket(parse_file_t * in)
1118 {
1119   char *token;
1120
1121   token = getToken(in);
1122   if(in->type != RANGLEBRACKET) in->error(in, "Right angle bracket was expected");
1123   return token;
1124 }
1125
1126 char *getQuotedString(parse_file_t * in)
1127 {
1128   char *token;
1129
1130   token = getToken(in);
1131   if(in->type != QUOTEDSTRING) in->error(in, "quoted string was expected");
1132   return token;
1133 }
1134
1135 char * getEqual(parse_file_t *in)
1136 {
1137   char *token;
1138
1139   token = getToken(in);
1140   if(in->type != EQUAL) in->error(in, "equal was expected");
1141   return token;
1142 }
1143
1144 int seekNextChar(parse_file_t *in)
1145 {
1146   int car;
1147   while((car = getc(in->fp)) != EOF) {
1148     if(!isspace(car)){
1149       ungetc(car,in->fp);
1150       return car;
1151     }
1152   }
1153   return EOF;
1154 }
1155
1156 /******************************************************************
1157  * Function :
1158  *    getToken, ungetToken
1159  * Description :
1160  *    Read a token from the input file and return its type and content.
1161  *    Line numbers are accounted for and whitespace/comments are skipped.
1162  *
1163  * Parameters :
1164  *    in, input file handle.
1165  *
1166  * Return values :
1167  *    address of token content.
1168  *
1169  ******************************************************************/
1170
1171 void ungetToken(parse_file_t * in)
1172 {
1173   in->unget = 1;
1174 }
1175
1176 char *getToken(parse_file_t * in)
1177 {
1178   FILE *fp = in->fp;
1179   int car, car1;
1180   int pos = 0, escaped;
1181
1182   if(in->unget == 1) {
1183     in->unget = 0;
1184     return in->buffer;
1185   }
1186
1187   /* skip whitespace and comments */
1188
1189   while((car = getc(fp)) != EOF) {
1190     if(car == '/') {
1191       car1 = getc(fp);
1192       if(car1 == '*') skipComment(in);
1193       else if(car1 == '/') skipEOL(in);
1194       else {
1195         car1 = ungetc(car1,fp);
1196         break;
1197       }
1198     }
1199     else if(car == '\n') in->lineno++;
1200     else if(!isspace(car)) break;
1201   }
1202
1203   switch(car) {
1204     case EOF:
1205       in->type = ENDFILE;
1206       break;
1207     case '/':
1208       in->type = FORWARDSLASH;
1209       in->buffer[pos] = car;
1210       pos++;
1211       break;
1212     case '<':
1213       in->type = LANGLEBRACKET;
1214       in->buffer[pos] = car;
1215       pos++;
1216       break;
1217     case '>':
1218       in->type = RANGLEBRACKET;
1219       in->buffer[pos] = car;
1220       pos++;
1221       break;
1222     case '=':
1223       in->type = EQUAL;
1224       in->buffer[pos] = car;
1225       pos++;
1226       break;
1227     case '"':
1228       escaped = 0;
1229       while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
1230         if(car == '\\' && escaped == 0) {
1231           in->buffer[pos] = car;
1232           pos++;
1233           escaped = 1;
1234           continue;
1235         }
1236         if(car == '"' && escaped == 0) break;
1237         if(car == '\n' && escaped == 0) {
1238           in->error(in, "non escaped newline inside quoted string");
1239         }
1240         if(car == '\n') in->lineno++;
1241         in->buffer[pos] = car;
1242         pos++;
1243         escaped = 0;
1244       }
1245       if(car == EOF) in->error(in,"no ending quotemark");
1246       if(pos == BUFFER_SIZE) in->error(in, "quoted string token too large");
1247       in->type = QUOTEDSTRING;
1248       break;
1249     default:
1250       if(isdigit(car)) {
1251         in->buffer[pos] = car;
1252         pos++;
1253         while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
1254           if(!isdigit(car)) {
1255             ungetc(car,fp);
1256             break;
1257           }
1258           in->buffer[pos] = car;
1259           pos++;
1260         }
1261         if(car == EOF) ungetc(car,fp);
1262         if(pos == BUFFER_SIZE) in->error(in, "number token too large");
1263         in->type = NUMBER;
1264       }
1265       else if(isalnum(car) || car == '_' || car == '-') {
1266         in->buffer[0] = car;
1267         pos = 1;
1268         while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
1269           if(!(isalnum(car) || car == '_' || car == '-')) {
1270             ungetc(car,fp);
1271             break;
1272           }
1273           in->buffer[pos] = car;
1274           pos++;
1275         }
1276       if(car == EOF) ungetc(car,fp);
1277         if(pos == BUFFER_SIZE) in->error(in, "name token too large");
1278         in->type = NAME;
1279       } else if(car == '?') {
1280         in->buffer[0] = car;
1281         pos++;
1282       }
1283       else in->error(in, "invalid character, unrecognized token");
1284   }
1285   in->buffer[pos] = 0;
1286   return in->buffer;
1287 }
1288
1289 void skipComment(parse_file_t * in)
1290 {
1291   int car;
1292   while((car = getc(in->fp)) != EOF) {
1293     if(car == '\n') in->lineno++;
1294     else if(car == '*') {
1295       car = getc(in->fp);
1296       if(car ==EOF) break;
1297       if(car == '/') return;
1298       ungetc(car,in->fp);
1299     }
1300   }
1301   if(car == EOF) in->error(in,"comment begining with '/*' has no ending '*/'");
1302 }
1303
1304 void skipEOL(parse_file_t * in)
1305 {
1306   int car;
1307   while((car = getc(in->fp)) != EOF) {
1308     if(car == '\n') {
1309       ungetc(car,in->fp);
1310       break;
1311     }
1312   }
1313   if(car == EOF)ungetc(car, in->fp);
1314 }
1315
1316 /*****************************************************************************
1317  *Function name
1318  *    checkNamedTypesImplemented : check if all named types have definition
1319  ****************************************************************************/
1320
1321 void checkNamedTypesImplemented(table_t * named_types)
1322 {
1323   type_descriptor_t *t;
1324   int pos;
1325   char str[256];
1326
1327   for(pos = 0 ; pos < named_types->values.position; pos++) {
1328     t = (type_descriptor_t *) named_types->values.array[pos];
1329     if(t->type == NONE){
1330       sprintf(str,"named type '%s' has no definition",
1331           (char*)named_types->keys.array[pos]);
1332       error_callback(NULL,str);
1333     }
1334   }
1335 }
1336
1337
1338 /*****************************************************************************
1339  *Function name
1340  *    generateChecksum  : generate checksum for the facility
1341  *Input Params
1342  *    facName           : name of facility
1343  *Output Params
1344  *    checksum          : checksum for the facility
1345  ****************************************************************************/
1346
1347 void generateChecksum(char* facName,
1348     unsigned int * checksum, sequence_t * events)
1349 {
1350   unsigned long crc ;
1351   int pos;
1352   event_t * ev;
1353   unsigned int i;
1354
1355   crc = crc32(facName);
1356   for(pos = 0; pos < events->position; pos++){
1357     ev = (event_t *)(events->array[pos]);
1358     crc = partial_crc32(ev->name, crc);
1359     for(i = 0; i < ev->fields.position; i++) {
1360       field_t *f = (field_t*)ev->fields.array[i];
1361       crc = partial_crc32(f->name, crc);
1362       crc = getTypeChecksum(crc, f->type);
1363     }
1364   }
1365   *checksum = crc;
1366 }
1367
1368 /*****************************************************************************
1369  *Function name
1370  *   getTypeChecksum    : generate checksum by type info
1371  *Input Params
1372  *    crc               : checksum generated so far
1373  *    type              : type descriptor containing type info
1374  *Return value
1375  *    unsigned long     : checksum
1376  *****************************************************************************/
1377
1378 unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor_t * type)
1379 {
1380   unsigned long crc = aCrc;
1381   char * str = NULL, buf[16];
1382   int flag = 0, pos;
1383   field_t * fld;
1384
1385   switch(type->type){
1386     case INT_FIXED:
1387       str = intOutputTypes[getSizeindex(type->size)];
1388       break;
1389     case UINT_FIXED:
1390       str = uintOutputTypes[getSizeindex(type->size)];
1391       break;
1392     case POINTER:
1393       str = allocAndCopy("void *");
1394       flag = 1;
1395       break;
1396     case CHAR:
1397       str = allocAndCopy("signed char");
1398       flag = 1;
1399       break;
1400     case UCHAR:
1401       str = allocAndCopy("unsigned char");
1402       flag = 1;
1403       break;
1404     case SHORT:
1405       str = allocAndCopy("short");
1406       flag = 1;
1407       break;
1408     case USHORT:
1409       str = allocAndCopy("unsigned short");
1410       flag = 1;
1411       break;
1412     case INT:
1413       str = allocAndCopy("int");
1414       flag = 1;
1415       break;
1416     case UINT:
1417       str = allocAndCopy("uint");
1418       flag = 1;
1419       break;
1420     case LONG:
1421       str = allocAndCopy("long");
1422       flag = 1;
1423       break;
1424     case ULONG:
1425       str = allocAndCopy("unsigned long");
1426       flag = 1;
1427       break;
1428     case SIZE_T:
1429       str = allocAndCopy("size_t");
1430       flag = 1;
1431       break;
1432     case SSIZE_T:
1433       str = allocAndCopy("ssize_t");
1434       flag = 1;
1435       break;
1436     case OFF_T:
1437       str = allocAndCopy("off_t");
1438       flag = 1;
1439       break;
1440     case FLOAT:
1441       str = floatOutputTypes[getSizeindex(type->size)];
1442       break;
1443     case STRING:
1444       str = allocAndCopy("string");
1445       flag = 1;
1446       break;
1447     case ENUM:
1448       //str = appendString("enum ", uintOutputTypes[getSizeindex(type->size)]);
1449       str = allocAndCopy("enum");
1450       flag = 1;
1451       break;
1452     case ARRAY:
1453       sprintf(buf,"%zu", type->size);
1454       str = appendString("array ",buf);
1455       flag = 1;
1456       break;
1457     case SEQUENCE:
1458       str = allocAndCopy("sequence ");
1459       flag = 1;
1460       break;
1461     case STRUCT:
1462       str = allocAndCopy("struct");
1463       flag = 1;
1464       break;
1465     case UNION:
1466       str = allocAndCopy("union");
1467       flag = 1;
1468       break;
1469     default:
1470       error_callback(NULL, "named type has no definition");
1471       break;
1472   }
1473
1474   crc = partial_crc32(str,crc);
1475   if(flag) free(str);
1476
1477   if(type->fmt) crc = partial_crc32(type->fmt,crc);
1478
1479   if(type->type == ARRAY){
1480     crc = getTypeChecksum(crc,((field_t*)type->fields.array[0])->type);
1481   } else if(type->type ==SEQUENCE) {
1482     crc = getTypeChecksum(crc,((field_t*)type->fields.array[0])->type);
1483     crc = getTypeChecksum(crc,((field_t*)type->fields.array[1])->type);
1484   } else if(type->type == STRUCT || type->type == UNION){
1485     for(pos =0; pos < type->fields.position; pos++){
1486       fld = (field_t *) type->fields.array[pos];
1487       crc = partial_crc32(fld->name,crc);
1488       crc = getTypeChecksum(crc, fld->type);
1489     }
1490   }else if(type->type == ENUM){
1491     for(pos = 0; pos < type->labels.position; pos++)
1492       crc = partial_crc32((char*)type->labels.array[pos],crc);
1493   }
1494
1495   return crc;
1496 }
1497
1498
1499 /* Event type descriptors */
1500 void freeType(type_descriptor_t * tp)
1501 {
1502   int pos2;
1503   field_t *f;
1504
1505   if(tp->fmt != NULL) free(tp->fmt);
1506   if(tp->type == ENUM) {
1507     for(pos2 = 0; pos2 < tp->labels.position; pos2++) {
1508       free(tp->labels.array[pos2]);
1509     }
1510     sequence_dispose(&(tp->labels));
1511     for(pos2 = 0; pos2 < tp->labels_values.position; pos2++) {
1512       free(tp->labels_values.array[pos2]);
1513     }
1514     sequence_dispose(&(tp->labels_values));
1515   }
1516   if(tp->type == STRUCT) {
1517     for(pos2 = 0; pos2 < tp->fields.position; pos2++) {
1518       f = (field_t *) tp->fields.array[pos2];
1519       free(f->name);
1520       free(f->description);
1521       free(f);
1522     }
1523     sequence_dispose(&(tp->fields));
1524   }
1525 }
1526
1527 void freeNamedType(table_t * t)
1528 {
1529   int pos;
1530   type_descriptor_t * td;
1531
1532   for(pos = 0 ; pos < t->keys.position; pos++) {
1533     free((char *)t->keys.array[pos]);
1534     td = (type_descriptor_t*)t->values.array[pos];
1535     freeType(td);
1536     free(td);
1537   }
1538 }
1539
1540 void freeTypes(sequence_t *t)
1541 {
1542   int pos;
1543   type_descriptor_t *tp;
1544
1545   for(pos = 0 ; pos < t->position; pos++) {
1546     tp = (type_descriptor_t *)t->array[pos];
1547     freeType(tp);
1548     free(tp);
1549   }
1550 }
1551
1552 void freeEvents(sequence_t *t)
1553 {
1554   int pos;
1555   event_t *ev;
1556
1557   for(pos = 0 ; pos < t->position; pos++) {
1558     ev = (event_t *) t->array[pos];
1559     free(ev->name);
1560     free(ev->description);
1561     sequence_dispose(&ev->fields);
1562     free(ev);
1563   }
1564
1565 }
1566
1567
1568 /* Extensible array */
1569
1570 void sequence_init(sequence_t *t)
1571 {
1572   t->size = 10;
1573   t->position = 0;
1574   t->array = (void **)memAlloc(t->size * sizeof(void *));
1575 }
1576
1577 void sequence_dispose(sequence_t *t)
1578 {
1579   t->size = 0;
1580   free(t->array);
1581   t->array = NULL;
1582 }
1583
1584 void sequence_push(sequence_t *t, void *elem)
1585 {
1586   void **tmp;
1587
1588   if(t->position >= t->size) {
1589     tmp = t->array;
1590     t->array = (void **)memAlloc(t->size * 2 * sizeof(void *));
1591     memcpy(t->array, tmp, t->size * sizeof(void *));
1592     t->size = t->size * 2;
1593     free(tmp);
1594   }
1595   t->array[t->position] = elem;
1596   t->position++;
1597 }
1598
1599 void *sequence_pop(sequence_t *t)
1600 {
1601   if(t->position == 0) printf("Error : trying to pop an empty sequence");
1602   return t->array[--t->position];
1603 }
1604
1605
1606 /* Hash table API, implementation is just linear search for now */
1607
1608 void table_init(table_t *t)
1609 {
1610   sequence_init(&(t->keys));
1611   sequence_init(&(t->values));
1612 }
1613
1614 void table_dispose(table_t *t)
1615 {
1616   sequence_dispose(&(t->keys));
1617   sequence_dispose(&(t->values));
1618 }
1619
1620 void table_insert(table_t *t, char *key, void *value)
1621 {
1622   sequence_push(&(t->keys),key);
1623   sequence_push(&(t->values),value);
1624 }
1625
1626 void *table_find(table_t *t, char *key)
1627 {
1628   int pos;
1629   for(pos = 0 ; pos < t->keys.position; pos++) {
1630     if(strcmp((char *)key,(char *)t->keys.array[pos]) == 0)
1631       return(t->values.array[pos]);
1632   }
1633   return NULL;
1634 }
1635
1636 void table_insert_int(table_t *t, int *key, void *value)
1637 {
1638   sequence_push(&(t->keys),key);
1639   sequence_push(&(t->values),value);
1640 }
1641
1642 void *table_find_int(table_t *t, int *key)
1643 {
1644   int pos;
1645   for(pos = 0 ; pos < t->keys.position; pos++) {
1646     if(*key == *(int *)t->keys.array[pos])
1647       return(t->values.array[pos]);
1648   }
1649   return NULL;
1650 }
1651
1652
1653 /* Concatenate strings */
1654
1655 char *appendString(char *s, char *suffix)
1656 {
1657   char *tmp;
1658   if(suffix == NULL) return s;
1659
1660   tmp = (char *)memAlloc(strlen(s) + strlen(suffix) + 1);
1661   strcpy(tmp,s);
1662   strcat(tmp,suffix);
1663   return tmp;
1664 }