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