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

/* This file is part of the Linux Trace Toolkit viewer
 * Copyright (C) 2003-2004 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. */

#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
*/

/**
 * 	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;

	for(i=0;i<strlen(expression);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*
lttv_filter_new(char *expression, LttvTrace *t) {

	unsigned 	
		i, 
		p=0,	/* parenthesis nesting value */
		b=0;	/* current breakpoint in expression string */
	
	gpointer tree;
		
	GString *current_option = g_string_new(""); 
	lttv_simple_expression current_expression;
	
	g_print("filter::lttv_filter_new()\n");		/* debug */

	/*
	 * 	1. parse expression
	 *	2. construct binary tree
	 * 	3. return corresponding filter
	 */

	/*
	 * 	Binary tree memory allocation
	 * 	- based upon a preliminary block size
	 */
	gulong size = (strlen(expression)/6) * 1.5;	
	tree = g_malloc(size*sizeof(lttv_filter_tree));
	
	/*
	 *	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
   *	    - op ( >, <, =, >=, <=, !=)
   *	    - value
	 */
	for(i=0;i<strlen(expression);i++) {
		switch(expression[i]) {
      /*
       *  boolean operators
       */
			case '&':		/* and */
				parse_simple_expression(currentOption);
				g_print("%s\n",&currentOption);
				currentOption = g_string_new("");
				break;
			case '|':		/* or */
				g_print("%s\n",currentOption);
				currentOption = g_string_new("");
				break;
			case '^':		/* xor */
				g_print("%s\n",currentOption);
				currentOption = g_string_new("");
				break;
			case '!':		/* not, or not equal (math op) */
        if(expression[i+1] == '=') {  /* != */
          current_expression.op = LTTV_FIELD_NE;
          i++;
        } else {  /* ! */
  				g_print("%s\n",currentOption);
  				currentOption = g_string_new("");
        }
        break;
			case '(':		/* start of parenthesis */
				p++;
				break;
			case ')':		/* end of parenthesis */
				p--;
				break;
      /*
       *  mathematic operators
       */
      case '<':   /* lower, lower or equal */
        if(expression[i+1] == '=') { /* <= */
          i++;
          current_expression.op = LTTV_FIELD_LE;                  
        } else current_expression.op = LTTV_FIELD_LT;
        break;
      case '>':   /* higher, higher or equal */
        if(expression[i+1] == '=') { /* >= */
          i++;
          current_expression.op = LTTV_FIELD_GE;                  
        } else current_expression.op = LTTV_FIELD_GT;
        break;
      case '=':   /* equal */
        current_expression.op = LTTV_FIELD_EQ;
        break;
      case 
			default:		/* concatening current string */
				g_string_append_c(currentOption,expression[i]); 				
		}
		
		
	}
	
	if( p>0 ) { 
		g_warning("Wrong filtering options, the string\n\"%s\"\n\ 
				is not valid due to parenthesis incorrect use",expression);	
		return NULL;
	}
}

/**
 * 	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 *filter, void *tracefile) {

}

/**
 * 	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 *filter, void *event) {

}
Commit	Line	Data
9c312311	1	/* This file is part of the Linux Trace Toolkit viewer
	2	* Copyright (C) 2003-2004 Michel Dagenais
	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
	23	larger or equal to a specified value. */
	24
31452f49	25	#include <lttv/filter.h>
31452f49	26
31452f49	27	/*
31452f49	28	read_token
48f6f3c2	29
31452f49	30	read_expression
	31	( read expr )
	32	simple expr [ op expr ]
48f6f3c2	33
31452f49	34	read_simple_expression
31452f49	35	read_field_path [ rel value ]
48f6f3c2	36
31452f49	37	read_field_path
31452f49	38	read_field_component [. field path]
48f6f3c2	39
31452f49	40	read_field_component
31452f49	41	name [ \[ value \] ]
48f6f3c2	42
31452f49	43	data struct:
	44	and/or(left/right)
	45	not(child)
	46	op(left/right)
	47	path(component...) -> field
	48	*/
	49
	50	/**
84a333d6	51	* Add an filtering option to the current tree
	52	* @param expression Current expression to parse
	53	* @return success/failure of operation
	54	*/
	55	gboolean
	56	parse_simple_expression(GString* expression) {
	57
	58	unsigned i;
	59
	60	for(i=0;i<strlen(expression);i++) {
84a333d6	61
	62	}
	63	}
	64
	65	/**
	66	* Creates a new lttv_filter
31452f49	67	* @param expression filtering options string
31452f49	68	* @param t pointer to the current LttvTrace
84a333d6	69	* @return the current lttv_filter or NULL if error
31452f49	70	*/
	71	lttv_filter*
	72	lttv_filter_new(char expression, LttvTrace t) {
48f6f3c2	73
84a333d6	74	unsigned
	75	i,
	76	p=0, /* parenthesis nesting value */
	77	b=0; /* current breakpoint in expression string */
	78
	79	gpointer tree;
	80
e854143a	81	GString *current_option = g_string_new("");
	82	lttv_simple_expression current_expression;
	83
31452f49	84	g_print("filter::lttv_filter_new()\n"); /* debug */
48f6f3c2	85
31452f49	86	/*
	87	* 1. parse expression
	88	* 2. construct binary tree
	89	* 3. return corresponding filter
	90	*/
	91
84a333d6	92	/*
	93	* Binary tree memory allocation
	94	* - based upon a preliminary block size
	95	*/
	96	gulong size = (strlen(expression)/6) * 1.5;
	97	tree = g_malloc(size*sizeof(lttv_filter_tree));
	98
	99	/*
	100	* Parse entire expression and construct
e854143a	101	* the binary tree. There are two steps
	102	* in browsing that string
	103	* 1. finding boolean ops ( &,\|,^,! ) and parenthesis
	104	* 2. finding simple expressions
	105	* - field path
	106	* - op ( >, <, =, >=, <=, !=)
	107	* - value
84a333d6	108	*/
	109	for(i=0;i<strlen(expression);i++) {
	110	switch(expression[i]) {
e854143a	111	/*
	112	* boolean operators
	113	*/
84a333d6	114	case '&': /* and */
	115	parse_simple_expression(currentOption);
	116	g_print("%s\n",&currentOption);
	117	currentOption = g_string_new("");
	118	break;
	119	case '\|': /* or */
	120	g_print("%s\n",currentOption);
	121	currentOption = g_string_new("");
	122	break;
	123	case '^': /* xor */
	124	g_print("%s\n",currentOption);
	125	currentOption = g_string_new("");
	126	break;
e854143a	127	case '!': /* not, or not equal (math op) */
	128	if(expression[i+1] == '=') { /* != */
	129	current_expression.op = LTTV_FIELD_NE;
	130	i++;
	131	} else { /* ! */
	132	g_print("%s\n",currentOption);
	133	currentOption = g_string_new("");
	134	}
	135	break;
84a333d6	136	case '(': /* start of parenthesis */
	137	p++;
	138	break;
	139	case ')': /* end of parenthesis */
	140	p--;
	141	break;
e854143a	142	/*
	143	* mathematic operators
	144	*/
	145	case '<': /* lower, lower or equal */
	146	if(expression[i+1] == '=') { /* <= */
	147	i++;
	148	current_expression.op = LTTV_FIELD_LE;
	149	} else current_expression.op = LTTV_FIELD_LT;
	150	break;
	151	case '>': /* higher, higher or equal */
	152	if(expression[i+1] == '=') { /* >= */
	153	i++;
	154	current_expression.op = LTTV_FIELD_GE;
	155	} else current_expression.op = LTTV_FIELD_GT;
	156	break;
	157	case '=': /* equal */
	158	current_expression.op = LTTV_FIELD_EQ;
	159	break;
	160	case
84a333d6	161	default: /* concatening current string */
	162	g_string_append_c(currentOption,expression[i]);
	163	}
	164
	165
	166	}
31452f49	167
84a333d6	168	if( p>0 ) {
	169	g_warning("Wrong filtering options, the string\n\"%s\"\n\
	170	is not valid due to parenthesis incorrect use",expression);
	171	return NULL;
	172	}
31452f49	173	}
31452f49	174
84a333d6	175	/**
	176	* Apply the filter to a specific trace
	177	* @param filter the current filter applied
	178	* @param tracefile the trace to apply the filter to
	179	* @return success/failure of operation
	180	*/
31452f49	181	gboolean
	182	lttv_filter_tracefile(lttv_filter filter, void tracefile) {
	183
	184	}
	185
84a333d6	186	/**
	187	* Apply the filter to a specific event
	188	* @param filter the current filter applied
	189	* @param event the event to apply the filter to
	190	* @return success/failure of operation
	191	*/
31452f49	192	gboolean
	193	lttv_filter_event(lttv_filter filter, void event) {
	194
	195	}