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

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

#include <stdio.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) };

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


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

char *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
 ****************************************************************************/

char *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_relative_id : get the relative id of the event type
 *Input params
 *    et                        : an  event type   
 *Return value
 *    unsigned                  : the relative id
 ****************************************************************************/

unsigned ltt_eventtype_relative_id(LttEventType *et)
{
  return et->index;
}

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

unsigned ltt_eventtype_id(LttEventType *et)
{
  return et->facility->base_id + et->index;
}

/*****************************************************************************
 *Function name
 *    ltt_eventtype_type : get the type of the event type
 *Input params
 *    et                 : an  event type   
 *Return value
 *    LttType *         : the type of the event type
 ****************************************************************************/

LttType *ltt_eventtype_type(LttEventType *et)
{
  if(!et->root_field) return NULL;
  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   
 *Return value
 *    char *         : the name of the type
 ****************************************************************************/

char *ltt_type_name(LttType *t)
{
  return t->element_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
 *    unsigned      : the type size
 *    returns 0 if erroneous, and show a critical warning message.
 ****************************************************************************/

unsigned ltt_type_size(LttTrace * trace, LttType *t)
{
  if(t->type_class==LTT_STRUCT || t->type_class==LTT_ARRAY || 
     t->type_class==LTT_STRING || t->type_class==LTT_UNION) 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{
      LttArchSize size = trace->system_description->size;
      if(size == LTT_LP32){
	      if(t->size == 5)return sizeof(int16_t);
	      else return sizeof(int32_t);
      }
      else if(size == LTT_ILP32 || size == LTT_LP64){
	      if(t->size == 5)return sizeof(int32_t);
	      else{
	        if(size == LTT_ILP32) return sizeof(int32_t);
	        else return sizeof(int64_t);
	      }
      }
      else if(size == LTT_ILP64)return sizeof(int64_t);	      
    }
  }
  
  g_critical("ltt_type_size : Type size %u unknown", t->size);
  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)
{
  if(t->type_class != LTT_ARRAY && t->type_class != LTT_SEQUENCE)
    return NULL;
  return t->element_type[0];
}

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

unsigned ltt_type_element_number(LttType *t)
{
  if(t->type_class != LTT_ARRAY)
    return 0;
  return t->element_number;
}

/*****************************************************************************
 *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)
{
  if(t->type_class != LTT_STRUCT && t->type_class != LTT_UNION)
    return 0;
  return t->element_number;  
}

/*****************************************************************************
 *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, char ** name)
{
  if(t->type_class != LTT_STRUCT
      && t->type_class != LTT_UNION){*name = NULL; return NULL;}
  if(i >= t->element_number){*name = NULL; return NULL;}
  *name = t->element_type[i]->element_name;
  return t->element_type[i];
}

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

char *ltt_enum_string_get(LttType *t, unsigned i)
{  
  if(t->type_class != LTT_ENUM) return NULL;
  if(i >= t->element_number) return NULL;
  return t->enum_strings[i];
}

/*****************************************************************************
 *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)
{
  if(f->field_type->type_class != LTT_ARRAY &&
     f->field_type->type_class != LTT_SEQUENCE)
    return NULL;

  return f->child[0];
}

/*****************************************************************************
 *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, unsigned i)
{
  if(f->field_type->type_class != LTT_STRUCT
      && f->field_type->type_class != LTT_UNION) return NULL;
  if(i >= f->field_type->element_number) return NULL;
  return f->child[i];
}

/*****************************************************************************
 *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(!f)return NULL;
  return f->field_type;
}

int ltt_field_size(LttField * f)
{
  if(!f)return 0;
  return f->field_size;
}
Commit	Line	Data
	1	/* This file is part of the Linux Trace Toolkit viewer
	2	* Copyright (C) 2003-2004 Xiangxiu Yang
	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	#include <stdio.h>
	20
	21	#include "parser.h"
	22	#include <ltt/ltt.h>
	23	#include "ltt-private.h"
	24	#include <ltt/type.h>
	25
	26	static unsigned intSizes[] = {
	27	sizeof(int8_t), sizeof(int16_t), sizeof(int32_t), sizeof(int64_t),
	28	sizeof(short) };
	29
	30	static unsigned floatSizes[] = {
	31	0, 0, sizeof(float), sizeof(double), 0, sizeof(float), sizeof(double) };
	32
	33
	34	/*****************************************************************************
	35	*Function name
	36	* ltt_eventtype_name : get the name of the event type
	37	*Input params
	38	* et : an event type
	39	*Return value
	40	* char * : the name of the event type
	41	****************************************************************************/
	42
	43	char ltt_eventtype_name(LttEventType et)
	44	{
	45	return et->name;
	46	}
	47
	48	/*****************************************************************************
	49	*Function name
	50	* ltt_eventtype_description : get the description of the event type
	51	*Input params
	52	* et : an event type
	53	*Return value
	54	* char * : the description of the event type
	55	****************************************************************************/
	56
	57	char ltt_eventtype_description(LttEventType et)
	58	{
	59	return et->description;
	60	}
	61
	62	/*****************************************************************************
	63	*Function name
	64	* ltt_eventtype_facility : get the facility which contains the event type
	65	*Input params
	66	* et : an event type
	67	*Return value
	68	* LttFacility * : the facility
	69	****************************************************************************/
	70
	71	LttFacility ltt_eventtype_facility(LttEventType et)
	72	{
	73	return et->facility;
	74	}
	75
	76	/*****************************************************************************
	77	*Function name
	78	* ltt_eventtype_relative_id : get the relative id of the event type
	79	*Input params
	80	* et : an event type
	81	*Return value
	82	* unsigned : the relative id
	83	****************************************************************************/
	84
	85	unsigned ltt_eventtype_relative_id(LttEventType *et)
	86	{
	87	return et->index;
	88	}
	89
	90	/*****************************************************************************
	91	*Function name
	92	* ltt_eventtype_id : get the id of the event type
	93	*Input params
	94	* et : an event type
	95	*Return value
	96	* unsigned : the id
	97	****************************************************************************/
	98
	99	unsigned ltt_eventtype_id(LttEventType *et)
	100	{
	101	return et->facility->base_id + et->index;
	102	}
	103
	104	/*****************************************************************************
	105	*Function name
	106	* ltt_eventtype_type : get the type of the event type
	107	*Input params
	108	* et : an event type
	109	*Return value
	110	* LttType * : the type of the event type
	111	****************************************************************************/
	112
	113	LttType ltt_eventtype_type(LttEventType et)
	114	{
	115	if(!et->root_field) return NULL;
	116	return et->root_field->field_type;
	117	}
	118
	119	/*****************************************************************************
	120	*Function name
	121	* ltt_eventtype_field : get the root filed of the event type
	122	*Input params
	123	* et : an event type
	124	*Return value
	125	* LttField * : the root filed of the event type
	126	****************************************************************************/
	127
	128	LttField ltt_eventtype_field(LttEventType et)
	129	{
	130	return et->root_field;
	131	}
	132
	133	/*****************************************************************************
	134	*Function name
	135	* ltt_type_name : get the name of the type
	136	*Input params
	137	* t : a type
	138	*Return value
	139	* char * : the name of the type
	140	****************************************************************************/
	141
	142	char ltt_type_name(LttType t)
	143	{
	144	return t->element_name;
	145	}
	146
	147	/*****************************************************************************
	148	*Function name
	149	* ltt_type_class : get the type class of the type
	150	*Input params
	151	* t : a type
	152	*Return value
	153	* LttTypeEnum : the type class of the type
	154	****************************************************************************/
	155
	156	LttTypeEnum ltt_type_class(LttType *t)
	157	{
	158	return t->type_class;
	159	}
	160
	161	/*****************************************************************************
	162	*Function name
	163	* ltt_type_size : obtain the type size. The size is the number of bytes
	164	* for primitive types (INT, UINT, FLOAT, ENUM), or the
	165	* size for the unsigned integer length count for sequences
	166	*Input params
	167	* tf : trace file
	168	* t : a type
	169	*Return value
	170	* unsigned : the type size
	171	* returns 0 if erroneous, and show a critical warning message.
	172	****************************************************************************/
	173
	174	unsigned ltt_type_size(LttTrace * trace, LttType *t)
	175	{
	176	if(t->type_class==LTT_STRUCT \|\| t->type_class==LTT_ARRAY \|\|
	177	t->type_class==LTT_STRING \|\| t->type_class==LTT_UNION) return 0;
	178
	179	if(t->type_class == LTT_FLOAT){
	180	return floatSizes[t->size];
	181	}else{
	182	if(t->size < sizeof(intSizes)/sizeof(unsigned))
	183	return intSizes[t->size];
	184	else{
	185	LttArchSize size = trace->system_description->size;
	186	if(size == LTT_LP32){
	187	if(t->size == 5)return sizeof(int16_t);
	188	else return sizeof(int32_t);
	189	}
	190	else if(size == LTT_ILP32 \|\| size == LTT_LP64){
	191	if(t->size == 5)return sizeof(int32_t);
	192	else{
	193	if(size == LTT_ILP32) return sizeof(int32_t);
	194	else return sizeof(int64_t);
	195	}
	196	}
	197	else if(size == LTT_ILP64)return sizeof(int64_t);
	198	}
	199	}
	200
	201	g_critical("ltt_type_size : Type size %u unknown", t->size);
	202	return 0;
	203	}
	204
	205	/*****************************************************************************
	206	*Function name
	207	* ltt_type_element_type : obtain the type of nested elements for arrays
	208	* and sequences
	209	*Input params
	210	* t : a type
	211	*Return value
	212	* LttType : the type of nested element of array or sequence
	213	****************************************************************************/
	214
	215	LttType ltt_type_element_type(LttType t)
	216	{
	217	if(t->type_class != LTT_ARRAY && t->type_class != LTT_SEQUENCE)
	218	return NULL;
	219	return t->element_type[0];
	220	}
	221
	222	/*****************************************************************************
	223	*Function name
	224	* ltt_type_element_number : obtain the number of elements for arrays
	225	*Input params
	226	* t : a type
	227	*Return value
	228	* unsigned : the number of elements for arrays
	229	****************************************************************************/
	230
	231	unsigned ltt_type_element_number(LttType *t)
	232	{
	233	if(t->type_class != LTT_ARRAY)
	234	return 0;
	235	return t->element_number;
	236	}
	237
	238	/*****************************************************************************
	239	*Function name
	240	* ltt_type_member_number : obtain the number of data members for structure
	241	*Input params
	242	* t : a type
	243	*Return value
	244	* unsigned : the number of members for structure
	245	****************************************************************************/
	246
	247	unsigned ltt_type_member_number(LttType *t)
	248	{
	249	if(t->type_class != LTT_STRUCT && t->type_class != LTT_UNION)
	250	return 0;
	251	return t->element_number;
	252	}
	253
	254	/*****************************************************************************
	255	*Function name
	256	* ltt_type_member_type : obtain the type of a data member in a structure
	257	* or union.
	258	*Input params
	259	* t : a type
	260	* i : index of the member
	261	*Return value
	262	* LttType * : the type of structure member
	263	****************************************************************************/
	264
	265	LttType ltt_type_member_type(LttType t, unsigned i, char ** name)
	266	{
	267	if(t->type_class != LTT_STRUCT
	268	&& t->type_class != LTT_UNION){*name = NULL; return NULL;}
	269	if(i >= t->element_number){*name = NULL; return NULL;}
	270	*name = t->element_type[i]->element_name;
	271	return t->element_type[i];
	272	}
	273
	274	/*****************************************************************************
	275	*Function name
	276	* ltt_enum_string_get : for enumerations, obtain the symbolic string
	277	* associated with a value (0 to n - 1 for an
	278	* enumeration of n elements)
	279	*Input params
	280	* t : a type
	281	* i : index of the member
	282	*Return value
	283	* char * : symbolic string associated with a value
	284	****************************************************************************/
	285
	286	char ltt_enum_string_get(LttType t, unsigned i)
	287	{
	288	if(t->type_class != LTT_ENUM) return NULL;
	289	if(i >= t->element_number) return NULL;
	290	return t->enum_strings[i];
	291	}
	292
	293	/*****************************************************************************
	294	*Function name
	295	* ltt_field_element : obtain the field of nested elements for arrays and
	296	* sequence
	297	*Input params
	298	* f : a field
	299	*Return value
	300	* LttField * : the field of the nested element
	301	****************************************************************************/
	302
	303	LttField ltt_field_element(LttField f)
	304	{
	305	if(f->field_type->type_class != LTT_ARRAY &&
	306	f->field_type->type_class != LTT_SEQUENCE)
	307	return NULL;
	308
	309	return f->child[0];
	310	}
	311
	312	/*****************************************************************************
	313	*Function name
	314	* ltt_field_member : obtain the field of data members for structure
	315	*Input params
	316	* f : a field
	317	* i : index of member field
	318	*Return value
	319	* LttField * : the field of the nested element
	320	****************************************************************************/
	321
	322	LttField ltt_field_member(LttField f, unsigned i)
	323	{
	324	if(f->field_type->type_class != LTT_STRUCT
	325	&& f->field_type->type_class != LTT_UNION) return NULL;
	326	if(i >= f->field_type->element_number) return NULL;
	327	return f->child[i];
	328	}
	329
	330	/*****************************************************************************
	331	*Function name
	332	* ltt_field_type : obtain the type of the field
	333	*Input params
	334	* f : a field
	335	*Return value
	336	* ltt_tyoe * : the type of field
	337	****************************************************************************/
	338
	339	LttType ltt_field_type(LttField f)
	340	{
	341	if(!f)return NULL;
	342	return f->field_type;
	343	}
	344
	345	int ltt_field_size(LttField * f)
	346	{
	347	if(!f)return 0;
	348	return f->field_size;
	349	}