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