ltt/branches/poly/lttv/lttv/filter.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2005 Michel Dagenais and Simon Bouvier-Zappa
   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
  19 /*! \file lttv/lttv/filter.c
  20  *  \brief Defines the core filter of application
  21  *
  22  *  consist in AND, OR and NOT nested expressions, forming a tree with
  23  *  simple relations as leaves. The simple relations test if a field
  24  *  in an event is equal, not equal, smaller, smaller or equal, larger, or
  25  *  larger or equal to a specified value.
  26  *
  27  *  Fields specified in a simple expression can take following
  28  *  values
  29  *
  30  *  \verbatim
  31  *  LttvTracefileContext{}
  32  *  |->event\
  33  *  | |->name (String, converted to GQuark)
  34  *  | |->facility (String, converted to GQuark)
  35  *  | |->category (String, not yet implemented)
  36  *  | |->time (LttTime)
  37  *  | |->tsc (LttCycleCount --> uint64)
  38  *  | |->fields
  39  *  |   |->"event name"
  40  *  |     |->"field name"
  41  *  |       |->"sub-field name"
  42  *  |         |->...
  43  *  |           |->"leaf-field name" (field type)
  44  *  |->tracefile
  45  *  | |->name (String, converted to GQuark)
  46  *  |->trace
  47  *  | |->name (String, converted to GQuark)
  48  *  |->state
  49  *    |->pid (guint)
  50  *    |->ppid (guint)
  51  *    |->creation_time (LttTime)
  52  *    |->insertion_time (LttTime)
  53  *    |->process_name (String, converted to GQuark)
  54  *    |->execution_mode (LttvExecutionMode)
  55  *    |->execution_submode (LttvExecutionSubmode)
  56  *    |->process_status (LttvProcessStatus)
  57  *    |->cpu (guint)
  58  *  \endverbatim
  59  */
  60
  61 /*
  62  *  \todo
  63  *  - refine switch of expression in multiple uses functions
  64  *  - remove the idle expressions in the tree
  65  */
  66
  67 #ifdef HAVE_CONFIG_H
  68 #include <config.h>
  69 #endif
  70
  71 //#define TEST
  72 #ifdef TEST
  73 #include <time.h>
  74 #include <sys/time.h>
  75 #endif
  76
  77 #include <lttv/lttv.h>
  78 #include <lttv/filter.h>
  79 #include <ltt/trace.h>
  80 #include <ltt/type.h>
  81 #include <ltt/facility.h>
  82 #include <stdlib.h>
  83 #include <string.h>
  84
  85 /**
  86  * @fn LttvSimpleExpression* lttv_simple_expression_new()
  87  *
  88  * Constructor for LttvSimpleExpression
  89  * @return pointer to new LttvSimpleExpression
  90  */
  91 LttvSimpleExpression*
  92 lttv_simple_expression_new() {
  93
  94   LttvSimpleExpression* se = g_new(LttvSimpleExpression,1);
  95
  96   se->field = LTTV_FILTER_UNDEFINED;
  97   se->op = NULL;
  98   se->offset = 0;
  99
 100   return se;
 101 }
 102
 103 /**
 104  *  @fn gboolean lttv_simple_expression_assign_field(GPtrArray*,LttvSimpleExpression*)
 105  *
 106  *  Parse through filtering field hierarchy as specified
 107  *  by user.  This function compares each value to
 108  *  predetermined quarks
 109  *  @param fp The field path list
 110  *  @param se current simple expression
 111  *  @return success/failure of operation
 112  */
 113 gboolean
 114 lttv_simple_expression_assign_field(GPtrArray* fp, LttvSimpleExpression* se) {
 115
 116   GString* f = NULL;
 117
 118   if(fp->len < 2) return FALSE;
 119   g_assert((f=g_ptr_array_remove_index(fp,0)));
 120
 121   /*
 122    * Parse through the specified
 123    * hardcoded fields.
 124    *
 125    * Take note however that the
 126    * 'event' subfields might change
 127    * depending on values specified
 128    * in core.xml file.  Hence, if
 129    * none of the subfields in the
 130    * array match the hardcoded
 131    * subfields, it will be considered
 132    * as a dynamic field
 133    */
 134   if(!g_strcasecmp(f->str,"trace") ) {
 135     /*
 136      * Possible values:
 137      *  trace.name
 138      */
 139     g_string_free(f,TRUE);
 140     f=g_ptr_array_remove_index(fp,0);
 141     if(!g_strcasecmp(f->str,"name")) {
 142       se->field = LTTV_FILTER_TRACE_NAME;
 143     }
 144   } else if(!g_strcasecmp(f->str,"traceset") ) {
 145     /*
 146      * FIXME: not yet implemented !
 147      */
 148   } else if(!g_strcasecmp(f->str,"tracefile") ) {
 149     /*
 150      * Possible values:
 151      *  tracefile.name
 152      */
 153     g_string_free(f,TRUE);
 154     f=g_ptr_array_remove_index(fp,0);
 155     if(!g_strcasecmp(f->str,"name")) {
 156       se->field = LTTV_FILTER_TRACEFILE_NAME;
 157     }
 158   } else if(!g_strcasecmp(f->str,"state") ) {
 159     /*
 160      * Possible values:
 161      *  state.pid
 162      *  state.ppid
 163      *  state.creation_time
 164      *  state.insertion_time
 165      *  state.process_name
 166      *  state.execution_mode
 167      *  state.execution_submode
 168      *  state.process_status
 169      *  state.cpu
 170      */
 171     g_string_free(f,TRUE);
 172     f=g_ptr_array_remove_index(fp,0);
 173     if(!g_strcasecmp(f->str,"pid") ) {
 174       se->field = LTTV_FILTER_STATE_PID;
 175     }
 176     else if(!g_strcasecmp(f->str,"ppid") ) {
 177       se->field = LTTV_FILTER_STATE_PPID;
 178     }
 179     else if(!g_strcasecmp(f->str,"creation_time") ) {
 180       se->field = LTTV_FILTER_STATE_CT;
 181     }
 182     else if(!g_strcasecmp(f->str,"insertion_time") ) {
 183       se->field = LTTV_FILTER_STATE_IT;
 184     }
 185     else if(!g_strcasecmp(f->str,"process_name") ) {
 186       se->field = LTTV_FILTER_STATE_P_NAME;
 187     }
 188     else if(!g_strcasecmp(f->str,"execution_mode") ) {
 189       se->field = LTTV_FILTER_STATE_EX_MODE;
 190     }
 191     else if(!g_strcasecmp(f->str,"execution_submode") ) {
 192       se->field = LTTV_FILTER_STATE_EX_SUBMODE;
 193     }
 194     else if(!g_strcasecmp(f->str,"process_status") ) {
 195       se->field = LTTV_FILTER_STATE_P_STATUS;
 196     }
 197     else if(!g_strcasecmp(f->str,"cpu") ) {
 198       se->field = LTTV_FILTER_STATE_CPU;
 199     }
 200   } else if(!g_strcasecmp(f->str,"event") ) {
 201     /*
 202      * Possible values:
 203      *  event.name
 204      *  event.category
 205      *  event.time
 206      *  event.tsc
 207      */
 208     g_string_free(f,TRUE);
 209     f=g_ptr_array_remove_index(fp,0);
 210     if(!g_strcasecmp(f->str,"name") ) {
 211       se->field = LTTV_FILTER_EVENT_NAME;
 212     }
 213     else if(!g_strcasecmp(f->str,"facility") ) {
 214       se->field = LTTV_FILTER_EVENT_FACILITY;
 215     }
 216     else if(!g_strcasecmp(f->str,"category") ) {
 217       /*
 218        * FIXME: Category not yet functional in lttv
 219        */
 220       se->field = LTTV_FILTER_EVENT_CATEGORY;
 221     }
 222     else if(!g_strcasecmp(f->str,"time") ) {
 223       se->field = LTTV_FILTER_EVENT_TIME;
 224     }
 225     else if(!g_strcasecmp(f->str,"tsc") ) {
 226       se->field = LTTV_FILTER_EVENT_TSC;
 227     }
 228     else {  /* core.xml specified options */
 229       se->field = LTTV_FILTER_EVENT_FIELD;
 230     }
 231   } else {
 232     g_warning("Unrecognized field in filter string");
 233   }
 234
 235   /* free memory for last string */
 236   g_string_free(f,TRUE);
 237
 238   /* array should be empty */
 239   g_assert(fp->len == 0);
 240
 241   if(se->field == LTTV_FILTER_UNDEFINED) {
 242     g_warning("The specified field was not recognized !");
 243     return FALSE;
 244   }
 245   return TRUE;
 246 }
 247
 248 /**
 249  *  @fn gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression*,LttvExpressionOp)
 250  *
 251  *  Sets the function pointer for the current
 252  *  Simple Expression
 253  *  @param se current simple expression
 254  *  @param op current operator
 255  *  @return success/failure of operation
 256  */
 257 gboolean
 258 lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvExpressionOp op) {
 259
 260   switch(se->field) {
 261      /*
 262       * string
 263       */
 264      case LTTV_FILTER_TRACE_NAME:
 265      case LTTV_FILTER_TRACEFILE_NAME:
 266      case LTTV_FILTER_STATE_P_NAME:
 267      case LTTV_FILTER_EVENT_NAME:
 268      case LTTV_FILTER_EVENT_FACILITY:
 269      case LTTV_FILTER_STATE_EX_MODE:
 270      case LTTV_FILTER_STATE_EX_SUBMODE:
 271      case LTTV_FILTER_STATE_P_STATUS:
 272        switch(op) {
 273          case LTTV_FIELD_EQ:
 274            se->op = lttv_apply_op_eq_quark;
 275            break;
 276          case LTTV_FIELD_NE:
 277            se->op = lttv_apply_op_ne_quark;
 278            break;
 279          default:
 280            g_warning("Error encountered in operator assignment = or != expected");
 281            return FALSE;
 282        }
 283        break;
 284      /*
 285       * integer
 286       */
 287      case LTTV_FILTER_EVENT_TSC:
 288        switch(op) {
 289          case LTTV_FIELD_EQ:
 290            se->op = lttv_apply_op_eq_uint64;
 291            break;
 292          case LTTV_FIELD_NE:
 293            se->op = lttv_apply_op_ne_uint64;
 294            break;
 295          case LTTV_FIELD_LT:
 296            se->op = lttv_apply_op_lt_uint64;
 297            break;
 298          case LTTV_FIELD_LE:
 299            se->op = lttv_apply_op_le_uint64;
 300            break;
 301          case LTTV_FIELD_GT:
 302            se->op = lttv_apply_op_gt_uint64;
 303            break;
 304          case LTTV_FIELD_GE:
 305            se->op = lttv_apply_op_ge_uint64;
 306            break;
 307          default:
 308            g_warning("Error encountered in operator assignment");
 309            return FALSE;
 310        }
 311        break;
 312      /*
 313       * unsigned integers
 314       */
 315      case LTTV_FILTER_STATE_CPU:
 316      case LTTV_FILTER_STATE_PID:
 317      case LTTV_FILTER_STATE_PPID:
 318        switch(op) {
 319          case LTTV_FIELD_EQ:
 320            se->op = lttv_apply_op_eq_uint;
 321            break;
 322          case LTTV_FIELD_NE:
 323            se->op = lttv_apply_op_ne_uint;
 324            break;
 325          case LTTV_FIELD_LT:
 326            se->op = lttv_apply_op_lt_uint;
 327            break;
 328          case LTTV_FIELD_LE:
 329            se->op = lttv_apply_op_le_uint;
 330            break;
 331          case LTTV_FIELD_GT:
 332            se->op = lttv_apply_op_gt_uint;
 333            break;
 334          case LTTV_FIELD_GE:
 335            se->op = lttv_apply_op_ge_uint;
 336            break;
 337          default:
 338            g_warning("Error encountered in operator assignment");
 339            return FALSE;
 340        }
 341        break;
 342
 343      /*
 344       * Enums
 345       * Entered as string, converted to enum
 346       *
 347       * can only be compared with 'equal' or 'not equal' operators
 348       *
 349       * unsigned int of 16 bits are used here since enums
 350       * should not go over 2^16-1 values
 351       */
 352 //      case /*NOTHING*/:
 353 //       switch(op) {
 354 //         case LTTV_FIELD_EQ:
 355 //           se->op = lttv_apply_op_eq_uint16;
 356 //           break;
 357 //         case LTTV_FIELD_NE:
 358 //           se->op = lttv_apply_op_ne_uint16;
 359 //           break;
 360 //         default:
 361 //           g_warning("Error encountered in operator assignment = or != expected");
 362 //           return FALSE;
 363 //       }
 364 //       break;
 365      /*
 366       * Ltttime
 367       */
 368      case LTTV_FILTER_STATE_CT:
 369      case LTTV_FILTER_STATE_IT:
 370      case LTTV_FILTER_EVENT_TIME:
 371        switch(op) {
 372          case LTTV_FIELD_EQ:
 373            se->op = lttv_apply_op_eq_ltttime;
 374            break;
 375          case LTTV_FIELD_NE:
 376            se->op = lttv_apply_op_ne_ltttime;
 377            break;
 378          case LTTV_FIELD_LT:
 379            se->op = lttv_apply_op_lt_ltttime;
 380            break;
 381          case LTTV_FIELD_LE:
 382            se->op = lttv_apply_op_le_ltttime;
 383            break;
 384          case LTTV_FIELD_GT:
 385            se->op = lttv_apply_op_gt_ltttime;
 386            break;
 387          case LTTV_FIELD_GE:
 388            se->op = lttv_apply_op_ge_ltttime;
 389            break;
 390          default:
 391            g_warning("Error encountered in operator assignment");
 392            return FALSE;
 393        }
 394        break;
 395      default:
 396        g_warning("Error encountered in operator assignation ! Field type:%i",se->field);
 397        return FALSE;
 398    }
 399
 400   return TRUE;
 401
 402 }
 403
 404 /**
 405  *  @fn gboolean lttv_simple_expression_assign_value(LttvSimpleExpression*,char*)
 406  *
 407  *  Assign the value field to the current LttvSimpleExpression
 408  *  @param se pointer to the current LttvSimpleExpression
 409  *  @param value string value for simple expression
 410  */
 411 gboolean
 412 lttv_simple_expression_assign_value(LttvSimpleExpression* se, char* value) {
 413
 414   unsigned i;
 415   gboolean is_double = FALSE;
 416   LttTime t = ltt_time_zero;
 417   GString* v;
 418
 419   switch(se->field) {
 420      /*
 421       * Strings
 422       * entered as strings, converted to Quarks
 423       */
 424      case LTTV_FILTER_TRACE_NAME:
 425      case LTTV_FILTER_TRACEFILE_NAME:
 426      case LTTV_FILTER_STATE_P_NAME:
 427      case LTTV_FILTER_EVENT_NAME:
 428      case LTTV_FILTER_EVENT_FACILITY:
 429      case LTTV_FILTER_STATE_EX_MODE:
 430      case LTTV_FILTER_STATE_EX_SUBMODE:
 431      case LTTV_FILTER_STATE_P_STATUS:
 432       // se->value.v_string = value;
 433        se->value.v_uint32 = g_quark_from_string(value);
 434        g_free(value);
 435        break;
 436      /*
 437       * integer -- supposed to be uint64
 438       */
 439      case LTTV_FILTER_EVENT_TSC:
 440        se->value.v_uint64 = atoi(value);
 441        g_free(value);
 442        break;
 443      /*
 444       * unsigned integers
 445       */
 446      case LTTV_FILTER_STATE_PID:
 447      case LTTV_FILTER_STATE_PPID:
 448      case LTTV_FILTER_STATE_CPU:
 449        se->value.v_uint = atoi(value);
 450        g_free(value);
 451        break;
 452      /*
 453       * LttTime
 454       */
 455      case LTTV_FILTER_STATE_CT:
 456      case LTTV_FILTER_STATE_IT:
 457      case LTTV_FILTER_EVENT_TIME:
 458        //se->value.v_double = atof(value);
 459        /*
 460         * parsing logic could be optimised,
 461         * but as for now, simpler this way
 462         */
 463        v = g_string_new("");
 464        for(i=0;i<strlen(value);i++) {
 465           if(value[i] == '.') {
 466               /* cannot specify number with more than one '.' */
 467               if(is_double) return FALSE;
 468               else is_double = TRUE;
 469               t.tv_sec = atoi(v->str);
 470               g_string_free(v,TRUE);
 471               v = g_string_new("");
 472           } else g_string_append_c(v,value[i]);
 473        }
 474        /* number can be integer or double */
 475        if(is_double) t.tv_nsec = atoi(v->str);
 476        else t.tv_sec = atoi(v->str);
 477
 478        g_string_free(v,TRUE);
 479
 480        se->value.v_ltttime = t;
 481        g_free(value);
 482        break;
 483      default:
 484        g_warning("Error encountered in value assignation ! Field type = %i",se->field);
 485        g_free(value);
 486        return FALSE;
 487    }
 488
 489   return TRUE;
 490
 491 }
 492
 493 /**
 494  *  @fn void lttv_simple_expression_destroy(LttvSimpleExpression*)
 495  *
 496  *  Disallocate memory for the current
 497  *  simple expression
 498  *  @param se pointer to the current LttvSimpleExpression
 499  */
 500 void
 501 lttv_simple_expression_destroy(LttvSimpleExpression* se) {
 502
 503  // g_free(se->value);
 504 //  switch(se->field) {
 505 //     case LTTV_FILTER_TRACE_NAME:
 506 //     case LTTV_FILTER_TRACEFILE_NAME:
 507 //     case LTTV_FILTER_STATE_P_NAME:
 508 //     case LTTV_FILTER_EVENT_NAME:
 509 //       g_free(se->value.v_string);
 510 //       break;
 511 //  }
 512   g_free(se);
 513
 514 }
 515
 516 /**
 517  *  @fn gint lttv_struct_type(gint)
 518  *
 519  *  Finds the structure type depending
 520  *  on the fields in parameters
 521  *  @params ft Field of the current structure
 522  *  @return LttvStructType enum or -1 for error
 523  */
 524 gint
 525 lttv_struct_type(gint ft) {
 526
 527     switch(ft) {
 528         case LTTV_FILTER_TRACE_NAME:
 529             return LTTV_FILTER_TRACE;
 530             break;
 531         case LTTV_FILTER_TRACEFILE_NAME:
 532             return LTTV_FILTER_TRACEFILE;
 533             break;
 534         case LTTV_FILTER_STATE_PID:
 535         case LTTV_FILTER_STATE_PPID:
 536         case LTTV_FILTER_STATE_CT:
 537         case LTTV_FILTER_STATE_IT:
 538         case LTTV_FILTER_STATE_P_NAME:
 539         case LTTV_FILTER_STATE_EX_MODE:
 540         case LTTV_FILTER_STATE_EX_SUBMODE:
 541         case LTTV_FILTER_STATE_P_STATUS:
 542         case LTTV_FILTER_STATE_CPU:
 543             return LTTV_FILTER_STATE;
 544             break;
 545         case LTTV_FILTER_EVENT_NAME:
 546         case LTTV_FILTER_EVENT_FACILITY:
 547         case LTTV_FILTER_EVENT_CATEGORY:
 548         case LTTV_FILTER_EVENT_TIME:
 549         case LTTV_FILTER_EVENT_TSC:
 550         case LTTV_FILTER_EVENT_FIELD:
 551             return LTTV_FILTER_EVENT;
 552             break;
 553         default:
 554             return -1;
 555     }
 556 }
 557
 558 /**
 559  *  @fn gboolean lttv_apply_op_eq_uint(gpointer,LttvFieldValue)
 560  *
 561  *  Applies the 'equal' operator to the
 562  *  specified structure and value
 563  *  @param v1 left member of comparison
 564  *  @param v2 right member of comparison
 565  *  @return success/failure of operation
 566  */
 567 gboolean lttv_apply_op_eq_uint(const gpointer v1, LttvFieldValue v2) {
 568
 569   guint* r = (guint*) v1;
 570   return (*r == v2.v_uint);
 571
 572 }
 573
 574 /**
 575  *  @fn gboolean lttv_apply_op_eq_uint64(gpointer,LttvFieldValue)
 576  *
 577  *  Applies the 'equal' operator to the
 578  *  specified structure and value
 579  *  @param v1 left member of comparison
 580  *  @param v2 right member of comparison
 581  *  @return success/failure of operation
 582  */
 583 gboolean lttv_apply_op_eq_uint64(const gpointer v1, LttvFieldValue v2) {
 584
 585   guint64* r = (guint64*) v1;
 586   return (*r == v2.v_uint64);
 587
 588 }
 589
 590 /**
 591  *  @fn gboolean lttv_apply_op_eq_uint32(gpointer,LttvFieldValue)
 592  *
 593  *  Applies the 'equal' operator to the
 594  *  specified structure and value
 595  *  @param v1 left member of comparison
 596  *  @param v2 right member of comparison
 597  *  @return success/failure of operation
 598  */
 599 gboolean lttv_apply_op_eq_uint32(const gpointer v1, LttvFieldValue v2) {
 600   guint32* r = (guint32*) v1;
 601   return (*r == v2.v_uint32);
 602 }
 603
 604 /**
 605  *  @fn gboolean lttv_apply_op_eq_uint16(gpointer,LttvFieldValue)
 606  *
 607  *  Applies the 'equal' operator to the
 608  *  specified structure and value
 609  *  @param v1 left member of comparison
 610  *  @param v2 right member of comparison
 611  *  @return success/failure of operation
 612  */
 613 gboolean lttv_apply_op_eq_uint16(const gpointer v1, LttvFieldValue v2) {
 614   guint16* r = (guint16*) v1;
 615   return (*r == v2.v_uint16);
 616 }
 617
 618 /**
 619  *  @fn gboolean lttv_apply_op_eq_double(gpointer,LttvFieldValue)
 620  *
 621  *  Applies the 'equal' operator to the
 622  *  specified structure and value
 623  *  @param v1 left member of comparison
 624  *  @param v2 right member of comparison
 625  *  @return success/failure of operation
 626  */
 627 gboolean lttv_apply_op_eq_double(const gpointer v1, LttvFieldValue v2) {
 628   double* r = (double*) v1;
 629   return (*r == v2.v_double);
 630 }
 631
 632 /**
 633  *  @fn gboolean lttv_apply_op_eq_string(gpointer,LttvFieldValue)
 634  *
 635  *  Applies the 'equal' operator to the
 636  *  specified structure and value
 637  *  @param v1 left member of comparison
 638  *  @param v2 right member of comparison
 639  *  @return success/failure of operation
 640  */
 641 gboolean lttv_apply_op_eq_string(const gpointer v1, LttvFieldValue v2) {
 642   char* r = (char*) v1;
 643   return (!g_strcasecmp(r,v2.v_string));
 644 }
 645
 646 /**
 647  *  @fn gboolean lttv_apply_op_eq_quark(gpointer,LttvFieldValue)
 648  *
 649  *  Applies the 'equal' operator to the
 650  *  specified structure and value
 651  *  @param v1 left member of comparison
 652  *  @param v2 right member of comparison
 653  *  @return success/failure of operation
 654  */
 655 gboolean lttv_apply_op_eq_quark(const gpointer v1, LttvFieldValue v2) {
 656   GQuark* r = (GQuark*) v1;
 657 //  g_print("v1:%i v2:%i\n",*r,v2.v_uint32);
 658   return (*r == v2.v_uint32);
 659 }
 660
 661 /**
 662  *  @fn gboolean lttv_apply_op_eq_ltttime(gpointer,LttvFieldValue)
 663  *
 664  *  Applies the 'equal' operator to the
 665  *  specified structure and value
 666  *  @param v1 left member of comparison
 667  *  @param v2 right member of comparison
 668  *  @return success/failure of operation
 669  */
 670 gboolean lttv_apply_op_eq_ltttime(const gpointer v1, LttvFieldValue v2) {
 671   LttTime* r = (LttTime*) v1;
 672   return ltt_time_compare(*r, v2.v_ltttime)==0?1:0;
 673 }
 674
 675 /**
 676  *  @fn gboolean lttv_apply_op_ne_uint(gpointer,LttvFieldValue)
 677  *
 678  *  Applies the 'not equal' operator to the
 679  *  specified structure and value
 680  *  @param v1 left member of comparison
 681  *  @param v2 right member of comparison
 682  *  @return success/failure of operation
 683  */
 684 gboolean lttv_apply_op_ne_uint(const gpointer v1, LttvFieldValue v2) {
 685   guint* r = (guint*) v1;
 686   return (*r != v2.v_uint);
 687 }
 688
 689 /**
 690  *  @fn gboolean lttv_apply_op_ne_uint64(gpointer,LttvFieldValue)
 691  *
 692  *  Applies the 'not equal' operator to the
 693  *  specified structure and value
 694  *  @param v1 left member of comparison
 695  *  @param v2 right member of comparison
 696  *  @return success/failure of operation
 697  */
 698 gboolean lttv_apply_op_ne_uint64(const gpointer v1, LttvFieldValue v2) {
 699   guint64* r = (guint64*) v1;
 700   return (*r != v2.v_uint64);
 701 }
 702
 703 /**
 704  *  @fn gboolean lttv_apply_op_ne_uint32(gpointer,LttvFieldValue)
 705  *
 706  *  Applies the 'not equal' operator to the
 707  *  specified structure and value
 708  *  @param v1 left member of comparison
 709  *  @param v2 right member of comparison
 710  *  @return success/failure of operation
 711  */
 712 gboolean lttv_apply_op_ne_uint32(const gpointer v1, LttvFieldValue v2) {
 713   guint32* r = (guint32*) v1;
 714   return (*r != v2.v_uint32);
 715 }
 716
 717 /**
 718  *  @fn gboolean lttv_apply_op_ne_uint16(gpointer,LttvFieldValue)
 719  *
 720  *  Applies the 'not equal' operator to the
 721  *  specified structure and value
 722  *  @param v1 left member of comparison
 723  *  @param v2 right member of comparison
 724  *  @return success/failure of operation
 725  */
 726 gboolean lttv_apply_op_ne_uint16(const gpointer v1, LttvFieldValue v2) {
 727   guint16* r = (guint16*) v1;
 728   return (*r != v2.v_uint16);
 729 }
 730
 731 /**
 732  *  @fn gboolean lttv_apply_op_ne_double(gpointer,LttvFieldValue)
 733  *
 734  *  Applies the 'not equal' operator to the
 735  *  specified structure and value
 736  *  @param v1 left member of comparison
 737  *  @param v2 right member of comparison
 738  *  @return success/failure of operation
 739  */
 740 gboolean lttv_apply_op_ne_double(const gpointer v1, LttvFieldValue v2) {
 741   double* r = (double*) v1;
 742   return (*r != v2.v_double);
 743 }
 744
 745 /**
 746  *  @fn gboolean lttv_apply_op_ne_string(gpointer,LttvFieldValue)
 747  *
 748  *  Applies the 'not equal' operator to the
 749  *  specified structure and value
 750  *  @param v1 left member of comparison
 751  *  @param v2 right member of comparison
 752  *  @return success/failure of operation
 753  */
 754 gboolean lttv_apply_op_ne_string(const gpointer v1, LttvFieldValue v2) {
 755   char* r = (char*) v1;
 756   return (g_strcasecmp(r,v2.v_string));
 757 }
 758
 759 /**
 760  *  @fn gboolean lttv_apply_op_ne_quark(gpointer,LttvFieldValue)
 761  *
 762  *  Applies the 'not equal' operator to the
 763  *  specified structure and value
 764  *  @param v1 left member of comparison
 765  *  @param v2 right member of comparison
 766  *  @return success/failure of operation
 767  */
 768 gboolean lttv_apply_op_ne_quark(const gpointer v1, LttvFieldValue v2) {
 769   GQuark* r = (GQuark*) v1;
 770   return (*r != v2.v_uint32);
 771 }
 772
 773
 774 /**
 775  *  @fn gboolean lttv_apply_op_ne_ltttime(gpointer,LttvFieldValue)
 776  *
 777  *  Applies the 'not equal' operator to the
 778  *  specified structure and value
 779  *  @param v1 left member of comparison
 780  *  @param v2 right member of comparison
 781  *  @return success/failure of operation
 782  */
 783 gboolean lttv_apply_op_ne_ltttime(const gpointer v1, LttvFieldValue v2) {
 784   LttTime* r = (LttTime*) v1;
 785   return ltt_time_compare(*r, v2.v_ltttime)!=0?1:0;
 786 }
 787
 788 /**
 789  *  @fn gboolean lttv_apply_op_lt_uint(gpointer,LttvFieldValue)
 790  *
 791  *  Applies the 'lower than' operator to the
 792  *  specified structure and value
 793  *  @param v1 left member of comparison
 794  *  @param v2 right member of comparison
 795  *  @return success/failure of operation
 796  */
 797 gboolean lttv_apply_op_lt_uint(const gpointer v1, LttvFieldValue v2) {
 798   guint* r = (guint*) v1;
 799   return (*r < v2.v_uint);
 800 }
 801
 802 /**
 803  *  @fn gboolean lttv_apply_op_lt_uint64(gpointer,LttvFieldValue)
 804  *
 805  *  Applies the 'lower than' operator to the
 806  *  specified structure and value
 807  *  @param v1 left member of comparison
 808  *  @param v2 right member of comparison
 809  *  @return success/failure of operation
 810  */
 811 gboolean lttv_apply_op_lt_uint64(const gpointer v1, LttvFieldValue v2) {
 812   guint64* r = (guint64*) v1;
 813   return (*r < v2.v_uint64);
 814 }
 815
 816 /**
 817  *  @fn gboolean lttv_apply_op_lt_uint32(gpointer,LttvFieldValue)
 818  *
 819  *  Applies the 'lower than' operator to the
 820  *  specified structure and value
 821  *  @param v1 left member of comparison
 822  *  @param v2 right member of comparison
 823  *  @return success/failure of operation
 824  */
 825 gboolean lttv_apply_op_lt_uint32(const gpointer v1, LttvFieldValue v2) {
 826   guint32* r = (guint32*) v1;
 827   return (*r < v2.v_uint32);
 828 }
 829
 830 /**
 831  *  @fn gboolean lttv_apply_op_lt_uint16(gpointer,LttvFieldValue)
 832  *
 833  *  Applies the 'lower than' operator to the
 834  *  specified structure and value
 835  *  @param v1 left member of comparison
 836  *  @param v2 right member of comparison
 837  *  @return success/failure of operation
 838  */
 839 gboolean lttv_apply_op_lt_uint16(const gpointer v1, LttvFieldValue v2) {
 840   guint16* r = (guint16*) v1;
 841   return (*r < v2.v_uint16);
 842 }
 843
 844 /**
 845  *  @fn gboolean lttv_apply_op_lt_double(gpointer,LttvFieldValue)
 846  *
 847  *  Applies the 'lower than' operator to the
 848  *  specified structure and value
 849  *  @param v1 left member of comparison
 850  *  @param v2 right member of comparison
 851  *  @return success/failure of operation
 852  */
 853 gboolean lttv_apply_op_lt_double(const gpointer v1, LttvFieldValue v2) {
 854   double* r = (double*) v1;
 855   return (*r < v2.v_double);
 856 }
 857
 858 /**
 859  *  @fn gboolean lttv_apply_op_lt_ltttime(gpointer,LttvFieldValue)
 860  *
 861  *  Applies the 'lower than' operator to the
 862  *  specified structure and value
 863  *  @param v1 left member of comparison
 864  *  @param v2 right member of comparison
 865  *  @return success/failure of operation
 866  */
 867 gboolean lttv_apply_op_lt_ltttime(const gpointer v1, LttvFieldValue v2) {
 868   LttTime* r = (LttTime*) v1;
 869 //  return ((r->tv_sec < v2.v_ltttime.tv_sec) || ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec < v2.v_ltttime.tv_nsec)));
 870   return ltt_time_compare(*r, v2.v_ltttime)==-1?1:0;
 871 }
 872
 873 /**
 874  *  @fn gboolean lttv_apply_op_le_uint(gpointer,LttvFieldValue)
 875  *
 876  *  Applies the 'lower or equal' operator to the
 877  *  specified structure and value
 878  *  @param v1 left member of comparison
 879  *  @param v2 right member of comparison
 880  *  @return success/failure of operation
 881  */
 882 gboolean lttv_apply_op_le_uint(const gpointer v1, LttvFieldValue v2) {
 883   guint* r = (guint*) v1;
 884   return (*r <= v2.v_uint);
 885 }
 886
 887 /**
 888  *  @fn gboolean lttv_apply_op_le_uint64(gpointer,LttvFieldValue)
 889  *
 890  *  Applies the 'lower or equal' operator to the
 891  *  specified structure and value
 892  *  @param v1 left member of comparison
 893  *  @param v2 right member of comparison
 894  *  @return success/failure of operation
 895  */
 896 gboolean lttv_apply_op_le_uint64(const gpointer v1, LttvFieldValue v2) {
 897   guint64* r = (guint64*) v1;
 898   return (*r <= v2.v_uint64);
 899 }
 900
 901 /**
 902  *  @fn gboolean lttv_apply_op_le_uint32(gpointer,LttvFieldValue)
 903  *
 904  *  Applies the 'lower or equal' operator to the
 905  *  specified structure and value
 906  *  @param v1 left member of comparison
 907  *  @param v2 right member of comparison
 908  *  @return success/failure of operation
 909  */
 910 gboolean lttv_apply_op_le_uint32(const gpointer v1, LttvFieldValue v2) {
 911   guint32* r = (guint32*) v1;
 912   return (*r <= v2.v_uint32);
 913 }
 914
 915 /**
 916  *  @fn gboolean lttv_apply_op_le_uint16(gpointer,LttvFieldValue)
 917  *
 918  *  Applies the 'lower or equal' operator to the
 919  *  specified structure and value
 920  *  @param v1 left member of comparison
 921  *  @param v2 right member of comparison
 922  *  @return success/failure of operation
 923  */
 924 gboolean lttv_apply_op_le_uint16(const gpointer v1, LttvFieldValue v2) {
 925   guint16* r = (guint16*) v1;
 926   return (*r <= v2.v_uint16);
 927 }
 928
 929 /**
 930  *  @fn gboolean lttv_apply_op_le_double(gpointer,LttvFieldValue)
 931  *
 932  *  Applies the 'lower or equal' operator to the
 933  *  specified structure and value
 934  *  @param v1 left member of comparison
 935  *  @param v2 right member of comparison
 936  *  @return success/failure of operation
 937  */
 938 gboolean lttv_apply_op_le_double(const gpointer v1, LttvFieldValue v2) {
 939   double* r = (double*) v1;
 940   return (*r <= v2.v_double);
 941 }
 942
 943 /**
 944  *  @fn gboolean lttv_apply_op_le_ltttime(gpointer,LttvFieldValue)
 945  *
 946  *  Applies the 'lower or equal' operator to the
 947  *  specified structure and value
 948  *  @param v1 left member of comparison
 949  *  @param v2 right member of comparison
 950  *  @return success/failure of operation
 951  */
 952 gboolean lttv_apply_op_le_ltttime(const gpointer v1, LttvFieldValue v2) {
 953   LttTime* r = (LttTime*) v1;
 954 //  return ((r->tv_sec < v2.v_ltttime.tv_sec) || ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec <= v2.v_ltttime.tv_nsec)));
 955   return ltt_time_compare(*r, v2.v_ltttime)<1?1:0;
 956 }
 957
 958
 959 /**
 960  *  @fn gboolean lttv_apply_op_gt_uint(gpointer,LttvFieldValue)
 961  *
 962  *  Applies the 'greater than' operator to the
 963  *  specified structure and value
 964  *  @param v1 left member of comparison
 965  *  @param v2 right member of comparison
 966  *  @return success/failure of operation
 967  */
 968 gboolean lttv_apply_op_gt_uint(const gpointer v1, LttvFieldValue v2) {
 969   guint* r = (guint*) v1;
 970   return (*r > v2.v_uint);
 971 }
 972
 973 /**
 974  *  @fn gboolean lttv_apply_op_gt_uint64(gpointer,LttvFieldValue)
 975  *
 976  *  Applies the 'greater than' operator to the
 977  *  specified structure and value
 978  *  @param v1 left member of comparison
 979  *  @param v2 right member of comparison
 980  *  @return success/failure of operation
 981  */
 982 gboolean lttv_apply_op_gt_uint64(const gpointer v1, LttvFieldValue v2) {
 983   guint64* r = (guint64*) v1;
 984   return (*r > v2.v_uint64);
 985 }
 986
 987 /**
 988  *  @fn gboolean lttv_apply_op_gt_uint32(gpointer,LttvFieldValue)
 989  *
 990  *  Applies the 'greater than' operator to the
 991  *  specified structure and value
 992  *  @param v1 left member of comparison
 993  *  @param v2 right member of comparison
 994  *  @return success/failure of operation
 995  */
 996 gboolean lttv_apply_op_gt_uint32(const gpointer v1, LttvFieldValue v2) {
 997   guint32* r = (guint32*) v1;
 998   return (*r > v2.v_uint32);
 999 }
1000
1001 /**
1002  *  @fn gboolean lttv_apply_op_gt_uint16(gpointer,LttvFieldValue)
1003  *
1004  *  Applies the 'greater than' operator to the
1005  *  specified structure and value
1006  *  @param v1 left member of comparison
1007  *  @param v2 right member of comparison
1008  *  @return success/failure of operation
1009  */
1010 gboolean lttv_apply_op_gt_uint16(const gpointer v1, LttvFieldValue v2) {
1011   guint16* r = (guint16*) v1;
1012   return (*r > v2.v_uint16);
1013 }
1014
1015 /**
1016  *  @fn gboolean lttv_apply_op_gt_double(gpointer,LttvFieldValue)
1017  *
1018  *  Applies the 'greater than' operator to the
1019  *  specified structure and value
1020  *  @param v1 left member of comparison
1021  *  @param v2 right member of comparison
1022  *  @return success/failure of operation
1023  */
1024 gboolean lttv_apply_op_gt_double(const gpointer v1, LttvFieldValue v2) {
1025   double* r = (double*) v1;
1026   return (*r > v2.v_double);
1027 }
1028
1029 /**
1030  *  @fn gboolean lttv_apply_op_gt_ltttime(gpointer,LttvFieldValue)
1031  *
1032  *  Applies the 'greater than' operator to the
1033  *  specified structure and value
1034  *  @param v1 left member of comparison
1035  *  @param v2 right member of comparison
1036  *  @return success/failure of operation
1037  */
1038 gboolean lttv_apply_op_gt_ltttime(const gpointer v1, LttvFieldValue v2) {
1039   LttTime* r = (LttTime*) v1;
1040 //  return ((r->tv_sec > v2.v_ltttime.tv_sec) || ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec > v2.v_ltttime.tv_nsec)));
1041   return ltt_time_compare(*r, v2.v_ltttime)==1?1:0;
1042 }
1043
1044 /**
1045  *  @fn gboolean lttv_apply_op_ge_uint(gpointer,LttvFieldValue)
1046  *
1047  *  Applies the 'greater or equal' operator to the
1048  *  specified structure and value
1049  *  @param v1 left member of comparison
1050  *  @param v2 right member of comparison
1051  *  @return success/failure of operation
1052  */
1053 gboolean lttv_apply_op_ge_uint(const gpointer v1, LttvFieldValue v2) {
1054   guint* r = (guint*) v1;
1055   return (*r >= v2.v_uint);
1056 }
1057
1058 /**
1059  *  @fn gboolean lttv_apply_op_ge_uint64(gpointer,LttvFieldValue)
1060  *
1061  *  Applies the 'greater or equal' operator to the
1062  *  specified structure and value
1063  *  @param v1 left member of comparison
1064  *  @param v2 right member of comparison
1065  *  @return success/failure of operation
1066  */
1067 gboolean lttv_apply_op_ge_uint64(const gpointer v1, LttvFieldValue v2) {
1068   guint64* r = (guint64*) v1;
1069   return (*r >= v2.v_uint64);
1070 }
1071
1072 /**
1073  *  @fn gboolean lttv_apply_op_ge_uint32(gpointer,LttvFieldValue)
1074  *
1075  *  Applies the 'greater or equal' operator to the
1076  *  specified structure and value
1077  *  @param v1 left member of comparison
1078  *  @param v2 right member of comparison
1079  *  @return success/failure of operation
1080  */
1081 gboolean lttv_apply_op_ge_uint32(const gpointer v1, LttvFieldValue v2) {
1082   guint32* r = (guint32*) v1;
1083   return (*r >= v2.v_uint32);
1084 }
1085
1086 /**
1087  *  @fn gboolean lttv_apply_op_ge_uint16(gpointer,LttvFieldValue)
1088  *
1089  *  Applies the 'greater or equal' operator to the
1090  *  specified structure and value
1091  *  @param v1 left member of comparison
1092  *  @param v2 right member of comparison
1093  *  @return success/failure of operation
1094  */
1095 gboolean lttv_apply_op_ge_uint16(const gpointer v1, LttvFieldValue v2) {
1096   guint16* r = (guint16*) v1;
1097   return (*r >= v2.v_uint16);
1098 }
1099
1100 /**
1101  *  @fn gboolean lttv_apply_op_ge_double(gpointer,LttvFieldValue)
1102  *
1103  *  Applies the 'greater or equal' operator to the
1104  *  specified structure and value
1105  *  @param v1 left member of comparison
1106  *  @param v2 right member of comparison
1107  *  @return success/failure of operation
1108  */
1109 gboolean lttv_apply_op_ge_double(const gpointer v1, LttvFieldValue v2) {
1110   double* r = (double*) v1;
1111   return (*r >= v2.v_double);
1112 }
1113
1114 /**
1115  *  @fn gboolean lttv_apply_op_ge_ltttime(gpointer,LttvFieldValue)
1116  *
1117  *  Applies the 'greater or equal' operator to the
1118  *  specified structure and value
1119  *  @param v1 left member of comparison
1120  *  @param v2 right member of comparison
1121  *  @return success/failure of operation
1122  */
1123 gboolean lttv_apply_op_ge_ltttime(const gpointer v1, LttvFieldValue v2) {
1124   LttTime* r = (LttTime*) v1;
1125 //  return ((r->tv_sec > v2.v_ltttime.tv_sec) || ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec >= v2.v_ltttime.tv_nsec)));
1126   return ltt_time_compare(*r, v2.v_ltttime)>-1?1:0;
1127 }
1128
1129
1130
1131 /**
1132  *  Makes a copy of the current filter tree
1133  *  @param tree pointer to the current tree
1134  *  @return new copy of the filter tree
1135  */
1136 LttvFilterTree*
1137 lttv_filter_tree_clone(const LttvFilterTree* tree) {
1138
1139   LttvFilterTree* newtree = lttv_filter_tree_new();
1140
1141   newtree->node = tree->node;
1142
1143   newtree->left = tree->left;
1144   if(newtree->left == LTTV_TREE_NODE) {
1145     newtree->l_child.t = lttv_filter_tree_clone(tree->l_child.t);
1146   } else if(newtree->left == LTTV_TREE_LEAF) {
1147     newtree->l_child.leaf = lttv_simple_expression_new();
1148     newtree->l_child.leaf->field = tree->l_child.leaf->field;
1149     newtree->l_child.leaf->offset = tree->l_child.leaf->offset;
1150     newtree->l_child.leaf->op = tree->l_child.leaf->op;
1151     /* FIXME: special case for string copy ! */
1152     newtree->l_child.leaf->value = tree->l_child.leaf->value;
1153   }
1154
1155   newtree->right = tree->right;
1156   if(newtree->right == LTTV_TREE_NODE) {
1157     newtree->r_child.t = lttv_filter_tree_clone(tree->r_child.t);
1158   } else if(newtree->right == LTTV_TREE_LEAF) {
1159     newtree->r_child.leaf = lttv_simple_expression_new();
1160     newtree->r_child.leaf->field = tree->r_child.leaf->field;
1161     newtree->r_child.leaf->offset = tree->r_child.leaf->offset;
1162     newtree->r_child.leaf->op = tree->r_child.leaf->op;
1163     newtree->r_child.leaf->value = tree->r_child.leaf->value;
1164   }
1165
1166   return newtree;
1167
1168 }
1169
1170 /**
1171  *  Makes a copy of the current filter
1172  *  @param filter pointer to the current filter
1173  *  @return new copy of the filter
1174  */
1175 LttvFilter*
1176 lttv_filter_clone(const LttvFilter* filter) {
1177
1178         if(!filter) return NULL;
1179
1180   LttvFilter* newfilter = g_new(LttvFilter,1);
1181
1182   strcpy(newfilter->expression,filter->expression);
1183
1184   newfilter->head = lttv_filter_tree_clone(filter->head);
1185
1186   return newfilter;
1187
1188 }
1189
1190
1191 /**
1192  *  @fn LttvFilter* lttv_filter_new()
1193  *
1194  *      Creates a new LttvFilter
1195  *      @return the current LttvFilter or NULL if error
1196  */
1197 LttvFilter*
1198 lttv_filter_new() {
1199
1200   LttvFilter* filter = g_new(LttvFilter,1);
1201   filter->expression = NULL;
1202   filter->head = NULL;
1203
1204   return filter;
1205
1206 }
1207
1208 /**
1209  *  @fn gboolean lttv_filter_update(LttvFilter*)
1210  *
1211  *  Updates the current LttvFilter by building
1212  *  its tree based upon the expression string
1213  *  @param filter pointer to the current LttvFilter
1214  *  @return Failure/Success of operation
1215  */
1216 gboolean
1217 lttv_filter_update(LttvFilter* filter) {
1218
1219 //  g_print("filter::lttv_filter_new()\n");             /* debug */
1220
1221   if(filter->expression == NULL) return FALSE;
1222
1223   int
1224     i,
1225     p_nesting=0,        /* parenthesis nesting value */
1226     not=0;
1227
1228   /* trees */
1229   LttvFilterTree
1230     *tree = lttv_filter_tree_new(),   /* main tree */
1231     *subtree = NULL,                  /* buffer for subtrees */
1232     *t1,                              /* buffer #1 */
1233     *t2,                              /* buffer #2 */
1234     *t3;                              /* buffer #3 */
1235
1236   /*
1237    * the filter
1238    * If the tree already exists,
1239    * destroy it and build a new one
1240    */
1241   if(filter->head != NULL) lttv_filter_tree_destroy(filter->head);
1242   filter->head = NULL;    /* will be assigned at the end */
1243
1244   /*
1245    * Tree Stack
1246    * each element of the list
1247    * is a sub tree created
1248    * by the use of parenthesis in the
1249    * global expression.  The final tree
1250    * will be the one left at the root of
1251    * the list
1252    */
1253   GPtrArray *tree_stack = g_ptr_array_new();
1254   g_ptr_array_add( tree_stack,(gpointer) tree );
1255
1256   /* temporary values */
1257   GString *a_field_component = g_string_new("");
1258   GString *a_string_spaces = g_string_new("");
1259   GPtrArray *a_field_path = g_ptr_array_new();
1260
1261   /* simple expression buffer */
1262   LttvSimpleExpression* a_simple_expression = lttv_simple_expression_new();
1263
1264   /*
1265    *    Parse entire expression and construct
1266    *    the binary tree.  There are two steps
1267    *    in browsing that string
1268    *      1. finding boolean ops " &,|,^,! " and parenthesis " {,(,[,],),} "
1269    *      2. finding simple expressions
1270    *        - field path ( separated by dots )
1271    *        - op ( >, <, =, >=, <=, !=)
1272    *        - value ( integer, string ... )
1273    *    To spare computing time, the whole
1274    *    string is parsed in this loop for a
1275    *    O(n) complexity order.
1276    *
1277    *  When encountering logical op &,|,^
1278    *    1. parse the last value if any
1279    *    2. create a new tree
1280    *    3. add the expression (simple exp, or exp (subtree)) to the tree
1281    *    4. concatenate this tree with the current tree on top of the stack
1282    *  When encountering math ops >,>=,<,<=,=,!=
1283    *    1. add to op to the simple expression
1284    *    2. concatenate last field component to field path
1285    *  When encountering concatening ops .
1286    *    1. concatenate last field component to field path
1287    *  When encountering opening parenthesis (,{,[
1288    *    1. create a new subtree on top of tree stack
1289    *  When encountering closing parenthesis ),},]
1290    *    1. add the expression on right child of the current tree
1291    *    2. the subtree is completed, allocate a new subtree
1292    *    3. pop the tree value from the tree stack
1293    */
1294
1295 #ifdef TEST
1296   struct timeval starttime;
1297   struct timeval endtime;
1298   gettimeofday(&starttime, NULL);
1299 #endif
1300
1301   for(i=0;i<strlen(filter->expression);i++) {
1302     // debug
1303 //    g_print("%c\n ",filter->expression[i]);
1304
1305     switch(filter->expression[i]) {
1306       /*
1307        *   logical operators
1308        */
1309       case '&':   /* and */
1310
1311         /* get current tree in tree stack */
1312         t1 = (LttvFilterTree*)g_ptr_array_index(tree_stack,tree_stack->len-1);
1313
1314         /* get current node at absolute right */
1315         while(t1->right != LTTV_TREE_IDLE) {
1316           g_assert(t1->right == LTTV_TREE_NODE);
1317           t1 = t1->r_child.t;
1318         }
1319         t2 = lttv_filter_tree_new();
1320         t2->node = LTTV_LOGICAL_AND;
1321         t1->right = LTTV_TREE_NODE;
1322         t1->r_child.t = t2;
1323         if(not) {   /* add not operator to tree */
1324           t3 = lttv_filter_tree_new();
1325           t3->node = LTTV_LOGICAL_NOT;
1326           t2->left = LTTV_TREE_NODE;
1327           t2->l_child.t = t3;
1328           t2 = t3;
1329           not = 0;
1330         }
1331         if(subtree != NULL) {   /* append subtree to current tree */
1332           t2->left = LTTV_TREE_NODE;
1333           t2->l_child.t = subtree;
1334           subtree = NULL;
1335         } else {  /* append a simple expression */
1336           lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE));
1337           a_field_component = g_string_new("");
1338                                         g_string_free(a_string_spaces, TRUE);
1339                                         a_string_spaces = g_string_new("");
1340           t2->left = LTTV_TREE_LEAF;
1341           t2->l_child.leaf = a_simple_expression;
1342           a_simple_expression = lttv_simple_expression_new();
1343         }
1344         break;
1345
1346       case '|':   /* or */
1347
1348         t1 = (LttvFilterTree*)g_ptr_array_index(tree_stack,tree_stack->len-1);
1349          while(t1->right != LTTV_TREE_IDLE) {
1350           g_assert(t1->right == LTTV_TREE_NODE);
1351           t1 = t1->r_child.t;
1352         }
1353         t2 = lttv_filter_tree_new();
1354         t2->node = LTTV_LOGICAL_OR;
1355         t1->right = LTTV_TREE_NODE;
1356         t1->r_child.t = t2;
1357         if(not) { // add not operator to tree
1358           t3 = lttv_filter_tree_new();
1359           t3->node = LTTV_LOGICAL_NOT;
1360           t2->left = LTTV_TREE_NODE;
1361           t2->l_child.t = t3;
1362           t2 = t3;
1363           not = 0;
1364        }
1365        if(subtree != NULL) {   /* append subtree to current tree */
1366           t2->left = LTTV_TREE_NODE;
1367           t2->l_child.t = subtree;
1368           subtree = NULL;
1369        } else {    /* append a simple expression */
1370           lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE));
1371           a_field_component = g_string_new("");
1372                                         g_string_free(a_string_spaces, TRUE);
1373                                         a_string_spaces = g_string_new("");
1374           t2->left = LTTV_TREE_LEAF;
1375           t2->l_child.leaf = a_simple_expression;
1376           a_simple_expression = lttv_simple_expression_new();
1377         }
1378         break;
1379
1380       case '^':   /* xor */
1381
1382         t1 = (LttvFilterTree*)g_ptr_array_index(tree_stack,tree_stack->len-1);
1383         while(t1->right != LTTV_TREE_IDLE) {
1384           g_assert(t1->right == LTTV_TREE_NODE);
1385           t1 = t1->r_child.t;
1386         }
1387         t2 = lttv_filter_tree_new();
1388         t2->node = LTTV_LOGICAL_XOR;
1389         t1->right = LTTV_TREE_NODE;
1390         t1->r_child.t = t2;
1391         if(not) { // add not operator to tree
1392           t3 = lttv_filter_tree_new();
1393           t3->node = LTTV_LOGICAL_NOT;
1394           t2->left = LTTV_TREE_NODE;
1395           t2->l_child.t = t3;
1396           t2 = t3;
1397           not = 0;
1398         }
1399         if(subtree != NULL) {   /* append subtree to current tree */
1400           t2->left = LTTV_TREE_NODE;
1401           t2->l_child.t = subtree;
1402           subtree = NULL;
1403         } else {    /* append a simple expression */
1404           lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE));
1405           a_field_component = g_string_new("");
1406                                         g_string_free(a_string_spaces, TRUE);
1407                                         a_string_spaces = g_string_new("");
1408           t2->left = LTTV_TREE_LEAF;
1409           t2->l_child.leaf = a_simple_expression;
1410           a_simple_expression = lttv_simple_expression_new();
1411         }
1412         break;
1413
1414       case '!':   /* not, or not equal (math op) */
1415
1416         if(filter->expression[i+1] == '=') {  /* != */
1417           g_ptr_array_add( a_field_path,(gpointer) a_field_component );
1418           lttv_simple_expression_assign_field(a_field_path,a_simple_expression);
1419           a_field_component = g_string_new("");
1420                                         g_string_free(a_string_spaces, TRUE);
1421                                         a_string_spaces = g_string_new("");
1422           lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_NE);
1423           i++;
1424         } else {  /* ! */
1425           not=1;
1426         }
1427         break;
1428
1429       case '(':   /* start of parenthesis */
1430       case '[':
1431       case '{':
1432
1433         p_nesting++;      /* incrementing parenthesis nesting value */
1434         t1 = lttv_filter_tree_new();
1435         if(not) { /* add not operator to tree */
1436           t3 = lttv_filter_tree_new();
1437           t3->node = LTTV_LOGICAL_NOT;
1438           t1->right = LTTV_TREE_NODE;
1439           t1->r_child.t = t3;
1440           not = 0;
1441         }
1442         g_ptr_array_add( tree_stack,(gpointer) t1 );
1443         break;
1444
1445       case ')':   /* end of parenthesis */
1446       case ']':
1447       case '}':
1448
1449         p_nesting--;      /* decrementing parenthesis nesting value */
1450         if(p_nesting<0 || tree_stack->len<2) {
1451           g_warning("Wrong filtering options, the string\n\"%s\"\n\
1452                      is not valid due to parenthesis incorrect use",filter->expression);
1453           return FALSE;
1454         }
1455
1456         /* there must at least be the root tree left in the array */
1457         g_assert(tree_stack->len>0);
1458
1459         t1 = g_ptr_array_index(tree_stack,tree_stack->len-1);
1460         while(t1->right != LTTV_TREE_IDLE) {
1461            t1 = t1->r_child.t;
1462         }
1463         if(not) { // add not operator to tree
1464           g_print("ici");
1465           t3 = lttv_filter_tree_new();
1466           t3->node = LTTV_LOGICAL_NOT;
1467           t1->right = LTTV_TREE_NODE;
1468           t1->r_child.t = t3;
1469           t1 = t3;
1470           not = 0;
1471         }
1472         if(subtree != NULL) {   /* append subtree to current tree */
1473           t1->right = LTTV_TREE_NODE;
1474           t1->r_child.t = subtree;
1475           subtree = g_ptr_array_index(tree_stack,tree_stack->len-1);
1476           g_ptr_array_remove_index(tree_stack,tree_stack->len-1);
1477         } else {    /* assign subtree as current tree */
1478           lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE));
1479           a_field_component = g_string_new("");
1480                                         g_string_free(a_string_spaces, TRUE);
1481                                         a_string_spaces = g_string_new("");
1482           t1->right = LTTV_TREE_LEAF;
1483           t1->r_child.leaf = a_simple_expression;
1484           a_simple_expression = lttv_simple_expression_new();
1485           subtree = g_ptr_array_remove_index(tree_stack,tree_stack->len-1);
1486         }
1487         break;
1488
1489       /*
1490        *        mathematic operators
1491        */
1492       case '<':   /* lower, lower or equal */
1493
1494         g_ptr_array_add( a_field_path,(gpointer) a_field_component );
1495         lttv_simple_expression_assign_field(a_field_path,a_simple_expression);
1496         a_field_component = g_string_new("");
1497                                 g_string_free(a_string_spaces, TRUE);
1498                                 a_string_spaces = g_string_new("");
1499         if(filter->expression[i+1] == '=') { /* <= */
1500           i++;
1501           lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_LE);
1502         } else lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_LT);
1503        break;
1504
1505       case '>':   /* higher, higher or equal */
1506
1507         g_ptr_array_add( a_field_path,(gpointer) a_field_component );
1508         lttv_simple_expression_assign_field(a_field_path,a_simple_expression);
1509         a_field_component = g_string_new("");
1510                                 g_string_free(a_string_spaces, TRUE);
1511                                 a_string_spaces = g_string_new("");
1512         if(filter->expression[i+1] == '=') {  /* >= */
1513           i++;
1514           lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_GE);
1515         } else lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_GT);
1516        break;
1517
1518       case '=':   /* equal */
1519
1520         g_ptr_array_add( a_field_path,(gpointer) a_field_component );
1521         lttv_simple_expression_assign_field(a_field_path,a_simple_expression);
1522         a_field_component = g_string_new("");
1523                                 g_string_free(a_string_spaces, TRUE);
1524                                 a_string_spaces = g_string_new("");
1525         lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_EQ);
1526         break;
1527
1528       /*
1529        *  Field concatening caracter
1530        */
1531       case '.':   /* dot */
1532
1533         /*
1534          * divide field expression into elements
1535          * in a_field_path array.
1536          *
1537          * A dot can also be present in double values
1538          */
1539         if(a_simple_expression->field == LTTV_FILTER_UNDEFINED) {
1540           g_ptr_array_add( a_field_path,(gpointer) a_field_component );
1541           a_field_component = g_string_new("");
1542                                         g_string_free(a_string_spaces, TRUE);
1543                                         a_string_spaces = g_string_new("");
1544         }
1545         break;
1546       case ' ':   /* keep spaces that are within a field component */
1547                                 if(a_field_component->len == 0) break; /* ignore */
1548                                 else
1549                 a_string_spaces = g_string_append_c(a_string_spaces,
1550                                                                                                                                                                                         filter->expression[i]);
1551
1552       case '\n':  /* ignore */
1553         break;
1554       default:    /* concatening current string */
1555                                 if(a_string_spaces->len != 0) {
1556                 g_string_append(a_field_component, a_string_spaces->str);
1557                                         a_string_spaces = g_string_set_size(a_string_spaces, 0);
1558                                 }
1559         a_field_component = g_string_append_c(a_field_component,
1560                                                                                                                                                                                         filter->expression[i]);
1561     }
1562   }
1563
1564   /*
1565    * Preliminary check to see
1566    * if tree was constructed correctly
1567    */
1568   if( p_nesting>0 ) {
1569     g_warning("Wrong filtering options, the string\n\"%s\"\n\
1570         is not valid due to parenthesis incorrect use",filter->expression);
1571     return FALSE;
1572   }
1573
1574   if(tree_stack->len != 1) /* only root tree should remain */
1575     return FALSE;
1576
1577   /*
1578    *  processing last element of expression
1579    */
1580   t1 = g_ptr_array_index(tree_stack,tree_stack->len-1);
1581   while(t1->right != LTTV_TREE_IDLE) {
1582     g_assert(t1->right == LTTV_TREE_NODE);
1583     t1 = t1->r_child.t;
1584   }
1585   if(not) { // add not operator to tree
1586      t3 = lttv_filter_tree_new();
1587      t3->node = LTTV_LOGICAL_NOT;
1588      t1->right = LTTV_TREE_NODE;
1589      t1->r_child.t = t3;
1590      t1 = t3;
1591      not = 0;
1592   }
1593   if(subtree != NULL) {  /* add the subtree */
1594     t1->right = LTTV_TREE_NODE;
1595     t1->r_child.t = subtree;
1596     subtree = NULL;
1597   } else {  /* add a leaf */
1598     lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE));
1599     a_field_component = NULL;
1600                 g_string_free(a_string_spaces, TRUE);
1601                 a_string_spaces = NULL;
1602     t1->right = LTTV_TREE_LEAF;
1603     t1->r_child.leaf = a_simple_expression;
1604     a_simple_expression = NULL;
1605   }
1606
1607
1608   /* free the pointer array */
1609   g_assert(a_field_path->len == 0);
1610   g_ptr_array_free(a_field_path,TRUE);
1611
1612   /* free the tree stack -- but keep the root tree */
1613   filter->head = g_ptr_array_remove_index(tree_stack,0);
1614   g_ptr_array_free(tree_stack,TRUE);
1615
1616   /* free the field buffer if allocated */
1617   if(a_field_component != NULL) g_string_free(a_field_component,TRUE);
1618         if(a_string_spaces != NULL) g_string_free(a_string_spaces, TRUE);
1619
1620   /* free the simple expression buffer if allocated */
1621   if(a_simple_expression != NULL) lttv_simple_expression_destroy(a_simple_expression);
1622
1623   g_assert(filter->head != NULL); /* tree should exist */
1624   g_assert(subtree == NULL); /* remaining subtree should be included in main tree */
1625
1626 #ifdef TEST
1627   gettimeofday(&endtime, NULL);
1628
1629   /* Calcul du temps de l'algorithme */
1630   double time1 = starttime.tv_sec + (starttime.tv_usec/1000000.0);
1631   double time2 = endtime.tv_sec + (endtime.tv_usec/1000000.0);
1632 // g_print("Tree build took %.10f ms for strlen of %i\n",(time2-time1)*1000,strlen(filter->expression));
1633   g_print("%.10f %i\n",(time2-time1)*1000,strlen(filter->expression));
1634 #endif
1635
1636   /* debug */
1637   g_debug("+++++++++++++++ BEGIN PRINT ++++++++++++++++\n");
1638   lttv_print_tree(filter->head,0) ;
1639   g_debug("+++++++++++++++ END PRINT ++++++++++++++++++\n");
1640
1641   /* success */
1642   return TRUE;
1643
1644 }
1645
1646 /**
1647  *  @fn void lttv_filter_destroy(LttvFilter*)
1648  *
1649  *  Destroy the current LttvFilter
1650  *  @param filter pointer to the current LttvFilter
1651  */
1652 void
1653 lttv_filter_destroy(LttvFilter* filter) {
1654
1655         if(!filter) return;
1656
1657         if(filter->expression)
1658           g_free(filter->expression);
1659         if(filter->head)
1660           lttv_filter_tree_destroy(filter->head);
1661   g_free(filter);
1662
1663 }
1664
1665 /**
1666  *  @fn LttvFilterTree* lttv_filter_tree_new()
1667  *
1668  *  Assign a new tree for the current expression
1669  *  or sub expression
1670  *  @return pointer of LttvFilterTree
1671  */
1672 LttvFilterTree*
1673 lttv_filter_tree_new() {
1674   LttvFilterTree* tree;
1675
1676   tree = g_new(LttvFilterTree,1);
1677   tree->node = 0; //g_new(lttv_expression,1);
1678   tree->left = LTTV_TREE_IDLE;
1679   tree->right = LTTV_TREE_IDLE;
1680   tree->r_child.t = NULL;
1681   tree->l_child.t = NULL;
1682
1683   return tree;
1684 }
1685
1686 /**
1687  *  @fn void lttv_filter_append_expression(LttvFilter*,char*)
1688  *
1689  *  Append a new expression to the expression
1690  *  defined in the current filter
1691  *  @param filter pointer to the current LttvFilter
1692  *  @param expression string that must be appended
1693  *  @return Success/Failure of operation
1694  */
1695 gboolean
1696 lttv_filter_append_expression(LttvFilter* filter, const char *expression) {
1697
1698   if(expression == NULL) return FALSE;
1699   if(filter == NULL) return FALSE;
1700   if(expression[0] == '\0') return FALSE;  /* Empty expression */
1701
1702   GString* s = g_string_new("");
1703   if(filter->expression != NULL) {
1704     g_string_append(s,filter->expression);
1705     g_string_append_c(s,'&');
1706   }
1707   g_string_append(s,expression);
1708
1709   g_free(filter->expression);
1710   filter->expression = g_string_free(s,FALSE);
1711
1712   /* TRUE if construction of tree proceeded without errors */
1713   return lttv_filter_update(filter);
1714
1715 }
1716
1717 /**
1718  *  @fn void lttv_filter_clear_expression(LttvFilter*)
1719  *
1720  *  Clear the filter expression from the
1721  *  current filter and sets its pointer to NULL
1722  *  @param filter pointer to the current LttvFilter
1723  */
1724 void
1725 lttv_filter_clear_expression(LttvFilter* filter) {
1726
1727   if(filter->expression != NULL) {
1728     g_free(filter->expression);
1729     filter->expression = NULL;
1730   }
1731
1732 }
1733
1734 /**
1735  *  @fn void lttv_filter_tree_destroy(LttvFilterTree*)
1736  *
1737  *  Destroys the tree and his sub-trees
1738  *  @param tree Tree which must be destroyed
1739  */
1740 void
1741 lttv_filter_tree_destroy(LttvFilterTree* tree) {
1742
1743   if(tree == NULL) return;
1744
1745   if(tree->left == LTTV_TREE_LEAF) lttv_simple_expression_destroy(tree->l_child.leaf);
1746   else if(tree->left == LTTV_TREE_NODE) lttv_filter_tree_destroy(tree->l_child.t);
1747
1748   if(tree->right == LTTV_TREE_LEAF) lttv_simple_expression_destroy(tree->r_child.leaf);
1749   else if(tree->right == LTTV_TREE_NODE) lttv_filter_tree_destroy(tree->r_child.t);
1750
1751 //  g_free(tree->node);
1752   g_free(tree);
1753 }
1754
1755 /**
1756  *  Global parsing function for the current
1757  *  LttvFilterTree
1758  *  @param t pointer to the current LttvFilterTree
1759  *  @param event current LttEvent, NULL if not used
1760  *  @param tracefile current LttTracefile, NULL if not used
1761  *  @param trace current LttTrace, NULL if not used
1762  *  @param state current LttvProcessState, NULL if not used
1763  *  @param context current LttvTracefileContext, NULL if not used
1764  *  @return response of filter
1765  */
1766 gboolean
1767 lttv_filter_tree_parse(
1768         const LttvFilterTree* t,
1769         const LttEvent* event,
1770         const LttTracefile* tracefile,
1771         const LttTrace* trace,
1772         const LttvTracefileContext* context
1773         /*,...*/)
1774 {
1775
1776    /*
1777    *  Each tree is parsed in inorder.
1778    *  This way, it's possible to apply the left filter of the
1779    *  tree, then decide whether or not the right branch should
1780    *  be parsed depending on the linking logical operator
1781    *
1782    *  Each node consists in a
1783    *  1. logical operator
1784    *  2. left child ( node or simple expression )
1785    *  3. right child ( node or simple expression )
1786    *
1787    *  When the child is a simple expression, we must
1788    *  before all determine if the expression refers to
1789    *  a structure which is whithin observation ( not NULL ).
1790    *    -If so, the expression is evaluated.
1791    *    -If not, the result is set to TRUE since this particular
1792    *     operation does not interfere with the lttv structure
1793    *
1794    *  The result of each simple expression will directly
1795    *  affect the next branch.  This way, depending on
1796    *  the linking logical operator, the parser will decide
1797    *  to explore or not the next branch.
1798    *  1. AND OPERATOR
1799    *     -If result of left branch is 0 / FALSE
1800    *      then don't explore right branch and return 0;
1801    *     -If result of left branch is 1 / TRUE then explore
1802    *  2. OR OPERATOR
1803    *     -If result of left branch is 1 / TRUE
1804    *      then don't explore right branch and return 1;
1805    *     -If result of left branch is 0 / FALSE then explore
1806    *  3. XOR OPERATOR
1807    *     -Result of left branch will not affect exploration of
1808    *      right branch
1809    */
1810
1811   gboolean lresult = FALSE, rresult = FALSE;
1812
1813   LttvProcessState* state;
1814
1815   guint cpu = ltt_tracefile_num(context->tf);
1816   LttvTraceState *ts = (LttvTraceState*)context->t_context;
1817   state = ts->running_process[cpu];
1818
1819   /*
1820    * Parse left branch
1821    */
1822   if(t->left == LTTV_TREE_NODE) {
1823       lresult = lttv_filter_tree_parse(t->l_child.t,event,tracefile,trace,context);
1824   }
1825   else if(t->left == LTTV_TREE_LEAF) {
1826       lresult = lttv_filter_tree_parse_branch(t->l_child.leaf,event,tracefile,trace,state,context);
1827   }
1828
1829   /*
1830    * Parse linking operator
1831    * make a cutoff if possible
1832    */
1833   if((t->node & LTTV_LOGICAL_OR) && lresult == TRUE) return TRUE;
1834   if((t->node & LTTV_LOGICAL_AND) && lresult == FALSE) return FALSE;
1835
1836   /*
1837    * Parse right branch
1838    */
1839   if(t->right == LTTV_TREE_NODE) {
1840       rresult = lttv_filter_tree_parse(t->r_child.t,event,tracefile,trace,context);
1841   }
1842   else if(t->right == LTTV_TREE_LEAF) {
1843       rresult = lttv_filter_tree_parse_branch(t->r_child.leaf,event,tracefile,trace,state,context);
1844   }
1845
1846
1847   /*
1848    * Apply and return the
1849    * logical link between the
1850    * two operation
1851    */
1852   switch(t->node) {
1853     case LTTV_LOGICAL_OR: return (lresult | rresult);
1854     case LTTV_LOGICAL_AND: return (lresult & rresult);
1855     case LTTV_LOGICAL_NOT:
1856       return (t->left==LTTV_TREE_LEAF)?!lresult:((t->right==LTTV_TREE_LEAF)?!rresult:TRUE);
1857     case LTTV_LOGICAL_XOR: return (lresult ^ rresult);
1858     case 0: return (rresult);
1859     default:
1860       /*
1861        * This case should never be
1862        * parsed, if so, this subtree
1863        * is cancelled !
1864        */
1865       return TRUE;
1866   }
1867
1868 }
1869
1870 /**
1871  *  This function parses a particular branch of the tree
1872  *  @param se pointer to the current LttvSimpleExpression
1873  *  @param event current LttEvent, NULL if not used
1874  *  @param tracefile current LttTracefile, NULL if not used
1875  *  @param trace current LttTrace, NULL if not used
1876  *  @param state current LttvProcessState, NULL if not used
1877  *  @param context current LttvTracefileContext, NULL if not used
1878  *  @return response of filter
1879  */
1880 gboolean
1881 lttv_filter_tree_parse_branch(
1882         const LttvSimpleExpression* se,
1883         const LttEvent* event,
1884         const LttTracefile* tracefile,
1885         const LttTrace* trace,
1886         const LttvProcessState* state,
1887         const LttvTracefileContext* context) {
1888
1889     LttvFieldValue v;
1890     v = se->value;
1891     switch(se->field) {
1892         case LTTV_FILTER_TRACE_NAME:
1893             if(trace == NULL) return TRUE;
1894             else {
1895                 GQuark quark = ltt_trace_name(trace);
1896                 return se->op((gpointer)&quark,v);
1897             }
1898             break;
1899         case LTTV_FILTER_TRACEFILE_NAME:
1900             if(tracefile == NULL) return TRUE;
1901             else {
1902                 GQuark quark = ltt_tracefile_name(tracefile);
1903                 return se->op((gpointer)&quark,v);
1904             }
1905             break;
1906         case LTTV_FILTER_STATE_PID:
1907             if(state == NULL) return TRUE;
1908             else return se->op((gpointer)&state->pid,v);
1909             break;
1910         case LTTV_FILTER_STATE_PPID:
1911             if(state == NULL) return TRUE;
1912             else return se->op((gpointer)&state->ppid,v);
1913             break;
1914         case LTTV_FILTER_STATE_CT:
1915             if(state == NULL) return TRUE;
1916             else {
1917               return se->op((gpointer)&state->creation_time,v);
1918             }
1919             break;
1920         case LTTV_FILTER_STATE_IT:
1921             if(state == NULL) return TRUE;
1922             else {
1923               return se->op((gpointer)&state->insertion_time,v);
1924             }
1925             break;
1926         case LTTV_FILTER_STATE_P_NAME:
1927             /*
1928              * All 'unnamed' for the moment
1929              */
1930             if(state == NULL) return TRUE;
1931             else {
1932               GQuark quark = state->name;
1933               return se->op((gpointer)&quark,v);
1934             }
1935             break;
1936         case LTTV_FILTER_STATE_EX_MODE:
1937             if(state == NULL) return TRUE;
1938             else return se->op((gpointer)&state->state->t,v);
1939             break;
1940         case LTTV_FILTER_STATE_EX_SUBMODE:
1941             if(state == NULL) return TRUE;
1942             else return se->op((gpointer)&state->state->n,v);
1943             break;
1944         case LTTV_FILTER_STATE_P_STATUS:
1945             if(state == NULL) return TRUE;
1946             else return se->op((gpointer)&state->state->s,v);
1947             break;
1948         case LTTV_FILTER_STATE_CPU:
1949             if(context == NULL) return TRUE;
1950             else {
1951               /* FIXME: not sure of that one  Mathieu : fixed.*/
1952  //             GQuark quark = ((LttvTracefileState*)context)->cpu_name;
1953  //                return se->op((gpointer)&quark,v);
1954               if(state == NULL) return TRUE;
1955               else return se->op((gpointer)&state->cpu,v);
1956             }
1957             break;
1958         case LTTV_FILTER_EVENT_NAME:
1959             if(event == NULL) return TRUE;
1960             else {
1961               LttEventType* et;
1962               et = ltt_event_eventtype(event);
1963               GQuark quark = ltt_eventtype_name(et);
1964               return se->op((gpointer)&quark,v);
1965             }
1966             break;
1967          case LTTV_FILTER_EVENT_FACILITY:
1968             if(event == NULL) return TRUE;
1969             else {
1970               LttFacility* fac;
1971               fac = ltt_event_facility(event);
1972               GQuark quark = ltt_facility_name(fac);
1973               return se->op((gpointer)&quark,v);
1974             }
1975             break;
1976         case LTTV_FILTER_EVENT_CATEGORY:
1977             /*
1978              * TODO: Not yet implemented
1979              */
1980             return TRUE;
1981             break;
1982         case LTTV_FILTER_EVENT_TIME:
1983             if(event == NULL) return TRUE;
1984             else {
1985                 LttTime time = ltt_event_time(event);
1986                 return se->op((gpointer)&time,v);
1987             }
1988             break;
1989         case LTTV_FILTER_EVENT_TSC:
1990             if(event == NULL) return TRUE;
1991             else {
1992               LttCycleCount count = ltt_event_cycle_count(event);
1993               return se->op((gpointer)&count,v);
1994             }
1995             break;
1996         case LTTV_FILTER_EVENT_FIELD:
1997             /*
1998              * TODO: Use the offset to
1999              * find the dynamic field
2000              * in the event struct
2001              */
2002             return TRUE;
2003         default:
2004             /*
2005              * This case should never be
2006              * parsed, if so, the whole
2007              * filtering is cancelled
2008              */
2009             g_warning("Error while parsing the filter tree");
2010             return TRUE;
2011     }
2012
2013     /* should never get here */
2014     return TRUE;
2015
2016 }
2017
2018
2019
2020 /**
2021  *  Debug function.  Prints tree memory allocation.
2022  *  @param t the pointer to the current LttvFilterTree
2023  */
2024 void
2025 lttv_print_tree(const LttvFilterTree* t, const int count) {
2026
2027   g_debug("node:%p lchild:%p rchild:%p depth:%i\n",t, //t->l_child.t,t->r_child.t);
2028           (t->left==LTTV_TREE_NODE)?t->l_child.t:NULL,
2029           (t->right==LTTV_TREE_NODE)?t->r_child.t:NULL,
2030           count);
2031   g_debug("logic operator: %s\n",(t->node&1)?"OR":((t->node&2)?"AND":((t->node&4)?"NOT":((t->node&8)?"XOR":"IDLE"))));
2032   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"));
2033   if(t->left == LTTV_TREE_LEAF) {
2034     g_debug("| |-> field type number: %i\n",t->l_child.leaf->field);
2035     g_debug("| |-> offset is: %i\n",t->l_child.leaf->offset);
2036     g_debug("| |-> operator function is: %p\n",t->l_child.leaf->op);
2037   }
2038   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"));
2039   if(t->right == LTTV_TREE_LEAF) {
2040     g_debug("| |-> field type number: %i\n",t->r_child.leaf->field);
2041     g_debug("| |-> offset is: %i\n",t->r_child.leaf->offset);
2042     g_debug("| |-> operator function is: %p\n",t->r_child.leaf->op);
2043   }
2044
2045   if(t->left == LTTV_TREE_NODE) lttv_print_tree(t->l_child.t,count+1);
2046   if(t->right == LTTV_TREE_NODE) lttv_print_tree(t->r_child.t,count+1);
2047 }
2048
2049 /**
2050  *  @fn static void module_init()
2051  *
2052  *  Initializes the filter module and specific values
2053  */
2054 static void module_init()
2055 {
2056
2057 }
2058
2059 /**
2060  *  Destroys the filter module and specific values
2061  */
2062 static void module_destroy()
2063 {
2064
2065 }
2066
2067
2068 LTTV_MODULE("filter", "Filters traceset and events", \
2069     "Filters traceset and events specifically to user input", \
2070     module_init, module_destroy)
2071
2072
2073