msi: Properly handle negative coordinates for mouse events.
[wine] / dlls / msi / sql.y
1 %{
2
3 /*
4  * Implementation of the Microsoft Installer (msi.dll)
5  *
6  * Copyright 2002-2004 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
24 #include "config.h"
25
26 #include <stdarg.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "query.h"
33 #include "wine/list.h"
34 #include "wine/debug.h"
35
36 #define YYLEX_PARAM info
37 #define YYPARSE_PARAM info
38
39 static int sql_error(const char *str);
40
41 WINE_DEFAULT_DEBUG_CHANNEL(msi);
42
43 typedef struct tag_SQL_input
44 {
45     MSIDATABASE *db;
46     LPCWSTR command;
47     DWORD n, len;
48     MSIVIEW **view;  /* view structure for the resulting query */
49     struct list *mem;
50 } SQL_input;
51
52 static LPWSTR SQL_getstring( void *info, struct sql_str *str );
53 static INT SQL_getint( void *info );
54 static int sql_lex( void *SQL_lval, SQL_input *info );
55
56 static void *parser_alloc( void *info, unsigned int sz );
57 static column_info *parser_alloc_column( void *info, LPCWSTR table, LPCWSTR column );
58
59 static BOOL SQL_MarkPrimaryKeys( column_info *cols, column_info *keys);
60
61 static struct expr * EXPR_complex( void *info, struct expr *l, UINT op, struct expr *r );
62 static struct expr * EXPR_column( void *info, column_info *column );
63 static struct expr * EXPR_ival( void *info, int val );
64 static struct expr * EXPR_sval( void *info, struct sql_str * );
65 static struct expr * EXPR_wildcard( void *info );
66
67 %}
68
69 %pure-parser
70
71 %union
72 {
73     struct sql_str str;
74     LPWSTR string;
75     column_info *column_list;
76     MSIVIEW *query;
77     struct expr *expr;
78     USHORT column_type;
79     int integer;
80 }
81
82 %token TK_ABORT TK_AFTER TK_AGG_FUNCTION TK_ALL TK_ALTER TK_AND TK_AS TK_ASC
83 %token TK_BEFORE TK_BEGIN TK_BETWEEN TK_BITAND TK_BITNOT TK_BITOR TK_BY
84 %token TK_CASCADE TK_CASE TK_CHAR TK_CHECK TK_CLUSTER TK_COLLATE TK_COLUMN
85 %token TK_COMMA TK_COMMENT TK_COMMIT TK_CONCAT TK_CONFLICT
86 %token TK_CONSTRAINT TK_COPY TK_CREATE
87 %token TK_DEFAULT TK_DEFERRABLE TK_DEFERRED TK_DELETE TK_DELIMITERS TK_DESC
88 %token TK_DISTINCT TK_DOT TK_DROP TK_EACH
89 %token TK_ELSE TK_END TK_END_OF_FILE TK_EQ TK_EXCEPT TK_EXPLAIN
90 %token TK_FAIL TK_FLOAT TK_FOR TK_FOREIGN TK_FREE TK_FROM TK_FUNCTION
91 %token TK_GE TK_GLOB TK_GROUP TK_GT
92 %token TK_HAVING TK_HOLD
93 %token TK_IGNORE TK_ILLEGAL TK_IMMEDIATE TK_IN TK_INDEX TK_INITIALLY
94 %token <str> TK_ID 
95 %token TK_INSERT TK_INSTEAD TK_INT 
96 %token <str> TK_INTEGER
97 %token TK_INTERSECT TK_INTO TK_IS
98 %token TK_ISNULL
99 %token TK_JOIN TK_JOIN_KW
100 %token TK_KEY
101 %token TK_LE TK_LIKE TK_LIMIT TK_LONG TK_LONGCHAR TK_LP TK_LSHIFT TK_LT
102 %token TK_LOCALIZABLE
103 %token TK_MATCH TK_MINUS
104 %token TK_NE TK_NOT TK_NOTNULL TK_NULL
105 %token TK_OBJECT TK_OF TK_OFFSET TK_ON TK_OR TK_ORACLE_OUTER_JOIN TK_ORDER
106 %token TK_PLUS TK_PRAGMA TK_PRIMARY
107 %token TK_RAISE TK_REFERENCES TK_REM TK_REPLACE TK_RESTRICT TK_ROLLBACK
108 %token TK_ROW TK_RP TK_RSHIFT
109 %token TK_SELECT TK_SEMI TK_SET TK_SHORT TK_SLASH TK_SPACE TK_STAR TK_STATEMENT 
110 %token <str> TK_STRING
111 %token TK_TABLE TK_TEMPORARY TK_THEN TK_TRANSACTION TK_TRIGGER
112 %token TK_UMINUS TK_UNCLOSED_STRING TK_UNION TK_UNIQUE
113 %token TK_UPDATE TK_UPLUS TK_USING
114 %token TK_VACUUM TK_VALUES TK_VIEW
115 %token TK_WHEN TK_WHERE TK_WILDCARD
116
117 /*
118  * These are extra tokens used by the lexer but never seen by the
119  * parser.  We put them in a rule so that the parser generator will
120  * add them to the parse.h output file.
121  *
122  */
123 %nonassoc END_OF_FILE ILLEGAL SPACE UNCLOSED_STRING COMMENT FUNCTION
124           COLUMN AGG_FUNCTION.
125
126 %type <string> table id
127 %type <column_list> selcollist column column_and_type column_def table_def
128 %type <column_list> column_assignment update_assign_list constlist
129 %type <query> query multifrom from fromtable selectfrom unorderedsel
130 %type <query> oneupdate onedelete oneselect onequery onecreate oneinsert onealter
131 %type <expr> expr val column_val const_val
132 %type <column_type> column_type data_type data_type_l data_count
133 %type <integer> number alterop
134
135 /* Reference: http://mates.ms.mff.cuni.cz/oracle/doc/ora815nt/server.815/a67779/operator.htm */
136 %left TK_OR
137 %left TK_AND
138 %left TK_NOT
139 %left TK_EQ TK_NE TK_LT TK_GT TK_LE TK_GE TK_ISNULL TK_LIKE TK_BETWEEN TK_IN
140 %left TK_PLUS TK_MINUS TK_CONCAT
141 %right TK_NEGATION
142
143 %%
144
145 query:
146     onequery
147     {
148         SQL_input* sql = (SQL_input*) info;
149         *sql->view = $1;
150     }
151     ;
152
153 onequery:
154     oneselect
155   | onecreate
156   | oneinsert
157   | oneupdate
158   | onedelete
159   | onealter
160     ;
161
162 oneinsert:
163     TK_INSERT TK_INTO table TK_LP selcollist TK_RP TK_VALUES TK_LP constlist TK_RP
164         {
165             SQL_input *sql = (SQL_input*) info;
166             MSIVIEW *insert = NULL; 
167             UINT r;
168
169             r = INSERT_CreateView( sql->db, &insert, $3, $5, $9, FALSE ); 
170             if( !insert )
171                 YYABORT;
172             $$ = insert;
173         }
174   | TK_INSERT TK_INTO table TK_LP selcollist TK_RP TK_VALUES TK_LP constlist TK_RP TK_TEMPORARY
175         {
176             SQL_input *sql = (SQL_input*) info;
177             MSIVIEW *insert = NULL; 
178
179             INSERT_CreateView( sql->db, &insert, $3, $5, $9, TRUE ); 
180             if( !insert )
181                 YYABORT;
182             $$ = insert;
183         }
184     ;
185
186 onecreate:
187     TK_CREATE TK_TABLE table TK_LP table_def TK_RP
188         {
189             SQL_input* sql = (SQL_input*) info;
190             MSIVIEW *create = NULL; 
191
192             if( !$5 )
193                 YYABORT;
194             CREATE_CreateView( sql->db, &create, $3, $5, FALSE );
195             if( !create )
196                 YYABORT;
197             $$ = create;
198         }
199   | TK_CREATE TK_TABLE table TK_LP table_def TK_RP TK_HOLD
200         {
201             SQL_input* sql = (SQL_input*) info;
202             MSIVIEW *create = NULL; 
203
204             if( !$5 )
205                 YYABORT;
206             CREATE_CreateView( sql->db, &create, $3, $5, TRUE );
207             if( !create )
208                 YYABORT;
209             $$ = create;
210         }
211     ;
212
213 oneupdate:
214     TK_UPDATE table TK_SET update_assign_list TK_WHERE expr
215         {
216             SQL_input* sql = (SQL_input*) info;
217             MSIVIEW *update = NULL; 
218
219             UPDATE_CreateView( sql->db, &update, $2, $4, $6 );
220             if( !update )
221                 YYABORT;
222             $$ = update;
223         }
224     ;
225
226 onedelete:
227     TK_DELETE from
228         {
229             SQL_input* sql = (SQL_input*) info;
230             MSIVIEW *delete = NULL; 
231
232             DELETE_CreateView( sql->db, &delete, $2 );
233             if( !delete )
234                 YYABORT;
235             $$ = delete;
236         }
237     ;
238
239 onealter:
240     TK_ALTER TK_TABLE table alterop
241         {
242             SQL_input* sql = (SQL_input*) info;
243             MSIVIEW *alter = NULL;
244
245             ALTER_CreateView( sql->db, &alter, $3, $4 );
246             if( !alter )
247                 YYABORT;
248             $$ = alter;
249         }
250     ;
251
252 alterop:
253     TK_HOLD
254         {
255             $$ = 1;
256         }
257   | TK_FREE
258         {
259             $$ = -1;
260         }
261   ;
262
263 table_def:
264     column_def TK_PRIMARY TK_KEY selcollist
265         {
266             if( SQL_MarkPrimaryKeys( $1, $4 ) )
267                 $$ = $1;
268             else
269                 $$ = NULL;
270         }
271     ;
272
273 column_def:
274     column_def TK_COMMA column_and_type
275         {
276             column_info *ci;
277
278             for( ci = $1; ci->next; ci = ci->next )
279                 ;
280
281             ci->next = $3;
282             $$ = $1;
283         }
284   | column_and_type
285         {
286             $$ = $1;
287         }
288     ;
289
290 column_and_type:
291     column column_type
292         {
293             $$ = $1;
294             $$->type = $2 | MSITYPE_VALID;
295         }
296     ;
297
298 column_type:
299     data_type_l
300         {
301             $$ = $1;
302         }
303   | data_type_l TK_LOCALIZABLE
304         {
305             $$ = $1 | MSITYPE_LOCALIZABLE;
306         }
307   | data_type_l TK_TEMPORARY
308         {
309             FIXME("temporary column\n");
310         }
311     ;
312
313 data_type_l:
314     data_type
315         {
316             $$ |= MSITYPE_NULLABLE;
317         }
318   | data_type TK_NOT TK_NULL
319         {
320             $$ = $1;
321         }
322     ;
323
324 data_type:
325     TK_CHAR
326         {
327             $$ = MSITYPE_STRING | 1;
328         }
329   | TK_CHAR TK_LP data_count TK_RP
330         {
331             $$ = MSITYPE_STRING | 0x400 | $3;
332         }
333   | TK_LONGCHAR
334         {
335             $$ = 2;
336         }
337   | TK_SHORT
338         {
339             $$ = 2;
340         }
341   | TK_INT
342         {
343             $$ = 2;
344         }
345   | TK_LONG
346         {
347             $$ = 4;
348         }
349   | TK_OBJECT
350         {
351             $$ = MSITYPE_STRING | MSITYPE_VALID;
352         }
353     ;
354
355 data_count:
356     number
357         {
358             if( ( $1 > 255 ) || ( $1 < 0 ) )
359                 YYABORT;
360             $$ = $1;
361         }
362     ;
363
364 oneselect:
365     unorderedsel TK_ORDER TK_BY selcollist
366         {
367             SQL_input* sql = (SQL_input*) info;
368
369             $$ = NULL;
370             if( $4 )
371                 ORDER_CreateView( sql->db, &$$, $1, $4 );
372             else
373                 $$ = $1;
374             if( !$$ )
375                 YYABORT;
376         }
377   | unorderedsel
378     ;
379
380 unorderedsel:
381     TK_SELECT selectfrom
382         {
383             $$ = $2;
384         }
385   | TK_SELECT TK_DISTINCT selectfrom
386         {
387             SQL_input* sql = (SQL_input*) info;
388             UINT r;
389
390             $$ = NULL;
391             r = DISTINCT_CreateView( sql->db, &$$, $3 );
392             if (r != ERROR_SUCCESS)
393             {
394                 $3->ops->delete($3);
395                 YYABORT;
396             }
397         }
398     ;
399
400 selectfrom:
401     selcollist multifrom 
402         {
403             SQL_input* sql = (SQL_input*) info;
404             UINT r;
405
406             $$ = NULL;
407             if( $1 )
408             {
409                 r = SELECT_CreateView( sql->db, &$$, $2, $1 );
410                 if (r != ERROR_SUCCESS)
411                 {
412                     $2->ops->delete($2);
413                     YYABORT;
414                 }
415             }
416             else
417                 $$ = $2;
418         }
419     ;
420
421 selcollist:
422     column 
423   | column TK_COMMA selcollist
424         { 
425             $1->next = $3;
426         }
427   | TK_STAR
428         {
429             $$ = NULL;
430         }
431     ;
432
433 multifrom:
434     from
435   | TK_FROM table TK_COMMA table TK_WHERE expr
436         {
437             SQL_input* sql = (SQL_input*) info;
438             UINT r;
439
440             /* only support inner joins on two tables */
441             r = JOIN_CreateView( sql->db, &$$, $2, $4, $6 );
442             if( r != ERROR_SUCCESS )
443                 YYABORT;
444         }
445     ;
446
447 from:
448     fromtable
449   | fromtable TK_WHERE expr
450         { 
451             SQL_input* sql = (SQL_input*) info;
452             UINT r;
453
454             $$ = NULL;
455             r = WHERE_CreateView( sql->db, &$$, $1, $3 );
456             if( r != ERROR_SUCCESS )
457             {
458                 $1->ops->delete( $1 );
459                 YYABORT;
460             }
461         }
462     ;
463
464 fromtable:
465     TK_FROM table
466         {
467             SQL_input* sql = (SQL_input*) info;
468             UINT r;
469
470             $$ = NULL;
471             r = TABLE_CreateView( sql->db, $2, &$$ );
472             if( r != ERROR_SUCCESS || !$$ )
473                 YYABORT;
474         }
475     ;
476
477 expr:
478     TK_LP expr TK_RP
479         {
480             $$ = $2;
481             if( !$$ )
482                 YYABORT;
483         }
484   | expr TK_AND expr
485         {
486             $$ = EXPR_complex( info, $1, OP_AND, $3 );
487             if( !$$ )
488                 YYABORT;
489         }
490   | expr TK_OR expr
491         {
492             $$ = EXPR_complex( info, $1, OP_OR, $3 );
493             if( !$$ )
494                 YYABORT;
495         }
496   | column_val TK_EQ val
497         {
498             $$ = EXPR_complex( info, $1, OP_EQ, $3 );
499             if( !$$ )
500                 YYABORT;
501         }
502   | column_val TK_GT val
503         {
504             $$ = EXPR_complex( info, $1, OP_GT, $3 );
505             if( !$$ )
506                 YYABORT;
507         }
508   | column_val TK_LT val
509         {
510             $$ = EXPR_complex( info, $1, OP_LT, $3 );
511             if( !$$ )
512                 YYABORT;
513         }
514   | column_val TK_LE val
515         {
516             $$ = EXPR_complex( info, $1, OP_LE, $3 );
517             if( !$$ )
518                 YYABORT;
519         }
520   | column_val TK_GE val
521         {
522             $$ = EXPR_complex( info, $1, OP_GE, $3 );
523             if( !$$ )
524                 YYABORT;
525         }
526   | column_val TK_NE val
527         {
528             $$ = EXPR_complex( info, $1, OP_NE, $3 );
529             if( !$$ )
530                 YYABORT;
531         }
532   | column_val TK_IS TK_NULL
533         {
534             $$ = EXPR_complex( info, $1, OP_ISNULL, NULL );
535             if( !$$ )
536                 YYABORT;
537         }
538   | column_val TK_IS TK_NOT TK_NULL
539         {
540             $$ = EXPR_complex( info, $1, OP_NOTNULL, NULL );
541             if( !$$ )
542                 YYABORT;
543         }
544     ;
545
546 val:
547     column_val
548   | const_val
549     ;
550
551 constlist:
552     const_val
553         {
554             $$ = parser_alloc_column( info, NULL, NULL );
555             if( !$$ )
556                 YYABORT;
557             $$->val = $1;
558         }
559   | const_val TK_COMMA constlist
560         {
561             $$ = parser_alloc_column( info, NULL, NULL );
562             if( !$$ )
563                 YYABORT;
564             $$->val = $1;
565             $$->next = $3;
566         }
567     ;
568
569 update_assign_list:
570     column_assignment
571   | column_assignment TK_COMMA update_assign_list
572         {
573             $$ = $1;
574             $$->next = $3;
575         }
576     ;
577
578 column_assignment:
579     column TK_EQ const_val
580         {
581             $$ = $1;
582             $$->val = $3;
583         }
584     ;
585
586 const_val:
587     number
588         {
589             $$ = EXPR_ival( info, $1 );
590             if( !$$ )
591                 YYABORT;
592         }
593   | TK_MINUS number %prec TK_NEGATION
594         {
595             $$ = EXPR_ival( info, -$2 );
596             if( !$$ )
597                 YYABORT;
598         }
599   | TK_STRING
600         {
601             $$ = EXPR_sval( info, &$1 );
602             if( !$$ )
603                 YYABORT;
604         }
605   | TK_WILDCARD
606         {
607             $$ = EXPR_wildcard( info );
608             if( !$$ )
609                 YYABORT;
610         }
611     ;
612
613 column_val:
614     column 
615         {
616             $$ = EXPR_column( info, $1 );
617             if( !$$ )
618                 YYABORT;
619         }
620     ;
621
622 column:
623     table TK_DOT id
624         {
625             $$ = parser_alloc_column( info, $1, $3 );
626             if( !$$ )
627                 YYABORT;
628         }
629   | id
630         {
631             $$ = parser_alloc_column( info, NULL, $1 );
632             if( !$$ )
633                 YYABORT;
634         }
635     ;
636
637 table:
638     id
639         {
640             $$ = $1;
641         }
642     ;
643
644 id:
645     TK_ID
646         {
647             $$ = SQL_getstring( info, &$1 );
648             if( !$$ )
649                 YYABORT;
650         }
651     ;
652
653 number:
654     TK_INTEGER
655         {
656             $$ = SQL_getint( info );
657         }
658     ;
659
660 %%
661
662 static void *parser_alloc( void *info, unsigned int sz )
663 {
664     SQL_input* sql = (SQL_input*) info;
665     struct list *mem;
666
667     mem = msi_alloc( sizeof (struct list) + sz );
668     list_add_tail( sql->mem, mem );
669     return &mem[1];
670 }
671
672 static column_info *parser_alloc_column( void *info, LPCWSTR table, LPCWSTR column )
673 {
674     column_info *col;
675
676     col = parser_alloc( info, sizeof (*col) );
677     if( col )
678     {
679         col->table = table;
680         col->column = column;
681         col->val = NULL;
682         col->type = 0;
683         col->next = NULL;
684     }
685
686     return col;
687 }
688
689 static int sql_lex( void *SQL_lval, SQL_input *sql )
690 {
691     int token;
692     struct sql_str * str = SQL_lval;
693
694     do
695     {
696         sql->n += sql->len;
697         if( ! sql->command[sql->n] )
698             return 0;  /* end of input */
699
700         /* TRACE("string : %s\n", debugstr_w(&sql->command[sql->n])); */
701         sql->len = sqliteGetToken( &sql->command[sql->n], &token );
702         if( sql->len==0 )
703             break;
704         str->data = &sql->command[sql->n];
705         str->len = sql->len;
706     }
707     while( token == TK_SPACE );
708
709     /* TRACE("token : %d (%s)\n", token, debugstr_wn(&sql->command[sql->n], sql->len)); */
710     
711     return token;
712 }
713
714 LPWSTR SQL_getstring( void *info, struct sql_str *strdata )
715 {
716     LPCWSTR p = strdata->data;
717     UINT len = strdata->len;
718     LPWSTR str;
719
720     /* if there's quotes, remove them */
721     if( ( (p[0]=='`') && (p[len-1]=='`') ) || 
722         ( (p[0]=='\'') && (p[len-1]=='\'') ) )
723     {
724         p++;
725         len -= 2;
726     }
727     str = parser_alloc( info, (len + 1)*sizeof(WCHAR) );
728     if( !str )
729         return str;
730     memcpy( str, p, len*sizeof(WCHAR) );
731     str[len]=0;
732
733     return str;
734 }
735
736 INT SQL_getint( void *info )
737 {
738     SQL_input* sql = (SQL_input*) info;
739     LPCWSTR p = &sql->command[sql->n];
740     INT i, r = 0;
741
742     for( i=0; i<sql->len; i++ )
743     {
744         if( '0' > p[i] || '9' < p[i] )
745         {
746             ERR("should only be numbers here!\n");
747             break;
748         }
749         r = (p[i]-'0') + r*10;
750     }
751
752     return r;
753 }
754
755 static int sql_error( const char *str )
756 {
757     return 0;
758 }
759
760 static struct expr * EXPR_wildcard( void *info )
761 {
762     struct expr *e = parser_alloc( info, sizeof *e );
763     if( e )
764     {
765         e->type = EXPR_WILDCARD;
766     }
767     return e;
768 }
769
770 static struct expr * EXPR_complex( void *info, struct expr *l, UINT op, struct expr *r )
771 {
772     struct expr *e = parser_alloc( info, sizeof *e );
773     if( e )
774     {
775         e->type = EXPR_COMPLEX;
776         e->u.expr.left = l;
777         e->u.expr.op = op;
778         e->u.expr.right = r;
779     }
780     return e;
781 }
782
783 static struct expr * EXPR_column( void *info, column_info *column )
784 {
785     struct expr *e = parser_alloc( info, sizeof *e );
786     if( e )
787     {
788         e->type = EXPR_COLUMN;
789         e->u.sval = column->column;
790     }
791     return e;
792 }
793
794 static struct expr * EXPR_ival( void *info, int val )
795 {
796     struct expr *e = parser_alloc( info, sizeof *e );
797     if( e )
798     {
799         e->type = EXPR_IVAL;
800         e->u.ival = val;
801     }
802     return e;
803 }
804
805 static struct expr * EXPR_sval( void *info, struct sql_str *str )
806 {
807     struct expr *e = parser_alloc( info, sizeof *e );
808     if( e )
809     {
810         e->type = EXPR_SVAL;
811         e->u.sval = SQL_getstring( info, str );
812     }
813     return e;
814 }
815
816 static BOOL SQL_MarkPrimaryKeys( column_info *cols,
817                                  column_info *keys )
818 {
819     column_info *k;
820     BOOL found = TRUE;
821
822     for( k = keys; k && found; k = k->next )
823     {
824         column_info *c;
825
826         found = FALSE;
827         for( c = cols; c && !found; c = c->next )
828         {
829              if( lstrcmpW( k->column, c->column ) )
830                  continue;
831              c->type |= MSITYPE_KEY;
832              found = TRUE;
833         }
834     }
835
836     return found;
837 }
838
839 UINT MSI_ParseSQL( MSIDATABASE *db, LPCWSTR command, MSIVIEW **phview,
840                    struct list *mem )
841 {
842     SQL_input sql;
843     int r;
844
845     *phview = NULL;
846
847     sql.db = db;
848     sql.command = command;
849     sql.n = 0;
850     sql.len = 0;
851     sql.view = phview;
852     sql.mem = mem;
853
854     r = sql_parse(&sql);
855
856     TRACE("Parse returned %d\n", r);
857     if( r )
858     {
859         *sql.view = NULL;
860         return ERROR_BAD_QUERY_SYNTAX;
861     }
862
863     return ERROR_SUCCESS;
864 }