X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Ffilter.c;h=dbdb16026f63abef0d89b8fa17cefe05b6cf0b8e;hb=2ea36caf80da2b86d4b565fe3cbded286c7664d7;hp=2cfc7d1018fd0adc41c4887332f5e9db887d418a;hpb=2a734d8ed3f5fd585402b4325bb6d14f969f9bd1;p=lttv.git

diff --git a/ltt/branches/poly/lttv/lttv/filter.c b/ltt/branches/poly/lttv/lttv/filter.c
index 2cfc7d10..dbdb1602 100644
--- a/ltt/branches/poly/lttv/lttv/filter.c
+++ b/ltt/branches/poly/lttv/lttv/filter.c
@@ -31,9 +31,7 @@
 /*
  *  TODO 
  *  - refine switch of expression in multiple uses functions
- *  - divide expression structure
- *    - a simple expression -> leaf
- *    - a logical operator -> node
+ *    - remove the idle expressions in the tree **** 
  *  - add the current simple expression to the tree
  */
 
@@ -81,18 +79,23 @@ GQuark
   LTTV_FILTER_EX_SUBMODE,
   LTTV_FILTER_P_STATUS,
   LTTV_FILTER_CPU;
-  
+
+LttvSimpleExpression* 
+lttv_simple_expression_new() {
+
+}
+
 /**
  *  Assign a new tree for the current expression
  *  or sub expression
- *  @return pointer of lttv_filter_tree
+ *  @return pointer of LttvFilter
  */
-lttv_filter_tree* lttv_filter_tree_new() {
-  lttv_filter_tree* tree;
+LttvFilter* lttv_filter_tree_new() {
+  LttvFilter* tree;
 
-  tree = g_new(lttv_filter_tree,1);
-  tree->node = g_new(lttv_expression,1);
-  tree->node->type = LTTV_UNDEFINED_EXPRESSION;
+  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;
 
@@ -103,7 +106,7 @@ lttv_filter_tree* lttv_filter_tree_new() {
  *  Destroys the tree and his sub-trees
  *  @param tree Tree which must be destroyed
  */
-void lttv_filter_tree_destroy(lttv_filter_tree* tree) {
+void lttv_filter_tree_destroy(LttvFilter* 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);
@@ -115,6 +118,47 @@ void lttv_filter_tree_destroy(lttv_filter_tree* tree) {
   g_free(tree);
 }
 
+LttvFilter*
+lttv_filter_clone(LttvFilter* tree) {
+
+    LttvFilter* newtree = lttv_filter_tree_new();
+
+    /*
+     * TODO : Copy tree into new tree
+     */
+    
+    return newtree;
+    
+}
+
+void
+lttv_filter_tree_add_node(GPtrArray* stack, LttvFilter* subtree, LttvLogicalOp op) {
+
+  LttvFilter* t1 = NULL;
+  LttvFilter* t2 = NULL;
+
+  t1 = (LttvFilter*)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; 
+  }
+  
+}
+
 /**
  *  Parse through filtering field hierarchy as specified 
  *  by user.  This function compares each value to 
@@ -192,7 +236,7 @@ parse_simple_expression(GString* expression) {
  * 	@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 */
@@ -203,7 +247,7 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) {
     b=0;	/* current breakpoint in expression string */
 
   /* trees */
-  lttv_filter_tree
+  LttvFilter
     *tree = lttv_filter_tree_new(),   /* main tree */
     *subtree = NULL,                  /* buffer for subtrees */
     *t1,                              /* buffer #1 */
@@ -225,7 +269,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
@@ -271,11 +315,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);
+        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_AND;
+        t2->node = LTTV_LOGICAL_AND;
         if(subtree != NULL) {
           t2->left = LTTV_TREE_NODE;
           t2->l_child.t = subtree;
@@ -283,21 +326,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);
+        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;
@@ -305,20 +348,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);
+        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;
@@ -326,26 +369,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);
+          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;
         }
@@ -379,12 +424,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_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);
@@ -397,21 +443,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;
@@ -428,37 +474,54 @@ 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_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) {
+
+}
+
 /**
  * 	Apply the filter to a specific trace
  * 	@param filter the current filter applied
@@ -466,7 +529,7 @@ 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) {
 
   /*
    *  Each tree is parsed in inorder.
@@ -480,13 +543,17 @@ lttv_filter_tracefile(lttv_filter_tree *filter, LttTracefile *tracefile) {
    */
   
   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 type%i\n",filter->node);
   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);
+  else if(filter->left == LTTV_TREE_LEAF) {
+    g_assert(filter->l_child.leaf->value != NULL);
+    g_print("%p: left is qqch %i %s\n",filter,filter->l_child.leaf->op,filter->l_child.leaf->value);
+  }
   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);
+  else if(filter->right == LTTV_TREE_LEAF) {
+    g_assert(filter->r_child.leaf->value != NULL);
+    g_print("%p: right is qqch %i %s\n",filter,filter->r_child.leaf->op,filter->r_child.leaf->value);
+  }
   
   /* test */
 /*  int i, nb;
@@ -515,7 +582,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) {
 
 }
 
@@ -526,7 +593,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) {
 
 }