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

#include <stdio.h>
#include <asm/types.h>
#include <linux/byteorder/swab.h>
#include <ltt/LTTTypes.h> 
#include "parser.h"
#include <ltt/event.h>

/*****************************************************************************
 *Function name
 *    ltt_event_refresh_fields   : refresh fields of an event 
 *Input params
 *    offsetRoot      : offset from the root
 *    offsetParent    : offset from the parrent
 *    fld             : field
 *    evD             : event data
 *Return value
 *    int             : size of the field
 ****************************************************************************/

int ltt_event_refresh_fields(int offsetRoot,int offsetParent, 
			     LttField * fld, void *evD)
{
  int size, size1, element_number, i, offset1, offset2;
  LttType * type = fld->field_type;

  if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY &&
     type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){
    size = fld->field_size;
  }else if(type->type_class == LTT_ARRAY){
    element_number = (int) type->element_number;
    if(fld->field_fixed == 0){// has string or sequence
      size = 0;
      for(i=0;i<element_number;i++){
	size += ltt_event_refresh_fields(offsetRoot+size,size, 
					 fld->child[0], evD+size);
      }      
    }else size = fld->field_size;
  }else if(type->type_class == LTT_SEQUENCE){
    size1 = fld->sequ_number_size;
    element_number = getIntNumber(size1,evD);
    type->element_number = element_number;
    if(fld->element_size > 0){
      size = element_number * fld->element_size;
    }else{//sequence has string or sequence
      size = 0;
      for(i=0;i<element_number;i++){
	size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1, 
					 fld->child[0], evD+size+size1);
      }	
      size += size1;
    }
  }else if(type->type_class == LTT_STRING){
    size = strlen((char*)evD) + 1; //include end : '\0'
  }else if(type->type_class == LTT_STRUCT){
    element_number = (int) type->element_number;
    if(fld->field_fixed == 0){
      offset1 = offsetRoot;
      offset2 = 0;
      for(i=0;i<element_number;i++){
	size=ltt_event_refresh_fields(offset1,offset2,fld->child[i],evD+offset2);
	offset1 += size;
	offset2 += size;
      }      
      size = offset2;
    }else size = fld->field_size;
  }

  fld->offset_root     = offsetRoot;
  fld->offset_parent   = offsetParent;
  fld->fixed_root      = (offsetRoot==-1)   ? 0 : 1;
  fld->fixed_parent    = (offsetParent==-1) ? 0 : 1;
  fld->field_size      = size;

  return size;
}

/*****************************************************************************
 *Function name
 *    ltt_event_eventtype_id: get event type id 
 *                            (base id + position of the event)
 *Input params
 *    e                     : an instance of an event type   
 *Return value
 *    unsigned              : event type id
 ****************************************************************************/

unsigned ltt_event_eventtype_id(LttEvent *e)
{
  return (unsigned) e->event_id;
}

/*****************************************************************************
 *Function name
 *    ltt_event_facility : get the facility of the event
 *Input params
 *    e                  : an instance of an event type   
 *Return value
 *    LttFacility *     : the facility of the event
 ****************************************************************************/

LttFacility *ltt_event_facility(LttEvent *e)
{
  LttTrace * trace = e->tracefile->trace;
  unsigned id = e->event_id;
  return ltt_trace_facility_by_id(trace,id);
}

/*****************************************************************************
 *Function name
 *    ltt_event_eventtype : get the event type of the event
 *Input params
 *    e                   : an instance of an event type   
 *Return value
 *    LttEventType *     : the event type of the event
 ****************************************************************************/

LttEventType *ltt_event_eventtype(LttEvent *e)
{
  LttFacility* facility = ltt_event_facility(e);
  if(!facility) return NULL;
  return facility->events[e->event_id - facility->base_id];
}

/*****************************************************************************
 *Function name
 *    ltt_event_field : get the root field of the event
 *Input params
 *    e               : an instance of an event type   
 *Return value
 *    LttField *      : the root field of the event
 ****************************************************************************/

LttField *ltt_event_field(LttEvent *e)
{
  LttField * field;
  LttEventType * event_type = ltt_event_eventtype(e);
  if(!event_type) return NULL;
  field = event_type->root_field;

  //check if the field need refresh
  if(e->which_block != event_type->latest_block ||
     e->which_event != event_type->latest_event){

    event_type->latest_block = e->which_block;
    event_type->latest_event = e->which_event;
    
    if(field->field_fixed == 1)return field;

    //refresh the field
    ltt_event_refresh_fields(0, 0, field, e->data);    
  }
  return field;
}

/*****************************************************************************
 *Function name
 *    ltt_event_time : get the time of the event
 *Input params
 *    e              : an instance of an event type   
 *Return value
 *    LttTime       : the time of the event
 ****************************************************************************/

LttTime ltt_event_time(LttEvent *e)
{
  return e->event_time;
}

/*****************************************************************************
 *Function name
 *    ltt_event_time : get the cycle count of the event
 *Input params
 *    e              : an instance of an event type   
 *Return value
 *    LttCycleCount  : the cycle count of the event
 ****************************************************************************/

LttCycleCount ltt_event_cycle_count(LttEvent *e)
{
  return e->event_cycle_count;
}

/*****************************************************************************
 *Function name
 *    ltt_event_cpu_i: get the cpu id where the event happens
 *Input params
 *    e              : an instance of an event type   
 *Return value
 *    unsigned       : the cpu id
 ****************************************************************************/

unsigned ltt_event_cpu_id(LttEvent *e)
{  
  return (unsigned)atoi(e->tracefile->name);
}

/*****************************************************************************
 *Function name
 *    ltt_event_data : get the raw data for the event
 *Input params
 *    e              : an instance of an event type   
 *Return value
 *    void *         : pointer to the raw data for the event
 ****************************************************************************/

void *ltt_event_data(LttEvent *e)
{
  return e->data;
}

/*****************************************************************************
 *Function name
 *    ltt_event_field_element_number
 *                   : The number of elements in a sequence field is specific
 *                     to each event. This function returns the number of 
 *                     elements for an array or sequence field in an event.
 *Input params
 *    e              : an instance of an event type
 *    f              : a field of the instance
 *Return value
 *    unsigned       : the number of elements for an array/sequence field
 ****************************************************************************/

unsigned ltt_event_field_element_number(LttEvent *e, LttField *f)
{
  if(f->field_type->type_class != LTT_ARRAY &&
     f->field_type->type_class != LTT_SEQUENCE)
    return 0;
  
  if(f->field_type->type_class == LTT_ARRAY)
    return f->field_type->element_number;
  return (unsigned)  getIntNumber(f->sequ_number_size, e + f->offset_root);
}

/*****************************************************************************
 *Function name
 *    ltt_event_field_element_select
 *                   : Set the currently selected element for a sequence or
 *                     array field
 *Input params
 *    e              : an instance of an event type
 *    f              : a field of the instance
 *    i              : the ith element
 ****************************************************************************/

void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i)
{
  unsigned element_number;
  LttField *fld;
  int k, size;
  void *evD;
 
  if(f->field_type->type_class != LTT_ARRAY &&
     f->field_type->type_class != LTT_SEQUENCE)
    return ;

  element_number  = ltt_event_field_element_number(e,f);
  if((element_number-1) < i || i < 0) return;
  
  fld = f->child[0];
  
  evD = e->data + f->offset_root;
  size = 0;
  for(k=0;k<i;k++){
    size += ltt_event_refresh_fields(f->offset_root+size,size, fld, evD+size);
  }

  f->current_element = i - 1;
}

/*****************************************************************************
 * These functions extract data from an event after architecture specific
 * conversions
 ****************************************************************************/

unsigned ltt_event_get_unsigned(LttEvent *e, LttField *f)
{
  int revFlag = e->tracefile->trace->my_arch_endian == 
                e->tracefile->trace->system_description->endian ? 0:1;
  LttTypeEnum t = f->field_type->type_class;

  if(t != LTT_UINT && t != LTT_ENUM)
    g_error("The type of the field is not unsigned int\n");

  if(f->field_size == 1){
    uint8_t x = *(uint8_t*)(e->data + f->offset_root);
    return (unsigned int) x;    
  }else if(f->field_size == 2){
    uint16_t x = *(uint16_t*)(e->data + f->offset_root);
    return (unsigned int) (revFlag ? BREV16(x): x);    
  }else if(f->field_size == 4){
    uint32_t x = *(uint32_t*)(e->data + f->offset_root);
    return (unsigned int) (revFlag ? BREV32(x): x);    
  }else if(f->field_size == 8){
    uint64_t x = *(uint64_t*)(e->data + f->offset_root);
    return (unsigned int) (revFlag ? BREV64(x): x);    
  }
}

int ltt_event_get_int(LttEvent *e, LttField *f)
{
  int revFlag = e->tracefile->trace->my_arch_endian == 
                e->tracefile->trace->system_description->endian ? 0:1;

  if(f->field_type->type_class != LTT_INT)
    g_error("The type of the field is not int\n");

  if(f->field_size == 1){
    int8_t x = *(int8_t*)(e->data + f->offset_root);
    return (int) x;    
  }else if(f->field_size == 2){
    int16_t x = *(int16_t*)(e->data + f->offset_root);
    return (int) (revFlag ? BREV16(x): x);    
  }else if(f->field_size == 4){
    int32_t x = *(int32_t*)(e->data + f->offset_root);
    return (int) (revFlag ? BREV32(x): x);    
  }else if(f->field_size == 8){
    int64_t x = *(int64_t*)(e->data + f->offset_root);
    return (int) (revFlag ? BREV64(x): x);    
  }
}

unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
{
  int revFlag = e->tracefile->trace->my_arch_endian == 
                e->tracefile->trace->system_description->endian ? 0:1;
  LttTypeEnum t = f->field_type->type_class;

  if(t != LTT_UINT && t != LTT_ENUM)
    g_error("The type of the field is not unsigned long\n");

  if(f->field_size == 1){
    uint8_t x = *(uint8_t*)(e->data + f->offset_root);
    return (unsigned long) x;    
  }else if(f->field_size == 2){
    uint16_t x = *(uint16_t*)(e->data + f->offset_root);
    return (unsigned long) (revFlag ? BREV16(x): x);    
  }else if(f->field_size == 4){
    uint32_t x = *(uint32_t*)(e->data + f->offset_root);
    return (unsigned long) (revFlag ? BREV32(x): x);    
  }else if(f->field_size == 8){
    uint64_t x = *(uint64_t*)(e->data + f->offset_root);
    return (unsigned long) (revFlag ? BREV64(x): x);    
  }
}

long int ltt_event_get_long_int(LttEvent *e, LttField *f)
{
  int revFlag = e->tracefile->trace->my_arch_endian == 
                e->tracefile->trace->system_description->endian ? 0:1;

  if( f->field_type->type_class != LTT_INT)
    g_error("The type of the field is not long int\n");

  if(f->field_size == 1){
    int8_t x = *(int8_t*)(e->data + f->offset_root);
    return (long) x;    
  }else if(f->field_size == 2){
    int16_t x = *(int16_t*)(e->data + f->offset_root);
    return (long) (revFlag ? BREV16(x): x);    
  }else if(f->field_size == 4){
    int32_t x = *(int32_t*)(e->data + f->offset_root);
    return (long) (revFlag ? BREV32(x): x);    
  }else if(f->field_size == 8){
    int64_t x = *(int64_t*)(e->data + f->offset_root);
    return (long) (revFlag ? BREV64(x): x);    
  }
}

float ltt_event_get_float(LttEvent *e, LttField *f)
{
  int revFlag = e->tracefile->trace->my_arch_endian == 
                e->tracefile->trace->system_description->endian ? 0:1;

  if(f->field_type->type_class != LTT_FLOAT || 
     (f->field_type->type_class == LTT_FLOAT && f->field_size != 4))
    g_error("The type of the field is not float\n");

  if(revFlag == 0) return *(float *)(e->data + f->offset_root);
  else{
    uint32_t aInt;
    memcpy((void*)&aInt, e->data + f->offset_root, 4);
    aInt = ___swab32(aInt);
    return *((float*)&aInt);
  }
}

double ltt_event_get_double(LttEvent *e, LttField *f)
{
  int revFlag = e->tracefile->trace->my_arch_endian == 
                e->tracefile->trace->system_description->endian ? 0:1;

  if(f->field_type->type_class != LTT_FLOAT || 
     (f->field_type->type_class == LTT_FLOAT && f->field_size != 8))
    g_error("The type of the field is not double\n");

  if(revFlag == 0) return *(double *)(e->data + f->offset_root);
  else{
    uint64_t aInt;
    memcpy((void*)&aInt, e->data + f->offset_root, 8);
    aInt = ___swab64(aInt);
    return *((double *)&aInt);
  }
}

/*****************************************************************************
 * The string obtained is only valid until the next read from
 * the same tracefile.
 ****************************************************************************/

char *ltt_event_get_string(LttEvent *e, LttField *f)
{
  if(f->field_type->type_class != LTT_STRING)
    g_error("The field contains no string\n");
  return (char*)g_strdup((char*)(e->data + f->offset_root));
}
Commit	Line	Data
6cd62ccf	1	#include <stdio.h>
	2	#include <asm/types.h>
	3	#include <linux/byteorder/swab.h>
fcdf0ec2	4	#include <ltt/LTTTypes.h>
6cd62ccf	5	#include "parser.h"
	6	#include <ltt/event.h>
	7
908f42fa	8	/*****************************************************************************
	9	*Function name
	10	* ltt_event_refresh_fields : refresh fields of an event
	11	*Input params
	12	* offsetRoot : offset from the root
	13	* offsetParent : offset from the parrent
	14	* fld : field
	15	* evD : event data
	16	*Return value
	17	* int : size of the field
	18	****************************************************************************/
	19
	20	int ltt_event_refresh_fields(int offsetRoot,int offsetParent,
	21	LttField * fld, void *evD)
	22	{
	23	int size, size1, element_number, i, offset1, offset2;
	24	LttType * type = fld->field_type;
	25
	26	if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY &&
	27	type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){
	28	size = fld->field_size;
	29	}else if(type->type_class == LTT_ARRAY){
	30	element_number = (int) type->element_number;
	31	if(fld->field_fixed == 0){// has string or sequence
	32	size = 0;
	33	for(i=0;i<element_number;i++){
	34	size += ltt_event_refresh_fields(offsetRoot+size,size,
	35	fld->child[0], evD+size);
	36	}
	37	}else size = fld->field_size;
	38	}else if(type->type_class == LTT_SEQUENCE){
	39	size1 = fld->sequ_number_size;
	40	element_number = getIntNumber(size1,evD);
	41	type->element_number = element_number;
	42	if(fld->element_size > 0){
	43	size = element_number * fld->element_size;
	44	}else{//sequence has string or sequence
	45	size = 0;
	46	for(i=0;i<element_number;i++){
	47	size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1,
	48	fld->child[0], evD+size+size1);
	49	}
	50	size += size1;
	51	}
	52	}else if(type->type_class == LTT_STRING){
	53	size = strlen((char*)evD) + 1; //include end : '\0'
	54	}else if(type->type_class == LTT_STRUCT){
	55	element_number = (int) type->element_number;
	56	if(fld->field_fixed == 0){
	57	offset1 = offsetRoot;
	58	offset2 = 0;
	59	for(i=0;i<element_number;i++){
	60	size=ltt_event_refresh_fields(offset1,offset2,fld->child[i],evD+offset2);
	61	offset1 += size;
	62	offset2 += size;
	63	}
	64	size = offset2;
	65	}else size = fld->field_size;
	66	}
	67
	68	fld->offset_root = offsetRoot;
	69	fld->offset_parent = offsetParent;
	70	fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
	71	fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
72	fld->field_size = size;
73
74	return size;
75	}
76
6cd62ccf	77	/*****************************************************************************
6cd62ccf	78	*Function name
963b5f2d	79	* ltt_event_eventtype_id: get event type id
963b5f2d	80	* (base id + position of the event)
6cd62ccf	81	*Input params
963b5f2d	82	* e : an instance of an event type
6cd62ccf	83	*Return value
963b5f2d	84	* unsigned : event type id
6cd62ccf	85	****************************************************************************/
6cd62ccf	86
963b5f2d	87	unsigned ltt_event_eventtype_id(LttEvent *e)
6cd62ccf	88	{
	89	return (unsigned) e->event_id;
	90	}
	91
	92	/*****************************************************************************
	93	*Function name
	94	* ltt_event_facility : get the facility of the event
	95	*Input params
	96	* e : an instance of an event type
	97	*Return value
963b5f2d	98	* LttFacility * : the facility of the event
6cd62ccf	99	****************************************************************************/
6cd62ccf	100
963b5f2d	101	LttFacility ltt_event_facility(LttEvent e)
6cd62ccf	102	{
963b5f2d	103	LttTrace * trace = e->tracefile->trace;
	104	unsigned id = e->event_id;
	105	return ltt_trace_facility_by_id(trace,id);
6cd62ccf	106	}
	107
	108	/*****************************************************************************
	109	*Function name
	110	* ltt_event_eventtype : get the event type of the event
	111	*Input params
	112	* e : an instance of an event type
	113	*Return value
963b5f2d	114	* LttEventType * : the event type of the event
6cd62ccf	115	****************************************************************************/
6cd62ccf	116
963b5f2d	117	LttEventType ltt_event_eventtype(LttEvent e)
6cd62ccf	118	{
963b5f2d	119	LttFacility* facility = ltt_event_facility(e);
	120	if(!facility) return NULL;
	121	return facility->events[e->event_id - facility->base_id];
6cd62ccf	122	}
	123
	124	/*****************************************************************************
	125	*Function name
963b5f2d	126	* ltt_event_field : get the root field of the event
6cd62ccf	127	*Input params
963b5f2d	128	* e : an instance of an event type
6cd62ccf	129	*Return value
963b5f2d	130	* LttField * : the root field of the event
6cd62ccf	131	****************************************************************************/
6cd62ccf	132
963b5f2d	133	LttField ltt_event_field(LttEvent e)
6cd62ccf	134	{
908f42fa	135	LttField * field;
963b5f2d	136	LttEventType * event_type = ltt_event_eventtype(e);
963b5f2d	137	if(!event_type) return NULL;
908f42fa	138	field = event_type->root_field;
	139
	140	//check if the field need refresh
	141	if(e->which_block != event_type->latest_block \|\|
	142	e->which_event != event_type->latest_event){
	143
	144	event_type->latest_block = e->which_block;
	145	event_type->latest_event = e->which_event;
	146
	147	if(field->field_fixed == 1)return field;
	148
	149	//refresh the field
	150	ltt_event_refresh_fields(0, 0, field, e->data);
	151	}
	152	return field;
6cd62ccf	153	}
	154
	155	/*****************************************************************************
	156	*Function name
963b5f2d	157	* ltt_event_time : get the time of the event
6cd62ccf	158	*Input params
	159	* e : an instance of an event type
	160	*Return value
963b5f2d	161	* LttTime : the time of the event
6cd62ccf	162	****************************************************************************/
6cd62ccf	163
963b5f2d	164	LttTime ltt_event_time(LttEvent *e)
6cd62ccf	165	{
963b5f2d	166	return e->event_time;
6cd62ccf	167	}
	168
	169	/*****************************************************************************
	170	*Function name
963b5f2d	171	* ltt_event_time : get the cycle count of the event
6cd62ccf	172	*Input params
	173	* e : an instance of an event type
	174	*Return value
963b5f2d	175	* LttCycleCount : the cycle count of the event
6cd62ccf	176	****************************************************************************/
6cd62ccf	177
963b5f2d	178	LttCycleCount ltt_event_cycle_count(LttEvent *e)
6cd62ccf	179	{
963b5f2d	180	return e->event_cycle_count;
6cd62ccf	181	}
	182
	183	/*****************************************************************************
	184	*Function name
963b5f2d	185	* ltt_event_cpu_i: get the cpu id where the event happens
6cd62ccf	186	*Input params
	187	* e : an instance of an event type
	188	*Return value
963b5f2d	189	* unsigned : the cpu id
6cd62ccf	190	****************************************************************************/
6cd62ccf	191
963b5f2d	192	unsigned ltt_event_cpu_id(LttEvent *e)
	193	{
	194	return (unsigned)atoi(e->tracefile->name);
6cd62ccf	195	}
	196
	197	/*****************************************************************************
	198	*Function name
	199	* ltt_event_data : get the raw data for the event
	200	*Input params
	201	* e : an instance of an event type
	202	*Return value
	203	* void * : pointer to the raw data for the event
	204	****************************************************************************/
	205
963b5f2d	206	void ltt_event_data(LttEvent e)
6cd62ccf	207	{
	208	return e->data;
	209	}
	210
	211	/*****************************************************************************
	212	*Function name
	213	* ltt_event_field_element_number
	214	* : The number of elements in a sequence field is specific
	215	* to each event. This function returns the number of
	216	* elements for an array or sequence field in an event.
	217	*Input params
908f42fa	218	* e : an instance of an event type
6cd62ccf	219	* f : a field of the instance
	220	*Return value
	221	* unsigned : the number of elements for an array/sequence field
	222	****************************************************************************/
	223
963b5f2d	224	unsigned ltt_event_field_element_number(LttEvent e, LttField f)
6cd62ccf	225	{
	226	if(f->field_type->type_class != LTT_ARRAY &&
	227	f->field_type->type_class != LTT_SEQUENCE)
	228	return 0;
908f42fa	229
	230	if(f->field_type->type_class == LTT_ARRAY)
	231	return f->field_type->element_number;
	232	return (unsigned) getIntNumber(f->sequ_number_size, e + f->offset_root);
6cd62ccf	233	}
	234
	235	/*****************************************************************************
	236	*Function name
	237	* ltt_event_field_element_select
	238	* : Set the currently selected element for a sequence or
	239	* array field
	240	*Input params
908f42fa	241	* e : an instance of an event type
6cd62ccf	242	* f : a field of the instance
6cd62ccf	243	* i : the ith element
6cd62ccf	244	****************************************************************************/
6cd62ccf	245
963b5f2d	246	void ltt_event_field_element_select(LttEvent e, LttField f, unsigned i)
6cd62ccf	247	{
908f42fa	248	unsigned element_number;
	249	LttField *fld;
	250	int k, size;
	251	void *evD;
	252
	253	if(f->field_type->type_class != LTT_ARRAY &&
6cd62ccf	254	f->field_type->type_class != LTT_SEQUENCE)
908f42fa	255	return ;
	256
	257	element_number = ltt_event_field_element_number(e,f);
89d4760c	258	if((element_number-1) < i \|\| i < 0) return;
908f42fa	259
	260	fld = f->child[0];
	261
	262	evD = e->data + f->offset_root;
	263	size = 0;
	264	for(k=0;k<i;k++){
	265	size += ltt_event_refresh_fields(f->offset_root+size,size, fld, evD+size);
	266	}
6cd62ccf	267
908f42fa	268	f->current_element = i - 1;
6cd62ccf	269	}
	270
	271	/*****************************************************************************
	272	* These functions extract data from an event after architecture specific
	273	* conversions
	274	****************************************************************************/
	275
963b5f2d	276	unsigned ltt_event_get_unsigned(LttEvent e, LttField f)
6cd62ccf	277	{
963b5f2d	278	int revFlag = e->tracefile->trace->my_arch_endian ==
	279	e->tracefile->trace->system_description->endian ? 0:1;
	280	LttTypeEnum t = f->field_type->type_class;
6cd62ccf	281
c687f6c8	282	if(t != LTT_UINT && t != LTT_ENUM)
6cd62ccf	283	g_error("The type of the field is not unsigned int\n");
6cd62ccf	284
b7b36242	285	if(f->field_size == 1){
	286	uint8_t x = (uint8_t)(e->data + f->offset_root);
	287	return (unsigned int) x;
	288	}else if(f->field_size == 2){
	289	uint16_t x = (uint16_t)(e->data + f->offset_root);
	290	return (unsigned int) (revFlag ? BREV16(x): x);
	291	}else if(f->field_size == 4){
	292	uint32_t x = (uint32_t)(e->data + f->offset_root);
	293	return (unsigned int) (revFlag ? BREV32(x): x);
	294	}else if(f->field_size == 8){
	295	uint64_t x = (uint64_t)(e->data + f->offset_root);
	296	return (unsigned int) (revFlag ? BREV64(x): x);
6cd62ccf	297	}
	298	}
	299
963b5f2d	300	int ltt_event_get_int(LttEvent e, LttField f)
6cd62ccf	301	{
963b5f2d	302	int revFlag = e->tracefile->trace->my_arch_endian ==
963b5f2d	303	e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf	304
	305	if(f->field_type->type_class != LTT_INT)
	306	g_error("The type of the field is not int\n");
	307
b7b36242	308	if(f->field_size == 1){
	309	int8_t x = (int8_t)(e->data + f->offset_root);
	310	return (int) x;
	311	}else if(f->field_size == 2){
	312	int16_t x = (int16_t)(e->data + f->offset_root);
	313	return (int) (revFlag ? BREV16(x): x);
	314	}else if(f->field_size == 4){
	315	int32_t x = (int32_t)(e->data + f->offset_root);
	316	return (int) (revFlag ? BREV32(x): x);
	317	}else if(f->field_size == 8){
	318	int64_t x = (int64_t)(e->data + f->offset_root);
	319	return (int) (revFlag ? BREV64(x): x);
6cd62ccf	320	}
	321	}
	322
963b5f2d	323	unsigned long ltt_event_get_long_unsigned(LttEvent e, LttField f)
6cd62ccf	324	{
963b5f2d	325	int revFlag = e->tracefile->trace->my_arch_endian ==
	326	e->tracefile->trace->system_description->endian ? 0:1;
	327	LttTypeEnum t = f->field_type->type_class;
6cd62ccf	328
c687f6c8	329	if(t != LTT_UINT && t != LTT_ENUM)
6cd62ccf	330	g_error("The type of the field is not unsigned long\n");
6cd62ccf	331
b7b36242	332	if(f->field_size == 1){
	333	uint8_t x = (uint8_t)(e->data + f->offset_root);
	334	return (unsigned long) x;
	335	}else if(f->field_size == 2){
	336	uint16_t x = (uint16_t)(e->data + f->offset_root);
	337	return (unsigned long) (revFlag ? BREV16(x): x);
	338	}else if(f->field_size == 4){
	339	uint32_t x = (uint32_t)(e->data + f->offset_root);
	340	return (unsigned long) (revFlag ? BREV32(x): x);
	341	}else if(f->field_size == 8){
	342	uint64_t x = (uint64_t)(e->data + f->offset_root);
	343	return (unsigned long) (revFlag ? BREV64(x): x);
6cd62ccf	344	}
	345	}
	346
963b5f2d	347	long int ltt_event_get_long_int(LttEvent e, LttField f)
6cd62ccf	348	{
963b5f2d	349	int revFlag = e->tracefile->trace->my_arch_endian ==
963b5f2d	350	e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf	351
	352	if( f->field_type->type_class != LTT_INT)
	353	g_error("The type of the field is not long int\n");
	354
b7b36242	355	if(f->field_size == 1){
	356	int8_t x = (int8_t)(e->data + f->offset_root);
	357	return (long) x;
	358	}else if(f->field_size == 2){
	359	int16_t x = (int16_t)(e->data + f->offset_root);
	360	return (long) (revFlag ? BREV16(x): x);
	361	}else if(f->field_size == 4){
	362	int32_t x = (int32_t)(e->data + f->offset_root);
	363	return (long) (revFlag ? BREV32(x): x);
	364	}else if(f->field_size == 8){
	365	int64_t x = (int64_t)(e->data + f->offset_root);
	366	return (long) (revFlag ? BREV64(x): x);
6cd62ccf	367	}
	368	}
	369
963b5f2d	370	float ltt_event_get_float(LttEvent e, LttField f)
6cd62ccf	371	{
963b5f2d	372	int revFlag = e->tracefile->trace->my_arch_endian ==
963b5f2d	373	e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf	374
	375	if(f->field_type->type_class != LTT_FLOAT \|\|
	376	(f->field_type->type_class == LTT_FLOAT && f->field_size != 4))
	377	g_error("The type of the field is not float\n");
	378
	379	if(revFlag == 0) return (float )(e->data + f->offset_root);
	380	else{
	381	uint32_t aInt;
	382	memcpy((void*)&aInt, e->data + f->offset_root, 4);
	383	aInt = ___swab32(aInt);
	384	return ((float)&aInt);
	385	}
	386	}
	387
963b5f2d	388	double ltt_event_get_double(LttEvent e, LttField f)
6cd62ccf	389	{
963b5f2d	390	int revFlag = e->tracefile->trace->my_arch_endian ==
963b5f2d	391	e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf	392
	393	if(f->field_type->type_class != LTT_FLOAT \|\|
	394	(f->field_type->type_class == LTT_FLOAT && f->field_size != 8))
	395	g_error("The type of the field is not double\n");
	396
	397	if(revFlag == 0) return (double )(e->data + f->offset_root);
	398	else{
	399	uint64_t aInt;
	400	memcpy((void*)&aInt, e->data + f->offset_root, 8);
	401	aInt = ___swab64(aInt);
	402	return ((double )&aInt);
	403	}
	404	}
	405
	406	/*****************************************************************************
	407	* The string obtained is only valid until the next read from
908f42fa	408	* the same tracefile.
6cd62ccf	409	****************************************************************************/
6cd62ccf	410
963b5f2d	411	char ltt_event_get_string(LttEvent e, LttField *f)
6cd62ccf	412	{
	413	if(f->field_type->type_class != LTT_STRING)
	414	g_error("The field contains no string\n");
	415	return (char)g_strdup((char)(e->data + f->offset_root));
	416	}