From: yangxx <yangxx@04897980-b3bd-0310-b5e0-8ef037075253>
Date: Wed, 16 Jul 2003 19:18:48 +0000 (+0000)
Subject: new version of the reading API
X-Git-Tag: v0.12.20~3385
X-Git-Url: https://git.lttng.org./?a=commitdiff_plain;h=963b5f2df23dc1c70bdc70d4aecb76f50651997b;p=lttv.git

new version of the reading API

git-svn-id: http://ltt.polymtl.ca/svn@104 04897980-b3bd-0310-b5e0-8ef037075253
---

diff --git a/ltt/branches/poly/include/ltt/trace.h b/ltt/branches/poly/include/ltt/trace.h
index be0311fb..e96e73e4 100644
--- a/ltt/branches/poly/include/ltt/trace.h
+++ b/ltt/branches/poly/include/ltt/trace.h
@@ -1,5 +1,5 @@
-#ifndef TRACEFILE_H
-#define TRACEFILE_H
+#ifndef TRACE_H
+#define TRACE_H
 
 #include <ltt/ltt.h>
 
@@ -18,10 +18,10 @@ void ltt_trace_close(LttTrace *t);
 /* The characteristics of the system on which the trace was obtained
    is described in a LttSystemDescription structure. */
 
-typedef struct _LttSystemDescription {
+struct _LttSystemDescription {
   char *description;
   char *node_name;
-  char *domainname;
+  char *domain_name;
   unsigned nb_cpu;
   LttArchSize size;
   LttArchEndian endian;
@@ -37,9 +37,9 @@ typedef struct _LttSystemDescription {
   unsigned ltt_block_size;
   LttTime trace_start;
   LttTime trace_end;
-} LttSystemDescription;
+};
 
-LttSystemDescription *ltt_trace_system_description(LttTrace *t)
+LttSystemDescription *ltt_trace_system_description(LttTrace *t);
 
 
 /* Functions to discover the facilities in the trace. Once the number
diff --git a/ltt/branches/poly/include/ltt/type.h b/ltt/branches/poly/include/ltt/type.h
index dd53c096..e43a1fd6 100644
--- a/ltt/branches/poly/include/ltt/type.h
+++ b/ltt/branches/poly/include/ltt/type.h
@@ -1,8 +1,6 @@
 #ifndef TYPE_H
 #define TYPE_H
 
-#include <ltt/ltt.h>
-
 
 /* Different types allowed */
 
@@ -11,6 +9,8 @@ typedef enum _LttTypeEnum
   LTT_SEQUENCE, LTT_STRUCT, LTT_UNION
 } LttTypeEnum;
 
+#include <ltt/ltt.h>
+
 
 /* All event types, data types and fields belong to their trace and 
    are released at the same time. */
@@ -41,7 +41,7 @@ char *ltt_type_name(LttType *t);
 
 LttTypeEnum ltt_type_class(LttType *t);
 
-unsigned ltt_type_size(LttTracefile *tf, LttType *t); 
+unsigned ltt_type_size(LttTrace *trace, LttType *t); 
 
 
 /* The type of nested elements for arrays and sequences. */
diff --git a/ltt/branches/poly/ltt/event.c b/ltt/branches/poly/ltt/event.c
index 791dabcc..ed605b9f 100644
--- a/ltt/branches/poly/ltt/event.c
+++ b/ltt/branches/poly/ltt/event.c
@@ -1,22 +1,21 @@
 #include <stdio.h>
 #include <asm/types.h>
 #include <linux/byteorder/swab.h>
-
 #include <ltt/LTTTypes.h> 
 #include "parser.h"
 #include <ltt/event.h>
 
 /*****************************************************************************
  *Function name
- *    ltt_facility_eventtype_id: get event type id 
- *                               (base id + position of the event)
+ *    ltt_event_eventtype_id: get event type id 
+ *                            (base id + position of the event)
  *Input params
- *    e                        : an instance of an event type   
+ *    e                     : an instance of an event type   
  *Return value
- *    unsigned                 : event type id
+ *    unsigned              : event type id
  ****************************************************************************/
 
-unsigned ltt_event_eventtype_id(ltt_event *e)
+unsigned ltt_event_eventtype_id(LttEvent *e)
 {
   return (unsigned) e->event_id;
 }
@@ -27,19 +26,14 @@ unsigned ltt_event_eventtype_id(ltt_event *e)
  *Input params
  *    e                  : an instance of an event type   
  *Return value
- *    ltt_facility *     : the facility of the event
+ *    LttFacility *     : the facility of the event
  ****************************************************************************/
 
-ltt_facility *ltt_event_facility(ltt_event *e)
+LttFacility *ltt_event_facility(LttEvent *e)
 {
-  ltt_eventtype * evT;
-  ptr_wrap * ptr;
-  ptr = (ptr_wrap*)g_ptr_array_index(e->tracefile->eventtype_event_id, 
-					  (gint)(e->event_id));
-  evT = (ltt_eventtype*)(ptr->ptr);
-
-  if(!evT) return NULL;
-  return evT->facility;
+  LttTrace * trace = e->tracefile->trace;
+  unsigned id = e->event_id;
+  return ltt_trace_facility_by_id(trace,id);
 }
 
 /*****************************************************************************
@@ -48,71 +42,72 @@ ltt_facility *ltt_event_facility(ltt_event *e)
  *Input params
  *    e                   : an instance of an event type   
  *Return value
- *    ltt_eventtype *     : the event type of the event
+ *    LttEventType *     : the event type of the event
  ****************************************************************************/
 
-ltt_eventtype *ltt_event_eventtype(ltt_event *e)
+LttEventType *ltt_event_eventtype(LttEvent *e)
 {
-  ptr_wrap * ptr;
-  ptr = (ptr_wrap*)g_ptr_array_index(e->tracefile->eventtype_event_id, 
-					  (gint)(e->event_id));
-  return (ltt_eventtype*)(ptr->ptr);
+  LttFacility* facility = ltt_event_facility(e);
+  if(!facility) return NULL;
+  return facility->events[e->event_id - facility->base_id];
 }
 
 /*****************************************************************************
  *Function name
- *    ltt_event_time : get the time of the event
+ *    ltt_event_field : get the root field of the event
  *Input params
- *    e              : an instance of an event type   
+ *    e               : an instance of an event type   
  *Return value
- *    ltt_time       : the time of the event
+ *    LttField *      : the root field of the event
  ****************************************************************************/
 
-ltt_time ltt_event_time(ltt_event *e)
+LttField *ltt_event_field(LttEvent *e)
 {
-  return getEventTime(e->tracefile);
+  LttEventType * event_type = ltt_event_eventtype(e);
+  if(!event_type) return NULL;
+  return event_type->root_field;
 }
 
 /*****************************************************************************
  *Function name
- *    ltt_event_time : get the cycle count of the event
+ *    ltt_event_time : get the time of the event
  *Input params
  *    e              : an instance of an event type   
  *Return value
- *    ltt_time       : the cycle count of the event
+ *    LttTime       : the time of the event
  ****************************************************************************/
 
-ltt_cycle_count ltt_event_cycle_count(ltt_event *e)
+LttTime ltt_event_time(LttEvent *e)
 {
-  return e->cycle_count;
+  return e->event_time;
 }
 
 /*****************************************************************************
  *Function name
- *    ltt_event_cpu_i: get the cpu id where the event happens
+ *    ltt_event_time : get the cycle count of the event
  *Input params
  *    e              : an instance of an event type   
  *Return value
- *    unsigned       : the cpu id
+ *    LttCycleCount  : the cycle count of the event
  ****************************************************************************/
 
-unsigned ltt_event_cpu_id(ltt_event *e)
+LttCycleCount ltt_event_cycle_count(LttEvent *e)
 {
-  return e->tracefile->trace_header->cpu_id;
+  return e->event_cycle_count;
 }
 
 /*****************************************************************************
  *Function name
- *    ltt_event_cpu_i: get the name of the system where the event happens
+ *    ltt_event_cpu_i: get the cpu id where the event happens
  *Input params
  *    e              : an instance of an event type   
  *Return value
- *    char *         : the name of the system
+ *    unsigned       : the cpu id
  ****************************************************************************/
 
-char *ltt_event_system_name(ltt_event *e)
-{
-  return e->tracefile->trace_header->system_name;  
+unsigned ltt_event_cpu_id(LttEvent *e)
+{  
+  return (unsigned)atoi(e->tracefile->name);
 }
 
 /*****************************************************************************
@@ -124,7 +119,7 @@ char *ltt_event_system_name(ltt_event *e)
  *    void *         : pointer to the raw data for the event
  ****************************************************************************/
 
-void *ltt_event_data(ltt_event *e)
+void *ltt_event_data(LttEvent *e)
 {
   return e->data;
 }
@@ -142,7 +137,7 @@ void *ltt_event_data(ltt_event *e)
  *    unsigned       : the number of elements for an array/sequence field
  ****************************************************************************/
 
-unsigned ltt_event_field_element_number(ltt_event *e, ltt_field *f)
+unsigned ltt_event_field_element_number(LttEvent *e, LttField *f)
 {
   if(f->field_type->type_class != LTT_ARRAY &&
      f->field_type->type_class != LTT_SEQUENCE)
@@ -160,20 +155,17 @@ unsigned ltt_event_field_element_number(ltt_event *e, ltt_field *f)
  *    e              : an instance of an event type   ????
  *    f              : a field of the instance
  *    i              : the ith element
- *Return value
- *    int            : ???? error number
  ****************************************************************************/
 
-int ltt_event_field_element_select(ltt_event *e, ltt_field *f, unsigned i)
+void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i)
 {
    if(f->field_type->type_class != LTT_ARRAY &&
      f->field_type->type_class != LTT_SEQUENCE)
-     return -1; //?????
+     return ;
    
-   if(f->field_type->element_number < i || i == 0) return -1; //????
+   if(f->field_type->element_number < i || i == 0) return;
 
    f->current_element = i - 1;
-   return 0;
 }
 
 /*****************************************************************************
@@ -181,12 +173,12 @@ int ltt_event_field_element_select(ltt_event *e, ltt_field *f, unsigned i)
  * conversions
  ****************************************************************************/
 
-unsigned ltt_event_get_unsigned(ltt_event *e, ltt_field *f)
+unsigned ltt_event_get_unsigned(LttEvent *e, LttField *f)
 {
-  ltt_arch_size rSize = e->tracefile->trace_header->arch_size;
-  int revFlag = e->tracefile->my_arch_endian == 
-                e->tracefile->trace_header->arch_endian ? 0:1;
-  ltt_type_enum t = f->field_type->type_class;
+  LttArchSize rSize = e->tracefile->trace->system_description->size;
+  int revFlag = e->tracefile->trace->my_arch_endian == 
+                e->tracefile->trace->system_description->endian ? 0:1;
+  LttTypeEnum t = f->field_type->type_class;
 
   if(t != LTT_UINT || t != LTT_ENUM)
     g_error("The type of the field is not unsigned int\n");
@@ -215,11 +207,11 @@ unsigned ltt_event_get_unsigned(ltt_event *e, ltt_field *f)
   }
 }
 
-int ltt_event_get_int(ltt_event *e, ltt_field *f)
+int ltt_event_get_int(LttEvent *e, LttField *f)
 {
-  ltt_arch_size rSize = e->tracefile->trace_header->arch_size;
-  int revFlag = e->tracefile->my_arch_endian == 
-                e->tracefile->trace_header->arch_endian ? 0:1;
+  LttArchSize rSize = e->tracefile->trace->system_description->size;
+  int revFlag = e->tracefile->trace->my_arch_endian == 
+                e->tracefile->trace->system_description->endian ? 0:1;
 
   if(f->field_type->type_class != LTT_INT)
     g_error("The type of the field is not int\n");
@@ -248,12 +240,12 @@ int ltt_event_get_int(ltt_event *e, ltt_field *f)
   }
 }
 
-unsigned long ltt_event_get_long_unsigned(ltt_event *e, ltt_field *f)
+unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
 {
-  ltt_arch_size rSize = e->tracefile->trace_header->arch_size;
-  int revFlag = e->tracefile->my_arch_endian == 
-                e->tracefile->trace_header->arch_endian ? 0:1;
-  ltt_type_enum t = f->field_type->type_class;
+  LttArchSize rSize = e->tracefile->trace->system_description->size;
+  int revFlag = e->tracefile->trace->my_arch_endian == 
+                e->tracefile->trace->system_description->endian ? 0:1;
+  LttTypeEnum t = f->field_type->type_class;
 
   if(t != LTT_UINT || t != LTT_ENUM)
     g_error("The type of the field is not unsigned long\n");
@@ -275,11 +267,11 @@ unsigned long ltt_event_get_long_unsigned(ltt_event *e, ltt_field *f)
   }
 }
 
-long int ltt_event_get_long_int(ltt_event *e, ltt_field *f)
+long int ltt_event_get_long_int(LttEvent *e, LttField *f)
 {
-  ltt_arch_size rSize = e->tracefile->trace_header->arch_size;
-  int revFlag = e->tracefile->my_arch_endian == 
-                e->tracefile->trace_header->arch_endian ? 0:1;
+  LttArchSize rSize = e->tracefile->trace->system_description->size;
+  int revFlag = e->tracefile->trace->my_arch_endian == 
+                e->tracefile->trace->system_description->endian ? 0:1;
 
   if( f->field_type->type_class != LTT_INT)
     g_error("The type of the field is not long int\n");
@@ -301,10 +293,10 @@ long int ltt_event_get_long_int(ltt_event *e, ltt_field *f)
   }
 }
 
-float ltt_event_get_float(ltt_event *e, ltt_field *f)
+float ltt_event_get_float(LttEvent *e, LttField *f)
 {
-  int revFlag = e->tracefile->my_arch_endian == 
-                e->tracefile->trace_header->arch_endian ? 0:1;
+  int revFlag = e->tracefile->trace->my_arch_endian == 
+                e->tracefile->trace->system_description->endian ? 0:1;
 
   if(f->field_type->type_class != LTT_FLOAT || 
      (f->field_type->type_class == LTT_FLOAT && f->field_size != 4))
@@ -319,10 +311,10 @@ float ltt_event_get_float(ltt_event *e, ltt_field *f)
   }
 }
 
-double ltt_event_get_double(ltt_event *e, ltt_field *f)
+double ltt_event_get_double(LttEvent *e, LttField *f)
 {
-  int revFlag = e->tracefile->my_arch_endian == 
-                e->tracefile->trace_header->arch_endian ? 0:1;
+  int revFlag = e->tracefile->trace->my_arch_endian == 
+                e->tracefile->trace->system_description->endian ? 0:1;
 
   if(f->field_type->type_class != LTT_FLOAT || 
      (f->field_type->type_class == LTT_FLOAT && f->field_size != 8))
@@ -342,7 +334,7 @@ double ltt_event_get_double(ltt_event *e, ltt_field *f)
  * the same tracefile. ????
  ****************************************************************************/
 
-char *ltt_event_get_string(ltt_event *e, ltt_field *f)
+char *ltt_event_get_string(LttEvent *e, LttField *f)
 {
   if(f->field_type->type_class != LTT_STRING)
     g_error("The field contains no string\n");
diff --git a/ltt/branches/poly/ltt/facility.c b/ltt/branches/poly/ltt/facility.c
index 5ededcaa..1c31f019 100644
--- a/ltt/branches/poly/ltt/facility.c
+++ b/ltt/branches/poly/ltt/facility.c
@@ -8,102 +8,92 @@
 
 /* search for the (named) type in the table, if it does not exist
    create a new one */
-ltt_type * lookup_named_type(ltt_facility *fac, type_descriptor * td);
+LttType * lookup_named_type(LttFacility *fac, type_descriptor * td);
 
 /* construct directed acyclic graph for types, and tree for fields */
-void constructTypeAndFields(ltt_facility * fac,type_descriptor * td, 
-                            ltt_field * fld);
+void constructTypeAndFields(LttFacility * fac,type_descriptor * td, 
+                            LttField * fld);
 
 /* generate the facility according to the events belongin to it */
-void generateFacility(ltt_facility * facility, char * pathname, 
-                      ltt_checksum checksum, sequence * events);
+void generateFacility(LttFacility * f, facility  * fac, 
+                      LttChecksum checksum);
 
 /* functions to release the memory occupied by a facility */
-void freeFacility(ltt_facility * facility);
-void freeEventtype(ltt_eventtype * evType);
+void freeFacility(LttFacility * facility);
+void freeEventtype(LttEventType * evType);
 void freeAllNamedTypes(table * named_types);
 void freeAllUnamedTypes(sequence * unnamed_types);
 void freeAllFields(sequence * all_fields);
-void freeLttType(ltt_type * type);
-void freeLttField(ltt_field * fld);
+void freeLttType(LttType * type);
+void freeLttField(LttField * fld);
 
 
 /*****************************************************************************
  *Function name
- *    ltt_facility_open       : open a facility
+ *    ltt_facility_open       : open facilities
  *Input params
+ *    t                       : the trace containing the facilities
  *    pathname                : the path name of the facility   
- *    c                       : checksum of the facility registered in kernal
- *Return value
- *    ltt_facility*           : return a ltt_facility
  ****************************************************************************/
 
-ltt_facility * ltt_facility_open(char * pathname, ltt_checksum c)
+void ltt_facility_open(LttTrace * t, char * pathname)
 {
   char *token;
   parse_file in;
   char buffer[BUFFER_SIZE];
-  ltt_checksum checksum;
-  event *ev;
-  sequence  events;
-  table namedTypes;
-  sequence unnamedTypes;
-  ltt_facility * aFacility = NULL;
-
-  sequence_init(&events);
-  table_init(&namedTypes);
-  sequence_init(&unnamedTypes);
+  facility * fac;
+  LttFacility * f;
+  LttChecksum checksum;
 
   in.buffer = buffer;
   in.lineno = 0;
   in.error = error_callback;
-  in.name = appendString(pathname,".event");
+  in.name = pathname;
 
   in.fp = fopen(in.name, "r");
-  if(!in.fp )g_error("cannot open input file: %s\n", in.name);
- 
+  if(!in.fp ) in.error(&in,"cannot open input file");
+
   while(1){
     token = getToken(&in);
     if(in.type == ENDFILE) break;
     
-    if(strcmp("event",token) == 0) {
-      ev = g_new(event,1);
-      sequence_push(&events,ev);
-      parseEvent(&in,ev, &unnamedTypes, &namedTypes);
-    }
-    else if(strcmp("type",token) == 0) {
-      parseTypeDefinition(&in, &unnamedTypes, &namedTypes);
+    if(strcmp(token, "<")) in.error(&in,"not a facility file");
+    token = getName(&in);
+    
+    if(strcmp("facility",token) == 0) {
+      fac = g_new(facility, 1);
+      fac->name = NULL;
+      fac->description = NULL;
+      sequence_init(&(fac->events));
+      table_init(&(fac->named_types));
+      sequence_init(&(fac->unnamed_types));
+      
+      parseFacility(&in, fac);
+
+      //check if any namedType is not defined
+      checkNamedTypesImplemented(&fac->named_types);
+    
+      generateChecksum(fac->name, &checksum, &fac->events);
+
+      f = g_new(LttFacility,1);    
+      generateFacility(f, fac, checksum);
+
+      t->facility_number++;
+      g_ptr_array_add(t->facilities,f);
+
+      free(fac->name);
+      free(fac->description);
+      freeEvents(&fac->events);
+      sequence_dispose(&fac->events);
+      freeNamedType(&fac->named_types);
+      table_dispose(&fac->named_types);
+      freeTypes(&fac->unnamed_types);
+      sequence_dispose(&fac->unnamed_types);      
+      free(fac);
     }
-    else g_error("event or type token expected\n");
+    else in.error(&in,"facility token was expected");
   }
-  
   fclose(in.fp);
-
-  checkNamedTypesImplemented(&namedTypes);
-
-  generateChecksum(pathname, &checksum, &events);
-
-  //yxx disable during the test
-  aFacility = g_new(ltt_facility,1);    
-  generateFacility(aFacility, pathname, checksum, &events);
-/*
-  if(checksum == c){
-    aFacility = g_new(ltt_facility,1);    
-    generateFacility(aFacility, pathname, checksum, &events);
-  }else{
-    g_error("local facility is different from the one registered in the kernel");
-  }
-*/
-
-  free(in.name);
-  freeEvents(&events);
-  sequence_dispose(&events);
-  freeNamedType(&namedTypes);
-  table_dispose(&namedTypes);
-  freeTypes(&unnamedTypes);
-  sequence_dispose(&unnamedTypes);
-
-  return aFacility;
 }
 
 
@@ -111,53 +101,46 @@ ltt_facility * ltt_facility_open(char * pathname, ltt_checksum c)
  *Function name
  *    generateFacility    : generate facility, internal function
  *Input params 
- *    facility            : facilty structure
- *    facName             : facility name
+ *    facility            : LttFacilty structure
+ *    fac                 : facility structure
  *    checksum            : checksum of the facility          
- *    events              : sequence of events belonging to the facility
  ****************************************************************************/
 
-void generateFacility(ltt_facility * facility, char * pathname, 
-                      ltt_checksum checksum, sequence * events)
+void generateFacility(LttFacility *f, facility *fac,LttChecksum checksum)
 {
-  char * facilityName;
+  char * facilityName = fac->name;
+  sequence * events = &fac->events;
   int i;
-  ltt_eventtype * evType;
-  ltt_field * field;
-  ltt_type * type;
-
-  //get the facility name (strip any leading directory) 
-  facilityName = strrchr(pathname,'/');
-  if(facilityName) facilityName++;    
-  else facilityName = pathname;
+  LttEventType * evType;
+  LttField * field;
+  LttType * type;
   
-  facility->name = g_strdup(facilityName);
-  facility->event_number = events->position;
-  facility->checksum = checksum;
-  facility->usage_count = 0;
+  f->name = g_strdup(facilityName);
+  f->event_number = events->position;
+  f->checksum = checksum;
   
   //initialize inner structures
-  facility->events = g_new(ltt_eventtype*,facility->event_number); 
-  sequence_init(&(facility->all_fields));
-  sequence_init(&(facility->all_unnamed_types));
-  table_init(&(facility->all_named_types));
+  f->events = g_new(LttEventType*,f->event_number); 
+  sequence_init(&(f->all_fields));
+  sequence_init(&(f->all_unnamed_types));
+  table_init(&(f->all_named_types));
 
   //for each event, construct field tree and type graph
   for(i=0;i<events->position;i++){
-    evType = g_new(ltt_eventtype,1);
-    facility->events[i] = evType;
+    evType = g_new(LttEventType,1);
+    f->events[i] = evType;
 
     evType->name = g_strdup(((event*)(events->array[i]))->name);
     evType->description=g_strdup(((event*)(events->array[i]))->description);
     
-    field = g_new(ltt_field, 1);
-    sequence_push(&(facility->all_fields), field);
+    field = g_new(LttField, 1);
+    sequence_push(&(f->all_fields), field);
     evType->root_field = field;
-    evType->facility = facility;
+    evType->facility = f;
     evType->index = i;
 
     field->field_pos = 0;
-    type = lookup_named_type(facility,((event*)(events->array[i]))->type);
+    type = lookup_named_type(f,((event*)(events->array[i]))->type);
     field->field_type = type;
     field->offset_root = 0;
     field->fixed_root = 1;
@@ -171,7 +154,7 @@ void generateFacility(ltt_facility * facility, char * pathname,
     field->current_element = 0;
 
     //construct field tree and type graph
-    constructTypeAndFields(facility,((event*)(events->array[i]))->type,field);
+    constructTypeAndFields(f,((event*)(events->array[i]))->type,field);
   }  
 }
 
@@ -186,8 +169,8 @@ void generateFacility(ltt_facility * facility, char * pathname,
  *    root_field             : root field of the event
  ****************************************************************************/
 
-void constructTypeAndFields(ltt_facility * fac,type_descriptor * td, 
-                            ltt_field * fld)
+void constructTypeAndFields(LttFacility * fac,type_descriptor * td, 
+                            LttField * fld)
 {
   int i;
   type_descriptor * tmpTd;
@@ -206,11 +189,11 @@ void constructTypeAndFields(ltt_facility * fac,type_descriptor * td,
   }else if(td->type == LTT_ARRAY || td->type == LTT_SEQUENCE){
     if(td->type == LTT_ARRAY)
       fld->field_type->element_number = (unsigned)td->size;
-    fld->field_type->element_type = g_new(ltt_type*,1);
+    fld->field_type->element_type = g_new(LttType*,1);
     tmpTd = td->nested_type;
     fld->field_type->element_type[0] = lookup_named_type(fac, tmpTd);
-    fld->child = g_new(ltt_field*, 1);
-    fld->child[0] = g_new(ltt_field, 1);
+    fld->child = g_new(LttField*, 1);
+    fld->child[0] = g_new(LttField, 1);
     sequence_push(&(fac->all_fields), fld->child[0]);
     
     fld->child[0]->field_pos = 0;
@@ -228,12 +211,12 @@ void constructTypeAndFields(ltt_facility * fac,type_descriptor * td,
     constructTypeAndFields(fac, tmpTd, fld->child[0]);
   }else if(td->type == LTT_STRUCT){
     fld->field_type->element_number = td->fields.position;
-    fld->field_type->element_type = g_new(ltt_type*, td->fields.position);
-    fld->child = g_new(ltt_field*, td->fields.position);      
+    fld->field_type->element_type = g_new(LttType*, td->fields.position);
+    fld->child = g_new(LttField*, td->fields.position);      
     for(i=0;i<td->fields.position;i++){
       tmpTd = ((field*)(td->fields.array[i]))->type;
       fld->field_type->element_type[i] = lookup_named_type(fac, tmpTd);
-      fld->child[i] = g_new(ltt_field,1); 
+      fld->child[i] = g_new(LttField,1); 
       sequence_push(&(fac->all_fields), fld->child[i]);
 
       fld->child[i]->field_pos = i;
@@ -264,26 +247,26 @@ void constructTypeAndFields(ltt_facility * fac,type_descriptor * td,
  *    fac              : facility struct
  *    td               : type descriptor
  *Return value    
- *                     : either find the named type, or create a new ltt_type
+ *                     : either find the named type, or create a new LttType
  ****************************************************************************/
 
-ltt_type * lookup_named_type(ltt_facility *fac, type_descriptor * td)
+LttType * lookup_named_type(LttFacility *fac, type_descriptor * td)
 {
-  ltt_type * lttType = NULL;
+  LttType * lttType = NULL;
   int i;
   char * name;
   if(td->type_name){
     for(i=0;i<fac->all_named_types.keys.position;i++){
       name = (char *)(fac->all_named_types.keys.array[i]);
       if(strcmp(name, td->type_name)==0){
-	lttType = (ltt_type*)(fac->all_named_types.values.array[i]);
+	lttType = (LttType*)(fac->all_named_types.values.array[i]);
 	break;
       }
     }
   }
   
   if(!lttType){
-    lttType = g_new(ltt_type,1);
+    lttType = g_new(LttType,1);
     lttType->type_class = td->type;
     if(td->fmt) lttType->fmt = g_strdup(td->fmt);
     else lttType->fmt = NULL;
@@ -316,11 +299,8 @@ ltt_type * lookup_named_type(ltt_facility *fac, type_descriptor * td)
  *    int                     : usage count ?? status
  ****************************************************************************/
 
-int ltt_facility_close(ltt_facility *f)
+int ltt_facility_close(LttFacility *f)
 {
-  //  f->usage_count--;
-  if(f->usage_count > 0) return f->usage_count;
-  
   //release the memory it occupied
   freeFacility(f);
 
@@ -331,7 +311,7 @@ int ltt_facility_close(ltt_facility *f)
  * Functions to release the memory occupied by the facility
  ****************************************************************************/
 
-void freeFacility(ltt_facility * fac)
+void freeFacility(LttFacility * fac)
 {
   int i;
   g_free(fac->name);  //free facility name
@@ -340,6 +320,7 @@ void freeFacility(ltt_facility * fac)
   for(i=0;i<fac->event_number;i++){
     freeEventtype(fac->events[i]);
   }
+  g_free(fac->events);
 
   //free all named types
   freeAllNamedTypes(&(fac->all_named_types));
@@ -354,7 +335,7 @@ void freeFacility(ltt_facility * fac)
   g_free(fac);
 }
 
-void freeEventtype(ltt_eventtype * evType)
+void freeEventtype(LttEventType * evType)
 {
   g_free(evType->name);
   if(evType->description)
@@ -370,7 +351,7 @@ void freeAllNamedTypes(table * named_types)
     g_free((char*)(named_types->keys.array[i]));
     
     //free type
-    freeLttType((ltt_type*)(named_types->values.array[i]));
+    freeLttType((LttType*)(named_types->values.array[i]));
   }
   table_dispose(named_types);
 }
@@ -379,7 +360,7 @@ void freeAllUnamedTypes(sequence * unnamed_types)
 {
   int i;
   for(i=0;i<unnamed_types->position;i++){
-    freeLttType((ltt_type*)(unnamed_types->array[i]));
+    freeLttType((LttType*)(unnamed_types->array[i]));
   }
   sequence_dispose(unnamed_types);
 }
@@ -388,25 +369,33 @@ void freeAllFields(sequence * all_fields)
 {
   int i;
   for(i=0;i<all_fields->position;i++){
-    freeLttField((ltt_field*)(all_fields->array[i]));
+    freeLttField((LttField*)(all_fields->array[i]));
   }
   sequence_dispose(all_fields);
 }
 
-void freeLttType(ltt_type * type)
+//only free current type, not child types
+void freeLttType(LttType * type)
 {
+  int i;
   if(type->element_name)
     g_free(type->element_name);
   if(type->fmt)
     g_free(type->fmt);
-  if(type->enum_strings)
+  if(type->enum_strings){
+    for(i=0;i<type->element_number;i++)
+      g_free(type->enum_strings[i]);
     g_free(type->enum_strings);
-  if(type->element_type)
+  }
+
+  if(type->element_type){
     g_free(type->element_type);
+  }
   g_free(type);
 }
 
-void freeLttField(ltt_field * fld)
+//only free the current field, not child fields
+void freeLttField(LttField * fld)
 {  
   if(fld->child)
     g_free(fld->child);
@@ -422,7 +411,7 @@ void freeLttField(ltt_field * fld)
  *    char *                  : the facility's name
  ****************************************************************************/
 
-char *ltt_facility_name(ltt_facility *f)
+char *ltt_facility_name(LttFacility *f)
 {
   return f->name;
 }
@@ -433,14 +422,28 @@ char *ltt_facility_name(ltt_facility *f)
  *Input params
  *    f                       : the facility that will be closed
  *Return value
- *    ltt_checksum            : the checksum of the facility 
+ *    LttChecksum            : the checksum of the facility 
  ****************************************************************************/
 
-ltt_checksum ltt_facility_checksum(ltt_facility *f)
+LttChecksum ltt_facility_checksum(LttFacility *f)
 {
   return f->checksum;
 }
 
+/*****************************************************************************
+ *Function name
+ *    ltt_facility_base_id    : obtain the facility base id
+ *Input params
+ *    f                       : the facility
+ *Return value
+ *                            : the base id of the facility
+ ****************************************************************************/
+
+unsigned ltt_facility_base_id(LttFacility *f)
+{
+  return f->base_id;
+}
+
 /*****************************************************************************
  *Function name
  *    ltt_facility_eventtype_number: obtain the number of the event types 
@@ -450,7 +453,7 @@ ltt_checksum ltt_facility_checksum(ltt_facility *f)
  *    unsigned                     : the number of the event types 
  ****************************************************************************/
 
-unsigned ltt_facility_eventtype_number(ltt_facility *f)
+unsigned ltt_facility_eventtype_number(LttFacility *f)
 {
   return (unsigned)(f->event_number);
 }
@@ -462,10 +465,10 @@ unsigned ltt_facility_eventtype_number(ltt_facility *f)
  *Input params
  *    f                         : the facility that will be closed
  *Return value
- *    ltt_eventtype *           : the event type required  
+ *    LttEventType *           : the event type required  
  ****************************************************************************/
 
-ltt_eventtype *ltt_facility_eventtype_get(ltt_facility *f, unsigned i)
+LttEventType *ltt_facility_eventtype_get(LttFacility *f, unsigned i)
 {
   return f->events[i];
 }
@@ -479,13 +482,13 @@ ltt_eventtype *ltt_facility_eventtype_get(ltt_facility *f, unsigned i)
  *    f                : the facility that will be closed
  *    name             : the name of the event
  *Return value
- *    ltt_eventtype *  : the event type required  
+ *    LttEventType *  : the event type required  
  ****************************************************************************/
 
-ltt_eventtype *ltt_facility_eventtype_get_by_name(ltt_facility *f, char *name)
+LttEventType *ltt_facility_eventtype_get_by_name(LttFacility *f, char *name)
 {
   int i;
-  ltt_eventtype * ev;
+  LttEventType * ev;
   for(i=0;i<f->event_number;i++){
     ev = f->events[i];
     if(strcmp(ev->name, name) == 0)break;      
diff --git a/ltt/branches/poly/ltt/parser.c b/ltt/branches/poly/ltt/parser.c
index 2851188f..31e89a51 100644
--- a/ltt/branches/poly/ltt/parser.c
+++ b/ltt/branches/poly/ltt/parser.c
@@ -19,9 +19,8 @@ This program is distributed in the hope that it will be useful,
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */
 
-/* This program reads the ".event" event definitions input files 
-   specified as command line arguments and generates corresponding
-   ".c" and ".h" files required to trace such events in the kernel.
+/* This program reads the ".xml" event definitions input files 
+   and constructs structure for each event.
  
    The program uses a very simple tokenizer, called from a hand written
    recursive descent parser to fill a data structure describing the events.
@@ -31,7 +30,7 @@ This program is distributed in the hope that it will be useful,
    A table of named types is maintained to allow refering to types by name
    when the same type is used at several places. Finally a sequence of
    all types is maintained to facilitate the freeing of all type 
-   information when the processing of an ".event" file is finished. */
+   information when the processing of an ".xml" file is finished. */
 
 #include <stdlib.h> 
 #include <string.h>
@@ -100,7 +99,9 @@ void error_callback(parse_file *in, char *msg)
 
 void * memAlloc(int size)
 {
-  void *addr = malloc(size);
+  void * addr;
+  if(size == 0) return NULL;
+  addr = malloc(size);
   if(!addr){
     printf("Failed to allocate memory");    
     exit(1);
@@ -119,11 +120,173 @@ void * memAlloc(int size)
 
 char *allocAndCopy(char *str)
 {
-  char *addr = (char *)memAlloc(strlen(str)+1);
+  char * addr;
+  if(str == NULL) return NULL;
+  addr = (char *)memAlloc(strlen(str)+1);
   strcpy(addr,str);
   return addr;
 }
 
+/**************************************************************************
+ * Function :
+ *    getNameAttribute,getFormatAttribute,getSizeAttribute,getValueAttribute 
+ *    getValueStrAttribute
+ * Description :
+ *    Read the attribute from the input file.
+ *
+ * Parameters :
+ *    in , input file handle.
+ *
+ * Return values :
+ *    address of the attribute.
+ *
+ **************************************************************************/
+
+char * getNameAttribute(parse_file *in)
+{
+  char * token, car;
+  token = getName(in);
+  if(strcmp("name",token))in->error(in,"name was expected");
+  getEqual(in);
+  
+  car = seekNextChar(in);
+  if(car == EOF)in->error(in,"name was expected");
+  else if(car == '\"')token = getQuotedString(in);
+  else token = getName(in);
+  return token;
+}
+
+char * getFormatAttribute(parse_file *in)
+{
+  char * token;
+
+  //format is an option
+  token = getToken(in); 
+  if(strcmp("/",token) == 0){
+    ungetToken(in);
+    return NULL;
+  }
+
+  if(strcmp("format",token))in->error(in,"format was expected");
+  getEqual(in);
+  token = getQuotedString(in);
+  return token;
+}
+
+int getSizeAttribute(parse_file *in)
+{
+  char * token;
+  getName(in);
+  getEqual(in);
+
+  return getSize(in);
+}
+
+int getValueAttribute(parse_file *in)
+{
+  char * token;
+  getName(in);
+  getEqual(in);
+  
+  return getNumber(in);
+}
+
+//for <label name=label_name value=n/>, value is an option
+char * getValueStrAttribute(parse_file *in)
+{
+  char * token;
+
+  token = getToken(in); 
+  if(strcmp("/",token) == 0){
+    ungetToken(in);
+    return NULL;
+  }
+  
+  if(strcmp("value",token))in->error(in,"value was expected");
+  getEqual(in);
+  token = getToken(in);
+  if(in->type != NUMBER) in->error(in,"number was expected");
+  return token;  
+}
+
+char * getDescription(parse_file *in)
+{
+  long int pos;
+  char * token, car, *str;
+
+  pos = ftell(in->fp);
+
+  getLAnglebracket(in);
+  token = getName(in);
+  if(strcmp("description",token)){
+    fseek(in->fp, pos, SEEK_SET);
+    return NULL;
+  }
+  
+  getRAnglebracket(in);
+
+  pos = 0;
+  while((car = getc(in->fp)) != EOF) {
+    if(car == '<') break;
+    if(car == '\0') continue;
+    in->buffer[pos] = car;
+    pos++;
+  }
+  if(car == EOF)in->error(in,"not a valid description");
+  in->buffer[pos] = '\0';
+
+  str = allocAndCopy(in->buffer);
+
+  getForwardslash(in);
+  token = getName(in);
+  if(strcmp("description", token))in->error(in,"not a valid description");
+  getRAnglebracket(in);
+
+  return str;
+}
+
+/*****************************************************************************
+ *Function name
+ *    parseFacility : generate event list  
+ *Input params 
+ *    in            : input file handle          
+ *    fac           : empty facility
+ *Output params
+ *    fac           : facility filled with event list
+ ****************************************************************************/
+
+void parseFacility(parse_file *in, facility * fac)
+{
+  char * token;
+  event *ev;
+  
+  fac->name = allocAndCopy(getNameAttribute(in));    
+  getRAnglebracket(in);    
+  
+  fac->description = allocAndCopy(getDescription(in));
+  
+  while(1){
+    getLAnglebracket(in);    
+
+    token = getToken(in);
+    if(in->type == ENDFILE)
+      in->error(in,"the definition of the facility is not finished");
+
+    if(strcmp("event",token) == 0){
+      ev = (event*) memAlloc(sizeof(event));
+      sequence_push(&(fac->events),ev);
+      parseEvent(in,ev, &(fac->unnamed_types), &(fac->named_types));    
+    }else if(strcmp("type",token) == 0){
+      parseTypeDefinition(in, &(fac->unnamed_types), &(fac->named_types));
+    }else if(in->type == FORWARDSLASH){
+      break;
+    }else in->error(in,"event or type token expected\n");
+  }
+
+  token = getName(in);
+  if(strcmp("facility",token)) in->error(in,"not the end of the facility");
+  getRAnglebracket(in); //</facility>
+}
 
 /*****************************************************************************
  *Function name
@@ -131,6 +294,8 @@ char *allocAndCopy(char *str)
  *Input params 
  *    in            : input file handle          
  *    ev            : new event                              
+ *    unnamed_types : array of unamed types
+ *    named_types   : array of named types
  *Output params    
  *    ev            : new event (parameters are passed to it)   
  ****************************************************************************/
@@ -141,48 +306,44 @@ void parseEvent(parse_file *in, event * ev, sequence * unnamed_types,
   char *token;
   type_descriptor *t;
 
-  getLParenthesis(in);
-  token = getName(in);
-  ev->name = allocAndCopy(token);
-  getComa(in);
+  //<event name=eventtype_name>
+  ev->name = allocAndCopy(getNameAttribute(in));
+  getRAnglebracket(in);  
 
-  token = getQuotedString(in);
-  ev->description = allocAndCopy(token);
+  //<description>...</descriptio>
+  ev->description = allocAndCopy(getDescription(in)); 
   
-  token = getToken(in); //token either is a ',' or a ')'
-  if(in->type == COMA) token = getName(in);
-  ungetToken(in);
+  //event can have STRUCT, TYPEREF or NOTHING
+  getLAnglebracket(in);
 
-  /* We have a possibly empty list of fields, containing struct implied */
-  if((in->type == NAME && strcmp(token,"field") == 0) || 
-      in->type == RPARENTHESIS) {
-    /* Insert an unnamed struct type */
-    t = (type_descriptor *)memAlloc(sizeof(type_descriptor));
-    t->type_name = NULL;
-    t->type = STRUCT;
-    t->fmt = NULL;
-    if(in->type == NAME) parseFields(in,t, unnamed_types, named_types);
-    else if(in->type == RPARENTHESIS) sequence_init(&(t->fields));      
-    sequence_push(unnamed_types,t);
-    ev->type = t;
-  }
-
-  /* Or a complete type declaration but it must be a struct */
-  else if(in->type == NAME){
-    ev->type = parseType(in,NULL, unnamed_types, named_types);
-    if(ev->type->type != STRUCT && ev->type->type != NONE) in->error(in,"type must be a struct");
+  token = getToken(in);
+  if(in->type == FORWARDSLASH){ //</event> NOTHING
+    ev->type = NULL;
+  }else if(in->type == NAME){
+    if(strcmp("struct",token)==0 || strcmp("typeref",token)==0){
+      ungetToken(in);
+      ev->type = parseType(in,NULL, unnamed_types, named_types);
+      if(ev->type->type != STRUCT && ev->type->type != NONE) 
+	in->error(in,"type must be a struct");     
+    }else in->error(in, "not a valid type");
+
+    getLAnglebracket(in);
+    getForwardslash(in);    
   }else in->error(in,"not a struct type");
 
-  getRParenthesis(in);
-  getSemiColon(in);
+  token = getName(in);
+  if(strcmp("event",token))in->error(in,"not an event definition");
+  getRAnglebracket(in);  //</event>
 }
 
 /*****************************************************************************
  *Function name
- *    parseField  : get field infomation from buffer 
+ *    parseField    : get field infomation from buffer 
  *Input params 
- *    in          : input file handle
- *    t           : type descriptor
+ *    in            : input file handle
+ *    t             : type descriptor
+ *    unnamed_types : array of unamed types
+ *    named_types   : array of named types
  ****************************************************************************/
 
 void parseFields(parse_file *in, type_descriptor *t, sequence * unnamed_types,
@@ -191,28 +352,24 @@ void parseFields(parse_file *in, type_descriptor *t, sequence * unnamed_types,
   char * token;
   field *f;
 
-  sequence_init(&(t->fields));
+  f = (field *)memAlloc(sizeof(field));
+  sequence_push(&(t->fields),f);
 
-  token = getToken(in);
-  while(in->type == NAME && strcmp(token,"field") == 0) {
-    f = (field *)memAlloc(sizeof(field));
-    sequence_push(&(t->fields),f);
-
-    getLParenthesis(in);
-    f->name = (char *)allocAndCopy(getName(in));
-    getComa(in);
-    f->description = (char *)allocAndCopy(getQuotedString(in));
-    getComa(in);
-    f->type = parseType(in,NULL, unnamed_types, named_types);
-    getRParenthesis(in);
-    
-    token = getToken(in);
-    if(in->type == COMA) token = getName(in);
-    else ungetToken(in); // no more fields, it must be a ')'
-  }
+  //<field name=field_name> <description> <type> </field>
+  f->name = allocAndCopy(getNameAttribute(in)); 
+  getRAnglebracket(in);
+
+  f->description = allocAndCopy(getDescription(in));
+
+  //<int size=...>
+  getLAnglebracket(in);
+  f->type = parseType(in,NULL, unnamed_types, named_types);
 
-  if(in->type == NAME && strcmp(token,"field") != 0)
-    in->error(in,"not a field");
+  getLAnglebracket(in);
+  getForwardslash(in);
+  token = getName(in);
+  if(strcmp("field",token))in->error(in,"not a valid field definition");
+  getRAnglebracket(in); //</field>
 }
 
 
@@ -230,6 +387,8 @@ void parseFields(parse_file *in, type_descriptor *t, sequence * unnamed_types,
  *Input params 
  *    in               : input file handle
  *    inType           : a type descriptor          
+ *    unnamed_types    : array of unamed types
+ *    named_types      : array of named types
  *Return values  
  *    type_descriptor* : a type descriptor             
  ****************************************************************************/
@@ -237,7 +396,7 @@ void parseFields(parse_file *in, type_descriptor *t, sequence * unnamed_types,
 type_descriptor *parseType(parse_file *in, type_descriptor *inType, 
 			   sequence * unnamed_types, table * named_types) 
 {
-  char *token, *car;
+  char *token;
   type_descriptor *t;
 
   if(inType == NULL) {
@@ -253,118 +412,149 @@ type_descriptor *parseType(parse_file *in, type_descriptor *inType,
 
   if(strcmp(token,"struct") == 0) {
     t->type = STRUCT;
-    getLParenthesis(in);
-    parseFields(in,t, unnamed_types, named_types);
-    getRParenthesis(in);
+    getRAnglebracket(in); //<struct>
+    getLAnglebracket(in); //<field name=..>
+    token = getToken(in);
+    sequence_init(&(t->fields));
+    while(strcmp("field",token) == 0){
+      parseFields(in,t, unnamed_types, named_types);
+      
+      //next field
+      getLAnglebracket(in);
+      token = getToken(in);	
+    }
+    if(strcmp("/",token))in->error(in,"not a valid structure definition");
+    token = getName(in);
+    if(strcmp("struct",token)!=0)
+      in->error(in,"not a valid structure definition");
+    getRAnglebracket(in); //</struct>
+  }
+  else if(strcmp(token,"union") == 0) {
+    t->type = UNION;
+    t->size = getSizeAttribute(in);
+    getRAnglebracket(in); //<union typecodesize=isize>
+
+    getLAnglebracket(in); //<field name=..>
+    token = getToken(in);
+    sequence_init(&(t->fields));
+    while(strcmp("field",token) == 0){
+      parseFields(in,t, unnamed_types, named_types);
+      
+      //next field
+      getLAnglebracket(in);
+      token = getToken(in);	
+    }
+    if(strcmp("/",token))in->error(in,"not a valid union definition");
+    token = getName(in);
+    if(strcmp("union",token)!=0)
+      in->error(in,"not a valid union definition");        
+    getRAnglebracket(in); //</union>
   }
   else if(strcmp(token,"array") == 0) {
     t->type = ARRAY;
-    getLParenthesis(in);
-    t->size = getNumber(in);
-    getComa(in);
+    t->size = getValueAttribute(in);
+    getRAnglebracket(in); //<array size=n>
+
+    getLAnglebracket(in); //<type struct> 
     t->nested_type = parseType(in,NULL, unnamed_types, named_types);
-    getRParenthesis(in);
+
+    getLAnglebracket(in); //</array>
+    getForwardslash(in);
+    token = getName(in);
+    if(strcmp("array",token))in->error(in,"not a valid array definition");
+    getRAnglebracket(in);  //</array>
   }
   else if(strcmp(token,"sequence") == 0) {
     t->type = SEQUENCE;
-    getLParenthesis(in);
-    t->size = getSize(in);
-    getComa(in);
+    t->size = getSizeAttribute(in);
+    getRAnglebracket(in); //<array lengthsize=isize>
+
+    getLAnglebracket(in); //<type struct> 
     t->nested_type = parseType(in,NULL, unnamed_types, named_types);
-    getRParenthesis(in);
+
+    getLAnglebracket(in); //</sequence>
+    getForwardslash(in);
+    token = getName(in);
+    if(strcmp("sequence",token))in->error(in,"not a valid sequence definition");
+    getRAnglebracket(in); //</sequence>
   }
   else if(strcmp(token,"enum") == 0) {
+    char * str, *str1;
     t->type = ENUM;
     sequence_init(&(t->labels));
-    getLParenthesis(in);
-    t->size = getSize(in);
-    getComa(in);
-    token = getToken(in);
-    if(in->type == QUOTEDSTRING){
-      t->fmt = allocAndCopy(token);
-      getComa(in);
-    }else ungetToken(in);
-    getLParenthesis(in);
-
-    token = getToken(in);
-    while(in->type != RPARENTHESIS) {
-      if(in->type != NAME) in->error(in,"Name token was expected");
-      car = allocAndCopy(token);
-      token = getToken(in);
-      if(in->type == COMA){
-	sequence_push(&(t->labels),allocAndCopy(car));
-	token = getName(in);
-      }else if(in->type == EQUAL){ //label followed by '=' and a number, e.x. label1 = 1,
-	car = appendString(car, token);
-	token = getToken(in);
-	if(in->type != NUMBER) in->error(in,"Number token was expected");
-	car = appendString(car, token);
-	sequence_push(&(t->labels),allocAndCopy(car));	
-	token = getToken(in);
-	if(in->type == COMA) token = getName(in);
-	else ungetToken(in);
-      }else{
-	sequence_push(&(t->labels),allocAndCopy(car));
-	ungetToken(in);
-      }
-    }  
-    getRParenthesis(in);
-    getRParenthesis(in);
+    t->size = getSizeAttribute(in);
+    t->fmt = allocAndCopy(getFormatAttribute(in));
+    getRAnglebracket(in);
+
+    //<label name=label1 value=n/>
+    getLAnglebracket(in);
+    token = getToken(in); //"label" or "/"
+    while(strcmp("label",token) == 0){
+      str   = allocAndCopy(getNameAttribute(in));      
+      token = getValueStrAttribute(in);
+      if(token){
+	str1 = appendString(str,"=");
+	free(str);
+	str = appendString(str1,token);
+	free(str1);
+	sequence_push(&(t->labels),allocAndCopy(str));
+	free(str);
+      }else
+	sequence_push(&(t->labels),allocAndCopy(str));
+
+      getForwardslash(in);
+      getRAnglebracket(in);
+      
+      //next label definition
+      getLAnglebracket(in);
+      token = getToken(in); //"label" or "/"      
+    }
+    if(strcmp("/",token))in->error(in, "not a valid enum definition");
+    token = getName(in);
+    if(strcmp("enum",token))in->error(in, "not a valid enum definition");
+    getRAnglebracket(in); //</label>
   }
   else if(strcmp(token,"int") == 0) {
     t->type = INT;
-    getLParenthesis(in);
-    t->size = getSize(in);
-    token = getToken(in);
-    if(in->type == COMA) {
-      token = getQuotedString(in);
-      t->fmt = allocAndCopy(token);
-    }
-    else ungetToken(in);
-    getRParenthesis(in);
+    t->size = getSizeAttribute(in);
+    t->fmt  = allocAndCopy(getFormatAttribute(in));
+    getForwardslash(in);
+    getRAnglebracket(in); 
   }
   else if(strcmp(token,"uint") == 0) {
     t->type = UINT;
-    getLParenthesis(in);
-    t->size = getSize(in);
-    token = getToken(in);
-    if(in->type == COMA) {
-      token = getQuotedString(in);
-      t->fmt = allocAndCopy(token);
-    }
-    else ungetToken(in);
-    getRParenthesis(in);
+    t->size = getSizeAttribute(in);
+    t->fmt  = allocAndCopy(getFormatAttribute(in));
+    getForwardslash(in);
+    getRAnglebracket(in); 
   }
   else if(strcmp(token,"float") == 0) {
     t->type = FLOAT;
-    getLParenthesis(in);
-    t->size = getSize(in);
-    token = getToken(in);
-    if(in->type == COMA) {
-      token = getQuotedString(in);
-      t->fmt = allocAndCopy(token);
-    }
-    else ungetToken(in);
-    getRParenthesis(in);
+    t->size = getSizeAttribute(in);
+    t->fmt  = allocAndCopy(getFormatAttribute(in));
+    getForwardslash(in);
+    getRAnglebracket(in); 
   }
   else if(strcmp(token,"string") == 0) {
     t->type = STRING;
-    getLParenthesis(in);
-    token = getToken(in);
-    if(in->type == QUOTEDSTRING) t->fmt = allocAndCopy(token);
-    else ungetToken(in);
-    getRParenthesis(in);
+    t->fmt  = allocAndCopy(getFormatAttribute(in));
+    getForwardslash(in);
+    getRAnglebracket(in); 
   }
-  else {
-    /* Must be a named type */
+  else if(strcmp(token,"typeref") == 0){
+    // Must be a named type
     if(inType != NULL) 
       in->error(in,"Named type cannot refer to a named type");
     else {
       free(t);
       sequence_pop(unnamed_types);
-      return(find_named_type(token, named_types));
+      token = getNameAttribute(in);
+      t = find_named_type(token, named_types);
+      getForwardslash(in);  //<typeref name=type_name/>
+      getRAnglebracket(in);
+      return t;
     }
-  }
+  }else in->error(in,"not a valid type");
 
   return t;
 }    
@@ -374,6 +564,7 @@ type_descriptor *parseType(parse_file *in, type_descriptor *inType,
  *    find_named_type     : find a named type from hash table 
  *Input params 
  *    name                : type name          
+ *    named_types         : array of named types
  *Return values  
  *    type_descriptor *   : a type descriptor                       
  *****************************************************************************/
@@ -398,6 +589,8 @@ type_descriptor * find_named_type(char *name, table * named_types)
  *    parseTypeDefinition : get type information from type definition 
  *Input params 
  *    in                  : input file handle          
+ *    unnamed_types       : array of unamed types
+ *    named_types         : array of named types
  *****************************************************************************/
 
 void parseTypeDefinition(parse_file * in, sequence * unnamed_types,
@@ -406,21 +599,28 @@ void parseTypeDefinition(parse_file * in, sequence * unnamed_types,
   char *token;
   type_descriptor *t;
 
-  getLParenthesis(in);
-  token = getName(in);
+  token = getNameAttribute(in);
   t = find_named_type(token, named_types);
-  getComa(in);
 
   if(t->type != NONE) in->error(in,"redefinition of named type");
+  getRAnglebracket(in); //<type name=type_name>
+  getLAnglebracket(in); //<struct>
+  token = getName(in);
+  if(strcmp("struct",token))in->error(in,"not a valid type definition");
+  ungetToken(in);
   parseType(in,t, unnamed_types, named_types);
-
-  getRParenthesis(in);
-  getSemiColon(in);
+  
+  //</type>
+  getLAnglebracket(in);
+  getForwardslash(in);
+  token = getName(in);
+  if(strcmp("type",token))in->error(in,"not a valid type definition");  
+  getRAnglebracket(in); //</type>
 }
 
 /**************************************************************************
  * Function :
- *    getComa, getName, getNumber, getLParenthesis, getRParenthesis, getEqual
+ *    getComa, getName, getNumber, getEqual
  * Description :
  *    Read a token from the input file, check its type, return it scontent.
  *
@@ -450,30 +650,30 @@ int getNumber(parse_file * in)
   return atoi(token);
 }
 
-char *getComa(parse_file * in) 
+char *getForwardslash(parse_file * in) 
 {
   char *token;
 
   token = getToken(in);
-  if(in->type != COMA) in->error(in, "Coma token was expected");
+  if(in->type != FORWARDSLASH) in->error(in, "forward slash token was expected");
   return token;
 }
 
-char *getLParenthesis(parse_file * in) 
+char *getLAnglebracket(parse_file * in) 
 {
   char *token;
 
   token = getToken(in);
-  if(in->type != LPARENTHESIS) in->error(in, "Left parenthesis was expected");
+  if(in->type != LANGLEBRACKET) in->error(in, "Left angle bracket was expected");
   return token;
 }
 
-char *getRParenthesis(parse_file * in) 
+char *getRAnglebracket(parse_file * in) 
 {
   char *token;
 
   token = getToken(in);
-  if(in->type != RPARENTHESIS) in->error(in, "Right parenthesis was expected");
+  if(in->type != RANGLEBRACKET) in->error(in, "Right angle bracket was expected");
   return token;
 }
 
@@ -486,22 +686,25 @@ char *getQuotedString(parse_file * in)
   return token;
 }
 
-char * getSemiColon(parse_file *in)
+char * getEqual(parse_file *in)
 {
   char *token;
 
   token = getToken(in);
-  if(in->type != SEMICOLON) in->error(in, "semicolon was expected");
+  if(in->type != EQUAL) in->error(in, "equal was expected");
   return token;
 }
 
-char * getEqual(parse_file *in)
+char seekNextChar(parse_file *in)
 {
-  char *token;
-
-  token = getToken(in);
-  if(in->type != EQUAL) in->error(in, "equal was expected");
-  return token;
+  char car;
+  while((car = getc(in->fp)) != EOF) {
+    if(!isspace(car)){
+      ungetc(car,in->fp);
+      return car;
+    }
+  }  
+  return EOF;
 }
 
 /******************************************************************
@@ -555,23 +758,18 @@ char *getToken(parse_file * in)
     case EOF:
       in->type = ENDFILE;
       break;
-    case ',':
-      in->type = COMA;
+    case '/':
+      in->type = FORWARDSLASH;
       in->buffer[pos] = car;
       pos++;
       break;
-    case '(':
-      in->type = LPARENTHESIS;
+    case '<':
+      in->type = LANGLEBRACKET;
       in->buffer[pos] = car;
       pos++;
       break;
-    case ')':
-      in->type = RPARENTHESIS;
-      in->buffer[pos] = car;
-      pos++;
-      break;
-    case ';':
-      in->type = SEMICOLON;
+    case '>':
+      in->type = RANGLEBRACKET;
       in->buffer[pos] = car;
       pos++;
       break;
@@ -714,22 +912,20 @@ void checkNamedTypesImplemented(table * named_types)
 void generateChecksum( char* facName, unsigned long * checksum, sequence * events)
 {
   unsigned long crc ;
-  int pos, nestedStruct;
+  int pos;
   event * ev;
   char str[256];
 
   crc = crc32(facName);
   for(pos = 0; pos < events->position; pos++){
     ev = (event *)(events->array[pos]);
-    ev->nested = 0; //by default, event has no nested struct
     crc = partial_crc32(ev->name,crc);    
-    nestedStruct = 0;
+    if(!ev->type) continue; //event without type
     if(ev->type->type != STRUCT){
       sprintf(str,"event '%s' has a type other than STRUCT",ev->name);
       error_callback(NULL, str);
     }
-    crc = getTypeChecksum(crc, ev->type,&nestedStruct);
-    if(nestedStruct ) ev->nested = 1;
+    crc = getTypeChecksum(crc, ev->type);
   }
   *checksum = crc;
 }
@@ -744,14 +940,12 @@ void generateChecksum( char* facName, unsigned long * checksum, sequence * event
  *    unsigned long     : checksum 
  *****************************************************************************/
 
-unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type,
-			      int * nestedStruct)
+unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type)
 {
   unsigned long crc = aCrc;
   char * str = NULL, buf[16];
-  int flag = 0, pos, max, min;
+  int flag = 0, pos;
   field * fld;
-  data_type dt;
 
   switch(type->type){
     case INT:
@@ -785,6 +979,10 @@ unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type,
       str = allocAndCopy("struct");
       flag = 1;
       break;
+    case UNION:
+      str = allocAndCopy("union");
+      flag = 1;
+      break;
     default:
       error_callback(NULL, "named type has no definition");
       break;
@@ -796,25 +994,16 @@ unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type,
   if(type->fmt) crc = partial_crc32(type->fmt,crc);
     
   if(type->type == ARRAY || type->type == SEQUENCE){
-    dt = type->nested_type->type;
-    if(dt == ARRAY || dt == SEQUENCE || dt == STRUCT) *nestedStruct += 1;
-    crc = getTypeChecksum(crc,type->nested_type,nestedStruct);
-  }else if(type->type == STRUCT){
-    if(type->fields.position != 0){//not a empty struct
-      max = 0;      
-      for(pos =0; pos < type->fields.position; pos++){
-	min = 0;
-	fld = (field *) type->fields.array[pos];
-	crc = partial_crc32(fld->name,crc);
-	if(fld->type->type == STRUCT) min++;
-	crc = getTypeChecksum(crc, fld->type,&min);
-	if(min>max) max = min;
-      }
-      *nestedStruct += max;
-    }
+    crc = getTypeChecksum(crc,type->nested_type);
+  }else if(type->type == STRUCT || type->type == UNION){
+    for(pos =0; pos < type->fields.position; pos++){
+      fld = (field *) type->fields.array[pos];
+      crc = partial_crc32(fld->name,crc);
+      crc = getTypeChecksum(crc, fld->type);
+    }    
   }else if(type->type == ENUM){
     for(pos = 0; pos < type->labels.position; pos++)
-      crc = partial_crc32((char*)type->labels.array[pos],crc);    
+      crc = partial_crc32((char*)type->labels.array[pos],crc);
   }
 
   return crc;
@@ -975,6 +1164,7 @@ void *table_find_int(table *t, int *key)
 char *appendString(char *s, char *suffix) 
 {
   char *tmp;
+  if(suffix == NULL) return s;
 
   tmp = (char *)memAlloc(strlen(s) + strlen(suffix) + 1);
   strcpy(tmp,s);
diff --git a/ltt/branches/poly/ltt/parser.h b/ltt/branches/poly/ltt/parser.h
index 5e0c421b..66120776 100644
--- a/ltt/branches/poly/ltt/parser.h
+++ b/ltt/branches/poly/ltt/parser.h
@@ -34,10 +34,9 @@ void *table_find_int(table *t, int *key);
 
 typedef enum _token_type {
   ENDFILE,
-  COMA,
-  LPARENTHESIS,
-  RPARENTHESIS,
-  SEMICOLON,
+  FORWARDSLASH,
+  LANGLEBRACKET,
+  RANGLEBRACKET,
   EQUAL,
   QUOTEDSTRING,
   NUMBER,
@@ -58,14 +57,14 @@ typedef struct _parse_file {
 
 void ungetToken(parse_file * in);
 char *getToken(parse_file *in);
-char *getComa(parse_file *in);
-char *getLParenthesis(parse_file *in);
-char *getRParenthesis(parse_file *in);
-char *getSemiColon(parse_file *in);
+char *getForwardslash(parse_file *in);
+char *getLAnglebracket(parse_file *in);
+char *getRAnglebracket(parse_file *in);
 char *getQuotedString(parse_file *in);
 char *getName(parse_file *in);
-int getNumber(parse_file *in);
-char * getEqual(parse_file *in);
+int   getNumber(parse_file *in);
+char *getEqual(parse_file *in);
+char  seekNextChar(parse_file *in);
 
 void skipComment(parse_file * in);
 void skipEOL(parse_file * in);
@@ -88,6 +87,7 @@ typedef enum _data_type {
   ARRAY,
   SEQUENCE,
   STRUCT,
+  UNION,
   NONE
 } data_type;
 
@@ -120,12 +120,20 @@ typedef struct _event {
   char *name;
   char *description;
   type_descriptor *type; 
-  int nested;
 } event;
 
+typedef struct _facility {
+  char * name;
+  char * description;
+  sequence events;
+  sequence unnamed_types;
+  table named_types;
+} facility;
+
 int getSize(parse_file *in);
-unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type, int * nestedStruct);
+unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type);
 
+void parseFacility(parse_file *in, facility * fac);
 void parseEvent(parse_file *in, event *ev, sequence * unnamed_types, table * named_types);
 void parseTypeDefinition(parse_file *in, sequence * unnamed_types, table * named_types);
 type_descriptor *parseType(parse_file *in, type_descriptor *t, sequence * unnamed_types, table * named_types);
@@ -135,6 +143,15 @@ type_descriptor * find_named_type(char *name, table * named_types);
 void generateChecksum(char * facName, unsigned long * checksum, sequence * events);
 
 
+/* get attributes */
+char * getNameAttribute(parse_file *in);
+char * getFormatAttribute(parse_file *in);
+int    getSizeAttribute(parse_file *in);
+int    getValueAttribute(parse_file *in);
+char * getValueStrAttribute(parse_file *in);
+
+char * getDescription(parse_file *in);
+
 
 static char *intOutputTypes[] = {
   "int8_t", "int16_t", "int32_t", "int64_t", "short int", "int", "long int" };
diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c
index f1b14a82..4819d5d1 100644
--- a/ltt/branches/poly/ltt/tracefile.c
+++ b/ltt/branches/poly/ltt/tracefile.c
@@ -2,49 +2,45 @@
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <dirent.h>
 #include <linux/errno.h>  
 
 #include <ltt/LTTTypes.h>  
 #include "parser.h"
-#include <ltt/tracefile.h>
+#include <ltt/trace.h>
 
-//#include "default.h"  //yxx test
+#define DIR_NAME_SIZE 256
 
 /* set the offset of the fields belonging to the event,
    need the information of the archecture */
-void setFieldsOffset(ltt_tracefile * t, ltt_eventtype *evT, void *evD);
+void setFieldsOffset(LttTracefile * t, LttEventType *evT, void *evD);
 
 /* get the size of the field type according to the archtecture's
    size and endian type(info of the archecture) */
-int getFieldtypeSize(ltt_tracefile * t, ltt_eventtype * evT, int offsetRoot,
-		     int offsetParent, ltt_field * fld, void * evD );
+int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot,
+		     int offsetParent, LttField * fld, void * evD );
 
 /* read a fixed size or a block information from the file (fd) */
 int readFile(int fd, void * buf, size_t size, char * mesg);
-int readBlock(ltt_tracefile * tf, int whichBlock);
+int readBlock(LttTracefile * tf, int whichBlock);
 
 /* calculate cycles per nsec for current block */
-void getCyclePerNsec(ltt_tracefile * t);
-
-/* functions to release the memory occupied by the tables of a tracefile */
-void freeKey (gpointer key, gpointer value, gpointer user_data);
-void freeValue (gpointer key, gpointer value, gpointer user_data);
-void freeFacilityNameTable (gpointer key, gpointer value, gpointer user_data);
+void getCyclePerNsec(LttTracefile * t);
 
 /* reinitialize the info of the block which is already in the buffer */
-void updateTracefile(ltt_tracefile * tf);
+void updateTracefile(LttTracefile * tf);
 
 /* go to the next event */
-int skipEvent(ltt_tracefile * t);
+int skipEvent(LttTracefile * t);
 
-/* compare two time (ltt_time), 0:t1=t2, -1:t1<t2, 1:t1>t2 */
-int timecmp(ltt_time * t1, ltt_time * t2);
+/* compare two time (LttTime), 0:t1=t2, -1:t1<t2, 1:t1>t2 */
+int timecmp(LttTime * t1, LttTime * t2);
 
 /* get an integer number */
 int getIntNumber(int size1, void *evD);
 
 
-/* Time operation macros for ltt_time (struct timespec) */
+/* Time operation macros for LttTime (struct timespec) */
 /*  (T3 = T2 - T1) */
 #define TimeSub(T3, T2, T1) \
 do \
@@ -75,23 +71,25 @@ do \
 
 /*****************************************************************************
  *Function name
- *    ltt_tracefile_open : open a trace file, construct a ltt_tracefile
+ *    ltt_tracefile_open : open a trace file, construct a LttTracefile
  *Input params
- *    pathname           : path name of the trace file
+ *    t                  : the trace containing the tracefile
+ *    fileName           : path name of the trace file
  *Return value
- *    ltt_tracefile *    : the structure represents the opened trace file
+ *                       : a pointer to a tracefile
  ****************************************************************************/ 
 
-ltt_tracefile *ltt_tracefile_open(char * fileName)
+LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName)
 {
-  ltt_tracefile * tf;
-  struct stat      lTDFStat;    /* Trace data file status */
-  trace_header_event *trace_header;
-  block_header   a_block_header;
+  LttTracefile * tf;
+  struct stat    lTDFStat;    /* Trace data file status */
+  BlockStart     a_block_start;
 
-  tf = g_new(ltt_tracefile, 1);
+  tf = g_new(LttTracefile, 1);  
 
   //open the file
+  tf->name = g_strdup(fileName);
+  tf->trace = t;
   tf->fd = open(fileName, O_RDONLY, 0);
   if(tf->fd < 0){
     g_error("Unable to open input data file %s\n", fileName);
@@ -103,371 +101,587 @@ ltt_tracefile *ltt_tracefile_open(char * fileName)
   }
 
   // Is the file large enough to contain a trace 
-  if(lTDFStat.st_size < sizeof(block_header) + sizeof(trace_header_event)){
+  if(lTDFStat.st_size < sizeof(BlockStart) + EVENT_HEADER_SIZE){
     g_error("The input data file %s does not contain a trace\n", fileName);
   }
   
   //store the size of the file
   tf->file_size = lTDFStat.st_size;
-
-  //read the first block header
-  if(readFile(tf->fd,(void*)&a_block_header, sizeof(block_header),
-              "Unable to read block header"))
-    exit(1);
-  
-  //read the trace header event
-  trace_header = g_new(trace_header_event, 1);
-  if(readFile(tf->fd,(void*)trace_header, sizeof(trace_header_event),
-              "Unable to read trace header event"))
-    exit(1);
-
-  tf->block_number = tf->file_size / trace_header->buffer_size;
-  tf->trace_header = (trace_header_event *)trace_header;
+  tf->block_size = t->system_description->ltt_block_size;
+  tf->block_number = tf->file_size / tf->block_size;
+  tf->which_block = 0;
 
   //allocate memory to contain the info of a block
-  tf->buffer = (void *) g_new(char, trace_header->buffer_size);
-
-  //read the last block, get the trace end time
-  if(readBlock(tf,tf->block_number)) exit(1);
-  tf->end_time = tf->a_block_footer->time;
-
-  //read the first block, get the trace start time
-  if(tf->block_number != 1)
-    if(readBlock(tf,1)) exit(1);
-  tf->start_time = tf->a_block_header->time;
-
-  //get local machine's data type size and endian type
-  getDataEndianType(&(tf->my_arch_size), &(tf->my_arch_endian));
+  tf->buffer = (void *) g_new(char, t->system_description->ltt_block_size);
 
-  //initialize all tables
-  tf->eventtype_number   = 0;
-  tf->facility_number    = 0;
-  tf->index_facility     = g_hash_table_new (g_int_hash, g_int_equal);
-  tf->facility_name      = g_hash_table_new (g_str_hash, g_str_equal);
-  tf->base_id_name       = g_hash_table_new (g_str_hash, g_int_equal);
-  tf->eventtype_event_id = g_ptr_array_new();
+  //read the first block
+  if(readBlock(tf,1)) exit(1);
 
   return tf;
 }
 
-/*****************************************************************************
- *Function name
- *    ltt_tracefile_close: close a trace file, release all facilities if their
- *                         usage count == 0 when close_facilities is true
- *Input params
- *    t                  : tracefile which will be closed
- *    close_facilities   : bool to show if the facilities need to be released
- *Return value
- *    int                : ????
- ****************************************************************************/
-
-int ltt_tracefile_close(ltt_tracefile *t, int close_facilities)
-{
-  //free index_facility table
-  g_hash_table_foreach (t->index_facility, freeKey, NULL);
-  g_hash_table_destroy(t->index_facility);
-
-  //free base_id_facility table
-  g_hash_table_foreach (t->base_id_name, freeValue, NULL);
-  g_hash_table_destroy(t->base_id_name);
-
-  //free eventtype_event_id array
-  g_ptr_array_free (t->eventtype_event_id, TRUE);
-
-  //free facility_name table
-  g_hash_table_foreach (t->facility_name, freeFacilityNameTable,
-			GINT_TO_POINTER(1));
-  g_hash_table_destroy(t->facility_name);  
-
-  //free tracefile structure
-  g_free(t->trace_header);
-  g_free(t->buffer);
-  g_free(t);
-  return 0;
-}
 
 /*****************************************************************************
- * functions to release the memory occupied by the tables of a tracefile
+ *Open control and per cpu tracefiles
  ****************************************************************************/
 
-void freeKey (gpointer key, gpointer value, gpointer user_data)
+void ltt_tracefile_open_cpu(LttTrace *t, char * tracefile_name)
 {
-  g_free(key);
+  LttTracefile * tf;
+  tf = ltt_tracefile_open(t,tracefile_name);
+  t->per_cpu_tracefile_number++;
+  g_ptr_array_add(t->per_cpu_tracefiles, tf);
 }
 
-void freeValue (gpointer key, gpointer value, gpointer user_data)
+void ltt_tracefile_open_control(LttTrace *t, char * control_name)
 {
-  g_free(value);
-}
-
-void freeFacilityNameTable (gpointer key, gpointer value, gpointer user_data)
-{
-  ltt_facility * fac = (ltt_facility*) value;
-  fac->usage_count--;
-  if(GPOINTER_TO_INT(user_data) != 0)
-    ltt_facility_close(fac);    
+  LttTracefile * tf;
+  LttEvent * ev;
+  LttFacility * f;
+  uint16_t evId;
+  void * pos;
+  FacilityLoad fLoad;
+  int i;
+
+  tf = ltt_tracefile_open(t,control_name);
+  t->control_tracefile_number++;
+  g_ptr_array_add(t->control_tracefiles,tf);
+
+  //parse facilities tracefile to get base_id
+  if(strcmp(control_name,"facilities") ==0){
+    while(1){
+      evId = *(uint16_t*)tf->cur_event_pos;    
+      if(evId == TRACE_FACILITY_LOAD){
+	pos = tf->cur_event_pos + EVENT_HEADER_SIZE;
+	fLoad.name = (char*)pos;
+	fLoad.checksum = *(LttChecksum*)(pos + sizeof(pos));
+	fLoad.base_code = *(uint32_t*)(pos + sizeof(pos) + sizeof(LttChecksum));
+
+	for(i=0;i<t->facility_number;i++){
+	  f = (LttFacility*)g_ptr_array_index(t->facilities,i);
+	  if(strcmp(f->name,fLoad.name)==0 && fLoad.checksum==f->checksum){
+	    f->base_id = fLoad.base_code;
+	    break;
+	  }
+	}
+	if(i==t->facility_number)
+	  g_error("Facility: %s, checksum: %d is not founded\n",
+		  fLoad.name,fLoad.checksum);
+
+	ev = ltt_tracefile_read(tf); //get next event
+	if(!ev) break;           //end of tracefile
+      }else if(evId == TRACE_BLOCK_END){
+	//can only reach here if it is the first event
+	g_error("Facilities does not contain any facility_load event\n");
+      }else g_error("Not valid facilities trace file\n");
+    }
+  }
 }
 
 /*****************************************************************************
  *Function name
- *    ltt_tracefile_facility_add: increases the facility usage count and also 
- *                                specifies the base of the numeric range
- *                                assigned to the event types in the facility 
- *                                for this tracefile
+ *    ltt_tracefile_close: close a trace file, 
  *Input params
- *    t                  : tracefile that the facility will be added
- *    f                  : facility that will be attached to the tracefile
- *    base_id            : the id for the first event of the facility in the 
- *                         trace file
- *Return value
- *    int                : ????
+ *    t                  : tracefile which will be closed
  ****************************************************************************/
 
-int ltt_tracefile_facility_add(ltt_tracefile *t,ltt_facility *f,int base_id)
+void ltt_tracefile_close(LttTracefile *t)
 {
-  int * id, *index;
-  int i, j, k;
-  ltt_eventtype * et;
-  gpointer tmpPtr;
-
-  //increase the facility usage count
-  f->usage_count++;
-  t->eventtype_number += f->event_number;
-  t->facility_number++;
-
-  //insert the facility into index_facility table
-  id = g_new(int,1);
-  *id = t->facility_number;
-  g_hash_table_insert(t->index_facility, (gpointer)id,(gpointer)f);  
-
-  //insert facility name into table: base_id_name
-  id = g_new(int,1);
-  *id = base_id;
-  g_hash_table_insert(t->base_id_name, (gpointer)(f->name), (gpointer)id);
+  g_free(t->name);
+  g_free(t->buffer);
+  g_free(t);
+}
 
-  //insert facility name into table: facility_name
-  g_hash_table_insert(t->facility_name, (gpointer)(f->name), (gpointer)f);
-  
-  //insert eventtype into the array: eventtype_event_id
-  j = base_id + f->event_number;
-  k = t->eventtype_event_id->len;
-  if(j > t->eventtype_event_id->len){
-    for(i=0; i < j - k; i++){
-      tmpPtr = (gpointer)g_new(ptr_wrap, 1);
-      g_ptr_array_add(t->eventtype_event_id,tmpPtr);
-    }
-  }
 
-  //initialize the unused elements: NULL
-  if(j-k > f->event_number){
-    for(i=k; i<base_id; i++){
-      tmpPtr = g_ptr_array_index(t->eventtype_event_id, i);
-      ((ptr_wrap*)tmpPtr)->ptr = NULL;
-    }
+/*****************************************************************************
+ *Get system information
+ ****************************************************************************/
+void getSystemInfo(LttSystemDescription* des, char * pathname)
+{
+  FILE * fp;
+  int i;
+  int entry_number = 15;
+  char buf[DIR_NAME_SIZE];
+  char description[4*DIR_NAME_SIZE];
+  char * ptr;
+
+  fp = fopen(pathname,"r");
+  if(!fp){
+    g_error("Can not open file : %s\n", pathname);
   }
-
-  //initialize the elements with the eventtypes belonging to the facility
-  for(i=0; i<f->event_number; i++){
-    tmpPtr = g_ptr_array_index(t->eventtype_event_id, base_id + i);
-    ((ptr_wrap*)tmpPtr)->ptr = (gpointer)(f->events[i]);
+  
+  while(fgets(buf,DIR_NAME_SIZE, fp)!= NULL){
+    ptr = buf;
+    while(isspace(*ptr)) ptr++;
+    if(strlen(ptr) == 0) continue;     
+    break;
   }
   
-  //update offset
-  for(i=0; i<f->event_number; i++){
-    et = f->events[i];
-    setFieldsOffset(t, et, NULL);
+  if(strlen(ptr) == 0) g_error("Not a valid file: %s\n", pathname);
+  if(strncmp("<system",ptr,7) !=0)g_error("Not a valid file: %s\n", pathname);
+
+  for(i=0;i<entry_number;i++){
+    if(fgets(buf,DIR_NAME_SIZE, fp)== NULL)
+      g_error("Not a valid file: %s\n", pathname);
+    ptr = buf;
+    while(isspace(*ptr)) ptr++;
+    switch(i){
+      case 0:
+	if(strncmp("node_name=",ptr,10)!=0)
+	  g_error("Not a valid file: %s\n", pathname);
+	des->node_name = g_strdup(ptr+10);
+        break;
+      case 1:
+	if(strncmp("domainname=",ptr,11)!=0)
+	  g_error("Not a valid file: %s\n", pathname);
+	des->domain_name = g_strdup(ptr+11);
+        break;
+      case 2:
+	if(strncmp("cpu=",ptr,4)!=0)
+	  g_error("Not a valid file: %s\n", pathname);
+	des->nb_cpu = (unsigned)atoi(ptr+4);
+        break;
+      case 3:
+	if(strncmp("arch_size=",ptr,10)!=0)
+	  g_error("Not a valid file: %s\n", pathname);
+	if(strcmp(ptr+10,"\"LP32\"") == 0) des->size = LTT_LP32;
+	else if(strcmp(ptr+10,"\"ILP32\"") == 0) des->size = LTT_ILP32;
+	else if(strcmp(ptr+10,"\"LP64\"") == 0) des->size = LTT_LP64;
+	else if(strcmp(ptr+10,"\"ILP64\"") == 0) des->size = LTT_ILP64;
+	else if(strcmp(ptr+10,"\"UNKNOWN\"") == 0) des->size = LTT_UNKNOWN;
+        break;
+      case 4:
+	if(strncmp("endian=",ptr,7)!=0)
+	  g_error("Not a valid file: %s\n", pathname);
+	if(strcmp(ptr+7,"\"LITTLE_ENDIAN\"") == 0)
+	  des->endian = LTT_LITTLE_ENDIAN;
+	else if(strcmp(ptr+7,"\"BIG_ENDIAN\"") == 0) 
+	  des->endian = LTT_BIG_ENDIAN;
+        break;
+      case 5:
+	if(strncmp("kernel_name=",ptr,12)!=0)
+	  g_error("Not a valid file: %s\n", pathname);
+	des->kernel_name = g_strdup(ptr+12);
+        break;
+      case 6:
+	if(strncmp("kernel_release=",ptr,15)!=0)
+	  g_error("Not a valid file: %s\n", pathname);
+	des->kernel_release = g_strdup(ptr+15);
+        break;
+       case 7:
+	 if(strncmp("kernel_version=",ptr,15)!=0)
+	   g_error("Not a valid file: %s\n", pathname);
+	 des->kernel_version = g_strdup(ptr+15);
+	 break;
+       case 8:
+	 if(strncmp("machine=",ptr,8)!=0)
+	   g_error("Not a valid file: %s\n", pathname);
+	 des->machine = g_strdup(ptr+8);
+	 break;
+       case 9:
+	 if(strncmp("processor=",ptr,10)!=0)
+	   g_error("Not a valid file: %s\n", pathname);
+	 des->processor = g_strdup(ptr+10);
+	 break;
+       case 10:
+	 if(strncmp("hardware_platform=",ptr,18)!=0)
+	   g_error("Not a valid file: %s\n", pathname);
+	 des->hardware_platform = g_strdup(ptr+18);
+	 break;
+       case 11:
+	 if(strncmp("operating_system=",ptr,17)!=0)
+	   g_error("Not a valid file: %s\n", pathname);
+	 des->operating_system = g_strdup(ptr+17);
+	 break;
+       case 12:
+	 if(strncmp("ltt_major_version=",ptr,18)!=0)
+	   g_error("Not a valid file: %s\n", pathname);
+	 ptr += 18; 
+	 ptr++;//skip begining "
+	 ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
+	 des->ltt_major_version = (unsigned)atoi(ptr);
+	 break;
+       case 13:
+	 if(strncmp("ltt_minor_version=",ptr,18)!=0)
+	   g_error("Not a valid file: %s\n", pathname);
+	 ptr += 18; 
+	 ptr++;//skip begining "
+	 ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
+	 des->ltt_minor_version = (unsigned)atoi(ptr);
+	 break;
+       case 14:
+	 if(strncmp("ltt_block_size=",ptr,15)!=0)
+	   g_error("Not a valid file: %s\n", pathname);
+	 ptr += 15; 
+	 ptr++;//skip begining "
+	 ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
+	 des->ltt_block_size = (unsigned)atoi(ptr);
+	 break;
+       default:
+	 g_error("Not a valid file: %s\n", pathname);      
+   }
   }
 
+  //get description
+  description[0] = '\0';
+  if(fgets(buf,DIR_NAME_SIZE, fp)== NULL)
+    g_error("Not a valid file: %s\n", pathname);
+  ptr = buf;
+  while(isspace(*ptr)) ptr++;
+  if(*ptr != '>') g_error("Not a valid file: %s\n", pathname);
+  while((ptr=fgets(buf,DIR_NAME_SIZE, fp))!= NULL){
+    ptr = buf;
+    while(isspace(*ptr)) ptr++;
+    if(strncmp("</system>",ptr,9) == 0 )break;
+    strcat(description, buf);
+  }
+  if(!ptr)g_error("Not a valid file: %s\n", pathname);
+  if(description[0] = '\0')des->description = NULL;
+  des->description = g_strdup(description);  
 
-  return 0;
+  fclose(fp);
 }
 
 /*****************************************************************************
- * The following functions used to query the info of the machine where the 
- * tracefile was generated.  A tracefile may be queried for its architecture 
- * type(e.g.,"i386", "powerpc", "powerpcle", "s390", "s390x"), its architecture
- * variant(e.g., "att" versus "sun" for m68k), its operating system (e.g., 
- * "linux","bsd"), its generic architecture, and the machine identity (e.g., 
- * system host name). All character strings belong to the associated tracefile 
- * and are freed when it is closed
+ *The following functions get facility/tracefile information
  ****************************************************************************/
 
-uint32_t ltt_tracefile_arch_type(ltt_tracefile *t)
+void getFacilityInfo(LttTrace *t, char* eventdefs)
 {
-  return t->trace_header->arch_type;
-}  
+  DIR * dir;
+  struct dirent *entry;
+  char * ptr;
+  int i,j;
+  LttFacility * f;
+  LttEventType * et;
+  LttTracefile * tracefile;
+
+  dir = opendir(eventdefs);
+  if(!dir) g_error("Can not open directory: %s\n", eventdefs);
+
+  while((entry = readdir(dir)) != NULL){
+    ptr = &entry->d_name[strlen(entry->d_name)-4];
+    if(strcmp(ptr,".xml") != 0) continue;
+    ltt_facility_open(t,entry->d_name);
+  }  
+  closedir(dir);
+  
+  tracefile = (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles,0);
+  for(j=0;j<t->facility_number;j++){
+    f = (LttFacility*)g_ptr_array_index(t->facilities, i);
+    for(i=0; i<f->event_number; i++){
+      et = f->events[i];
+      setFieldsOffset(tracefile, et, NULL);
+    }    
+  }
+}
 
-uint32_t ltt_tracefile_arch_variant(ltt_tracefile *t)
+void getControlFileInfo(LttTrace *t, char* control)
 {
-  return t->trace_header->arch_variant;
+  DIR * dir;
+  struct dirent *entry;
+
+  dir = opendir(control);
+  if(!dir) g_error("Can not open directory: %s\n", control);
+
+  while((entry = readdir(dir)) != NULL){
+    if(strcmp(entry->d_name,"facilities") != 0 ||
+       strcmp(entry->d_name,"interrupts") != 0 ||
+       strcmp(entry->d_name,"processes") != 0) continue;
+    
+    ltt_tracefile_open_control(t,entry->d_name);
+  }  
+  closedir(dir);
 }
 
-ltt_arch_size ltt_tracefile_arch_size(ltt_tracefile *t)
+void getCpuFileInfo(LttTrace *t, char* cpu)
 {
-  return t->trace_header->arch_size;
+  DIR * dir;
+  struct dirent *entry;
+
+  dir = opendir(cpu);
+  if(!dir) g_error("Can not open directory: %s\n", cpu);
+
+  while((entry = readdir(dir)) != NULL){
+    if(strcmp(entry->d_name,".") != 0 ||
+       strcmp(entry->d_name,"..") != 0 ){
+      ltt_tracefile_open_cpu(t,entry->d_name);
+    }else continue;
+  }  
+  closedir(dir);
 }
 
-ltt_arch_endian ltt_tracefile_arch_endian(ltt_tracefile *t)
-{
-  return t->trace_header->arch_endian;
-} 
+/*****************************************************************************
+ *A trace is specified as a pathname to the directory containing all the
+ *associated data (control tracefiles, per cpu tracefiles, event 
+ *descriptions...).
+ *
+ *When a trace is closed, all the associated facilities, types and fields
+ *are released as well.
+ ****************************************************************************/
 
-uint32_t ltt_tracefile_system_type(ltt_tracefile *t)
+LttTrace *ltt_trace_open(char *pathname)
 {
-  return t->trace_header->system_type;
+  LttTrace  * t;
+  LttSystemDescription * sys_description;
+  char eventdefs[DIR_NAME_SIZE];
+  char info[DIR_NAME_SIZE];
+  char control[DIR_NAME_SIZE];
+  char cpu[DIR_NAME_SIZE];
+  char tmp[DIR_NAME_SIZE];
+  gboolean has_slash = FALSE;
+
+  //establish the pathname to different directories
+  if(pathname[strlen(pathname)-1] == '/')has_slash = TRUE;
+  strcpy(eventdefs,pathname);
+  if(!has_slash)strcat(eventdefs,"/");
+  strcat(eventdefs,"eventdefs/");
+
+  strcpy(info,pathname);
+  if(!has_slash)strcat(info,"/");
+  strcat(info,"info/");
+
+  strcpy(control,pathname);
+  if(!has_slash)strcat(control,"/");
+  strcat(control,"control/");
+
+  strcpy(cpu,pathname);
+  if(!has_slash)strcat(cpu,"/");
+  strcat(cpu,"cpu/");
+
+  //new trace
+  t               = g_new(LttTrace, 1);
+  sys_description = g_new(LttSystemDescription, 1);  
+  t->pathname     = g_strdup(pathname);
+  t->facility_number          = 0;
+  t->control_tracefile_number = 0;
+  t->per_cpu_tracefile_number = 0;
+  t->system_description = sys_description;
+  t->control_tracefiles = g_ptr_array_new();
+  t->per_cpu_tracefiles = g_ptr_array_new();
+  t->facilities         = g_ptr_array_new();
+  getDataEndianType(&(t->my_arch_size), &(t->my_arch_endian));
+
+  //get system description  
+  strcpy(tmp,info);
+  strcat(tmp,"system.xml");
+  getSystemInfo(sys_description, tmp);
+
+  //get control tracefile info
+  getControlFileInfo(t,control);
+
+  //get cpu tracefile info
+  getCpuFileInfo(t,cpu);
+
+  //get facilities info
+  getFacilityInfo(t,eventdefs);
+  
+  return t;
 }
 
-char *ltt_tracefile_system_name(ltt_tracefile *t)
+void ltt_trace_close(LttTrace *t)
 {
-  return t->trace_header->system_name;
+  int i;
+  LttTracefile * tf;
+  LttFacility * f;
+
+  g_free(t->pathname);
+ 
+  //free system_description
+  g_free(t->system_description->description);
+  g_free(t->system_description->node_name);
+  g_free(t->system_description->domain_name);
+  g_free(t->system_description->kernel_name);
+  g_free(t->system_description->kernel_release);
+  g_free(t->system_description->kernel_version);
+  g_free(t->system_description->machine);
+  g_free(t->system_description->processor);
+  g_free(t->system_description->hardware_platform);
+  g_free(t->system_description->operating_system);
+  g_free(t->system_description);
+
+  //free control_tracefiles
+  for(i=0;i<t->control_tracefile_number;i++){
+    tf = (LttTracefile*)g_ptr_array_index(t->control_tracefiles,i);
+    ltt_tracefile_close(tf);
+  }
+  g_ptr_array_free(t->control_tracefiles, FALSE);
+
+  //free per_cpu_tracefiles
+  for(i=0;i<t->per_cpu_tracefile_number;i++){
+    tf = (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles,i);
+    ltt_tracefile_close(tf);
+  }
+  g_ptr_array_free(t->per_cpu_tracefiles, FALSE);
+
+  //free facilities
+  for(i=0;i<t->facility_number;i++){
+    f = (LttFacility*)g_ptr_array_index(t->facilities,i);
+    ltt_facility_close(f);
+  }
+  g_ptr_array_free(t->facilities, FALSE);
+
+  g_free(t);
 }
 
+
 /*****************************************************************************
- *Function name
- *    ltt_tracefile_cpu_number: get the number of the cpu
- *Input params
- *    t                       : tracefile
- *Return value
- *    unsigned                : the number of cpu the system has
+ *Get the system description of the trace
  ****************************************************************************/
 
-unsigned ltt_tracefile_cpu_number(ltt_tracefile *t)
+LttSystemDescription *ltt_trace_system_description(LttTrace *t)
 {
-  return (unsigned)(t->trace_header->cpu_number);
+  return t->system_description;
 }
 
 /*****************************************************************************
- *Function name
- *    ltt_tracefile_cpu_single: does the tracefile contain events only for a 
- *                              single CPU ?
- *Input params
- *    t                       : tracefile
- *Return value
- *    int                     : 1 for YES, 0 for NO
+ * The following functions discover the facilities of the trace
  ****************************************************************************/
 
-int ltt_tracefile_cpu_single(ltt_tracefile *t)
+unsigned ltt_trace_facility_number(LttTrace *t)
+{
+  return (unsigned)(t->facility_number);
+}
+
+LttFacility *ltt_trace_facility_get(LttTrace *t, unsigned i)
 {
-  if(t->trace_header->cpu_number_used == 1) return 1;
-  else return 0;
+  return (LttFacility*)g_ptr_array_index(t->facilities, i);
 }
 
 /*****************************************************************************
  *Function name
- *    ltt_tracefile_cpu_id: which CPU is contained in the tracefile?
+ *    ltt_trace_facility_find : find facilities in the trace
  *Input params
- *    t                   : tracefile
+ *    t                       : the trace 
+ *    name                    : facility name
+ *Output params
+ *    position                : position of the facility in the trace
  *Return value
- *    unsigned            : cpu id
+ *                            : the number of facilities
  ****************************************************************************/
 
-unsigned ltt_tracefile_cpu_id(ltt_tracefile *t)
+unsigned ltt_trace_facility_find(LttTrace *t, char *name, unsigned *position)
 {
-  return (unsigned)(t->trace_header->cpu_id);
+  int i, count=0;
+  LttFacility * f;
+  for(i=0;i=t->facility_number;i++){
+    f = (LttFacility*)g_ptr_array_index(t->facilities, i);
+    if(strcmp(f->name,name)==0){
+      count++;
+      if(count==1) *position = i;      
+    }else{
+      if(count) break;
+    }
+  }
+  return count;
 }
 
 /*****************************************************************************
- * The following functions get the times related to the tracefile
+ * Functions to discover all the event types in the trace 
  ****************************************************************************/
 
-ltt_time ltt_tracefile_time_start(ltt_tracefile *t)
+unsigned ltt_trace_eventtype_number(LttTrace *t)
 {
-  return t->start_time;
+  int i;
+  unsigned count = 0;
+  LttFacility * f;
+  for(i=0;i=t->facility_number;i++){
+    f = (LttFacility*)g_ptr_array_index(t->facilities, i);
+    count += f->event_number;
+  }
+  return count;
 }
 
-ltt_time ltt_tracefile_time_end(ltt_tracefile *t)
+LttFacility * ltt_trace_facility_by_id(LttTrace * trace, unsigned id)
 {
-  return t->end_time;
+  LttFacility * facility;
+  int i;
+  for(i=0;i<trace->facility_number;i++){
+    facility = (LttFacility*) g_ptr_array_index(trace->facilities,i);
+    if(id >= facility->base_id && 
+       id < facility->base_id + facility->event_number)
+      break;
+  }
+  if(i==trace->facility_number) return NULL;
+  else return facility;
 }
 
-ltt_time ltt_tracefile_duration(ltt_tracefile *t)
+LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned evId)
 {
-  ltt_time T;
-  TimeSub(T, t->end_time, t->start_time);
-  return T;
+  LttFacility * f;
+  f = ltt_trace_facility_by_id(t,evId);
+  if(!f) return NULL;
+  return f->events[evId - f->base_id];
 }
 
 /*****************************************************************************
- * The following functions discover the facilities added to the tracefile
+ *There is one "per cpu" tracefile for each CPU, numbered from 0 to
+ *the maximum number of CPU in the system. When the number of CPU installed
+ *is less than the maximum, some positions are unused. There are also a
+ *number of "control" tracefiles (facilities, interrupts...). 
  ****************************************************************************/
-
-unsigned ltt_tracefile_facility_number(ltt_tracefile *t)
-{
-  return (unsigned)(t->facility_number);
-}
-
-ltt_facility *ltt_tracefile_facility_get(ltt_tracefile *t, unsigned i)
+unsigned ltt_trace_control_tracefile_number(LttTrace *t)
 {
-  gconstpointer ptr = (gconstpointer)(&i);
-  if(i<=0 || i> t->facility_number)return NULL;
-  return (ltt_facility*)g_hash_table_lookup(t->index_facility,ptr);
+  return t->control_tracefile_number;
 }
 
-ltt_facility *ltt_tracefile_facility_get_by_name(ltt_tracefile *t,char *name)
+unsigned ltt_trace_per_cpu_tracefile_number(LttTrace *t)
 {
-  ltt_facility * fac;
-  fac=(ltt_facility*)g_hash_table_lookup(t->facility_name,(gconstpointer)name);
-  return fac;
+  return t->per_cpu_tracefile_number;
 }
 
 /*****************************************************************************
- * The following functions to discover all the event types in the facilities 
- * added to the tracefile. The event type integer id, unique for the trace, 
- * is used
+ *It is possible to search for the tracefiles by name or by CPU position.
+ *The index within the tracefiles of the same type is returned if found
+ *and a negative value otherwise. 
  ****************************************************************************/
 
-unsigned ltt_tracefile_eventtype_number(ltt_tracefile *t)
+int ltt_trace_control_tracefile_find(LttTrace *t, char *name)
 {
-  return t->eventtype_number;
+  LttTracefile * tracefile;
+  int i;
+  for(i=0;i<t->control_tracefile_number;i++){
+    tracefile = (LttTracefile*)g_ptr_array_index(t->control_tracefiles, i);
+    if(strcmp(tracefile->name, name)==0)break;
+  }
+  if(i == t->control_tracefile_number) return -1;
+  return i;
 }
 
-ltt_eventtype *ltt_tracefile_eventtype_get(ltt_tracefile *t, unsigned evId)
+int ltt_trace_per_cpu_tracefile_find(LttTrace *t, unsigned i)
 {
-  ptr_wrap * ptr;
-  ptr = (ptr_wrap *)g_ptr_array_index(t->eventtype_event_id, (gint)evId);
-  return (ltt_eventtype *)(ptr->ptr);
+  LttTracefile * tracefile;
+  int j, name;
+  for(j=0;j<t->per_cpu_tracefile_number;j++){
+    tracefile = (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, j);
+    name = atoi(tracefile->name);
+    if(name == (int)i)break;
+  }
+  if(j == t->per_cpu_tracefile_number) return -1;
+  return j;
 }
 
 /*****************************************************************************
- *Function name
- *    ltt_tracefile_eventtype_id
- *                        : given an event type, find its unique id within 
- *                          the tracefile
- *Input params
- *    t                   : tracefile
- *    et                  : event type
- *Return value
- *    unsigned            : id of the event type in the tracefile
+ *Get a specific tracefile 
  ****************************************************************************/
 
-unsigned ltt_tracefile_eventtype_id(ltt_tracefile *t, ltt_eventtype *et)
+LttTracefile *ltt_trace_control_tracefile_get(LttTrace *t, unsigned i)
 {
-  int *id;
-  char *name = et->facility->name;
-  
-  id = (int*)g_hash_table_lookup(t->base_id_name, (gconstpointer)name);
-  if(!id)return 0;
-  return (unsigned)(*id + et->index);
+  return (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, i);  
+}
+
+LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i)
+{
+  return (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, i);
 }
 
 /*****************************************************************************
- *Function name
- *    ltt_tracefile_eventtype_root_field
- *                        : get the root field associated with an event type
- *                          for the tracefile
- *Input params
- *    t                   : tracefile
- *    id                  : event id
- *Return value
- *    ltt_field *         : root field of the event
+ *Get the name of a tracefile
  ****************************************************************************/
 
-ltt_field *ltt_tracefile_eventtype_root_field(ltt_tracefile *t, unsigned id)
+char *ltt_tracefile_name(LttTracefile *tf)
 {
-  ltt_eventtype * et;
-  et = ltt_tracefile_eventtype_get(t, id);
-  if(!et) return NULL;
-  return et->root_field;
+  return tf->name;
 }
 
 /*****************************************************************************
@@ -477,37 +691,34 @@ ltt_field *ltt_tracefile_eventtype_root_field(ltt_tracefile *t, unsigned id)
  *Input params
  *    t                      : tracefile
  *    time                   : criteria of the time
- *Return value
- *    int                    : error code
- *                             ENOENT, end of the file
- *                             EINVAL, lseek fail
- *                             EIO, can not read from the file
  ****************************************************************************/
 
-int ltt_tracefile_seek_time(ltt_tracefile *t, ltt_time time)
+void ltt_tracefile_seek_time(LttTracefile *t, LttTime time)
 {
   int err;
-  ltt_time lttTime;
-  int headTime = timecmp(&(t->a_block_header->time), &time);
-  int tailTime = timecmp(&(t->a_block_footer->time), &time);
+  LttTime lttTime;
+  int headTime = timecmp(&(t->a_block_start->time), &time);
+  int tailTime = timecmp(&(t->a_block_end->time), &time);
   
   if(headTime < 0 && tailTime > 0){
     lttTime = getEventTime(t);
     err = timecmp(&lttTime, &time);
-    if(err >= 0){
-      if( ( (t->which_block != 1 && t->which_event != 0) ||
-            (t->which_block == 1 && t->which_event != 1)   ) &&
-          ((t->prev_event_time.tv_sec==0 && t->prev_event_time.tv_nsec==0) ||
-	   timecmp(&t->prev_event_time, &time) >= 0 )  ){
+    if(err > 0){
+      if(t->which_event==1 || timecmp(&t->prev_event_time,&time)<0){
+	return;
+      }else{
 	updateTracefile(t);
 	return ltt_tracefile_seek_time(t, time);
       }
     }else if(err < 0){
       err = t->which_block;
-      if(ltt_tracefile_read(t) == NULL) return ENOENT;      
+      if(ltt_tracefile_read(t) == NULL){
+	g_printf("End of file\n");      
+	return;
+      }
       if(t->which_block == err)
 	return ltt_tracefile_seek_time(t,time);
-    }    
+    }else return;    
   }else if(headTime > 0){
     if(t->which_block == 1){
       updateTracefile(t);      
@@ -516,7 +727,7 @@ int ltt_tracefile_seek_time(ltt_tracefile *t, ltt_time time)
 	   t->prev_block_end_time.tv_nsec == 0  ) ||
 	   timecmp(&(t->prev_block_end_time),&time) > 0 ){
 	err=readBlock(t,t->which_block-1);
-	if(err) return err; 
+	if(err) g_error("Can not read tracefile: %s\n", t->name); 
 	return ltt_tracefile_seek_time(t, time) ;
       }else{
 	updateTracefile(t);
@@ -525,13 +736,15 @@ int ltt_tracefile_seek_time(ltt_tracefile *t, ltt_time time)
   }else if(tailTime <= 0){
     if(t->which_block != t->block_number){
       err=readBlock(t,t->which_block+1);
-      if(err) return err; 
-    }else return ENOENT;    
+      if(err) g_error("Can not read tracefile: %s\n", t->name); 
+    }else {
+      g_printf("End of file\n");      
+      return;      
+    }    
     if(tailTime < 0) return ltt_tracefile_seek_time(t, time);
   }else if(headTime == 0){
     updateTracefile(t);
   }
-  return 0;
 }
 
 /*****************************************************************************
@@ -540,26 +753,32 @@ int ltt_tracefile_seek_time(ltt_tracefile *t, ltt_time time)
  *Input params
  *    t                  : tracefile
  *Return value
- *    ltt_event *        : an event to be processed
+ *    LttEvent *        : an event to be processed
  ****************************************************************************/
 
-ltt_event *ltt_tracefile_read(ltt_tracefile *t)
+LttEvent *ltt_tracefile_read(LttTracefile *t)
 {
-  ltt_event * lttEvent = (ltt_event *)g_new(ltt_event, 1);
-  ltt_eventtype * evT;
-  ltt_facility * fac;
+  LttEvent * lttEvent = (LttEvent *)g_new(LttEvent, 1);
+  int err;
 
   //update the fields of the current event and go to the next event
-  if(skipEvent(t)) return NULL;
+  err = skipEvent(t);
+  if(err == ENOENT) return NULL;
+  if(err == ERANGE) g_error("event id is out of range\n");
+  if(err)g_error("Can not read tracefile\n");
+
+  lttEvent->event_id = (int)(*(uint16_t *)(t->cur_event_pos));
+  if(lttEvent->event_id == TRACE_TIME_HEARTBEAT)
+    t->cur_heart_beat_number++;
 
   t->current_event_time = getEventTime(t);
 
-  lttEvent->event_id = (int)(*(uint8_t *)(t->cur_event_pos));
-  evT = ltt_tracefile_eventtype_get(t, (unsigned)lttEvent->event_id);
-  fac = evT->facility;
-  //  if(evT->index == TRACE_EV_HEARTBEAT && strcmp(fac->name, "default")==0)
-  //    t->cur_heart_beat_number++;
-  lttEvent->cycle_count=*(uint32_t*)(t->cur_event_pos + EVENT_ID_SIZE);
+  lttEvent->time_delta = *(uint32_t*)(t->cur_event_pos + EVENT_ID_SIZE);
+  lttEvent->event_time = t->current_event_time;
+
+  lttEvent->event_cycle_count = ((uint64_t)1)<<32  * t->cur_heart_beat_number 
+                                + lttEvent->time_delta;
+
   lttEvent->tracefile = t;
   lttEvent->data = t->cur_event_pos + EVENT_HEADER_SIZE;  
 
@@ -602,13 +821,13 @@ int readFile(int fd, void * buf, size_t size, char * mesg)
  *    EIO             : can not read from the file
  ****************************************************************************/
 
-int readBlock(ltt_tracefile * tf, int whichBlock)
+int readBlock(LttTracefile * tf, int whichBlock)
 {
   off_t nbBytes;
   uint32_t lostSize;
 
   if(whichBlock - tf->which_block == 1 && tf->which_block != 0){
-    tf->prev_block_end_time = tf->a_block_footer->time;
+    tf->prev_block_end_time = tf->a_block_end->time;
   }else{
     tf->prev_block_end_time.tv_sec = 0;
     tf->prev_block_end_time.tv_nsec = 0;
@@ -616,30 +835,23 @@ int readBlock(ltt_tracefile * tf, int whichBlock)
   tf->prev_event_time.tv_sec = 0;
   tf->prev_event_time.tv_nsec = 0;
 
-  nbBytes=lseek(tf->fd,(off_t)((whichBlock-1)*tf->trace_header->buffer_size),
-                  SEEK_SET);
+  nbBytes=lseek(tf->fd,(off_t)((whichBlock-1)*tf->block_size), SEEK_SET);
   if(nbBytes == -1) return EINVAL;
   
-  if(readFile(tf->fd,tf->buffer,tf->trace_header->buffer_size,
-              "Unable to read a block")) return EIO;
+  if(readFile(tf->fd,tf->buffer,tf->block_size,"Unable to read a block")) 
+    return EIO;
 
+  tf->a_block_start=(BlockStart *) (tf->buffer + EVENT_HEADER_SIZE);
+  lostSize = *(uint32_t*)(tf->buffer + tf->block_size - sizeof(uint32_t));
+  tf->a_block_end=(BlockEnd *)(tf->buffer + tf->block_size - 
+				lostSize + EVENT_HEADER_SIZE); 
 
-  tf->a_block_header=(block_header *) tf->buffer;
-  lostSize = *(uint32_t*)(tf->buffer + tf->trace_header->buffer_size 
-			  - sizeof(uint32_t));
-  /* skip event ID and time delta to get the address of the block foot */
-  tf->a_block_footer=(block_footer *)(tf->buffer+tf->trace_header->buffer_size
-                                   -lostSize+sizeof(uint8_t)+sizeof(uint32_t)); 
   tf->which_block = whichBlock;
-  tf->which_event = 0;
-  tf->first_event_pos = tf->buffer + sizeof(block_header);
-  if(tf->which_block == 1){
-    tf->which_event++;
-    tf->first_event_pos += sizeof(trace_header_event);
-  }
-  tf->cur_event_pos = tf->first_event_pos;
-  tf->current_event_time = tf->a_block_header->time;
+  tf->which_event = 1;
+  tf->cur_event_pos = tf->a_block_start + sizeof(BlockStart); //first event
   tf->cur_heart_beat_number = 0;
+
+  tf->current_event_time = getEventTime(tf);
   
   getCyclePerNsec(tf);
 
@@ -654,12 +866,11 @@ int readBlock(ltt_tracefile * tf, int whichBlock)
  *    tf              : tracefile
  ****************************************************************************/
 
-void updateTracefile(ltt_tracefile * tf)
+void updateTracefile(LttTracefile * tf)
 {
-  if(tf->which_block == 1)tf->which_event = 1;
-  else tf->which_event = 0;
-  tf->cur_event_pos = tf->first_event_pos;
-  tf->current_event_time = tf->a_block_header->time;  
+  tf->which_event = 1;
+  tf->cur_event_pos = tf->a_block_start + sizeof(BlockStart);
+  tf->current_event_time = getEventTime(tf);  
   tf->cur_heart_beat_number = 0;
 
   tf->prev_event_time.tv_sec = 0;
@@ -679,16 +890,16 @@ void updateTracefile(ltt_tracefile * tf)
  *    ERANGE          : event id is out of range
  ****************************************************************************/
 
-int skipEvent(ltt_tracefile * t)
+int skipEvent(LttTracefile * t)
 {
   int evId, err;
   void * evData;
-  ltt_eventtype * evT;
-  ltt_field * rootFld;
+  LttEventType * evT;
+  LttField * rootFld;
 
-  evId   = (int)(*(uint8_t *)(t->cur_event_pos));
+  evId   = (int)(*(uint16_t *)(t->cur_event_pos));
   evData = t->cur_event_pos + EVENT_HEADER_SIZE;
-  evT    = ltt_tracefile_eventtype_get(t,(unsigned)evId);
+  evT    = ltt_trace_eventtype_get(t->trace,(unsigned)evId);
 
   if(evT) rootFld = evT->root_field;
   else return ERANGE;
@@ -706,7 +917,7 @@ int skipEvent(ltt_tracefile * t)
   evT->latest_event = t->which_event;
   
   //the next event is in the next block
-  if(t->which_event == t->a_block_header->event_count - 1){
+  if(evId == TRACE_BLOCK_END){
     if(t->which_block == t->block_number) return ENOENT;
     err = readBlock(t, t->which_block + 1);
     if(err) return err;
@@ -724,18 +935,18 @@ int skipEvent(ltt_tracefile * t)
  *    t               : tracefile
  ****************************************************************************/
 
-void getCyclePerNsec(ltt_tracefile * t)
+void getCyclePerNsec(LttTracefile * t)
 {
-  ltt_time            lBufTotalTime; /* Total time for this buffer */
-  ltt_cycle_count     lBufTotalNSec; /* Total time for this buffer in nsecs */
-  ltt_cycle_count     lBufTotalCycle;/* Total cycles for this buffer */
+  LttTime           lBufTotalTime; /* Total time for this buffer */
+  LttCycleCount     lBufTotalNSec; /* Total time for this buffer in nsecs */
+  LttCycleCount     lBufTotalCycle;/* Total cycles for this buffer */
 
   /* Calculate the total time for this buffer */
-  TimeSub(lBufTotalTime,t->a_block_footer->time, t->a_block_header->time);
+  TimeSub(lBufTotalTime,t->a_block_end->time, t->a_block_start->time);
 
   /* Calculate the total cycles for this bufffer */
-  lBufTotalCycle = t->a_block_footer->cycle_count 
-                   - t->a_block_header->cycle_count;
+  lBufTotalCycle = t->a_block_end->cycle_count 
+                   - t->a_block_start->cycle_count;
 
   /* Convert the total time to nsecs */
   lBufTotalNSec = lBufTotalTime.tv_sec * 1000000000 + lBufTotalTime.tv_nsec;
@@ -749,31 +960,31 @@ void getCyclePerNsec(ltt_tracefile * t)
  *Input params 
  *    tf              : tracefile
  *Return value
- *    ltt_time        : the time of the event
+ *    LttTime        : the time of the event
  ****************************************************************************/
 
-ltt_time getEventTime(ltt_tracefile * tf)
+LttTime getEventTime(LttTracefile * tf)
 {
-  ltt_time        time;
-  ltt_cycle_count cycle_count;      /* cycle count for the current event */
-  ltt_cycle_count lEventTotalCycle; /* Total cycles from start for event */
-  double          lEventNSec;       /* Total usecs from start for event */
-  ltt_time        lTimeOffset;      /* Time offset in struct ltt_time */
+  LttTime       time;
+  LttCycleCount cycle_count;      // cycle count for the current event
+  LttCycleCount lEventTotalCycle; // Total cycles from start for event
+  double        lEventNSec;       // Total usecs from start for event
+  LttTime       lTimeOffset;      // Time offset in struct LttTime
   
-  /* Calculate total time in cycles from start of buffer for this event */
-  cycle_count = *(uint32_t*)(tf->cur_event_pos + EVENT_ID_SIZE);
+  // Calculate total time in cycles from start of buffer for this event 
+  cycle_count = (LttCycleCount)*(uint32_t*)(tf->cur_event_pos + EVENT_ID_SIZE);
   if(tf->cur_heart_beat_number)
     cycle_count += ((uint64_t)1)<<32  * tf->cur_heart_beat_number;
-  lEventTotalCycle=cycle_count-(tf->a_block_header->cycle_count & 0xFFFFFFFF);
+  lEventTotalCycle = cycle_count - tf->a_block_start->cycle_count;
 
-  /* Convert it to nsecs */
+  // Convert it to nsecs
   lEventNSec = lEventTotalCycle / tf->cycle_per_nsec;
   
-  /* Determine offset in struct ltt_time */
+  // Determine offset in struct LttTime 
   lTimeOffset.tv_nsec = (long)lEventNSec % 1000000000;
   lTimeOffset.tv_sec  = (long)lEventNSec / 1000000000;
 
-  TimeAdd(time, tf->a_block_header->time, lTimeOffset);  
+  TimeAdd(time, tf->a_block_start->time, lTimeOffset);  
 
   return time;
 }
@@ -787,9 +998,9 @@ ltt_time getEventTime(ltt_tracefile * tf)
  *    evD             : event data, it may be NULL
  ****************************************************************************/
 
-void setFieldsOffset(ltt_tracefile * t, ltt_eventtype * evT, void * evD)
+void setFieldsOffset(LttTracefile * t, LttEventType * evT, void * evD)
 {
-  ltt_field * rootFld = evT->root_field;
+  LttField * rootFld = evT->root_field;
   //  rootFld->base_address = evD;
 
   rootFld->field_size = getFieldtypeSize(t, evT, 0,0,rootFld, evD);  
@@ -809,15 +1020,17 @@ void setFieldsOffset(ltt_tracefile * t, ltt_eventtype * evT, void * evD)
  *    int             : size of the field
  ****************************************************************************/
 
-int getFieldtypeSize(ltt_tracefile * t, ltt_eventtype * evT, int offsetRoot,
-		     int offsetParent, ltt_field * fld, void * evD)
+int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot,
+		     int offsetParent, LttField * fld, void * evD)
 {
   int size, size1, element_number, i, offset1, offset2;
-  ltt_type * type = fld->field_type;
+  LttType * type = fld->field_type;
 
-  if(evT->latest_block==t->which_block && evT->latest_event==t->which_event){
-    return fld->field_size;
-  } 
+  if(!t){
+    if(evT->latest_block==t->which_block && evT->latest_event==t->which_event){
+      return fld->field_size;
+    } 
+  }
 
   if(fld->field_fixed == 1){
     if(fld == evT->root_field) return fld->field_size;
@@ -826,7 +1039,7 @@ int getFieldtypeSize(ltt_tracefile * t, ltt_eventtype * evT, int offsetRoot,
   if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY &&
      type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){
     if(fld->field_fixed == -1){
-      size = (int) ltt_type_size(t, type);
+      size = (int) ltt_type_size(t->trace, type);
       fld->field_fixed = 1;
     }else size = fld->field_size;
 
@@ -849,7 +1062,7 @@ int getFieldtypeSize(ltt_tracefile * t, ltt_eventtype * evT, int offsetRoot,
     }else size = fld->field_size;
 
   }else if(type->type_class == LTT_SEQUENCE){
-    size1 = (int) ltt_type_size(t, type);
+    size1 = (int) ltt_type_size(t->trace, type);
     if(fld->field_fixed == -1){
       fld->field_fixed = 0;
       size = getFieldtypeSize(t, evT, offsetRoot,0,fld->child[0], NULL);      
@@ -932,9 +1145,9 @@ int getFieldtypeSize(ltt_tracefile * t, ltt_eventtype * evT, int offsetRoot,
  *    int       : 0: t1 == t2; -1: t1 < t2; 1: t1 > t2
  ****************************************************************************/
 
-int timecmp(ltt_time * t1, ltt_time * t2)
+int timecmp(LttTime * t1, LttTime * t2)
 {
-  ltt_time T;
+  LttTime T;
   TimeSub(T, *t1, *t2);
   if(T.tv_sec == 0 && T.tv_nsec == 0) return 0;
   else if(T.tv_sec > 0 || (T.tv_sec==0 && T.tv_nsec > 0)) return 1;
@@ -971,7 +1184,7 @@ int getIntNumber(int size, void *evD)
  *    endian            : endian type, little or big
  ****************************************************************************/
 
-void getDataEndianType(ltt_arch_size * size, ltt_arch_endian * endian)
+void getDataEndianType(LttArchSize * size, LttArchEndian * endian)
 {
   int i = 1;
   char c = (char) i;
diff --git a/ltt/branches/poly/ltt/type.c b/ltt/branches/poly/ltt/type.c
index 34a7b5d6..ee0d7193 100644
--- a/ltt/branches/poly/ltt/type.c
+++ b/ltt/branches/poly/ltt/type.c
@@ -21,7 +21,7 @@ static unsigned floatSizes[] = {
  *    char *             : the name of the event type
  ****************************************************************************/
 
-char *ltt_eventtype_name(ltt_eventtype *et)
+char *ltt_eventtype_name(LttEventType *et)
 {
   return et->name;
 }
@@ -35,25 +35,83 @@ char *ltt_eventtype_name(ltt_eventtype *et)
  *    char *             : the description of the event type
  ****************************************************************************/
 
-char *ltt_eventtype_description(ltt_eventtype *et)
+char *ltt_eventtype_description(LttEventType *et)
 {
   return et->description;
 }
 
+/*****************************************************************************
+ *Function name
+ *    ltt_eventtype_facility : get the facility which contains the event type
+ *Input params
+ *    et                     : an  event type   
+ *Return value
+ *    LttFacility *          : the facility
+ ****************************************************************************/
+
+LttFacility *ltt_eventtype_facility(LttEventType *et)
+{
+  return et->facility;
+}
+
+/*****************************************************************************
+ *Function name
+ *    ltt_eventtype_relative_id : get the relative id of the event type
+ *Input params
+ *    et                        : an  event type   
+ *Return value
+ *    unsigned *                : the relative id
+ ****************************************************************************/
+
+unsigned *ltt_eventtype_relative_id(LttEventType *et)
+{
+  return (unsigned*)&et->index;
+}
+
+/*****************************************************************************
+ *Function name
+ *    ltt_eventtype_id : get the id of the event type
+ *Input params
+ *    et               : an  event type   
+ *Return value
+ *    unsigned *       : the id
+ ****************************************************************************/
+
+unsigned *ltt_eventtype_id(LttEventType *et)
+{
+  unsigned *id = g_new(unsigned,1);
+  *id = et->facility->base_id + et->index;
+  return (unsigned*)id;
+}
+
 /*****************************************************************************
  *Function name
  *    ltt_eventtype_type : get the type of the event type
  *Input params
  *    et                 : an  event type   
  *Return value
- *    ltt_type *         : the type of the event type
+ *    LttType *         : the type of the event type
  ****************************************************************************/
 
-ltt_type *ltt_eventtype_type(ltt_eventtype *et)
+LttType *ltt_eventtype_type(LttEventType *et)
 {
   return et->root_field->field_type;
 }
 
+/*****************************************************************************
+ *Function name
+ *    ltt_eventtype_field : get the root filed of the event type
+ *Input params
+ *    et                  : an  event type   
+ *Return value
+ *    LttField *          : the root filed of the event type
+ ****************************************************************************/
+
+LttField *ltt_eventtype_field(LttEventType *et)
+{
+  return et->root_field;
+}
+
 /*****************************************************************************
  *Function name
  *    ltt_type_name  : get the name of the type
@@ -63,7 +121,7 @@ ltt_type *ltt_eventtype_type(ltt_eventtype *et)
  *    char *         : the name of the type
  ****************************************************************************/
 
-char *ltt_type_name(ltt_type *t)
+char *ltt_type_name(LttType *t)
 {
   return t->element_name;
 }
@@ -74,10 +132,10 @@ char *ltt_type_name(ltt_type *t)
  *Input params
  *    t              : a type   
  *Return value
- *    ltt_type_enum  : the type class of the type
+ *    LttTypeEnum  : the type class of the type
  ****************************************************************************/
 
-ltt_type_enum ltt_type_class(ltt_type *t)
+LttTypeEnum ltt_type_class(LttType *t)
 {
   return t->type_class;
 }
@@ -94,7 +152,7 @@ ltt_type_enum ltt_type_class(ltt_type *t)
  *    unsigned      : the type size
  ****************************************************************************/
 
-unsigned ltt_type_size(ltt_tracefile * tf, ltt_type *t)
+unsigned ltt_type_size(LttTrace * trace, LttType *t)
 {
   if(t->type_class==LTT_STRUCT || t->type_class==LTT_ARRAY || 
      t->type_class==LTT_STRING) return 0;
@@ -105,7 +163,7 @@ unsigned ltt_type_size(ltt_tracefile * tf, ltt_type *t)
     if(t->size < sizeof(intSizes)/sizeof(unsigned))
       return intSizes[t->size];
     else{
-      ltt_arch_size size = tf->trace_header->arch_size;
+      LttArchSize size = trace->system_description->size;
       if(size == LTT_LP32)
 	return sizeof(int16_t);
       else if(size == LTT_ILP32 || size == LTT_LP64)
@@ -123,10 +181,10 @@ unsigned ltt_type_size(ltt_tracefile * tf, ltt_type *t)
  *Input params
  *    t                     : a type   
  *Return value
- *    ltt_type              : the type of nested element of array or sequence
+ *    LttType              : the type of nested element of array or sequence
  ****************************************************************************/
 
-ltt_type *ltt_type_element_type(ltt_type *t)
+LttType *ltt_type_element_type(LttType *t)
 {
   if(t->type_class != LTT_ARRAY || t->type_class != LTT_SEQUENCE)
     return NULL;
@@ -142,7 +200,7 @@ ltt_type *ltt_type_element_type(ltt_type *t)
  *    unsigned                : the number of elements for arrays
  ****************************************************************************/
 
-unsigned ltt_type_element_number(ltt_type *t)
+unsigned ltt_type_element_number(LttType *t)
 {
   if(t->type_class != LTT_ARRAY)
     return 0;
@@ -158,9 +216,9 @@ unsigned ltt_type_element_number(ltt_type *t)
  *    unsigned               : the number of members for structure
  ****************************************************************************/
 
-unsigned ltt_type_member_number(ltt_type *t)
+unsigned ltt_type_member_number(LttType *t)
 {
-  if(t->type_class != LTT_STRUCT)
+  if(t->type_class != LTT_STRUCT || t->type_class != LTT_UNION)
     return 0;
   return t->element_number;  
 }
@@ -172,10 +230,10 @@ unsigned ltt_type_member_number(ltt_type *t)
  *    t                    : a type   
  *    i                    : index of the member
  *Return value
- *    ltt_type *           : the type of structure member
+ *    LttType *           : the type of structure member
  ****************************************************************************/
 
-ltt_type *ltt_type_member_type(ltt_type *t, unsigned i)
+LttType *ltt_type_member_type(LttType *t, unsigned i)
 {
   if(t->type_class != LTT_STRUCT) return NULL;
   if(i > t->element_number || i == 0 ) return NULL;
@@ -194,7 +252,7 @@ ltt_type *ltt_type_member_type(ltt_type *t, unsigned i)
  *    char *              : symbolic string associated with a value
  ****************************************************************************/
 
-char *ltt_enum_string_get(ltt_type *t, unsigned i)
+char *ltt_enum_string_get(LttType *t, unsigned i)
 {  
   if(t->type_class != LTT_ENUM) return NULL;
   if(i > t->element_number || i == 0 ) return NULL;
@@ -208,10 +266,10 @@ char *ltt_enum_string_get(ltt_type *t, unsigned i)
  *Input params
  *    f                 : a field   
  *Return value
- *    ltt_field *       : the field of the nested element
+ *    LttField *       : the field of the nested element
  ****************************************************************************/
 
-ltt_field *ltt_field_element(ltt_field *f)
+LttField *ltt_field_element(LttField *f)
 {
   if(f->field_type->type_class != LTT_ARRAY ||
      f->field_type->type_class != LTT_SEQUENCE)
@@ -227,10 +285,10 @@ ltt_field *ltt_field_element(ltt_field *f)
  *    f                 : a field   
  *    i                 : index of member field
  *Return value
- *    ltt_field *       : the field of the nested element
+ *    LttField *       : the field of the nested element
  ****************************************************************************/
 
-ltt_field *ltt_field_member(ltt_field *f, unsigned i)
+LttField *ltt_field_member(LttField *f, unsigned i)
 {
   if(f->field_type->type_class != LTT_STRUCT) return NULL;
   if(i==0 || i>f->field_type->element_number) return NULL;
@@ -246,7 +304,7 @@ ltt_field *ltt_field_member(ltt_field *f, unsigned i)
  *    ltt_tyoe *      : the type of field
  ****************************************************************************/
 
-ltt_type *ltt_field_type(ltt_field *f)
+LttType *ltt_field_type(LttField *f)
 {
   return f->field_type;
 }