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