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