X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Ffilter.c;h=91a3edb0cfac90205fcc7ea8193c7bc490179366;hb=7145a0733484cc976ab46a4595d4e1a41dd6970c;hp=b39b844c4392b6150ebfb3d7d8b0b9348e14d1ba;hpb=80f9611a4e0e5c9dd739ea57ca4062579382b467;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/filter.c b/ltt/branches/poly/lttv/lttv/filter.c index b39b844c..91a3edb0 100644 --- a/ltt/branches/poly/lttv/lttv/filter.c +++ b/ltt/branches/poly/lttv/lttv/filter.c @@ -82,6 +82,8 @@ GQuark */ /** + * @fn void lttv_filter_tree_add_node(GPtrArray*,LttvFilterTree*,LttvLogicalOp) + * * add a node to the current tree * FIXME: Might be used to lower coding in lttv_filter_new switch expression * @param stack the tree stack @@ -95,7 +97,7 @@ lttv_filter_tree_add_node(GPtrArray* stack, LttvFilterTree* subtree, LttvLogical LttvFilterTree* t2 = NULL; t1 = (LttvFilterTree*)g_ptr_array_index(stack,stack->len-1); - while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + while(t1->right != LTTV_TREE_IDLE) t1 = (LttvFilterTree*)t1->r_child.t; t2 = lttv_filter_tree_new(); t2->node = op; if(subtree != NULL) { @@ -118,6 +120,8 @@ lttv_filter_tree_add_node(GPtrArray* stack, LttvFilterTree* subtree, LttvLogical /** + * @fn LttvSimpleExpression* lttv_simple_expression_new() + * * Constructor for LttvSimpleExpression * @return pointer to new LttvSimpleExpression */ @@ -129,12 +133,14 @@ lttv_simple_expression_new() { se->field = LTTV_FILTER_UNDEFINED; se->op = NULL; se->offset = 0; - se->value = NULL; +// se->value.v_uint64 = 0; return se; } /** + * @fn gboolean lttv_simple_expression_add_field(GPtrArray*,LttvSimpleExpression*) + * * Parse through filtering field hierarchy as specified * by user. This function compares each value to * predetermined quarks @@ -143,18 +149,13 @@ lttv_simple_expression_new() { * @return success/failure of operation */ gboolean -parse_field_path(GPtrArray* fp, LttvSimpleExpression* se) { +lttv_simple_expression_assign_field(GPtrArray* fp, LttvSimpleExpression* se) { GString* f = NULL; - g_print("fp->len:%i\n",fp->len); - int i; - for(i=0;ilen;i++) { - GString* f2 = g_ptr_array_index(fp,i); - g_print("%i=%s",i,f2->str); - } + if(fp->len < 2) return FALSE; - g_assert(f=g_ptr_array_index(fp,0)); //list_first(fp)->data; - + g_assert(f=g_ptr_array_remove_index(fp,0)); + /* * Parse through the specified * hardcoded fields. @@ -173,11 +174,11 @@ parse_field_path(GPtrArray* fp, LttvSimpleExpression* se) { * Possible values: * trace.name */ - f=g_ptr_array_index(fp,1); + g_string_free(f,TRUE); + f=g_ptr_array_remove_index(fp,0); if(!g_strcasecmp(f->str,"name")) { se->field = LTTV_FILTER_TRACE_NAME; } - else return FALSE; } else if(!g_strcasecmp(f->str,"traceset") ) { /* * FIXME: not yet implemented ! @@ -187,11 +188,11 @@ parse_field_path(GPtrArray* fp, LttvSimpleExpression* se) { * Possible values: * tracefile.name */ - f=g_ptr_array_index(fp,1); + g_string_free(f,TRUE); + f=g_ptr_array_remove_index(fp,0); if(!g_strcasecmp(f->str,"name")) { se->field = LTTV_FILTER_TRACEFILE_NAME; } - else return FALSE; } else if(!g_strcasecmp(f->str,"state") ) { /* * Possible values: @@ -205,7 +206,8 @@ parse_field_path(GPtrArray* fp, LttvSimpleExpression* se) { * state.process_status * state.cpu */ - f=g_ptr_array_index(fp,1); + g_string_free(f,TRUE); + f=g_ptr_array_remove_index(fp,0); if(!g_strcasecmp(f->str,"pid") ) { se->field = LTTV_FILTER_STATE_PID; } @@ -233,7 +235,6 @@ parse_field_path(GPtrArray* fp, LttvSimpleExpression* se) { else if(!g_strcasecmp(f->str,"cpu") ) { se->field = LTTV_FILTER_STATE_CPU; } - else return FALSE; } else if(!g_strcasecmp(f->str,"event") ) { /* * Possible values: @@ -242,7 +243,8 @@ parse_field_path(GPtrArray* fp, LttvSimpleExpression* se) { * event.time * event.tsc */ - f=g_ptr_array_index(fp,1); + g_string_free(f,TRUE); + f=g_ptr_array_remove_index(fp,0); if(!g_strcasecmp(f->str,"name") ) { se->field = LTTV_FILTER_EVENT_NAME; } @@ -254,42 +256,50 @@ parse_field_path(GPtrArray* fp, LttvSimpleExpression* se) { } else if(!g_strcasecmp(f->str,"time") ) { se->field = LTTV_FILTER_EVENT_TIME; - // offset = &((LttEvent*)NULL)->event_time); } else if(!g_strcasecmp(f->str,"tsc") ) { se->field = LTTV_FILTER_EVENT_TSC; - // offset = &((LttEvent*)NULL)->event_cycle_count); } else { /* core.xml specified options */ se->field = LTTV_FILTER_EVENT_FIELD; - //se->offset = (...); } } else { g_warning("Unrecognized field in filter string"); - return FALSE; } - /* free the pointer array */ - g_ptr_array_free(fp,FALSE); - + /* free memory for last string */ + g_string_free(f,TRUE); + + /* array should be empty */ + g_assert(fp->len == 0); + + g_print("field: %i\n",se->field); + if(se->field == LTTV_FILTER_UNDEFINED) { + g_warning("The specified field was not recognized !"); + return FALSE; + } return TRUE; } /** + * @fn gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression*,LttvExpressionOp) + * * Sets the function pointer for the current * Simple Expression * @param se current simple expression * @return success/failure of operation */ -gboolean assign_operator(LttvSimpleExpression* se, LttvExpressionOp op) { +gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvExpressionOp op) { - g_print("se->field = %i\n",se->field); - g_print("se->offset = %i\n",se->offset); - g_print("se->op = %p\n",se->op); - g_print("se->value = %s\n",se->value); - +// g_print("se->field = %i\n",se->field); +// g_print("se->offset = %i\n",se->offset); +// g_print("se->op = %p\n",se->op); +// g_print("se->value = %s\n",se->value); + switch(se->field) { - /* char */ + /* + * string + */ case LTTV_FILTER_TRACE_NAME: case LTTV_FILTER_TRACEFILE_NAME: case LTTV_FILTER_STATE_P_NAME: @@ -299,13 +309,16 @@ gboolean assign_operator(LttvSimpleExpression* se, LttvExpressionOp op) { se->op = lttv_apply_op_eq_string; break; case LTTV_FIELD_NE: - se->op = lttv_apply_op_eq_string; + se->op = lttv_apply_op_ne_string; break; default: - g_warning("Error encountered in operator assignment"); + g_warning("Error encountered in operator assignment = or != expected"); return FALSE; } break; + /* + * integer + */ case LTTV_FILTER_STATE_PID: case LTTV_FILTER_STATE_PPID: case LTTV_FILTER_STATE_EX_MODE: @@ -335,28 +348,31 @@ gboolean assign_operator(LttvSimpleExpression* se, LttvExpressionOp op) { return FALSE; } break; + /* + * Ltttime + */ case LTTV_FILTER_STATE_CT: case LTTV_FILTER_STATE_IT: case LTTV_FILTER_EVENT_TIME: case LTTV_FILTER_EVENT_TSC: switch(op) { case LTTV_FIELD_EQ: - se->op = lttv_apply_op_eq_double; + se->op = lttv_apply_op_eq_ltttime; break; case LTTV_FIELD_NE: - se->op = lttv_apply_op_ne_double; + se->op = lttv_apply_op_ne_ltttime; break; case LTTV_FIELD_LT: - se->op = lttv_apply_op_lt_double; + se->op = lttv_apply_op_lt_ltttime; break; case LTTV_FIELD_LE: - se->op = lttv_apply_op_le_double; + se->op = lttv_apply_op_le_ltttime; break; case LTTV_FIELD_GT: - se->op = lttv_apply_op_gt_double; + se->op = lttv_apply_op_gt_ltttime; break; case LTTV_FIELD_GE: - se->op = lttv_apply_op_ge_double; + se->op = lttv_apply_op_ge_ltttime; break; default: g_warning("Error encountered in operator assignment"); @@ -364,7 +380,7 @@ gboolean assign_operator(LttvSimpleExpression* se, LttvExpressionOp op) { } break; default: - g_warning("Error encountered in operator assignment"); + g_warning("Error encountered in operator assignation ! Field type:%i",se->field); return FALSE; } @@ -373,6 +389,83 @@ gboolean assign_operator(LttvSimpleExpression* se, LttvExpressionOp op) { } /** + * @fn void lttv_simple_expression_assign_value(LttvSimpleExpression*,char*) + * + * Assign the value field to the current LttvSimpleExpression + * @param se pointer to the current LttvSimpleExpression + * @param value string value for simple expression + */ +gboolean lttv_simple_expression_assign_value(LttvSimpleExpression* se, char* value) { + +// g_print("se->value:%s\n",value); + + switch(se->field) { + /* + * string + */ + case LTTV_FILTER_TRACE_NAME: + case LTTV_FILTER_TRACEFILE_NAME: + case LTTV_FILTER_STATE_P_NAME: + case LTTV_FILTER_EVENT_NAME: + se->value.v_string = value; + break; + /* + * integer + */ + case LTTV_FILTER_STATE_PID: + case LTTV_FILTER_STATE_PPID: + case LTTV_FILTER_STATE_EX_MODE: + case LTTV_FILTER_STATE_EX_SUBMODE: + case LTTV_FILTER_STATE_P_STATUS: + se->value.v_uint64 = atoi(value); + g_free(value); + break; + /* + * LttTime + */ + case LTTV_FILTER_STATE_CT: + case LTTV_FILTER_STATE_IT: + case LTTV_FILTER_EVENT_TIME: + case LTTV_FILTER_EVENT_TSC: + //se->value.v_double = atof(value); + se->value.v_ltttime = ltt_time_from_double(atof(value)); + g_free(value); + break; + default: + g_warning("Error encountered in value assignation ! Field type = %i",se->field); + return FALSE; + } + + return TRUE; + +} + +/** + * @fn void lttv_simple_expression_destroy(LttvSimpleExpression*) + * + * Disallocate memory for the current + * simple expression + * @param se pointer to the current LttvSimpleExpression + */ +void +lttv_simple_expression_destroy(LttvSimpleExpression* se) { + + // g_free(se->value); + switch(se->field) { + case LTTV_FILTER_TRACE_NAME: + case LTTV_FILTER_TRACEFILE_NAME: + case LTTV_FILTER_STATE_P_NAME: + case LTTV_FILTER_EVENT_NAME: + g_free(se->value.v_string); + break; + } + g_free(se); + +} + +/** + * @fn gint lttv_struct_type(gint) + * * Finds the structure type depending * on the fields in parameters * @params ft Field of the current structure @@ -412,348 +505,469 @@ lttv_struct_type(gint ft) { } /** + * @fn gboolean lttv_apply_op_eq_uint64(gpointer,LttvFieldValue) + * * Applies the 'equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_uint64(gpointer v1, char* v2) { +gboolean lttv_apply_op_eq_uint64(gpointer v1, LttvFieldValue v2) { guint64* r = (guint64*) v1; - guint64 l = atoi(v2); - return (*r == l); + return (*r == v2.v_uint64); } /** + * @fn gboolean lttv_apply_op_eq_uint32(gpointer,LttvFieldValue) + * * Applies the 'equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_uint32(gpointer v1, char* v2) { +gboolean lttv_apply_op_eq_uint32(gpointer v1, LttvFieldValue v2) { guint32* r = (guint32*) v1; - guint32 l = atoi(v2); - return (*r == l); + return (*r == v2.v_uint32); } /** + * @fn gboolean lttv_apply_op_eq_uint16(gpointer,LttvFieldValue) + * * Applies the 'equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_uint16(gpointer v1, char* v2) { +gboolean lttv_apply_op_eq_uint16(gpointer v1, LttvFieldValue v2) { guint16* r = (guint16*) v1; - guint16 l = atoi(v2); - return (*r == l); + return (*r == v2.v_uint16); } /** + * @fn gboolean lttv_apply_op_eq_double(gpointer,LttvFieldValue) + * * Applies the 'equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_double(gpointer v1, char* v2) { +gboolean lttv_apply_op_eq_double(gpointer v1, LttvFieldValue v2) { double* r = (double*) v1; - double l = atof(v2); - return (*r == l); + return (*r == v2.v_double); } /** + * @fn gboolean lttv_apply_op_eq_string(gpointer,LttvFieldValue) + * * Applies the 'equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_string(gpointer v1, char* v2) { +gboolean lttv_apply_op_eq_string(gpointer v1, LttvFieldValue v2) { char* r = (char*) v1; - return (!g_strcasecmp(r,v2)); + g_print("v1:%s = v2:%s\n",r,v2.v_string); + return (!g_strcasecmp(r,v2.v_string)); +} + +/** + * @fn gboolean lttv_apply_op_eq_ltttime(gpointer,LttvFieldValue) + * + * Applies the 'equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_eq_ltttime(gpointer v1, LttvFieldValue v2) { + LttTime* r = (LttTime*) v1; + return ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec == v2.v_ltttime.tv_nsec)); } + /** + * @fn gboolean lttv_apply_op_ne_uint64(gpointer,LttvFieldValue) + * * Applies the 'not equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_uint64(gpointer v1, char* v2) { +gboolean lttv_apply_op_ne_uint64(gpointer v1, LttvFieldValue v2) { guint64* r = (guint64*) v1; - guint64 l = atoi(v2); - return (*r != l); + return (*r != v2.v_uint64); } /** + * @fn gboolean lttv_apply_op_ne_uint32(gpointer,LttvFieldValue) + * * Applies the 'not equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_uint32(gpointer v1, char* v2) { +gboolean lttv_apply_op_ne_uint32(gpointer v1, LttvFieldValue v2) { guint32* r = (guint32*) v1; - guint32 l = atoi(v2); - return (*r != l); + return (*r != v2.v_uint32); } /** + * @fn gboolean lttv_apply_op_ne_uint16(gpointer,LttvFieldValue) + * * Applies the 'not equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_uint16(gpointer v1, char* v2) { +gboolean lttv_apply_op_ne_uint16(gpointer v1, LttvFieldValue v2) { guint16* r = (guint16*) v1; - guint16 l = atoi(v2); - return (*r != l); + return (*r != v2.v_uint16); } /** + * @fn gboolean lttv_apply_op_ne_double(gpointer,LttvFieldValue) + * * Applies the 'not equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_double(gpointer v1, char* v2) { +gboolean lttv_apply_op_ne_double(gpointer v1, LttvFieldValue v2) { double* r = (double*) v1; - double l = atof(v2); - return (*r != l); + return (*r != v2.v_double); } /** + * @fn gboolean lttv_apply_op_ne_string(gpointer,LttvFieldValue) + * * Applies the 'not equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_string(gpointer v1, char* v2) { +gboolean lttv_apply_op_ne_string(gpointer v1, LttvFieldValue v2) { char* r = (char*) v1; - return (g_strcasecmp(r,v2)); + return (g_strcasecmp(r,v2.v_string)); } /** + * @fn gboolean lttv_apply_op_ne_ltttime(gpointer,LttvFieldValue) + * + * Applies the 'not equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_ne_ltttime(gpointer v1, LttvFieldValue v2) { + LttTime* r = (LttTime*) v1; + return ((r->tv_sec != v2.v_ltttime.tv_sec) || (r->tv_nsec != v2.v_ltttime.tv_nsec)); +} + + +/** + * @fn gboolean lttv_apply_op_lt_uint64(gpointer,LttvFieldValue) + * * Applies the 'lower than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_lt_uint64(gpointer v1, char* v2) { +gboolean lttv_apply_op_lt_uint64(gpointer v1, LttvFieldValue v2) { guint64* r = (guint64*) v1; - guint64 l = atoi(v2); - return (*r < l); + return (*r < v2.v_uint64); } /** + * @fn gboolean lttv_apply_op_lt_uint32(gpointer,LttvFieldValue) + * * Applies the 'lower than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_lt_uint32(gpointer v1, char* v2) { +gboolean lttv_apply_op_lt_uint32(gpointer v1, LttvFieldValue v2) { guint32* r = (guint32*) v1; - guint32 l = atoi(v2); - return (*r < l); + return (*r < v2.v_uint32); } /** + * @fn gboolean lttv_apply_op_lt_uint16(gpointer,LttvFieldValue) + * * Applies the 'lower than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_lt_uint16(gpointer v1, char* v2) { +gboolean lttv_apply_op_lt_uint16(gpointer v1, LttvFieldValue v2) { guint16* r = (guint16*) v1; - guint16 l = atoi(v2); - return (*r < l); + return (*r < v2.v_uint16); } /** + * @fn gboolean lttv_apply_op_lt_double(gpointer,LttvFieldValue) + * * Applies the 'lower than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_lt_double(gpointer v1, char* v2) { +gboolean lttv_apply_op_lt_double(gpointer v1, LttvFieldValue v2) { double* r = (double*) v1; - double l = atof(v2); - return (*r < l); + return (*r < v2.v_double); } /** + * @fn gboolean lttv_apply_op_lt_ltttime(gpointer,LttvFieldValue) + * * Applies the 'lower than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_le_uint64(gpointer v1, char* v2) { +gboolean lttv_apply_op_lt_ltttime(gpointer v1, LttvFieldValue v2) { + LttTime* r = (LttTime*) v1; + return ((r->tv_sec < v2.v_ltttime.tv_sec) || ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec < v2.v_ltttime.tv_nsec))); +} + + +/** + * @fn gboolean lttv_apply_op_le_uint64(gpointer,LttvFieldValue) + * + * Applies the 'lower or equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_le_uint64(gpointer v1, LttvFieldValue v2) { guint64* r = (guint64*) v1; - guint64 l = atoi(v2); - return (*r <= l); + return (*r <= v2.v_uint64); } /** + * @fn gboolean lttv_apply_op_le_uint32(gpointer,LttvFieldValue) + * * Applies the 'lower or equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_le_uint32(gpointer v1, char* v2) { +gboolean lttv_apply_op_le_uint32(gpointer v1, LttvFieldValue v2) { guint32* r = (guint32*) v1; - guint32 l = atoi(v2); - return (*r <= l); + return (*r <= v2.v_uint32); } /** + * @fn gboolean lttv_apply_op_le_uint16(gpointer,LttvFieldValue) + * * Applies the 'lower or equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_le_uint16(gpointer v1, char* v2) { +gboolean lttv_apply_op_le_uint16(gpointer v1, LttvFieldValue v2) { guint16* r = (guint16*) v1; - guint16 l = atoi(v2); - return (*r <= l); + return (*r <= v2.v_uint16); } /** + * @fn gboolean lttv_apply_op_le_double(gpointer,LttvFieldValue) + * * Applies the 'lower or equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_le_double(gpointer v1, char* v2) { +gboolean lttv_apply_op_le_double(gpointer v1, LttvFieldValue v2) { double* r = (double*) v1; - double l = atof(v2); - return (*r <= l); + return (*r <= v2.v_double); +} + +/** + * @fn gboolean lttv_apply_op_le_ltttime(gpointer,LttvFieldValue) + * + * Applies the 'lower or equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_le_ltttime(gpointer v1, LttvFieldValue v2) { + LttTime* r = (LttTime*) v1; + return ((r->tv_sec < v2.v_ltttime.tv_sec) || ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec <= v2.v_ltttime.tv_nsec))); } + /** + * @fn gboolean lttv_apply_op_gt_uint64(gpointer,LttvFieldValue) + * * Applies the 'greater than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_gt_uint64(gpointer v1, char* v2) { +gboolean lttv_apply_op_gt_uint64(gpointer v1, LttvFieldValue v2) { guint64* r = (guint64*) v1; - guint64 l = atoi(v2); - return (*r > l); + return (*r > v2.v_uint64); } /** + * @fn gboolean lttv_apply_op_gt_uint32(gpointer,LttvFieldValue) + * * Applies the 'greater than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_gt_uint32(gpointer v1, char* v2) { +gboolean lttv_apply_op_gt_uint32(gpointer v1, LttvFieldValue v2) { guint32* r = (guint32*) v1; - guint32 l = atoi(v2); - return (*r > l); + return (*r > v2.v_uint32); } /** + * @fn gboolean lttv_apply_op_gt_uint16(gpointer,LttvFieldValue) + * * Applies the 'greater than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_gt_uint16(gpointer v1, char* v2) { +gboolean lttv_apply_op_gt_uint16(gpointer v1, LttvFieldValue v2) { guint16* r = (guint16*) v1; - guint16 l = atoi(v2); - return (*r > l); + return (*r > v2.v_uint16); } /** + * @fn gboolean lttv_apply_op_gt_double(gpointer,LttvFieldValue) + * * Applies the 'greater than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_gt_double(gpointer v1, char* v2) { +gboolean lttv_apply_op_gt_double(gpointer v1, LttvFieldValue v2) { double* r = (double*) v1; - double l = atof(v2); - return (*r > l); + return (*r > v2.v_double); } /** + * @fn gboolean lttv_apply_op_gt_ltttime(gpointer,LttvFieldValue) + * + * Applies the 'greater than' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_gt_ltttime(gpointer v1, LttvFieldValue v2) { + LttTime* r = (LttTime*) v1; + return ((r->tv_sec > v2.v_ltttime.tv_sec) || ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec > v2.v_ltttime.tv_nsec))); +} + + +/** + * @fn gboolean lttv_apply_op_ge_uint64(gpointer,LttvFieldValue) + * * Applies the 'greater or equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ge_uint64(gpointer v1, char* v2) { +gboolean lttv_apply_op_ge_uint64(gpointer v1, LttvFieldValue v2) { guint64* r = (guint64*) v1; - guint64 l = atoi(v2); - return (*r >= l); + return (*r >= v2.v_uint64); } /** + * @fn gboolean lttv_apply_op_ge_uint32(gpointer,LttvFieldValue) + * * Applies the 'greater or equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ge_uint32(gpointer v1, char* v2) { +gboolean lttv_apply_op_ge_uint32(gpointer v1, LttvFieldValue v2) { guint32* r = (guint32*) v1; - guint32 l = atoi(v2); - return (*r >= l); + return (*r >= v2.v_uint32); } /** + * @fn gboolean lttv_apply_op_ge_uint16(gpointer,LttvFieldValue) + * * Applies the 'greater or equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ge_uint16(gpointer v1, char* v2) { +gboolean lttv_apply_op_ge_uint16(gpointer v1, LttvFieldValue v2) { guint16* r = (guint16*) v1; - guint16 l = atoi(v2); - return (*r >= l); + return (*r >= v2.v_uint16); } /** + * @fn gboolean lttv_apply_op_ge_double(gpointer,LttvFieldValue) + * * Applies the 'greater or equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ge_double(gpointer v1, char* v2) { +gboolean lttv_apply_op_ge_double(gpointer v1, LttvFieldValue v2) { double* r = (double*) v1; - double l = atof(v2); - return (*r >= l); + return (*r >= v2.v_double); +} + +/** + * @fn gboolean lttv_apply_op_ge_ltttime(gpointer,LttvFieldValue) + * + * Applies the 'greater or equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_ge_ltttime(gpointer v1, LttvFieldValue v2) { + LttTime* r = (LttTime*) v1; + return ((r->tv_sec > v2.v_ltttime.tv_sec) || ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec >= v2.v_ltttime.tv_nsec))); } + /** - * Makes a copy of the current filter tree - * @param tree pointer to the current tree - * @return new copy of the filter tree + * @fn LttvFilterTree* lttv_filter_tree_clone(LttvFilterTree*) + * + * Makes a copy of the current filter tree + * @param tree pointer to the current tree + * @return new copy of the filter tree */ LttvFilterTree* lttv_filter_tree_clone(LttvFilterTree* tree) { @@ -770,7 +984,8 @@ lttv_filter_tree_clone(LttvFilterTree* tree) { newtree->l_child.leaf->field = tree->l_child.leaf->field; newtree->l_child.leaf->offset = tree->l_child.leaf->offset; newtree->l_child.leaf->op = tree->l_child.leaf->op; - newtree->l_child.leaf->value = g_strconcat(tree->l_child.leaf->value); + /* FIXME: special case for string copy ! */ + newtree->l_child.leaf->value = tree->l_child.leaf->value; } newtree->right = tree->right; @@ -781,7 +996,7 @@ lttv_filter_tree_clone(LttvFilterTree* tree) { newtree->r_child.leaf->field = tree->r_child.leaf->field; newtree->r_child.leaf->offset = tree->r_child.leaf->offset; newtree->r_child.leaf->op = tree->r_child.leaf->op; - newtree->r_child.leaf->value = g_strconcat(tree->r_child.leaf->value); + newtree->r_child.leaf->value = tree->r_child.leaf->value; } return newtree; @@ -789,9 +1004,11 @@ lttv_filter_tree_clone(LttvFilterTree* tree) { } /** - * Makes a copy of the current filter - * @param filter pointer to the current filter - * @return new copy of the filter + * @fn LttvFilter* lttv_filter_clone(LttvFilter*) + * + * Makes a copy of the current filter + * @param filter pointer to the current filter + * @return new copy of the filter */ LttvFilter* lttv_filter_clone(LttvFilter* filter) { @@ -810,6 +1027,8 @@ lttv_filter_clone(LttvFilter* filter) { /** + * @fn LttvFilter* lttv_filter_new() + * * Creates a new lttv_filter * @param expression filtering options string * @param t pointer to the current LttvTrace @@ -825,6 +1044,8 @@ lttv_filter_new() { } /** + * @fn gboolean lttv_filter_update(LttvFilter*) + * * Updates the current LttvFilter by building * its tree based upon the expression string * @param filter pointer to the current LttvFilter @@ -837,10 +1058,9 @@ lttv_filter_update(LttvFilter* filter) { if(filter->expression == NULL) return FALSE; - unsigned + int i, - p_nesting=0, /* parenthesis nesting value */ - b=0; /* current breakpoint in expression string */ + p_nesting=0; /* parenthesis nesting value */ /* trees */ LttvFilterTree @@ -855,7 +1075,7 @@ lttv_filter_update(LttvFilter* filter) { * destroy it and build a new one */ if(filter->head != NULL) lttv_filter_tree_destroy(filter->head); - filter->head = tree; + filter->head = NULL; /* will be assigned at the end */ /* * Tree Stack @@ -871,8 +1091,9 @@ lttv_filter_update(LttvFilter* filter) { /* temporary values */ GString *a_field_component = g_string_new(""); - GPtrArray *a_field_path = NULL; - + GPtrArray *a_field_path = g_ptr_array_new(); + + /* simple expression buffer */ LttvSimpleExpression* a_simple_expression = lttv_simple_expression_new(); /* @@ -906,17 +1127,10 @@ lttv_filter_update(LttvFilter* filter) { * 3. pop the tree value from the tree stack */ - a_field_path = g_ptr_array_new(); -// g_ptr_array_set_size(a_field_path,2); /* by default, recording 2 field expressions */ - - +// g_print("expression: %s\n",filter->expression); +// g_print("strlen(expression): %i\n",strlen(filter->expression)); for(i=0;iexpression);i++) { // debug - int t; -// for(t=0;tlen;t++) { -// GString* t3 = g_ptr_array_index(a_field_path,t); -// g_print("%i=%s ",t,t3->str); -// } g_print("%c ",filter->expression[i]); switch(filter->expression[i]) { /* @@ -925,7 +1139,10 @@ lttv_filter_update(LttvFilter* filter) { case '&': /* and */ t1 = (LttvFilterTree*)g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + while(t1->right != LTTV_TREE_IDLE) { + g_assert(t1->right == LTTV_TREE_NODE); + t1 = t1->r_child.t; + } t2 = lttv_filter_tree_new(); t2->node = LTTV_LOGICAL_AND; if(subtree != NULL) { /* append subtree to current tree */ @@ -935,20 +1152,25 @@ lttv_filter_update(LttvFilter* filter) { t1->right = LTTV_TREE_NODE; t1->r_child.t = t2; } else { /* append a simple expression */ - a_simple_expression->value = a_field_component->str; + lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); + // a_simple_expression->value = g_string_free(a_field_component,FALSE); a_field_component = g_string_new(""); t2->left = LTTV_TREE_LEAF; t2->l_child.leaf = a_simple_expression; a_simple_expression = lttv_simple_expression_new(); t1->right = LTTV_TREE_NODE; - t1->r_child.t = t2; + t1->r_child.t = t2; + g_print("t1:%p t1->child:%p\n",t1,t1->r_child.t); } break; case '|': /* or */ - t1 = (LttvFilter*)g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + t1 = (LttvFilterTree*)g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) { + g_assert(t1->right == LTTV_TREE_NODE); + t1 = t1->r_child.t; + } t2 = lttv_filter_tree_new(); t2->node = LTTV_LOGICAL_OR; if(subtree != NULL) { /* append subtree to current tree */ @@ -958,7 +1180,8 @@ lttv_filter_update(LttvFilter* filter) { t1->right = LTTV_TREE_NODE; t1->r_child.t = t2; } else { /* append a simple expression */ - a_simple_expression->value = a_field_component->str; + lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); + //a_simple_expression->value = g_string_free(a_field_component,FALSE); a_field_component = g_string_new(""); t2->left = LTTV_TREE_LEAF; t2->l_child.leaf = a_simple_expression; @@ -970,8 +1193,11 @@ lttv_filter_update(LttvFilter* filter) { case '^': /* xor */ - t1 = (LttvFilter*)g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + t1 = (LttvFilterTree*)g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) { + g_assert(t1->right == LTTV_TREE_NODE); + t1 = t1->r_child.t; + } t2 = lttv_filter_tree_new(); t2->node = LTTV_LOGICAL_XOR; if(subtree != NULL) { /* append subtree to current tree */ @@ -981,7 +1207,8 @@ lttv_filter_update(LttvFilter* filter) { t1->right = LTTV_TREE_NODE; t1->r_child.t = t2; } else { /* append a simple expression */ - a_simple_expression->value = a_field_component->str; + lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); + //a_simple_expression->value = g_string_free(a_field_component,FALSE); a_field_component = g_string_new(""); t2->left = LTTV_TREE_LEAF; t2->l_child.leaf = a_simple_expression; @@ -995,15 +1222,16 @@ lttv_filter_update(LttvFilter* filter) { if(filter->expression[i+1] == '=') { /* != */ g_ptr_array_add( a_field_path,(gpointer) a_field_component ); - parse_field_path(a_field_path,a_simple_expression); + lttv_simple_expression_assign_field(a_field_path,a_simple_expression); a_field_component = g_string_new(""); - assign_operator(a_simple_expression,LTTV_FIELD_NE); + lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_NE); i++; } else { /* ! */ - // g_print("%s\n",a_field_component); - // a_field_component = g_string_new(""); - t1 = (LttvFilter*)g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + t1 = (LttvFilterTree*)g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) { + g_assert(t1->right == LTTV_TREE_NODE); + t1 = t1->r_child.t; + } t2 = lttv_filter_tree_new(); t2->node = LTTV_LOGICAL_NOT; t1->right = LTTV_TREE_NODE; @@ -1030,29 +1258,35 @@ lttv_filter_update(LttvFilter* filter) { is not valid due to parenthesis incorrect use",filter->expression); return FALSE; } - + + /* there must at least be the root tree left in the array */ g_assert(tree_stack->len>0); + if(subtree != NULL) { /* append subtree to current tree */ t1 = g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_IDLE && t1->right != LTTV_TREE_LEAF) { - g_assert(t1!=NULL && t1->r_child.t != NULL); - t1 = t1->r_child.t; + while(t1->right != LTTV_TREE_IDLE) { + g_assert(t1->right == LTTV_TREE_NODE); + t1 = t1->r_child.t; } t1->right = LTTV_TREE_NODE; t1->r_child.t = subtree; subtree = g_ptr_array_index(tree_stack,tree_stack->len-1); g_ptr_array_remove_index(tree_stack,tree_stack->len-1); } else { /* assign subtree as current tree */ - a_simple_expression->value = a_field_component->str; + lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); + //a_simple_expression->value = g_string_free(a_field_component,FALSE); a_field_component = g_string_new(""); t1 = g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + while(t1->right != LTTV_TREE_IDLE) { + g_print("while right:%i %p->child:%p\n",t1->right,t1,t1->r_child.t); + g_assert(t1->right == LTTV_TREE_NODE); + g_assert(t1->r_child.t != NULL); + t1 = t1->r_child.t; + } t1->right = LTTV_TREE_LEAF; t1->r_child.leaf = a_simple_expression; a_simple_expression = lttv_simple_expression_new(); - subtree = g_ptr_array_index(tree_stack,tree_stack->len-1); - g_assert(subtree != NULL); - g_ptr_array_remove_index(tree_stack,tree_stack->len-1); + subtree = g_ptr_array_remove_index(tree_stack,tree_stack->len-1); } break; @@ -1062,31 +1296,31 @@ lttv_filter_update(LttvFilter* filter) { case '<': /* lower, lower or equal */ g_ptr_array_add( a_field_path,(gpointer) a_field_component ); - parse_field_path(a_field_path,a_simple_expression); + lttv_simple_expression_assign_field(a_field_path,a_simple_expression); a_field_component = g_string_new(""); if(filter->expression[i+1] == '=') { /* <= */ i++; - assign_operator(a_simple_expression,LTTV_FIELD_LE); - } else assign_operator(a_simple_expression,LTTV_FIELD_LT); + lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_LE); + } else lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_LT); break; case '>': /* higher, higher or equal */ g_ptr_array_add( a_field_path,(gpointer) a_field_component ); - parse_field_path(a_field_path,a_simple_expression); + lttv_simple_expression_assign_field(a_field_path,a_simple_expression); a_field_component = g_string_new(""); if(filter->expression[i+1] == '=') { /* >= */ i++; - assign_operator(a_simple_expression,LTTV_FIELD_GE); - } else assign_operator(a_simple_expression,LTTV_FIELD_GT); + lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_GE); + } else lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_GT); break; case '=': /* equal */ g_ptr_array_add( a_field_path,(gpointer) a_field_component ); - parse_field_path(a_field_path,a_simple_expression); + lttv_simple_expression_assign_field(a_field_path,a_simple_expression); a_field_component = g_string_new(""); - assign_operator(a_simple_expression,LTTV_FIELD_EQ); + lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_EQ); break; /* @@ -1098,19 +1332,22 @@ lttv_filter_update(LttvFilter* filter) { * divide field expression into elements * in a_field_path array. */ -// if(a_simple_expression->op == NULL) { + /* FIXME: check for double values */ + if(a_simple_expression->field == LTTV_FILTER_UNDEFINED) { g_ptr_array_add( a_field_path,(gpointer) a_field_component ); a_field_component = g_string_new(""); -// } + } + break; + case ' ': + case '\n': break; - default: /* concatening current string */ - g_string_append_c(a_field_component,filter->expression[i]); + g_string_append_c(a_field_component,filter->expression[i]); } } - g_print("subtree:%p, tree:%p, t1:%p, t2:%p\n",subtree,tree,t1,t2); - g_print("stack size: %i\n",tree_stack->len); +// g_print("subtree:%p, tree:%p, t1:%p, t2:%p\n",subtree,tree,t1,t2); +// g_print("stack size: %i\n",tree_stack->len); /* * Preliminary check to see @@ -1127,36 +1364,55 @@ lttv_filter_update(LttvFilter* filter) { /* processing last element of expression */ t1 = g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + while(t1->right != LTTV_TREE_IDLE) { + g_assert(t1->right == LTTV_TREE_NODE); + t1 = t1->r_child.t; + } if(subtree != NULL) { /* add the subtree */ t1->right = LTTV_TREE_NODE; t1->r_child.t = subtree; subtree = NULL; } else { /* add a leaf */ - a_simple_expression->value = a_field_component->str; - a_field_component = g_string_new(""); + lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); + //a_simple_expression->value = g_string_free(a_field_component,FALSE); + a_field_component = NULL; t1->right = LTTV_TREE_LEAF; t1->r_child.leaf = a_simple_expression; - /* - * FIXME: is it really necessary to reallocate - * LttvSimpleExpression at this point ?? - */ - a_simple_expression = lttv_simple_expression_new(); + a_simple_expression = NULL; } - g_assert(tree != NULL); - g_assert(subtree == NULL); - lttv_print_tree(filter->head) ; + /* free the pointer array */ + g_assert(a_field_path->len == 0); + g_ptr_array_free(a_field_path,TRUE); - g_print("ended update tree!\n"); + /* free the tree stack -- but keep the root tree */ + // g_ptr_array_free(tree_stack,FALSE); + filter->head = g_ptr_array_remove_index(tree_stack,0); + g_ptr_array_free(tree_stack,TRUE); + + /* free the field buffer if allocated */ + if(a_field_component != NULL) g_string_free(a_field_component,TRUE); + + /* free the simple expression buffer if allocated */ + if(a_simple_expression != NULL) lttv_simple_expression_destroy(a_simple_expression); + + g_assert(filter->head != NULL); /* tree should exist */ + g_assert(subtree == NULL); /* remaining subtree should be included in main tree */ + + /* debug */ + g_print("+++++++++++++++ BEGIN PRINT ++++++++++++++++\n"); + lttv_print_tree(filter->head) ; + g_print("+++++++++++++++ END PRINT ++++++++++++++++++\n"); + + /* success */ return TRUE; -// return filter; - } /** + * @fn void lttv_filter_destroy(LttvFilter*) + * * Destroy the current LttvFilter * @param filter pointer to the current LttvFilter */ @@ -1170,6 +1426,8 @@ lttv_filter_destroy(LttvFilter* filter) { } /** + * @fn LttvFilterTree* lttv_filter_tree_new() + * * Assign a new tree for the current expression * or sub expression * @return pointer of LttvFilterTree @@ -1178,23 +1436,28 @@ LttvFilterTree* lttv_filter_tree_new() { LttvFilterTree* tree; - tree = g_new(LttvFilter,1); + tree = g_new(LttvFilterTree,1); tree->node = 0; //g_new(lttv_expression,1); tree->left = LTTV_TREE_IDLE; tree->right = LTTV_TREE_IDLE; - + tree->r_child.t = NULL; + tree->l_child.t = NULL; + return tree; } /** + * @fn void lttv_filter_append_expression(LttvFilter*,char*) + * * Append a new expression to the expression * defined in the current filter * @param filter pointer to the current LttvFilter * @param expression string that must be appended + * @return Success/Failure of operation */ -void lttv_filter_append_expression(LttvFilter* filter, char *expression) { +gboolean lttv_filter_append_expression(LttvFilter* filter, char *expression) { - if(expression == NULL) return; + if(expression == NULL) return FALSE; if(filter == NULL) { filter = lttv_filter_new(); filter->expression = expression; @@ -1204,11 +1467,13 @@ void lttv_filter_append_expression(LttvFilter* filter, char *expression) { filter->expression = g_strconcat(filter->expression,"&",expression); } - lttv_filter_update(filter); + return lttv_filter_update(filter); } /** + * @fn void lttv_filter_clear_expression(LttvFilter*) + * * Clear the filter expression from the * current filter and sets its pointer to NULL * @param filter pointer to the current LttvFilter @@ -1223,25 +1488,29 @@ void lttv_filter_clear_expression(LttvFilter* filter) { } /** + * @fn void lttv_filter_tree_destroy(LttvFilterTree*) + * * Destroys the tree and his sub-trees * @param tree Tree which must be destroyed */ void lttv_filter_tree_destroy(LttvFilterTree* tree) { - + if(tree == NULL) return; - if(tree->left == LTTV_TREE_LEAF) g_free(tree->l_child.leaf); + if(tree->left == LTTV_TREE_LEAF) lttv_simple_expression_destroy(tree->l_child.leaf); else if(tree->left == LTTV_TREE_NODE) lttv_filter_tree_destroy(tree->l_child.t); - if(tree->right == LTTV_TREE_LEAF) g_free(tree->r_child.leaf); + if(tree->right == LTTV_TREE_LEAF) lttv_simple_expression_destroy(tree->r_child.leaf); else if(tree->right == LTTV_TREE_NODE) lttv_filter_tree_destroy(tree->r_child.t); - g_free(tree->node); +// g_free(tree->node); g_free(tree); } /** + * @fn gboolean lttv_filter_tree_parse(LttvFilterTree*,LttEvent,LttTracefile,LttTrace,LttvProcessState) + * * Global parsing function for the current * LttvFilterTree * @param tree pointer to the current LttvFilterTree @@ -1291,10 +1560,11 @@ lttv_filter_tree_parse( * then don't explore right branch and return 1; * -If result of left branch is 0 / FALSE then explore * 3. XOR OPERATOR - * -Result of left branchwill not affect exploration of + * -Result of left branch will not affect exploration of * right branch */ - + g_print("filter::lttv_parse_tree(...)\n"); + gboolean lresult = FALSE, rresult = FALSE; /* @@ -1303,8 +1573,8 @@ lttv_filter_tree_parse( if(t->left == LTTV_TREE_NODE) lresult = lttv_filter_tree_parse(t->l_child.t,event,tracefile,trace,state); else if(t->left == LTTV_TREE_LEAF) { //g_print("%p: left is %i %p %s\n",t,t->l_child.leaf->field,t->l_child.leaf->op,t->l_child.leaf->value); - char* v; - g_assert(v = t->l_child.leaf->value); + LttvFieldValue v; + v = t->l_child.leaf->value; switch(t->l_child.leaf->field) { case LTTV_FILTER_TRACE_NAME: @@ -1326,15 +1596,15 @@ lttv_filter_tree_parse( case LTTV_FILTER_STATE_CT: if(state == NULL) lresult = TRUE; else { - double val = ltt_time_to_double(state->creation_time); - lresult = t->l_child.leaf->op((gpointer)&val,v); +// double val = ltt_time_to_double(state->creation_time); + lresult = t->l_child.leaf->op((gpointer)&state->creation_time,v); } break; case LTTV_FILTER_STATE_IT: if(state == NULL) lresult = TRUE; else { - double val = ltt_time_to_double(state->insertion_time); - lresult = t->l_child.leaf->op((gpointer)&val,v); +// double val = ltt_time_to_double(state->insertion_time); + lresult = t->l_child.leaf->op((gpointer)&state->insertion_time,v); } break; case LTTV_FILTER_STATE_P_NAME: @@ -1422,8 +1692,8 @@ lttv_filter_tree_parse( if(t->right == LTTV_TREE_NODE) rresult = lttv_filter_tree_parse(t->r_child.t,event,tracefile,trace,state); else if(t->right == LTTV_TREE_LEAF) { //g_print("%p: right is %i %p %s\n",t,t->r_child.leaf->field,t->r_child.leaf->op,t->r_child.leaf->value); - char* v; - g_assert(v = t->r_child.leaf->value); + LttvFieldValue v; + v = t->r_child.leaf->value; switch(t->r_child.leaf->field) { case LTTV_FILTER_TRACE_NAME: @@ -1445,15 +1715,15 @@ lttv_filter_tree_parse( case LTTV_FILTER_STATE_CT: if(state == NULL) rresult = TRUE; else { - double val = ltt_time_to_double(state->creation_time); - rresult = t->r_child.leaf->op((gpointer)&val,v); + // double val = ltt_time_to_double(state->creation_time); + rresult = t->r_child.leaf->op((gpointer)&state->creation_time,v); } break; case LTTV_FILTER_STATE_IT: if(state == NULL) rresult = TRUE; else { - double val = ltt_time_to_double(state->insertion_time); - rresult = t->r_child.leaf->op((gpointer)&val,v); +// double val = ltt_time_to_double(state->insertion_time); + rresult = t->r_child.leaf->op((gpointer)&state->insertion_time,v); } break; case LTTV_FILTER_STATE_P_NAME: @@ -1494,8 +1764,8 @@ lttv_filter_tree_parse( case LTTV_FILTER_EVENT_TIME: // if(event == NULL) rresult = TRUE; // else { -// double val = ltt_time_to_double(event->event_time); -// rresult = t->r_child.leaf->op((gpointer)&val,v); +// double val = ltt_time_to_double(event->event_time); +// rresult = t->r_child.leaf->op((gpointer)&event->event_time,v); // } rresult = TRUE; break; @@ -1538,6 +1808,7 @@ lttv_filter_tree_parse( case LTTV_LOGICAL_AND: return (lresult & rresult); case LTTV_LOGICAL_NOT: return (!rresult); case LTTV_LOGICAL_XOR: return (lresult ^ rresult); + case 0: return (rresult); default: /* * This case should never be @@ -1550,31 +1821,34 @@ lttv_filter_tree_parse( } /** - * Debug + * @fn void lttv_print_tree(LttvFilterTree*) + * + * Debug + * @param t the pointer to the current LttvFilterTree */ void lttv_print_tree(LttvFilterTree* t) { - g_print("node:%p lchild:%p rchild:%p\n",t, + g_print("node:%p lchild:%p rchild:%p\n",t, //t->l_child.t,t->r_child.t); (t->left==LTTV_TREE_NODE)?t->l_child.t:NULL, (t->right==LTTV_TREE_NODE)?t->r_child.t:NULL); g_print("node type: %i / [left] %i / [right] %i\n",t->node,t->left,t->right); if(t->left == LTTV_TREE_NODE) lttv_print_tree(t->l_child.t); else if(t->left == LTTV_TREE_LEAF) { - g_assert(t->l_child.leaf->value != NULL); - g_print("%p: left is %i %p %s\n",t,t->l_child.leaf->field,t->l_child.leaf->op,t->l_child.leaf->value); +// g_assert(t->l_child.leaf->value != NULL); + g_print("%p: left is %i %p value\n",t,t->l_child.leaf->field,t->l_child.leaf->op); } - g_print("1\n"); if(t->right == LTTV_TREE_NODE) lttv_print_tree(t->r_child.t); else if(t->right == LTTV_TREE_LEAF) { - g_assert(t->r_child.leaf->value != NULL); - g_print("%p: right is %i %p %s\n",t,t->r_child.leaf->field,t->r_child.leaf->op,t->r_child.leaf->value); +// g_assert(t->r_child.leaf->value != NULL); + g_print("%p: right is %i %p value\n",t,t->r_child.leaf->field,t->r_child.leaf->op); } - g_print("end\n"); } /** + * @fn gboolean lttv_filter_tracefile(LttvFilter*, LttTracefile*) + * * Apply the filter to a specific trace * @param filter the current filter applied * @param tracefile the trace to apply the filter to @@ -1587,12 +1861,21 @@ lttv_filter_tracefile(LttvFilter *filter, LttTracefile *tracefile) { } +/** + * @fn gboolean lttv_filter_tracestate(LttvFilter*,LttvTraceState*) + * + * Parse the current tracestate + * @param filter pointer to the current LttvFilter + * @param tracestate pointer to the current tracestate + */ gboolean lttv_filter_tracestate(LttvFilter *filter, LttvTraceState *tracestate) { } /** + * @fn gboolean lttv_filter_event(LttvFilter*,LttEvent*) + * * Apply the filter to a specific event * @param filter the current filter applied * @param event the event to apply the filter to @@ -1604,51 +1887,21 @@ lttv_filter_event(LttvFilter *filter, LttEvent *event) { } /** + * @fn static void module_init() + * * Initializes the filter module and specific values */ static void module_init() { - /* - * Quarks initialization - * for hardcoded filtering options - * - * TODO: traceset has no yet been defined - */ - - /* top fields */ -// LTTV_FILTER_EVENT = g_quark_from_string("event"); -// LTTV_FILTER_TRACE = g_quark_from_string("trace"); -// LTTV_FILTER_TRACESET = g_quark_from_string("traceset"); -// LTTV_FILTER_STATE = g_quark_from_string("state"); -// LTTV_FILTER_TRACEFILE = g_quark_from_string("tracefile"); - - /* event.name, tracefile.name, trace.name */ -// LTTV_FILTER_NAME = g_quark_from_string("name"); - - /* event sub fields */ -// LTTV_FILTER_CATEGORY = g_quark_from_string("category"); -// LTTV_FILTER_TIME = g_quark_from_string("time"); -// LTTV_FILTER_TSC = g_quark_from_string("tsc"); - - /* state sub fields */ -// LTTV_FILTER_PID = g_quark_from_string("pid"); -// LTTV_FILTER_PPID = g_quark_from_string("ppid"); -// LTTV_FILTER_C_TIME = g_quark_from_string("creation_time"); -// LTTV_FILTER_I_TIME = g_quark_from_string("insertion_time"); -// LTTV_FILTER_P_NAME = g_quark_from_string("process_name"); -// LTTV_FILTER_EX_MODE = g_quark_from_string("execution_mode"); -// LTTV_FILTER_EX_SUBMODE = g_quark_from_string("execution_submode"); -// LTTV_FILTER_P_STATUS = g_quark_from_string("process_status"); -// LTTV_FILTER_CPU = g_quark_from_string("cpu"); - } /** - * Destroys the filter module and specific values + * @fn Destroys the filter module and specific values */ static void module_destroy() { + }