[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_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)
{
  LttEventType * event_type = ltt_event_eventtype(e);
  if(!event_type) return NULL;
  return event_type->root_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;

  return f->field_type->element_number;
}

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

   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)
{
  LttArchSize rSize = e->tracefile->trace->system_description->size;
  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(rSize == LTT_LP32){
    if(f->field_size != 2)
      g_error("The type of the field is not unsigned int: uint16_t\n");
    else{
      uint16_t x = *(uint16_t *)(e->data + f->offset_root);
      return (unsigned) (revFlag ? BREV16(x) : x); 
    }
  }else if(rSize == LTT_ILP32 || rSize == LTT_LP64){
    if(f->field_size != 4)
      g_error("The type of the field is not unsigned int: uint32_t\n");
    else{
      uint32_t x = *(uint32_t *)(e->data + f->offset_root);
      return (unsigned) (revFlag ? BREV32(x): x);
    }
  }else if(rSize == LTT_ILP64){
    if(f->field_size != 8)
      g_error("The type of the field is not unsigned int: uint64_t\n");
    else{
      uint64_t x = *(uint64_t *)(e->data + f->offset_root);
      return (unsigned) (revFlag ? BREV64(x): x);
    }
  }
}

int ltt_event_get_int(LttEvent *e, LttField *f)
{
  LttArchSize rSize = e->tracefile->trace->system_description->size;
  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(rSize == LTT_LP32){
    if(f->field_size != 2)
      g_error("The type of the field is not int: int16_t\n");
    else{
      int16_t x = *(int16_t *)(e->data + f->offset_root);
      return (int) (revFlag ? BREV16(x) : x); 
    }
  }else if(rSize == LTT_ILP32 || rSize == LTT_LP64){
    if(f->field_size != 4)
      g_error("The type of the field is not int: int32_t\n");
    else{
      int32_t x = *(int32_t *)(e->data + f->offset_root);
      return (int) (revFlag ? BREV32(x): x);
    }
  }else if(rSize == LTT_ILP64){
    if(f->field_size != 8)
      g_error("The type of the field is not int: int64_t\n");
    else{
      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)
{
  LttArchSize rSize = e->tracefile->trace->system_description->size;
  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(rSize == LTT_LP32 || rSize == LTT_ILP32 ){
    if(f->field_size != 4)
      g_error("The type of the field is not unsigned long: uint32_t\n");
    else{
      uint32_t x = *(uint32_t *)(e->data + f->offset_root);
      return (unsigned long) (revFlag ? BREV32(x) : x); 
    }
  }else if(rSize == LTT_LP64 || rSize == LTT_ILP64){
    if(f->field_size != 8)
      g_error("The type of the field is not unsigned long: uint64_t\n");
    else{
      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)
{
  LttArchSize rSize = e->tracefile->trace->system_description->size;
  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(rSize == LTT_LP32 || rSize == LTT_ILP32 ){
    if(f->field_size != 4)
      g_error("The type of the field is not long int: int32_t\n");
    else{
      int32_t x = *(int32_t *)(e->data + f->offset_root);
      return (long) (revFlag ? BREV32(x) : x); 
    }
  }else if(rSize == LTT_LP64 || rSize == LTT_ILP64){
    if(f->field_size != 8)
      g_error("The type of the field is not long int: int64_t\n");
    else{
      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
	8	/*****************************************************************************
	9	*Function name
963b5f2d	10	* ltt_event_eventtype_id: get event type id
963b5f2d	11	* (base id + position of the event)
6cd62ccf	12	*Input params
963b5f2d	13	* e : an instance of an event type
6cd62ccf	14	*Return value
963b5f2d	15	* unsigned : event type id
6cd62ccf	16	****************************************************************************/
6cd62ccf	17
963b5f2d	18	unsigned ltt_event_eventtype_id(LttEvent *e)
6cd62ccf	19	{
	20	return (unsigned) e->event_id;
	21	}
	22
	23	/*****************************************************************************
	24	*Function name
	25	* ltt_event_facility : get the facility of the event
	26	*Input params
	27	* e : an instance of an event type
	28	*Return value
963b5f2d	29	* LttFacility * : the facility of the event
6cd62ccf	30	****************************************************************************/
6cd62ccf	31
963b5f2d	32	LttFacility ltt_event_facility(LttEvent e)
6cd62ccf	33	{
963b5f2d	34	LttTrace * trace = e->tracefile->trace;
	35	unsigned id = e->event_id;
	36	return ltt_trace_facility_by_id(trace,id);
6cd62ccf	37	}
	38
	39	/*****************************************************************************
	40	*Function name
	41	* ltt_event_eventtype : get the event type of the event
	42	*Input params
	43	* e : an instance of an event type
	44	*Return value
963b5f2d	45	* LttEventType * : the event type of the event
6cd62ccf	46	****************************************************************************/
6cd62ccf	47
963b5f2d	48	LttEventType ltt_event_eventtype(LttEvent e)
6cd62ccf	49	{
963b5f2d	50	LttFacility* facility = ltt_event_facility(e);
	51	if(!facility) return NULL;
	52	return facility->events[e->event_id - facility->base_id];
6cd62ccf	53	}
	54
	55	/*****************************************************************************
	56	*Function name
963b5f2d	57	* ltt_event_field : get the root field of the event
6cd62ccf	58	*Input params
963b5f2d	59	* e : an instance of an event type
6cd62ccf	60	*Return value
963b5f2d	61	* LttField * : the root field of the event
6cd62ccf	62	****************************************************************************/
6cd62ccf	63
963b5f2d	64	LttField ltt_event_field(LttEvent e)
6cd62ccf	65	{
963b5f2d	66	LttEventType * event_type = ltt_event_eventtype(e);
	67	if(!event_type) return NULL;
	68	return event_type->root_field;
6cd62ccf	69	}
	70
	71	/*****************************************************************************
	72	*Function name
963b5f2d	73	* ltt_event_time : get the time of the event
6cd62ccf	74	*Input params
	75	* e : an instance of an event type
	76	*Return value
963b5f2d	77	* LttTime : the time of the event
6cd62ccf	78	****************************************************************************/
6cd62ccf	79
963b5f2d	80	LttTime ltt_event_time(LttEvent *e)
6cd62ccf	81	{
963b5f2d	82	return e->event_time;
6cd62ccf	83	}
	84
	85	/*****************************************************************************
	86	*Function name
963b5f2d	87	* ltt_event_time : get the cycle count of the event
6cd62ccf	88	*Input params
	89	* e : an instance of an event type
	90	*Return value
963b5f2d	91	* LttCycleCount : the cycle count of the event
6cd62ccf	92	****************************************************************************/
6cd62ccf	93
963b5f2d	94	LttCycleCount ltt_event_cycle_count(LttEvent *e)
6cd62ccf	95	{
963b5f2d	96	return e->event_cycle_count;
6cd62ccf	97	}
	98
	99	/*****************************************************************************
	100	*Function name
963b5f2d	101	* ltt_event_cpu_i: get the cpu id where the event happens
6cd62ccf	102	*Input params
	103	* e : an instance of an event type
	104	*Return value
963b5f2d	105	* unsigned : the cpu id
6cd62ccf	106	****************************************************************************/
6cd62ccf	107
963b5f2d	108	unsigned ltt_event_cpu_id(LttEvent *e)
	109	{
	110	return (unsigned)atoi(e->tracefile->name);
6cd62ccf	111	}
	112
	113	/*****************************************************************************
	114	*Function name
	115	* ltt_event_data : get the raw data for the event
	116	*Input params
	117	* e : an instance of an event type
	118	*Return value
	119	* void * : pointer to the raw data for the event
	120	****************************************************************************/
	121
963b5f2d	122	void ltt_event_data(LttEvent e)
6cd62ccf	123	{
	124	return e->data;
	125	}
	126
	127	/*****************************************************************************
	128	*Function name
	129	* ltt_event_field_element_number
	130	* : The number of elements in a sequence field is specific
	131	* to each event. This function returns the number of
	132	* elements for an array or sequence field in an event.
	133	*Input params
	134	* e : an instance of an event type ????
	135	* f : a field of the instance
	136	*Return value
	137	* unsigned : the number of elements for an array/sequence field
	138	****************************************************************************/
	139
963b5f2d	140	unsigned ltt_event_field_element_number(LttEvent e, LttField f)
6cd62ccf	141	{
	142	if(f->field_type->type_class != LTT_ARRAY &&
	143	f->field_type->type_class != LTT_SEQUENCE)
	144	return 0;
	145
	146	return f->field_type->element_number;
	147	}
	148
	149	/*****************************************************************************
	150	*Function name
	151	* ltt_event_field_element_select
	152	* : Set the currently selected element for a sequence or
	153	* array field
	154	*Input params
	155	* e : an instance of an event type ????
	156	* f : a field of the instance
	157	* i : the ith element
6cd62ccf	158	****************************************************************************/
6cd62ccf	159
963b5f2d	160	void ltt_event_field_element_select(LttEvent e, LttField f, unsigned i)
6cd62ccf	161	{
	162	if(f->field_type->type_class != LTT_ARRAY &&
	163	f->field_type->type_class != LTT_SEQUENCE)
963b5f2d	164	return ;
6cd62ccf	165
963b5f2d	166	if(f->field_type->element_number < i \|\| i == 0) return;
6cd62ccf	167
6cd62ccf	168	f->current_element = i - 1;
6cd62ccf	169	}
	170
	171	/*****************************************************************************
	172	* These functions extract data from an event after architecture specific
	173	* conversions
	174	****************************************************************************/
	175
963b5f2d	176	unsigned ltt_event_get_unsigned(LttEvent e, LttField f)
6cd62ccf	177	{
963b5f2d	178	LttArchSize rSize = e->tracefile->trace->system_description->size;
	179	int revFlag = e->tracefile->trace->my_arch_endian ==
	180	e->tracefile->trace->system_description->endian ? 0:1;
	181	LttTypeEnum t = f->field_type->type_class;
6cd62ccf	182
	183	if(t != LTT_UINT \|\| t != LTT_ENUM)
	184	g_error("The type of the field is not unsigned int\n");
	185
	186	if(rSize == LTT_LP32){
	187	if(f->field_size != 2)
	188	g_error("The type of the field is not unsigned int: uint16_t\n");
	189	else{
	190	uint16_t x = (uint16_t )(e->data + f->offset_root);
	191	return (unsigned) (revFlag ? BREV16(x) : x);
	192	}
	193	}else if(rSize == LTT_ILP32 \|\| rSize == LTT_LP64){
	194	if(f->field_size != 4)
	195	g_error("The type of the field is not unsigned int: uint32_t\n");
	196	else{
	197	uint32_t x = (uint32_t )(e->data + f->offset_root);
	198	return (unsigned) (revFlag ? BREV32(x): x);
	199	}
	200	}else if(rSize == LTT_ILP64){
	201	if(f->field_size != 8)
	202	g_error("The type of the field is not unsigned int: uint64_t\n");
	203	else{
	204	uint64_t x = (uint64_t )(e->data + f->offset_root);
	205	return (unsigned) (revFlag ? BREV64(x): x);
	206	}
	207	}
	208	}
	209
963b5f2d	210	int ltt_event_get_int(LttEvent e, LttField f)
6cd62ccf	211	{
963b5f2d	212	LttArchSize rSize = e->tracefile->trace->system_description->size;
	213	int revFlag = e->tracefile->trace->my_arch_endian ==
	214	e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf	215
	216	if(f->field_type->type_class != LTT_INT)
	217	g_error("The type of the field is not int\n");
	218
	219	if(rSize == LTT_LP32){
	220	if(f->field_size != 2)
	221	g_error("The type of the field is not int: int16_t\n");
	222	else{
	223	int16_t x = (int16_t )(e->data + f->offset_root);
	224	return (int) (revFlag ? BREV16(x) : x);
	225	}
	226	}else if(rSize == LTT_ILP32 \|\| rSize == LTT_LP64){
	227	if(f->field_size != 4)
	228	g_error("The type of the field is not int: int32_t\n");
	229	else{
	230	int32_t x = (int32_t )(e->data + f->offset_root);
	231	return (int) (revFlag ? BREV32(x): x);
	232	}
	233	}else if(rSize == LTT_ILP64){
	234	if(f->field_size != 8)
	235	g_error("The type of the field is not int: int64_t\n");
	236	else{
	237	int64_t x = (int64_t )(e->data + f->offset_root);
	238	return (int) (revFlag ? BREV64(x): x);
	239	}
	240	}
	241	}
	242
963b5f2d	243	unsigned long ltt_event_get_long_unsigned(LttEvent e, LttField f)
6cd62ccf	244	{
963b5f2d	245	LttArchSize rSize = e->tracefile->trace->system_description->size;
	246	int revFlag = e->tracefile->trace->my_arch_endian ==
	247	e->tracefile->trace->system_description->endian ? 0:1;
	248	LttTypeEnum t = f->field_type->type_class;
6cd62ccf	249
	250	if(t != LTT_UINT \|\| t != LTT_ENUM)
	251	g_error("The type of the field is not unsigned long\n");
	252
	253	if(rSize == LTT_LP32 \|\| rSize == LTT_ILP32 ){
	254	if(f->field_size != 4)
	255	g_error("The type of the field is not unsigned long: uint32_t\n");
	256	else{
	257	uint32_t x = (uint32_t )(e->data + f->offset_root);
	258	return (unsigned long) (revFlag ? BREV32(x) : x);
	259	}
	260	}else if(rSize == LTT_LP64 \|\| rSize == LTT_ILP64){
	261	if(f->field_size != 8)
	262	g_error("The type of the field is not unsigned long: uint64_t\n");
	263	else{
	264	uint64_t x = (uint64_t )(e->data + f->offset_root);
	265	return (unsigned long) (revFlag ? BREV64(x): x);
	266	}
	267	}
	268	}
	269
963b5f2d	270	long int ltt_event_get_long_int(LttEvent e, LttField f)
6cd62ccf	271	{
963b5f2d	272	LttArchSize rSize = e->tracefile->trace->system_description->size;
	273	int revFlag = e->tracefile->trace->my_arch_endian ==
	274	e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf	275
	276	if( f->field_type->type_class != LTT_INT)
	277	g_error("The type of the field is not long int\n");
	278
	279	if(rSize == LTT_LP32 \|\| rSize == LTT_ILP32 ){
	280	if(f->field_size != 4)
	281	g_error("The type of the field is not long int: int32_t\n");
	282	else{
	283	int32_t x = (int32_t )(e->data + f->offset_root);
	284	return (long) (revFlag ? BREV32(x) : x);
	285	}
	286	}else if(rSize == LTT_LP64 \|\| rSize == LTT_ILP64){
	287	if(f->field_size != 8)
	288	g_error("The type of the field is not long int: int64_t\n");
	289	else{
	290	int64_t x = (int64_t )(e->data + f->offset_root);
	291	return (long) (revFlag ? BREV64(x): x);
	292	}
	293	}
	294	}
	295
963b5f2d	296	float ltt_event_get_float(LttEvent e, LttField f)
6cd62ccf	297	{
963b5f2d	298	int revFlag = e->tracefile->trace->my_arch_endian ==
963b5f2d	299	e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf	300
	301	if(f->field_type->type_class != LTT_FLOAT \|\|
	302	(f->field_type->type_class == LTT_FLOAT && f->field_size != 4))
	303	g_error("The type of the field is not float\n");
	304
	305	if(revFlag == 0) return (float )(e->data + f->offset_root);
	306	else{
	307	uint32_t aInt;
	308	memcpy((void*)&aInt, e->data + f->offset_root, 4);
	309	aInt = ___swab32(aInt);
	310	return ((float)&aInt);
	311	}
	312	}
	313
963b5f2d	314	double ltt_event_get_double(LttEvent e, LttField f)
6cd62ccf	315	{
963b5f2d	316	int revFlag = e->tracefile->trace->my_arch_endian ==
963b5f2d	317	e->tracefile->trace->system_description->endian ? 0:1;
6cd62ccf	318
	319	if(f->field_type->type_class != LTT_FLOAT \|\|
	320	(f->field_type->type_class == LTT_FLOAT && f->field_size != 8))
	321	g_error("The type of the field is not double\n");
	322
	323	if(revFlag == 0) return (double )(e->data + f->offset_root);
	324	else{
	325	uint64_t aInt;
	326	memcpy((void*)&aInt, e->data + f->offset_root, 8);
	327	aInt = ___swab64(aInt);
	328	return ((double )&aInt);
	329	}
	330	}
	331
	332	/*****************************************************************************
	333	* The string obtained is only valid until the next read from
	334	* the same tracefile. ????
	335	****************************************************************************/
	336
963b5f2d	337	char ltt_event_get_string(LttEvent e, LttField *f)
6cd62ccf	338	{
	339	if(f->field_type->type_class != LTT_STRING)
	340	g_error("The field contains no string\n");
	341	return (char)g_strdup((char)(e->data + f->offset_root));
	342	}