reactos/dll/win32/wbemprox/wql.y

   1 %{
   2
   3 /*
   4  * Copyright 2012 Hans Leidekker for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include <stdarg.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "wbemcli.h"
  27 #include "wbemprox_private.h"
  28
  29 #include "wine/list.h"
  30 #include "wine/debug.h"
  31 #include "wine/unicode.h"
  32
  33 #define YYLEX_PARAM ctx
  34 #define YYPARSE_PARAM ctx
  35 #define YYERROR_DEBUG 1
  36 #define YYERROR_VERBOSE 1
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(wbemprox);
  39
  40 struct parser
  41 {
  42     const WCHAR *cmd;
  43     UINT idx;
  44     UINT len;
  45     HRESULT error;
  46     struct view **view;
  47     struct list *mem;
  48 };
  49
  50 struct string
  51 {
  52     const WCHAR *data;
  53     int len;
  54 };
  55
  56 static void *alloc_mem( struct parser *parser, UINT size )
  57 {
  58     struct list *mem = heap_alloc( sizeof(struct list) + size );
  59     list_add_tail( parser->mem, mem );
  60     return &mem[1];
  61 }
  62
  63 static struct property *alloc_property( struct parser *parser, const WCHAR *class, const WCHAR *name )
  64 {
  65     struct property *prop = alloc_mem( parser, sizeof(*prop) );
  66     if (prop)
  67     {
  68         prop->name  = name;
  69         prop->class = class;
  70         prop->next  = NULL;
  71     }
  72     return prop;
  73 }
  74
  75 static WCHAR *get_string( struct parser *parser, const struct string *str )
  76 {
  77     const WCHAR *p = str->data;
  78     int len = str->len;
  79     WCHAR *ret;
  80
  81     if ((p[0] == '\"' && p[len - 1] != '\"') ||
  82         (p[0] == '\'' && p[len - 1] != '\'')) return NULL;
  83     if ((p[0] == '\"' && p[len - 1] == '\"') ||
  84         (p[0] == '\'' && p[len - 1] == '\''))
  85     {
  86         p++;
  87         len -= 2;
  88     }
  89     if (!(ret = alloc_mem( parser, (len + 1) * sizeof(WCHAR) ))) return NULL;
  90     memcpy( ret, p, len * sizeof(WCHAR) );
  91     ret[len] = 0;
  92     return ret;
  93 }
  94
  95 static int get_int( struct parser *parser )
  96 {
  97     const WCHAR *p = &parser->cmd[parser->idx];
  98     int i, ret = 0;
  99
 100     for (i = 0; i < parser->len; i++)
 101     {
 102         if (p[i] < '0' || p[i] > '9')
 103         {
 104             ERR("should only be numbers here!\n");
 105             break;
 106         }
 107         ret = (p[i] - '0') + ret * 10;
 108     }
 109     return ret;
 110 }
 111
 112 static struct expr *expr_complex( struct parser *parser, struct expr *l, UINT op, struct expr *r )
 113 {
 114     struct expr *e = alloc_mem( parser, sizeof(*e) );
 115     if (e)
 116     {
 117         e->type = EXPR_COMPLEX;
 118         e->u.expr.left = l;
 119         e->u.expr.op = op;
 120         e->u.expr.right = r;
 121     }
 122     return e;
 123 }
 124
 125 static struct expr *expr_unary( struct parser *parser, struct expr *l, UINT op )
 126 {
 127     struct expr *e = alloc_mem( parser, sizeof(*e) );
 128     if (e)
 129     {
 130         e->type = EXPR_UNARY;
 131         e->u.expr.left = l;
 132         e->u.expr.op = op;
 133         e->u.expr.right = NULL;
 134     }
 135     return e;
 136 }
 137
 138 static struct expr *expr_ival( struct parser *parser, int val )
 139 {
 140     struct expr *e = alloc_mem( parser, sizeof *e );
 141     if (e)
 142     {
 143         e->type = EXPR_IVAL;
 144         e->u.ival = val;
 145     }
 146     return e;
 147 }
 148
 149 static struct expr *expr_sval( struct parser *parser, const struct string *str )
 150 {
 151     struct expr *e = alloc_mem( parser, sizeof *e );
 152     if (e)
 153     {
 154         e->type = EXPR_SVAL;
 155         e->u.sval = get_string( parser, str );
 156         if (!e->u.sval)
 157             return NULL; /* e will be freed by query destructor */
 158     }
 159     return e;
 160 }
 161
 162 static struct expr *expr_bval( struct parser *parser, int val )
 163 {
 164     struct expr *e = alloc_mem( parser, sizeof *e );
 165     if (e)
 166     {
 167         e->type = EXPR_BVAL;
 168         e->u.ival = val;
 169     }
 170     return e;
 171 }
 172
 173 static struct expr *expr_propval( struct parser *parser, const struct property *prop )
 174 {
 175     struct expr *e = alloc_mem( parser, sizeof *e );
 176     if (e)
 177     {
 178         e->type = EXPR_PROPVAL;
 179         e->u.propval = prop;
 180     }
 181     return e;
 182 }
 183
 184 static int wql_error( const char *str );
 185 static int wql_lex( void *val, struct parser *parser );
 186
 187 #define PARSER_BUBBLE_UP_VIEW( parser, result, current_view ) \
 188     *parser->view = current_view; \
 189     result = current_view
 190
 191 %}
 192
 193 %pure-parser
 194
 195 %union
 196 {
 197     struct string str;
 198     WCHAR *string;
 199     struct property *proplist;
 200     struct view *view;
 201     struct expr *expr;
 202     int integer;
 203 }
 204
 205 %token TK_SELECT TK_FROM TK_STAR TK_COMMA TK_DOT TK_IS TK_LP TK_RP TK_NULL TK_FALSE TK_TRUE
 206 %token TK_INTEGER TK_WHERE TK_SPACE TK_MINUS TK_ILLEGAL TK_BY
 207 %token <str> TK_STRING TK_ID
 208
 209 %type <string> id
 210 %type <proplist> prop proplist
 211 %type <view> select
 212 %type <expr> expr prop_val const_val string_val
 213 %type <integer> number
 214
 215 %left TK_OR
 216 %left TK_AND
 217 %left TK_NOT
 218 %left TK_EQ TK_NE TK_LT TK_GT TK_LE TK_GE TK_LIKE
 219
 220 %%
 221
 222 select:
 223     TK_SELECT TK_FROM id
 224         {
 225             HRESULT hr;
 226             struct parser *parser = ctx;
 227             struct view *view;
 228
 229             hr = create_view( NULL, $3, NULL, &view );
 230             if (hr != S_OK)
 231                 YYABORT;
 232
 233             PARSER_BUBBLE_UP_VIEW( parser, $$, view );
 234         }
 235   | TK_SELECT proplist TK_FROM id
 236         {
 237             HRESULT hr;
 238             struct parser *parser = ctx;
 239             struct view *view;
 240
 241             hr = create_view( $2, $4, NULL, &view );
 242             if (hr != S_OK)
 243                 YYABORT;
 244
 245             PARSER_BUBBLE_UP_VIEW( parser, $$, view );
 246         }
 247   | TK_SELECT proplist TK_FROM id TK_WHERE expr
 248         {
 249             HRESULT hr;
 250             struct parser *parser = ctx;
 251             struct view *view;
 252
 253             hr = create_view( $2, $4, $6, &view );
 254             if (hr != S_OK)
 255                 YYABORT;
 256
 257             PARSER_BUBBLE_UP_VIEW( parser, $$, view );
 258         }
 259     ;
 260
 261 proplist:
 262     prop
 263   | prop TK_COMMA proplist
 264         {
 265             $1->next = $3;
 266         }
 267   | TK_STAR
 268         {
 269             $$ = NULL;
 270         }
 271     ;
 272
 273 prop:
 274     id TK_DOT id
 275         {
 276             $$ = alloc_property( ctx, $1, $3 );
 277             if (!$$)
 278                 YYABORT;
 279         }
 280   | id
 281         {
 282             $$ = alloc_property( ctx, NULL, $1 );
 283             if (!$$)
 284                 YYABORT;
 285         }
 286     ;
 287
 288 id:
 289     TK_ID
 290         {
 291             $$ = get_string( ctx, &$1 );
 292             if (!$$)
 293                 YYABORT;
 294         }
 295     ;
 296
 297 number:
 298     TK_INTEGER
 299         {
 300             $$ = get_int( ctx );
 301         }
 302     ;
 303
 304 expr:
 305     TK_LP expr TK_RP
 306         {
 307             $$ = $2;
 308             if (!$$)
 309                 YYABORT;
 310         }
 311   | expr TK_AND expr
 312         {
 313             $$ = expr_complex( ctx, $1, OP_AND, $3 );
 314             if (!$$)
 315                 YYABORT;
 316         }
 317   | expr TK_OR expr
 318         {
 319             $$ = expr_complex( ctx, $1, OP_OR, $3 );
 320             if (!$$)
 321                 YYABORT;
 322         }
 323   | prop_val TK_EQ const_val
 324         {
 325             $$ = expr_complex( ctx, $1, OP_EQ, $3 );
 326             if (!$$)
 327                 YYABORT;
 328         }
 329   | prop_val TK_GT const_val
 330         {
 331             $$ = expr_complex( ctx, $1, OP_GT, $3 );
 332             if (!$$)
 333                 YYABORT;
 334         }
 335   | prop_val TK_LT const_val
 336         {
 337             $$ = expr_complex( ctx, $1, OP_LT, $3 );
 338             if (!$$)
 339                 YYABORT;
 340         }
 341   | prop_val TK_LE const_val
 342         {
 343             $$ = expr_complex( ctx, $1, OP_LE, $3 );
 344             if (!$$)
 345                 YYABORT;
 346         }
 347   | prop_val TK_GE const_val
 348         {
 349             $$ = expr_complex( ctx, $1, OP_GE, $3 );
 350             if (!$$)
 351                 YYABORT;
 352         }
 353   | prop_val TK_NE const_val
 354         {
 355             $$ = expr_complex( ctx, $1, OP_NE, $3 );
 356             if (!$$)
 357                 YYABORT;
 358         }
 359   | const_val TK_EQ prop_val
 360         {
 361             $$ = expr_complex( ctx, $1, OP_EQ, $3 );
 362             if (!$$)
 363                 YYABORT;
 364         }
 365   | const_val TK_GT prop_val
 366         {
 367             $$ = expr_complex( ctx, $1, OP_GT, $3 );
 368             if (!$$)
 369                 YYABORT;
 370         }
 371   | const_val TK_LT prop_val
 372         {
 373             $$ = expr_complex( ctx, $1, OP_LT, $3 );
 374             if (!$$)
 375                 YYABORT;
 376         }
 377   | const_val TK_LE prop_val
 378         {
 379             $$ = expr_complex( ctx, $1, OP_LE, $3 );
 380             if (!$$)
 381                 YYABORT;
 382         }
 383   | const_val TK_GE prop_val
 384         {
 385             $$ = expr_complex( ctx, $1, OP_GE, $3 );
 386             if (!$$)
 387                 YYABORT;
 388         }
 389   | const_val TK_NE prop_val
 390         {
 391             $$ = expr_complex( ctx, $1, OP_NE, $3 );
 392             if (!$$)
 393                 YYABORT;
 394         }
 395   | prop_val TK_LIKE string_val
 396         {
 397             $$ = expr_complex( ctx, $1, OP_LIKE, $3 );
 398             if (!$$)
 399                 YYABORT;
 400         }
 401   | prop_val TK_IS TK_NULL
 402         {
 403             $$ = expr_unary( ctx, $1, OP_ISNULL );
 404             if (!$$)
 405                 YYABORT;
 406         }
 407   | prop_val TK_IS TK_NOT TK_NULL
 408         {
 409             $$ = expr_unary( ctx, $1, OP_NOTNULL );
 410             if (!$$)
 411                 YYABORT;
 412         }
 413     ;
 414
 415 string_val:
 416     TK_STRING
 417         {
 418             $$ = expr_sval( ctx, &$1 );
 419             if (!$$)
 420                 YYABORT;
 421         }
 422     ;
 423
 424 prop_val:
 425     prop
 426         {
 427             $$ = expr_propval( ctx, $1 );
 428             if (!$$)
 429                 YYABORT;
 430         }
 431     ;
 432
 433 const_val:
 434     number
 435         {
 436             $$ = expr_ival( ctx, $1 );
 437             if (!$$)
 438                 YYABORT;
 439         }
 440   | TK_STRING
 441         {
 442             $$ = expr_sval( ctx, &$1 );
 443             if (!$$)
 444                 YYABORT;
 445         }
 446   | TK_TRUE
 447         {
 448             $$ = expr_bval( ctx, -1 );
 449             if (!$$)
 450                 YYABORT;
 451         }
 452   | TK_FALSE
 453         {
 454             $$ = expr_bval( ctx, 0 );
 455             if (!$$)
 456                 YYABORT;
 457         }
 458     ;
 459
 460 %%
 461
 462 HRESULT parse_query( const WCHAR *str, struct view **view, struct list *mem )
 463 {
 464     struct parser parser;
 465     int ret;
 466
 467     *view = NULL;
 468
 469     parser.cmd   = str;
 470     parser.idx   = 0;
 471     parser.len   = 0;
 472     parser.error = WBEM_E_INVALID_QUERY;
 473     parser.view  = view;
 474     parser.mem   = mem;
 475
 476     ret = wql_parse( &parser );
 477     TRACE("wql_parse returned %d\n", ret);
 478     if (ret)
 479     {
 480         if (*parser.view)
 481         {
 482             destroy_view( *parser.view );
 483             *parser.view = NULL;
 484         }
 485         return parser.error;
 486     }
 487     return S_OK;
 488 }
 489
 490 static const char id_char[] =
 491 {
 492     0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 493     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 494     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
 495     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
 496     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 497     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
 498     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 499     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
 500     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 501     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 502     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 503     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 504     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 505     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 506     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 507     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 508 };
 509
 510 struct keyword
 511 {
 512     const WCHAR *name;
 513     unsigned int len;
 514     int type;
 515 };
 516
 517 #define MAX_TOKEN_LEN 6
 518
 519 static const WCHAR andW[] = {'A','N','D'};
 520 static const WCHAR byW[] = {'B','Y'};
 521 static const WCHAR falseW[] = {'F','A','L','S','E'};
 522 static const WCHAR fromW[] = {'F','R','O','M'};
 523 static const WCHAR isW[] = {'I','S'};
 524 static const WCHAR likeW[] = {'L','I','K','E'};
 525 static const WCHAR notW[] = {'N','O','T'};
 526 static const WCHAR nullW[] = {'N','U','L','L'};
 527 static const WCHAR orW[] = {'O','R'};
 528 static const WCHAR selectW[] = {'S','E','L','E','C','T'};
 529 static const WCHAR trueW[] = {'T','R','U','E'};
 530 static const WCHAR whereW[] = {'W','H','E','R','E'};
 531
 532 static const struct keyword keyword_table[] =
 533 {
 534   { andW,    SIZEOF(andW),    TK_AND },
 535   { byW,     SIZEOF(byW),     TK_BY },
 536   { falseW,  SIZEOF(falseW),  TK_FALSE },
 537   { fromW,   SIZEOF(fromW),   TK_FROM },
 538   { isW,     SIZEOF(isW),     TK_IS },
 539   { likeW,   SIZEOF(likeW),   TK_LIKE },
 540   { notW,    SIZEOF(notW),    TK_NOT },
 541   { nullW,   SIZEOF(nullW),   TK_NULL },
 542   { orW,     SIZEOF(orW),     TK_OR },
 543   { selectW, SIZEOF(selectW), TK_SELECT },
 544   { trueW,   SIZEOF(trueW),   TK_TRUE },
 545   { whereW,  SIZEOF(whereW),  TK_WHERE }
 546 };
 547
 548 static int cmp_keyword( const void *arg1, const void *arg2 )
 549 {
 550     const struct keyword *key1 = arg1, *key2 = arg2;
 551     int len = min( key1->len, key2->len );
 552     int ret;
 553
 554     if ((ret = memicmpW( key1->name, key2->name, len ))) return ret;
 555     if (key1->len < key2->len) return -1;
 556     else if (key1->len > key2->len) return 1;
 557     return 0;
 558 }
 559
 560 static int keyword_type( const WCHAR *str, unsigned int len )
 561 {
 562     struct keyword key, *ret;
 563
 564     if (len > MAX_TOKEN_LEN) return TK_ID;
 565
 566     key.name = str;
 567     key.len  = len;
 568     key.type = 0;
 569     ret = bsearch( &key, keyword_table, SIZEOF(keyword_table), sizeof(struct keyword), cmp_keyword );
 570     if (ret) return ret->type;
 571     return TK_ID;
 572 }
 573
 574 static int get_token( const WCHAR *s, int *token )
 575 {
 576     int i;
 577
 578     switch (*s)
 579     {
 580     case ' ':
 581     case '\t':
 582     case '\n':
 583         for (i = 1; isspaceW( s[i] ); i++) {}
 584         *token = TK_SPACE;
 585         return i;
 586     case '-':
 587         if (!s[1]) return -1;
 588         *token = TK_MINUS;
 589         return 1;
 590     case '(':
 591         *token = TK_LP;
 592         return 1;
 593     case ')':
 594         *token = TK_RP;
 595         return 1;
 596     case '*':
 597         *token = TK_STAR;
 598         return 1;
 599     case '=':
 600         *token = TK_EQ;
 601         return 1;
 602     case '<':
 603         if (s[1] == '=' )
 604         {
 605             *token = TK_LE;
 606             return 2;
 607         }
 608         else if (s[1] == '>')
 609         {
 610             *token = TK_NE;
 611             return 2;
 612         }
 613         else
 614         {
 615             *token = TK_LT;
 616             return 1;
 617         }
 618     case '>':
 619         if (s[1] == '=')
 620         {
 621             *token = TK_GE;
 622             return 2;
 623         }
 624         else
 625         {
 626             *token = TK_GT;
 627             return 1;
 628         }
 629     case '!':
 630         if (s[1] != '=')
 631         {
 632             *token = TK_ILLEGAL;
 633             return 2;
 634         }
 635         else
 636         {
 637             *token = TK_NE;
 638             return 2;
 639         }
 640     case ',':
 641         *token = TK_COMMA;
 642         return 1;
 643     case '\"':
 644     case '\'':
 645         {
 646             for (i = 1; s[i]; i++)
 647             {
 648                 if (s[i] == s[0]) break;
 649             }
 650             if (s[i]) i++;
 651             *token = TK_STRING;
 652             return i;
 653         }
 654     case '.':
 655         if (!isdigitW( s[1] ))
 656         {
 657             *token = TK_DOT;
 658             return 1;
 659         }
 660         /* fall through */
 661     case '0': case '1': case '2': case '3': case '4':
 662     case '5': case '6': case '7': case '8': case '9':
 663         *token = TK_INTEGER;
 664         for (i = 1; isdigitW( s[i] ); i++) {}
 665         return i;
 666     default:
 667         if (!id_char[*s]) break;
 668
 669         for (i = 1; id_char[s[i]]; i++) {}
 670         *token = keyword_type( s, i );
 671         return i;
 672     }
 673     *token = TK_ILLEGAL;
 674     return 1;
 675 }
 676
 677 static int wql_lex( void *p, struct parser *parser )
 678 {
 679     struct string *str = p;
 680     int token = -1;
 681     do
 682     {
 683         parser->idx += parser->len;
 684         if (!parser->cmd[parser->idx]) return 0;
 685         parser->len = get_token( &parser->cmd[parser->idx], &token );
 686         if (!parser->len) break;
 687
 688         str->data = &parser->cmd[parser->idx];
 689         str->len = parser->len;
 690     } while (token == TK_SPACE);
 691     return token;
 692 }
 693
 694 static int wql_error( const char *str )
 695 {
 696     ERR("%s\n", str);
 697     return 0;
 698 }