[lttv.git] / ltt / branches / poly / ltt / type.c

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2003-2004 Xiangxiu Yang, 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 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.
 */

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

size_t ltt_type_size(LttTrace * trace, LttType *t)
{
  size_t size;

  switch(t->type_class) {

    case LTT_INT:
    case LTT_UINT:
    case LTT_SEQUENCE:
    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_OFF_T:
    case LTT_STRING:
    case LTT_ARRAY:
    case LTT_STRUCT:
    case LTT_UNION:
      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 arrays 
 *Input params
 *    t                       : a type   
 *Return value
 *    unsigned                : the number of elements for arrays
 ****************************************************************************/
#if 0
unsigned ltt_type_element_number(LttType *t)
{
  unsigned ret = 0;

  if(likely(t->type_class == LTT_ARRAY))
    ret = t->element_number;

  return ret;
}
#endif //0
/*****************************************************************************
 *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 NULL;

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