dlls/msi/cond.y

   1 %{
   2
   3 /*
   4  * Implementation of the Microsoft Installer (msi.dll)
   5  *
   6  * Copyright 2003 Mike McCormack for CodeWeavers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library 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 GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winuser.h"
  32 #include "wine/debug.h"
  33 #include "wine/unicode.h"
  34
  35 #include "msi.h"
  36 #include "msiquery.h"
  37 #include "msipriv.h"
  38 #include "action.h"
  39
  40 #define YYLEX_PARAM info
  41 #define YYPARSE_PARAM info
  42
  43 static int COND_error(const char *str);
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  46
  47 typedef struct tag_yyinput
  48 {
  49     MSIPACKAGE *package;
  50     LPCWSTR str;
  51     INT    n;
  52     MSICONDITION result;
  53 } COND_input;
  54
  55 struct cond_str {
  56     LPCWSTR data;
  57     INT len;
  58 };
  59
  60 static LPWSTR COND_GetString( struct cond_str *str );
  61 static LPWSTR COND_GetLiteral( struct cond_str *str );
  62 static int COND_lex( void *COND_lval, COND_input *info);
  63 static const WCHAR szEmpty[] = { 0 };
  64
  65 static INT compare_int( INT a, INT operator, INT b );
  66 static INT compare_string( LPCWSTR a, INT operator, LPCWSTR b );
  67
  68 static INT compare_and_free_strings( LPWSTR a, INT op, LPWSTR b )
  69 {
  70     INT r;
  71
  72     r = compare_string( a, op, b );
  73     msi_free( a );
  74     msi_free( b );
  75     return r;
  76 }
  77
  78 %}
  79
  80 %pure-parser
  81
  82 %union
  83 {
  84     struct cond_str str;
  85     LPWSTR    string;
  86     INT       value;
  87 }
  88
  89 %token COND_SPACE COND_EOF COND_SPACE
  90 %token COND_OR COND_AND COND_NOT COND_XOR COND_IMP COND_EQV
  91 %token COND_LT COND_GT COND_EQ COND_NE COND_GE COND_LE
  92 %token COND_ILT COND_IGT COND_IEQ COND_INE COND_IGE COND_ILE
  93 %token COND_LPAR COND_RPAR COND_TILDA COND_SS COND_ISS
  94 %token COND_ILHS COND_IRHS COND_LHS COND_RHS
  95 %token COND_PERCENT COND_DOLLARS COND_QUESTION COND_AMPER COND_EXCLAM
  96 %token <str> COND_IDENT <str> COND_NUMBER <str> COND_LITER
  97
  98 %nonassoc COND_ERROR COND_EOF
  99
 100 %type <value> expression boolean_term boolean_factor
 101 %type <value> value_i integer operator
 102 %type <string> identifier symbol_s value_s literal
 103
 104 %%
 105
 106 condition:
 107     expression
 108         {
 109             COND_input* cond = (COND_input*) info;
 110             cond->result = $1;
 111         }
 112   | /* empty */
 113         {
 114             COND_input* cond = (COND_input*) info;
 115             cond->result = MSICONDITION_NONE;
 116         }
 117     ;
 118
 119 expression:
 120     boolean_term
 121         {
 122             $$ = $1;
 123         }
 124   | expression COND_OR boolean_term
 125         {
 126             $$ = $1 || $3;
 127         }
 128   | expression COND_IMP boolean_term
 129         {
 130             $$ = !$1 || $3;
 131         }
 132   | expression COND_XOR boolean_term
 133         {
 134             $$ = ( $1 || $3 ) && !( $1 && $3 );
 135         }
 136   | expression COND_EQV boolean_term
 137         {
 138             $$ = ( $1 && $3 ) || ( !$1 && !$3 );
 139         }
 140     ;
 141
 142 boolean_term:
 143     boolean_factor
 144         {
 145             $$ = $1;
 146         }
 147   | boolean_term COND_AND boolean_factor
 148         {
 149             $$ = $1 && $3;
 150         }
 151     ;
 152
 153 boolean_factor:
 154     COND_NOT boolean_factor
 155         {
 156             $$ = $2 ? 0 : 1;
 157         }
 158   | value_i
 159         {
 160             $$ = $1 ? 1 : 0;
 161         }
 162   | value_s
 163         {
 164             $$ = ($1 && $1[0]) ? 1 : 0;
 165         }
 166   | value_i operator value_i
 167         {
 168             $$ = compare_int( $1, $2, $3 );
 169         }
 170   | symbol_s operator value_i
 171         {
 172             $$ = compare_int( $1 ? atoiW($1) : 0, $2, $3 );
 173         }
 174   | value_i operator symbol_s
 175         {
 176             $$ = compare_int( $1, $2, $3 ? atoiW($3) : 0 );
 177         }
 178   | symbol_s operator symbol_s
 179         {
 180             $$ = compare_and_free_strings( $1, $2, $3 );
 181         }
 182   | symbol_s operator literal
 183         {
 184             $$ = compare_and_free_strings( $1, $2, $3 );
 185         }
 186   | literal operator symbol_s
 187         {
 188             $$ = compare_and_free_strings( $1, $2, $3 );
 189         }
 190   | literal operator literal
 191         {
 192             $$ = compare_and_free_strings( $1, $2, $3 );
 193         }
 194   | literal operator value_i
 195         {
 196             $$ = 0;
 197         }
 198   | value_i operator literal
 199         {
 200             $$ = 0;
 201         }
 202   | COND_LPAR expression COND_RPAR
 203         {
 204             $$ = $2;
 205         }
 206     ;
 207
 208 operator:
 209     /* common functions */
 210     COND_EQ { $$ = COND_EQ; }
 211   | COND_NE { $$ = COND_NE; }
 212   | COND_LT { $$ = COND_LT; }
 213   | COND_GT { $$ = COND_GT; }
 214   | COND_LE { $$ = COND_LE; }
 215   | COND_GE { $$ = COND_GE; }
 216   | COND_SS { $$ = COND_SS; }
 217   | COND_IEQ { $$ = COND_IEQ; }
 218   | COND_INE { $$ = COND_INE; }
 219   | COND_ILT { $$ = COND_ILT; }
 220   | COND_IGT { $$ = COND_IGT; }
 221   | COND_ILE { $$ = COND_ILE; }
 222   | COND_IGE { $$ = COND_IGE; }
 223   | COND_ISS { $$ = COND_ISS; }
 224   | COND_LHS { $$ = COND_LHS; }
 225   | COND_RHS { $$ = COND_RHS; }
 226   | COND_ILHS { $$ = COND_ILHS; }
 227   | COND_IRHS { $$ = COND_IRHS; }
 228     ;
 229
 230 value_s:
 231     symbol_s
 232     {
 233         $$ = $1;
 234     }
 235   | literal
 236     {
 237         $$ = $1;
 238     }
 239     ;
 240
 241 literal:
 242     COND_LITER
 243         {
 244             $$ = COND_GetLiteral(&$1);
 245             if( !$$ )
 246                 YYABORT;
 247         }
 248     ;
 249
 250 value_i:
 251     integer
 252         {
 253             $$ = $1;
 254         }
 255   | COND_DOLLARS identifier
 256         {
 257             COND_input* cond = (COND_input*) info;
 258             INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
 259
 260             MSI_GetComponentStateW(cond->package, $2, &install, &action );
 261             $$ = action;
 262             msi_free( $2 );
 263         }
 264   | COND_QUESTION identifier
 265         {
 266             COND_input* cond = (COND_input*) info;
 267             INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
 268
 269             MSI_GetComponentStateW(cond->package, $2, &install, &action );
 270             $$ = install;
 271             msi_free( $2 );
 272         }
 273   | COND_AMPER identifier
 274         {
 275             COND_input* cond = (COND_input*) info;
 276             INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
 277
 278             MSI_GetFeatureStateW(cond->package, $2, &install, &action );
 279             $$ = action;
 280             msi_free( $2 );
 281         }
 282   | COND_EXCLAM identifier
 283         {
 284             COND_input* cond = (COND_input*) info;
 285             INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
 286
 287             MSI_GetFeatureStateW(cond->package, $2, &install, &action );
 288             $$ = install;
 289             msi_free( $2 );
 290         }
 291     ;
 292
 293 symbol_s:
 294     identifier
 295         {
 296             COND_input* cond = (COND_input*) info;
 297
 298             $$ = msi_dup_property( cond->package, $1 );
 299             msi_free( $1 );
 300         }
 301     | COND_PERCENT identifier
 302         {
 303             UINT len = GetEnvironmentVariableW( $2, NULL, 0 );
 304             $$ = NULL;
 305             if (len++)
 306             {
 307                 $$ = msi_alloc( len*sizeof (WCHAR) );
 308                 GetEnvironmentVariableW( $2, $$, len );
 309             }
 310             msi_free( $2 );
 311         }
 312     ;
 313
 314 identifier:
 315     COND_IDENT
 316         {
 317             $$ = COND_GetString(&$1);
 318             if( !$$ )
 319                 YYABORT;
 320         }
 321     ;
 322
 323 integer:
 324     COND_NUMBER
 325         {
 326             LPWSTR szNum = COND_GetString(&$1);
 327             if( !szNum )
 328                 YYABORT;
 329             $$ = atoiW( szNum );
 330             msi_free( szNum );
 331         }
 332     ;
 333
 334 %%
 335
 336
 337 static int COND_IsAlpha( WCHAR x )
 338 {
 339     return( ( ( x >= 'A' ) && ( x <= 'Z' ) ) ||
 340             ( ( x >= 'a' ) && ( x <= 'z' ) ) ||
 341             ( ( x == '_' ) ) );
 342 }
 343
 344 static int COND_IsNumber( WCHAR x )
 345 {
 346     return( (( x >= '0' ) && ( x <= '9' ))  || (x =='-') || (x =='.') );
 347 }
 348
 349 static WCHAR *strstriW( const WCHAR *str, const WCHAR *sub )
 350 {
 351     LPWSTR strlower, sublower, r;
 352     strlower = CharLowerW( strdupW( str ) );
 353     sublower = CharLowerW( strdupW( sub ) );
 354     r = strstrW( strlower, sublower );
 355     if (r)
 356         r = (LPWSTR)str + (r - strlower);
 357     msi_free( strlower );
 358     msi_free( sublower );
 359     return r;
 360 }
 361
 362 static INT compare_string( LPCWSTR a, INT operator, LPCWSTR b )
 363 {
 364     /* null and empty string are equivalent */
 365     if (!a) a = szEmpty;
 366     if (!b) b = szEmpty;
 367
 368     /* a or b may be NULL */
 369     switch (operator)
 370     {
 371     case COND_LT:
 372         return -1 == lstrcmpW( a, b );
 373     case COND_GT:
 374         return  1 == lstrcmpW( a, b );
 375     case COND_EQ:
 376         return  0 == lstrcmpW( a, b );
 377     case COND_NE:
 378         return  0 != lstrcmpW( a, b );
 379     case COND_GE:
 380         return -1 != lstrcmpW( a, b );
 381     case COND_LE:
 382         return  1 != lstrcmpW( a, b );
 383     case COND_SS: /* substring */
 384         return strstrW( a, b ) ? 1 : 0;
 385     case COND_ILT:
 386         return -1 == lstrcmpiW( a, b );
 387     case COND_IGT:
 388         return  1 == lstrcmpiW( a, b );
 389     case COND_IEQ:
 390         return  0 == lstrcmpiW( a, b );
 391     case COND_INE:
 392         return  0 != lstrcmpiW( a, b );
 393     case COND_IGE:
 394         return -1 != lstrcmpiW( a, b );
 395     case COND_ILE:
 396         return  1 != lstrcmpiW( a, b );
 397     case COND_ISS:
 398         return strstriW( a, b ) ? 1 : 0;
 399     case COND_LHS:
 400     case COND_RHS:
 401     case COND_ILHS:
 402     case COND_IRHS:
 403         ERR("unimplemented string comparison\n");
 404         break;
 405     default:
 406         ERR("invalid integer operator\n");
 407         return 0;
 408     }
 409     return 0;
 410 }
 411
 412
 413 static INT compare_int( INT a, INT operator, INT b )
 414 {
 415     switch (operator)
 416     {
 417     case COND_LT:
 418     case COND_ILT:
 419         return a < b;
 420     case COND_GT:
 421     case COND_IGT:
 422         return a > b;
 423     case COND_EQ:
 424     case COND_IEQ:
 425         return a == b;
 426     case COND_NE:
 427     case COND_INE:
 428         return a != b;
 429     case COND_GE:
 430     case COND_IGE:
 431         return a >= b;
 432     case COND_LE:
 433     case COND_ILE:
 434         return a >= b;
 435     case COND_SS:
 436     case COND_ISS:
 437         return ( a & b ) ? 1 : 0;
 438     case COND_RHS:
 439         return ( ( a & 0xffff ) == b ) ? 1 : 0;
 440     case COND_LHS:
 441         return ( ( (a>>16) & 0xffff ) == b ) ? 1 : 0;
 442     default:
 443         ERR("invalid integer operator\n");
 444         return 0;
 445     }
 446     return 0;
 447 }
 448
 449
 450 static int COND_IsIdent( WCHAR x )
 451 {
 452     return( COND_IsAlpha( x ) || COND_IsNumber( x ) || ( x == '_' )
 453             || ( x == '#' ) || (x == '.') );
 454 }
 455
 456 static int COND_GetOperator( COND_input *cond )
 457 {
 458     static const struct {
 459         const WCHAR str[4];
 460         int id;
 461     } table[] = {
 462         { {'~','=',0},     COND_IEQ },
 463         { {'~','>','=',0}, COND_ILE },
 464         { {'~','>','<',0}, COND_ISS },
 465         { {'~','>','>',0}, COND_IRHS },
 466         { {'~','>',0},     COND_ILT },
 467         { {'~','<','>',0}, COND_INE },
 468         { {'~','<','=',0}, COND_IGE },
 469         { {'~','<','<',0}, COND_ILHS },
 470         { {'~','<',0},     COND_IGT },
 471         { {'>','=',0},     COND_GE  },
 472         { {'>','<',0},     COND_SS  },
 473         { {'>','>',0},     COND_LHS },
 474         { {'>',0},         COND_GT  },
 475         { {'<','>',0},     COND_NE  },
 476         { {'<','=',0},     COND_LE  },
 477         { {'<','<',0},     COND_RHS },
 478         { {'<',0},         COND_LT  },
 479         { {0},             0        }
 480     };
 481     LPCWSTR p = &cond->str[cond->n];
 482     int i = 0, len;
 483
 484     while ( 1 )
 485     {
 486         len = lstrlenW( table[i].str );
 487         if ( !len || 0 == strncmpW( table[i].str, p, len ) )
 488             break;
 489         i++;
 490     }
 491     cond->n += len;
 492     return table[i].id;
 493 }
 494
 495 static int COND_GetOne( struct cond_str *str, COND_input *cond )
 496 {
 497     int rc, len = 1;
 498     WCHAR ch;
 499
 500     str->data = &cond->str[cond->n];
 501
 502     ch = str->data[0];
 503
 504     switch( ch )
 505     {
 506     case 0: return 0;
 507     case '(': rc = COND_LPAR; break;
 508     case ')': rc = COND_RPAR; break;
 509     case '&': rc = COND_AMPER; break;
 510     case '!': rc = COND_EXCLAM; break;
 511     case '$': rc = COND_DOLLARS; break;
 512     case '?': rc = COND_QUESTION; break;
 513     case '%': rc = COND_PERCENT; break;
 514     case ' ': rc = COND_SPACE; break;
 515     case '=': rc = COND_EQ; break;
 516         break;
 517
 518     case '~':
 519     case '<':
 520     case '>':
 521         rc = COND_GetOperator( cond );
 522         if (!rc)
 523             rc = COND_ERROR;
 524         return rc;
 525     default:
 526         rc = 0;
 527     }
 528
 529     if ( rc )
 530     {
 531         cond->n += len;
 532         return rc;
 533     }
 534
 535     if (ch == '"' )
 536     {
 537         LPCWSTR p = strchrW( str->data + 1, '"' );
 538         if (!p)
 539             return COND_ERROR;
 540         len = p - str->data + 1;
 541         rc = COND_LITER;
 542     }
 543     else if( COND_IsAlpha( ch ) )
 544     {
 545         static const WCHAR szNot[] = {'N','O','T',0};
 546         static const WCHAR szAnd[] = {'A','N','D',0};
 547         static const WCHAR szXor[] = {'X','O','R',0};
 548         static const WCHAR szEqv[] = {'E','Q','V',0};
 549         static const WCHAR szImp[] = {'I','M','P',0};
 550         static const WCHAR szOr[] = {'O','R',0};
 551
 552         while( COND_IsIdent( str->data[len] ) )
 553             len++;
 554         rc = COND_IDENT;
 555
 556         if ( len == 3 )
 557         {
 558             if ( !strncmpiW( str->data, szNot, len ) )
 559                 rc = COND_NOT;
 560             else if( !strncmpiW( str->data, szAnd, len ) )
 561                 rc = COND_AND;
 562             else if( !strncmpiW( str->data, szXor, len ) )
 563                 rc = COND_XOR;
 564             else if( !strncmpiW( str->data, szEqv, len ) )
 565                 rc = COND_EQV;
 566             else if( !strncmpiW( str->data, szImp, len ) )
 567                 rc = COND_IMP;
 568         }
 569         else if( (len == 2) && !strncmpiW( str->data, szOr, len ) )
 570             rc = COND_OR;
 571     }
 572     else if( COND_IsNumber( ch ) )
 573     {
 574         while( COND_IsNumber( str->data[len] ) )
 575             len++;
 576         rc = COND_NUMBER;
 577     }
 578     else
 579     {
 580         ERR("Got unknown character %c(%x)\n",ch,ch);
 581         return COND_ERROR;
 582     }
 583
 584     cond->n += len;
 585     str->len = len;
 586
 587     return rc;
 588 }
 589
 590 static int COND_lex( void *COND_lval, COND_input *cond )
 591 {
 592     int rc;
 593     struct cond_str *str = COND_lval;
 594
 595     do {
 596         rc = COND_GetOne( str, cond );
 597     } while (rc == COND_SPACE);
 598
 599     return rc;
 600 }
 601
 602 static LPWSTR COND_GetString( struct cond_str *str )
 603 {
 604     LPWSTR ret;
 605
 606     ret = msi_alloc( (str->len+1) * sizeof (WCHAR) );
 607     if( ret )
 608     {
 609         memcpy( ret, str->data, str->len * sizeof(WCHAR));
 610         ret[str->len]=0;
 611     }
 612     TRACE("Got identifier %s\n",debugstr_w(ret));
 613     return ret;
 614 }
 615
 616 static LPWSTR COND_GetLiteral( struct cond_str *str )
 617 {
 618     LPWSTR ret;
 619
 620     ret = msi_alloc( (str->len-1) * sizeof (WCHAR) );
 621     if( ret )
 622     {
 623         memcpy( ret, str->data+1, (str->len-2) * sizeof(WCHAR) );
 624         ret[str->len - 2]=0;
 625     }
 626     TRACE("Got literal %s\n",debugstr_w(ret));
 627     return ret;
 628 }
 629
 630 static int COND_error(const char *str)
 631 {
 632     TRACE("%s\n", str );
 633     return 0;
 634 }
 635
 636 MSICONDITION MSI_EvaluateConditionW( MSIPACKAGE *package, LPCWSTR szCondition )
 637 {
 638     COND_input cond;
 639     MSICONDITION r;
 640
 641     TRACE("%s\n", debugstr_w( szCondition ) );
 642
 643     if ( szCondition == NULL )
 644         return MSICONDITION_NONE;
 645
 646     cond.package = package;
 647     cond.str   = szCondition;
 648     cond.n     = 0;
 649     cond.result = MSICONDITION_ERROR;
 650
 651     if ( !COND_parse( &cond ) )
 652         r = cond.result;
 653     else
 654         r = MSICONDITION_ERROR;
 655
 656     TRACE("%i <- %s\n", r, debugstr_w(szCondition));
 657     return r;
 658 }
 659
 660 MSICONDITION WINAPI MsiEvaluateConditionW( MSIHANDLE hInstall, LPCWSTR szCondition )
 661 {
 662     MSIPACKAGE *package;
 663     UINT ret;
 664
 665     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE);
 666     if( !package)
 667         return MSICONDITION_ERROR;
 668     ret = MSI_EvaluateConditionW( package, szCondition );
 669     msiobj_release( &package->hdr );
 670     return ret;
 671 }
 672
 673 MSICONDITION WINAPI MsiEvaluateConditionA( MSIHANDLE hInstall, LPCSTR szCondition )
 674 {
 675     LPWSTR szwCond = NULL;
 676     MSICONDITION r;
 677
 678     szwCond = strdupAtoW( szCondition );
 679     if( szCondition && !szwCond )
 680         return MSICONDITION_ERROR;
 681
 682     r = MsiEvaluateConditionW( hInstall, szwCond );
 683     msi_free( szwCond );
 684     return r;
 685 }