X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftype.c;h=df1b8ea805d52c4edc90e064d52b9d2f1455c93c;hb=3c165eaf5aa1e60ce88c036cfb692ce3e1d81585;hp=34a7b5d6a8dea3fe4c2c456270ce244a6bf3ad15;hpb=fcdf0ec203524819d926c57c9aa4d2fb6a268ca1;p=lttv.git diff --git a/ltt/branches/poly/ltt/type.c b/ltt/branches/poly/ltt/type.c index 34a7b5d6..df1b8ea8 100644 --- a/ltt/branches/poly/ltt/type.c +++ b/ltt/branches/poly/ltt/type.c @@ -1,7 +1,32 @@ +/* This file is part of the Linux Trace Toolkit viewer + * Copyright (C) 2003-2004 Xiangxiu Yang + * 2005 Mathieu Desnoyers + * + * 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 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 + * Lesser General Public License for more details. + * + * 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 +#include +#endif + #include +#include -#include #include "parser.h" +#include +#include "ltt-private.h" #include static unsigned intSizes[] = { @@ -12,16 +37,29 @@ static unsigned floatSizes[] = { 0, 0, sizeof(float), sizeof(double), 0, sizeof(float), sizeof(double) }; +typedef enum _intSizesNames { SIZE_INT8, SIZE_INT16, SIZE_INT32, + SIZE_INT64, SIZE_SHORT, INT_SIZES_NUMBER } + intSizesNames; + +static char * typeNames[] = { + "int_fixed", "uint_fixed", "pointer", "char", "uchar", "short", "ushort", + "int", "uint", "long", "ulong", "size_t", "ssize_t", "off_t", "float", + "string", "enum", "array", "sequence", "struct", "union", "none" }; + + +#define FLOAT_SIZES_NUMBER 7 + + /***************************************************************************** *Function name * ltt_eventtype_name : get the name of the event type *Input params * et : an event type *Return value - * char * : the name of the event type + * GQuark : the name of the event type ****************************************************************************/ -char *ltt_eventtype_name(ltt_eventtype *et) +GQuark ltt_eventtype_name(LttEventType *et) { return et->name; } @@ -35,37 +73,51 @@ char *ltt_eventtype_name(ltt_eventtype *et) * char * : the description of the event type ****************************************************************************/ -char *ltt_eventtype_description(ltt_eventtype *et) +gchar *ltt_eventtype_description(LttEventType *et) { return et->description; } /***************************************************************************** *Function name - * ltt_eventtype_type : get the type of the event type + * ltt_eventtype_id : get the id of the event type *Input params - * et : an event type + * et : an event type *Return value - * ltt_type * : the type of the event type + * unsigned : the id ****************************************************************************/ -ltt_type *ltt_eventtype_type(ltt_eventtype *et) +guint8 ltt_eventtype_id(LttEventType *et) { - return et->root_field->field_type; + return et->index; } /***************************************************************************** *Function name * ltt_type_name : get the name of the type *Input params - * t : a type + * t : a type + *Return value + * GQuark : the name of the type + ****************************************************************************/ + +GQuark ltt_type_name(LttType *t) +{ + return g_quark_from_static_string(typeNames[t->type_class]); +} + +/***************************************************************************** + *Function name + * ltt_field_name : get the name of the field + *Input params + * f : a field *Return value * char * : the name of the type ****************************************************************************/ -char *ltt_type_name(ltt_type *t) +GQuark ltt_field_name(LttField *f) { - return t->element_name; + return f->name; } /***************************************************************************** @@ -74,10 +126,10 @@ char *ltt_type_name(ltt_type *t) *Input params * t : a type *Return value - * ltt_type_enum : the type class of the type + * LttTypeEnum : the type class of the type ****************************************************************************/ -ltt_type_enum ltt_type_class(ltt_type *t) +LttTypeEnum ltt_type_class(LttType *t) { return t->type_class; } @@ -85,35 +137,64 @@ ltt_type_enum ltt_type_class(ltt_type *t) /***************************************************************************** *Function name * ltt_type_size : obtain the type size. The size is the number of bytes - * for primitive types (INT, UINT, FLOAT, ENUM), or the - * size for the unsigned integer length count for sequences + * for primitive types (INT, UINT, FLOAT, ENUM) + * or the size for the unsigned integer length count for + * sequences *Input params * tf : trace file * t : a type *Return value - * unsigned : the type size + * : the type size + * returns 0 if erroneous, and show a critical warning message. ****************************************************************************/ -unsigned ltt_type_size(ltt_tracefile * tf, ltt_type *t) +guint ltt_type_size(LttTrace * trace, LttType *t) { - if(t->type_class==LTT_STRUCT || t->type_class==LTT_ARRAY || - t->type_class==LTT_STRING) return 0; - - if(t->type_class == LTT_FLOAT){ - return floatSizes[t->size]; - }else{ - if(t->size < sizeof(intSizes)/sizeof(unsigned)) - return intSizes[t->size]; - else{ - ltt_arch_size size = tf->trace_header->arch_size; - if(size == LTT_LP32) - return sizeof(int16_t); - else if(size == LTT_ILP32 || size == LTT_LP64) - return sizeof(int32_t); - else if(size == LTT_ILP64) - return sizeof(int64_t); - } + 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_ENUM: + if(likely(t->size < INT_SIZES_NUMBER)) + size = intSizes[t->size]; + else + goto error; + break; + case LTT_FLOAT: + if(likely(t->size < FLOAT_SIZES_NUMBER)) + size = floatSizes[t->size]; + else + goto error; + break; + case LTT_POINTER: + case LTT_LONG: + 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; } + + return size; + + +error: + g_warning("no size known for the type"); + return 0; } /***************************************************************************** @@ -123,30 +204,44 @@ unsigned ltt_type_size(ltt_tracefile * tf, ltt_type *t) *Input params * t : a type *Return value - * ltt_type : the type of nested element of array or sequence + * LttType : the type of nested element of array or sequence ****************************************************************************/ -ltt_type *ltt_type_element_type(ltt_type *t) +LttType *ltt_type_element_type(LttType *t) { - if(t->type_class != LTT_ARRAY || t->type_class != LTT_SEQUENCE) - return NULL; - return t->element_type[0]; + LttType *element_type; + LttField *field; + + if(unlikely(t->type_class != LTT_ARRAY && t->type_class != LTT_SEQUENCE)) + element_type = NULL; + 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(ltt_type *t) +unsigned ltt_type_element_number(LttType *t) { - if(t->type_class != LTT_ARRAY) - return 0; - return t->element_number; + unsigned ret = 0; + + if(likely(t->type_class == LTT_ENUM)) + // Permits non full enums ret = g_hash_table_size(t->enum_map); + ret = (unsigned)(t->highest_value - t->lowest_value); + + return ret; } /***************************************************************************** @@ -158,30 +253,17 @@ unsigned ltt_type_element_number(ltt_type *t) * unsigned : the number of members for structure ****************************************************************************/ -unsigned ltt_type_member_number(ltt_type *t) +unsigned ltt_type_member_number(LttType *t) { - if(t->type_class != LTT_STRUCT) - return 0; - return t->element_number; -} - -/***************************************************************************** - *Function name - * ltt_type_member_type : obtain the type of a data members in a structure - *Input params - * t : a type - * i : index of the member - *Return value - * ltt_type * : the type of structure member - ****************************************************************************/ + unsigned ret = 0; + + if(likely(t->type_class == LTT_STRUCT || t->type_class == LTT_UNION)) + ret = t->fields->len; -ltt_type *ltt_type_member_type(ltt_type *t, unsigned i) -{ - if(t->type_class != LTT_STRUCT) return NULL; - if(i > t->element_number || i == 0 ) return NULL; - return t->element_type[i-1]; + return ret; } + /***************************************************************************** *Function name * ltt_enum_string_get : for enumerations, obtain the symbolic string @@ -194,13 +276,14 @@ ltt_type *ltt_type_member_type(ltt_type *t, unsigned i) * char * : symbolic string associated with a value ****************************************************************************/ -char *ltt_enum_string_get(ltt_type *t, unsigned i) -{ - if(t->type_class != LTT_ENUM) return NULL; - if(i > t->element_number || i == 0 ) return NULL; - return t->enum_strings[i-1]; +GQuark ltt_enum_string_get(LttType *t, gulong 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 @@ -208,33 +291,65 @@ char *ltt_enum_string_get(ltt_type *t, unsigned i) *Input params * f : a field *Return value - * ltt_field * : the field of the nested element + * LttField * : the field of the nested element + ****************************************************************************/ + +LttField *ltt_field_element(LttField *f) +{ + LttField *nest = NULL; + + if(likely(f->field_type->type_class == LTT_ARRAY || + f->field_type->type_class == LTT_SEQUENCE)) + nest = f->child[0]; + + 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 ****************************************************************************/ -ltt_field *ltt_field_element(ltt_field *f) +LttField *ltt_field_member_by_name(LttField *f, GQuark name) { - if(f->field_type->type_class != LTT_ARRAY || - f->field_type->type_class != LTT_SEQUENCE) - return NULL; + LttField *field_member; + + g_assert(f->field_type.type_class == LTT_STRUCT || + f->field_type.type_class == LTT_UNION); - return f->child[0]; + field_member = g_datalist_id_get_data(&f->field_type.fields_by_name, name); + + return field_member; } + /***************************************************************************** *Function name - * ltt_field_member : obtain the filed of data members for structure + * ltt_field_member : obtain the field of data members for structure *Input params * f : a field * i : index of member field *Return value - * ltt_field * : the field of the nested element + * LttField * : the field of the nested element ****************************************************************************/ -ltt_field *ltt_field_member(ltt_field *f, unsigned i) +LttField *ltt_field_member(LttField *f, guint i) { - if(f->field_type->type_class != LTT_STRUCT) return NULL; - if(i==0 || i>f->field_type->element_number) return NULL; - return f->child[i-1]; + LttField *field_member; + + 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; } /***************************************************************************** @@ -246,8 +361,71 @@ ltt_field *ltt_field_member(ltt_field *f, unsigned i) * ltt_tyoe * : the type of field ****************************************************************************/ -ltt_type *ltt_field_type(ltt_field *f) +LttType *ltt_field_type(LttField *f) { - return f->field_type; + if(unlikely(!f))return NULL; + return &f->field_type; } +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); + +} + +