trunk/lttng-xenomai/LinuxTraceToolkitViewer-0.8.61-xenoltt/ltt/type.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2004 Xiangxiu Yang
   3  *               2005 Mathieu Desnoyers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License Version 2.1 as published by the Free Software Foundation.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <stdio.h>
  25 #include <glib.h>
  26
  27 #include "parser.h"
  28 #include <ltt/ltt.h>
  29 #include "ltt-private.h"
  30 #include <ltt/type.h>
  31
  32 static unsigned intSizes[] = {
  33   sizeof(int8_t), sizeof(int16_t), sizeof(int32_t), sizeof(int64_t),
  34   sizeof(short) };
  35
  36 typedef enum _intSizesNames { SIZE_INT8, SIZE_INT16, SIZE_INT32,
  37                               SIZE_INT64, SIZE_SHORT, INT_SIZES_NUMBER }
  38                    intSizesNames;
  39
  40
  41 static unsigned floatSizes[] = {
  42   0, 0, sizeof(float), sizeof(double), 0, sizeof(float), sizeof(double) };
  43
  44 #define FLOAT_SIZES_NUMBER 7
  45
  46
  47 /*****************************************************************************
  48  *Function name
  49  *    ltt_eventtype_name : get the name of the event type
  50  *Input params
  51  *    et                 : an  event type
  52  *Return value
  53  *    GQuark             : the name of the event type
  54  ****************************************************************************/
  55
  56 GQuark ltt_eventtype_name(LttEventType *et)
  57 {
  58   return et->name;
  59 }
  60
  61 /*****************************************************************************
  62  *Function name
  63  *    ltt_eventtype_description : get the description of the event type
  64  *Input params
  65  *    et                 : an  event type
  66  *Return value
  67  *    char *             : the description of the event type
  68  ****************************************************************************/
  69
  70 gchar *ltt_eventtype_description(LttEventType *et)
  71 {
  72   return et->description;
  73 }
  74
  75 /*****************************************************************************
  76  *Function name
  77  *    ltt_eventtype_facility : get the facility which contains the event type
  78  *Input params
  79  *    et                     : an  event type
  80  *Return value
  81  *    LttFacility *          : the facility
  82  ****************************************************************************/
  83
  84 LttFacility *ltt_eventtype_facility(LttEventType *et)
  85 {
  86   return et->facility;
  87 }
  88
  89 /*****************************************************************************
  90  *Function name
  91  *    ltt_eventtype_id : get the id of the event type
  92  *Input params
  93  *    et               : an  event type
  94  *Return value
  95  *    unsigned         : the id
  96  ****************************************************************************/
  97
  98 guint8 ltt_eventtype_id(LttEventType *et)
  99 {
 100   return et->index;
 101 }
 102
 103 /*****************************************************************************
 104  *Function name
 105  *    ltt_field_name  : get the name of the field
 106  *Input params
 107  *    f              : a field
 108  *Return value
 109  *    char *         : the name of the type
 110  ****************************************************************************/
 111
 112 GQuark ltt_field_name(LttField *f)
 113 {
 114   return f->name;
 115 }
 116 /*****************************************************************************
 117  *Function name
 118  *    ltt_type_class : get the type class of the type
 119  *Input params
 120  *    t              : a type
 121  *Return value
 122  *    LttTypeEnum  : the type class of the type
 123  ****************************************************************************/
 124
 125 LttTypeEnum ltt_type_class(LttType *t)
 126 {
 127   return t->type_class;
 128 }
 129
 130 /*****************************************************************************
 131  *Function name
 132  *    ltt_type_size : obtain the type size. The size is the number of bytes
 133  *                    for primitive types (INT, UINT, FLOAT, ENUM)
 134  *                    or the size for the unsigned integer length count for
 135  *                    sequences
 136  *Input params
 137  *    tf            : trace file
 138  *    t             : a type
 139  *Return value
 140  *                  : the type size
 141  *    returns 0 if erroneous, and show a critical warning message.
 142  ****************************************************************************/
 143
 144 guint ltt_type_size(LttTrace * trace, LttType *t)
 145 {
 146   guint size;
 147
 148   switch(t->type_class) {
 149     case LTT_INT_FIXED:
 150     case LTT_UINT_FIXED:
 151     case LTT_CHAR:
 152     case LTT_UCHAR:
 153     case LTT_SHORT:
 154     case LTT_USHORT:
 155     case LTT_INT:
 156     case LTT_UINT:
 157     case LTT_ENUM:
 158       if(likely(t->size < INT_SIZES_NUMBER))
 159         size = intSizes[t->size];
 160       else
 161         goto error;
 162       break;
 163     case LTT_FLOAT:
 164       if(likely(t->size < FLOAT_SIZES_NUMBER))
 165         size = floatSizes[t->size];
 166       else
 167         goto error;
 168       break;
 169     case LTT_POINTER:
 170     case LTT_LONG:
 171     case LTT_ULONG:
 172     case LTT_SIZE_T:
 173     case LTT_SSIZE_T:
 174     case LTT_SEQUENCE:
 175     case LTT_OFF_T:
 176     case LTT_STRING:
 177     case LTT_ARRAY:
 178     case LTT_STRUCT:
 179     case LTT_UNION:
 180     case LTT_NONE:
 181       goto error;
 182       break;
 183   }
 184
 185   return size;
 186
 187
 188 error:
 189   g_warning("no size known for the type");
 190   return 0;
 191 }
 192
 193 /*****************************************************************************
 194  *Function name
 195  *    ltt_type_element_type : obtain the type of nested elements for arrays
 196  *                            and sequences
 197  *Input params
 198  *    t                     : a type
 199  *Return value
 200  *    LttType              : the type of nested element of array or sequence
 201  ****************************************************************************/
 202
 203 LttType *ltt_type_element_type(LttType *t)
 204 {
 205   LttType *element_type;
 206   LttField *field;
 207
 208   if(unlikely(t->type_class != LTT_ARRAY && t->type_class != LTT_SEQUENCE))
 209     element_type = NULL;
 210   else {
 211     if(t->type_class == LTT_ARRAY)
 212       field = &g_array_index(t->fields, LttField, 0);
 213     else
 214       field = &g_array_index(t->fields, LttField, 1);
 215     element_type = ltt_field_type(field);
 216   }
 217
 218   return element_type;
 219 }
 220
 221 /*****************************************************************************
 222  *Function name
 223  *    ltt_type_element_number : obtain the number of elements for enums
 224  *Input params
 225  *    t                       : a type
 226  *Return value
 227  *    unsigned                : the number of elements for arrays
 228  ****************************************************************************/
 229 unsigned ltt_type_element_number(LttType *t)
 230 {
 231   unsigned ret = 0;
 232
 233   if(likely(t->type_class == LTT_ENUM))
 234     ret = g_hash_table_size(t->enum_map);
 235
 236   return ret;
 237 }
 238
 239 /*****************************************************************************
 240  *Function name
 241  *    ltt_type_member_number : obtain the number of data members for structure
 242  *Input params
 243  *    t                      : a type
 244  *Return value
 245  *    unsigned               : the number of members for structure
 246  ****************************************************************************/
 247
 248 unsigned ltt_type_member_number(LttType *t)
 249 {
 250   unsigned ret = 0;
 251
 252   if(likely(t->type_class == LTT_STRUCT || t->type_class == LTT_UNION))
 253     ret = t->fields->len;
 254
 255   return ret;
 256 }
 257
 258
 259 /*****************************************************************************
 260  *Function name
 261  *    ltt_enum_string_get : for enumerations, obtain the symbolic string
 262  *                          associated with a value (0 to n - 1 for an
 263  *                          enumeration of n elements)
 264  *Input params
 265  *    t                   : a type
 266  *    i                   : index of the member
 267  *Return value
 268  *    char *              : symbolic string associated with a value
 269  ****************************************************************************/
 270
 271 GQuark ltt_enum_string_get(LttType *t, gulong i)
 272 {
 273   if(likely(t->type_class == LTT_ENUM))
 274     return (GQuark)g_hash_table_lookup(t->enum_map, (gpointer)i);
 275   else
 276     return 0;
 277 }
 278 #if 0
 279 /*****************************************************************************
 280  *Function name
 281  *    ltt_field_element : obtain the field of nested elements for arrays and
 282  *                        sequence
 283  *Input params
 284  *    f                 : a field
 285  *Return value
 286  *    LttField *       : the field of the nested element
 287  ****************************************************************************/
 288
 289 LttField *ltt_field_element(LttField *f)
 290 {
 291   LttField *nest = NULL;
 292
 293   if(likely(f->field_type->type_class == LTT_ARRAY ||
 294               f->field_type->type_class == LTT_SEQUENCE))
 295     nest = f->child[0];
 296
 297   return nest;
 298 }
 299 #endif//0
 300
 301 /*****************************************************************************
 302  *Function name
 303  *    ltt_field_member_by_name  : obtain the field of data members for structure
 304  *Input params
 305  *    f                 : a field
 306  *    name              : name of the field
 307  *Return value
 308  *    LttField *       : the field of the nested element
 309  ****************************************************************************/
 310
 311 LttField *ltt_field_member_by_name(LttField *f, GQuark name)
 312 {
 313   LttField *field_member;
 314
 315   g_assert(f->field_type.type_class == LTT_STRUCT ||
 316               f->field_type.type_class == LTT_UNION);
 317
 318   field_member = g_datalist_id_get_data(&f->field_type.fields_by_name, name);
 319
 320   return field_member;
 321 }
 322
 323
 324 /*****************************************************************************
 325  *Function name
 326  *    ltt_field_member  : obtain the field of data members for structure
 327  *Input params
 328  *    f                 : a field
 329  *    i                 : index of member field
 330  *Return value
 331  *    LttField *       : the field of the nested element
 332  ****************************************************************************/
 333
 334 LttField *ltt_field_member(LttField *f, guint i)
 335 {
 336   LttField *field_member;
 337
 338   g_assert(f->field_type.type_class == LTT_STRUCT ||
 339               f->field_type.type_class == LTT_UNION);
 340   g_assert(i < f->field_type.fields->len);
 341
 342   field_member = &g_array_index(f->field_type.fields, LttField, i);
 343
 344   return field_member;
 345 }
 346
 347 /*****************************************************************************
 348  *Function name
 349  *    ltt_field_type  : obtain the type of the field
 350  *Input params
 351  *    f               : a field
 352  *Return value
 353  *    ltt_tyoe *      : the type of field
 354  ****************************************************************************/
 355
 356 LttType *ltt_field_type(LttField *f)
 357 {
 358   if(unlikely(!f))return NULL;
 359   return &f->field_type;
 360 }
 361
 362 int ltt_field_size(LttField * f)
 363 {
 364   if(unlikely(!f))return 0;
 365   return f->field_size;
 366 }
 367
 368
 369 /*****************************************************************************
 370  *Function name
 371  *    ltt_eventtype_num_fields : get the number of fields of the event
 372  *Input params
 373  *    e               : an instance of an event type
 374  *Return value
 375  *    guint           : number of fields
 376  ****************************************************************************/
 377
 378 guint ltt_eventtype_num_fields(LttEventType *event_type)
 379 {
 380   if(unlikely(!event_type)) return 0;
 381
 382   return event_type->fields->len;
 383
 384 }
 385 /*****************************************************************************
 386  *Function name
 387  *    ltt_eventtype_field : get the i th field of the event
 388  *Input params
 389  *    e               : an instance of an event type
 390  *    i               : field index
 391  *Return value
 392  *    LttField *      : The requested field, or NULL
 393  ****************************************************************************/
 394
 395 LttField *ltt_eventtype_field(LttEventType *event_type, guint i)
 396 {
 397   if(unlikely(!event_type)) return NULL;
 398
 399   if(i >= event_type->fields->len) return NULL;
 400
 401   return &g_array_index(event_type->fields, LttField, i);
 402
 403 }
 404
 405 /*****************************************************************************
 406  *Function name
 407  *    ltt_eventtype_field_by_name : get a field of the event
 408  *Input params
 409  *    e               : an instance of an event type
 410  *    name            : field name
 411  *Return value
 412  *    LttField *      : The requested field, or NULL
 413  ****************************************************************************/
 414
 415 LttField *ltt_eventtype_field_by_name(LttEventType *event_type, GQuark name)
 416 {
 417   if(unlikely(!event_type)) return NULL;
 418
 419   return (LttField*)g_datalist_id_get_data(&event_type->fields_by_name, name);
 420
 421 }
 422
 423