libcli/wsp/wsp_aqs_parser.y

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *
   4  *  Window Search Service
   5  *
   6  *  Copyright (c) Noel Power
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 3 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 %{
  23
  24 #include "includes.h"
  25 #include "libcli/wsp/wsp_aqs.h"
  26 #include "libcli/wsp/wsp_aqs_parser.tab.h"
  27 #include "libcli/wsp/wsp_aqs_lexer.h"
  28
  29 static int yyerror(t_select_stmt **stmt, yyscan_t scanner, const char *msg)
  30 {
  31         fprintf(stderr,"Error :%s\n",msg); return 0;
  32 }
  33 %}
  34 %code requires {
  35
  36 #ifndef YY_TYPEDEF_YY_SCANNER_T
  37 #define YY_TYPEDEF_YY_SCANNER_T
  38 typedef void* yyscan_t;
  39 #endif
  40
  41 }
  42
  43 %define api.pure
  44 %lex-param   { yyscan_t scanner }
  45 %parse-param { t_select_stmt **select }
  46 %parse-param { yyscan_t scanner }
  47
  48 %union {
  49         char *strval;
  50         int64_t num;
  51         t_value_holder *value;
  52         t_select_stmt *select_stmt;
  53         t_select_stmt *query_stmt;
  54         t_basic_restr *bas_rest;
  55         t_basic_query *bas_query;
  56         t_restr *restr;
  57         t_query       *query;
  58         t_col_list *columns;
  59         daterange_type daterange;
  60         sizerange_type sizerange;
  61         t_optype prop_op;
  62 }
  63
  64 %left "AND" TOKEN_AND
  65 %left "OR" TOKEN_OR
  66 %left "!=" TOKEN_NE
  67 %left ">=" TOKEN_GE
  68 %left "<=" TOKEN_LE
  69 %left "<" TOKEN_LT
  70 %left ">" TOKEN_GT
  71 %right "NOT" TOKEN_NOT
  72 %right "==" TOKEN_EQ
  73 %right ":" TOKEN_PROP_EQUALS
  74
  75 %right "$<" TOKEN_STARTS_WITH
  76 %right "$=" TOKEN_EQUALS
  77
  78 %token TOKEN_LPAREN
  79 %token TOKEN_RPAREN
  80 %token TOKEN_AND
  81 %token TOKEN_OR
  82 %token TOKEN_WHERE
  83 %token TOKEN_SELECT
  84 %token TOKEN_TRUE
  85 %token TOKEN_FALSE
  86 %token TOKEN_COMMA
  87 %token TOKEN_STARTS_WITH
  88 %token TOKEN_EQUALS
  89 %token TOKEN_MATCHES
  90 %token TOKEN_K
  91 %token TOKEN_M
  92 %token TOKEN_G
  93 %token TOKEN_T
  94 %token TOKEN_KB
  95 %token TOKEN_MB
  96 %token TOKEN_GB
  97 %token TOKEN_TB
  98 %token TOKEN_RANGE
  99 %token TOKEN_TODAY
 100 %token TOKEN_YESTERDAY
 101 %token TOKEN_THISWEEK
 102 %token TOKEN_LASTWEEK
 103 %token TOKEN_THISMONTH
 104 %token TOKEN_LASTMONTH
 105 %token TOKEN_THISYEAR
 106 %token TOKEN_LASTYEAR
 107 %token TOKEN_EMPTY
 108 %token TOKEN_TINY
 109 %token TOKEN_SMALL
 110 %token TOKEN_MEDIUM
 111 %token TOKEN_LARGE
 112 %token TOKEN_HUGE
 113 %token TOKEN_GIGANTIC
 114
 115 %token <num> TOKEN_NUMBER
 116 %token <strval> TOKEN_IDENTIFIER
 117 %token <strval> TOKEN_STRING_LITERAL
 118
 119 %type <strval> prop
 120 %type <bas_rest> basic_restr
 121 %type <restr> restr
 122 %type <bas_query> basic_query
 123 %type <query> query
 124 %type <columns> cols
 125 %type <strval> col
 126 %type <select_stmt> select_stmt
 127 %type <value> simple_value
 128 %type <value> value
 129 %type <daterange> date_shortcut
 130 %type <prop_op> property_op
 131 %type <prop_op> content_op
 132 %type <sizerange> size_shortcut
 133
 134 %%
 135
 136 input:
 137         select_stmt {
 138                 *select = $1;
 139         }
 140 ;
 141
 142 select_stmt:
 143         TOKEN_SELECT cols[C] TOKEN_WHERE query[Q] {
 144                 $$ = create_select(talloc_tos(), $C, $Q );
 145                 if (!$$) {
 146                          YYERROR;
 147                 }
 148         }
 149         | query[Q] {
 150                 $$ = create_select(talloc_tos(), NULL, $Q );
 151                 if (!$$) {
 152                          YYERROR;
 153                 }
 154         }
 155         ;
 156
 157 cols :
 158         col[C] {
 159                 $$ = create_cols(talloc_tos(), $1, NULL);
 160                 if (!$$) {
 161                          YYERROR;
 162                 }
 163         }
 164         | col[C] TOKEN_COMMA cols[CS]  {
 165                 $$ = create_cols(talloc_tos(), $C, $CS);
 166                 if (!$$) {
 167                          YYERROR;
 168                 }
 169         }
 170         ;
 171
 172 col:
 173         TOKEN_IDENTIFIER[I] {
 174                 $$ = $I;
 175                 if (!$$) {
 176                          YYERROR;
 177                 }
 178         }
 179         ;
 180
 181 query:
 182         basic_query {
 183                 $$ = create_query_node(talloc_tos(), eVALUE, NULL, NULL, $1);
 184                 if (!$$) {
 185                          YYERROR;
 186                 }
 187         }
 188         | TOKEN_LPAREN query[Q] TOKEN_RPAREN {
 189                 $$ = $Q;
 190                 if (!$$) {
 191                          YYERROR;
 192                 }
 193         }
 194         | query[L] TOKEN_AND query[R] {
 195                 $$ = create_query_node(talloc_tos(), eAND, $L, $R, NULL);
 196                 if (!$$) {
 197                          YYERROR;
 198                 }
 199         }
 200         | query[L] TOKEN_OR query[R] {
 201                 $$ = create_query_node(talloc_tos(), eOR, $L, $R, NULL);
 202                 if (!$$) {
 203                          YYERROR;
 204                 }
 205         }
 206         | TOKEN_NOT query[R] {
 207                 $$ = create_query_node(talloc_tos(), eNOT, NULL, $R, NULL);
 208                 if (!$$) {
 209                          YYERROR;
 210                 }
 211         }
 212         ;
 213
 214 basic_query:
 215         prop[P] TOKEN_PROP_EQUALS basic_restr[V] {
 216                 $$ = create_basic_query(talloc_tos(), $P, $V);
 217                 if (!$$) {
 218                          YYERROR;
 219                 }
 220         }
 221         ;
 222
 223 prop: TOKEN_IDENTIFIER[I] {
 224                 $$ = $I;
 225                 if (!$$) {
 226                          YYERROR;
 227                 }
 228         }
 229         ;
 230
 231 basic_restr:
 232         value[V] {
 233                 $$ = create_basic_restr(talloc_tos(), RTPROPERTY, eEQ, $V);
 234                 if (!$$) {
 235                          YYERROR;
 236                 }
 237         }
 238         | property_op[P] value[T] {
 239                 $$ = create_basic_restr(talloc_tos(), RTPROPERTY, $P, $T);
 240                 if (!$$) {
 241                          YYERROR;
 242                 }
 243         }
 244         | content_op[P] value[T] {
 245                 $$ = create_basic_restr(talloc_tos(), RTCONTENT, $P, $T);
 246                 if (!$$) {
 247                          YYERROR;
 248                 }
 249         }
 250         | TOKEN_LPAREN restr[R] TOKEN_RPAREN {
 251                 t_value_holder *holder = talloc_zero(talloc_tos(), t_value_holder);
 252                 holder->type = RESTR;
 253                 holder->value.restr_tree = $R;
 254                 $$ = create_basic_restr(talloc_tos(), RTNONE, eEQ, holder);
 255                 if (!$$) {
 256                          YYERROR;
 257                 }
 258         }
 259         ;
 260
 261 property_op:
 262         TOKEN_EQ { $$ = eEQ; }
 263         | TOKEN_NE { $$ = eNE; }
 264         | TOKEN_GE { $$ = eGE; }
 265         | TOKEN_LE { $$ = eLE; }
 266         | TOKEN_LT { $$ = eLT; }
 267         | TOKEN_GT { $$ = eGT; }
 268         ;
 269
 270 content_op:
 271         TOKEN_STARTS_WITH { $$ = eSTARTSWITH; }
 272         | TOKEN_EQUALS { $$ = eEQUALS; }
 273         ;
 274
 275 value:
 276         simple_value[V] { $$ = $V;}
 277         | simple_value[L] TOKEN_RANGE simple_value[R] {
 278                 $$ = create_value_range(talloc_tos(), $L, $R);
 279                 if (!$$) {
 280                          YYERROR;
 281                 }
 282         }
 283         | date_shortcut[D] {
 284                 $$ = create_date_range_shortcut(talloc_tos(), $D);
 285                 if (!$$) {
 286                          YYERROR;
 287                 }
 288         }
 289         | size_shortcut[S] {
 290                 $$ = create_size_range_shortcut(talloc_tos(), $S);
 291                 if (!$$) {
 292                          YYERROR;
 293                 }
 294         }
 295         ;
 296
 297 date_shortcut:
 298         TOKEN_TODAY { $$ = eTODAY; }
 299         | TOKEN_YESTERDAY { $$ = eYESTERDAY; }
 300         | TOKEN_THISWEEK { $$ = eTHISWEEK; }
 301         | TOKEN_LASTWEEK { $$ = eLASTWEEK; }
 302         | TOKEN_THISMONTH { $$ = eTHISMONTH; }
 303         | TOKEN_LASTMONTH { $$ = eTHISMONTH; }
 304         | TOKEN_THISYEAR { $$ = eTHISYEAR; }
 305         | TOKEN_LASTYEAR { $$ = eLASTYEAR; }
 306         ;
 307
 308 size_shortcut:
 309         TOKEN_EMPTY { $$ = eEMPTY; }
 310         | TOKEN_TINY { $$ = eTINY; }
 311         | TOKEN_SMALL { $$ = eSMALL; }
 312         | TOKEN_MEDIUM { $$ = eMEDIUM; }
 313         | TOKEN_LARGE { $$ = eLARGE; }
 314         | TOKEN_HUGE { $$ = eHUGE; }
 315         | TOKEN_GIGANTIC { $$ = eGIGANTIC; }
 316         ;
 317
 318 simple_value:
 319         TOKEN_NUMBER[N] {
 320                 $$ = create_num_val(talloc_tos(), $N);
 321                 if (!$$) {
 322                          YYERROR;
 323                 }
 324         }
 325         | TOKEN_NUMBER[N] TOKEN_K {
 326                 $$ = create_num_val(talloc_tos(), $N * 1024);
 327                 if (!$$) {
 328                          YYERROR;
 329                 }
 330         }
 331         | TOKEN_NUMBER[N] TOKEN_M {
 332                 $$ = create_num_val( talloc_tos(), $N * 1024 * 1024);
 333                 if (!$$) {
 334                          YYERROR;
 335                 }
 336         }
 337         | TOKEN_NUMBER[N] TOKEN_G {
 338                 $$ = create_num_val(talloc_tos(), $N * 1024 * 1024 * 1024);
 339                 if (!$$) {
 340                          YYERROR;
 341                 }
 342         }
 343         | TOKEN_NUMBER[N] TOKEN_T {
 344                 $$ = create_num_val(talloc_tos(),
 345                                     $N * 1024 * 1024 * 1024 * 1024);
 346                 if (!$$) {
 347                          YYERROR;
 348                 }
 349         }
 350         | TOKEN_NUMBER[N] TOKEN_KB {
 351                 $$ = create_num_val(talloc_tos(), $N * 1000);
 352                 if (!$$) {
 353                          YYERROR;
 354                 }
 355         }
 356         | TOKEN_NUMBER[N] TOKEN_MB {
 357                 $$ = create_num_val( talloc_tos(), $N * 1000 * 1000);
 358                 if (!$$) {
 359                          YYERROR;
 360                 }
 361         }
 362         | TOKEN_NUMBER[N] TOKEN_GB {
 363                 $$ = create_num_val(talloc_tos(), $N * 1000 * 1000 * 1000);
 364                 if (!$$) {
 365                          YYERROR;
 366                 }
 367         }
 368         | TOKEN_NUMBER[N] TOKEN_TB {
 369                 $$ = create_num_val(talloc_tos(),
 370                                     $N * 1000 * 1000 * 1000 * 1000);
 371                 if (!$$) {
 372                          YYERROR;
 373                 }
 374         }
 375         | TOKEN_TRUE {
 376                 $$ = create_bool_val(talloc_tos(), true);
 377                 if (!$$) {
 378                          YYERROR;
 379                 }
 380         }
 381         | TOKEN_FALSE {
 382                 $$ = create_num_val(talloc_tos(), false);
 383                 if (!$$) {
 384                          YYERROR;
 385                 }
 386         }
 387         | TOKEN_STRING_LITERAL[S] {
 388                 char *tmp_str = talloc_strdup(talloc_tos(), $S+1);
 389                 tmp_str[strlen(tmp_str)-1] = '\0';
 390                 $$ = create_string_val(talloc_tos(), tmp_str);
 391                 if (!$$) {
 392                          YYERROR;
 393                 }
 394         }
 395         | TOKEN_IDENTIFIER[I] {
 396                 $$ = create_string_val(talloc_tos(), $I);
 397                 if (!$$) {
 398                          YYERROR;
 399                 }
 400         }
 401         ;
 402
 403 restr: basic_restr[V] {
 404                 $$ = create_restr(talloc_tos(), eVALUE, NULL, NULL, $V);
 405                 if (!$$) {
 406                          YYERROR;
 407                 }
 408         }
 409         | restr[L] TOKEN_AND restr[R] {
 410                 $$ = create_restr(talloc_tos(), eAND, $L, $R, NULL);
 411                 if (!$$) {
 412                          YYERROR;
 413                 }
 414         }
 415         | restr[L] TOKEN_OR restr[R] {
 416                 $$ = create_restr(talloc_tos(), eOR, $L, $R, NULL);
 417                 if (!$$) {
 418                          YYERROR;
 419                 }
 420         }
 421         ;
 422 %%