X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Ffilter.c;h=f2f978828887be8101a6f237c930d09643a4b49a;hb=47aa6e5829423aabcb60f4f318ea862a36cedf9e;hp=a97427232d566056b693d3662ffa8a5829a9e939;hpb=1601b3650799aefdc6e5c3a20bb8584ab3d14cfd;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/filter.c b/ltt/branches/poly/lttv/lttv/filter.c index a9742723..f2f97882 100644 --- a/ltt/branches/poly/lttv/lttv/filter.c +++ b/ltt/branches/poly/lttv/lttv/filter.c @@ -16,26 +16,6 @@ * MA 02111-1307, USA. */ -/* - consist in AND, OR and NOT nested expressions, forming a tree with - simple relations as leaves. The simple relations test is a field - in an event is equal, not equal, smaller, smaller or equal, larger, or - larger or equal to a specified value. -*/ - -/* - * YET TO BE ANSWERED - * - the exists an other lttv_filter which conflicts with this one - */ - -/* - * TODO - * - refine switch of expression in multiple uses functions - * - add the current simple expression to the tree - */ - -#include - /* read_token @@ -57,8 +37,28 @@ not(child) op(left/right) path(component...) -> field + + consist in AND, OR and NOT nested expressions, forming a tree with + simple relations as leaves. The simple relations test is a field + in an event is equal, not equal, smaller, smaller or equal, larger, or + larger or equal to a specified value. */ +/* + * YET TO BE ANSWERED + * - none yet + */ + +/* + * TODO + * - refine switch of expression in multiple uses functions + * - remove the idle expressions in the tree **** + * - add the current simple expression to the tree + */ + +#include + +/* GQuark LTTV_FILTER_TRACE, LTTV_FILTER_TRACESET, @@ -78,38 +78,44 @@ GQuark LTTV_FILTER_EX_SUBMODE, LTTV_FILTER_P_STATUS, LTTV_FILTER_CPU; - -/** - * Assign a new tree for the current expression - * or sub expression - * @return pointer of lttv_filter_tree - */ -lttv_filter_tree* lttv_filter_tree_new() { - lttv_filter_tree* tree; +*/ - tree = g_new(lttv_filter_tree,1); - tree->node = g_new(lttv_expression,1); - tree->node->type = LTTV_UNDEFINED_EXPRESSION; - tree->left = LTTV_TREE_UNDEFINED; - tree->right = LTTV_TREE_UNDEFINED; +LttvSimpleExpression* +lttv_simple_expression_new() { - return tree; } - /** - * Destroys the tree and his sub-trees - * @param tree Tree which must be destroyed + * add a node to the current tree + * @param stack the tree stack + * @param subtree the subtree if available (pointer or NULL) + * @param op the logical operator that will form the node */ -void lttv_filter_tree_destroy(lttv_filter_tree* tree) { - - if(tree->left == LTTV_TREE_LEAF) g_free(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); - else if(tree->right == LTTV_TREE_NODE) lttv_filter_tree_destroy(tree->r_child.t); - - g_free(tree->node); - g_free(tree); +void +lttv_filter_tree_add_node(GPtrArray* stack, LttvFilterTree* subtree, LttvLogicalOp op) { + + LttvFilterTree* t1 = NULL; + LttvFilterTree* t2 = NULL; + + t1 = (LttvFilterTree*)g_ptr_array_index(stack,stack->len-1); + while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + t2 = lttv_filter_tree_new(); + t2->node = op; + if(subtree != NULL) { + t2->left = LTTV_TREE_NODE; + t2->l_child.t = subtree; + subtree = NULL; + t1->right = LTTV_TREE_NODE; + t1->r_child.t = t2; + } else { +// a_simple_expression->value = a_field_component->str; +// a_field_component = g_string_new(""); + t2->left = LTTV_TREE_LEAF; +// t2->l_child.leaf = a_simple_expression; +// a_simple_expression = g_new(lttv_simple_expression,1); + t1->right = LTTV_TREE_NODE; + t1->r_child.t = t2; + } + } /** @@ -120,24 +126,87 @@ void lttv_filter_tree_destroy(lttv_filter_tree* tree) { * @return success/failure of operation */ gboolean -parse_field_path(GPtrArray* fp) { +parse_field_path(GPtrArray* fp, LttvSimpleExpression* se) { GString* f = NULL; + if(fp->len < 2) return FALSE; g_assert(f=g_ptr_array_index(fp,0)); //list_first(fp)->data; - - if(g_quark_try_string(f->str) == LTTV_FILTER_EVENT) { -// parse_subfield(fp, LTTV_FILTER_EVENT); - - } else if(g_quark_try_string(f->str) == LTTV_FILTER_TRACEFILE) { - - } else if(g_quark_try_string(f->str) == LTTV_FILTER_TRACE) { - - } else if(g_quark_try_string(f->str) == LTTV_FILTER_STATE) { + + /* + * Parse through the specified + * hardcoded fields. + * + * Take note however that the + * 'event' subfields might change + * depending on values specified + * in core.xml file. Hence, if + * none of the subfields in the + * array match the hardcoded + * subfields, it will be considered + * as a dynamic field + */ + if(g_strcasecmp(f->str,"trace") ) { + /* + * Possible values: + * trace.name + */ + f=g_ptr_array_index(fp,1); + if(g_strcasecmp(f->str,"name")) {} + else return FALSE; + } else if(g_strcasecmp(f->str,"traceset") ) { + /* + * FIXME: not yet implemented ! + */ + } else if(g_strcasecmp(f->str,"tracefile") ) { + /* + * Possible values: + * tracefile.name + */ + f=g_ptr_array_index(fp,1); + if(g_strcasecmp(f->str,"name")) {} + else return FALSE; + } else if(g_strcasecmp(f->str,"state") ) { + /* + * Possible values: + * state.pid + * state.ppid + * state.creation_time + * state.insertion_time + * state.process_name + * state.execution_mode + * state.execution_submode + * state.process_status + * state.cpu + */ + f=g_ptr_array_index(fp,1); + if(g_strcasecmp(f->str,"pid") ) {} + else if(g_strcasecmp(f->str,"ppid") ) {} + else if(g_strcasecmp(f->str,"creation_time") ) {} + else if(g_strcasecmp(f->str,"insertion_time") ) {} + else if(g_strcasecmp(f->str,"process_name") ) {} + else if(g_strcasecmp(f->str,"execution_mode") ) {} + else if(g_strcasecmp(f->str,"execution_submode") ) {} + else if(g_strcasecmp(f->str,"process_status") ) {} + else if(g_strcasecmp(f->str,"cpu") ) {} + else return FALSE; + } else if(g_strcasecmp(f->str,"event") ) { + f=g_ptr_array_index(fp,1); + if(g_strcasecmp(f->str,"name") ) {} + else if(g_strcasecmp(f->str,"category") ) {} + else if(g_strcasecmp(f->str,"time") ) { + // offset = &((LttEvent*)NULL)->event_time); + } + else if(g_strcasecmp(f->str,"tsc") ) { + // offset = &((LttEvent*)NULL)->event_cycle_count); + } + else { /* core.xml specified options */ + } } else { g_warning("Unrecognized field in filter string"); return FALSE; } + return TRUE; } @@ -156,13 +225,281 @@ parse_simple_expression(GString* expression) { } +/** + * 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(guint64 v1, guint64 v2) {} + +/** + * 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(guint32 v1, guint32 v2) {} + +/** + * 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(guint16 v1, guint16 v2) {} + +/** + * 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(double v1, double v2) {} + +/** + * 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(char* v1, char* v2) {} + +/** + * 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(guint64 v1, guint64 v2) {} + +/** + * 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(guint32 v1, guint32 v2) {} + +/** + * 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(guint16 v1, guint16 v2) {} + +/** + * 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(double v1, double v2) {} + +/** + * 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(char* v1, char* v2) {} + +/** + * 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(guint64 v1, guint64 v2) {} + +/** + * 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(guint32 v1, guint32 v2) {} + +/** + * 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(guint16 v1, guint16 v2) {} + +/** + * 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(double v1, double v2) {} + +/** + * 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(guint64 v1, guint64 v2) {} + +/** + * 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(guint32 v1, guint32 v2) {} + +/** + * 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(guint16 v1, guint16 v2) {} + +/** + * 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(double v1, double v2) {} + +/** + * 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_gt_uint64(guint64 v1, guint64 v2) {} + +/** + * 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(guint32 v1, guint32 v2) {} + +/** + * 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(guint16 v1, guint16 v2) {} + +/** + * 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(double v1, double v2) {} + +/** + * 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_ge_uint64(guint64 v1, guint64 v2) {} + +/** + * 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(guint32 v1, guint32 v2) {} + +/** + * 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(guint16 v1, guint16 v2) {} + +/** + * 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(double v1, double v2) {} + + +/** + * 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) { + + + +} + +/** + * 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) { + + + LttvFilter* newfilter = g_new(LttvFilter,1); + + // newfilter->expression = g_new(char,1) + strcpy(newfilter->expression,filter->expression); + + newfilter->head = lttv_filter_tree_clone(filter->head); + + return newfilter; + +} + + /** * Creates a new lttv_filter * @param expression filtering options string * @param t pointer to the current LttvTrace * @return the current lttv_filter or NULL if error */ -lttv_filter_tree* +LttvFilter* lttv_filter_new(char *expression, LttvTraceState *tcs) { g_print("filter::lttv_filter_new()\n"); /* debug */ @@ -173,7 +510,7 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { b=0; /* current breakpoint in expression string */ /* trees */ - lttv_filter_tree + LttvFilterTree *tree = lttv_filter_tree_new(), /* main tree */ *subtree = NULL, /* buffer for subtrees */ *t1, /* buffer #1 */ @@ -195,7 +532,7 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { GString *a_field_component = g_string_new(""); GPtrArray *a_field_path = NULL; - lttv_simple_expression a_simple_expression; + LttvSimpleExpression* a_simple_expression = g_new(LttvSimpleExpression,1); /* * Parse entire expression and construct @@ -241,11 +578,10 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { * logical operators */ case '&': /* and */ - t1 = (lttv_filter_tree*)g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_UNDEFINED) t1 = t1->r_child.t; + t1 = (LttvFilterTree*)g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; t2 = lttv_filter_tree_new(); - t2->node->type = LTTV_EXPRESSION_OP; - t2->node->e.op = LTTV_LOGICAL_AND; + t2->node = LTTV_LOGICAL_AND; if(subtree != NULL) { t2->left = LTTV_TREE_NODE; t2->l_child.t = subtree; @@ -253,21 +589,21 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { t1->right = LTTV_TREE_NODE; t1->r_child.t = t2; } else { - a_simple_expression.value = a_field_component->str; + a_simple_expression->value = a_field_component->str; a_field_component = g_string_new(""); t2->left = LTTV_TREE_LEAF; - t2->l_child.leaf = g_new(lttv_simple_expression,1); + t2->l_child.leaf = a_simple_expression; + a_simple_expression = g_new(LttvSimpleExpression,1); t1->right = LTTV_TREE_NODE; t1->r_child.t = t2; } break; case '|': /* or */ - t1 = (lttv_filter_tree*)g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_UNDEFINED) t1 = t1->r_child.t; + t1 = (LttvFilter*)g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; t2 = lttv_filter_tree_new(); - t2->node->type = LTTV_EXPRESSION_OP; - t2->node->e.op = LTTV_LOGICAL_OR; + t2->node = LTTV_LOGICAL_OR; if(subtree != NULL) { t2->left = LTTV_TREE_NODE; t2->l_child.t = subtree; @@ -275,20 +611,20 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { t1->right = LTTV_TREE_NODE; t1->r_child.t = t2; } else { - a_simple_expression.value = a_field_component->str; + a_simple_expression->value = a_field_component->str; a_field_component = g_string_new(""); t2->left = LTTV_TREE_LEAF; - t2->l_child.leaf = g_new(lttv_simple_expression,1); + t2->l_child.leaf = a_simple_expression; + a_simple_expression = g_new(LttvSimpleExpression,1); t1->right = LTTV_TREE_NODE; t1->r_child.t = t2; } break; case '^': /* xor */ - t1 = (lttv_filter_tree*)g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_UNDEFINED) t1 = t1->r_child.t; + t1 = (LttvFilter*)g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; t2 = lttv_filter_tree_new(); - t2->node->type = LTTV_EXPRESSION_OP; - t2->node->e.op = LTTV_LOGICAL_XOR; + t2->node = LTTV_LOGICAL_XOR; if(subtree != NULL) { t2->left = LTTV_TREE_NODE; t2->l_child.t = subtree; @@ -296,26 +632,28 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { t1->right = LTTV_TREE_NODE; t1->r_child.t = t2; } else { - a_simple_expression.value = a_field_component->str; + a_simple_expression->value = a_field_component->str; a_field_component = g_string_new(""); t2->left = LTTV_TREE_LEAF; - t2->l_child.leaf = g_new(lttv_simple_expression,1); + t2->l_child.leaf = a_simple_expression; + a_simple_expression = g_new(LttvSimpleExpression,1); t1->right = LTTV_TREE_NODE; t1->r_child.t = t2; } break; case '!': /* not, or not equal (math op) */ if(expression[i+1] == '=') { /* != */ - a_simple_expression.op = LTTV_FIELD_NE; + a_simple_expression->op = LTTV_FIELD_NE; i++; + g_ptr_array_add( a_field_path,(gpointer) a_field_component ); + a_field_component = g_string_new(""); } else { /* ! */ // g_print("%s\n",a_field_component); // a_field_component = g_string_new(""); - t1 = (lttv_filter_tree*)g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_UNDEFINED) t1 = t1->r_child.t; + t1 = (LttvFilter*)g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; t2 = lttv_filter_tree_new(); - t2->node->type = LTTV_EXPRESSION_OP; - t2->node->e.op = LTTV_LOGICAL_NOT; + t2->node = LTTV_LOGICAL_NOT; t1->right = LTTV_TREE_NODE; t1->r_child.t = t2; } @@ -340,7 +678,7 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { g_assert(tree_stack->len>0); if(subtree != NULL) { t1 = g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_UNDEFINED && t1->right != LTTV_TREE_LEAF) { + 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; } @@ -349,12 +687,13 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { subtree = g_ptr_array_index(tree_stack,tree_stack->len-1); g_ptr_array_remove_index(tree_stack,tree_stack->len-1); } else { - a_simple_expression.value = a_field_component->str; + a_simple_expression->value = a_field_component->str; a_field_component = g_string_new(""); t1 = g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_UNDEFINED) t1 = t1->r_child.t; + while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; t1->right = LTTV_TREE_LEAF; - t1->r_child.leaf = g_new(lttv_simple_expression,1); + t1->r_child.leaf = a_simple_expression; + a_simple_expression = g_new(LttvSimpleExpression,1); 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); @@ -367,21 +706,21 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { case '<': /* lower, lower or equal */ if(expression[i+1] == '=') { /* <= */ i++; - a_simple_expression.op = LTTV_FIELD_LE; - } else a_simple_expression.op = LTTV_FIELD_LT; + a_simple_expression->op = LTTV_FIELD_LE; + } else a_simple_expression->op = LTTV_FIELD_LT; g_ptr_array_add( a_field_path,(gpointer) a_field_component ); a_field_component = g_string_new(""); break; case '>': /* higher, higher or equal */ if(expression[i+1] == '=') { /* >= */ i++; - a_simple_expression.op = LTTV_FIELD_GE; - } else a_simple_expression.op = LTTV_FIELD_GT; + a_simple_expression->op = LTTV_FIELD_GE; + } else a_simple_expression->op = LTTV_FIELD_GT; g_ptr_array_add( a_field_path,(gpointer) a_field_component ); a_field_component = g_string_new(""); break; case '=': /* equal */ - a_simple_expression.op = LTTV_FIELD_EQ; + a_simple_expression->op = LTTV_FIELD_EQ; g_ptr_array_add( a_field_path,(gpointer) a_field_component ); a_field_component = g_string_new(""); break; @@ -398,37 +737,90 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { } 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 + * if tree was constructed correctly + */ + if( p_nesting>0 ) { + g_warning("Wrong filtering options, the string\n\"%s\"\n\ + is not valid due to parenthesis incorrect use",expression); + return NULL; + } + + if(tree_stack->len != 1) /* only root tree should remain */ + return NULL; /* processing last element of expression */ - g_assert(tree_stack->len==1); /* only root tree should remain */ t1 = g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_UNDEFINED) t1 = t1->r_child.t; + while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; if(subtree != NULL) { /* add the subtree */ t1->right = LTTV_TREE_NODE; - t1->l_child.t = subtree; + t1->r_child.t = subtree; subtree = NULL; } else { /* add a leaf */ - a_simple_expression.value = a_field_component->str; + a_simple_expression->value = a_field_component->str; a_field_component = g_string_new(""); t1->right = LTTV_TREE_LEAF; - t1->r_child.leaf = g_new(lttv_simple_expression,1); + t1->r_child.leaf = a_simple_expression; + /* + * FIXME: is it really necessary to reallocate + * LttvSimpleExpression at this point ?? + */ + a_simple_expression = g_new(LttvSimpleExpression,1); } g_assert(tree != NULL); g_assert(subtree == NULL); - if( p_nesting>0 ) { - g_warning("Wrong filtering options, the string\n\"%s\"\n\ - is not valid due to parenthesis incorrect use",expression); - return NULL; - } - lttv_filter_tracefile(tree,NULL); return tree; } +void +lttv_filter_destroy(LttvFilter* filter) { + +} + +/** + * Assign a new tree for the current expression + * or sub expression + * @return pointer of LttvFilterTree + */ +LttvFilterTree* lttv_filter_tree_new() { + LttvFilterTree* tree; + + tree = g_new(LttvFilter,1); + tree->node = 0; //g_new(lttv_expression,1); +// tree->node->type = LTTV_UNDEFINED_EXPRESSION; + tree->left = LTTV_TREE_IDLE; + tree->right = LTTV_TREE_IDLE; + + return tree; +} + +/** + * 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); + 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); + else if(tree->right == LTTV_TREE_NODE) lttv_filter_tree_destroy(tree->r_child.t); + + g_free(tree->node); + g_free(tree); +} + + /** * Apply the filter to a specific trace * @param filter the current filter applied @@ -436,8 +828,10 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { * @return success/failure of operation */ gboolean -lttv_filter_tracefile(lttv_filter_tree *filter, LttTracefile *tracefile) { +lttv_filter_tracefile(LttvFilter *filter, LttTracefile *tracefile) { + LttvFilterTree* t = filter->head; + /* * Each tree is parsed in inorder. * This way, it's possible to apply the left filter of the @@ -449,14 +843,18 @@ lttv_filter_tracefile(lttv_filter_tree *filter, LttTracefile *tracefile) { * managing an array of all items to be removed .. */ - g_print("node:%p lchild:%p rchild:%p\n",filter,filter->l_child.t,filter->r_child.t); - if(filter->node->type == LTTV_EXPRESSION_OP) { - g_print("node type%i\n",filter->node->e.op); + g_print("node:%p lchild:%p rchild:%p\n",t,t->l_child.t,t->r_child.t); + g_print("node type%i\n",t->node); + if(t->left == LTTV_TREE_NODE) lttv_filter_tracefile(t->l_child.t,NULL); + else if(t->left == LTTV_TREE_LEAF) { + g_assert(t->l_child.leaf->value != NULL); + g_print("%p: left is qqch %i %s\n",t,t->l_child.leaf->op,t->l_child.leaf->value); + } + if(t->right == LTTV_TREE_NODE) lttv_filter_tracefile(t->r_child.t,NULL); + else if(t->right == LTTV_TREE_LEAF) { + g_assert(t->r_child.leaf->value != NULL); + g_print("%p: right is qqch %i %s\n",t,t->r_child.leaf->op,t->r_child.leaf->value); } - if(filter->left == LTTV_TREE_NODE) lttv_filter_tracefile(filter->l_child.t,NULL); - else g_print("%p: left is %i\n",filter,filter->left); - if(filter->right == LTTV_TREE_NODE) lttv_filter_tracefile(filter->r_child.t,NULL); - else g_print("%p: right is %i\n",filter,filter->right); /* test */ /* int i, nb; @@ -485,7 +883,7 @@ lttv_filter_tracefile(lttv_filter_tree *filter, LttTracefile *tracefile) { } gboolean -lttv_filter_tracestate(lttv_filter_t *filter, LttvTraceState *tracestate) { +lttv_filter_tracestate(LttvFilter *filter, LttvTraceState *tracestate) { } @@ -496,7 +894,7 @@ lttv_filter_tracestate(lttv_filter_t *filter, LttvTraceState *tracestate) { * @return success/failure of operation */ gboolean -lttv_filter_event(lttv_filter_t *filter, LttEvent *event) { +lttv_filter_event(LttvFilter *filter, LttEvent *event) { } @@ -514,30 +912,30 @@ static void module_init() */ /* 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"); +// 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"); +// 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"); +// 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"); +// 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"); }