X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;ds=inline;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftype.c;h=d650d35510f5ab07fb268a60b9b7a7cb4f882730;hb=de4a3e25528f0eeca03c1c1137f566bf55d5fec5;hp=e153d5403c322595ef83ad17d34aee61e2d216c5;hpb=3aee1200b100fe8063661fd2d8eaa5fbbfc1977f;p=lttv.git

diff --git a/ltt/branches/poly/ltt/type.c b/ltt/branches/poly/ltt/type.c
index e153d540..d650d355 100644
--- a/ltt/branches/poly/ltt/type.c
+++ b/ltt/branches/poly/ltt/type.c
@@ -1,19 +1,20 @@
 /* This file is part of the Linux Trace Toolkit viewer
- * Copyright (C) 2003-2004 Xiangxiu Yang, Mathieu Desnoyers
+ * Copyright (C) 2003-2004 Xiangxiu Yang
+ *               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 Version 2 as
- * published by the Free Software Foundation;
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License Version 2.1 as published by the Free Software Foundation.
  *
- * This program is distributed in the hope that it will be useful,
+ * This library 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.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser 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.
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
  */
 
 #ifdef HAVE_CONFIG_H
@@ -101,47 +102,17 @@ guint8 ltt_eventtype_id(LttEventType *et)
 
 /*****************************************************************************
  *Function name
- *    ltt_eventtype_type : get the type of the event type
+ *    ltt_field_name  : get the name of the field
  *Input params
- *    et                 : an  event type   
- *Return value
- *    LttType *         : the type of the event type
- ****************************************************************************/
-
-LttType *ltt_eventtype_type(LttEventType *et)
-{
-  if(unlikely(!et->root_field)) return NULL;
-  else return et->root_field->field_type;
-}
-
-/*****************************************************************************
- *Function name
- *    ltt_eventtype_field : get the root filed of the event type
- *Input params
- *    et                  : an  event type   
- *Return value
- *    LttField *          : the root filed of the event type
- ****************************************************************************/
-
-LttField *ltt_eventtype_field(LttEventType *et)
-{
-  return et->root_field;
-}
-
-/*****************************************************************************
- *Function name
- *    ltt_type_name  : get the name of the type
- *Input params
- *    t              : a type   
+ *    f              : a field
  *Return value
  *    char *         : the name of the type
  ****************************************************************************/
 
-GQuark ltt_type_name(LttType *t)
+GQuark ltt_field_name(LttField *f)
 {
-  return t->element_name;
+  return f->name;
 }
-
 /*****************************************************************************
  *Function name
  *    ltt_type_class : get the type class of the type
@@ -170,15 +141,19 @@ LttTypeEnum ltt_type_class(LttType *t)
  *    returns 0 if erroneous, and show a critical warning message.
  ****************************************************************************/
 
-size_t ltt_type_size(LttTrace * trace, LttType *t)
+guint ltt_type_size(LttTrace * trace, LttType *t)
 {
-  size_t size;
+  guint size;
 
   switch(t->type_class) {
-
+    case LTT_INT_FIXED:
+    case LTT_UINT_FIXED:
+    case LTT_CHAR:
+    case LTT_UCHAR:
+    case LTT_SHORT:
+    case LTT_USHORT:
     case LTT_INT:
     case LTT_UINT:
-    case LTT_SEQUENCE:
     case LTT_ENUM:
       if(likely(t->size < INT_SIZES_NUMBER))
         size = intSizes[t->size];
@@ -196,11 +171,13 @@ size_t ltt_type_size(LttTrace * trace, LttType *t)
     case LTT_ULONG:
     case LTT_SIZE_T:
     case LTT_SSIZE_T:
+    case LTT_SEQUENCE:
     case LTT_OFF_T:
     case LTT_STRING:
     case LTT_ARRAY:
     case LTT_STRUCT:
     case LTT_UNION:
+    case LTT_NONE:
       goto error;
       break;
   }
@@ -226,30 +203,35 @@ error:
 LttType *ltt_type_element_type(LttType *t)
 {
   LttType *element_type;
+  LttField *field;
 
   if(unlikely(t->type_class != LTT_ARRAY && t->type_class != LTT_SEQUENCE))
     element_type = NULL;
-  else
-    element_type = t->element_type[0];
+  else {
+    if(t->type_class == LTT_ARRAY)
+      field = &g_array_index(t->fields, LttField, 0);
+    else
+      field = &g_array_index(t->fields, LttField, 1);
+    element_type = ltt_field_type(field);
+  }
 
   return element_type;
 }
 
 /*****************************************************************************
  *Function name
- *    ltt_type_element_number : obtain the number of elements for arrays 
+ *    ltt_type_element_number : obtain the number of elements for enums
  *Input params
- *    t                       : a type   
+ *    t                       : a type
  *Return value
  *    unsigned                : the number of elements for arrays
  ****************************************************************************/
-
 unsigned ltt_type_element_number(LttType *t)
 {
   unsigned ret = 0;
 
-  if(likely(t->type_class == LTT_ARRAY))
-    ret = t->element_number;
+  if(likely(t->type_class == LTT_ENUM))
+    ret = g_hash_table_size(t->enum_map);
 
   return ret;
 }
@@ -268,39 +250,11 @@ unsigned ltt_type_member_number(LttType *t)
   unsigned ret = 0;
   
   if(likely(t->type_class == LTT_STRUCT || t->type_class == LTT_UNION))
-    ret =t->element_number;
+    ret = t->fields->len;
 
   return ret;
 }
 
-/*****************************************************************************
- *Function name
- *    ltt_type_member_type : obtain the type of a data member in a structure 
- *                           or union.
- *Input params
- *    t                    : a type   
- *    i                    : index of the member
- *Return value
- *    LttType *           : the type of structure member
- ****************************************************************************/
-
-LttType *ltt_type_member_type(LttType *t, unsigned i, GQuark *name)
-{
-  LttType *member_type = NULL;
-
-  if(unlikely(  (t->type_class != LTT_STRUCT
-                 && t->type_class != LTT_UNION)
-              ||
-                (i >= t->element_number)
-             )) {
-      *name = 0;
-  } else {
-    *name = t->element_type[i]->element_name;
-    member_type = t->element_type[i];
-  }
-
-  return member_type;
-}
 
 /*****************************************************************************
  *Function name
@@ -314,14 +268,14 @@ LttType *ltt_type_member_type(LttType *t, unsigned i, GQuark *name)
  *    char *              : symbolic string associated with a value
  ****************************************************************************/
 
-GQuark ltt_enum_string_get(LttType *t, unsigned i)
+GQuark ltt_enum_string_get(LttType *t, gulong i)
 { 
-  if(likely(t->type_class == LTT_ENUM && i < t->element_number))
-    return t->enum_strings[i];
+  if(likely(t->type_class == LTT_ENUM))
+    return (GQuark)g_hash_table_lookup(t->enum_map, (gpointer)i);
   else
     return 0;
 }
-
+#if 0
 /*****************************************************************************
  *Function name
  *    ltt_field_element : obtain the field of nested elements for arrays and
@@ -342,6 +296,30 @@ LttField *ltt_field_element(LttField *f)
 
   return nest;
 }
+#endif//0
+
+/*****************************************************************************
+ *Function name
+ *    ltt_field_member_by_name  : obtain the field of data members for structure
+ *Input params
+ *    f                 : a field   
+ *    name              : name of the field
+ *Return value
+ *    LttField *       : the field of the nested element
+ ****************************************************************************/
+
+LttField *ltt_field_member_by_name(LttField *f, GQuark name)
+{
+  LttField *field_member;
+
+  g_assert(f->field_type.type_class == LTT_STRUCT ||
+              f->field_type.type_class == LTT_UNION);
+
+  field_member = g_datalist_id_get_data(&f->field_type.fields_by_name, name);
+
+  return field_member;
+}
+
 
 /*****************************************************************************
  *Function name
@@ -353,16 +331,15 @@ LttField *ltt_field_element(LttField *f)
  *    LttField *       : the field of the nested element
  ****************************************************************************/
 
-LttField *ltt_field_member(LttField *f, unsigned i)
+LttField *ltt_field_member(LttField *f, guint i)
 {
   LttField *field_member;
 
-  if(unlikely(   f->field_type->type_class != LTT_STRUCT
-                 && f->field_type->type_class != LTT_UNION)
-              || i >= f->field_type->element_number )
-    field_member = NULL;
-  else
-    field_member = f->child[i];
+  g_assert(f->field_type.type_class == LTT_STRUCT ||
+              f->field_type.type_class == LTT_UNION);
+  g_assert(i < f->field_type.fields->len);
+
+  field_member = &g_array_index(f->field_type.fields, LttField, i);
 
   return field_member;
 }
@@ -379,7 +356,7 @@ LttField *ltt_field_member(LttField *f, unsigned i)
 LttType *ltt_field_type(LttField *f)
 {
   if(unlikely(!f))return NULL;
-  return f->field_type;
+  return &f->field_type;
 }
 
 int ltt_field_size(LttField * f)
@@ -387,3 +364,60 @@ int ltt_field_size(LttField * f)
   if(unlikely(!f))return 0;
   return f->field_size;
 }
+
+
+/*****************************************************************************
+ *Function name
+ *    ltt_eventtype_num_fields : get the number of fields of the event
+ *Input params
+ *    e               : an instance of an event type
+ *Return value
+ *    guint           : number of fields
+ ****************************************************************************/
+
+guint ltt_eventtype_num_fields(LttEventType *event_type)
+{
+  if(unlikely(!event_type)) return 0;
+
+  return event_type->fields->len;
+  
+}
+/*****************************************************************************
+ *Function name
+ *    ltt_eventtype_field : get the i th field of the event
+ *Input params
+ *    e               : an instance of an event type
+ *    i               : field index
+ *Return value
+ *    LttField *      : The requested field, or NULL
+ ****************************************************************************/
+
+LttField *ltt_eventtype_field(LttEventType *event_type, guint i)
+{
+  if(unlikely(!event_type)) return NULL;
+
+  if(i >= event_type->fields->len) return NULL;
+  
+  return &g_array_index(event_type->fields, LttField, i);
+  
+}
+
+/*****************************************************************************
+ *Function name
+ *    ltt_eventtype_field_by_name : get a field of the event
+ *Input params
+ *    e               : an instance of an event type
+ *    name            : field name
+ *Return value
+ *    LttField *      : The requested field, or NULL
+ ****************************************************************************/
+
+LttField *ltt_eventtype_field_by_name(LttEventType *event_type, GQuark name)
+{
+  if(unlikely(!event_type)) return NULL;
+
+  return (LttField*)g_datalist_id_get_data(&event_type->fields_by_name, name);
+  
+}
+
+