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