From: compudj <compudj@04897980-b3bd-0310-b5e0-8ef037075253>
Date: Sat, 20 Aug 2005 15:23:09 +0000 (+0000)
Subject: remove old LTTV XML parser
X-Git-Tag: v0.12.20~2462
X-Git-Url: https://git.lttng.org./?a=commitdiff_plain;h=70076b6a47206b1e6c668cdc468e23953ae1f2fb;p=lttv.git

remove old LTTV XML parser

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

diff --git a/ltt/branches/poly/ltt/parser.c b/ltt/branches/poly/ltt/parser.c
deleted file mode 100644
index 8e409aa9..00000000
--- a/ltt/branches/poly/ltt/parser.c
+++ /dev/null
@@ -1,1242 +0,0 @@
-/*
-
-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
-   it under the terms of the GNU General Public License as published by
-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
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
-*/
-
-/* 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.
-   The result is a sequence of events definitions which refer to type
-   definitions.
-
-   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 ".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 <ctype.h>
-#include <linux/errno.h>
-#include <glib.h>
-
-
-#include "parser.h"
-
-/*****************************************************************************
- *Function name
- *    getSize    : translate from string to integer
- *Input params 
- *    in         : input file handle
- *Return values  
- *    size                           
- *****************************************************************************/
-
-int getSize(parse_file *in)
-{
-  gchar *token;
-
-  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;
-  }
-  in->error(in,"incorrect size specification");
-  return -1;
-}
-
-/*****************************************************************************
- *Function name
- *    error_callback  : print out error info
- *Input params
- *    in              : input file handle
- *    msg             : message to be printed                  
- ****************************************************************************/
-
-void error_callback(parse_file *in, char *msg)
-{
-  if(in)
-    g_printf("Error in file %s, line %d: %s\n", in->name, in->lineno, msg);
-  else
-    printf("%s\n",msg);
-}
-
-/**************************************************************************
- * 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.
- *
- **************************************************************************/
-
-gchar * getNameAttribute(parse_file *in)
-{
-  gchar * token;
-  gunichar car;
-  GIOStatus status;
-  
-  token = getName(in);
-  if(g_ascii_strcasecmp("name",token))in->error(in,"name was expected");
-  getEqual(in);
-  
-  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;
-}
-
-char * getFormatAttribute(parse_file *in)
-{
-  char * token;
-
-  //format is an option
-  token = getToken(in); 
-  if(g_ascii_strcasecmp("/",token) == 0 || g_ascii_strcasecmp(">",token) == 0){
-    ungetToken(in);
-    return NULL;
-  }
-
-  if(g_ascii_strcasecmp("format",token))in->error(in,"format was expected");
-  getEqual(in);
-  token = getQuotedString(in);
-  return token;
-}
-
-int getSizeAttribute(parse_file *in)
-{
-  /* skip name and equal */
-  getName(in);
-  getEqual(in);
-
-  return getSize(in);
-}
-
-int getValueAttribute(parse_file *in)
-{
-  /* skip name and equal */
-  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(g_ascii_strcasecmp("/",token) == 0){
-    ungetToken(in);
-    return NULL;
-  }
-  
-  if(g_ascii_strcasecmp("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)
-{
-  gint64 pos;
-  gchar * token, *str;
-  gunichar car;
-  GError * error = NULL;
-
-  pos = in->pos;
-
-  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;
-
-    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++;
-
-    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 = g_strdup(in->buffer);
-
-  getForwardslash(in);
-  token = getName(in);
-  if(g_ascii_strcasecmp("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_t * fac)
-{
-  char * token;
-  event_t *ev;
-  
-  fac->name = g_strdup(getNameAttribute(in));    
-  getRAnglebracket(in);    
-  
-  fac->description = 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(g_ascii_strcasecmp("event",token) == 0){
-      ev = (event_t*) g_new(event_t,1);
-      sequence_push(&(fac->events),ev);
-      parseEvent(in,ev, &(fac->unnamed_types), &(fac->named_types));    
-    }else if(g_ascii_strcasecmp("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(g_ascii_strcasecmp("facility",token)) in->error(in,"not the end of the facility");
-  getRAnglebracket(in); //</facility>
-}
-
-/*****************************************************************************
- *Function name
- *    parseEvent    : generate event from event definition 
- *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)   
- ****************************************************************************/
-
-void parseEvent(parse_file *in, event_t * ev, sequence * unnamed_types, 
-		table * named_types) 
-{
-  char *token;
-
-  //<event name=eventtype_name>
-  ev->name = g_strdup(getNameAttribute(in));
-  getRAnglebracket(in);  
-
-  //<description>...</descriptio>
-  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>
-}
-
-/*****************************************************************************
- *Function name
- *    parseField    : get field infomation from buffer 
- *Input params 
- *    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,
-		 table * named_types) 
-{
-  char * token;
-  type_fields *f;
-
-  f = g_new(type_fields,1);
-  sequence_push(&(t->fields),f);
-
-  //<field name=field_name> <description> <type> </field>
-  f->name = g_strdup(getNameAttribute(in)); 
-  getRAnglebracket(in);
-
-  f->description = getDescription(in);
-
-  //<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>
-}
-
-
-/*****************************************************************************
- *Function name
- *    parseType      : get type information, type can be : 
- *                     Primitive:
- *                        int(size,fmt); uint(size,fmt); float(size,fmt); 
- *                        string(fmt); enum(size,fmt,(label1,label2...))
- *                     Compound:
- *                        array(arraySize, type); sequence(lengthSize,type)
- *		          struct(field(name,type,description)...)
- *                     type name:
- *                        type(name,type)
- *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             
- ****************************************************************************/
-
-type_descriptor *parseType(parse_file *in, type_descriptor *inType, 
-			   sequence * unnamed_types, table * named_types) 
-{
-  char *token;
-  type_descriptor *t;
-
-  if(inType == NULL) {
-    t = g_new(type_descriptor,1);
-    t->type_name = NULL;
-    t->type = NONE;
-    t->fmt = NULL;
-    sequence_push(unnamed_types,t);
-  }
-  else t = inType;
-
-  token = getName(in);
-
-  if(g_ascii_strcasecmp(token,"struct") == 0) {
-    t->type = STRUCT;
-    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);
-      
-      //next field
-      getLAnglebracket(in);
-      token = getToken(in);	
-    }
-    if(g_ascii_strcasecmp("/",token))in->error(in,"not a valid structure definition");
-    token = getName(in);
-    if(g_ascii_strcasecmp("struct",token)!=0)
-      in->error(in,"not a valid structure definition");
-    getRAnglebracket(in); //</struct>
-  }
-  else if(g_ascii_strcasecmp(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(g_ascii_strcasecmp("field",token) == 0){
-      parseFields(in,t, unnamed_types, named_types);
-      
-      //next field
-      getLAnglebracket(in);
-      token = getToken(in);	
-    }
-    if(g_ascii_strcasecmp("/",token))in->error(in,"not a valid union definition");
-    token = getName(in);
-    if(g_ascii_strcasecmp("union",token)!=0)
-      in->error(in,"not a valid union definition");        
-    getRAnglebracket(in); //</union>
-  }
-  else if(g_ascii_strcasecmp(token,"array") == 0) {
-    t->type = ARRAY;
-    t->size = getValueAttribute(in);
-    getRAnglebracket(in); //<array size=n>
-
-    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");
-    getRAnglebracket(in);  //</array>
-  }
-  else if(g_ascii_strcasecmp(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);
-
-    getLAnglebracket(in); //</sequence>
-    getForwardslash(in);
-    token = getName(in);
-    if(g_ascii_strcasecmp("sequence",token))in->error(in,"not a valid sequence definition");
-    getRAnglebracket(in); //</sequence>
-  }
-  else if(g_ascii_strcasecmp(token,"enum") == 0) {
-    char * str, *str1;
-    t->type = ENUM;
-    sequence_init(&(t->labels));
-    t->size = getSizeAttribute(in);
-    t->fmt = g_strdup(getFormatAttribute(in));
-    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);
-
-      getForwardslash(in);
-      getRAnglebracket(in);
-      
-      //next label definition
-      getLAnglebracket(in);
-      token = getToken(in); //"label" or "/"      
-    }
-    if(g_ascii_strcasecmp("/",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>
-  }
-  else if(g_ascii_strcasecmp(token,"int") == 0) {
-    t->type = INT;
-    t->size = getSizeAttribute(in);
-    t->fmt  = g_strdup(getFormatAttribute(in));
-    getForwardslash(in);
-    getRAnglebracket(in); 
-  }
-  else if(g_ascii_strcasecmp(token,"uint") == 0) {
-    t->type = UINT;
-    t->size = getSizeAttribute(in);
-    t->fmt  = g_strdup(getFormatAttribute(in));
-    getForwardslash(in);
-    getRAnglebracket(in); 
-  }
-  else if(g_ascii_strcasecmp(token,"float") == 0) {
-    t->type = FLOAT;
-    t->size = getSizeAttribute(in);
-    t->fmt  = g_strdup(getFormatAttribute(in));
-    getForwardslash(in);
-    getRAnglebracket(in); 
-  }
-  else if(g_ascii_strcasecmp(token,"string") == 0) {
-    t->type = STRING;
-    t->fmt  = g_strdup(getFormatAttribute(in));
-    getForwardslash(in);
-    getRAnglebracket(in); 
-  }
-  else if(g_ascii_strcasecmp(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;
-    }
-  }else in->error(in,"not a valid type");
-
-  return t;
-}    
-
-/*****************************************************************************
- *Function name
- *    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                       
- *****************************************************************************/
-
-type_descriptor * find_named_type(gchar *name, table * named_types)
-{ 
-  type_descriptor *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;
-}  
-
-/*****************************************************************************
- *Function name
- *    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,
-			 table * named_types)
-{
-  char *token;
-  type_descriptor *t;
-
-  token = getNameAttribute(in);
-  t = find_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>
-  token = getName(in);
-  if(g_ascii_strcasecmp("struct",token))in->error(in,"not a valid type definition");
-  ungetToken(in);
-  parseType(in,t, unnamed_types, named_types);
-  
-  //</type>
-  getLAnglebracket(in);
-  getForwardslash(in);
-  token = getName(in);
-  if(g_ascii_strcasecmp("type",token))in->error(in,"not a valid type definition");  
-  getRAnglebracket(in); //</type>
-}
-
-/**************************************************************************
- * Function :
- *    getComa, getName, getNumber, getEqual
- * Description :
- *    Read a token from the input file, check its type, return it scontent.
- *
- * Parameters :
- *    in , input file handle.
- *
- * Return values :
- *    address of token content.
- *
- **************************************************************************/
-
-char *getName(parse_file * in) 
-{
-  char *token;
-
-  token = getToken(in);
-  if(in->type != NAME) in->error(in,"Name token was expected");
-  return token;
-}
-
-int getNumber(parse_file * in) 
-{
-  char *token;
-
-  token = getToken(in);
-  if(in->type != NUMBER) in->error(in, "Number token was expected");
-  return atoi(token);
-}
-
-char *getForwardslash(parse_file * in) 
-{
-  char *token;
-
-  token = getToken(in);
-  if(in->type != FORWARDSLASH) in->error(in, "forward slash token was expected");
-  return token;
-}
-
-char *getLAnglebracket(parse_file * in) 
-{
-  char *token;
-
-  token = getToken(in);
-  if(in->type != LANGLEBRACKET) in->error(in, "Left angle bracket was expected");
-  return token;
-}
-
-char *getRAnglebracket(parse_file * in) 
-{
-  char *token;
-
-  token = getToken(in);
-  if(in->type != RANGLEBRACKET) in->error(in, "Right angle bracket was expected");
-  return token;
-}
-
-char *getQuotedString(parse_file * in) 
-{
-  char *token;
-
-  token = getToken(in);
-  if(in->type != QUOTEDSTRING) in->error(in, "quoted string was expected");
-  return token;
-}
-
-char * getEqual(parse_file *in)
-{
-  char *token;
-
-  token = getToken(in);
-  if(in->type != EQUAL) in->error(in, "equal was expected");
-  return token;
-}
-
-gunichar seekNextChar(parse_file *in, gunichar *car)
-{
-  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;
-    }
-    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;
-}
-
-
-/******************************************************************
- * Function :
- *    getToken, ungetToken
- * Description :
- *    Read a token from the input file and return its type and content.
- *    Line numbers are accounted for and whitespace/comments are skipped.
- *
- * Parameters :
- *    in, input file handle.
- *
- * Return values :
- *    address of token content.
- *
- ******************************************************************/
-
-void ungetToken(parse_file * in)
-{
-  in->unget = 1;
-}
-
-gchar *getToken(parse_file * in)
-{
-  gunichar car, car1;
-  int pos = 0, escaped;
-  GError * error = NULL;
-
-  if(in->unget == 1) {
-    in->unget = 0;
-    return in->buffer;
-  }
-
-  /* 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++;
-
-    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++;
-
-      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--;
-        break;
-      }
-    }
-    else if(car == '\n') in->lineno++;
-    else if(!g_unichar_isspace(car)) break;
-  }
-  switch(car) {
-    case EOF:
-      in->type = ENDFILE;
-      break;
-    case '/':
-      in->type = FORWARDSLASH;
-      in->buffer[pos] = car;
-      pos++;
-      break;
-    case '<':
-      in->type = LANGLEBRACKET;
-      in->buffer[pos] = car;
-      pos++;
-      break;
-    case '>':
-      in->type = RANGLEBRACKET;
-      in->buffer[pos] = car;
-      pos++;
-      break;
-    case '=':
-      in->type = EQUAL;
-      in->buffer[pos] = car;
-      pos++;
-      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++;
-
-        if(car == '\\' && escaped == 0) {
-	        in->buffer[pos] = car;
-      	  pos++;
-          escaped = 1;
-          continue;
-        }
-        if(car == '"' && escaped == 0) break;
-        if(car == '\n' && escaped == 0) {
-          in->error(in, "non escaped newline inside quoted string");
-        }
-        if(car == '\n') in->lineno++;
-        in->buffer[pos] = car;
-        pos++;
-        escaped = 0;
-      }
-      if(car == EOF) in->error(in,"no ending quotemark");
-      if(pos == BUFFER_SIZE) in->error(in, "quoted string token too large");
-      in->type = QUOTEDSTRING;
-      break;
-    default:
-      if(g_unichar_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++;
-
-          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--;
-            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(pos == BUFFER_SIZE) in->error(in, "number token too large");
-        in->type = NUMBER;
-      }    
-      else if(g_unichar_isalpha(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--;
-            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(pos == BUFFER_SIZE) in->error(in, "name token too large");
-        in->type = NAME;
-      }
-      else in->error(in, "invalid character, unrecognized token");
-  }
-  in->buffer[pos] = 0;
-  return in->buffer;
-}
-
-void skipComment(parse_file * 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++;
-
-    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++;
-
-      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--;
-
-    }
-  }
-  if(car == EOF) in->error(in,"comment begining with '/*' has no ending '*/'");
-}
-
-void skipEOL(parse_file * in)
-{
-  gunichar car;
-  GError * error = NULL;
-
-  while(g_io_channel_read_unichar(in->channel, &car, &error)
-                                          != G_IO_STATUS_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--;
-      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--;
-  }
-}
-
-/*****************************************************************************
- *Function name
- *    checkNamedTypesImplemented : check if all named types have definition
- *    returns -1 on error, 0 if ok
- ****************************************************************************/
-
-int checkNamedTypesImplemented(table * named_types)
-{
-  type_descriptor *t;
-  int pos;
-  char str[256];
-
-  for(pos = 0 ; pos < named_types->values.position; pos++) {
-    t = (type_descriptor *) 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;
-    }
-  }
-  return 0;
-}
-
-
-/*****************************************************************************
- *Function name
- *    generateChecksum  : generate checksum for the facility
- *Input Params
- *    facName           : name of facility
- *Output Params
- *    checksum          : checksum for the facility
- ****************************************************************************/
-
-int generateChecksum(char* facName, guint32 * checksum, sequence * events)
-{
-  unsigned long crc ;
-  int pos;
-  event_t * ev;
-  char str[256];
-
-  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);
-  }
-  *checksum = crc;
-  return 0;
-}
-
-/*****************************************************************************
- *Function name
- *   getTypeChecksum    : generate checksum by type info
- *Input Params
- *    crc               : checksum generated so far
- *    type              : type descriptor containing type info
- *Return value          
- *    unsigned long     : checksum 
- *****************************************************************************/
-
-unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type)
-{
-  unsigned long crc = aCrc;
-  char * str = NULL, buf[16];
-  int flag = 0, pos;
-  type_fields * fld;
-
-  switch(type->type){
-    case INT:
-      str = intOutputTypes[type->size];
-      break;
-    case UINT:
-      str = uintOutputTypes[type->size];
-      break;
-    case FLOAT:
-      str = floatOutputTypes[type->size];
-      break;
-    case STRING:
-      str = g_strdup("string");
-      flag = 1;
-      break;
-    case ENUM:
-      str = g_strconcat("enum ", uintOutputTypes[type->size], NULL);
-      flag = 1;
-      break;
-    case ARRAY:
-      sprintf(buf,"%d",type->size);
-      str = g_strconcat("array ",buf, NULL);
-      flag = 1;
-      break;
-    case SEQUENCE:
-      sprintf(buf,"%d",type->size);
-      str = g_strconcat("sequence ",buf, NULL);
-      flag = 1;
-      break;
-    case STRUCT:
-      str = g_strdup("struct");
-      flag = 1;
-      break;
-    case UNION:
-      str = g_strdup("union");
-      flag = 1;
-      break;
-    default:
-      error_callback(NULL, "named type has no definition");
-      break;
-  }
-
-  crc = partial_crc32(str,crc);
-  if(flag) g_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){
-    for(pos =0; pos < type->fields.position; pos++){
-      fld = (type_fields *) 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);
-  }
-
-  return crc;
-}
-
-
-/* Event type descriptors */
-void freeType(type_descriptor * tp)
-{
-  int pos2;
-  type_fields *f;
-
-  if(tp->fmt != NULL) g_free(tp->fmt);
-  if(tp->type == ENUM) {
-    for(pos2 = 0; pos2 < tp->labels.position; pos2++) {
-      g_free(tp->labels.array[pos2]);
-    }
-    sequence_dispose(&(tp->labels));
-  }
-  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);
-    }
-    sequence_dispose(&(tp->fields));
-  }
-}
-
-void freeNamedType(table * t)
-{
-  int pos;
-  type_descriptor * td;
-
-  for(pos = 0 ; pos < t->keys.position; pos++) {
-    g_free((char *)t->keys.array[pos]);
-    td = (type_descriptor*)t->values.array[pos];
-    freeType(td);
-    g_free(td);
-  }
-}
-
-void freeTypes(sequence *t) 
-{
-  int pos;
-  type_descriptor *tp;
-
-  for(pos = 0 ; pos < t->position; pos++) {
-    tp = (type_descriptor *)t->array[pos];
-    freeType(tp);
-    g_free(tp);
-  }
-}
-
-void freeEvents(sequence *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);
-  }
-
-}
-
-
-/* Extensible array */
-
-void sequence_init(sequence *t) 
-{
-  t->size = 10;
-  t->position = 0;
-  t->array = g_new(void*, t->size);
-}
-
-void sequence_dispose(sequence *t) 
-{
-  t->size = 0;
-  g_free(t->array);
-  t->array = NULL;
-}
-
-void sequence_push(sequence *t, void *elem) 
-{
-  void **tmp;
-
-  if(t->position >= t->size) {
-    tmp = t->array;
-    t->array = g_new(void*, 2*t->size);
-    memcpy(t->array, tmp, t->size * sizeof(void *));
-    t->size = t->size * 2;
-    g_free(tmp);
-  }
-  t->array[t->position] = elem;
-  t->position++;
-}
-
-void *sequence_pop(sequence *t) 
-{
-  return t->array[t->position--];
-}
-
-
-/* Hash table API, implementation is just linear search for now */
-
-void table_init(table *t) 
-{
-  sequence_init(&(t->keys));
-  sequence_init(&(t->values));
-}
-
-void table_dispose(table *t) 
-{
-  sequence_dispose(&(t->keys));
-  sequence_dispose(&(t->values));
-}
-
-void table_insert(table *t, char *key, void *value) 
-{
-  sequence_push(&(t->keys),key);
-  sequence_push(&(t->values),value);
-}
-
-void *table_find(table *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)
-      return(t->values.array[pos]);
-  }
-  return NULL;
-}
-
-void table_insert_int(table *t, int *key, void *value)
-{
-  sequence_push(&(t->keys),key);
-  sequence_push(&(t->values),value);
-}
-
-void *table_find_int(table *t, int *key)
-{
-  int pos;
-  for(pos = 0 ; pos < t->keys.position; pos++) {
-    if(*key == *(int *)t->keys.array[pos])
-      return(t->values.array[pos]);
-  }
-  return NULL;
-}
-
-
diff --git a/ltt/branches/poly/ltt/parser.h b/ltt/branches/poly/ltt/parser.h
deleted file mode 100644
index c2c5d917..00000000
--- a/ltt/branches/poly/ltt/parser.h
+++ /dev/null
@@ -1,226 +0,0 @@
-/*
-
-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 
-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.
-
-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.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
-*/
-
-#ifndef PARSER_H
-#define PARSER_H
-
-#include <glib.h>
-
-/* Extensible array container */
-
-typedef struct _sequence {
-  int size;
-  int position;
-  void **array;
-} sequence;
-
-void sequence_init(sequence *t);
-void sequence_dispose(sequence *t);
-void sequence_push(sequence *t, void *elem);
-void *sequence_pop(sequence *t);
-
-
-/* Hash table */
-
-typedef struct _table {
-  sequence keys;
-  sequence values;
-} table;
-
-void table_init(table *t);
-void table_dispose(table *t);
-void table_insert(table *t, char *key, void *value);
-void *table_find(table *t, char *key);
-void table_insert_int(table *t, int *key, void *value);
-void *table_find_int(table *t, int *key);
-
-
-/* Token types */
-
-typedef enum _token_type {
-  ENDFILE,
-  FORWARDSLASH,
-  LANGLEBRACKET,
-  RANGLEBRACKET,
-  EQUAL,
-  QUOTEDSTRING,
-  NUMBER,
-  NAME
-} token_type;
-
-
-/* State associated with a file being parsed */
-typedef struct _parse_file {
-  gchar *name;
-  int fd;
-  guint64 pos;
-  GIOChannel *channel;
-  int lineno;
-  gchar *buffer;
-  token_type type; 
-  int unget;
-  void (*error) (struct _parse_file *, char *);
-} parse_file;
-
-void ungetToken(parse_file * in);
-gchar *getToken(parse_file *in);
-gchar *getForwardslash(parse_file *in);
-gchar *getLAnglebracket(parse_file *in);
-gchar *getRAnglebracket(parse_file *in);
-gchar *getQuotedString(parse_file *in);
-gchar *getName(parse_file *in);
-int   getNumber(parse_file *in);
-gchar *getEqual(parse_file *in);
-GIOStatus seekNextChar(parse_file *in, gunichar *car);
-
-void skipComment(parse_file * in);
-void skipEOL(parse_file * in);
-
-/* Some constants */
-
-#define BUFFER_SIZE 1024
-
-
-/* Events data types */
-
-typedef enum _data_type {
-  INT,
-  UINT,
-  FLOAT,
-  STRING,
-  ENUM,
-  ARRAY,
-  SEQUENCE,
-  STRUCT,
-  UNION,
-  NONE
-} data_type;
-
-
-/* Event type descriptors */
-
-typedef struct _type_descriptor {
-  char * type_name; //used for named type
-  data_type type;
-  char *fmt;
-  int size;
-  sequence labels; // for enumeration
-  sequence fields; // for structure
-  struct _type_descriptor *nested_type; // for array and sequence 
-} type_descriptor;
-
-
-/* Fields within types */
-
-typedef struct _type_fields{
-  char *name;
-  char *description;
-  type_descriptor *type;
-} type_fields;
-
-
-/* Events definitions */
-
-typedef struct _event_t {  
-  char *name;
-  char *description;
-  type_descriptor *type; 
-} event_t;
-
-typedef struct _facility_t {
-  char * name;
-  char * description;
-  sequence events;
-  sequence unnamed_types;
-  table named_types;
-} facility_t;
-
-int getSize(parse_file *in);
-unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type);
-
-void parseFacility(parse_file *in, facility_t * fac);
-void parseEvent(parse_file *in, event_t *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);
-void parseFields(parse_file *in, type_descriptor *t, sequence * unnamed_types, table * named_types);
-int checkNamedTypesImplemented(table * namedTypes);
-type_descriptor * find_named_type(char *name, table * named_types);
-int generateChecksum(char * facName, guint32 * 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" };
-
-static char *uintOutputTypes[] = {
-  "uint8_t", "uint16_t", "uint32_t", "uint64_t", "unsigned short int", 
-  "unsigned int", "unsigned long int" };
-
-static char *floatOutputTypes[] = {
-  "undef", "undef", "float", "double", "undef", "float", "double" };
-
-
-/* Dynamic memory allocation and freeing */
-
-void freeTypes(sequence *t);
-void freeType(type_descriptor * td);
-void freeEvents(sequence *t);
-void freeNamedType(table * t);
-void error_callback(parse_file *in, char *msg);
-
-
-//checksum part
-static const unsigned int crctab32[] =
-{
-#include "crc32.tab"
-};
-
-static inline unsigned long
-partial_crc32_one(unsigned char c, unsigned long crc)
-{
-  return crctab32[(crc ^ c) & 0xff] ^ (crc >> 8);
-}
-
-static inline unsigned long
-partial_crc32(const char *s, unsigned long crc)
-{
-  while (*s)
-    crc = partial_crc32_one(*s++, crc);
-  return crc;
-}
-
-static inline unsigned long
-crc32(const char *s)
-{
-  return partial_crc32(s, 0xffffffff) ^ 0xffffffff;
-}
-
-
-#endif // PARSER_H