src/Parser.y

   1 %{
   2 #include "SearchExpr.h"
   3 #include "Scanner.h.in"
   4 #include "Scanner.h"
   5 #include "OtherFunctions.h"
   6
   7 #include "libs/common/StringFunctions.h"
   8
   9 #ifdef _DEBUG
  10 #undef THIS_FILE
  11 static char THIS_FILE[] = __FILE__;
  12 #endif
  13
  14 extern wxArrayString _astrParserErrors;
  15
  16 void ParsedSearchExpression(const CSearchExpr* pexpr);
  17 int yyerror(const char* errstr);
  18 int yyerror(wxString errstr);
  19
  20 %}
  21
  22 %union {
  23         wxString*               pstr;
  24         CSearchExpr*    pexpr;
  25 }
  26
  27 %token TOK_STRING
  28 %token TOK_AND TOK_OR TOK_NOT
  29 %token TOK_ED2K_LINK
  30
  31 %type <pexpr> searchexpr and_strings
  32 %type <pstr> TOK_STRING TOK_ED2K_LINK
  33
  34 %left TOK_OR
  35 %left TOK_AND
  36 %left TOK_NOT
  37
  38 %%
  39 /*-------------------------------------------------------------------*/
  40
  41 action                  : searchexpr
  42                                         {
  43                                                 ParsedSearchExpression($1);
  44                                                 delete $1;
  45                                                 return 0;
  46                                         }
  47                                 | TOK_ED2K_LINK
  48                                         {
  49                                                 CSearchExpr* pexpr = new CSearchExpr(*$1);
  50                                                 ParsedSearchExpression(pexpr);
  51                                                 delete pexpr;
  52                                                 delete $1;
  53                                                 return 0;
  54                                         }
  55                                 /* --------- Error Handling --------- */
  56                                 | searchexpr error
  57                                         {
  58                                                 yyerror(wxT("Undefined search expression error"));
  59                                                 delete $1;
  60                                                 return 1;
  61                                         }
  62                                 ;
  63
  64
  65 searchexpr              : and_strings
  66                                 | searchexpr TOK_AND searchexpr
  67                                         {
  68                                                 CSearchExpr* pexpr = new CSearchExpr;
  69                                                 pexpr->Add(SEARCHOP_AND);
  70                                                 pexpr->Add($1);
  71                                                 pexpr->Add($3);
  72                                                 $$ = pexpr;
  73                                                 delete $1;
  74                                                 delete $3;
  75                                         }
  76                                 | searchexpr TOK_OR searchexpr
  77                                         {
  78                                                 CSearchExpr* pexpr = new CSearchExpr;
  79                                                 pexpr->Add(SEARCHOP_OR);
  80                                                 pexpr->Add($1);
  81                                                 pexpr->Add($3);
  82                                                 $$ = pexpr;
  83                                                 delete $1;
  84                                                 delete $3;
  85                                         }
  86                                 | searchexpr TOK_NOT searchexpr
  87                                         {
  88                                                 CSearchExpr* pexpr = new CSearchExpr;
  89                                                 pexpr->Add(SEARCHOP_NOT);
  90                                                 pexpr->Add($1);
  91                                                 pexpr->Add($3);
  92                                                 $$ = pexpr;
  93                                                 delete $1;
  94                                                 delete $3;
  95                                         }
  96                                 | '(' searchexpr ')'
  97                                         {
  98                                                 $$ = $2;
  99                                         }
 100                                 /* --------- Error Handling --------- */
 101                                 | searchexpr TOK_OR error
 102                                         {
 103                                                 yyerror(wxT("Missing right operand for OR on search expression"));
 104                                                 delete $1;
 105                                                 return 1;
 106                                         }
 107                                 | searchexpr TOK_NOT error
 108                                         {
 109                                                 yyerror(wxT("Missing operand for NOT on search expression"));
 110                                                 delete $1;
 111                                                 return 1;
 112                                         }
 113                                 | '(' error
 114                                         {
 115                                                 yyerror(wxT("Missing left parenthesis on search expression"));
 116                                                 return 1;
 117                                         }
 118                                 | '(' searchexpr error
 119                                         {
 120                                                 yyerror(wxT("Missing closing parenthesis on search expression"));
 121                                                 delete $2;
 122                                                 return 1;
 123                                         }
 124                                 | TOK_AND error
 125                                         {
 126                                                 yyerror(wxT("Missing left operand for AND on search expression"));
 127                                                 return 1;
 128                                         }
 129                                 | TOK_OR error
 130                                         {
 131                                                 yyerror(wxT("Missing left operand for OR on search expression"));
 132                                                 return 1;
 133                                         }
 134                                 | TOK_NOT error
 135                                         {
 136                                                 yyerror(wxT("Missing left operand for NOT on search expression (?)"));
 137                                                 return 1;
 138                                         }
 139                                 ;
 140
 141 and_strings             : TOK_STRING
 142                                         {
 143                                                 $$ = new CSearchExpr(*$1);
 144                                                 delete $1;
 145                                         }
 146                                 | and_strings TOK_STRING
 147                                         {
 148                                                 /*$1->Concatenate($2);
 149                                                 delete $2;*/
 150                                                 CSearchExpr* pexpr = new CSearchExpr;
 151                                                 pexpr->Add(SEARCHOP_AND);
 152                                                 pexpr->Add($1);
 153                                                 pexpr->Add(*$2);
 154                                                 $$ = pexpr;
 155                                                 delete $1;
 156                                                 delete $2;
 157                                         }
 158                                 ;
 159
 160 %%
 161
 162 int yyerror(const char* errstr)
 163 {
 164         // Errors created by yacc generated code
 165         //yyerror ("syntax error: cannot back up");
 166         //yyerror ("syntax error; also virtual memory exhausted");
 167         //yyerror ("syntax error");
 168         //yyerror ("parser stack overflow");
 169
 170         _astrParserErrors.Add(char2unicode(errstr));
 171         return EXIT_FAILURE;
 172 }
 173
 174 int yyerror(wxString errstr)
 175 {
 176         _astrParserErrors.Add(errstr);
 177         return EXIT_FAILURE;
 178 }