[lttv.git] / trunk / lttng-xenomai / LinuxTraceToolkitViewer-0.8.61-xenoltt / ltt / type.c

/* 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 <config.h>
#endif

#include <stdio.h>
#include <glib.h>

#include "parser.h"
#include <ltt/ltt.h>
#include "ltt-private.h"
#include <ltt/type.h>

static unsigned intSizes[] = {
  sizeof(int8_t), sizeof(int16_t), sizeof(int32_t), sizeof(int64_t), 
  sizeof(short) };

typedef enum _intSizesNames { SIZE_INT8, SIZE_INT16, SIZE_INT32,
                              SIZE_INT64, SIZE_SHORT, INT_SIZES_NUMBER }
                   intSizesNames;


static unsigned floatSizes[] = {
  0, 0, sizeof(float), sizeof(double), 0, sizeof(float), sizeof(double) };

#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
 *    GQuark             : the name of the event type
 ****************************************************************************/

GQuark ltt_eventtype_name(LttEventType *et)
{
  return et->name;
}

/*****************************************************************************
 *Function name
 *    ltt_eventtype_description : get the description of the event type
 *Input params
 *    et                 : an  event type   
 *Return value
 *    char *             : the description of the event type
 ****************************************************************************/

gchar *ltt_eventtype_description(LttEventType *et)
{
  return et->description;
}

/*****************************************************************************
 *Function name
 *    ltt_eventtype_facility : get the facility which contains the event type
 *Input params
 *    et                     : an  event type   
 *Return value
 *    LttFacility *          : the facility
 ****************************************************************************/

LttFacility *ltt_eventtype_facility(LttEventType *et)
{
  return et->facility;
}

/*****************************************************************************
 *Function name
 *    ltt_eventtype_id : get the id of the event type
 *Input params
 *    et               : an  event type   
 *Return value
 *    unsigned         : the id
 ****************************************************************************/

guint8 ltt_eventtype_id(LttEventType *et)
{
  return et->index;
}

/*****************************************************************************
 *Function name
 *    ltt_field_name  : get the name of the field
 *Input params
 *    f              : a field
 *Return value
 *    char *         : the name of the type
 ****************************************************************************/

GQuark ltt_field_name(LttField *f)
{
  return f->name;
}
/*****************************************************************************
 *Function name
 *    ltt_type_class : get the type class of the type
 *Input params
 *    t              : a type   
 *Return value
 *    LttTypeEnum  : the type class of the type
 ****************************************************************************/

LttTypeEnum ltt_type_class(LttType *t)
{
  return t->type_class;
}

/*****************************************************************************
 *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
 *Input params
 *    tf            : trace file
 *    t             : a type   
 *Return value
 *                  : the type size
 *    returns 0 if erroneous, and show a critical warning message.
 ****************************************************************************/

guint ltt_type_size(LttTrace * trace, LttType *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;
}

/*****************************************************************************
 *Function name
 *    ltt_type_element_type : obtain the type of nested elements for arrays 
 *                            and sequences 
 *Input params
 *    t                     : a type   
 *Return value
 *    LttType              : the type of nested element of array or sequence
 ****************************************************************************/

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 {
    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 enums
 *Input params
 *    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_ENUM))
    ret = g_hash_table_size(t->enum_map);

  return ret;
}

/*****************************************************************************
 *Function name
 *    ltt_type_member_number : obtain the number of data members for structure 
 *Input params
 *    t                      : a type   
 *Return value
 *    unsigned               : the number of members for structure
 ****************************************************************************/

unsigned ltt_type_member_number(LttType *t)
{
  unsigned ret = 0;
  
  if(likely(t->type_class == LTT_STRUCT || t->type_class == LTT_UNION))
    ret = t->fields->len;

  return ret;
}


/*****************************************************************************
 *Function name
 *    ltt_enum_string_get : for enumerations, obtain the symbolic string 
 *                          associated with a value (0 to n - 1 for an 
 *                          enumeration of n elements) 
 *Input params
 *    t                   : a type   
 *    i                   : index of the member
 *Return value
 *    char *              : symbolic string associated with a value
 ****************************************************************************/

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
 *                        sequence 
 *Input params
 *    f                 : a field   
 *Return value
 *    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
 ****************************************************************************/

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
 *    ltt_field_member  : obtain the field of data members for structure
 *Input params
 *    f                 : a field   
 *    i                 : index of member field
 *Return value
 *    LttField *       : the field of the nested element
 ****************************************************************************/

LttField *ltt_field_member(LttField *f, guint i)
{
  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;
}

/*****************************************************************************
 *Function name
 *    ltt_field_type  : obtain the type of the field 
 *Input params
 *    f               : a field   
 *Return value
 *    ltt_tyoe *      : the type of field
 ****************************************************************************/

LttType *ltt_field_type(LttField *f)
{
  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);
  
}
Commit	Line	Data
03d7fdf3	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