X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Fparser.c;h=1ab1b73bf7bf256ac23f468d95482c31584cfc33;hb=01e5c8ac303294105046b1383fe923ae28bd4890;hp=8e409aa927736ac2f9334a58d14e55e23f928626;hpb=4e4d11b3b1db254446f6cad04b3c3fa9b574851f;p=lttv.git

diff --git a/ltt/branches/poly/ltt/parser.c b/ltt/branches/poly/ltt/parser.c
index 8e409aa9..1ab1b73b 100644
--- a/ltt/branches/poly/ltt/parser.c
+++ b/ltt/branches/poly/ltt/parser.c
@@ -3,16 +3,15 @@
 parser.c: Generate helper declarations and functions to trace events
   from an event description file.
 
-Copyright (C) 2002, Xianxiu Yang
-Copyright (C) 2002, Michel Dagenais
-Copyright (C) 2005, Mathieu Desnoyers
-
-This program is free software; you can redistribute it and/or modify
+	    Copyright (C) 2005, Mathieu Desnoyers
+      Copyright (C) 2002, Xianxiu Yang
+      Copyright (C) 2002, Michel Dagenais 
+   This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-the Free Software Foundation; version 2 of the License.
+   the Free Software Foundation; version 2 of the License.
 
-This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
@@ -34,21 +33,58 @@ This program is distributed in the hope that it will be useful,
    all types is maintained to facilitate the freeing of all type 
    information when the processing of an ".xml" file is finished. */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <stdlib.h> 
 #include <string.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <linux/errno.h>  
+#include <assert.h>
 #include <ctype.h>
-#include <linux/errno.h>
-#include <glib.h>
-
 
 #include "parser.h"
 
+
+char *intOutputTypes[] = {
+  "int8_t", "int16_t", "int32_t", "int64_t" };
+
+char *uintOutputTypes[] = {
+  "uint8_t", "uint16_t", "uint32_t", "uint64_t" };
+
+char *floatOutputTypes[] = {
+  "undef", "undef", "float", "double" };
+
+
+
+
+/* helper function  */
+void strupper(char *string)
+{
+  char *ptr = string;
+  
+  while(*ptr != '\0') {
+    *ptr = toupper(*ptr);
+		ptr++;
+  }
+}
+
+
+int getSizeindex(unsigned int value)
+{ 
+  switch(value) {
+    case 1:
+      return 0;
+    case 2:
+      return 1;
+    case 4:
+      return 2;
+    case 8:
+      return 3;
+    default:
+      printf("Error : unknown value size %d\n", value);
+      exit(-1);
+  }
+}
+
 /*****************************************************************************
  *Function name
  *    getSize    : translate from string to integer
@@ -58,22 +94,33 @@ This program is distributed in the hope that it will be useful,
  *    size                           
  *****************************************************************************/
 
-int getSize(parse_file *in)
+unsigned long long int getSize(parse_file_t *in)
 {
-  gchar *token;
+  char *token, *token2;
+	unsigned long long int ret;
 
   token = getToken(in);
-  if(in->type == NUMBER) {
-    if(g_ascii_strcasecmp(token,"1") == 0) return 0;
-    else if(g_ascii_strcasecmp(token,"2") == 0) return 1;
-    else if(g_ascii_strcasecmp(token,"4") == 0) return 2;
-    else if(g_ascii_strcasecmp(token,"8") == 0) return 3;
-  }
-  else if(in->type == NAME) {
-    if(g_ascii_strcasecmp(token,"short") == 0) return 4;
-    else if(g_ascii_strcasecmp(token,"medium") == 0) return 5;
-    else if(g_ascii_strcasecmp(token,"long") == 0) return 6;
+
+
+  if(in->type == QUOTEDSTRING) {
+    in->type = NUMBER;
+    token2 = token;
+    do {
+       if (!isdigit(*token2)) {
+          in->type = QUOTEDSTRING;
+          break;
+				}
+    } while (*(++token2) != '\0');
   }
+
+  if(in->type == NUMBER) {
+		ret = strtoull(token, NULL, 0);
+  } else {
+		goto error;
+	}
+		
+	return ret;
+error:
   in->error(in,"incorrect size specification");
   return -1;
 }
@@ -86,131 +133,347 @@ int getSize(parse_file *in)
  *    msg             : message to be printed                  
  ****************************************************************************/
 
-void error_callback(parse_file *in, char *msg)
+void error_callback(parse_file_t *in, char *msg)
 {
   if(in)
-    g_printf("Error in file %s, line %d: %s\n", in->name, in->lineno, msg);
+    printf("Error in file %s, line %d: %s\n", in->name, in->lineno, msg);
   else
     printf("%s\n",msg);
+  assert(0);
+  exit(1);
+}
+
+/*****************************************************************************
+ *Function name
+ *    memAlloc  : allocate memory                    
+ *Input params 
+ *    size      : required memory size               
+ *return value 
+ *    void *    : pointer to allocate memory or NULL 
+ ****************************************************************************/
+
+void * memAlloc(int size)
+{
+  void * addr;
+  if(size == 0) return NULL;
+  addr = malloc(size);
+  if(!addr){
+    printf("Failed to allocate memory");    
+    exit(1);
+  }
+  return addr;	  
+}
+
+/*****************************************************************************
+ *Function name
+ *    allocAndCopy : allocate memory and initialize it  
+ *Input params 
+ *    str          : string to be put in memory         
+ *return value 
+ *    char *       : pointer to allocate memory or NULL
+ ****************************************************************************/
+
+char *allocAndCopy(char *str)
+{
+  char * addr;
+  if(str == NULL) return NULL;
+  addr = (char *)memAlloc(strlen(str)+1);
+  strcpy(addr,str);
+  return addr;
 }
 
 /**************************************************************************
  * Function :
- *    getNameAttribute,getFormatAttribute,getSizeAttribute,getValueAttribute 
- *    getValueStrAttribute
+ *    getTypeAttributes
  * Description :
  *    Read the attribute from the input file.
  *
  * Parameters :
  *    in , input file handle.
- *
- * Return values :
- *    address of the attribute.
+ *    t , the type descriptor to fill.
  *
  **************************************************************************/
 
-gchar * getNameAttribute(parse_file *in)
+void getTypeAttributes(parse_file_t *in, type_descriptor_t *t,
+			   sequence_t * unnamed_types, table_t * named_types) 
 {
-  gchar * token;
-  gunichar car;
-  GIOStatus status;
-  
-  token = getName(in);
-  if(g_ascii_strcasecmp("name",token))in->error(in,"name was expected");
-  getEqual(in);
+  char * token;
+	char car;
+
+  t->fmt = NULL;
+  t->size = 0;
+  t->custom_write = 0;
+	t->network = 0;
   
-  status = seekNextChar(in, &car);
-  if(status == G_IO_STATUS_EOF || status == G_IO_STATUS_ERROR)
-    in->error(in,"name was expected");
-  else if(car == '\"') token = getQuotedString(in);
-  else token = getName(in);
-  return token;
+  while(1) {
+    token = getToken(in); 
+    if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
+      ungetToken(in);
+      break;
+    }
+    
+    if(!strcmp("format",token)) {
+      getEqual(in);
+      t->fmt = allocAndCopy(getQuotedString(in));
+    //} else if(!strcmp("name",token)) {
+     // getEqual(in);
+     // car = seekNextChar(in);
+     // if(car == EOF) in->error(in,"name was expected");
+     // else if(car == '\"') t->type_name = allocAndCopy(getQuotedString(in));
+     // else t->type_name = allocAndCopy(getName(in));
+    } else if(!strcmp("size",token)) {
+      getEqual(in);
+      t->size = getSize(in);
+    } else if(!strcmp("custom_write", token)) {
+      t->custom_write = 1;
+		} else if(!strcmp("byte_order",token)) {
+     	getEqual(in);
+     	car = seekNextChar(in);
+     	if(car == EOF) in->error(in,"byte order was expected (network?)");
+     	else if(car == '\"') token = getQuotedString(in);
+     	else token = getName(in);
+		 	if(!strcmp("network", token)) {
+		   	t->network = 1;
+			}
+		} else if(!strcmp("write",token)) {
+     	getEqual(in);
+     	car = seekNextChar(in);
+     	if(car == EOF) in->error(in,"write type was expected (custom?)");
+     	else if(car == '\"') token = getQuotedString(in);
+     	else token = getName(in);
+		 	if(!strcmp("custom", token)) {
+		   	t->custom_write = 1;
+			}
+	  }
+	}
 }
 
-char * getFormatAttribute(parse_file *in)
+/**************************************************************************
+ * Function :
+ *    getEventAttributes
+ * Description :
+ *    Read the attribute from the input file.
+ *
+ * Parameters :
+ *    in , input file handle.
+ *    ev , the event to fill.
+ *
+ **************************************************************************/
+
+void getEventAttributes(parse_file_t *in, event_t *ev)
 {
   char * token;
+  char car;
+  
+  ev->name = NULL;
+  ev->per_trace = 0;
+  ev->per_tracefile = 0;
+  ev->param_buffer = 0;
+	ev->no_instrument_function = 0;
+
+  while(1) {
+    token = getToken(in); 
+    if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
+      ungetToken(in);
+      break;
+    }
 
-  //format is an option
-  token = getToken(in); 
-  if(g_ascii_strcasecmp("/",token) == 0 || g_ascii_strcasecmp(">",token) == 0){
-    ungetToken(in);
-    return NULL;
+    if(!strcmp("name",token)) {
+      getEqual(in);
+      car = seekNextChar(in);
+      if(car == EOF) in->error(in,"name was expected");
+      else if(car == '\"') ev->name = allocAndCopy(getQuotedString(in));
+      else ev->name = allocAndCopy(getName(in));
+    } else if(!strcmp("scope", token)) {
+			getEqual(in);
+			car = seekNextChar(in);
+			if(car == EOF) in->error(in,"scope was expected");
+      else if(car == '\"') token = getQuotedString(in);
+      else token = getName(in);
+			if(!strcmp(token, "trace")) ev->per_trace = 1;
+			else if(!strcmp(token, "tracefile")) ev->per_tracefile = 1;
+	  } else if(!strcmp("param", token)) {
+			getEqual(in);
+			car = seekNextChar(in);
+			if(car == EOF) in->error(in,"parameter type was expected");
+      else if(car == '\"') token = getQuotedString(in);
+      else token = getName(in);
+			if(!strcmp(token, "buffer")) ev->param_buffer = 1;
+		} else if(!strcmp("attribute", token)) {
+			getEqual(in);
+			car = seekNextChar(in);
+			if(car == EOF) in->error(in,"attribute was expected");
+      else if(car == '\"') token = getQuotedString(in);
+      else token = getName(in);
+			if(!strcmp(token, "no_instrument_function"))
+				ev->no_instrument_function = 1;
+    }
   }
+}
 
-  if(g_ascii_strcasecmp("format",token))in->error(in,"format was expected");
-  getEqual(in);
-  token = getQuotedString(in);
-  return token;
+/**************************************************************************
+ * Function :
+ *    getFacilityAttributes
+ * Description :
+ *    Read the attribute from the input file.
+ *
+ * Parameters :
+ *    in , input file handle.
+ *    fac , the facility to fill.
+ *
+ **************************************************************************/
+
+void getFacilityAttributes(parse_file_t *in, facility_t *fac)
+{
+  char * token;
+  char car;
+  
+  fac->name = NULL;
+  fac->arch = NULL;
+	fac->user = 0;
+
+  while(1) {
+    token = getToken(in); 
+    if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
+      ungetToken(in);
+      break;
+    }
+
+    if(!strcmp("name",token)) {
+      getEqual(in);
+      car = seekNextChar(in);
+      if(car == EOF) in->error(in,"name was expected");
+      else if(car == '\"') fac->name = allocAndCopy(getQuotedString(in));
+      else fac->name = allocAndCopy(getName(in));
+			if(!strncmp(fac->name, "user_", sizeof("user_")-1))
+				fac->user = 1;
+    } else if(!strcmp("arch", token)) {
+      getEqual(in);
+      car = seekNextChar(in);
+      if(car == '\"') fac->arch = allocAndCopy(getQuotedString(in));
+			else fac->arch = allocAndCopy(getName(in));
+		}
+  }
 }
 
-int getSizeAttribute(parse_file *in)
+/**************************************************************************
+ * Function :
+ *    getFieldAttributes
+ * Description :
+ *    Read the attribute from the input file.
+ *
+ * Parameters :
+ *    in , input file handle.
+ *    f , the field to fill.
+ *
+ **************************************************************************/
+
+void getFieldAttributes(parse_file_t *in, field_t *f)
 {
-  /* skip name and equal */
-  getName(in);
-  getEqual(in);
+  char * token;
+  char car;
+
+  f->name = NULL;
+
+  while(1) {
+    token = getToken(in); 
+    if(strcmp("/",token) == 0 || strcmp(">",token) == 0){
+      ungetToken(in);
+      break;
+    }
 
-  return getSize(in);
+    if(!strcmp("name",token)) {
+      getEqual(in);
+      car = seekNextChar(in);
+      if(car == EOF) in->error(in,"name was expected");
+      else if(car == '\"') f->name = allocAndCopy(getQuotedString(in));
+      else f->name = allocAndCopy(getName(in));
+    }
+	}
 }
 
-int getValueAttribute(parse_file *in)
+char *getNameAttribute(parse_file_t *in)
 {
-  /* skip name and equal */
-  getName(in);
-  getEqual(in);
+  char * token;
+  char *name = NULL;
+  char car;
   
-  return getNumber(in);
+  while(1) {
+    token = getToken(in); 
+    if(!strcmp("name",token)) {
+      getEqual(in);
+      car = seekNextChar(in);
+      if(car == EOF) in->error(in,"name was expected");
+      else if(car == '\"') name = allocAndCopy(getQuotedString(in));
+      else name = allocAndCopy(getName(in));
+    } else {
+      ungetToken(in);
+      break;
+    }
+
+  }
+  if(name == NULL) in->error(in, "Name was expected");
+  return name;
 }
 
-//for <label name=label_name value=n/>, value is an option
-char * getValueStrAttribute(parse_file *in)
+
+
+//for <label name=label_name value=n format="...">, value is an option
+//Return value : 0 : no value,   1 : has a value
+int getValueAttribute(parse_file_t *in, long long *value)
 {
-  char * token;
+  char * token, *token2;
 
-  token = getToken(in); 
-  if(g_ascii_strcasecmp("/",token) == 0){
+  token = getToken(in);
+	
+  if(strcmp("/",token) == 0 || strcmp(">", token) == 0){
     ungetToken(in);
-    return NULL;
+    return 0;
   }
-  
-  if(g_ascii_strcasecmp("value",token))in->error(in,"value was expected");
+  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;  
+
+  if(in->type == QUOTEDSTRING) {
+    in->type = NUMBER;
+    token2 = token;
+    do {
+       if (!isdigit(*token2)) {
+          in->type = QUOTEDSTRING;
+          break;
+			 }
+    } while (*(++token2) != '\0');
+  }
+
+  if(in->type == NUMBER)
+		*value = strtoll(token, NULL, 0);
+	else
+		goto error;
+  return 1;
+error:
+  in->error(in,"incorrect size specification");
+  return 0;
 }
 
-char * getDescription(parse_file *in)
+char * getDescription(parse_file_t *in)
 {
-  gint64 pos;
-  gchar * token, *str;
-  gunichar car;
-  GError * error = NULL;
+  long int pos;
+  char * token, car, *str;
 
-  pos = in->pos;
+  pos = ftell(in->fp);
 
   getLAnglebracket(in);
   token = getName(in);
-  if(g_ascii_strcasecmp("description",token)){
-    g_io_channel_seek_position(in->channel, pos-(in->pos), G_SEEK_CUR, &error);
-    if(error != NULL) {
-      g_warning("Can not seek file: \n%s\n", error->message);
-      g_error_free(error);
-    } else in->pos = pos;
-
+  if(strcmp("description",token)){
+    fseek(in->fp, pos, SEEK_SET);
     return NULL;
   }
   
   getRAnglebracket(in);
 
   pos = 0;
-  while((g_io_channel_read_unichar(in->channel, &car, &error))
-            != G_IO_STATUS_EOF) {
-    if(error != NULL) {
-      g_warning("Can not seek file: \n%s\n", error->message);
-      g_error_free(error);
-    } else in->pos++;
-
+  while((car = getc(in->fp)) != EOF) {
     if(car == '<') break;
     if(car == '\0') continue;
     in->buffer[pos] = car;
@@ -219,11 +482,11 @@ char * getDescription(parse_file *in)
   if(car == EOF)in->error(in,"not a valid description");
   in->buffer[pos] = '\0';
 
-  str = g_strdup(in->buffer);
+  str = allocAndCopy(in->buffer);
 
   getForwardslash(in);
   token = getName(in);
-  if(g_ascii_strcasecmp("description", token))in->error(in,"not a valid description");
+  if(strcmp("description", token))in->error(in,"not a valid description");
   getRAnglebracket(in);
 
   return str;
@@ -239,12 +502,16 @@ char * getDescription(parse_file *in)
  *    fac           : facility filled with event list
  ****************************************************************************/
 
-void parseFacility(parse_file *in, facility_t * fac)
+void parseFacility(parse_file_t *in, facility_t * fac)
 {
   char * token;
   event_t *ev;
   
-  fac->name = g_strdup(getNameAttribute(in));    
+  getFacilityAttributes(in, fac);
+  if(fac->name == NULL) in->error(in, "Attribute not named");
+	
+  fac->capname = allocAndCopy(fac->name);
+	strupper(fac->capname);
   getRAnglebracket(in);    
   
   fac->description = getDescription(in);
@@ -256,11 +523,11 @@ void parseFacility(parse_file *in, facility_t * fac)
     if(in->type == ENDFILE)
       in->error(in,"the definition of the facility is not finished");
 
-    if(g_ascii_strcasecmp("event",token) == 0){
-      ev = (event_t*) g_new(event_t,1);
+    if(strcmp("event",token) == 0){
+      ev = (event_t*) memAlloc(sizeof(event_t));
       sequence_push(&(fac->events),ev);
       parseEvent(in,ev, &(fac->unnamed_types), &(fac->named_types));    
-    }else if(g_ascii_strcasecmp("type",token) == 0){
+    }else if(strcmp("type",token) == 0){
       parseTypeDefinition(in, &(fac->unnamed_types), &(fac->named_types));
     }else if(in->type == FORWARDSLASH){
       break;
@@ -268,7 +535,7 @@ void parseFacility(parse_file *in, facility_t * fac)
   }
 
   token = getName(in);
-  if(g_ascii_strcasecmp("facility",token)) in->error(in,"not the end of the facility");
+  if(strcmp("facility",token)) in->error(in,"not the end of the facility");
   getRAnglebracket(in); //</facility>
 }
 
@@ -284,39 +551,66 @@ void parseFacility(parse_file *in, facility_t * fac)
  *    ev            : new event (parameters are passed to it)   
  ****************************************************************************/
 
-void parseEvent(parse_file *in, event_t * ev, sequence * unnamed_types, 
-		table * named_types) 
+void parseEvent(parse_file_t *in, event_t * ev, sequence_t * unnamed_types, 
+		table_t * named_types) 
 {
   char *token;
+	field_t *f;
 
+	sequence_init(&(ev->fields));
   //<event name=eventtype_name>
-  ev->name = g_strdup(getNameAttribute(in));
+  getEventAttributes(in, ev);
+  if(ev->name == NULL) in->error(in, "Event not named");
   getRAnglebracket(in);  
 
-  //<description>...</descriptio>
+  //<description>...</description>
   ev->description = getDescription(in); 
   
-  //event can have STRUCT, TYPEREF or NOTHING
-  getLAnglebracket(in);
-
-  token = getToken(in);
-  if(in->type == FORWARDSLASH){ //</event> NOTHING
-    ev->type = NULL;
-  }else if(in->type == NAME){
-    if(g_ascii_strcasecmp("struct",token)==0 || g_ascii_strcasecmp("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");
-
-  token = getName(in);
-  if(g_ascii_strcasecmp("event",token))in->error(in,"not an event definition");
-  getRAnglebracket(in);  //</event>
+	int got_end = 0;
+	/* Events can have multiple fields. each field form at least a function
+	 * parameter of the logging function. */
+	while(!got_end) {
+		getLAnglebracket(in);
+		token = getToken(in);
+		
+		switch(in->type) {
+		case FORWARDSLASH:	/* </event> */
+			token = getName(in);
+			if(strcmp("event",token))in->error(in,"not an event definition");
+			getRAnglebracket(in);  //</event>
+			got_end = 1;
+			break;
+		case NAME: /* a field */
+			if(strcmp("field",token))in->error(in,"expecting a field");
+			f = (field_t *)memAlloc(sizeof(field_t));
+			sequence_push(&(ev->fields),f);
+			parseFields(in, f, unnamed_types, named_types, 1);
+			break;
+		default:
+			in->error(in, "expecting </event> or <field >");
+			break;
+		}
+	}
+#if 0
+		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");
+		getLAnglebracket(in);
+		getForwardslash(in);    
+		token = getName(in);
+		if(strcmp("event",token))in->error(in,"not an event definition");
+		getRAnglebracket(in);  //</event>
+#endif //0
 }
 
 /*****************************************************************************
@@ -324,35 +618,40 @@ void parseEvent(parse_file *in, event_t * ev, sequence * unnamed_types,
  *    parseField    : get field infomation from buffer 
  *Input params 
  *    in            : input file handle
- *    t             : type descriptor
+ *    f             : field
  *    unnamed_types : array of unamed types
  *    named_types   : array of named types
+ *    tag						: is field surrounded by a <field> </field> tag ?
  ****************************************************************************/
 
-void parseFields(parse_file *in, type_descriptor *t, sequence * unnamed_types,
-		 table * named_types) 
+void parseFields(parse_file_t *in, field_t *f,
+    sequence_t * unnamed_types,
+		table_t * named_types,
+		int tag) 
 {
   char * token;
-  type_fields *f;
-
-  f = g_new(type_fields,1);
-  sequence_push(&(t->fields),f);
+	if(tag) {
+		//<field name=field_name> <description> <type> </field>
+		getFieldAttributes(in, f);
+		if(f->name == NULL) in->error(in, "Field not named");
+		getRAnglebracket(in);
 
-  //<field name=field_name> <description> <type> </field>
-  f->name = g_strdup(getNameAttribute(in)); 
-  getRAnglebracket(in);
-
-  f->description = getDescription(in);
+		f->description = getDescription(in);
+	} else {
+		f->description = NULL;
+	}
 
   //<int size=...>
   getLAnglebracket(in);
   f->type = parseType(in,NULL, unnamed_types, named_types);
 
-  getLAnglebracket(in);
-  getForwardslash(in);
-  token = getName(in);
-  if(g_ascii_strcasecmp("field",token))in->error(in,"not a valid field definition");
-  getRAnglebracket(in); //</field>
+	if(tag) {
+		getLAnglebracket(in);
+		getForwardslash(in);
+		token = getName(in);
+		if(strcmp("field",token))in->error(in,"not a valid field definition");
+		getRAnglebracket(in); //</field>
+	}
 }
 
 
@@ -376,14 +675,15 @@ void parseFields(parse_file *in, type_descriptor *t, sequence * unnamed_types,
  *    type_descriptor* : a type descriptor             
  ****************************************************************************/
 
-type_descriptor *parseType(parse_file *in, type_descriptor *inType, 
-			   sequence * unnamed_types, table * named_types) 
+type_descriptor_t *parseType(parse_file_t *in, type_descriptor_t *inType, 
+			   sequence_t * unnamed_types, table_t * named_types) 
 {
   char *token;
-  type_descriptor *t;
+  type_descriptor_t *t;
+	field_t *f;
 
   if(inType == NULL) {
-    t = g_new(type_descriptor,1);
+    t = (type_descriptor_t *) memAlloc(sizeof(type_descriptor_t));
     t->type_name = NULL;
     t->type = NONE;
     t->fmt = NULL;
@@ -393,147 +693,287 @@ type_descriptor *parseType(parse_file *in, type_descriptor *inType,
 
   token = getName(in);
 
-  if(g_ascii_strcasecmp(token,"struct") == 0) {
+  if(strcmp(token,"struct") == 0) {
     t->type = STRUCT;
+    getTypeAttributes(in, t, unnamed_types, named_types);
     getRAnglebracket(in); //<struct>
     getLAnglebracket(in); //<field name=..>
     token = getToken(in);
     sequence_init(&(t->fields));
-    while(g_ascii_strcasecmp("field",token) == 0){
-      parseFields(in,t, unnamed_types, named_types);
+    while(strcmp("field",token) == 0){
+			f = (field_t *)memAlloc(sizeof(field_t));
+			sequence_push(&(t->fields),f);
+
+      parseFields(in, f, unnamed_types, named_types, 1);
       
       //next field
       getLAnglebracket(in);
       token = getToken(in);	
     }
-    if(g_ascii_strcasecmp("/",token))in->error(in,"not a valid structure definition");
+    if(strcmp("/",token))in->error(in,"not a valid structure definition");
     token = getName(in);
-    if(g_ascii_strcasecmp("struct",token)!=0)
+    if(strcmp("struct",token)!=0)
       in->error(in,"not a valid structure definition");
     getRAnglebracket(in); //</struct>
   }
-  else if(g_ascii_strcasecmp(token,"union") == 0) {
+  else if(strcmp(token,"union") == 0) {
     t->type = UNION;
-    t->size = getSizeAttribute(in);
-    getRAnglebracket(in); //<union typecodesize=isize>
+    getTypeAttributes(in, t, unnamed_types, named_types);
+    getRAnglebracket(in); //<union>
 
     getLAnglebracket(in); //<field name=..>
     token = getToken(in);
     sequence_init(&(t->fields));
-    while(g_ascii_strcasecmp("field",token) == 0){
-      parseFields(in,t, unnamed_types, named_types);
+    while(strcmp("field",token) == 0){
+			f = (field_t *)memAlloc(sizeof(field_t));
+			sequence_push(&(t->fields),f);
+      parseFields(in, f, unnamed_types, named_types, 1);
       
       //next field
       getLAnglebracket(in);
       token = getToken(in);	
     }
-    if(g_ascii_strcasecmp("/",token))in->error(in,"not a valid union definition");
+    if(strcmp("/",token))in->error(in,"not a valid union definition");
     token = getName(in);
-    if(g_ascii_strcasecmp("union",token)!=0)
+    if(strcmp("union",token)!=0)
       in->error(in,"not a valid union definition");        
     getRAnglebracket(in); //</union>
   }
-  else if(g_ascii_strcasecmp(token,"array") == 0) {
+  else if(strcmp(token,"array") == 0) {
     t->type = ARRAY;
-    t->size = getValueAttribute(in);
+    sequence_init(&(t->fields));
+    getTypeAttributes(in, t, unnamed_types, named_types);
+    if(t->size == 0) in->error(in, "Array has empty size");
+    getForwardslash(in);
     getRAnglebracket(in); //<array size=n>
 
-    getLAnglebracket(in); //<type struct> 
-    t->nested_type = parseType(in,NULL, unnamed_types, named_types);
+    //getLAnglebracket(in); //<subtype> 
+		/* subfield */
+		f = (field_t *)memAlloc(sizeof(field_t));
+		sequence_push(&(t->fields),f);
+    parseFields(in, f, unnamed_types, named_types, 0);
+
+    //getLAnglebracket(in); //<type struct> 
+    //t->nested_type = parseType(in, NULL, unnamed_types, named_types);
 
     getLAnglebracket(in); //</array>
     getForwardslash(in);
     token = getName(in);
-    if(g_ascii_strcasecmp("array",token))in->error(in,"not a valid array definition");
+    if(strcmp("array",token))in->error(in,"not a valid array definition");
     getRAnglebracket(in);  //</array>
   }
-  else if(g_ascii_strcasecmp(token,"sequence") == 0) {
+  else if(strcmp(token,"sequence") == 0) {
     t->type = SEQUENCE;
-    t->size = getSizeAttribute(in);
-    getRAnglebracket(in); //<array lengthsize=isize>
-
-    getLAnglebracket(in); //<type struct> 
-    t->nested_type = parseType(in,NULL, unnamed_types, named_types);
+    sequence_init(&(t->fields));
+    getTypeAttributes(in, t, unnamed_types, named_types);
+    getForwardslash(in);
+    getRAnglebracket(in); //<sequence>
+
+    //getLAnglebracket(in); //<sequence size type> 
+		/* subfield */
+		f = (field_t *)memAlloc(sizeof(field_t));
+		sequence_push(&(t->fields),f);
+    parseFields(in, f, unnamed_types, named_types, 0);
+
+    //getLAnglebracket(in); //<subtype> 
+		/* subfield */
+		f = (field_t *)memAlloc(sizeof(field_t));
+		sequence_push(&(t->fields),f);
+    parseFields(in, f, unnamed_types, named_types, 0);
+
+    //getLAnglebracket(in); //<type sequence> 
+    //t->length_type = parseType(in, NULL, unnamed_types, named_types);
+
+    //getLAnglebracket(in); //<type sequence> 
+
+    //t->nested_type = parseType(in, NULL, unnamed_types, named_types);
+
+    if(t->fields.position < 1) in->error(in, "Sequence has no length type");
+    if(t->fields.position < 2) in->error(in, "Sequence has no subtype");
+		switch(((field_t*)t->fields.array[0])->type->type) {
+			case UINT_FIXED :
+			case UCHAR :
+			case USHORT :
+			case UINT :
+			case ULONG :
+			case SIZE_T :
+			case OFF_T :
+				break;
+			default:
+				in->error(in, "Wrong length type for sequence");
+		}
 
     getLAnglebracket(in); //</sequence>
     getForwardslash(in);
     token = getName(in);
-    if(g_ascii_strcasecmp("sequence",token))in->error(in,"not a valid sequence definition");
+    if(strcmp("sequence",token))in->error(in,"not a valid sequence definition");
     getRAnglebracket(in); //</sequence>
   }
-  else if(g_ascii_strcasecmp(token,"enum") == 0) {
-    char * str, *str1;
+  else if(strcmp(token,"enum") == 0) {
+    char * str;
+    long long value = -1;
+
     t->type = ENUM;
     sequence_init(&(t->labels));
-    t->size = getSizeAttribute(in);
-    t->fmt = g_strdup(getFormatAttribute(in));
+    sequence_init(&(t->labels_values));
+    sequence_init(&(t->labels_description));
+		t->already_printed = 0;
+    getTypeAttributes(in, t, unnamed_types, named_types);
+    //if(t->size == 0) in->error(in, "Sequence has empty size");
+		//Mathieu : we fix enum size to target int size. GCC is always like this.
+		//fox copy optimisation.
+    if(t->size != 0) in->error(in, "Enum has fixed size of target int.");
+		t->size = 0;
     getRAnglebracket(in);
 
     //<label name=label1 value=n/>
     getLAnglebracket(in);
     token = getToken(in); //"label" or "/"
-    while(g_ascii_strcasecmp("label",token) == 0){
-      str1   = g_strdup(getNameAttribute(in));      
-      token = getValueStrAttribute(in);
-      if(token){
-	      str = g_strconcat(str1,"=",token,NULL);
-      	g_free(str1);
-      	sequence_push(&(t->labels),str);
-      }else
-      	sequence_push(&(t->labels),str1);
+    while(strcmp("label",token) == 0){
+      int *label_value = malloc(sizeof(int));
+			int has_value = 0;
+			long long loc_value;
+      
+      str   = allocAndCopy(getNameAttribute(in));
+      has_value = getValueAttribute(in, &loc_value);
+      
+     	sequence_push(&(t->labels),str);
+
+      if(has_value) value = loc_value;
+      else value++;
+
+      *label_value = value;
+      sequence_push(&(t->labels_values), label_value);
 
       getForwardslash(in);
       getRAnglebracket(in);
       
+      //read description if any. May be NULL.
+      str = allocAndCopy(getDescription(in));
+			sequence_push(&(t->labels_description),str);
+			      
       //next label definition
       getLAnglebracket(in);
       token = getToken(in); //"label" or "/"      
     }
-    if(g_ascii_strcasecmp("/",token))in->error(in, "not a valid enum definition");
+    if(strcmp("/",token))in->error(in, "not a valid enum definition");
     token = getName(in);
-    if(g_ascii_strcasecmp("enum",token))in->error(in, "not a valid enum definition");
-    getRAnglebracket(in); //</label>
+    if(strcmp("enum",token))in->error(in, "not a valid enum definition");
+      getRAnglebracket(in); //</label>
+  }
+  else if(strcmp(token,"int_fixed") == 0) {
+    t->type = INT_FIXED;
+    getTypeAttributes(in, t, unnamed_types, named_types);
+    if(t->size == 0) in->error(in, "int has empty size");
+    getForwardslash(in);
+    getRAnglebracket(in); 
   }
-  else if(g_ascii_strcasecmp(token,"int") == 0) {
+  else if(strcmp(token,"uint_fixed") == 0) {
+    t->type = UINT_FIXED;
+    getTypeAttributes(in, t, unnamed_types, named_types);
+    if(t->size == 0) in->error(in, "uint has empty size");
+    getForwardslash(in);
+    getRAnglebracket(in); 
+  }
+  else if(strcmp(token,"char") == 0) {
+    t->type = CHAR;
+    getTypeAttributes(in, t, unnamed_types, named_types);
+		t->size = 1;
+    getForwardslash(in);
+    getRAnglebracket(in); 
+  }
+  else if(strcmp(token,"uchar") == 0) {
+    t->type = UCHAR;
+    getTypeAttributes(in, t, unnamed_types, named_types);
+		t->size = 1;
+    getForwardslash(in);
+    getRAnglebracket(in); 
+  }
+  else if(strcmp(token,"short") == 0) {
+    t->type = SHORT;
+    getTypeAttributes(in, t, unnamed_types, named_types);
+		t->size = 2;
+    getForwardslash(in);
+    getRAnglebracket(in); 
+  }
+  else if(strcmp(token,"ushort") == 0) {
+    t->type = USHORT;
+    getTypeAttributes(in, t, unnamed_types, named_types);
+		t->size = 2;
+    getForwardslash(in);
+    getRAnglebracket(in); 
+  }
+  else if(strcmp(token,"int") == 0) {
     t->type = INT;
-    t->size = getSizeAttribute(in);
-    t->fmt  = g_strdup(getFormatAttribute(in));
+    getTypeAttributes(in, t, unnamed_types, named_types);
     getForwardslash(in);
     getRAnglebracket(in); 
   }
-  else if(g_ascii_strcasecmp(token,"uint") == 0) {
+  else if(strcmp(token,"uint") == 0) {
     t->type = UINT;
-    t->size = getSizeAttribute(in);
-    t->fmt  = g_strdup(getFormatAttribute(in));
+    getTypeAttributes(in, t, unnamed_types, named_types);
+    getForwardslash(in);
+    getRAnglebracket(in); 
+  }
+
+  else if(strcmp(token,"pointer") == 0) {
+    t->type = POINTER;
+    getTypeAttributes(in, t, unnamed_types, named_types);
+    getForwardslash(in);
+    getRAnglebracket(in); 
+  }
+  else if(strcmp(token,"long") == 0) {
+    t->type = LONG;
+    getTypeAttributes(in, t, unnamed_types, named_types);
+    getForwardslash(in);
+    getRAnglebracket(in); 
+  }
+  else if(strcmp(token,"ulong") == 0) {
+    t->type = ULONG;
+    getTypeAttributes(in, t, unnamed_types, named_types);
+    getForwardslash(in);
+    getRAnglebracket(in); 
+  }
+  else if(strcmp(token,"size_t") == 0) {
+    t->type = SIZE_T;
+    getTypeAttributes(in, t, unnamed_types, named_types);
+    getForwardslash(in);
+    getRAnglebracket(in); 
+  }
+  else if(strcmp(token,"ssize_t") == 0) {
+    t->type = SSIZE_T;
+    getTypeAttributes(in, t, unnamed_types, named_types);
+    getForwardslash(in);
+    getRAnglebracket(in); 
+  }
+  else if(strcmp(token,"off_t") == 0) {
+    t->type = OFF_T;
+    getTypeAttributes(in, t, unnamed_types, named_types);
     getForwardslash(in);
     getRAnglebracket(in); 
   }
-  else if(g_ascii_strcasecmp(token,"float") == 0) {
+  else if(strcmp(token,"float") == 0) {
     t->type = FLOAT;
-    t->size = getSizeAttribute(in);
-    t->fmt  = g_strdup(getFormatAttribute(in));
+    getTypeAttributes(in, t, unnamed_types, named_types);
     getForwardslash(in);
     getRAnglebracket(in); 
   }
-  else if(g_ascii_strcasecmp(token,"string") == 0) {
+  else if(strcmp(token,"string") == 0) {
     t->type = STRING;
-    t->fmt  = g_strdup(getFormatAttribute(in));
+    getTypeAttributes(in, t, unnamed_types, named_types);
     getForwardslash(in);
     getRAnglebracket(in); 
   }
-  else if(g_ascii_strcasecmp(token,"typeref") == 0){
+  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 {
-      g_free(t);
-      sequence_pop(unnamed_types);
-      token = getNameAttribute(in);
-      t = find_named_type(token, named_types);
-      getForwardslash(in);  //<typeref name=type_name/>
-      getRAnglebracket(in);
-      return t;
-    }
+		free(t);
+		sequence_pop(unnamed_types);
+		token = getNameAttribute(in);
+		t = find_named_type(token, named_types);
+		if(t == NULL) in->error(in,"Named referred to must be pre-declared.");
+		getForwardslash(in);  //<typeref name=type_name/>
+		getRAnglebracket(in);
+		return t;
   }else in->error(in,"not a valid type");
 
   return t;
@@ -549,21 +989,27 @@ type_descriptor *parseType(parse_file *in, type_descriptor *inType,
  *    type_descriptor *   : a type descriptor                       
  *****************************************************************************/
 
-type_descriptor * find_named_type(gchar *name, table * named_types)
+type_descriptor_t * find_named_type(char *name, table_t * named_types)
 { 
-  type_descriptor *t;
+  type_descriptor_t *t;
 
   t = table_find(named_types,name);
-  if(t == NULL) {
-    t = g_new(type_descriptor,1);
-    t->type_name = g_strdup(name);
-    t->type = NONE;
-    t->fmt = NULL;
-    table_insert(named_types,t->type_name,t);
-    //    table_insert(named_types,g_strdup(name),t);
-  }
+
   return t;
-}  
+}
+
+type_descriptor_t * create_named_type(char *name, table_t * named_types)
+{
+  type_descriptor_t *t;
+
+	t = (type_descriptor_t *)memAlloc(sizeof(type_descriptor_t));
+	t->type_name = allocAndCopy(name);
+	t->type = NONE;
+	t->fmt = NULL;
+	table_insert(named_types,t->type_name,t);
+	//    table_insert(named_types,allocAndCopy(name),t);
+	return t;
+}
 
 /*****************************************************************************
  *Function name
@@ -574,20 +1020,21 @@ type_descriptor * find_named_type(gchar *name, table * named_types)
  *    named_types         : array of named types
  *****************************************************************************/
 
-void parseTypeDefinition(parse_file * in, sequence * unnamed_types,
-			 table * named_types)
+void parseTypeDefinition(parse_file_t * in, sequence_t * unnamed_types,
+			 table_t * named_types)
 {
   char *token;
-  type_descriptor *t;
+  type_descriptor_t *t;
 
   token = getNameAttribute(in);
-  t = find_named_type(token, named_types);
+  if(token == NULL) in->error(in, "Type has empty name");
+  t = create_named_type(token, named_types);
 
   if(t->type != NONE) in->error(in,"redefinition of named type");
   getRAnglebracket(in); //<type name=type_name>
-  getLAnglebracket(in); //<struct>
+  getLAnglebracket(in); //<
   token = getName(in);
-  if(g_ascii_strcasecmp("struct",token))in->error(in,"not a valid type definition");
+  //MD ??if(strcmp("struct",token))in->error(in,"not a valid type definition");
   ungetToken(in);
   parseType(in,t, unnamed_types, named_types);
   
@@ -595,7 +1042,7 @@ void parseTypeDefinition(parse_file * in, sequence * unnamed_types,
   getLAnglebracket(in);
   getForwardslash(in);
   token = getName(in);
-  if(g_ascii_strcasecmp("type",token))in->error(in,"not a valid type definition");  
+  if(strcmp("type",token))in->error(in,"not a valid type definition");  
   getRAnglebracket(in); //</type>
 }
 
@@ -613,16 +1060,17 @@ void parseTypeDefinition(parse_file * in, sequence * unnamed_types,
  *
  **************************************************************************/
 
-char *getName(parse_file * in) 
+char *getName(parse_file_t * in) 
 {
   char *token;
 
   token = getToken(in);
-  if(in->type != NAME) in->error(in,"Name token was expected");
+  // Optional descriptions
+	// if(in->type != NAME) in->error(in,"Name token was expected");
   return token;
 }
 
-int getNumber(parse_file * in) 
+int getNumber(parse_file_t * in) 
 {
   char *token;
 
@@ -631,16 +1079,19 @@ int getNumber(parse_file * in)
   return atoi(token);
 }
 
-char *getForwardslash(parse_file * in) 
+char *getForwardslash(parse_file_t * in) 
 {
   char *token;
 
   token = getToken(in);
-  if(in->type != FORWARDSLASH) in->error(in, "forward slash token was expected");
+  //if(in->type != FORWARDSLASH) in->error(in, "forward slash token was expected");
+	/* Mathieu : final / is optional now. */
+  if(in->type != FORWARDSLASH) ungetToken(in);
+
   return token;
 }
 
-char *getLAnglebracket(parse_file * in) 
+char *getLAnglebracket(parse_file_t * in) 
 {
   char *token;
 
@@ -649,7 +1100,7 @@ char *getLAnglebracket(parse_file * in)
   return token;
 }
 
-char *getRAnglebracket(parse_file * in) 
+char *getRAnglebracket(parse_file_t * in) 
 {
   char *token;
 
@@ -658,7 +1109,7 @@ char *getRAnglebracket(parse_file * in)
   return token;
 }
 
-char *getQuotedString(parse_file * in) 
+char *getQuotedString(parse_file_t * in) 
 {
   char *token;
 
@@ -667,7 +1118,7 @@ char *getQuotedString(parse_file * in)
   return token;
 }
 
-char * getEqual(parse_file *in)
+char * getEqual(parse_file_t *in)
 {
   char *token;
 
@@ -676,38 +1127,18 @@ char * getEqual(parse_file *in)
   return token;
 }
 
-gunichar seekNextChar(parse_file *in, gunichar *car)
+char seekNextChar(parse_file_t *in)
 {
-  GError * error = NULL;
-  GIOStatus status;
-
-  do {
-
-    status = g_io_channel_read_unichar(in->channel, car, &error);
-    
-    if(error != NULL) {
-      g_warning("Can not read file: \n%s\n", error->message);
-      g_error_free(error);
-      break;
+  char car;
+  while((car = getc(in->fp)) != EOF) {
+    if(!isspace(car)){
+      ungetc(car,in->fp);
+      return car;
     }
-    in->pos++;
-   
-    if(!g_unichar_isspace(*car)) {
-      g_io_channel_seek_position(in->channel, -1, G_SEEK_CUR, &error);
-      if(error != NULL) {
-        g_warning("Can not seek file: \n%s\n", error->message);
-        g_error_free(error);
-      }
-      in->pos--;
-      break;
-    }
-
-  } while(status != G_IO_STATUS_EOF && status != G_IO_STATUS_ERROR);
-
-  return status;
+  }  
+  return EOF;
 }
 
-
 /******************************************************************
  * Function :
  *    getToken, ungetToken
@@ -723,16 +1154,16 @@ gunichar seekNextChar(parse_file *in, gunichar *car)
  *
  ******************************************************************/
 
-void ungetToken(parse_file * in)
+void ungetToken(parse_file_t * in)
 {
   in->unget = 1;
 }
 
-gchar *getToken(parse_file * in)
+char *getToken(parse_file_t * in)
 {
-  gunichar car, car1;
+  FILE *fp = in->fp;
+  char car, car1;
   int pos = 0, escaped;
-  GError * error = NULL;
 
   if(in->unget == 1) {
     in->unget = 0;
@@ -741,35 +1172,20 @@ gchar *getToken(parse_file * in)
 
   /* skip whitespace and comments */
 
-  while((g_io_channel_read_unichar(in->channel, &car, &error))
-      != G_IO_STATUS_EOF) {
-
-    if(error != NULL) {
-      g_warning("Can not read file: \n%s\n", error->message);
-      g_error_free(error);
-    } else in->pos++;
-
+  while((car = getc(fp)) != EOF) {
     if(car == '/') {
-      g_io_channel_read_unichar(in->channel, &car1, &error);
-      if(error != NULL) {
-        g_warning("Can not read file: \n%s\n", error->message);
-        g_error_free(error);
-      } else in->pos++;
-
+      car1 = getc(fp); 
       if(car1 == '*') skipComment(in);
       else if(car1 == '/') skipEOL(in);
-      else {
-        g_io_channel_seek_position(in->channel, -1, G_SEEK_CUR, &error);
-        if(error != NULL) {
-          g_warning("Can not seek file: \n%s\n", error->message);
-          g_error_free(error);
-        } else in->pos--;
+      else { 
+        car1 = ungetc(car1,fp);
         break;
       }
     }
     else if(car == '\n') in->lineno++;
-    else if(!g_unichar_isspace(car)) break;
+    else if(!isspace(car)) break;
   }
+
   switch(car) {
     case EOF:
       in->type = ENDFILE;
@@ -796,17 +1212,10 @@ gchar *getToken(parse_file * in)
       break;
     case '"':
       escaped = 0;
-      while(g_io_channel_read_unichar(in->channel, &car, &error)
-                  != G_IO_STATUS_EOF && pos < BUFFER_SIZE) {
-
-        if(error != NULL) {
-          g_warning("Can not read file: \n%s\n", error->message);
-          g_error_free(error);
-        } else in->pos++;
-
+      while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
         if(car == '\\' && escaped == 0) {
-	        in->buffer[pos] = car;
-      	  pos++;
+	  			in->buffer[pos] = car;
+				  pos++;
           escaped = 1;
           continue;
         }
@@ -824,159 +1233,91 @@ gchar *getToken(parse_file * in)
       in->type = QUOTEDSTRING;
       break;
     default:
-      if(g_unichar_isdigit(car)) {
+      if(isdigit(car)) {
         in->buffer[pos] = car;
         pos++;
-        while(g_io_channel_read_unichar(in->channel, &car, &error)
-                    != G_IO_STATUS_EOF && pos < BUFFER_SIZE) {
-
-          if(error != NULL) {
-            g_warning("Can not read file: \n%s\n", error->message);
-            g_error_free(error);
-          } else in->pos++;
-
+        while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
           if(!isdigit(car)) {
-            g_io_channel_seek_position(in->channel, -1, G_SEEK_CUR, &error);
-            if(error != NULL) {
-              g_warning("Can not seek file: \n%s\n", error->message);
-              g_error_free(error);
-            } else in->pos--;
+            ungetc(car,fp);
             break;
           }
           in->buffer[pos] = car;
           pos++;
         }
-	      if(car == EOF) {
-          g_io_channel_seek_position(in->channel, -1, G_SEEK_CUR, &error);
-          if(error != NULL) {
-            g_warning("Can not seek file: \n%s\n", error->message);
-            g_error_free(error);
-          } else in->pos--;
-        }
+				if(car == EOF) ungetc(car,fp);
         if(pos == BUFFER_SIZE) in->error(in, "number token too large");
         in->type = NUMBER;
-      }    
-      else if(g_unichar_isalpha(car)) {
+      }
+      else if(isalnum(car) || car == '_' || car == '-') {
         in->buffer[0] = car;
         pos = 1;
-        while(g_io_channel_read_unichar(in->channel, &car, &error)
-                              != G_IO_STATUS_EOF && pos < BUFFER_SIZE) {
-
-          if(error != NULL) {
-            g_warning("Can not read file: \n%s\n", error->message);
-            g_error_free(error);
-          } else in->pos++;
-
-          if(!(g_unichar_isalnum(car) || car == '_')) {
-            g_io_channel_seek_position(in->channel, -1, G_SEEK_CUR, &error);
-            if(error != NULL) {
-              g_warning("Can not seek file: \n%s\n", error->message);
-              g_error_free(error);
-            } else in->pos--;
+        while((car = getc(fp)) != EOF && pos < BUFFER_SIZE) {
+          if(!(isalnum(car) || car == '_' || car == '-')) {
+            ungetc(car,fp);
             break;
           }
           in->buffer[pos] = car;
           pos++;
         }
-	      if(car == EOF) {
-          g_io_channel_seek_position(in->channel, -1, G_SEEK_CUR, &error);
-          if(error != NULL) {
-            g_warning("Can not seek file: \n%s\n", error->message);
-            g_error_free(error);
-          } else in->pos--;
-        }
+			if(car == EOF) ungetc(car,fp);
         if(pos == BUFFER_SIZE) in->error(in, "name token too large");
         in->type = NAME;
-      }
+      } else if(car == '?') {
+				in->buffer[0] = car;
+				pos++;
+			}
       else in->error(in, "invalid character, unrecognized token");
   }
   in->buffer[pos] = 0;
   return in->buffer;
 }
 
-void skipComment(parse_file * in)
+void skipComment(parse_file_t * in)
 {
-  gunichar car;
-  GError * error = NULL;
-
-  while(g_io_channel_read_unichar(in->channel, &car, &error)
-                                    != G_IO_STATUS_EOF) {
-
-    if(error != NULL) {
-      g_warning("Can not read file: \n%s\n", error->message);
-      g_error_free(error);
-    } else in->pos++;
-
+  char car;
+  while((car = getc(in->fp)) != EOF) {
     if(car == '\n') in->lineno++;
     else if(car == '*') {
-
-      g_io_channel_read_unichar(in->channel, &car, &error);
-      if(error != NULL) {
-        g_warning("Can not read file: \n%s\n", error->message);
-        g_error_free(error);
-      } else in->pos++;
-
+      car = getc(in->fp);
       if(car ==EOF) break;
       if(car == '/') return;
-
-      g_io_channel_seek_position(in->channel, -1, G_SEEK_CUR, &error);
-      if(error != NULL) {
-        g_warning("Can not seek file: \n%s\n", error->message);
-        g_error_free(error);
-      } else in->pos--;
-
+      ungetc(car,in->fp);
     }
   }
   if(car == EOF) in->error(in,"comment begining with '/*' has no ending '*/'");
 }
 
-void skipEOL(parse_file * in)
+void skipEOL(parse_file_t * in)
 {
-  gunichar car;
-  GError * error = NULL;
-
-  while(g_io_channel_read_unichar(in->channel, &car, &error)
-                                          != G_IO_STATUS_EOF) {
+  char car;
+  while((car = getc(in->fp)) != EOF) {
     if(car == '\n') {
-      g_io_channel_seek_position(in->channel, -1, G_SEEK_CUR, &error);
-      if(error != NULL) {
-        g_warning("Can not seek file: \n%s\n", error->message);
-        g_error_free(error);
-      } else in->pos--;
+      ungetc(car,in->fp);
       break;
     }
   }
-  if(car == EOF) {
-    g_io_channel_seek_position(in->channel, -1, G_SEEK_CUR, &error);
-    if(error != NULL) {
-      g_warning("Can not seek file: \n%s\n", error->message);
-      g_error_free(error);
-    } else in->pos--;
-  }
+  if(car == EOF)ungetc(car, in->fp);
 }
 
 /*****************************************************************************
  *Function name
  *    checkNamedTypesImplemented : check if all named types have definition
- *    returns -1 on error, 0 if ok
  ****************************************************************************/
 
-int checkNamedTypesImplemented(table * named_types)
+void checkNamedTypesImplemented(table_t * named_types)
 {
-  type_descriptor *t;
+  type_descriptor_t *t;
   int pos;
   char str[256];
 
   for(pos = 0 ; pos < named_types->values.position; pos++) {
-    t = (type_descriptor *) named_types->values.array[pos];
+    t = (type_descriptor_t *) named_types->values.array[pos];
     if(t->type == NONE){
       sprintf(str,"named type '%s' has no definition",
-              (char*)named_types->keys.array[pos]);
-      error_callback(NULL,str);
-      return -1;
+          (char*)named_types->keys.array[pos]);
+      error_callback(NULL,str);   
     }
   }
-  return 0;
 }
 
 
@@ -989,27 +1330,25 @@ int checkNamedTypesImplemented(table * named_types)
  *    checksum          : checksum for the facility
  ****************************************************************************/
 
-int generateChecksum(char* facName, guint32 * checksum, sequence * events)
+void generateChecksum(char* facName,
+    unsigned int * checksum, sequence_t * events)
 {
   unsigned long crc ;
   int pos;
   event_t * ev;
-  char str[256];
+  unsigned int i;
 
   crc = crc32(facName);
   for(pos = 0; pos < events->position; pos++){
     ev = (event_t *)(events->array[pos]);
-    crc = partial_crc32(ev->name,crc);    
-    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);
-      return -1;
-    }
-    crc = getTypeChecksum(crc, ev->type);
+    crc = partial_crc32(ev->name, crc);
+		for(i = 0; i < ev->fields.position; i++) {
+			field_t *f = (field_t*)ev->fields.array[i];
+      crc = partial_crc32(f->name, crc);
+      crc = getTypeChecksum(crc, f->type);
+		}
   }
   *checksum = crc;
-  return 0;
 }
 
 /*****************************************************************************
@@ -1022,47 +1361,95 @@ int generateChecksum(char* facName, guint32 * checksum, sequence * events)
  *    unsigned long     : checksum 
  *****************************************************************************/
 
-unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type)
+unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor_t * type)
 {
   unsigned long crc = aCrc;
   char * str = NULL, buf[16];
   int flag = 0, pos;
-  type_fields * fld;
+  field_t * fld;
 
   switch(type->type){
+    case INT_FIXED:
+      str = intOutputTypes[getSizeindex(type->size)];
+      break;
+    case UINT_FIXED:
+      str = uintOutputTypes[getSizeindex(type->size)];
+      break;
+    case POINTER:
+      str = allocAndCopy("void *");
+			flag = 1;
+      break;
+    case CHAR:
+      str = allocAndCopy("signed char");
+			flag = 1;
+      break;
+    case UCHAR:
+      str = allocAndCopy("unsigned char");
+			flag = 1;
+      break;
+    case SHORT:
+      str = allocAndCopy("short");
+			flag = 1;
+      break;
+    case USHORT:
+      str = allocAndCopy("unsigned short");
+			flag = 1;
+      break;
     case INT:
-      str = intOutputTypes[type->size];
+      str = allocAndCopy("int");
+			flag = 1;
       break;
     case UINT:
-      str = uintOutputTypes[type->size];
+      str = allocAndCopy("uint");
+			flag = 1;
+      break;
+    case LONG:
+      str = allocAndCopy("long");
+			flag = 1;
+      break;
+    case ULONG:
+      str = allocAndCopy("unsigned long");
+			flag = 1;
+      break;
+    case SIZE_T:
+      str = allocAndCopy("size_t");
+			flag = 1;
+      break;
+    case SSIZE_T:
+      str = allocAndCopy("ssize_t");
+			flag = 1;
+      break;
+    case OFF_T:
+      str = allocAndCopy("off_t");
+			flag = 1;
       break;
     case FLOAT:
-      str = floatOutputTypes[type->size];
+      str = floatOutputTypes[getSizeindex(type->size)];
       break;
     case STRING:
-      str = g_strdup("string");
+      str = allocAndCopy("string");
       flag = 1;
       break;
     case ENUM:
-      str = g_strconcat("enum ", uintOutputTypes[type->size], NULL);
+      //str = appendString("enum ", uintOutputTypes[getSizeindex(type->size)]);
+      str = allocAndCopy("enum");
       flag = 1;
       break;
     case ARRAY:
-      sprintf(buf,"%d",type->size);
-      str = g_strconcat("array ",buf, NULL);
+      sprintf(buf,"%zu", type->size);
+      str = appendString("array ",buf);
       flag = 1;
       break;
     case SEQUENCE:
-      sprintf(buf,"%d",type->size);
-      str = g_strconcat("sequence ",buf, NULL);
+      str = allocAndCopy("sequence ");
       flag = 1;
       break;
     case STRUCT:
-      str = g_strdup("struct");
+      str = allocAndCopy("struct");
       flag = 1;
       break;
     case UNION:
-      str = g_strdup("union");
+      str = allocAndCopy("union");
       flag = 1;
       break;
     default:
@@ -1071,15 +1458,18 @@ unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type)
   }
 
   crc = partial_crc32(str,crc);
-  if(flag) g_free(str);
+  if(flag) free(str);
 
   if(type->fmt) crc = partial_crc32(type->fmt,crc);
     
-  if(type->type == ARRAY || type->type == SEQUENCE){
-    crc = getTypeChecksum(crc,type->nested_type);
-  }else if(type->type == STRUCT || type->type == UNION){
+  if(type->type == ARRAY){
+    crc = getTypeChecksum(crc,((field_t*)type->fields.array[0])->type);
+  } else if(type->type ==SEQUENCE) {
+    crc = getTypeChecksum(crc,((field_t*)type->fields.array[0])->type);
+    crc = getTypeChecksum(crc,((field_t*)type->fields.array[1])->type);
+	} else if(type->type == STRUCT || type->type == UNION){
     for(pos =0; pos < type->fields.position; pos++){
-      fld = (type_fields *) type->fields.array[pos];
+      fld = (field_t *) type->fields.array[pos];
       crc = partial_crc32(fld->name,crc);
       crc = getTypeChecksum(crc, fld->type);
     }    
@@ -1093,64 +1483,69 @@ unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type)
 
 
 /* Event type descriptors */
-void freeType(type_descriptor * tp)
+void freeType(type_descriptor_t * tp)
 {
   int pos2;
-  type_fields *f;
+  field_t *f;
 
-  if(tp->fmt != NULL) g_free(tp->fmt);
+  if(tp->fmt != NULL) free(tp->fmt);
   if(tp->type == ENUM) {
     for(pos2 = 0; pos2 < tp->labels.position; pos2++) {
-      g_free(tp->labels.array[pos2]);
+      free(tp->labels.array[pos2]);
     }
     sequence_dispose(&(tp->labels));
+    for(pos2 = 0; pos2 < tp->labels_values.position; pos2++) {
+      free(tp->labels_values.array[pos2]);
+    }
+    sequence_dispose(&(tp->labels_values));
   }
   if(tp->type == STRUCT) {
     for(pos2 = 0; pos2 < tp->fields.position; pos2++) {
-      f = (type_fields *) tp->fields.array[pos2];
-      g_free(f->name);
-      g_free(f->description);
-      g_free(f);
+      f = (field_t *) tp->fields.array[pos2];
+      free(f->name);
+      free(f->description);
+      free(f);
     }
     sequence_dispose(&(tp->fields));
   }
 }
 
-void freeNamedType(table * t)
+void freeNamedType(table_t * t)
 {
   int pos;
-  type_descriptor * td;
+  type_descriptor_t * td;
 
   for(pos = 0 ; pos < t->keys.position; pos++) {
-    g_free((char *)t->keys.array[pos]);
-    td = (type_descriptor*)t->values.array[pos];
+    free((char *)t->keys.array[pos]);
+    td = (type_descriptor_t*)t->values.array[pos];
     freeType(td);
-    g_free(td);
+    free(td);
   }
 }
 
-void freeTypes(sequence *t) 
+void freeTypes(sequence_t *t) 
 {
   int pos;
-  type_descriptor *tp;
+  type_descriptor_t *tp;
 
   for(pos = 0 ; pos < t->position; pos++) {
-    tp = (type_descriptor *)t->array[pos];
+    tp = (type_descriptor_t *)t->array[pos];
     freeType(tp);
-    g_free(tp);
+    free(tp);
   }
 }
 
-void freeEvents(sequence *t) 
+void freeEvents(sequence_t *t) 
 {
   int pos;
   event_t *ev;
 
   for(pos = 0 ; pos < t->position; pos++) {
     ev = (event_t *) t->array[pos];
-    g_free(ev->name);
-    g_free(ev->description);
-    g_free(ev);
+    free(ev->name);
+    free(ev->description);
+		sequence_dispose(&ev->fields);
+    free(ev);
   }
 
 }
@@ -1158,78 +1553,79 @@ void freeEvents(sequence *t)
 
 /* Extensible array */
 
-void sequence_init(sequence *t) 
+void sequence_init(sequence_t *t) 
 {
   t->size = 10;
   t->position = 0;
-  t->array = g_new(void*, t->size);
+  t->array = (void **)memAlloc(t->size * sizeof(void *));
 }
 
-void sequence_dispose(sequence *t) 
+void sequence_dispose(sequence_t *t) 
 {
   t->size = 0;
-  g_free(t->array);
+  free(t->array);
   t->array = NULL;
 }
 
-void sequence_push(sequence *t, void *elem) 
+void sequence_push(sequence_t *t, void *elem) 
 {
   void **tmp;
 
   if(t->position >= t->size) {
     tmp = t->array;
-    t->array = g_new(void*, 2*t->size);
+    t->array = (void **)memAlloc(t->size * 2 * sizeof(void *));
     memcpy(t->array, tmp, t->size * sizeof(void *));
     t->size = t->size * 2;
-    g_free(tmp);
+    free(tmp);
   }
   t->array[t->position] = elem;
   t->position++;
 }
 
-void *sequence_pop(sequence *t) 
+void *sequence_pop(sequence_t *t) 
 {
-  return t->array[t->position--];
+	if(t->position == 0) printf("Error : trying to pop an empty sequence");
+  return t->array[--t->position];
 }
 
 
 /* Hash table API, implementation is just linear search for now */
 
-void table_init(table *t) 
+void table_init(table_t *t) 
 {
   sequence_init(&(t->keys));
   sequence_init(&(t->values));
 }
 
-void table_dispose(table *t) 
+void table_dispose(table_t *t) 
 {
   sequence_dispose(&(t->keys));
   sequence_dispose(&(t->values));
 }
 
-void table_insert(table *t, char *key, void *value) 
+void table_insert(table_t *t, char *key, void *value) 
 {
   sequence_push(&(t->keys),key);
   sequence_push(&(t->values),value);
 }
 
-void *table_find(table *t, char *key) 
+void *table_find(table_t *t, char *key) 
 {
   int pos;
   for(pos = 0 ; pos < t->keys.position; pos++) {
-    if(g_ascii_strcasecmp((char *)key,(char *)t->keys.array[pos]) == 0)
+    if(strcmp((char *)key,(char *)t->keys.array[pos]) == 0)
       return(t->values.array[pos]);
   }
   return NULL;
 }
 
-void table_insert_int(table *t, int *key, void *value)
+void table_insert_int(table_t *t, int *key, void *value)
 {
   sequence_push(&(t->keys),key);
   sequence_push(&(t->values),value);
 }
 
-void *table_find_int(table *t, int *key)
+void *table_find_int(table_t *t, int *key)
 {
   int pos;
   for(pos = 0 ; pos < t->keys.position; pos++) {
@@ -1240,3 +1636,15 @@ void *table_find_int(table *t, int *key)
 }
 
 
+/* Concatenate strings */
+
+char *appendString(char *s, char *suffix) 
+{
+  char *tmp;
+  if(suffix == NULL) return s;
+
+  tmp = (char *)memAlloc(strlen(s) + strlen(suffix) + 1);
+  strcpy(tmp,s);
+  strcat(tmp,suffix);  
+  return tmp;
+}