Tweak the API documentation to silence winapi_check warnings.
[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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22
23 #include "config.h"
24
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "wine/debug.h"
32 #include "wine/unicode.h"
33
34 #include "msi.h"
35 #include "msiquery.h"
36 #include "msipriv.h"
37
38 #define YYLEX_PARAM info
39 #define YYPARSE_PARAM info
40
41 static int COND_error(char *str);
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 } COND_input;
52
53 struct cond_str {
54     LPCWSTR data;
55     INT len;
56 };
57
58 static LPWSTR COND_GetString( struct cond_str *str );
59 static LPWSTR COND_GetLiteral( struct cond_str *str );
60 static int COND_lex( void *COND_lval, COND_input *info);
61
62 typedef INT (*comp_int)(INT a, INT b);
63 typedef INT (*comp_str)(LPWSTR a, LPWSTR b, BOOL caseless);
64 typedef INT (*comp_m1)(LPWSTR a,int b);
65 typedef INT (*comp_m2)(int a,LPWSTR b);
66
67 static INT comp_lt_i(INT a, INT b);
68 static INT comp_gt_i(INT a, INT b);
69 static INT comp_le_i(INT a, INT b);
70 static INT comp_ge_i(INT a, INT b);
71 static INT comp_eq_i(INT a, INT b);
72 static INT comp_ne_i(INT a, INT b);
73 static INT comp_bitand(INT a, INT b);
74 static INT comp_highcomp(INT a, INT b);
75 static INT comp_lowcomp(INT a, INT b);
76
77 static INT comp_eq_s(LPWSTR a, LPWSTR b, BOOL casless);
78 static INT comp_ne_s(LPWSTR a, LPWSTR b, BOOL casless);
79 static INT comp_lt_s(LPWSTR a, LPWSTR b, BOOL casless);
80 static INT comp_gt_s(LPWSTR a, LPWSTR b, BOOL casless);
81 static INT comp_le_s(LPWSTR a, LPWSTR b, BOOL casless);
82 static INT comp_ge_s(LPWSTR a, LPWSTR b, BOOL casless);
83 static INT comp_substring(LPWSTR a, LPWSTR b, BOOL casless);
84 static INT comp_start(LPWSTR a, LPWSTR b, BOOL casless);
85 static INT comp_end(LPWSTR a, LPWSTR b, BOOL casless);
86
87 static INT comp_eq_m1(LPWSTR a, INT b);
88 static INT comp_ne_m1(LPWSTR a, INT b);
89 static INT comp_lt_m1(LPWSTR a, INT b);
90 static INT comp_gt_m1(LPWSTR a, INT b);
91 static INT comp_le_m1(LPWSTR a, INT b);
92 static INT comp_ge_m1(LPWSTR a, INT b);
93
94 static INT comp_eq_m2(INT a, LPWSTR b);
95 static INT comp_ne_m2(INT a, LPWSTR b);
96 static INT comp_lt_m2(INT a, LPWSTR b);
97 static INT comp_gt_m2(INT a, LPWSTR b);
98 static INT comp_le_m2(INT a, LPWSTR b);
99 static INT comp_ge_m2(INT a, LPWSTR b);
100
101 %}
102
103 %pure-parser
104
105 %union
106 {
107     struct cond_str str;
108     LPWSTR    string;
109     INT       value;
110     comp_int  fn_comp_int;
111     comp_str  fn_comp_str;
112     comp_m1   fn_comp_m1;
113     comp_m2   fn_comp_m2;
114 }
115
116 %token COND_SPACE COND_EOF COND_SPACE
117 %token COND_OR COND_AND COND_NOT
118 %token COND_LT COND_GT COND_EQ 
119 %token COND_LPAR COND_RPAR COND_TILDA
120 %token COND_PERCENT COND_DOLLARS COND_QUESTION COND_AMPER COND_EXCLAM
121 %token <str> COND_IDENT <str> COND_NUMBER <str> COND_LITER
122
123 %nonassoc COND_EOF COND_ERROR
124
125 %type <value> expression boolean_term boolean_factor 
126 %type <value> term value_i symbol_i integer
127 %type <string> identifier value_s symbol_s literal
128 %type <fn_comp_int> comp_op_i
129 %type <fn_comp_str> comp_op_s 
130 %type <fn_comp_m1>  comp_op_m1 
131 %type <fn_comp_m2>  comp_op_m2
132
133 %%
134
135 condition:
136     expression
137         {
138             COND_input* cond = (COND_input*) info;
139             cond->result = $1;
140         }
141     ;
142
143 expression:
144     boolean_term 
145         {
146             $$ = $1;
147         }
148   | boolean_term COND_OR expression
149         {
150             $$ = $1 || $3;
151         }
152     ;
153
154 boolean_term:
155     boolean_factor
156         {
157             $$ = $1;
158         }
159     | boolean_term COND_AND boolean_factor
160         {
161             $$ = $1 && $3;
162         }
163     ;
164
165 boolean_factor:
166     term
167         {
168             $$ = $1;
169         }
170   | COND_NOT term
171         {
172             $$ = ! $2;
173         }
174     ;
175
176
177 term:
178     value_i
179         {
180             $$ = $1;
181         }
182   | value_s
183         {
184             $$ = $1[0] ? MSICONDITION_TRUE : MSICONDITION_FALSE;
185         }
186   | value_i comp_op_i value_i
187         {
188             $$ = $2( $1, $3 );
189         }
190   | value_s comp_op_s value_s
191         {
192             $$ = $2( $1, $3, FALSE );
193         }
194   | value_s COND_TILDA comp_op_s value_s
195         {
196             $$ = $3( $1, $4, TRUE );
197         }
198   | value_s comp_op_m1 value_i
199         {
200             $$ = $2( $1, $3 );
201         }
202   | value_i comp_op_m2 value_s
203         {
204             $$ = $2( $1, $3 );
205         }
206   | COND_LPAR expression COND_RPAR
207         {
208             $$ = $2;
209         }
210     ;
211
212 comp_op_i:
213     /* common functions */
214    COND_EQ
215         {
216             $$ = comp_eq_i;
217         }
218   | COND_LT COND_GT
219         {
220             $$ = comp_ne_i;
221         }
222   | COND_LT
223         {
224             $$ = comp_lt_i;
225         }
226   | COND_GT
227         {
228             $$ = comp_gt_i;
229         }
230   | COND_LT COND_EQ
231         {
232             $$ = comp_le_i;
233         }
234   | COND_GT COND_EQ
235         {
236             $$ = comp_ge_i;
237         }
238   /*Int only*/
239   | COND_GT COND_LT
240         {
241             $$ = comp_bitand;
242         }
243   | COND_LT COND_LT
244         {
245             $$ = comp_highcomp;
246         }
247   | COND_GT COND_GT
248         {
249             $$ = comp_lowcomp;
250         }
251     ;
252
253 comp_op_s:
254     /* common functions */
255    COND_EQ
256         {
257             $$ = comp_eq_s;
258         }
259   | COND_LT COND_GT
260         {
261             $$ = comp_ne_s;
262         }
263   | COND_LT
264         {
265             $$ = comp_lt_s;
266         }
267   | COND_GT
268         {
269             $$ = comp_gt_s;
270         }
271   | COND_LT COND_EQ
272         {
273             $$ = comp_le_s;
274         }
275   | COND_GT COND_EQ
276         {
277             $$ = comp_ge_s;
278         }
279   /*string only*/
280   | COND_GT COND_LT
281         {
282             $$ = comp_substring;
283         }
284   | COND_LT COND_LT
285         {
286             $$ = comp_start;
287         }
288   | COND_GT COND_GT
289         {
290             $$ = comp_end;
291         }
292     ;
293
294 comp_op_m1:
295     /* common functions */
296    COND_EQ
297         {
298             $$ = comp_eq_m1;
299         }
300   | COND_LT COND_GT
301         {
302             $$ = comp_ne_m1;
303         }
304   | COND_LT
305         {
306             $$ = comp_lt_m1;
307         }
308   | COND_GT
309         {
310             $$ = comp_gt_m1;
311         }
312   | COND_LT COND_EQ
313         {
314             $$ = comp_le_m1;
315         }
316   | COND_GT COND_EQ
317         {
318             $$ = comp_ge_m1;
319         }
320   /*Not valid for mixed compares*/
321   | COND_GT COND_LT
322         {
323             $$ = 0;
324         }
325   | COND_LT COND_LT
326         {
327             $$ = 0;
328         }
329   | COND_GT COND_GT
330         {
331             $$ = 0;
332         }
333     ;
334
335 comp_op_m2:
336     /* common functions */
337    COND_EQ
338         {
339             $$ = comp_eq_m2;
340         }
341   | COND_LT COND_GT
342         {
343             $$ = comp_ne_m2;
344         }
345   | COND_LT
346         {
347             $$ = comp_lt_m2;
348         }
349   | COND_GT
350         {
351             $$ = comp_gt_m2;
352         }
353   | COND_LT COND_EQ
354         {
355             $$ = comp_le_m2;
356         }
357   | COND_GT COND_EQ
358         {
359             $$ = comp_ge_m2;
360         }
361   /*Not valid for mixed compares*/
362   | COND_GT COND_LT
363         {
364             $$ = 0;
365         }
366   | COND_LT COND_LT
367         {
368             $$ = 0;
369         }
370   | COND_GT COND_GT
371         {
372             $$ = 0;
373         }
374     ;
375
376 value_i:
377     symbol_i
378         {
379             $$ = $1;
380         }
381   | integer
382         {
383             $$ = $1;
384         }
385     ;
386
387 value_s:
388   symbol_s
389     {
390         $$ = $1;
391     } 
392   | literal
393     {
394         $$ = $1;
395     }
396     ;
397
398 literal:
399     COND_LITER
400         {
401             $$ = COND_GetLiteral(&$1);
402             if( !$$ )
403                 YYABORT;
404         }
405     ;
406
407 symbol_i:
408     COND_DOLLARS identifier
409         {
410             COND_input* cond = (COND_input*) info;
411             INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
412       
413             MSI_GetComponentStateW(cond->package, $2, &install, &action );
414             $$ = action;
415             HeapFree( GetProcessHeap(), 0, $2 );
416         }
417   | COND_QUESTION identifier
418         {
419             COND_input* cond = (COND_input*) info;
420             INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
421       
422             MSI_GetComponentStateW(cond->package, $2, &install, &action );
423             $$ = install;
424             HeapFree( GetProcessHeap(), 0, $2 );
425         }
426   | COND_AMPER identifier
427         {
428             COND_input* cond = (COND_input*) info;
429             INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
430       
431             MSI_GetFeatureStateW(cond->package, $2, &install, &action );
432             $$ = action;
433             HeapFree( GetProcessHeap(), 0, $2 );
434         }
435   | COND_EXCLAM identifier
436         {
437             COND_input* cond = (COND_input*) info;
438             INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
439       
440             MSI_GetFeatureStateW(cond->package, $2, &install, &action );
441             $$ = install;
442             HeapFree( GetProcessHeap(), 0, $2 );
443         }
444     ;
445
446 symbol_s:
447     identifier
448         {
449             DWORD sz;
450             COND_input* cond = (COND_input*) info;
451
452             sz = 0;
453             MSI_GetPropertyW(cond->package, $1, NULL, &sz);
454             if (sz == 0)
455             {
456                 $$ = HeapAlloc( GetProcessHeap(), 0 ,sizeof(WCHAR));
457                 $$[0] = 0;
458             }
459             else
460             {
461                 sz ++;
462                 $$ = HeapAlloc( GetProcessHeap(), 0, sz*sizeof (WCHAR) );
463
464                 /* Lookup the identifier */
465
466                 MSI_GetPropertyW(cond->package,$1,$$,&sz);
467             }
468             HeapFree( GetProcessHeap(), 0, $1 );
469         }
470     | COND_PERCENT identifier
471         {
472             UINT len = GetEnvironmentVariableW( $2, NULL, 0 );
473             if( len++ )
474             {
475                 $$ = HeapAlloc( GetProcessHeap(), 0, len*sizeof (WCHAR) );
476                 if( $$ )
477                     GetEnvironmentVariableW( $2, $$, len );
478             }
479             HeapFree( GetProcessHeap(), 0, $2 );
480         }
481     ;
482
483 identifier:
484     COND_IDENT
485         {
486             $$ = COND_GetString(&$1);
487             if( !$$ )
488                 YYABORT;
489         }
490     ;
491
492 integer:
493     COND_NUMBER
494         {
495             LPWSTR szNum = COND_GetString(&$1);
496             if( !szNum )
497                 YYABORT;
498             $$ = atoiW( szNum );
499             HeapFree( GetProcessHeap(), 0, szNum );
500         }
501     ;
502
503 %%
504
505
506 static int COND_IsAlpha( WCHAR x )
507 {
508     return( ( ( x >= 'A' ) && ( x <= 'Z' ) ) ||
509             ( ( x >= 'a' ) && ( x <= 'z' ) ) ||
510             ( ( x == '_' ) ) );
511 }
512
513 static int COND_IsNumber( WCHAR x )
514 {
515     return( (( x >= '0' ) && ( x <= '9' ))  || (x =='-') || (x =='.') );
516 }
517
518
519 /* the mess of comparison functions */
520
521 static INT comp_lt_i(INT a, INT b)
522 { return (a < b); }
523 static INT comp_gt_i(INT a, INT b)
524 { return (a > b); }
525 static INT comp_le_i(INT a, INT b)
526 { return (a <= b); }
527 static INT comp_ge_i(INT a, INT b)
528 { return (a >= b); }
529 static INT comp_eq_i(INT a, INT b)
530 { return (a == b); }
531 static INT comp_ne_i(INT a, INT b)
532 { return (a != b); }
533 static INT comp_bitand(INT a, INT b)
534 { return a & b;}
535 static INT comp_highcomp(INT a, INT b)
536 { return HIWORD(a)==b; }
537 static INT comp_lowcomp(INT a, INT b)
538 { return LOWORD(a)==b; }
539
540 static INT comp_eq_s(LPWSTR a, LPWSTR b, BOOL casless)
541 { if (casless) return !strcmpiW(a,b); else return !strcmpW(a,b);}
542 static INT comp_ne_s(LPWSTR a, LPWSTR b, BOOL casless)
543 { if (casless) return strcmpiW(a,b); else  return strcmpW(a,b);}
544 static INT comp_lt_s(LPWSTR a, LPWSTR b, BOOL casless)
545 { if (casless) return strcmpiW(a,b)<0; else return strcmpW(a,b)<0;}
546 static INT comp_gt_s(LPWSTR a, LPWSTR b, BOOL casless)
547 { if (casless) return strcmpiW(a,b)>0; else return strcmpW(a,b)>0;}
548 static INT comp_le_s(LPWSTR a, LPWSTR b, BOOL casless)
549 { if (casless) return strcmpiW(a,b)<=0; else return strcmpW(a,b)<=0;}
550 static INT comp_ge_s(LPWSTR a, LPWSTR b, BOOL casless)
551 { if (casless) return strcmpiW(a,b)>=0; else return  strcmpW(a,b)>=0;}
552 static INT comp_substring(LPWSTR a, LPWSTR b, BOOL casless)
553 /* ERROR NOT WORKING REWRITE */
554 { if (casless) return strstrW(a,b)!=NULL; else return strstrW(a,b)!=NULL;}
555 static INT comp_start(LPWSTR a, LPWSTR b, BOOL casless)
556 { if (casless) return strncmpiW(a,b,strlenW(b))==0; 
557   else return strncmpW(a,b,strlenW(b))==0;}
558 static INT comp_end(LPWSTR a, LPWSTR b, BOOL casless)
559
560     int i = strlenW(a); 
561     int j = strlenW(b); 
562     if (j>i)
563         return 0;
564     if (casless) return (!strcmpiW(&a[i-j-1],b));
565     else  return (!strcmpW(&a[i-j-1],b));
566 }
567
568
569 static INT comp_eq_m1(LPWSTR a, INT b)
570 { if (COND_IsNumber(a[0])) return atoiW(a)==b; else return 0;}
571 static INT comp_ne_m1(LPWSTR a, INT b)
572 { if (COND_IsNumber(a[0])) return atoiW(a)!=b; else return 1;}
573 static INT comp_lt_m1(LPWSTR a, INT b)
574 { if (COND_IsNumber(a[0])) return atoiW(a)<b; else return 0;}
575 static INT comp_gt_m1(LPWSTR a, INT b)
576 { if (COND_IsNumber(a[0])) return atoiW(a)>b; else return 0;}
577 static INT comp_le_m1(LPWSTR a, INT b)
578 { if (COND_IsNumber(a[0])) return atoiW(a)<=b; else return 0;}
579 static INT comp_ge_m1(LPWSTR a, INT b)
580 { if (COND_IsNumber(a[0])) return atoiW(a)>=b; else return 0;}
581
582 static INT comp_eq_m2(INT a, LPWSTR b)
583 { if (COND_IsNumber(b[0])) return a == atoiW(b); else return 0;}
584 static INT comp_ne_m2(INT a, LPWSTR b)
585 { if (COND_IsNumber(b[0])) return a != atoiW(b); else return 1;}
586 static INT comp_lt_m2(INT a, LPWSTR b)
587 { if (COND_IsNumber(b[0])) return a < atoiW(b); else return 0;}
588 static INT comp_gt_m2(INT a, LPWSTR b)
589 { if (COND_IsNumber(b[0])) return a > atoiW(b); else return 0;}
590 static INT comp_le_m2(INT a, LPWSTR b)
591 { if (COND_IsNumber(b[0])) return a <= atoiW(b); else return 0;}
592 static INT comp_ge_m2(INT a, LPWSTR b)
593 { if (COND_IsNumber(b[0])) return a >= atoiW(b); else return 0;}
594
595
596
597 static int COND_IsIdent( WCHAR x )
598 {
599     return( COND_IsAlpha( x ) || COND_IsNumber( x ) || ( x == '_' ) 
600             || ( x == '#' ) || (x == '.') );
601 }
602
603 static int COND_GetOne( struct cond_str *str, COND_input *cond )
604 {
605     static const WCHAR szNot[] = {'N','O','T',0};
606     static const WCHAR szAnd[] = {'A','N','D',0};
607     static const WCHAR szOr[] = {'O','R',0};
608     WCHAR ch;
609     int rc, len = 1;
610
611     str->data = &cond->str[cond->n];
612
613     ch = str->data[0];
614     switch( ch )
615     {
616     case 0: return 0;
617     case '(': rc = COND_LPAR; break;
618     case ')': rc = COND_RPAR; break;
619     case '&': rc = COND_AMPER; break;
620     case '!': rc = COND_EXCLAM; break;
621     case '$': rc = COND_DOLLARS; break;
622     case '?': rc = COND_QUESTION; break;
623     case '%': rc = COND_PERCENT; break;
624     case ' ': rc = COND_SPACE; break;
625     case '=': rc = COND_EQ; break;
626     case '~': rc = COND_TILDA; break;
627     case '<': rc = COND_LT; break;
628     case '>': rc = COND_GT; break;
629     case '"':
630         {
631             const WCHAR *ch2 = str->data + 1;
632
633
634             while ( *ch2 && *ch2 != '"' )
635                 ++ch2;
636             if (*ch2 == '"')
637             {
638                 len = ch2 - str->data + 1;
639                 rc = COND_LITER;
640                 break;
641             }
642         }
643         ERR("Unterminated string\n");
644         rc = COND_ERROR;
645         break;
646     default: 
647         if( COND_IsAlpha( ch ) )
648         {
649             while( COND_IsIdent( str->data[len] ) )
650                 len++;
651             rc = COND_IDENT;
652             break;
653         }
654
655         if( COND_IsNumber( ch ) )
656         {
657             while( COND_IsNumber( str->data[len] ) )
658                 len++;
659             rc = COND_NUMBER;
660             break;
661         }
662
663         ERR("Got unknown character %c(%x)\n",ch,ch);
664         rc = COND_ERROR;
665         break;
666     }
667
668     /* keyword identifiers */
669     if( rc == COND_IDENT )
670     {
671         if( (len==3) && (strncmpiW(str->data,szNot,len)==0) )
672             rc = COND_NOT;
673         else if( (len==3) && (strncmpiW(str->data,szAnd,len)==0) )
674             rc = COND_AND;
675         else if( (len==2) && (strncmpiW(str->data,szOr,len)==0) )
676             rc = COND_OR;
677     }
678
679     cond->n += len;
680     str->len = len;
681
682     return rc;
683 }
684
685 static int COND_lex( void *COND_lval, COND_input *cond )
686 {
687     int rc;
688     struct cond_str *str = COND_lval;
689
690     do {
691         rc = COND_GetOne( str, cond );
692     } while (rc == COND_SPACE);
693     
694     return rc;
695 }
696
697 static LPWSTR COND_GetString( struct cond_str *str )
698 {
699     LPWSTR ret;
700
701     ret = HeapAlloc( GetProcessHeap(), 0, (str->len+1) * sizeof (WCHAR) );
702     if( ret )
703     {
704         memcpy( ret, str->data, str->len * sizeof(WCHAR));
705         ret[str->len]=0;
706     }
707     TRACE("Got identifier %s\n",debugstr_w(ret));
708     return ret;
709 }
710
711 static LPWSTR COND_GetLiteral( struct cond_str *str )
712 {
713     LPWSTR ret;
714
715     ret = HeapAlloc( GetProcessHeap(), 0, (str->len-1) * sizeof (WCHAR) );
716     if( ret )
717     {
718         memcpy( ret, str->data+1, (str->len-2) * sizeof(WCHAR) );
719         ret[str->len - 2]=0;
720     }
721     TRACE("Got literal %s\n",debugstr_w(ret));
722     return ret;
723 }
724
725 static int COND_error(char *str)
726 {
727     return 0;
728 }
729
730 MSICONDITION MSI_EvaluateConditionW( MSIPACKAGE *package, LPCWSTR szCondition )
731 {
732     COND_input cond;
733     MSICONDITION r;
734
735     cond.package = package;
736     cond.str   = szCondition;
737     cond.n     = 0;
738     cond.result = -1;
739     
740     TRACE("Evaluating %s\n",debugstr_w(szCondition));    
741
742     if( szCondition && !COND_parse( &cond ) )
743         r = cond.result;
744     else
745         r = MSICONDITION_ERROR;
746
747     TRACE("Evaluates to %i\n",r);
748     return r;
749 }
750
751 MSICONDITION WINAPI MsiEvaluateConditionW( MSIHANDLE hInstall, LPCWSTR szCondition )
752 {
753     MSIPACKAGE *package;
754     UINT ret;
755
756     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE);
757     if( !package)
758         return ERROR_INVALID_HANDLE;
759     ret = MSI_EvaluateConditionW( package, szCondition );
760     msiobj_release( &package->hdr );
761     return ret;
762 }
763
764 MSICONDITION WINAPI MsiEvaluateConditionA( MSIHANDLE hInstall, LPCSTR szCondition )
765 {
766     LPWSTR szwCond = NULL;
767     MSICONDITION r;
768
769     if( szCondition )
770     {
771         UINT len = MultiByteToWideChar( CP_ACP, 0, szCondition, -1, NULL, 0 );
772         szwCond = HeapAlloc( GetProcessHeap(), 0, len * sizeof (WCHAR) );
773         MultiByteToWideChar( CP_ACP, 0, szCondition, -1, szwCond, len );
774     }
775
776     r = MsiEvaluateConditionW( hInstall, szwCond );
777
778     HeapFree( GetProcessHeap(), 0, szwCond );
779
780     return r;
781 }