msi: An inactive dialog control does not require a property.
[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->db, $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 ) != 0;
460     case COND_ISS:
461         return strstriW( a, b ) != 0;
462     case COND_LHS:
463     {
464         int l = strlenW( a );
465         int r = strlenW( b );
466         if (r > l) return 0;
467         return !strncmpW( a, b, r );
468     }
469     case COND_RHS:
470     {
471         int l = strlenW( a );
472         int r = strlenW( b );
473         if (r > l) return 0;
474         return !strncmpW( a + (l - r), b, r );
475     }
476     case COND_ILHS:
477     {
478         int l = strlenW( a );
479         int r = strlenW( b );
480         if (r > l) return 0;
481         return !strncmpiW( a, b, r );
482     }
483     case COND_IRHS:
484     {
485         int l = strlenW( a );
486         int r = strlenW( b );
487         if (r > l) return 0;
488         return !strncmpiW( a + (l - r), b, r );
489     }
490     default:
491         ERR("invalid substring operator\n");
492         return 0;
493     }
494     return 0;
495 }
496
497 static INT compare_string( LPCWSTR a, INT operator, LPCWSTR b, BOOL convert )
498 {
499     if (operator >= COND_SS && operator <= COND_RHS)
500         return compare_substring( a, operator, b );
501         
502     /* null and empty string are equivalent */
503     if (!a) a = szEmpty;
504     if (!b) b = szEmpty;
505
506     if (convert && str_is_number(a) && str_is_number(b))
507         return compare_int( atoiW(a), operator, atoiW(b) );
508
509     /* a or b may be NULL */
510     switch (operator)
511     {
512     case COND_LT:
513         return strcmpW( a, b ) < 0;
514     case COND_GT:
515         return strcmpW( a, b ) > 0;
516     case COND_EQ:
517         return strcmpW( a, b ) == 0;
518     case COND_NE:
519         return strcmpW( a, b ) != 0;
520     case COND_GE:
521         return strcmpW( a, b ) >= 0;
522     case COND_LE:
523         return strcmpW( a, b ) <= 0;
524     case COND_ILT:
525         return strcmpiW( a, b ) < 0;
526     case COND_IGT:
527         return strcmpiW( a, b ) > 0;
528     case COND_IEQ:
529         return strcmpiW( a, b ) == 0;
530     case COND_INE:
531         return strcmpiW( a, b ) != 0;
532     case COND_IGE:
533         return strcmpiW( a, b ) >= 0;
534     case COND_ILE:
535         return strcmpiW( a, b ) <= 0;
536     default:
537         ERR("invalid string operator\n");
538         return 0;
539     }
540     return 0;
541 }
542
543
544 static INT compare_int( INT a, INT operator, INT b )
545 {
546     switch (operator)
547     {
548     case COND_LT:
549     case COND_ILT:
550         return a < b;
551     case COND_GT:
552     case COND_IGT:
553         return a > b;
554     case COND_EQ:
555     case COND_IEQ:
556         return a == b;
557     case COND_NE:
558     case COND_INE:
559         return a != b;
560     case COND_GE:
561     case COND_IGE:
562         return a >= b;
563     case COND_LE:
564     case COND_ILE:
565         return a <= b;
566     case COND_SS:
567     case COND_ISS:
568         return ( a & b ) ? 1 : 0;
569     case COND_RHS:
570         return ( ( a & 0xffff ) == b ) ? 1 : 0;
571     case COND_LHS:
572         return ( ( (a>>16) & 0xffff ) == b ) ? 1 : 0;
573     default:
574         ERR("invalid integer operator\n");
575         return 0;
576     }
577     return 0;
578 }
579
580
581 static int COND_IsIdent( WCHAR x )
582 {
583     return( COND_IsAlpha( x ) || COND_IsNumber( x ) || ( x == '_' ) 
584             || ( x == '#' ) || (x == '.') );
585 }
586
587 static int COND_GetOperator( COND_input *cond )
588 {
589     static const struct {
590         const WCHAR str[4];
591         int id;
592     } table[] = {
593         { {'~','<','=',0}, COND_ILE },
594         { {'~','>','<',0}, COND_ISS },
595         { {'~','>','>',0}, COND_IRHS },
596         { {'~','<','>',0}, COND_INE },
597         { {'~','>','=',0}, COND_IGE },
598         { {'~','<','<',0}, COND_ILHS },
599         { {'~','=',0},     COND_IEQ },
600         { {'~','<',0},     COND_ILT },
601         { {'~','>',0},     COND_IGT },
602         { {'>','=',0},     COND_GE  },
603         { {'>','<',0},     COND_SS  },
604         { {'<','<',0},     COND_LHS },
605         { {'<','>',0},     COND_NE  },
606         { {'<','=',0},     COND_LE  },
607         { {'>','>',0},     COND_RHS },
608         { {'>',0},         COND_GT  },
609         { {'<',0},         COND_LT  },
610         { {0},             0        }
611     };
612     LPCWSTR p = &cond->str[cond->n];
613     int i = 0, len;
614
615     while ( 1 )
616     {
617         len = lstrlenW( table[i].str );
618         if ( !len || 0 == strncmpW( table[i].str, p, len ) )
619             break;
620         i++;
621     }
622     cond->n += len;
623     return table[i].id;
624 }
625
626 static int COND_GetOne( struct cond_str *str, COND_input *cond )
627 {
628     int rc, len = 1;
629     WCHAR ch;
630
631     str->data = &cond->str[cond->n];
632
633     ch = str->data[0];
634
635     switch( ch )
636     {
637     case 0: return 0;
638     case '(': rc = COND_LPAR; break;
639     case ')': rc = COND_RPAR; break;
640     case '&': rc = COND_AMPER; break;
641     case '!': rc = COND_EXCLAM; break;
642     case '$': rc = COND_DOLLARS; break;
643     case '?': rc = COND_QUESTION; break;
644     case '%': rc = COND_PERCENT; break;
645     case ' ': rc = COND_SPACE; break;
646     case '=': rc = COND_EQ; break;
647
648     case '~':
649     case '<':
650     case '>':
651         rc = COND_GetOperator( cond );
652         if (!rc)
653             rc = COND_ERROR;
654         return rc;
655     default:
656         rc = 0;
657     }
658
659     if ( rc )
660     {
661         cond->n += len;
662         return rc;
663     }
664
665     if (ch == '"' )
666     {
667         LPCWSTR p = strchrW( str->data + 1, '"' );
668         if (!p)
669             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 ( !strncmpiW( str->data, szNot, len ) )
689                 rc = COND_NOT;
690             else if( !strncmpiW( str->data, szAnd, len ) )
691                 rc = COND_AND;
692             else if( !strncmpiW( str->data, szXor, len ) )
693                 rc = COND_XOR;
694             else if( !strncmpiW( str->data, szEqv, len ) )
695                 rc = COND_EQV;
696             else if( !strncmpiW( str->data, szImp, len ) )
697                 rc = COND_IMP;
698         }
699         else if( (len == 2) && !strncmpiW( 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(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 )
817         return MSICONDITION_NONE;
818
819     cond.package = package;
820     cond.str   = szCondition;
821     cond.n     = 0;
822     cond.result = MSICONDITION_ERROR;
823
824     list_init( &cond.mem );
825
826     if ( !cond_parse( &cond ) )
827         r = cond.result;
828     else
829         r = MSICONDITION_ERROR;
830
831     LIST_FOR_EACH_SAFE( mem, safety, &cond.mem )
832     {
833         /* The tracked memory lives directly after the list struct */
834         void *ptr = mem + 1;
835         if ( r != MSICONDITION_ERROR )
836             WARN( "condition parser failed to free up some memory: %p\n", ptr );
837         cond_free( ptr );
838     }
839
840     TRACE("%i <- %s\n", r, debugstr_w(szCondition));
841     return r;
842 }
843
844 MSICONDITION WINAPI MsiEvaluateConditionW( MSIHANDLE hInstall, LPCWSTR szCondition )
845 {
846     MSIPACKAGE *package;
847     UINT ret;
848
849     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE);
850     if( !package )
851     {
852         HRESULT hr;
853         BSTR condition;
854         IWineMsiRemotePackage *remote_package;
855
856         remote_package = (IWineMsiRemotePackage *)msi_get_remote( hInstall );
857         if (!remote_package)
858             return MSICONDITION_ERROR;
859
860         condition = SysAllocString( szCondition );
861         if (!condition)
862         {
863             IWineMsiRemotePackage_Release( remote_package );
864             return ERROR_OUTOFMEMORY;
865         }
866
867         hr = IWineMsiRemotePackage_EvaluateCondition( remote_package, condition );
868
869         SysFreeString( condition );
870         IWineMsiRemotePackage_Release( remote_package );
871
872         if (FAILED(hr))
873         {
874             if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
875                 return HRESULT_CODE(hr);
876
877             return ERROR_FUNCTION_FAILED;
878         }
879
880         return ERROR_SUCCESS;
881     }
882
883     ret = MSI_EvaluateConditionW( package, szCondition );
884     msiobj_release( &package->hdr );
885     return ret;
886 }
887
888 MSICONDITION WINAPI MsiEvaluateConditionA( MSIHANDLE hInstall, LPCSTR szCondition )
889 {
890     LPWSTR szwCond = NULL;
891     MSICONDITION r;
892
893     szwCond = strdupAtoW( szCondition );
894     if( szCondition && !szwCond )
895         return MSICONDITION_ERROR;
896
897     r = MsiEvaluateConditionW( hInstall, szwCond );
898     msi_free( szwCond );
899     return r;
900 }