Ignore:
Timestamp:
07/17/15 13:58:13 (9 years ago)
Author:
rlacroix
Message:

Use the filter infrastructure to handle the expressions

Parse the expressions to get a new tree representation that can be converted to a filter graph based on new arithmetic filters.

Temporal operations are still unsupported.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/parse_expr/yacc_parser.yacc

    r501 r642  
    11%{ 
    2 #include "simple_node_expr.hpp" 
     2#include "filter_expr_node.hpp" 
    33#include <string> 
    44#include <iostream> 
    55#include "exception.hpp" 
    66 
    7 using namespace std ; 
    8 using namespace xios ; 
     7using namespace std; 
     8using namespace xios; 
    99 
    1010extern "C" 
    … …  
    1212  int yyparse(void); 
    1313  int yylex(void); 
    14   int yyerror(const char *s) ; 
     14  int yyerror(const char *s); 
    1515} 
    1616 
    17    CSimpleNodeExpr* parsed ; 
    18    std::string globalInputText; 
    19    int globalReadOffset=0; 
    20     
    21    int readInputForLexer( char *buffer, int *numBytesRead, int maxBytesToRead ) 
    22    { 
    23     int numBytesToRead = maxBytesToRead; 
    24     int bytesRemaining = globalInputText.length()-globalReadOffset; 
    25     int i; 
    26     if ( numBytesToRead > bytesRemaining ) numBytesToRead = bytesRemaining; 
    27     for ( i = 0; i < numBytesToRead; i++ ) buffer[i] = globalInputText.c_str()[globalReadOffset+i]; 
     17  IFilterExprNode* parsed; 
     18  std::string globalInputText; 
     19  size_t globalReadOffset = 0; 
     20 
     21  int readInputForLexer(char* buffer, size_t* numBytesRead, size_t maxBytesToRead) 
     22  { 
     23    size_t numBytesToRead = maxBytesToRead; 
     24    size_t bytesRemaining = globalInputText.length()-globalReadOffset; 
     25    size_t i; 
     26    if (numBytesToRead > bytesRemaining) numBytesToRead = bytesRemaining; 
     27    for (i = 0; i < numBytesToRead; i++) buffer[i] = globalInputText.c_str()[globalReadOffset + i]; 
    2828    *numBytesRead = numBytesToRead; 
    2929    globalReadOffset += numBytesToRead; 
    3030    return 0; 
    31    } 
    32  
     31  } 
    3332%} 
    3433 
    3534%union 
    3635{ 
    37     std::string* str ;                /* symbol table index */ 
    38     CSimpleNodeExpr* node ; 
     36  std::string* str;                /* symbol table index */ 
     37  xios::IScalarExprNode* scalarNode; 
     38  xios::IFilterExprNode* filterNode; 
    3939}; 
    4040 
    4141%token <str> NUMBER 
    42 %token <str>  VAR ID AVERAGE 
     42%token <str> VAR ID AVERAGE 
    4343%token PLUS MINUS TIMES DIVIDE POWER 
    4444%token LEFT_PARENTHESIS RIGHT_PARENTHESIS 
    … …  
    5050%right POWER 
    5151 
    52 %type <node> Line Expression Field_expr 
     52%type <scalarNode> Expression 
     53%type <filterNode> Line Field_expr 
    5354%start Line 
    5455%% 
    … …  
    5657 
    5758Line: 
    58      END                           { } 
    59    | Field_expr END {  parsed=$1 ;} 
    60    ; 
     59     END            { /* Nothing to do */ } 
     60   | Field_expr END { parsed = $1; } 
     61  ; 
    6162 
    6263Expression: 
    63             NUMBER { $$=new CSimpleNodeExpr(CSimpleNodeExpr::scalarDouble,$1); delete $1 } 
    64           | VAR    { $$=new CSimpleNodeExpr(CSimpleNodeExpr::scalarVariable,$1) ; delete $1} 
    65           | Expression PLUS Expression { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opScalarScalar,"add") ; $$->addChild($1) ; $$->addChild($3); } 
    66           | Expression MINUS Expression { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opScalarScalar,"minus") ; $$->addChild($1) ; $$->addChild($3); } 
    67           | Expression TIMES Expression { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opScalarScalar,"mult") ; $$->addChild($1) ; $$->addChild($3); } 
    68           | Expression DIVIDE Expression { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opScalarScalar,"div") ; $$->addChild($1) ; $$->addChild($3); } 
    69           | MINUS Expression %prec NEG { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opScalar,"neg") ;  $$->addChild($2); } 
    70           | Expression POWER Expression { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opScalarScalar,"pow") ; $$->addChild($1) ; $$->addChild($3); } 
    71           | LEFT_PARENTHESIS Expression RIGHT_PARENTHESIS { $$=$2 ; } 
    72           | ID LEFT_PARENTHESIS Expression RIGHT_PARENTHESIS { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opScalar,$1) ; $$->addChild($3) ; delete $1 } 
     64            NUMBER { $$ = new CScalarValExprNode(*$1); delete $1; } 
     65          | VAR    { $$ = new CScalarVarExprNode(*$1); delete $1; } 
     66          | Expression PLUS Expression   { $$ = new CScalarBinaryOpExprNode($1, "add", $3); } 
     67          | Expression MINUS Expression  { $$ = new CScalarBinaryOpExprNode($1, "minus", $3); } 
     68          | Expression TIMES Expression  { $$ = new CScalarBinaryOpExprNode($1, "mult", $3); } 
     69          | Expression DIVIDE Expression { $$ = new CScalarBinaryOpExprNode($1, "div", $3); } 
     70          | MINUS Expression %prec NEG   { $$ = new CScalarUnaryOpExprNode("neg", $2); } 
     71          | Expression POWER Expression  { $$ = new CScalarBinaryOpExprNode($1, "pow", $3); } 
     72          | LEFT_PARENTHESIS Expression RIGHT_PARENTHESIS    { $$ = $2; } 
     73          | ID LEFT_PARENTHESIS Expression RIGHT_PARENTHESIS { $$ = new CScalarUnaryOpExprNode(*$1, $3); delete $1; } 
    7374          ; 
    7475 
    7576Field_expr: 
    76             ID    { $$=new CSimpleNodeExpr(CSimpleNodeExpr::fieldInstant,$1); delete $1} 
    77           | AVERAGE  { $$=new CSimpleNodeExpr(CSimpleNodeExpr::fieldAverage,$1); delete $1} 
    78           | Field_expr PLUS Field_expr { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opFieldField,"add") ; $$->addChild($1) ; $$->addChild($3); } 
    79           | Field_expr MINUS Field_expr { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opFieldField,"minus") ; $$->addChild($1) ; $$->addChild($3); } 
    80           | Field_expr TIMES Field_expr { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opFieldField,"mult") ; $$->addChild($1) ; $$->addChild($3); } 
    81           | Field_expr DIVIDE Field_expr { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opFieldField,"div") ; $$->addChild($1) ; $$->addChild($3); } 
    82           | MINUS Field_expr %prec NEG { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opField,"neg") ; $$->addChild($2);} 
    83           | Field_expr POWER Field_expr { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opFieldField,"pow") ; $$->addChild($1) ; $$->addChild($3); } 
    84           | LEFT_PARENTHESIS Field_expr RIGHT_PARENTHESIS       { $$=$2 ;} 
    85           | Field_expr PLUS Expression { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opFieldScalar,"add") ; $$->addChild($1) ; $$->addChild($3); } 
    86           | Expression PLUS Field_expr { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opScalarField,"add") ; $$->addChild($1) ; $$->addChild($3); } 
    87           | Field_expr MINUS Expression { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opFieldScalar,"minus") ; $$->addChild($1) ; $$->addChild($3); } 
    88           | Expression MINUS Field_expr { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opScalarField,"minus") ; $$->addChild($1) ; $$->addChild($3); } 
    89           | Field_expr TIMES Expression { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opFieldScalar,"mult") ; $$->addChild($1) ; $$->addChild($3); } 
    90           | Expression TIMES Field_expr { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opScalarField,"mult") ; $$->addChild($1) ; $$->addChild($3); } 
    91           | Field_expr DIVIDE Expression { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opFieldScalar,"div") ; $$->addChild($1) ; $$->addChild($3); } 
    92           | Expression DIVIDE Field_expr { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opScalarField,"div") ; $$->addChild($1) ; $$->addChild($3); } 
    93           | Field_expr POWER Expression { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opFieldScalar,"pow") ; $$->addChild($1) ; $$->addChild($3); } 
    94           | ID LEFT_PARENTHESIS Field_expr RIGHT_PARENTHESIS { $$=new CSimpleNodeExpr(CSimpleNodeExpr::opField,$1) ;  $$->addChild($3) ; delete $1} 
     77            ID      { $$ = new CFilterFieldExprNode(*$1); delete $1; } 
     78          | AVERAGE { /* TODO: Use temporal operation */ $$ = new CFilterFieldExprNode(*$1); delete $1; } 
     79          | Field_expr PLUS Field_expr   { $$ = new CFilterFieldFieldOpExprNode($1, "add", $3); } 
     80          | Field_expr MINUS Field_expr  { $$ = new CFilterFieldFieldOpExprNode($1, "minus", $3); } 
     81          | Field_expr TIMES Field_expr  { $$ = new CFilterFieldFieldOpExprNode($1, "mult", $3); } 
     82          | Field_expr DIVIDE Field_expr { $$ = new CFilterFieldFieldOpExprNode($1, "div", $3); } 
     83          | MINUS Field_expr %prec NEG   { $$ = new CFilterUnaryOpExprNode("neg", $2); } 
     84          | Field_expr POWER Field_expr  { $$ = new CFilterFieldFieldOpExprNode($1, "pow", $3); } 
     85          | LEFT_PARENTHESIS Field_expr RIGHT_PARENTHESIS       { $$ = $2; } 
     86          | Field_expr PLUS Expression   { $$ = new CFilterFieldScalarOpExprNode($1, "add", $3); } 
     87          | Expression PLUS Field_expr   { $$ = new CFilterScalarFieldOpExprNode($1, "add", $3); } 
     88          | Field_expr MINUS Expression  { $$ = new CFilterFieldScalarOpExprNode($1, "minus", $3); } 
     89          | Expression MINUS Field_expr  { $$ = new CFilterScalarFieldOpExprNode($1, "minus", $3); } 
     90          | Field_expr TIMES Expression  { $$ = new CFilterFieldScalarOpExprNode($1, "mult", $3); } 
     91          | Expression TIMES Field_expr  { $$ = new CFilterScalarFieldOpExprNode($1, "mult", $3); } 
     92          | Field_expr DIVIDE Expression { $$ = new CFilterFieldScalarOpExprNode($1, "div", $3); } 
     93          | Expression DIVIDE Field_expr { $$ = new CFilterScalarFieldOpExprNode($1, "div", $3); } 
     94          | Field_expr POWER Expression  { $$ = new CFilterFieldScalarOpExprNode($1, "pow", $3); } 
     95          | ID LEFT_PARENTHESIS Field_expr RIGHT_PARENTHESIS { $$ = new CFilterUnaryOpExprNode(*$1, $3); delete $1; } 
    9596          ; 
    9697%% 
    … …  
    9899extern "C" 
    99100{ 
    100   int yyerror(const char *s)  
     101  int yyerror(const char *s) 
    101102  { 
    102     ERROR("int yyerror(const char *s)", <<"Parsing error :"<<s<<endl) ;  
     103    ERROR("int yyerror(const char *s)", << "Parsing error: " << s << endl); 
    103104  } 
    104105} 
    … …  
    106107namespace xios 
    107108{ 
    108   CSimpleNodeExpr* parseExpr(const string& strExpr) 
     109  IFilterExprNode* parseExpr(const string& strExpr) 
    109110  { 
    110     globalInputText=strExpr ; 
    111     globalReadOffset=0 ; 
     111    globalInputText = strExpr; 
     112    globalReadOffset = 0; 
    112113    yyparse(); 
    113     return  parsed ; 
     114    return parsed; 
    114115  } 
    115116} 
Note: See TracChangeset for help on using the changeset viewer.