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

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2003-2005 Michel Dagenais
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, 
 * 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 <lttv/filter.h>

/*
  read_token

  read_expression
    ( read expr )
    simple expr [ op expr ]

  read_simple_expression
    read_field_path [ rel value ]

  read_field_path
    read_field_component [. field path]

  read_field_component
    name [ \[ value \] ]

  data struct:
  and/or(left/right)
  not(child)
  op(left/right)
  path(component...) -> field
*/

GQuark
  LTTV_FILTER_TRACE,
  LTTV_FILTER_TRACESET,
  LTTV_FILTER_TRACEFILE,
  LTTV_FILTER_STATE,
  LTTV_FILTER_EVENT,
  LTTV_FILTER_NAME,
  LTTV_FILTER_CATEGORY,
  LTTV_FILTER_TIME,
  LTTV_FILTER_TSC,
  LTTV_FILTER_PID,
  LTTV_FILTER_PPID,
  LTTV_FILTER_C_TIME,
  LTTV_FILTER_I_TIME,
  LTTV_FILTER_P_NAME,
  LTTV_FILTER_EX_MODE,
  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;

  return tree;
}

/**
 *  Destroys the tree and his sub-trees
 *  @param tree Tree which must be destroyed
 */
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);
}

/**
 *  Parse through filtering field hierarchy as specified 
 *  by user.  This function compares each value to 
 *  predetermined quarks
 *  @param fp The field path list
 *  @return success/failure of operation
 */
gboolean
parse_field_path(GPtrArray* fp) {

  GString* f = NULL;
  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) {

  } else {
    g_warning("Unrecognized field in filter string");
    return FALSE;
  }
  return TRUE;  
}

/**
 * 	Add an filtering option to the current tree
 * 	@param expression Current expression to parse
 * 	@return success/failure of operation
 */
gboolean
parse_simple_expression(GString* expression) {
	
	unsigned i;

  
}

/**
 * 	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*
lttv_filter_new(char *expression, LttvTraceState *tcs) {

  g_print("filter::lttv_filter_new()\n");		/* debug */

  unsigned 	
    i, 
    p_nesting=0,	/* parenthesis nesting value */
    b=0;	/* current breakpoint in expression string */
	
  /* 
   * Main tree & Tree concatening list 
   * each element of the list
   * is a sub tree created 
   * by the use of parenthesis in the 
   * global expression.  The final tree 
   * will be the one created at the root of 
   * the list
   */
  lttv_filter_tree* tree = lttv_filter_tree_new(); 
  lttv_filter_tree* subtree = NULL;
  GPtrArray *tree_stack = g_ptr_array_new();
  g_ptr_array_add( tree_stack,(gpointer) tree );
  
  /* temporary values */
  GString *a_field_component = g_string_new(""); 
  GPtrArray *a_field_path = NULL;
    
  lttv_simple_expression a_simple_expression;
  
  /*
   *	Parse entire expression and construct
   *	the binary tree.  There are two steps 
   *	in browsing that string
   *	  1. finding boolean ops " &,|,^,! " and parenthesis " {,(,[,],),} "
   *	  2. finding simple expressions
   *	    - field path ( separated by dots )
   *	    - op ( >, <, =, >=, <=, !=)
   *	    - value ( integer, string ... )
   *	To spare computing time, the whole 
   *	string is parsed in this loop for a 
   *	O(n) complexity order.
   */

  /*
   *  When encountering logical op &,|,^
   *    1. parse the last value if any
   *    2. create a new tree
   *    3. add the expression (simple exp, or exp (subtree)) to the tree
   *    4. concatenate this tree with the current tree on top of the stack
   *  When encountering math ops >,>=,<,<=,=,!=
   *    1. add to op to the simple expression
   *    2. concatenate last field component to field path
   *  When encountering concatening ops .
   *    1. concatenate last field component to field path
   *  When encountering opening parenthesis (,{,[
   *    1. create a new subtree on top of tree stack
   *  When encountering closing parenthesis ),},]
   *    1. add the expression on right child of the current tree
   *    2. the subtree is completed, allocate a new subtree
   *    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 */

  lttv_filter_tree *t1, *t2;
  
  for(i=0;i<strlen(expression);i++) {
//    g_print("%s\n",a_field_component->str);
    g_print("%c ",expression[i]);
    switch(expression[i]) {
      /*
       *   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;
        t2 = lttv_filter_tree_new();
        t2->node->type = LTTV_EXPRESSION_OP;
        t2->node->e.op = LTTV_LOGICAL_AND;
        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 = g_new(lttv_simple_expression,1);
          t1->right = LTTV_TREE_NODE;
          t1->r_child.t = t2; 
        }
        
        break;
      case '|':   /* or */
        break;
      case '^':   /* xor */
        break;
      case '!':   /* not, or not equal (math op) */
        if(expression[i+1] == '=') {  /* != */
          a_simple_expression.op = LTTV_FIELD_NE;
          i++;
        } else {  /* ! */
          g_print("%s\n",a_field_component);
          a_field_component = g_string_new("");
        }
        break;
      case '(':   /* start of parenthesis */
      case '[':
      case '{':
        p_nesting++;      /* incrementing parenthesis nesting value */
        lttv_filter_tree* subtree = lttv_filter_tree_new();
        g_ptr_array_add( tree_stack,(gpointer) subtree );
        break;
      case ')':   /* end of parenthesis */
      case ']':
      case '}':
        p_nesting--;      /* decrementing parenthesis nesting value */
        if(p_nesting<0 || tree_stack->len<2) {
          g_warning("Wrong filtering options, the string\n\"%s\"\n\
                     is not valid due to parenthesis incorrect use",expression);	
          return NULL;
        }
        
        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) {
              g_assert(t1!=NULL && t1->r_child.t != NULL);
              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 {
          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;
          t1->right = LTTV_TREE_LEAF;
          t1->r_child.leaf = g_new(lttv_simple_expression,1);
          subtree = g_ptr_array_index(tree_stack,tree_stack->len-1);
          g_ptr_array_remove_index(tree_stack,tree_stack->len-1);
        }
      /*  lttv_filter_tree *sub1 = g_ptr_array_index(tree_list,tree_list->len-1);
        lttv_filter_tree *sub2 = g_ptr_array_index(tree_list,tree_list->len);
        if(sub1->left == LTTV_TREE_UNDEFINED){ 
          sub1->l_child.t = sub2;
          sub1->left = LTTV_TREE_NODE;
        } else if(sub1->right == LTTV_TREE_UNDEFINED){
          sub1->r_child.t = sub2; 
          sub1->right = LTTV_TREE_NODE;
        } else g_error("error during tree assignation");
        g_ptr_array_remove_index(tree_list,tree_list->len);
        break;
        */
      //  subtree = g_ptr_array_index(tree_stack,tree_stack->len);
      //  g_ptr_array_remove_index(tree_stack,tree_stack->len);
        break;

      /*	
       *	mathematic operators
       */
      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;
        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;
        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;
        g_ptr_array_add( a_field_path,(gpointer) a_field_component );
        a_field_component = g_string_new("");         
        break;
      /*
       *  Field concatening caracter
       */
      case '.':   /* dot */
        g_ptr_array_add( a_field_path,(gpointer) a_field_component );
        a_field_component = g_string_new("");
        break;
      default:    /* concatening current string */
        g_string_append_c(a_field_component,expression[i]); 				
    }
  }
 
  /*  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;
  if(subtree != NULL) {  /* add the subtree */
    t1->right = LTTV_TREE_NODE;
    t1->l_child.t = subtree;
    subtree = NULL;
  } else {  /* add a leaf */
    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);
  }
  
  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;
  }

  return tree;
  
}

/**
 * 	Apply the filter to a specific trace
 * 	@param filter the current filter applied
 * 	@param tracefile the trace to apply the filter to
 * 	@return success/failure of operation
 */
gboolean
lttv_filter_tracefile(lttv_filter_t *filter, LttTracefile *tracefile) {

  
  /* test */
/*  int i, nb;
  char *f_name, *e_name;

  char* field = "cpu";
   
  LttvTraceHook h;

  LttEventType *et;

  LttType *t;

  GString *fe_name = g_string_new("");

  nb = ltt_trace_eventtype_number(tcs->parent.t);
  g_print("NB:%i\n",nb);
  for(i = 0 ; i < nb ; i++) {
    et = ltt_trace_eventtype_get(tcs->parent.t, i);
    e_name = ltt_eventtype_name(et);
    f_name = ltt_facility_name(ltt_eventtype_facility(et));
    g_string_printf(fe_name, "%s.%s", f_name, e_name);
    g_print("facility:%s and event:%s\n",f_name,e_name);
  }
 */
}

gboolean
lttv_filter_tracestate(lttv_filter_t *filter, LttvTraceState *tracestate) {

}

/**
 * 	Apply the filter to a specific event
 * 	@param filter the current filter applied
 * 	@param event the event to apply the filter to
 * 	@return success/failure of operation
 */
gboolean
lttv_filter_event(lttv_filter_t *filter, LttEvent *event) {

}

/**
 *  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
 */
static void module_destroy() 
{
}


LTTV_MODULE("filter", "Filters traceset and events", \
    "Filters traceset and events specifically to user input", \
    module_init, module_destroy)
Commit	Line	Data
9c312311	1	/* This file is part of the Linux Trace Toolkit viewer
0769c82f	2	* Copyright (C) 2003-2005 Michel Dagenais
9c312311	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License Version 2 as
	6	* published by the Free Software Foundation;
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU General Public License
	14	* along with this program; if not, write to the Free Software
	15	* Foundation, Inc., 59 Temple Place - Suite 330, Boston,
	16	* MA 02111-1307, USA.
	17	*/
	18
31452f49	19	/*
48f6f3c2	20	consist in AND, OR and NOT nested expressions, forming a tree with
	21	simple relations as leaves. The simple relations test is a field
	22	in an event is equal, not equal, smaller, smaller or equal, larger, or
a4c292d4	23	larger or equal to a specified value.
a4c292d4	24	*/
48f6f3c2	25
0769c82f	26	/*
0769c82f	27	* YET TO BE ANSWERED
f4e9dd16	28	* - the exists an other lttv_filter which conflicts with this one
0769c82f	29	*/
0769c82f	30
410c83da	31	/*
	32	* TODO
	33	* - refine switch of expression in multiple uses functions
	34	* - add the current simple expression to the tree
	35	*/
	36
31452f49	37	#include <lttv/filter.h>
31452f49	38
31452f49	39	/*
a4c292d4	40	read_token
48f6f3c2	41
a4c292d4	42	read_expression
	43	( read expr )
	44	simple expr [ op expr ]
48f6f3c2	45
a4c292d4	46	read_simple_expression
a4c292d4	47	read_field_path [ rel value ]
48f6f3c2	48
a4c292d4	49	read_field_path
a4c292d4	50	read_field_component [. field path]
48f6f3c2	51
a4c292d4	52	read_field_component
a4c292d4	53	name [ \[ value \] ]
48f6f3c2	54
a4c292d4	55	data struct:
	56	and/or(left/right)
	57	not(child)
	58	op(left/right)
	59	path(component...) -> field
31452f49	60	*/
31452f49	61
1a7fa682	62	GQuark
	63	LTTV_FILTER_TRACE,
	64	LTTV_FILTER_TRACESET,
	65	LTTV_FILTER_TRACEFILE,
	66	LTTV_FILTER_STATE,
91ad3f0a	67	LTTV_FILTER_EVENT,
	68	LTTV_FILTER_NAME,
	69	LTTV_FILTER_CATEGORY,
	70	LTTV_FILTER_TIME,
	71	LTTV_FILTER_TSC,
	72	LTTV_FILTER_PID,
	73	LTTV_FILTER_PPID,
	74	LTTV_FILTER_C_TIME,
	75	LTTV_FILTER_I_TIME,
	76	LTTV_FILTER_P_NAME,
	77	LTTV_FILTER_EX_MODE,
	78	LTTV_FILTER_EX_SUBMODE,
	79	LTTV_FILTER_P_STATUS,
	80	LTTV_FILTER_CPU;
	81
f4e9dd16	82	/**
	83	* Assign a new tree for the current expression
	84	* or sub expression
	85	* @return pointer of lttv_filter_tree
	86	*/
	87	lttv_filter_tree* lttv_filter_tree_new() {
	88	lttv_filter_tree* tree;
	89
	90	tree = g_new(lttv_filter_tree,1);
	91	tree->node = g_new(lttv_expression,1);
	92	tree->node->type = LTTV_UNDEFINED_EXPRESSION;
	93	tree->left = LTTV_TREE_UNDEFINED;
	94	tree->right = LTTV_TREE_UNDEFINED;
	95
	96	return tree;
	97	}
	98
	99	/**
	100	* Destroys the tree and his sub-trees
	101	* @param tree Tree which must be destroyed
	102	*/
	103	void lttv_filter_tree_destroy(lttv_filter_tree* tree) {
	104
	105	if(tree->left == LTTV_TREE_LEAF) g_free(tree->l_child.leaf);
	106	else if(tree->left == LTTV_TREE_NODE) lttv_filter_tree_destroy(tree->l_child.t);
	107
	108	if(tree->right == LTTV_TREE_LEAF) g_free(tree->r_child.leaf);
	109	else if(tree->right == LTTV_TREE_NODE) lttv_filter_tree_destroy(tree->r_child.t);
	110
	111	g_free(tree->node);
	112	g_free(tree);
	113	}
1a7fa682	114
0769c82f	115	/**
	116	* Parse through filtering field hierarchy as specified
	117	* by user. This function compares each value to
	118	* predetermined quarks
	119	* @param fp The field path list
	120	* @return success/failure of operation
	121	*/
	122	gboolean
f4e9dd16	123	parse_field_path(GPtrArray* fp) {
0769c82f	124
f4e9dd16	125	GString* f = NULL;
f4e9dd16	126	g_assert(f=g_ptr_array_index(fp,0)); //list_first(fp)->data;
0769c82f	127
91ad3f0a	128	if(g_quark_try_string(f->str) == LTTV_FILTER_EVENT) {
	129	// parse_subfield(fp, LTTV_FILTER_EVENT);
	130
	131	} else if(g_quark_try_string(f->str) == LTTV_FILTER_TRACEFILE) {
	132
	133	} else if(g_quark_try_string(f->str) == LTTV_FILTER_TRACE) {
	134
	135	} else if(g_quark_try_string(f->str) == LTTV_FILTER_STATE) {
	136
	137	} else {
	138	g_warning("Unrecognized field in filter string");
	139	return FALSE;
0769c82f	140	}
91ad3f0a	141	return TRUE;
0769c82f	142	}
0769c82f	143
31452f49	144	/**
84a333d6	145	* Add an filtering option to the current tree
	146	* @param expression Current expression to parse
	147	* @return success/failure of operation
	148	*/
	149	gboolean
	150	parse_simple_expression(GString* expression) {
	151
	152	unsigned i;
	153
a4c292d4	154
0769c82f	155
a4c292d4	156
84a333d6	157	}
	158
	159	/**
	160	* Creates a new lttv_filter
31452f49	161	* @param expression filtering options string
31452f49	162	* @param t pointer to the current LttvTrace
84a333d6	163	* @return the current lttv_filter or NULL if error
31452f49	164	*/
f4e9dd16	165	lttv_filter_tree*
0769c82f	166	lttv_filter_new(char expression, LttvTraceState tcs) {
a4c292d4	167
0769c82f	168	g_print("filter::lttv_filter_new()\n"); /* debug */
a4c292d4	169
a4c292d4	170	unsigned
a4c292d4	171	i,
91ad3f0a	172	p_nesting=0, /* parenthesis nesting value */
a4c292d4	173	b=0; /* current breakpoint in expression string */
31452f49	174
f4e9dd16	175	/*
	176	* Main tree & Tree concatening list
	177	* each element of the list
	178	* is a sub tree created
	179	* by the use of parenthesis in the
	180	* global expression. The final tree
	181	* will be the one created at the root of
	182	* the list
	183	*/
18d1226f	184	lttv_filter_tree* tree = lttv_filter_tree_new();
f4e9dd16	185	lttv_filter_tree* subtree = NULL;
18d1226f	186	GPtrArray *tree_stack = g_ptr_array_new();
18d1226f	187	g_ptr_array_add( tree_stack,(gpointer) tree );
f4e9dd16	188
a4c292d4	189	/* temporary values */
0769c82f	190	GString *a_field_component = g_string_new("");
f4e9dd16	191	GPtrArray *a_field_path = NULL;
f4e9dd16	192
a4c292d4	193	lttv_simple_expression a_simple_expression;
0769c82f	194
a4c292d4	195	/*
	196	* Parse entire expression and construct
	197	* the binary tree. There are two steps
	198	* in browsing that string
f4e9dd16	199	* 1. finding boolean ops " &,\|,^,! " and parenthesis " {,(,[,],),} "
a4c292d4	200	* 2. finding simple expressions
0769c82f	201	* - field path ( separated by dots )
a4c292d4	202	* - op ( >, <, =, >=, <=, !=)
0769c82f	203	* - value ( integer, string ... )
	204	* To spare computing time, the whole
	205	* string is parsed in this loop for a
	206	* O(n) complexity order.
a4c292d4	207	*/
f4e9dd16	208
18d1226f	209	/*
	210	* When encountering logical op &,\|,^
	211	* 1. parse the last value if any
	212	* 2. create a new tree
	213	* 3. add the expression (simple exp, or exp (subtree)) to the tree
	214	* 4. concatenate this tree with the current tree on top of the stack
	215	* When encountering math ops >,>=,<,<=,=,!=
	216	* 1. add to op to the simple expression
	217	* 2. concatenate last field component to field path
	218	* When encountering concatening ops .
	219	* 1. concatenate last field component to field path
	220	* When encountering opening parenthesis (,{,[
	221	* 1. create a new subtree on top of tree stack
	222	* When encountering closing parenthesis ),},]
	223	* 1. add the expression on right child of the current tree
	224	* 2. the subtree is completed, allocate a new subtree
	225	* 3. pop the tree value from the tree stack
	226	*/
	227
f4e9dd16	228	a_field_path = g_ptr_array_new();
	229	g_ptr_array_set_size(a_field_path,2); /* by default, recording 2 field expressions */
	230
18d1226f	231	lttv_filter_tree t1, t2;
18d1226f	232
a4c292d4	233	for(i=0;i<strlen(expression);i++) {
18d1226f	234	// g_print("%s\n",a_field_component->str);
410c83da	235	g_print("%c ",expression[i]);
a4c292d4	236	switch(expression[i]) {
	237	/*
	238	* logical operators
	239	*/
	240	case '&': /* and */
410c83da	241	t1 = (lttv_filter_tree*)g_ptr_array_index(tree_stack,tree_stack->len-1);
18d1226f	242	while(t1->right != LTTV_TREE_UNDEFINED) t1 = t1->r_child.t;
	243	t2 = lttv_filter_tree_new();
	244	t2->node->type = LTTV_EXPRESSION_OP;
	245	t2->node->e.op = LTTV_LOGICAL_AND;
f4e9dd16	246	if(subtree != NULL) {
18d1226f	247	t2->left = LTTV_TREE_NODE;
18d1226f	248	t2->l_child.t = subtree;
f4e9dd16	249	subtree = NULL;
18d1226f	250	t1->right = LTTV_TREE_NODE;
410c83da	251	t1->r_child.t = t2;
f4e9dd16	252	} else {
18d1226f	253	a_simple_expression.value = a_field_component->str;
	254	a_field_component = g_string_new("");
	255	t2->left = LTTV_TREE_LEAF;
	256	t2->l_child.leaf = g_new(lttv_simple_expression,1);
	257	t1->right = LTTV_TREE_NODE;
410c83da	258	t1->r_child.t = t2;
f4e9dd16	259	}
	260
	261	break;
a4c292d4	262	case '\|': /* or */
f4e9dd16	263	break;
a4c292d4	264	case '^': /* xor */
a4c292d4	265	break;
	266	case '!': /* not, or not equal (math op) */
	267	if(expression[i+1] == '=') { /* != */
	268	a_simple_expression.op = LTTV_FIELD_NE;
	269	i++;
	270	} else { /* ! */
0769c82f	271	g_print("%s\n",a_field_component);
1a7fa682	272	a_field_component = g_string_new("");
a4c292d4	273	}
	274	break;
	275	case '(': /* start of parenthesis */
91ad3f0a	276	case '[':
	277	case '{':
	278	p_nesting++; /* incrementing parenthesis nesting value */
f4e9dd16	279	lttv_filter_tree* subtree = lttv_filter_tree_new();
18d1226f	280	g_ptr_array_add( tree_stack,(gpointer) subtree );
a4c292d4	281	break;
a4c292d4	282	case ')': /* end of parenthesis */
91ad3f0a	283	case ']':
	284	case '}':
	285	p_nesting--; /* decrementing parenthesis nesting value */
18d1226f	286	if(p_nesting<0 \|\| tree_stack->len<2) {
f4e9dd16	287	g_warning("Wrong filtering options, the string\n\"%s\"\n\
	288	is not valid due to parenthesis incorrect use",expression);
	289	return NULL;
	290	}
18d1226f	291
	292	g_assert(tree_stack->len>0);
	293	if(subtree != NULL) {
	294	t1 = g_ptr_array_index(tree_stack,tree_stack->len-1);
18d1226f	295	while(t1->right != LTTV_TREE_UNDEFINED && t1->right != LTTV_TREE_LEAF) {
	296	g_assert(t1!=NULL && t1->r_child.t != NULL);
	297	t1 = t1->r_child.t;
	298	}
	299	t1->right = LTTV_TREE_NODE;
	300	t1->r_child.t = subtree;
	301	subtree = g_ptr_array_index(tree_stack,tree_stack->len-1);
	302	g_ptr_array_remove_index(tree_stack,tree_stack->len-1);
	303	} else {
	304	a_simple_expression.value = a_field_component->str;
	305	a_field_component = g_string_new("");
	306	t1 = g_ptr_array_index(tree_stack,tree_stack->len-1);
	307	while(t1->right != LTTV_TREE_UNDEFINED) t1 = t1->r_child.t;
	308	t1->right = LTTV_TREE_LEAF;
	309	t1->r_child.leaf = g_new(lttv_simple_expression,1);
	310	subtree = g_ptr_array_index(tree_stack,tree_stack->len-1);
	311	g_ptr_array_remove_index(tree_stack,tree_stack->len-1);
	312	}
f4e9dd16	313	/* lttv_filter_tree *sub1 = g_ptr_array_index(tree_list,tree_list->len-1);
	314	lttv_filter_tree *sub2 = g_ptr_array_index(tree_list,tree_list->len);
	315	if(sub1->left == LTTV_TREE_UNDEFINED){
	316	sub1->l_child.t = sub2;
	317	sub1->left = LTTV_TREE_NODE;
	318	} else if(sub1->right == LTTV_TREE_UNDEFINED){
	319	sub1->r_child.t = sub2;
	320	sub1->right = LTTV_TREE_NODE;
	321	} else g_error("error during tree assignation");
	322	g_ptr_array_remove_index(tree_list,tree_list->len);
	323	break;
	324	*/
18d1226f	325	// subtree = g_ptr_array_index(tree_stack,tree_stack->len);
18d1226f	326	// g_ptr_array_remove_index(tree_stack,tree_stack->len);
a4c292d4	327	break;
	328
	329	/*
	330	* mathematic operators
	331	*/
	332	case '<': /* lower, lower or equal */
	333	if(expression[i+1] == '=') { /* <= */
	334	i++;
f4e9dd16	335	a_simple_expression.op = LTTV_FIELD_LE;
a4c292d4	336	} else a_simple_expression.op = LTTV_FIELD_LT;
f4e9dd16	337	g_ptr_array_add( a_field_path,(gpointer) a_field_component );
f4e9dd16	338	a_field_component = g_string_new("");
a4c292d4	339	break;
	340	case '>': /* higher, higher or equal */
	341	if(expression[i+1] == '=') { /* >= */
	342	i++;
f4e9dd16	343	a_simple_expression.op = LTTV_FIELD_GE;
a4c292d4	344	} else a_simple_expression.op = LTTV_FIELD_GT;
f4e9dd16	345	g_ptr_array_add( a_field_path,(gpointer) a_field_component );
f4e9dd16	346	a_field_component = g_string_new("");
a4c292d4	347	break;
	348	case '=': /* equal */
	349	a_simple_expression.op = LTTV_FIELD_EQ;
f4e9dd16	350	g_ptr_array_add( a_field_path,(gpointer) a_field_component );
f4e9dd16	351	a_field_component = g_string_new("");
a4c292d4	352	break;
0769c82f	353	/*
	354	* Field concatening caracter
	355	*/
	356	case '.': /* dot */
f4e9dd16	357	g_ptr_array_add( a_field_path,(gpointer) a_field_component );
0769c82f	358	a_field_component = g_string_new("");
0769c82f	359	break;
a4c292d4	360	default: /* concatening current string */
1a7fa682	361	g_string_append_c(a_field_component,expression[i]);
a4c292d4	362	}
a4c292d4	363	}
410c83da	364
	365	/* processing last element of expression */
	366	g_assert(tree_stack->len==1); /* only root tree should remain */
	367	t1 = g_ptr_array_index(tree_stack,tree_stack->len-1);
	368	while(t1->right != LTTV_TREE_UNDEFINED) t1 = t1->r_child.t;
	369	if(subtree != NULL) { /* add the subtree */
	370	t1->right = LTTV_TREE_NODE;
	371	t1->l_child.t = subtree;
	372	subtree = NULL;
	373	} else { /* add a leaf */
	374	a_simple_expression.value = a_field_component->str;
	375	a_field_component = g_string_new("");
	376	t1->right = LTTV_TREE_LEAF;
	377	t1->r_child.leaf = g_new(lttv_simple_expression,1);
	378	}
	379
	380	g_assert(tree != NULL);
	381	g_assert(subtree == NULL);
a4c292d4	382
91ad3f0a	383	if( p_nesting>0 ) {
a4c292d4	384	g_warning("Wrong filtering options, the string\n\"%s\"\n\
	385	is not valid due to parenthesis incorrect use",expression);
	386	return NULL;
	387	}
410c83da	388
	389	return tree;
	390
31452f49	391	}
31452f49	392
84a333d6	393	/**
	394	* Apply the filter to a specific trace
	395	* @param filter the current filter applied
	396	* @param tracefile the trace to apply the filter to
	397	* @return success/failure of operation
	398	*/
31452f49	399	gboolean
91ad3f0a	400	lttv_filter_tracefile(lttv_filter_t filter, LttTracefile tracefile) {
0769c82f	401
	402
	403
	404	/* test */
	405	/* int i, nb;
	406	char f_name, e_name;
31452f49	407
0769c82f	408	char* field = "cpu";
	409
	410	LttvTraceHook h;
	411
	412	LttEventType *et;
	413
	414	LttType *t;
	415
	416	GString *fe_name = g_string_new("");
	417
	418	nb = ltt_trace_eventtype_number(tcs->parent.t);
	419	g_print("NB:%i\n",nb);
	420	for(i = 0 ; i < nb ; i++) {
	421	et = ltt_trace_eventtype_get(tcs->parent.t, i);
	422	e_name = ltt_eventtype_name(et);
	423	f_name = ltt_facility_name(ltt_eventtype_facility(et));
	424	g_string_printf(fe_name, "%s.%s", f_name, e_name);
	425	g_print("facility:%s and event:%s\n",f_name,e_name);
	426	}
	427	*/
31452f49	428	}
31452f49	429
1a7fa682	430	gboolean
91ad3f0a	431	lttv_filter_tracestate(lttv_filter_t filter, LttvTraceState tracestate) {
341aa948	432
341aa948	433	}
1a7fa682	434
84a333d6	435	/**
	436	* Apply the filter to a specific event
	437	* @param filter the current filter applied
	438	* @param event the event to apply the filter to
	439	* @return success/failure of operation
	440	*/
31452f49	441	gboolean
91ad3f0a	442	lttv_filter_event(lttv_filter_t filter, LttEvent event) {
31452f49	443
31452f49	444	}
1a7fa682	445
91ad3f0a	446	/**
	447	* Initializes the filter module and specific values
	448	*/
1a7fa682	449	static void module_init()
1a7fa682	450	{
91ad3f0a	451
	452	/*
	453	* Quarks initialization
	454	* for hardcoded filtering options
	455	*
	456	* TODO: traceset has no yet been defined
	457	*/
	458
	459	/* top fields */
	460	LTTV_FILTER_EVENT = g_quark_from_string("event");
	461	LTTV_FILTER_TRACE = g_quark_from_string("trace");
	462	LTTV_FILTER_TRACESET = g_quark_from_string("traceset");
	463	LTTV_FILTER_STATE = g_quark_from_string("state");
	464	LTTV_FILTER_TRACEFILE = g_quark_from_string("tracefile");
1a7fa682	465
91ad3f0a	466	/* event.name, tracefile.name, trace.name */
	467	LTTV_FILTER_NAME = g_quark_from_string("name");
	468
	469	/* event sub fields */
	470	LTTV_FILTER_CATEGORY = g_quark_from_string("category");
	471	LTTV_FILTER_TIME = g_quark_from_string("time");
	472	LTTV_FILTER_TSC = g_quark_from_string("tsc");
	473
	474	/* state sub fields */
	475	LTTV_FILTER_PID = g_quark_from_string("pid");
	476	LTTV_FILTER_PPID = g_quark_from_string("ppid");
	477	LTTV_FILTER_C_TIME = g_quark_from_string("creation_time");
	478	LTTV_FILTER_I_TIME = g_quark_from_string("insertion_time");
	479	LTTV_FILTER_P_NAME = g_quark_from_string("process_name");
	480	LTTV_FILTER_EX_MODE = g_quark_from_string("execution_mode");
	481	LTTV_FILTER_EX_SUBMODE = g_quark_from_string("execution_submode");
	482	LTTV_FILTER_P_STATUS = g_quark_from_string("process_status");
	483	LTTV_FILTER_CPU = g_quark_from_string("cpu");
	484
1a7fa682	485	}
1a7fa682	486
91ad3f0a	487	/**
	488	* Destroys the filter module and specific values
	489	*/
1a7fa682	490	static void module_destroy()
	491	{
	492	}
	493
	494
91ad3f0a	495	LTTV_MODULE("filter", "Filters traceset and events", \
91ad3f0a	496	"Filters traceset and events specifically to user input", \
1a7fa682	497	module_init, module_destroy)
	498
	499
	500