X-Git-Url: https://git.liburcu.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Ffilter.c;h=e1066eeea071e116219286c974536d5dec40abff;hb=d564d2ad46f6d25d814c22f28c344f3adf418e12;hp=a837317d7913beda14ed4f718aff0c2558c17c37;hpb=6e0d58d62e75ecf147ebadb1e23b927d772e9a3a;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/filter.c b/ltt/branches/poly/lttv/lttv/filter.c index a837317d..e1066eee 100644 --- a/ltt/branches/poly/lttv/lttv/filter.c +++ b/ltt/branches/poly/lttv/lttv/filter.c @@ -31,25 +31,28 @@ * LttvTracefileContext{} * |->event\ * | |->name (String, converted to GQuark) + * | |->facility (String, converted to GQuark) * | |->category (String, not yet implemented) * | |->time (LttTime) * | |->tsc (LttCycleCount --> uint64) * | |->fields - * | |->"event name" - * | |->"field name" - * | |->"sub-field name" - * | |->... - * | |->"leaf-field name" (field type) + * | |->"facility_name + * | |->"event name" + * | |->"field name" + * | |->"sub-field name" + * | |->... + * | |->"leaf-field name" (field type) * |->tracefile * | |->name (String, converted to GQuark) * |->trace * | |->name (String, converted to GQuark) * |->state - * |->pid (uint64) - * |->ppid (uint64) + * |->pid (guint) + * |->ppid (guint) * |->creation_time (LttTime) * |->insertion_time (LttTime) * |->process_name (String, converted to GQuark) + * |->thread_brand (String, converted to GQuark) * |->execution_mode (LttvExecutionMode) * |->execution_submode (LttvExecutionSubmode) * |->process_status (LttvProcessStatus) @@ -73,9 +76,11 @@ #include #endif +#include #include #include #include +#include #include #include @@ -160,6 +165,7 @@ lttv_simple_expression_assign_field(GPtrArray* fp, LttvSimpleExpression* se) { * state.creation_time * state.insertion_time * state.process_name + * state.thread_brand * state.execution_mode * state.execution_submode * state.process_status @@ -182,6 +188,9 @@ lttv_simple_expression_assign_field(GPtrArray* fp, LttvSimpleExpression* se) { else if(!g_strcasecmp(f->str,"process_name") ) { se->field = LTTV_FILTER_STATE_P_NAME; } + else if(!g_strcasecmp(f->str,"thread_brand") ) { + se->field = LTTV_FILTER_STATE_T_BRAND; + } else if(!g_strcasecmp(f->str,"execution_mode") ) { se->field = LTTV_FILTER_STATE_EX_MODE; } @@ -201,12 +210,16 @@ lttv_simple_expression_assign_field(GPtrArray* fp, LttvSimpleExpression* se) { * event.category * event.time * event.tsc + * event.field */ g_string_free(f,TRUE); f=g_ptr_array_remove_index(fp,0); if(!g_strcasecmp(f->str,"name") ) { se->field = LTTV_FILTER_EVENT_NAME; } + else if(!g_strcasecmp(f->str,"facility") ) { + se->field = LTTV_FILTER_EVENT_FACILITY; + } else if(!g_strcasecmp(f->str,"category") ) { /* * FIXME: Category not yet functional in lttv @@ -219,10 +232,20 @@ lttv_simple_expression_assign_field(GPtrArray* fp, LttvSimpleExpression* se) { else if(!g_strcasecmp(f->str,"tsc") ) { se->field = LTTV_FILTER_EVENT_TSC; } - else { /* core.xml specified options */ + else if(!g_strcasecmp(f->str,"field") ) { se->field = LTTV_FILTER_EVENT_FIELD; + g_string_free(f,TRUE); + f=g_ptr_array_remove_index(fp,0); + + } else { + g_string_free(f,TRUE); + f=g_ptr_array_remove_index(fp,0); + g_warning("Unknown event filter subtype %s", f->str); } } else { + g_string_free(f,TRUE); + f=g_ptr_array_remove_index(fp,0); + g_warning("Unrecognized field in filter string"); } @@ -258,7 +281,9 @@ lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvExpressionO case LTTV_FILTER_TRACE_NAME: case LTTV_FILTER_TRACEFILE_NAME: case LTTV_FILTER_STATE_P_NAME: + case LTTV_FILTER_STATE_T_BRAND: case LTTV_FILTER_EVENT_NAME: + case LTTV_FILTER_EVENT_FACILITY: case LTTV_FILTER_STATE_EX_MODE: case LTTV_FILTER_STATE_EX_SUBMODE: case LTTV_FILTER_STATE_P_STATUS: @@ -303,29 +328,29 @@ lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvExpressionO } break; /* - * 32 bits unsigned integers + * unsigned integers */ case LTTV_FILTER_STATE_CPU: case LTTV_FILTER_STATE_PID: case LTTV_FILTER_STATE_PPID: switch(op) { case LTTV_FIELD_EQ: - se->op = lttv_apply_op_eq_uint32; + se->op = lttv_apply_op_eq_uint; break; case LTTV_FIELD_NE: - se->op = lttv_apply_op_ne_uint32; + se->op = lttv_apply_op_ne_uint; break; case LTTV_FIELD_LT: - se->op = lttv_apply_op_lt_uint32; + se->op = lttv_apply_op_lt_uint; break; case LTTV_FIELD_LE: - se->op = lttv_apply_op_le_uint32; + se->op = lttv_apply_op_le_uint; break; case LTTV_FIELD_GT: - se->op = lttv_apply_op_gt_uint32; + se->op = lttv_apply_op_gt_uint; break; case LTTV_FIELD_GE: - se->op = lttv_apply_op_ge_uint32; + se->op = lttv_apply_op_ge_uint; break; default: g_warning("Error encountered in operator assignment"); @@ -417,12 +442,14 @@ lttv_simple_expression_assign_value(LttvSimpleExpression* se, char* value) { case LTTV_FILTER_TRACE_NAME: case LTTV_FILTER_TRACEFILE_NAME: case LTTV_FILTER_STATE_P_NAME: + case LTTV_FILTER_STATE_T_BRAND: case LTTV_FILTER_EVENT_NAME: + case LTTV_FILTER_EVENT_FACILITY: case LTTV_FILTER_STATE_EX_MODE: case LTTV_FILTER_STATE_EX_SUBMODE: case LTTV_FILTER_STATE_P_STATUS: // se->value.v_string = value; - se->value.v_uint32 = g_quark_from_string(value); + se->value.v_quark = g_quark_from_string(value); g_free(value); break; /* @@ -433,12 +460,12 @@ lttv_simple_expression_assign_value(LttvSimpleExpression* se, char* value) { g_free(value); break; /* - * 32 bits integer + * unsigned integers */ case LTTV_FILTER_STATE_PID: case LTTV_FILTER_STATE_PPID: case LTTV_FILTER_STATE_CPU: - se->value.v_uint32 = atoi(value); + se->value.v_uint = atoi(value); g_free(value); break; /* @@ -461,7 +488,7 @@ lttv_simple_expression_assign_value(LttvSimpleExpression* se, char* value) { t.tv_sec = atoi(v->str); g_string_free(v,TRUE); v = g_string_new(""); - } else g_string_append_c(v,value[i]); + } else v = g_string_append_c(v,value[i]); } /* number can be integer or double */ if(is_double) t.tv_nsec = atoi(v->str); @@ -528,6 +555,7 @@ lttv_struct_type(gint ft) { case LTTV_FILTER_STATE_CT: case LTTV_FILTER_STATE_IT: case LTTV_FILTER_STATE_P_NAME: + case LTTV_FILTER_STATE_T_BRAND: case LTTV_FILTER_STATE_EX_MODE: case LTTV_FILTER_STATE_EX_SUBMODE: case LTTV_FILTER_STATE_P_STATUS: @@ -535,6 +563,7 @@ lttv_struct_type(gint ft) { return LTTV_FILTER_STATE; break; case LTTV_FILTER_EVENT_NAME: + case LTTV_FILTER_EVENT_FACILITY: case LTTV_FILTER_EVENT_CATEGORY: case LTTV_FILTER_EVENT_TIME: case LTTV_FILTER_EVENT_TSC: @@ -546,6 +575,22 @@ lttv_struct_type(gint ft) { } } +/** + * @fn gboolean lttv_apply_op_eq_uint(gpointer,LttvFieldValue) + * + * 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_uint(const gpointer v1, LttvFieldValue v2) { + + guint* r = (guint*) v1; + return (*r == v2.v_uint); + +} + /** * @fn gboolean lttv_apply_op_eq_uint64(gpointer,LttvFieldValue) * @@ -629,8 +674,7 @@ gboolean lttv_apply_op_eq_string(const gpointer v1, LttvFieldValue v2) { */ gboolean lttv_apply_op_eq_quark(const gpointer v1, LttvFieldValue v2) { GQuark* r = (GQuark*) v1; -// g_print("v1:%i v2:%i\n",*r,v2.v_uint32); - return (*r == v2.v_uint32); + return (*r == v2.v_quark); } /** @@ -647,6 +691,19 @@ gboolean lttv_apply_op_eq_ltttime(const gpointer v1, LttvFieldValue v2) { return ltt_time_compare(*r, v2.v_ltttime)==0?1:0; } +/** + * @fn gboolean lttv_apply_op_ne_uint(gpointer,LttvFieldValue) + * + * 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_uint(const gpointer v1, LttvFieldValue v2) { + guint* r = (guint*) v1; + return (*r != v2.v_uint); +} /** * @fn gboolean lttv_apply_op_ne_uint64(gpointer,LttvFieldValue) @@ -729,7 +786,7 @@ gboolean lttv_apply_op_ne_string(const gpointer v1, LttvFieldValue v2) { */ gboolean lttv_apply_op_ne_quark(const gpointer v1, LttvFieldValue v2) { GQuark* r = (GQuark*) v1; - return (*r != v2.v_uint32); + return (*r != v2.v_quark); } @@ -747,6 +804,19 @@ gboolean lttv_apply_op_ne_ltttime(const gpointer v1, LttvFieldValue v2) { return ltt_time_compare(*r, v2.v_ltttime)!=0?1:0; } +/** + * @fn gboolean lttv_apply_op_lt_uint(gpointer,LttvFieldValue) + * + * 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_uint(const gpointer v1, LttvFieldValue v2) { + guint* r = (guint*) v1; + return (*r < v2.v_uint); +} /** * @fn gboolean lttv_apply_op_lt_uint64(gpointer,LttvFieldValue) @@ -819,6 +889,19 @@ gboolean lttv_apply_op_lt_ltttime(const gpointer v1, LttvFieldValue v2) { return ltt_time_compare(*r, v2.v_ltttime)==-1?1:0; } +/** + * @fn gboolean lttv_apply_op_le_uint(gpointer,LttvFieldValue) + * + * 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_uint(const gpointer v1, LttvFieldValue v2) { + guint* r = (guint*) v1; + return (*r <= v2.v_uint); +} /** * @fn gboolean lttv_apply_op_le_uint64(gpointer,LttvFieldValue) @@ -892,6 +975,20 @@ gboolean lttv_apply_op_le_ltttime(const gpointer v1, LttvFieldValue v2) { } +/** + * @fn gboolean lttv_apply_op_gt_uint(gpointer,LttvFieldValue) + * + * 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_uint(const gpointer v1, LttvFieldValue v2) { + guint* r = (guint*) v1; + return (*r > v2.v_uint); +} + /** * @fn gboolean lttv_apply_op_gt_uint64(gpointer,LttvFieldValue) * @@ -963,6 +1060,19 @@ gboolean lttv_apply_op_gt_ltttime(const gpointer v1, LttvFieldValue v2) { return ltt_time_compare(*r, v2.v_ltttime)==1?1:0; } +/** + * @fn gboolean lttv_apply_op_ge_uint(gpointer,LttvFieldValue) + * + * 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_uint(const gpointer v1, LttvFieldValue v2) { + guint* r = (guint*) v1; + return (*r >= v2.v_uint); +} /** * @fn gboolean lttv_apply_op_ge_uint64(gpointer,LttvFieldValue) @@ -1164,10 +1274,13 @@ lttv_filter_update(LttvFilter* filter) { /* temporary values */ GString *a_field_component = g_string_new(""); + GString *a_string_spaces = g_string_new(""); GPtrArray *a_field_path = g_ptr_array_new(); /* simple expression buffer */ LttvSimpleExpression* a_simple_expression = lttv_simple_expression_new(); + + gint nest_quotes = 0; /* * Parse entire expression and construct @@ -1209,7 +1322,28 @@ lttv_filter_update(LttvFilter* filter) { for(i=0;iexpression);i++) { // debug // g_print("%c\n ",filter->expression[i]); - + if(nest_quotes) { + switch(filter->expression[i]) { + case '\\' : + if(filter->expression[i+1] == '\"') { + i++; + } + break; + case '\"': + nest_quotes = 0; + i++; + break; + } + if(a_string_spaces->len != 0) { + a_field_component = g_string_append( + a_field_component, a_string_spaces->str); + a_string_spaces = g_string_set_size(a_string_spaces, 0); + } + a_field_component = g_string_append_c(a_field_component, + filter->expression[i]); + continue; + } + switch(filter->expression[i]) { /* * logical operators @@ -1243,6 +1377,8 @@ lttv_filter_update(LttvFilter* filter) { } else { /* append a simple expression */ lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); a_field_component = g_string_new(""); + g_string_free(a_string_spaces, TRUE); + a_string_spaces = g_string_new(""); t2->left = LTTV_TREE_LEAF; t2->l_child.leaf = a_simple_expression; a_simple_expression = lttv_simple_expression_new(); @@ -1275,6 +1411,8 @@ lttv_filter_update(LttvFilter* filter) { } else { /* append a simple expression */ lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); a_field_component = g_string_new(""); + g_string_free(a_string_spaces, TRUE); + a_string_spaces = g_string_new(""); t2->left = LTTV_TREE_LEAF; t2->l_child.leaf = a_simple_expression; a_simple_expression = lttv_simple_expression_new(); @@ -1307,6 +1445,8 @@ lttv_filter_update(LttvFilter* filter) { } else { /* append a simple expression */ lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); a_field_component = g_string_new(""); + g_string_free(a_string_spaces, TRUE); + a_string_spaces = g_string_new(""); t2->left = LTTV_TREE_LEAF; t2->l_child.leaf = a_simple_expression; a_simple_expression = lttv_simple_expression_new(); @@ -1319,6 +1459,8 @@ lttv_filter_update(LttvFilter* filter) { g_ptr_array_add( a_field_path,(gpointer) a_field_component ); lttv_simple_expression_assign_field(a_field_path,a_simple_expression); a_field_component = g_string_new(""); + g_string_free(a_string_spaces, TRUE); + a_string_spaces = g_string_new(""); lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_NE); i++; } else { /* ! */ @@ -1377,6 +1519,8 @@ lttv_filter_update(LttvFilter* filter) { } else { /* assign subtree as current tree */ lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); a_field_component = g_string_new(""); + g_string_free(a_string_spaces, TRUE); + a_string_spaces = g_string_new(""); t1->right = LTTV_TREE_LEAF; t1->r_child.leaf = a_simple_expression; a_simple_expression = lttv_simple_expression_new(); @@ -1392,6 +1536,8 @@ lttv_filter_update(LttvFilter* filter) { g_ptr_array_add( a_field_path,(gpointer) a_field_component ); lttv_simple_expression_assign_field(a_field_path,a_simple_expression); a_field_component = g_string_new(""); + g_string_free(a_string_spaces, TRUE); + a_string_spaces = g_string_new(""); if(filter->expression[i+1] == '=') { /* <= */ i++; lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_LE); @@ -1403,6 +1549,8 @@ lttv_filter_update(LttvFilter* filter) { g_ptr_array_add( a_field_path,(gpointer) a_field_component ); lttv_simple_expression_assign_field(a_field_path,a_simple_expression); a_field_component = g_string_new(""); + g_string_free(a_string_spaces, TRUE); + a_string_spaces = g_string_new(""); if(filter->expression[i+1] == '=') { /* >= */ i++; lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_GE); @@ -1414,6 +1562,8 @@ lttv_filter_update(LttvFilter* filter) { g_ptr_array_add( a_field_path,(gpointer) a_field_component ); lttv_simple_expression_assign_field(a_field_path,a_simple_expression); a_field_component = g_string_new(""); + g_string_free(a_string_spaces, TRUE); + a_string_spaces = g_string_new(""); lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_EQ); break; @@ -1431,13 +1581,29 @@ lttv_filter_update(LttvFilter* filter) { if(a_simple_expression->field == LTTV_FILTER_UNDEFINED) { g_ptr_array_add( a_field_path,(gpointer) a_field_component ); a_field_component = g_string_new(""); + g_string_free(a_string_spaces, TRUE); + a_string_spaces = g_string_new(""); } break; - case ' ': /* ignore */ + case ' ': /* keep spaces that are within a field component */ + if(a_field_component->len == 0) break; /* ignore */ + else + a_string_spaces = g_string_append_c(a_string_spaces, + filter->expression[i]); + case '\n': /* ignore */ break; + case '\"': + nest_quotes?(nest_quotes=0):(nest_quotes=1); + break; default: /* concatening current string */ - g_string_append_c(a_field_component,filter->expression[i]); + if(a_string_spaces->len != 0) { + a_field_component = g_string_append( + a_field_component, a_string_spaces->str); + a_string_spaces = g_string_set_size(a_string_spaces, 0); + } + a_field_component = g_string_append_c(a_field_component, + filter->expression[i]); } } @@ -1477,6 +1643,8 @@ lttv_filter_update(LttvFilter* filter) { } else { /* add a leaf */ lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); a_field_component = NULL; + g_string_free(a_string_spaces, TRUE); + a_string_spaces = NULL; t1->right = LTTV_TREE_LEAF; t1->r_child.leaf = a_simple_expression; a_simple_expression = NULL; @@ -1493,7 +1661,8 @@ lttv_filter_update(LttvFilter* filter) { /* free the field buffer if allocated */ if(a_field_component != NULL) g_string_free(a_field_component,TRUE); - + if(a_string_spaces != NULL) g_string_free(a_string_spaces, TRUE); + /* free the simple expression buffer if allocated */ if(a_simple_expression != NULL) lttv_simple_expression_destroy(a_simple_expression); @@ -1511,9 +1680,9 @@ lttv_filter_update(LttvFilter* filter) { #endif /* debug */ - g_print("+++++++++++++++ BEGIN PRINT ++++++++++++++++\n"); + g_debug("+++++++++++++++ BEGIN PRINT ++++++++++++++++\n"); lttv_print_tree(filter->head,0) ; - g_print("+++++++++++++++ END PRINT ++++++++++++++++++\n"); + g_debug("+++++++++++++++ END PRINT ++++++++++++++++++\n"); /* success */ return TRUE; @@ -1578,10 +1747,10 @@ lttv_filter_append_expression(LttvFilter* filter, const char *expression) { GString* s = g_string_new(""); if(filter->expression != NULL) { - g_string_append(s,filter->expression); - g_string_append_c(s,'&'); + s = g_string_append(s,filter->expression); + s = g_string_append_c(s,'&'); } - g_string_append(s,expression); + s = g_string_append(s,expression); g_free(filter->expression); filter->expression = g_string_free(s,FALSE); @@ -1689,8 +1858,9 @@ lttv_filter_tree_parse( LttvProcessState* state; - guint cpu = ltt_tracefile_num(context->tf); LttvTraceState *ts = (LttvTraceState*)context->t_context; + LttvTracefileState *tfs = (LttvTracefileState*)context; + guint cpu = tfs->cpu; state = ts->running_process[cpu]; /* @@ -1801,15 +1971,19 @@ lttv_filter_tree_parse_branch( } break; case LTTV_FILTER_STATE_P_NAME: - /* - * All 'unnamed' for the moment - */ if(state == NULL) return TRUE; else { GQuark quark = state->name; return se->op((gpointer)&quark,v); } break; + case LTTV_FILTER_STATE_T_BRAND: + if(state == NULL) return TRUE; + else { + GQuark quark = state->brand; + return se->op((gpointer)&quark,v); + } + break; case LTTV_FILTER_STATE_EX_MODE: if(state == NULL) return TRUE; else return se->op((gpointer)&state->state->t,v); @@ -1825,9 +1999,6 @@ lttv_filter_tree_parse_branch( case LTTV_FILTER_STATE_CPU: if(context == NULL) return TRUE; else { - /* FIXME: not sure of that one Mathieu : fixed.*/ - // GQuark quark = ((LttvTracefileState*)context)->cpu_name; - // return se->op((gpointer)&quark,v); if(state == NULL) return TRUE; else return se->op((gpointer)&state->cpu,v); } @@ -1841,7 +2012,15 @@ lttv_filter_tree_parse_branch( return se->op((gpointer)&quark,v); } break; - + case LTTV_FILTER_EVENT_FACILITY: + if(event == NULL) return TRUE; + else { + LttFacility* fac; + fac = ltt_event_facility(event); + GQuark quark = ltt_facility_name(fac); + return se->op((gpointer)&quark,v); + } + break; case LTTV_FILTER_EVENT_CATEGORY: /* * TODO: Not yet implemented @@ -1893,22 +2072,22 @@ lttv_filter_tree_parse_branch( void lttv_print_tree(const LttvFilterTree* t, const int count) { - g_print("node:%p lchild:%p rchild:%p depth:%i\n",t, //t->l_child.t,t->r_child.t); + g_debug("node:%p lchild:%p rchild:%p depth:%i\n",t, //t->l_child.t,t->r_child.t); (t->left==LTTV_TREE_NODE)?t->l_child.t:NULL, (t->right==LTTV_TREE_NODE)?t->r_child.t:NULL, count); - g_print("logic operator: %s\n",(t->node&1)?"OR":((t->node&2)?"AND":((t->node&4)?"NOT":((t->node&8)?"XOR":"IDLE")))); - g_print("|-> left branch %p is a %s\n",t->l_child.t,(t->left==LTTV_TREE_NODE)?"NODE":((t->left==LTTV_TREE_LEAF)?"LEAF":"IDLE")); + g_debug("logic operator: %s\n",(t->node&1)?"OR":((t->node&2)?"AND":((t->node&4)?"NOT":((t->node&8)?"XOR":"IDLE")))); + g_debug("|-> left branch %p is a %s\n",t->l_child.t,(t->left==LTTV_TREE_NODE)?"NODE":((t->left==LTTV_TREE_LEAF)?"LEAF":"IDLE")); if(t->left == LTTV_TREE_LEAF) { - g_print("| |-> field type number: %i\n",t->l_child.leaf->field); - g_print("| |-> offset is: %i\n",t->l_child.leaf->offset); - g_print("| |-> operator function is: %p\n",t->l_child.leaf->op); + g_debug("| |-> field type number: %i\n",t->l_child.leaf->field); + g_debug("| |-> offset is: %i\n",t->l_child.leaf->offset); + g_debug("| |-> operator function is: %p\n",t->l_child.leaf->op); } - g_print("|-> right branch %p is a %s\n",t->r_child.t,(t->right==LTTV_TREE_NODE)?"NODE":((t->right==LTTV_TREE_LEAF)?"LEAF":"IDLE")); + g_debug("|-> right branch %p is a %s\n",t->r_child.t,(t->right==LTTV_TREE_NODE)?"NODE":((t->right==LTTV_TREE_LEAF)?"LEAF":"IDLE")); if(t->right == LTTV_TREE_LEAF) { - g_print("| |-> field type number: %i\n",t->r_child.leaf->field); - g_print("| |-> offset is: %i\n",t->r_child.leaf->offset); - g_print("| |-> operator function is: %p\n",t->r_child.leaf->op); + g_debug("| |-> field type number: %i\n",t->r_child.leaf->field); + g_debug("| |-> offset is: %i\n",t->r_child.leaf->offset); + g_debug("| |-> operator function is: %p\n",t->r_child.leaf->op); } if(t->left == LTTV_TREE_NODE) lttv_print_tree(t->l_child.t,count+1);