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