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

#include <stdio.h>
#include <asm/types.h>
#include <linux/byteorder/swab.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;
  if(!field) return NULL;

  //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_position : get the event's position
 *Input params
 *    e                  : an instance of an event type   
 *    ep                 : a pointer to event's position structure
 ****************************************************************************/

void ltt_event_position(LttEvent *e, LttEventPosition *ep)
{
  ep->block_num         = e->which_block;
  ep->event_num         = e->which_event;
  ep->event_time        = e->event_time;
  ep->event_cycle_count = e->event_cycle_count;
  ep->heart_beat_number = e->tracefile->cur_heart_beat_number;
  ep->old_position      = FALSE;
  ep->event_offset      = e->data - e->tracefile->buffer - EVENT_HEADER_SIZE ;
  ep->tf                = e->tracefile;
}

/*****************************************************************************
 *Function name
 *    ltt_event_position_get : get the block number and index of the event
 *Input params
 *    ep                     : a pointer to event's position structure
 *    block_number           : the block number of the event
 *    index_in_block         : the index of the event within the block
 ****************************************************************************/

void ltt_event_position_get(LttEventPosition *ep,
    unsigned *block_number, unsigned *index_in_block, LttTracefile ** tf)
{
  *block_number   = ep->block_num;
  *index_in_block = ep->event_num;
  *tf             = ep->tf;
}

/*****************************************************************************
 *Function name
 *    ltt_event_position_set : set the block number and index of the event
 *Input params
 *    ep                     : a pointer to event's position structure
 *    block_number           : the block number of the event
 *    index_in_block         : the index of the event within the block
 ****************************************************************************/

void ltt_event_position_set(LttEventPosition *ep,
    unsigned block_number, unsigned index_in_block)
{
  ep->block_num = block_number;
  ep->event_num = index_in_block;  
}

/*****************************************************************************
 *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){
    guint8 x = *(guint8 *)(e->data + f->offset_root);
    return (unsigned int) x;    
  }else if(f->field_size == 2){
    guint16 x = *(guint16 *)(e->data + f->offset_root);
    if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
      return (unsigned int) (revFlag ? GUINT16_FROM_BE(x): x);    
    else
      return (unsigned int) (revFlag ? GUINT16_FROM_LE(x): x);          
  }else if(f->field_size == 4){
    guint32 x = *(guint32 *)(e->data + f->offset_root);
    if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
      return (unsigned int) (revFlag ? GUINT32_FROM_BE(x): x);    
    else
      return (unsigned int) (revFlag ? GUINT32_FROM_LE(x): x);    
  }else if(f->field_size == 8){
    guint64 x = *(guint64 *)(e->data + f->offset_root);
    if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
      return (unsigned int) (revFlag ? GUINT64_FROM_BE(x): x);    
    else
      return (unsigned int) (revFlag ? GUINT64_FROM_LE(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){
    gint8 x = *(gint8 *)(e->data + f->offset_root);
    return (int) x;    
  }else if(f->field_size == 2){
    gint16 x = *(gint16 *)(e->data + f->offset_root);
    if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
      return (int) (revFlag ? GINT16_FROM_BE(x): x);    
    else
      return (int) (revFlag ? GINT16_FROM_LE(x): x);    
  }else if(f->field_size == 4){
    gint32 x = *(gint32 *)(e->data + f->offset_root);
    if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
      return (int) (revFlag ? GINT32_FROM_BE(x): x);    
    else
      return (int) (revFlag ? GINT32_FROM_LE(x): x);    
  }else if(f->field_size == 8){
    gint64 x = *(gint64 *)(e->data + f->offset_root);
    if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
      return (int) (revFlag ? GINT64_FROM_BE(x): x);    
    else
      return (int) (revFlag ? GINT64_FROM_LE(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){
    guint8 x = *(guint8 *)(e->data + f->offset_root);
    return (unsigned long) x;    
  }else if(f->field_size == 2){
    guint16 x = *(guint16 *)(e->data + f->offset_root);
    if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
      return (unsigned long) (revFlag ? GUINT16_FROM_BE(x): x);  
    else
      return (unsigned long) (revFlag ? GUINT16_FROM_LE(x): x);    
  }else if(f->field_size == 4){
    guint32 x = *(guint32 *)(e->data + f->offset_root);
    if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
      return (unsigned long) (revFlag ? GUINT32_FROM_BE(x): x);    
    else
      return (unsigned long) (revFlag ? GUINT32_FROM_LE(x): x);    
  }else if(f->field_size == 8){
    guint64 x = *(guint64 *)(e->data + f->offset_root);
    if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
      return (unsigned long) (revFlag ? GUINT64_FROM_BE(x): x);    
    else
      return (unsigned long) (revFlag ? GUINT64_FROM_LE(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){
    gint8 x = *(gint8 *)(e->data + f->offset_root);
    return (long) x;    
  }else if(f->field_size == 2){
    gint16 x = *(gint16 *)(e->data + f->offset_root);
    if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
      return (long) (revFlag ? GINT16_FROM_BE(x): x);    
    else
      return (long) (revFlag ? GINT16_FROM_LE(x): x);    
  }else if(f->field_size == 4){
    gint32 x = *(gint32 *)(e->data + f->offset_root);
    if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
      return (long) (revFlag ? GINT32_FROM_BE(x): x);    
    else
      return (long) (revFlag ? GINT32_FROM_LE(x): x);    
  }else if(f->field_size == 8){
    gint64 x = *(gint64 *)(e->data + f->offset_root);
    if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
      return (long) (revFlag ? GINT64_FROM_BE(x): x);    
    else
      return (long) (revFlag ? GINT64_FROM_LE(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{
    guint32 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{
    guint64 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>
6cd62ccf	4	#include "parser.h"
	5	#include <ltt/event.h>
	6
908f42fa	7	/*****************************************************************************
	8	*Function name
	9	* ltt_event_refresh_fields : refresh fields of an event
	10	*Input params
	11	* offsetRoot : offset from the root
	12	* offsetParent : offset from the parrent
	13	* fld : field
	14	* evD : event data
	15	*Return value
	16	* int : size of the field
	17	****************************************************************************/
	18
	19	int ltt_event_refresh_fields(int offsetRoot,int offsetParent,
	20	LttField * fld, void *evD)
	21	{
	22	int size, size1, element_number, i, offset1, offset2;
	23	LttType * type = fld->field_type;
	24
	25	if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY &&
	26	type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){
	27	size = fld->field_size;
	28	}else if(type->type_class == LTT_ARRAY){
	29	element_number = (int) type->element_number;
	30	if(fld->field_fixed == 0){// has string or sequence
	31	size = 0;
	32	for(i=0;i<element_number;i++){
	33	size += ltt_event_refresh_fields(offsetRoot+size,size,
	34	fld->child[0], evD+size);
	35	}
	36	}else size = fld->field_size;
	37	}else if(type->type_class == LTT_SEQUENCE){
	38	size1 = fld->sequ_number_size;
	39	element_number = getIntNumber(size1,evD);
	40	type->element_number = element_number;
	41	if(fld->element_size > 0){
	42	size = element_number * fld->element_size;
	43	}else{//sequence has string or sequence
	44	size = 0;
	45	for(i=0;i<element_number;i++){
	46	size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1,
	47	fld->child[0], evD+size+size1);
	48	}
	49	size += size1;
	50	}
	51	}else if(type->type_class == LTT_STRING){
	52	size = strlen((char*)evD) + 1; //include end : '\0'
	53	}else if(type->type_class == LTT_STRUCT){
	54	element_number = (int) type->element_number;
	55	if(fld->field_fixed == 0){
	56	offset1 = offsetRoot;
	57	offset2 = 0;
	58	for(i=0;i<element_number;i++){
	59	size=ltt_event_refresh_fields(offset1,offset2,fld->child[i],evD+offset2);
	60	offset1 += size;
	61	offset2 += size;
	62	}
	63	size = offset2;
	64	}else size = fld->field_size;
	65	}
	66
	67	fld->offset_root = offsetRoot;
	68	fld->offset_parent = offsetParent;
	69	fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
	70	fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
71	fld->field_size = size;
72
73	return size;
74	}
75
6cd62ccf	76	/*****************************************************************************
6cd62ccf	77	*Function name
963b5f2d	78	* ltt_event_eventtype_id: get event type id
963b5f2d	79	* (base id + position of the event)
6cd62ccf	80	*Input params
963b5f2d	81	* e : an instance of an event type
6cd62ccf	82	*Return value
963b5f2d	83	* unsigned : event type id
6cd62ccf	84	****************************************************************************/
6cd62ccf	85
963b5f2d	86	unsigned ltt_event_eventtype_id(LttEvent *e)
6cd62ccf	87	{
	88	return (unsigned) e->event_id;
	89	}
	90
	91	/*****************************************************************************
	92	*Function name
	93	* ltt_event_facility : get the facility of the event
	94	*Input params
	95	* e : an instance of an event type
	96	*Return value
963b5f2d	97	* LttFacility * : the facility of the event
6cd62ccf	98	****************************************************************************/
6cd62ccf	99
963b5f2d	100	LttFacility ltt_event_facility(LttEvent e)
6cd62ccf	101	{
963b5f2d	102	LttTrace * trace = e->tracefile->trace;
	103	unsigned id = e->event_id;
	104	return ltt_trace_facility_by_id(trace,id);
6cd62ccf	105	}
	106
	107	/*****************************************************************************
	108	*Function name
	109	* ltt_event_eventtype : get the event type of the event
	110	*Input params
	111	* e : an instance of an event type
	112	*Return value
963b5f2d	113	* LttEventType * : the event type of the event
6cd62ccf	114	****************************************************************************/
6cd62ccf	115
963b5f2d	116	LttEventType ltt_event_eventtype(LttEvent e)
6cd62ccf	117	{
963b5f2d	118	LttFacility* facility = ltt_event_facility(e);
	119	if(!facility) return NULL;
	120	return facility->events[e->event_id - facility->base_id];
6cd62ccf	121	}
	122
	123	/*****************************************************************************
	124	*Function name
963b5f2d	125	* ltt_event_field : get the root field of the event
6cd62ccf	126	*Input params
963b5f2d	127	* e : an instance of an event type
6cd62ccf	128	*Return value
963b5f2d	129	* LttField * : the root field of the event
6cd62ccf	130	****************************************************************************/
6cd62ccf	131
963b5f2d	132	LttField ltt_event_field(LttEvent e)
6cd62ccf	133	{
908f42fa	134	LttField * field;
963b5f2d	135	LttEventType * event_type = ltt_event_eventtype(e);
963b5f2d	136	if(!event_type) return NULL;
908f42fa	137	field = event_type->root_field;
a2331fa0	138	if(!field) return NULL;
908f42fa	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	}
6cd62ccf	182
80da81ad	183	/*****************************************************************************
	184	*Function name
	185	* ltt_event_position : get the event's position
	186	*Input params
	187	* e : an instance of an event type
	188	* ep : a pointer to event's position structure
	189	****************************************************************************/
	190
	191	void ltt_event_position(LttEvent e, LttEventPosition ep)
	192	{
	193	ep->block_num = e->which_block;
	194	ep->event_num = e->which_event;
	195	ep->event_time = e->event_time;
	196	ep->event_cycle_count = e->event_cycle_count;
	197	ep->heart_beat_number = e->tracefile->cur_heart_beat_number;
e4eced0f	198	ep->old_position = FALSE;
80da81ad	199	ep->event_offset = e->data - e->tracefile->buffer - EVENT_HEADER_SIZE ;
e4eced0f	200	ep->tf = e->tracefile;
80da81ad	201	}
	202
	203	/*****************************************************************************
	204	*Function name
	205	* ltt_event_position_get : get the block number and index of the event
	206	*Input params
	207	* ep : a pointer to event's position structure
	208	* block_number : the block number of the event
	209	* index_in_block : the index of the event within the block
	210	****************************************************************************/
	211
	212	void ltt_event_position_get(LttEventPosition *ep,
e4eced0f	213	unsigned block_number, unsigned index_in_block, LttTracefile ** tf)
80da81ad	214	{
	215	*block_number = ep->block_num;
	216	*index_in_block = ep->event_num;
e4eced0f	217	*tf = ep->tf;
80da81ad	218	}
	219
	220	/*****************************************************************************
	221	*Function name
	222	* ltt_event_position_set : set the block number and index of the event
	223	*Input params
	224	* ep : a pointer to event's position structure
	225	* block_number : the block number of the event
	226	* index_in_block : the index of the event within the block
	227	****************************************************************************/
	228
	229	void ltt_event_position_set(LttEventPosition *ep,
	230	unsigned block_number, unsigned index_in_block)
	231	{
	232	ep->block_num = block_number;
e4eced0f	233	ep->event_num = index_in_block;
80da81ad	234	}
80da81ad	235
6cd62ccf	236	/*****************************************************************************
6cd62ccf	237	*Function name
963b5f2d	238	* ltt_event_cpu_i: get the cpu id where the event happens
6cd62ccf	239	*Input params
	240	* e : an instance of an event type
	241	*Return value
963b5f2d	242	* unsigned : the cpu id
6cd62ccf	243	****************************************************************************/
6cd62ccf	244
963b5f2d	245	unsigned ltt_event_cpu_id(LttEvent *e)
	246	{
	247	return (unsigned)atoi(e->tracefile->name);
6cd62ccf	248	}
	249
	250	/*****************************************************************************
	251	*Function name
	252	* ltt_event_data : get the raw data for the event
	253	*Input params
	254	* e : an instance of an event type
	255	*Return value
	256	* void * : pointer to the raw data for the event
	257	****************************************************************************/
	258
963b5f2d	259	void ltt_event_data(LttEvent e)
6cd62ccf	260	{
	261	return e->data;
	262	}
	263
	264	/*****************************************************************************
	265	*Function name
	266	* ltt_event_field_element_number
	267	* : The number of elements in a sequence field is specific
	268	* to each event. This function returns the number of
	269	* elements for an array or sequence field in an event.
	270	*Input params
908f42fa	271	* e : an instance of an event type
6cd62ccf	272	* f : a field of the instance
	273	*Return value
	274	* unsigned : the number of elements for an array/sequence field
	275	****************************************************************************/
	276
963b5f2d	277	unsigned ltt_event_field_element_number(LttEvent e, LttField f)
6cd62ccf	278	{
	279	if(f->field_type->type_class != LTT_ARRAY &&
	280	f->field_type->type_class != LTT_SEQUENCE)
	281	return 0;
908f42fa	282
	283	if(f->field_type->type_class == LTT_ARRAY)
	284	return f->field_type->element_number;
	285	return (unsigned) getIntNumber(f->sequ_number_size, e + f->offset_root);
6cd62ccf	286	}
	287
	288	/*****************************************************************************
	289	*Function name
	290	* ltt_event_field_element_select
	291	* : Set the currently selected element for a sequence or
	292	* array field
	293	*Input params
908f42fa	294	* e : an instance of an event type
6cd62ccf	295	* f : a field of the instance
6cd62ccf	296	* i : the ith element
6cd62ccf	297	****************************************************************************/
6cd62ccf	298
963b5f2d	299	void ltt_event_field_element_select(LttEvent e, LttField f, unsigned i)
6cd62ccf	300	{
908f42fa	301	unsigned element_number;
	302	LttField *fld;
	303	int k, size;
	304	void *evD;
	305
	306	if(f->field_type->type_class != LTT_ARRAY &&
6cd62ccf	307	f->field_type->type_class != LTT_SEQUENCE)
908f42fa	308	return ;
	309
	310	element_number = ltt_event_field_element_number(e,f);
89d4760c	311	if((element_number-1) < i \|\| i < 0) return;
908f42fa	312
	313	fld = f->child[0];
	314
	315	evD = e->data + f->offset_root;
	316	size = 0;
	317	for(k=0;k<i;k++){
	318	size += ltt_event_refresh_fields(f->offset_root+size,size, fld, evD+size);
	319	}
6cd62ccf	320
908f42fa	321	f->current_element = i - 1;
6cd62ccf	322	}
	323
	324	/*****************************************************************************
	325	* These functions extract data from an event after architecture specific
	326	* conversions
	327	****************************************************************************/
	328
963b5f2d	329	unsigned ltt_event_get_unsigned(LttEvent e, LttField f)
6cd62ccf	330	{
963b5f2d	331	int revFlag = e->tracefile->trace->my_arch_endian ==
	332	e->tracefile->trace->system_description->endian ? 0:1;
	333	LttTypeEnum t = f->field_type->type_class;
6cd62ccf	334
c687f6c8	335	if(t != LTT_UINT && t != LTT_ENUM)
6cd62ccf	336	g_error("The type of the field is not unsigned int\n");
6cd62ccf	337
b7b36242	338	if(f->field_size == 1){
cbd41522	339	guint8 x = (guint8 )(e->data + f->offset_root);
b7b36242	340	return (unsigned int) x;
b7b36242	341	}else if(f->field_size == 2){
cbd41522	342	guint16 x = (guint16 )(e->data + f->offset_root);
	343	if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
	344	return (unsigned int) (revFlag ? GUINT16_FROM_BE(x): x);
	345	else
	346	return (unsigned int) (revFlag ? GUINT16_FROM_LE(x): x);
b7b36242	347	}else if(f->field_size == 4){
cbd41522	348	guint32 x = (guint32 )(e->data + f->offset_root);
	349	if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
	350	return (unsigned int) (revFlag ? GUINT32_FROM_BE(x): x);
	351	else
	352	return (unsigned int) (revFlag ? GUINT32_FROM_LE(x): x);
b7b36242	353	}else if(f->field_size == 8){
cbd41522	354	guint64 x = (guint64 )(e->data + f->offset_root);
	355	if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
	356	return (unsigned int) (revFlag ? GUINT64_FROM_BE(x): x);
	357	else
	358	return (unsigned int) (revFlag ? GUINT64_FROM_LE(x): x);
6cd62ccf	359	}
	360	}
	361
963b5f2d	362	int ltt_event_get_int(LttEvent e, LttField f)
6cd62ccf	363	{
963b5f2d	364	int revFlag = e->tracefile->trace->my_arch_endian ==
963b5f2d	365	e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf	366
	367	if(f->field_type->type_class != LTT_INT)
	368	g_error("The type of the field is not int\n");
	369
b7b36242	370	if(f->field_size == 1){
cbd41522	371	gint8 x = (gint8 )(e->data + f->offset_root);
b7b36242	372	return (int) x;
b7b36242	373	}else if(f->field_size == 2){
cbd41522	374	gint16 x = (gint16 )(e->data + f->offset_root);
	375	if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
	376	return (int) (revFlag ? GINT16_FROM_BE(x): x);
	377	else
	378	return (int) (revFlag ? GINT16_FROM_LE(x): x);
b7b36242	379	}else if(f->field_size == 4){
cbd41522	380	gint32 x = (gint32 )(e->data + f->offset_root);
	381	if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
	382	return (int) (revFlag ? GINT32_FROM_BE(x): x);
	383	else
	384	return (int) (revFlag ? GINT32_FROM_LE(x): x);
b7b36242	385	}else if(f->field_size == 8){
cbd41522	386	gint64 x = (gint64 )(e->data + f->offset_root);
	387	if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
	388	return (int) (revFlag ? GINT64_FROM_BE(x): x);
	389	else
	390	return (int) (revFlag ? GINT64_FROM_LE(x): x);
6cd62ccf	391	}
	392	}
	393
963b5f2d	394	unsigned long ltt_event_get_long_unsigned(LttEvent e, LttField f)
6cd62ccf	395	{
963b5f2d	396	int revFlag = e->tracefile->trace->my_arch_endian ==
	397	e->tracefile->trace->system_description->endian ? 0:1;
	398	LttTypeEnum t = f->field_type->type_class;
6cd62ccf	399
c687f6c8	400	if(t != LTT_UINT && t != LTT_ENUM)
6cd62ccf	401	g_error("The type of the field is not unsigned long\n");
6cd62ccf	402
b7b36242	403	if(f->field_size == 1){
cbd41522	404	guint8 x = (guint8 )(e->data + f->offset_root);
b7b36242	405	return (unsigned long) x;
b7b36242	406	}else if(f->field_size == 2){
cbd41522	407	guint16 x = (guint16 )(e->data + f->offset_root);
	408	if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
	409	return (unsigned long) (revFlag ? GUINT16_FROM_BE(x): x);
	410	else
	411	return (unsigned long) (revFlag ? GUINT16_FROM_LE(x): x);
b7b36242	412	}else if(f->field_size == 4){
cbd41522	413	guint32 x = (guint32 )(e->data + f->offset_root);
	414	if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
	415	return (unsigned long) (revFlag ? GUINT32_FROM_BE(x): x);
	416	else
	417	return (unsigned long) (revFlag ? GUINT32_FROM_LE(x): x);
b7b36242	418	}else if(f->field_size == 8){
cbd41522	419	guint64 x = (guint64 )(e->data + f->offset_root);
	420	if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
	421	return (unsigned long) (revFlag ? GUINT64_FROM_BE(x): x);
	422	else
	423	return (unsigned long) (revFlag ? GUINT64_FROM_LE(x): x);
6cd62ccf	424	}
	425	}
	426
963b5f2d	427	long int ltt_event_get_long_int(LttEvent e, LttField f)
6cd62ccf	428	{
963b5f2d	429	int revFlag = e->tracefile->trace->my_arch_endian ==
963b5f2d	430	e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf	431
	432	if( f->field_type->type_class != LTT_INT)
	433	g_error("The type of the field is not long int\n");
	434
b7b36242	435	if(f->field_size == 1){
cbd41522	436	gint8 x = (gint8 )(e->data + f->offset_root);
b7b36242	437	return (long) x;
b7b36242	438	}else if(f->field_size == 2){
cbd41522	439	gint16 x = (gint16 )(e->data + f->offset_root);
	440	if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
	441	return (long) (revFlag ? GINT16_FROM_BE(x): x);
	442	else
	443	return (long) (revFlag ? GINT16_FROM_LE(x): x);
b7b36242	444	}else if(f->field_size == 4){
cbd41522	445	gint32 x = (gint32 )(e->data + f->offset_root);
	446	if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
	447	return (long) (revFlag ? GINT32_FROM_BE(x): x);
	448	else
	449	return (long) (revFlag ? GINT32_FROM_LE(x): x);
b7b36242	450	}else if(f->field_size == 8){
cbd41522	451	gint64 x = (gint64 )(e->data + f->offset_root);
	452	if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
	453	return (long) (revFlag ? GINT64_FROM_BE(x): x);
	454	else
	455	return (long) (revFlag ? GINT64_FROM_LE(x): x);
6cd62ccf	456	}
	457	}
	458
963b5f2d	459	float ltt_event_get_float(LttEvent e, LttField f)
6cd62ccf	460	{
963b5f2d	461	int revFlag = e->tracefile->trace->my_arch_endian ==
963b5f2d	462	e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf	463
	464	if(f->field_type->type_class != LTT_FLOAT \|\|
	465	(f->field_type->type_class == LTT_FLOAT && f->field_size != 4))
	466	g_error("The type of the field is not float\n");
	467
	468	if(revFlag == 0) return (float )(e->data + f->offset_root);
	469	else{
cbd41522	470	guint32 aInt;
6cd62ccf	471	memcpy((void*)&aInt, e->data + f->offset_root, 4);
	472	aInt = ___swab32(aInt);
	473	return ((float)&aInt);
	474	}
	475	}
	476
963b5f2d	477	double ltt_event_get_double(LttEvent e, LttField f)
6cd62ccf	478	{
963b5f2d	479	int revFlag = e->tracefile->trace->my_arch_endian ==
963b5f2d	480	e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf	481
	482	if(f->field_type->type_class != LTT_FLOAT \|\|
	483	(f->field_type->type_class == LTT_FLOAT && f->field_size != 8))
	484	g_error("The type of the field is not double\n");
	485
	486	if(revFlag == 0) return (double )(e->data + f->offset_root);
	487	else{
cbd41522	488	guint64 aInt;
6cd62ccf	489	memcpy((void*)&aInt, e->data + f->offset_root, 8);
	490	aInt = ___swab64(aInt);
	491	return ((double )&aInt);
	492	}
	493	}
	494
	495	/*****************************************************************************
	496	* The string obtained is only valid until the next read from
908f42fa	497	* the same tracefile.
6cd62ccf	498	****************************************************************************/
6cd62ccf	499
963b5f2d	500	char ltt_event_get_string(LttEvent e, LttField *f)
6cd62ccf	501	{
	502	if(f->field_type->type_class != LTT_STRING)
	503	g_error("The field contains no string\n");
	504	return (char)g_strdup((char)(e->data + f->offset_root));
	505	}