* - refine switch of expression in multiple uses functions
* - remove the idle expressions in the tree ****
* - add the current simple expression to the tree
+ * * clear the field_path array after use
*/
#include <lttv/filter.h>
LTTV_FILTER_CPU;
*/
+/**
+ * Constructor for LttvSimpleExpression
+ * @return pointer to new LttvSimpleExpression
+ */
LttvSimpleExpression*
lttv_simple_expression_new() {
+ LttvSimpleExpression* se = g_new(LttvSimpleExpression,1);
+
+ se->field = LTTV_FILTER_UNDEFINED;
+ se->op = NULL;
+ se->offset = 0;
+ se->value = NULL;
+
+ return se;
}
/**
* 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
* @param subtree the subtree if available (pointer or NULL)
* @param op the logical operator that will form the node
*/
void
-lttv_filter_tree_add_node(GPtrArray* stack, LttvFilter* subtree, LttvLogicalOp op) {
+lttv_filter_tree_add_node(GPtrArray* stack, LttvFilterTree* subtree, LttvLogicalOp op) {
- LttvFilter* t1 = NULL;
- LttvFilter* t2 = NULL;
+ LttvFilterTree* t1 = NULL;
+ LttvFilterTree* t2 = NULL;
- t1 = (LttvFilter*)g_ptr_array_index(stack,stack->len-1);
+ 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;
* by user. This function compares each value to
* predetermined quarks
* @param fp The field path list
+ * @param se current simple expression
* @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 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_quark_try_string(f->str) == LTTV_FILTER_NAME) {}
- else if(g_quark_try_string(f->str) == LTTV_FILTER_CATEGORY) {}
- else if(g_quark_try_string(f->str) == LTTV_FILTER_TIME) {
- // offset = &((LttEvent*)NULL)->event_time);
+ if(g_strcasecmp(f->str,"name")) {
+ se->field = LTTV_FILTER_TRACE_NAME;
}
- else if(g_quark_try_string(f->str) == LTTV_FILTER_TSC) {
- // offset = &((LttEvent*)NULL)->event_cycle_count);
- }
- else { /* core.xml specified options */
-
- }
- } else if(g_quark_try_string(f->str) == LTTV_FILTER_TRACEFILE) {
- f=g_ptr_array_index(fp,1);
- if(g_quark_try_string(f->str) == LTTV_FILTER_NAME) {}
else return FALSE;
- } else if(g_quark_try_string(f->str) == LTTV_FILTER_TRACE) {
+ } 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_quark_try_string(f->str) == LTTV_FILTER_NAME) {}
+ if(g_strcasecmp(f->str,"name")) {
+ se->field = LTTV_FILTER_TRACEFILE_NAME;
+ }
else return FALSE;
-
- } else if(g_quark_try_string(f->str) == LTTV_FILTER_STATE) {
+ } 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_quark_try_string(f->str) == LTTV_FILTER_PID) {}
- else if(g_quark_try_string(f->str) == LTTV_FILTER_PPID) {}
- else if(g_quark_try_string(f->str) == LTTV_FILTER_C_TIME) {}
- else if(g_quark_try_string(f->str) == LTTV_FILTER_I_TIME) {}
- else if(g_quark_try_string(f->str) == LTTV_FILTER_P_NAME) {}
- else if(g_quark_try_string(f->str) == LTTV_FILTER_EX_MODE) {}
- else if(g_quark_try_string(f->str) == LTTV_FILTER_EX_SUBMODE) {}
- else if(g_quark_try_string(f->str) == LTTV_FILTER_P_STATUS) {}
- else if(g_quark_try_string(f->str) == LTTV_FILTER_CPU) {}
+ if(g_strcasecmp(f->str,"pid") ) {
+ se->field = LTTV_FILTER_STATE_PID;
+ }
+ else if(g_strcasecmp(f->str,"ppid") ) {
+ se->field = LTTV_FILTER_STATE_PPID;
+ }
+ else if(g_strcasecmp(f->str,"creation_time") ) {
+ se->field = LTTV_FILTER_STATE_CT;
+ }
+ else if(g_strcasecmp(f->str,"insertion_time") ) {
+ se->field = LTTV_FILTER_STATE_IT;
+ }
+ else if(g_strcasecmp(f->str,"process_name") ) {
+ se->field = LTTV_FILTER_STATE_P_NAME;
+ }
+ else if(g_strcasecmp(f->str,"execution_mode") ) {
+ se->field = LTTV_FILTER_STATE_EX_MODE;
+ }
+ else if(g_strcasecmp(f->str,"execution_submode") ) {
+ se->field = LTTV_FILTER_STATE_EX_SUBMODE;
+ }
+ else if(g_strcasecmp(f->str,"process_status") ) {
+ se->field = LTTV_FILTER_STATE_P_STATUS;
+ }
+ 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:
+ * event.name
+ * event.category
+ * event.time
+ * event.tsc
+ */
+ f=g_ptr_array_index(fp,1);
+ if(g_strcasecmp(f->str,"name") ) {
+ se->field = LTTV_FILTER_EVENT_NAME;
+ }
+ else if(g_strcasecmp(f->str,"category") ) {
+ /*
+ * FIXME: Category not yet functional in lttv
+ */
+ se->field = LTTV_FILTER_EVENT_CATEGORY;
+ }
+ 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);
+
return TRUE;
}
+/**
+ * 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) {
+
+ switch(se->field) {
+ /* char */
+ case LTTV_FILTER_TRACE_NAME:
+ case LTTV_FILTER_TRACEFILE_NAME:
+ case LTTV_FILTER_STATE_P_NAME:
+ case LTTV_FILTER_EVENT_NAME:
+ switch(op) {
+ case LTTV_FIELD_EQ:
+ se->op = lttv_apply_op_eq_string;
+ break;
+ case LTTV_FIELD_NE:
+ se->op = lttv_apply_op_eq_string;
+ break;
+ default:
+ g_warning("Error encountered in operator assignment");
+ return FALSE;
+ }
+ break;
+ 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:
+ switch(op) {
+ case LTTV_FIELD_EQ:
+ se->op = lttv_apply_op_eq_uint64;
+ break;
+ case LTTV_FIELD_NE:
+ se->op = lttv_apply_op_ne_uint64;
+ break;
+ case LTTV_FIELD_LT:
+ se->op = lttv_apply_op_lt_uint64;
+ break;
+ case LTTV_FIELD_LE:
+ se->op = lttv_apply_op_le_uint64;
+ break;
+ case LTTV_FIELD_GT:
+ se->op = lttv_apply_op_gt_uint64;
+ break;
+ case LTTV_FIELD_GE:
+ se->op = lttv_apply_op_ge_uint64;
+ break;
+ default:
+ g_warning("Error encountered in operator assignment");
+ return FALSE;
+ }
+ break;
+ 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;
+ break;
+ case LTTV_FIELD_NE:
+ se->op = lttv_apply_op_ne_double;
+ break;
+ case LTTV_FIELD_LT:
+ se->op = lttv_apply_op_lt_double;
+ break;
+ case LTTV_FIELD_LE:
+ se->op = lttv_apply_op_le_double;
+ break;
+ case LTTV_FIELD_GT:
+ se->op = lttv_apply_op_gt_double;
+ break;
+ case LTTV_FIELD_GE:
+ se->op = lttv_apply_op_ge_double;
+ break;
+ default:
+ g_warning("Error encountered in operator assignment");
+ return FALSE;
+ }
+ break;
+ default:
+ g_warning("Error encountered in operator assignment");
+ return FALSE;
+ }
+
+}
+
/**
* Add an filtering option to the current tree
* @param expression Current expression to parse
/**
* Applies the 'equal' operator to the
- * specified structure and value
+ * 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) {
+
+ guint64* r = (guint64*) v1;
+ guint64 l = atoi(v2);
+ return (*r == l);
+
+}
+
+/**
+ * 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) {
+ guint32* r = (guint32*) v1;
+ guint32 l = atoi(v2);
+ return (*r == l);
+}
+
+/**
+ * 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) {
+ guint16* r = (guint16*) v1;
+ guint16 l = atoi(v2);
+ return (*r == l);
+}
+
+/**
+ * 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() {
+gboolean lttv_apply_op_eq_double(gpointer v1, char* v2) {
+ double* r = (double*) v1;
+ double l = atof(v2);
+ return (*r == l);
+}
+/**
+ * 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) {
+ char* r = (char*) v1;
+ return (g_strcasecmp(r,v2));
}
/**
* Applies the 'not equal' operator to the
- * specified structure and value
+ * 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() {
+gboolean lttv_apply_op_ne_uint64(gpointer v1, char* v2) {
+ guint64* r = (guint64*) v1;
+ guint64 l = atoi(v2);
+ return (*r != l);
+}
+/**
+ * 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) {
+ guint32* r = (guint32*) v1;
+ guint32 l = atoi(v2);
+ return (*r != l);
+}
+
+/**
+ * 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) {
+ guint16* r = (guint16*) v1;
+ guint16 l = atoi(v2);
+ return (*r != l);
+}
+
+/**
+ * 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) {
+ double* r = (double*) v1;
+ double l = atof(v2);
+ return (*r != l);
+}
+
+/**
+ * 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) {
+ char* r = (char*) v1;
+ return (!g_strcasecmp(r,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(gpointer v1, char* v2) {
+ guint64* r = (guint64*) v1;
+ guint64 l = atoi(v2);
+ return (*r < l);
+}
+
+/**
+ * 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) {
+ guint32* r = (guint32*) v1;
+ guint32 l = atoi(v2);
+ return (*r < l);
+}
+
+/**
+ * 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) {
+ guint16* r = (guint16*) v1;
+ guint16 l = atoi(v2);
+ return (*r < l);
+}
+
+/**
+ * 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) {
+ double* r = (double*) v1;
+ double l = atof(v2);
+ return (*r < l);
}
/**
* Applies the 'lower than' operator to the
- * specified structure and value
+ * 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) {
+ guint64* r = (guint64*) v1;
+ guint64 l = atoi(v2);
+ return (*r <= l);
+}
+
+/**
+ * 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_lt() {
+gboolean lttv_apply_op_le_uint32(gpointer v1, char* v2) {
+ guint32* r = (guint32*) v1;
+ guint32 l = atoi(v2);
+ return (*r <= l);
+}
+/**
+ * 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) {
+ guint16* r = (guint16*) v1;
+ guint16 l = atoi(v2);
+ return (*r <= l);
}
/**
* Applies the 'lower or equal' operator to the
- * specified structure and value
+ * 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) {
+ double* r = (double*) v1;
+ double l = atof(v2);
+ return (*r <= l);
+}
+
+/**
+ * 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_le() {
+gboolean lttv_apply_op_gt_uint64(gpointer v1, char* v2) {
+ guint64* r = (guint64*) v1;
+ guint64 l = atoi(v2);
+ return (*r > l);
+}
+/**
+ * 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) {
+ guint32* r = (guint32*) v1;
+ guint32 l = atoi(v2);
+ return (*r > l);
+}
+
+/**
+ * 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) {
+ guint16* r = (guint16*) v1;
+ guint16 l = atoi(v2);
+ return (*r > l);
}
/**
* Applies the 'greater than' operator to the
- * specified structure and value
+ * 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() {
+gboolean lttv_apply_op_gt_double(gpointer v1, char* v2) {
+ double* r = (double*) v1;
+ double l = atof(v2);
+ return (*r > l);
+}
+/**
+ * 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) {
+ guint64* r = (guint64*) v1;
+ guint64 l = atoi(v2);
+ return (*r >= l);
}
/**
* Applies the 'greater or equal' operator to the
- * specified structure and value
+ * 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() {
+gboolean lttv_apply_op_ge_uint32(gpointer v1, char* v2) {
+ guint32* r = (guint32*) v1;
+ guint32 l = atoi(v2);
+ return (*r >= l);
+}
+/**
+ * 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) {
+ guint16* r = (guint16*) v1;
+ guint16 l = atoi(v2);
+ return (*r >= l);
}
+/**
+ * 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) {
+ double* r = (double*) v1;
+ double l = atof(v2);
+ return (*r >= l);
+}
/**
b=0; /* current breakpoint in expression string */
/* trees */
- LttvFilter
+ LttvFilterTree
*tree = lttv_filter_tree_new(), /* main tree */
*subtree = NULL, /* buffer for subtrees */
*t1, /* buffer #1 */
GString *a_field_component = g_string_new("");
GPtrArray *a_field_path = NULL;
- LttvSimpleExpression* a_simple_expression = g_new(LttvSimpleExpression,1);
+ LttvSimpleExpression* a_simple_expression = lttv_simple_expression_new();
/*
* Parse entire expression and construct
* logical operators
*/
case '&': /* and */
- t1 = (LttvFilter*)g_ptr_array_index(tree_stack,tree_stack->len-1);
+ 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 = LTTV_LOGICAL_AND;
- if(subtree != NULL) {
+ if(subtree != NULL) { /* append subtree to current tree */
t2->left = LTTV_TREE_NODE;
t2->l_child.t = subtree;
subtree = NULL;
t1->right = LTTV_TREE_NODE;
t1->r_child.t = t2;
- } else {
+ } else { /* append a simple expression */
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(LttvSimpleExpression,1);
+ a_simple_expression = lttv_simple_expression_new();
t1->right = LTTV_TREE_NODE;
t1->r_child.t = t2;
}
while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t;
t2 = lttv_filter_tree_new();
t2->node = LTTV_LOGICAL_OR;
- if(subtree != NULL) {
+ if(subtree != NULL) { /* append subtree to current tree */
t2->left = LTTV_TREE_NODE;
t2->l_child.t = subtree;
subtree = NULL;
t1->right = LTTV_TREE_NODE;
t1->r_child.t = t2;
- } else {
+ } else { /* append a simple expression */
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(LttvSimpleExpression,1);
+ a_simple_expression = lttv_simple_expression_new();
t1->right = LTTV_TREE_NODE;
t1->r_child.t = t2;
}
while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t;
t2 = lttv_filter_tree_new();
t2->node = LTTV_LOGICAL_XOR;
- if(subtree != NULL) {
+ if(subtree != NULL) { /* append subtree to current tree */
t2->left = LTTV_TREE_NODE;
t2->l_child.t = subtree;
subtree = NULL;
t1->right = LTTV_TREE_NODE;
t1->r_child.t = t2;
- } else {
+ } else { /* append a simple expression */
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(LttvSimpleExpression,1);
+ a_simple_expression = lttv_simple_expression_new();
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;
+ assign_operator(a_simple_expression,LTTV_FIELD_NE);
i++;
g_ptr_array_add( a_field_path,(gpointer) a_field_component );
+ parse_field_path(a_field_path,a_simple_expression);
a_field_component = g_string_new("");
} else { /* ! */
// g_print("%s\n",a_field_component);
}
g_assert(tree_stack->len>0);
- if(subtree != NULL) {
+ 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->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 {
+ } else { /* assign subtree as current tree */
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 = a_simple_expression;
- a_simple_expression = g_new(LttvSimpleExpression,1);
+ 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);
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;
+ assign_operator(a_simple_expression,LTTV_FIELD_LE);
+ } else assign_operator(a_simple_expression,LTTV_FIELD_LT);
g_ptr_array_add( a_field_path,(gpointer) a_field_component );
+ parse_field_path(a_field_path,a_simple_expression);
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 );
+ assign_operator(a_simple_expression,LTTV_FIELD_GE);
+ } else assign_operator(a_simple_expression,LTTV_FIELD_GT);
+ g_ptr_array_add( a_field_path,(gpointer) a_field_component );
+ parse_field_path(a_field_path,a_simple_expression);
a_field_component = g_string_new("");
break;
case '=': /* equal */
- a_simple_expression->op = LTTV_FIELD_EQ;
+ assign_operator(a_simple_expression,LTTV_FIELD_EQ);
g_ptr_array_add( a_field_path,(gpointer) a_field_component );
+ parse_field_path(a_field_path,a_simple_expression);
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("");
+ /*
+ * divide field expression into elements
+ * in a_field_path array.
+ */
+ if(a_simple_expression->op != NULL) {
+ 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]);
* FIXME: is it really necessary to reallocate
* LttvSimpleExpression at this point ??
*/
- a_simple_expression = g_new(LttvSimpleExpression,1);
+ a_simple_expression = lttv_simple_expression_new();
}
g_assert(tree != NULL);
gboolean
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
* 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);
- g_print("node type%i\n",filter->node);
- if(filter->left == LTTV_TREE_NODE) lttv_filter_tracefile(filter->l_child.t,NULL);
- 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);
+ 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(filter->right == LTTV_TREE_NODE) lttv_filter_tracefile(filter->r_child.t,NULL);
- 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);
+ 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);
}
/* test */
*/
/* 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");
}