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

#include <stdio.h>

#include <ltt/LTTTypes.h> 
#include "parser.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
 ****************************************************************************/

unsigned 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{
      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);	      
    }
  }
}

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