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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #define COBJMACROS
  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 "msi.h"
  33 #include "msiquery.h"
  34 #include "objbase.h"
  35 #include "oleauto.h"
  36
  37 #include "msipriv.h"
  38 #include "winemsi.h"
  39 #include "wine/debug.h"
  40 #include "wine/exception.h"
  41 #include "wine/list.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  44
  45 typedef struct tag_yyinput
  46 {
  47     MSIPACKAGE *package;
  48     LPCWSTR str;
  49     INT    n;
  50     MSICONDITION result;
  51     struct list mem;
  52 } COND_input;
  53
  54 struct cond_str {
  55     LPCWSTR data;
  56     INT len;
  57 };
  58
  59 struct value {
  60     enum value_type {
  61         VALUE_INTEGER,
  62         VALUE_LITERAL,
  63         VALUE_SYMBOL
  64     } type;
  65     union {
  66         INT integer;
  67         WCHAR *string;
  68     } u;
  69 };
  70
  71 static LPWSTR COND_GetString( COND_input *info, const struct cond_str *str );
  72 static LPWSTR COND_GetLiteral( COND_input *info, const struct cond_str *str );
  73 static int cond_lex( void *COND_lval, COND_input *info);
  74 static int cond_error( COND_input *info, const char *str);
  75
  76 static void *cond_alloc( COND_input *cond, unsigned int sz );
  77 static void *cond_track_mem( COND_input *cond, void *ptr, unsigned int sz );
  78 static void cond_free( void *ptr );
  79
  80 static INT compare_int( INT a, INT operator, INT b );
  81 static INT compare_string( LPCWSTR a, INT operator, LPCWSTR b, BOOL convert );
  82
  83 static BOOL num_from_prop( LPCWSTR p, INT *val )
  84 {
  85     INT ret = 0, sign = 1;
  86
  87     if (!p)
  88         return FALSE;
  89     if (*p == '-')
  90     {
  91         sign = -1;
  92         p++;
  93     }
  94     if (!*p)
  95         return FALSE;
  96     while (*p)
  97     {
  98         if( *p < '0' || *p > '9' )
  99             return FALSE;
 100         ret = ret*10 + (*p - '0');
 101         p++;
 102     }
 103     *val = ret*sign;
 104     return TRUE;
 105 }
 106
 107 static void value_free( struct value val )
 108 {
 109     if (val.type != VALUE_INTEGER)
 110         cond_free( val.u.string );
 111 }
 112
 113 %}
 114
 115 %lex-param { COND_input *info }
 116 %parse-param { COND_input *info }
 117 %define api.pure
 118
 119 %union
 120 {
 121     struct cond_str str;
 122     struct value value;
 123     LPWSTR identifier;
 124     INT operator;
 125     BOOL bool;
 126 }
 127
 128 %token COND_SPACE COND_EOF
 129 %token COND_OR COND_AND COND_NOT COND_XOR COND_IMP COND_EQV
 130 %token COND_LT COND_GT COND_EQ COND_NE COND_GE COND_LE
 131 %token COND_ILT COND_IGT COND_IEQ COND_INE COND_IGE COND_ILE
 132 %token COND_LPAR COND_RPAR COND_TILDA COND_SS COND_ISS
 133 %token COND_ILHS COND_IRHS COND_LHS COND_RHS
 134 %token COND_PERCENT COND_DOLLARS COND_QUESTION COND_AMPER COND_EXCLAM
 135 %token <str> COND_IDENT <str> COND_NUMBER <str> COND_LITER
 136
 137 %nonassoc COND_ERROR COND_EOF
 138
 139 %type <bool> expression boolean_term boolean_factor
 140 %type <value> value
 141 %type <identifier> identifier
 142 %type <operator> operator
 143
 144 %%
 145
 146 condition:
 147     expression
 148         {
 149             COND_input* cond = (COND_input*) info;
 150             cond->result = $1;
 151         }
 152   | /* empty */
 153         {
 154             COND_input* cond = (COND_input*) info;
 155             cond->result = MSICONDITION_NONE;
 156         }
 157     ;
 158
 159 expression:
 160     boolean_term
 161         {
 162             $$ = $1;
 163         }
 164   | expression COND_OR boolean_term
 165         {
 166             $$ = $1 || $3;
 167         }
 168   | expression COND_IMP boolean_term
 169         {
 170             $$ = !$1 || $3;
 171         }
 172   | expression COND_XOR boolean_term
 173         {
 174             $$ = ( $1 || $3 ) && !( $1 && $3 );
 175         }
 176   | expression COND_EQV boolean_term
 177         {
 178             $$ = ( $1 && $3 ) || ( !$1 && !$3 );
 179         }
 180     ;
 181
 182 boolean_term:
 183     boolean_factor
 184         {
 185             $$ = $1;
 186         }
 187   | boolean_term COND_AND boolean_factor
 188         {
 189             $$ = $1 && $3;
 190         }
 191     ;
 192
 193 boolean_factor:
 194     COND_NOT boolean_factor
 195         {
 196             $$ = !$2;
 197         }
 198   | value
 199         {
 200             if ($1.type == VALUE_INTEGER)
 201                 $$ = $1.u.integer ? 1 : 0;
 202             else
 203                 $$ = $1.u.string && $1.u.string[0];
 204             value_free( $1 );
 205         }
 206   | value operator value
 207         {
 208             if ($1.type == VALUE_INTEGER && $3.type == VALUE_INTEGER)
 209             {
 210                 $$ = compare_int($1.u.integer, $2, $3.u.integer);
 211             }
 212             else if ($1.type != VALUE_INTEGER && $3.type != VALUE_INTEGER)
 213             {
 214                 $$ = compare_string($1.u.string, $2, $3.u.string,
 215                         $1.type == VALUE_SYMBOL || $3.type == VALUE_SYMBOL);
 216             }
 217             else if ($1.type == VALUE_LITERAL || $3.type == VALUE_LITERAL)
 218             {
 219                 $$ = ($2 == COND_NE || $2 == COND_INE );
 220             }
 221             else if ($1.type == VALUE_SYMBOL) /* symbol operator integer */
 222             {
 223                 int num;
 224                 if (num_from_prop( $1.u.string, &num ))
 225                     $$ = compare_int( num, $2, $3.u.integer );
 226                 else
 227                     $$ = ($2 == COND_NE || $2 == COND_INE );
 228             }
 229             else /* integer operator symbol */
 230             {
 231                 int num;
 232                 if (num_from_prop( $3.u.string, &num ))
 233                     $$ = compare_int( $1.u.integer, $2, num );
 234                 else
 235                     $$ = ($2 == COND_NE || $2 == COND_INE );
 236             }
 237
 238             value_free( $1 );
 239             value_free( $3 );
 240         }
 241   | COND_LPAR expression COND_RPAR
 242         {
 243             $$ = $2;
 244         }
 245     ;
 246
 247 operator:
 248     /* common functions */
 249     COND_EQ { $$ = COND_EQ; }
 250   | COND_NE { $$ = COND_NE; }
 251   | COND_LT { $$ = COND_LT; }
 252   | COND_GT { $$ = COND_GT; }
 253   | COND_LE { $$ = COND_LE; }
 254   | COND_GE { $$ = COND_GE; }
 255   | COND_SS { $$ = COND_SS; }
 256   | COND_IEQ { $$ = COND_IEQ; }
 257   | COND_INE { $$ = COND_INE; }
 258   | COND_ILT { $$ = COND_ILT; }
 259   | COND_IGT { $$ = COND_IGT; }
 260   | COND_ILE { $$ = COND_ILE; }
 261   | COND_IGE { $$ = COND_IGE; }
 262   | COND_ISS { $$ = COND_ISS; }
 263   | COND_LHS { $$ = COND_LHS; }
 264   | COND_RHS { $$ = COND_RHS; }
 265   | COND_ILHS { $$ = COND_ILHS; }
 266   | COND_IRHS { $$ = COND_IRHS; }
 267     ;
 268
 269 value:
 270     identifier
 271         {
 272             COND_input* cond = (COND_input*) info;
 273             UINT len;
 274
 275             $$.type = VALUE_SYMBOL;
 276             $$.u.string = msi_dup_property( cond->package->db, $1 );
 277             if ($$.u.string)
 278             {
 279                 len = (lstrlenW($$.u.string) + 1) * sizeof (WCHAR);
 280                 $$.u.string = cond_track_mem( cond, $$.u.string, len );
 281             }
 282             cond_free( $1 );
 283         }
 284   | COND_PERCENT identifier
 285         {
 286             COND_input* cond = (COND_input*) info;
 287             UINT len = GetEnvironmentVariableW( $2, NULL, 0 );
 288             $$.type = VALUE_SYMBOL;
 289             $$.u.string = NULL;
 290             if (len++)
 291             {
 292                 $$.u.string = cond_alloc( cond, len*sizeof (WCHAR) );
 293                 if( !$$.u.string )
 294                     YYABORT;
 295                 GetEnvironmentVariableW( $2, $$.u.string, len );
 296             }
 297             cond_free( $2 );
 298         }
 299   | COND_LITER
 300         {
 301             COND_input* cond = (COND_input*) info;
 302             $$.type = VALUE_LITERAL;
 303             $$.u.string = COND_GetLiteral( cond, &$1 );
 304             if( !$$.u.string )
 305                 YYABORT;
 306         }
 307   | COND_NUMBER
 308         {
 309             COND_input* cond = (COND_input*) info;
 310             LPWSTR szNum = COND_GetString( cond, &$1 );
 311             if( !szNum )
 312                 YYABORT;
 313             $$.type = VALUE_INTEGER;
 314             $$.u.integer = wcstol( szNum, NULL, 10 );
 315             cond_free( szNum );
 316         }
 317   | COND_DOLLARS identifier
 318         {
 319             COND_input* cond = (COND_input*) info;
 320             INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
 321
 322             if(MSI_GetComponentStateW(cond->package, $2, &install, &action ) != ERROR_SUCCESS)
 323             {
 324                 $$.type = VALUE_LITERAL;
 325                 $$.u.string = NULL;
 326             }
 327             else
 328             {
 329                 $$.type = VALUE_INTEGER;
 330                 $$.u.integer = action;
 331             }
 332             cond_free( $2 );
 333         }
 334   | COND_QUESTION identifier
 335         {
 336             COND_input* cond = (COND_input*) info;
 337             INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
 338
 339             if(MSI_GetComponentStateW(cond->package, $2, &install, &action ) != ERROR_SUCCESS)
 340             {
 341                 $$.type = VALUE_LITERAL;
 342                 $$.u.string = NULL;
 343             }
 344             else
 345             {
 346                 $$.type = VALUE_INTEGER;
 347                 $$.u.integer = install;
 348             }
 349             cond_free( $2 );
 350         }
 351   | COND_AMPER identifier
 352         {
 353             COND_input* cond = (COND_input*) info;
 354             INSTALLSTATE install, action;
 355
 356             if (MSI_GetFeatureStateW(cond->package, $2, &install, &action ) != ERROR_SUCCESS)
 357             {
 358                 $$.type = VALUE_LITERAL;
 359                 $$.u.string = NULL;
 360             }
 361             else
 362             {
 363                 $$.type = VALUE_INTEGER;
 364                 $$.u.integer = action;
 365             }
 366             cond_free( $2 );
 367         }
 368   | COND_EXCLAM identifier
 369         {
 370             COND_input* cond = (COND_input*) info;
 371             INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
 372
 373             if(MSI_GetFeatureStateW(cond->package, $2, &install, &action ) != ERROR_SUCCESS)
 374             {
 375                 $$.type = VALUE_LITERAL;
 376                 $$.u.string = NULL;
 377             }
 378             else
 379             {
 380                 $$.type = VALUE_INTEGER;
 381                 $$.u.integer = install;
 382             }
 383             cond_free( $2 );
 384         }
 385     ;
 386
 387 identifier:
 388     COND_IDENT
 389         {
 390             COND_input* cond = (COND_input*) info;
 391             $$ = COND_GetString( cond, &$1 );
 392             if( !$$ )
 393                 YYABORT;
 394         }
 395     ;
 396
 397 %%
 398
 399
 400 static int COND_IsAlpha( WCHAR x )
 401 {
 402     return( ( ( x >= 'A' ) && ( x <= 'Z' ) ) ||
 403             ( ( x >= 'a' ) && ( x <= 'z' ) ) ||
 404             ( ( x == '_' ) ) );
 405 }
 406
 407 static int COND_IsNumber( WCHAR x )
 408 {
 409     return( (( x >= '0' ) && ( x <= '9' ))  || (x =='-') || (x =='.') );
 410 }
 411
 412 static WCHAR *strstriW( const WCHAR *str, const WCHAR *sub )
 413 {
 414     LPWSTR strlower, sublower, r;
 415     strlower = CharLowerW( strdupW( str ) );
 416     sublower = CharLowerW( strdupW( sub ) );
 417     r = wcsstr( strlower, sublower );
 418     if (r)
 419         r = (LPWSTR)str + (r - strlower);
 420     msi_free( strlower );
 421     msi_free( sublower );
 422     return r;
 423 }
 424
 425 static BOOL str_is_number( LPCWSTR str )
 426 {
 427     int i;
 428
 429     if (!*str)
 430         return FALSE;
 431
 432     for (i = 0; i < lstrlenW( str ); i++)
 433         if (!iswdigit(str[i]))
 434             return FALSE;
 435
 436     return TRUE;
 437 }
 438
 439 static INT compare_substring( LPCWSTR a, INT operator, LPCWSTR b )
 440 {
 441     int lhs, rhs;
 442
 443     /* substring operators return 0 if LHS is missing */
 444     if (!a || !*a)
 445         return 0;
 446
 447     /* substring operators return 1 if RHS is missing */
 448     if (!b || !*b)
 449         return 1;
 450
 451     /* if both strings contain only numbers, use integer comparison */
 452     lhs = wcstol(a, NULL, 10);
 453     rhs = wcstol(b, NULL, 10);
 454     if (str_is_number(a) && str_is_number(b))
 455         return compare_int( lhs, operator, rhs );
 456
 457     switch (operator)
 458     {
 459     case COND_SS:
 460         return wcsstr( a, b ) != 0;
 461     case COND_ISS:
 462         return strstriW( a, b ) != 0;
 463     case COND_LHS:
 464     {
 465         int l = lstrlenW( a );
 466         int r = lstrlenW( b );
 467         if (r > l) return 0;
 468         return !wcsncmp( a, b, r );
 469     }
 470     case COND_RHS:
 471     {
 472         int l = lstrlenW( a );
 473         int r = lstrlenW( b );
 474         if (r > l) return 0;
 475         return !wcsncmp( a + (l - r), b, r );
 476     }
 477     case COND_ILHS:
 478     {
 479         int l = lstrlenW( a );
 480         int r = lstrlenW( b );
 481         if (r > l) return 0;
 482         return !wcsnicmp( a, b, r );
 483     }
 484     case COND_IRHS:
 485     {
 486         int l = lstrlenW( a );
 487         int r = lstrlenW( b );
 488         if (r > l) return 0;
 489         return !wcsnicmp( a + (l - r), b, r );
 490     }
 491     default:
 492         ERR("invalid substring operator\n");
 493         return 0;
 494     }
 495     return 0;
 496 }
 497
 498 static INT compare_string( LPCWSTR a, INT operator, LPCWSTR b, BOOL convert )
 499 {
 500     if (operator >= COND_SS && operator <= COND_RHS)
 501         return compare_substring( a, operator, b );
 502
 503     /* null and empty string are equivalent */
 504     if (!a) a = szEmpty;
 505     if (!b) b = szEmpty;
 506
 507     if (convert && str_is_number(a) && str_is_number(b))
 508         return compare_int( wcstol(a, NULL, 10), operator, wcstol(b, NULL, 10) );
 509
 510     /* a or b may be NULL */
 511     switch (operator)
 512     {
 513     case COND_LT:
 514         return wcscmp( a, b ) < 0;
 515     case COND_GT:
 516         return wcscmp( a, b ) > 0;
 517     case COND_EQ:
 518         return wcscmp( a, b ) == 0;
 519     case COND_NE:
 520         return wcscmp( a, b ) != 0;
 521     case COND_GE:
 522         return wcscmp( a, b ) >= 0;
 523     case COND_LE:
 524         return wcscmp( a, b ) <= 0;
 525     case COND_ILT:
 526         return wcsicmp( a, b ) < 0;
 527     case COND_IGT:
 528         return wcsicmp( a, b ) > 0;
 529     case COND_IEQ:
 530         return wcsicmp( a, b ) == 0;
 531     case COND_INE:
 532         return wcsicmp( a, b ) != 0;
 533     case COND_IGE:
 534         return wcsicmp( a, b ) >= 0;
 535     case COND_ILE:
 536         return wcsicmp( a, b ) <= 0;
 537     default:
 538         ERR("invalid string operator\n");
 539         return 0;
 540     }
 541     return 0;
 542 }
 543
 544
 545 static INT compare_int( INT a, INT operator, INT b )
 546 {
 547     switch (operator)
 548     {
 549     case COND_LT:
 550     case COND_ILT:
 551         return a < b;
 552     case COND_GT:
 553     case COND_IGT:
 554         return a > b;
 555     case COND_EQ:
 556     case COND_IEQ:
 557         return a == b;
 558     case COND_NE:
 559     case COND_INE:
 560         return a != b;
 561     case COND_GE:
 562     case COND_IGE:
 563         return a >= b;
 564     case COND_LE:
 565     case COND_ILE:
 566         return a <= b;
 567     case COND_SS:
 568     case COND_ISS:
 569         return ( a & b ) ? 1 : 0;
 570     case COND_RHS:
 571         return ( ( a & 0xffff ) == b ) ? 1 : 0;
 572     case COND_LHS:
 573         return ( ( (a>>16) & 0xffff ) == b ) ? 1 : 0;
 574     default:
 575         ERR("invalid integer operator\n");
 576         return 0;
 577     }
 578     return 0;
 579 }
 580
 581
 582 static int COND_IsIdent( WCHAR x )
 583 {
 584     return( COND_IsAlpha( x ) || COND_IsNumber( x ) || ( x == '_' )
 585             || ( x == '#' ) || (x == '.') );
 586 }
 587
 588 static int COND_GetOperator( COND_input *cond )
 589 {
 590     static const struct {
 591         const WCHAR str[4];
 592         int id;
 593     } table[] = {
 594         { {'~','<','=',0}, COND_ILE },
 595         { {'~','>','<',0}, COND_ISS },
 596         { {'~','>','>',0}, COND_IRHS },
 597         { {'~','<','>',0}, COND_INE },
 598         { {'~','>','=',0}, COND_IGE },
 599         { {'~','<','<',0}, COND_ILHS },
 600         { {'~','=',0},     COND_IEQ },
 601         { {'~','<',0},     COND_ILT },
 602         { {'~','>',0},     COND_IGT },
 603         { {'>','=',0},     COND_GE  },
 604         { {'>','<',0},     COND_SS  },
 605         { {'<','<',0},     COND_LHS },
 606         { {'<','>',0},     COND_NE  },
 607         { {'<','=',0},     COND_LE  },
 608         { {'>','>',0},     COND_RHS },
 609         { {'>',0},         COND_GT  },
 610         { {'<',0},         COND_LT  },
 611         { {0},             0        }
 612     };
 613     LPCWSTR p = &cond->str[cond->n];
 614     int i = 0, len;
 615
 616     while ( 1 )
 617     {
 618         len = lstrlenW( table[i].str );
 619         if ( !len || 0 == wcsncmp( table[i].str, p, len ) )
 620             break;
 621         i++;
 622     }
 623     cond->n += len;
 624     return table[i].id;
 625 }
 626
 627 static int COND_GetOne( struct cond_str *str, COND_input *cond )
 628 {
 629     int rc, len = 1;
 630     WCHAR ch;
 631
 632     str->data = &cond->str[cond->n];
 633
 634     ch = str->data[0];
 635
 636     switch( ch )
 637     {
 638     case 0: return 0;
 639     case '(': rc = COND_LPAR; break;
 640     case ')': rc = COND_RPAR; break;
 641     case '&': rc = COND_AMPER; break;
 642     case '!': rc = COND_EXCLAM; break;
 643     case '$': rc = COND_DOLLARS; break;
 644     case '?': rc = COND_QUESTION; break;
 645     case '%': rc = COND_PERCENT; break;
 646     case ' ': rc = COND_SPACE; break;
 647     case '=': rc = COND_EQ; break;
 648
 649     case '~':
 650     case '<':
 651     case '>':
 652         rc = COND_GetOperator( cond );
 653         if (!rc)
 654             rc = COND_ERROR;
 655         return rc;
 656     default:
 657         rc = 0;
 658     }
 659
 660     if ( rc )
 661     {
 662         cond->n += len;
 663         return rc;
 664     }
 665
 666     if (ch == '"' )
 667     {
 668         LPCWSTR p = wcschr( str->data + 1, '"' );
 669         if (!p) return COND_ERROR;
 670         len = p - str->data + 1;
 671         rc = COND_LITER;
 672     }
 673     else if( COND_IsAlpha( ch ) )
 674     {
 675         static const WCHAR szNot[] = {'N','O','T',0};
 676         static const WCHAR szAnd[] = {'A','N','D',0};
 677         static const WCHAR szXor[] = {'X','O','R',0};
 678         static const WCHAR szEqv[] = {'E','Q','V',0};
 679         static const WCHAR szImp[] = {'I','M','P',0};
 680         static const WCHAR szOr[] = {'O','R',0};
 681
 682         while( COND_IsIdent( str->data[len] ) )
 683             len++;
 684         rc = COND_IDENT;
 685
 686         if ( len == 3 )
 687         {
 688             if ( !wcsnicmp( str->data, szNot, len ) )
 689                 rc = COND_NOT;
 690             else if( !wcsnicmp( str->data, szAnd, len ) )
 691                 rc = COND_AND;
 692             else if( !wcsnicmp( str->data, szXor, len ) )
 693                 rc = COND_XOR;
 694             else if( !wcsnicmp( str->data, szEqv, len ) )
 695                 rc = COND_EQV;
 696             else if( !wcsnicmp( str->data, szImp, len ) )
 697                 rc = COND_IMP;
 698         }
 699         else if( (len == 2) && !wcsnicmp( str->data, szOr, len ) )
 700             rc = COND_OR;
 701     }
 702     else if( COND_IsNumber( ch ) )
 703     {
 704         while( COND_IsNumber( str->data[len] ) )
 705             len++;
 706         rc = COND_NUMBER;
 707     }
 708     else
 709     {
 710         ERR("Got unknown character %c(%x)\n",ch,ch);
 711         return COND_ERROR;
 712     }
 713
 714     cond->n += len;
 715     str->len = len;
 716
 717     return rc;
 718 }
 719
 720 static int cond_lex( void *COND_lval, COND_input *cond )
 721 {
 722     int rc;
 723     struct cond_str *str = COND_lval;
 724
 725     do {
 726         rc = COND_GetOne( str, cond );
 727     } while (rc == COND_SPACE);
 728
 729     return rc;
 730 }
 731
 732 static LPWSTR COND_GetString( COND_input *cond, const struct cond_str *str )
 733 {
 734     LPWSTR ret;
 735
 736     ret = cond_alloc( cond, (str->len+1) * sizeof (WCHAR) );
 737     if( ret )
 738     {
 739         memcpy( ret, str->data, str->len * sizeof(WCHAR));
 740         ret[str->len]=0;
 741     }
 742     TRACE("Got identifier %s\n",debugstr_w(ret));
 743     return ret;
 744 }
 745
 746 static LPWSTR COND_GetLiteral( COND_input *cond, const struct cond_str *str )
 747 {
 748     LPWSTR ret;
 749
 750     ret = cond_alloc( cond, (str->len-1) * sizeof (WCHAR) );
 751     if( ret )
 752     {
 753         memcpy( ret, str->data+1, (str->len-2) * sizeof(WCHAR) );
 754         ret[str->len - 2]=0;
 755     }
 756     TRACE("Got literal %s\n",debugstr_w(ret));
 757     return ret;
 758 }
 759
 760 static void *cond_alloc( COND_input *cond, unsigned int sz )
 761 {
 762     struct list *mem;
 763
 764     mem = msi_alloc( sizeof (struct list) + sz );
 765     if( !mem )
 766         return NULL;
 767
 768     list_add_head( &(cond->mem), mem );
 769     return mem + 1;
 770 }
 771
 772 static void *cond_track_mem( COND_input *cond, void *ptr, unsigned int sz )
 773 {
 774     void *new_ptr;
 775
 776     if( !ptr )
 777         return ptr;
 778
 779     new_ptr = cond_alloc( cond, sz );
 780     if( !new_ptr )
 781     {
 782         msi_free( ptr );
 783         return NULL;
 784     }
 785
 786     memcpy( new_ptr, ptr, sz );
 787     msi_free( ptr );
 788     return new_ptr;
 789 }
 790
 791 static void cond_free( void *ptr )
 792 {
 793     struct list *mem = (struct list *)ptr - 1;
 794
 795     if( ptr )
 796     {
 797         list_remove( mem );
 798         msi_free( mem );
 799     }
 800 }
 801
 802 static int cond_error( COND_input *info, const char *str )
 803 {
 804     TRACE("%s\n", str );
 805     return 0;
 806 }
 807
 808 MSICONDITION MSI_EvaluateConditionW( MSIPACKAGE *package, LPCWSTR szCondition )
 809 {
 810     COND_input cond;
 811     MSICONDITION r;
 812     struct list *mem, *safety;
 813
 814     TRACE("%s\n", debugstr_w( szCondition ) );
 815
 816     if (szCondition == NULL) return MSICONDITION_NONE;
 817
 818     cond.package = package;
 819     cond.str   = szCondition;
 820     cond.n     = 0;
 821     cond.result = MSICONDITION_ERROR;
 822
 823     list_init( &cond.mem );
 824
 825     if ( !cond_parse( &cond ) )
 826         r = cond.result;
 827     else
 828         r = MSICONDITION_ERROR;
 829
 830     LIST_FOR_EACH_SAFE( mem, safety, &cond.mem )
 831     {
 832         /* The tracked memory lives directly after the list struct */
 833         void *ptr = mem + 1;
 834         if ( r != MSICONDITION_ERROR )
 835             WARN( "condition parser failed to free up some memory: %p\n", ptr );
 836         cond_free( ptr );
 837     }
 838
 839     TRACE("%i <- %s\n", r, debugstr_w(szCondition));
 840     return r;
 841 }
 842
 843 MSICONDITION WINAPI MsiEvaluateConditionW( MSIHANDLE hInstall, LPCWSTR szCondition )
 844 {
 845     MSIPACKAGE *package;
 846     UINT ret;
 847
 848     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE);
 849     if( !package )
 850     {
 851         MSIHANDLE remote;
 852
 853         if (!(remote = msi_get_remote(hInstall)))
 854             return MSICONDITION_ERROR;
 855
 856         if (!szCondition)
 857             return MSICONDITION_NONE;
 858
 859         __TRY
 860         {
 861             ret = remote_EvaluateCondition(remote, szCondition);
 862         }
 863         __EXCEPT(rpc_filter)
 864         {
 865             ret = GetExceptionCode();
 866         }
 867         __ENDTRY
 868
 869         return ret;
 870     }
 871
 872     ret = MSI_EvaluateConditionW( package, szCondition );
 873     msiobj_release( &package->hdr );
 874     return ret;
 875 }
 876
 877 MSICONDITION WINAPI MsiEvaluateConditionA( MSIHANDLE hInstall, LPCSTR szCondition )
 878 {
 879     LPWSTR szwCond = NULL;
 880     MSICONDITION r;
 881
 882     szwCond = strdupAtoW( szCondition );
 883     if( szCondition && !szwCond )
 884         return MSICONDITION_ERROR;
 885
 886     r = MsiEvaluateConditionW( hInstall, szwCond );
 887     msi_free( szwCond );
 888     return r;
 889 }