mirror of
https://github.com/reactos/reactos.git
synced 2024-10-31 03:48:17 +00:00
1017 lines
22 KiB
Plaintext
1017 lines
22 KiB
Plaintext
%{
|
|
|
|
/*
|
|
* Implementation of the Microsoft Installer (msi.dll)
|
|
*
|
|
* Copyright 2002-2004 Mike McCormack for CodeWeavers
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
|
|
#include "config.h"
|
|
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "query.h"
|
|
#include "wine/list.h"
|
|
#include "wine/debug.h"
|
|
#include "wine/unicode.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(msi);
|
|
|
|
static UINT SQL_getstring( void *info, const struct sql_str *strdata, LPWSTR *str );
|
|
static INT SQL_getint( void *info );
|
|
static int sql_lex( void *SQL_lval, SQL_input *info );
|
|
static int sql_error( SQL_input *info, const char *str);
|
|
|
|
static LPWSTR parser_add_table( void *info, LPCWSTR list, LPCWSTR table );
|
|
static void *parser_alloc( void *info, unsigned int sz );
|
|
static column_info *parser_alloc_column( void *info, LPCWSTR table, LPCWSTR column );
|
|
|
|
static BOOL SQL_MarkPrimaryKeys( column_info **cols, column_info *keys);
|
|
|
|
static struct expr * EXPR_complex( void *info, struct expr *l, UINT op, struct expr *r );
|
|
static struct expr * EXPR_unary( void *info, struct expr *l, UINT op );
|
|
static struct expr * EXPR_column( void *info, const column_info *column );
|
|
static struct expr * EXPR_ival( void *info, int val );
|
|
static struct expr * EXPR_sval( void *info, const struct sql_str *str );
|
|
static struct expr * EXPR_wildcard( void *info );
|
|
|
|
#define PARSER_BUBBLE_UP_VIEW( sql, result, current_view ) \
|
|
*sql->view = current_view; \
|
|
result = current_view
|
|
|
|
%}
|
|
|
|
%lex-param { SQL_input *info }
|
|
%parse-param { SQL_input *info }
|
|
%pure-parser
|
|
|
|
%union
|
|
{
|
|
struct sql_str str;
|
|
LPWSTR string;
|
|
column_info *column_list;
|
|
MSIVIEW *query;
|
|
struct expr *expr;
|
|
USHORT column_type;
|
|
int integer;
|
|
}
|
|
|
|
%token TK_ALTER TK_AND TK_BY TK_CHAR TK_COMMA TK_CREATE TK_DELETE TK_DROP
|
|
%token TK_DISTINCT TK_DOT TK_EQ TK_FREE TK_FROM TK_GE TK_GT TK_HOLD TK_ADD
|
|
%token <str> TK_ID
|
|
%token TK_ILLEGAL TK_INSERT TK_INT
|
|
%token <str> TK_INTEGER
|
|
%token TK_INTO TK_IS TK_KEY TK_LE TK_LONG TK_LONGCHAR TK_LP TK_LT
|
|
%token TK_LOCALIZABLE TK_MINUS TK_NE TK_NOT TK_NULL
|
|
%token TK_OBJECT TK_OR TK_ORDER TK_PRIMARY TK_RP
|
|
%token TK_SELECT TK_SET TK_SHORT TK_SPACE TK_STAR
|
|
%token <str> TK_STRING
|
|
%token TK_TABLE TK_TEMPORARY TK_UPDATE TK_VALUES TK_WHERE TK_WILDCARD
|
|
|
|
/*
|
|
* These are extra tokens used by the lexer but never seen by the
|
|
* parser. We put them in a rule so that the parser generator will
|
|
* add them to the parse.h output file.
|
|
*
|
|
*/
|
|
%nonassoc END_OF_FILE ILLEGAL SPACE UNCLOSED_STRING COMMENT FUNCTION
|
|
COLUMN AGG_FUNCTION.
|
|
|
|
%type <string> table tablelist id string
|
|
%type <column_list> selcollist collist selcolumn column column_and_type column_def table_def
|
|
%type <column_list> column_assignment update_assign_list constlist
|
|
%type <query> query from selectfrom unorderdfrom
|
|
%type <query> oneupdate onedelete oneselect onequery onecreate oneinsert onealter onedrop
|
|
%type <expr> expr val column_val const_val
|
|
%type <column_type> column_type data_type data_type_l data_count
|
|
%type <integer> number alterop
|
|
|
|
%left TK_OR
|
|
%left TK_AND
|
|
%left TK_NOT
|
|
%left TK_EQ TK_NE TK_LT TK_GT TK_LE TK_GE TK_LIKE
|
|
%right TK_NEGATION
|
|
|
|
%%
|
|
|
|
query:
|
|
onequery
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
*sql->view = $1;
|
|
}
|
|
;
|
|
|
|
onequery:
|
|
oneselect
|
|
| onecreate
|
|
| oneinsert
|
|
| oneupdate
|
|
| onedelete
|
|
| onealter
|
|
| onedrop
|
|
;
|
|
|
|
oneinsert:
|
|
TK_INSERT TK_INTO table TK_LP collist TK_RP TK_VALUES TK_LP constlist TK_RP
|
|
{
|
|
SQL_input *sql = (SQL_input*) info;
|
|
MSIVIEW *insert = NULL;
|
|
|
|
INSERT_CreateView( sql->db, &insert, $3, $5, $9, FALSE );
|
|
if( !insert )
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, insert );
|
|
}
|
|
| TK_INSERT TK_INTO table TK_LP collist TK_RP TK_VALUES TK_LP constlist TK_RP TK_TEMPORARY
|
|
{
|
|
SQL_input *sql = (SQL_input*) info;
|
|
MSIVIEW *insert = NULL;
|
|
|
|
INSERT_CreateView( sql->db, &insert, $3, $5, $9, TRUE );
|
|
if( !insert )
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, insert );
|
|
}
|
|
;
|
|
|
|
onecreate:
|
|
TK_CREATE TK_TABLE table TK_LP table_def TK_RP
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
MSIVIEW *create = NULL;
|
|
UINT r;
|
|
|
|
if( !$5 )
|
|
YYABORT;
|
|
r = CREATE_CreateView( sql->db, &create, $3, $5, FALSE );
|
|
if( !create )
|
|
{
|
|
sql->r = r;
|
|
YYABORT;
|
|
}
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, create );
|
|
}
|
|
| TK_CREATE TK_TABLE table TK_LP table_def TK_RP TK_HOLD
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
MSIVIEW *create = NULL;
|
|
|
|
if( !$5 )
|
|
YYABORT;
|
|
CREATE_CreateView( sql->db, &create, $3, $5, TRUE );
|
|
if( !create )
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, create );
|
|
}
|
|
;
|
|
|
|
oneupdate:
|
|
TK_UPDATE table TK_SET update_assign_list TK_WHERE expr
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
MSIVIEW *update = NULL;
|
|
|
|
UPDATE_CreateView( sql->db, &update, $2, $4, $6 );
|
|
if( !update )
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, update );
|
|
}
|
|
| TK_UPDATE table TK_SET update_assign_list
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
MSIVIEW *update = NULL;
|
|
|
|
UPDATE_CreateView( sql->db, &update, $2, $4, NULL );
|
|
if( !update )
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, update );
|
|
}
|
|
;
|
|
|
|
onedelete:
|
|
TK_DELETE from
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
MSIVIEW *delete = NULL;
|
|
|
|
DELETE_CreateView( sql->db, &delete, $2 );
|
|
if( !delete )
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, delete );
|
|
}
|
|
;
|
|
|
|
onealter:
|
|
TK_ALTER TK_TABLE table alterop
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
MSIVIEW *alter = NULL;
|
|
|
|
ALTER_CreateView( sql->db, &alter, $3, NULL, $4 );
|
|
if( !alter )
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, alter );
|
|
}
|
|
| TK_ALTER TK_TABLE table TK_ADD column_and_type
|
|
{
|
|
SQL_input *sql = (SQL_input *)info;
|
|
MSIVIEW *alter = NULL;
|
|
|
|
ALTER_CreateView( sql->db, &alter, $3, $5, 0 );
|
|
if (!alter)
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, alter );
|
|
}
|
|
| TK_ALTER TK_TABLE table TK_ADD column_and_type TK_HOLD
|
|
{
|
|
SQL_input *sql = (SQL_input *)info;
|
|
MSIVIEW *alter = NULL;
|
|
|
|
ALTER_CreateView( sql->db, &alter, $3, $5, 1 );
|
|
if (!alter)
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, alter );
|
|
}
|
|
;
|
|
|
|
alterop:
|
|
TK_HOLD
|
|
{
|
|
$$ = 1;
|
|
}
|
|
| TK_FREE
|
|
{
|
|
$$ = -1;
|
|
}
|
|
;
|
|
|
|
onedrop:
|
|
TK_DROP TK_TABLE table
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
MSIVIEW* drop = NULL;
|
|
UINT r;
|
|
|
|
r = DROP_CreateView( sql->db, &drop, $3 );
|
|
if( r != ERROR_SUCCESS || !$$ )
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, drop );
|
|
}
|
|
;
|
|
|
|
table_def:
|
|
column_def TK_PRIMARY TK_KEY collist
|
|
{
|
|
if( SQL_MarkPrimaryKeys( &$1, $4 ) )
|
|
$$ = $1;
|
|
else
|
|
$$ = NULL;
|
|
}
|
|
;
|
|
|
|
column_def:
|
|
column_def TK_COMMA column_and_type
|
|
{
|
|
column_info *ci;
|
|
|
|
for( ci = $1; ci->next; ci = ci->next )
|
|
;
|
|
|
|
ci->next = $3;
|
|
$$ = $1;
|
|
}
|
|
| column_and_type
|
|
{
|
|
$$ = $1;
|
|
}
|
|
;
|
|
|
|
column_and_type:
|
|
column column_type
|
|
{
|
|
$$ = $1;
|
|
$$->type = ($2 | MSITYPE_VALID);
|
|
$$->temporary = $2 & MSITYPE_TEMPORARY ? TRUE : FALSE;
|
|
}
|
|
;
|
|
|
|
column_type:
|
|
data_type_l
|
|
{
|
|
$$ = $1;
|
|
}
|
|
| data_type_l TK_LOCALIZABLE
|
|
{
|
|
$$ = $1 | MSITYPE_LOCALIZABLE;
|
|
}
|
|
| data_type_l TK_TEMPORARY
|
|
{
|
|
$$ = $1 | MSITYPE_TEMPORARY;
|
|
}
|
|
;
|
|
|
|
data_type_l:
|
|
data_type
|
|
{
|
|
$$ |= MSITYPE_NULLABLE;
|
|
}
|
|
| data_type TK_NOT TK_NULL
|
|
{
|
|
$$ = $1;
|
|
}
|
|
;
|
|
|
|
data_type:
|
|
TK_CHAR
|
|
{
|
|
$$ = MSITYPE_STRING | 1;
|
|
}
|
|
| TK_CHAR TK_LP data_count TK_RP
|
|
{
|
|
$$ = MSITYPE_STRING | 0x400 | $3;
|
|
}
|
|
| TK_LONGCHAR
|
|
{
|
|
$$ = MSITYPE_STRING | 0x400;
|
|
}
|
|
| TK_SHORT
|
|
{
|
|
$$ = 2 | 0x400;
|
|
}
|
|
| TK_INT
|
|
{
|
|
$$ = 2 | 0x400;
|
|
}
|
|
| TK_LONG
|
|
{
|
|
$$ = 4;
|
|
}
|
|
| TK_OBJECT
|
|
{
|
|
$$ = MSITYPE_STRING | MSITYPE_VALID;
|
|
}
|
|
;
|
|
|
|
data_count:
|
|
number
|
|
{
|
|
if( ( $1 > 255 ) || ( $1 < 0 ) )
|
|
YYABORT;
|
|
$$ = $1;
|
|
}
|
|
;
|
|
|
|
oneselect:
|
|
TK_SELECT selectfrom
|
|
{
|
|
$$ = $2;
|
|
}
|
|
| TK_SELECT TK_DISTINCT selectfrom
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
MSIVIEW* distinct = NULL;
|
|
UINT r;
|
|
|
|
r = DISTINCT_CreateView( sql->db, &distinct, $3 );
|
|
if (r != ERROR_SUCCESS)
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, distinct );
|
|
}
|
|
;
|
|
|
|
selectfrom:
|
|
selcollist from
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
MSIVIEW* select = NULL;
|
|
UINT r;
|
|
|
|
if( $1 )
|
|
{
|
|
r = SELECT_CreateView( sql->db, &select, $2, $1 );
|
|
if (r != ERROR_SUCCESS)
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, select );
|
|
}
|
|
else
|
|
$$ = $2;
|
|
}
|
|
;
|
|
|
|
selcollist:
|
|
selcolumn
|
|
| selcolumn TK_COMMA selcollist
|
|
{
|
|
$1->next = $3;
|
|
}
|
|
| TK_STAR
|
|
{
|
|
$$ = NULL;
|
|
}
|
|
;
|
|
|
|
collist:
|
|
column
|
|
| column TK_COMMA collist
|
|
{
|
|
$1->next = $3;
|
|
}
|
|
| TK_STAR
|
|
{
|
|
$$ = NULL;
|
|
}
|
|
;
|
|
|
|
from:
|
|
TK_FROM table
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
MSIVIEW* table = NULL;
|
|
UINT r;
|
|
|
|
r = TABLE_CreateView( sql->db, $2, &table );
|
|
if( r != ERROR_SUCCESS || !$$ )
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, table );
|
|
}
|
|
| unorderdfrom TK_ORDER TK_BY collist
|
|
{
|
|
UINT r;
|
|
|
|
if( $4 )
|
|
{
|
|
r = $1->ops->sort( $1, $4 );
|
|
if ( r != ERROR_SUCCESS)
|
|
YYABORT;
|
|
}
|
|
|
|
$$ = $1;
|
|
}
|
|
| unorderdfrom
|
|
;
|
|
|
|
unorderdfrom:
|
|
TK_FROM tablelist
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
MSIVIEW* where = NULL;
|
|
UINT r;
|
|
|
|
r = WHERE_CreateView( sql->db, &where, $2, NULL );
|
|
if( r != ERROR_SUCCESS )
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, where );
|
|
}
|
|
| TK_FROM tablelist TK_WHERE expr
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
MSIVIEW* where = NULL;
|
|
UINT r;
|
|
|
|
r = WHERE_CreateView( sql->db, &where, $2, $4 );
|
|
if( r != ERROR_SUCCESS )
|
|
YYABORT;
|
|
|
|
PARSER_BUBBLE_UP_VIEW( sql, $$, where );
|
|
}
|
|
;
|
|
|
|
tablelist:
|
|
table
|
|
{
|
|
$$ = $1;
|
|
}
|
|
| table TK_COMMA tablelist
|
|
{
|
|
$$ = parser_add_table( info, $3, $1 );
|
|
if (!$$)
|
|
YYABORT;
|
|
}
|
|
;
|
|
|
|
expr:
|
|
TK_LP expr TK_RP
|
|
{
|
|
$$ = $2;
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| expr TK_AND expr
|
|
{
|
|
$$ = EXPR_complex( info, $1, OP_AND, $3 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| expr TK_OR expr
|
|
{
|
|
$$ = EXPR_complex( info, $1, OP_OR, $3 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| column_val TK_EQ val
|
|
{
|
|
$$ = EXPR_complex( info, $1, OP_EQ, $3 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| column_val TK_GT val
|
|
{
|
|
$$ = EXPR_complex( info, $1, OP_GT, $3 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| column_val TK_LT val
|
|
{
|
|
$$ = EXPR_complex( info, $1, OP_LT, $3 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| column_val TK_LE val
|
|
{
|
|
$$ = EXPR_complex( info, $1, OP_LE, $3 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| column_val TK_GE val
|
|
{
|
|
$$ = EXPR_complex( info, $1, OP_GE, $3 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| column_val TK_NE val
|
|
{
|
|
$$ = EXPR_complex( info, $1, OP_NE, $3 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| column_val TK_IS TK_NULL
|
|
{
|
|
$$ = EXPR_unary( info, $1, OP_ISNULL );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| column_val TK_IS TK_NOT TK_NULL
|
|
{
|
|
$$ = EXPR_unary( info, $1, OP_NOTNULL );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
;
|
|
|
|
val:
|
|
column_val
|
|
| const_val
|
|
;
|
|
|
|
constlist:
|
|
const_val
|
|
{
|
|
$$ = parser_alloc_column( info, NULL, NULL );
|
|
if( !$$ )
|
|
YYABORT;
|
|
$$->val = $1;
|
|
}
|
|
| const_val TK_COMMA constlist
|
|
{
|
|
$$ = parser_alloc_column( info, NULL, NULL );
|
|
if( !$$ )
|
|
YYABORT;
|
|
$$->val = $1;
|
|
$$->next = $3;
|
|
}
|
|
;
|
|
|
|
update_assign_list:
|
|
column_assignment
|
|
| column_assignment TK_COMMA update_assign_list
|
|
{
|
|
$$ = $1;
|
|
$$->next = $3;
|
|
}
|
|
;
|
|
|
|
column_assignment:
|
|
column TK_EQ const_val
|
|
{
|
|
$$ = $1;
|
|
$$->val = $3;
|
|
}
|
|
;
|
|
|
|
const_val:
|
|
number
|
|
{
|
|
$$ = EXPR_ival( info, $1 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| TK_MINUS number %prec TK_NEGATION
|
|
{
|
|
$$ = EXPR_ival( info, -$2 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| TK_STRING
|
|
{
|
|
$$ = EXPR_sval( info, &$1 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| TK_WILDCARD
|
|
{
|
|
$$ = EXPR_wildcard( info );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
;
|
|
|
|
column_val:
|
|
column
|
|
{
|
|
$$ = EXPR_column( info, $1 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
;
|
|
|
|
column:
|
|
table TK_DOT id
|
|
{
|
|
$$ = parser_alloc_column( info, $1, $3 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| id
|
|
{
|
|
$$ = parser_alloc_column( info, NULL, $1 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
;
|
|
|
|
selcolumn:
|
|
table TK_DOT id
|
|
{
|
|
$$ = parser_alloc_column( info, $1, $3 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| id
|
|
{
|
|
$$ = parser_alloc_column( info, NULL, $1 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
| string
|
|
{
|
|
$$ = parser_alloc_column( info, NULL, $1 );
|
|
if( !$$ )
|
|
YYABORT;
|
|
}
|
|
;
|
|
|
|
table:
|
|
id
|
|
{
|
|
$$ = $1;
|
|
}
|
|
;
|
|
|
|
id:
|
|
TK_ID
|
|
{
|
|
if ( SQL_getstring( info, &$1, &$$ ) != ERROR_SUCCESS || !$$ )
|
|
YYABORT;
|
|
}
|
|
;
|
|
|
|
string:
|
|
TK_STRING
|
|
{
|
|
if ( SQL_getstring( info, &$1, &$$ ) != ERROR_SUCCESS || !$$ )
|
|
YYABORT;
|
|
}
|
|
;
|
|
|
|
number:
|
|
TK_INTEGER
|
|
{
|
|
$$ = SQL_getint( info );
|
|
}
|
|
;
|
|
|
|
%%
|
|
|
|
static LPWSTR parser_add_table( void *info, LPCWSTR list, LPCWSTR table )
|
|
{
|
|
static const WCHAR space[] = {' ',0};
|
|
DWORD len = strlenW( list ) + strlenW( table ) + 2;
|
|
LPWSTR ret;
|
|
|
|
ret = parser_alloc( info, len * sizeof(WCHAR) );
|
|
if( ret )
|
|
{
|
|
strcpyW( ret, list );
|
|
strcatW( ret, space );
|
|
strcatW( ret, table );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static void *parser_alloc( void *info, unsigned int sz )
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
struct list *mem;
|
|
|
|
mem = msi_alloc( sizeof (struct list) + sz );
|
|
list_add_tail( sql->mem, mem );
|
|
return &mem[1];
|
|
}
|
|
|
|
static column_info *parser_alloc_column( void *info, LPCWSTR table, LPCWSTR column )
|
|
{
|
|
column_info *col;
|
|
|
|
col = parser_alloc( info, sizeof (*col) );
|
|
if( col )
|
|
{
|
|
col->table = table;
|
|
col->column = column;
|
|
col->val = NULL;
|
|
col->type = 0;
|
|
col->next = NULL;
|
|
}
|
|
|
|
return col;
|
|
}
|
|
|
|
static int sql_lex( void *SQL_lval, SQL_input *sql )
|
|
{
|
|
int token, skip;
|
|
struct sql_str * str = SQL_lval;
|
|
|
|
do
|
|
{
|
|
sql->n += sql->len;
|
|
if( ! sql->command[sql->n] )
|
|
return 0; /* end of input */
|
|
|
|
/* TRACE("string : %s\n", debugstr_w(&sql->command[sql->n])); */
|
|
sql->len = sqliteGetToken( &sql->command[sql->n], &token, &skip );
|
|
if( sql->len==0 )
|
|
break;
|
|
str->data = &sql->command[sql->n];
|
|
str->len = sql->len;
|
|
sql->n += skip;
|
|
}
|
|
while( token == TK_SPACE );
|
|
|
|
/* TRACE("token : %d (%s)\n", token, debugstr_wn(&sql->command[sql->n], sql->len)); */
|
|
|
|
return token;
|
|
}
|
|
|
|
UINT SQL_getstring( void *info, const struct sql_str *strdata, LPWSTR *str )
|
|
{
|
|
LPCWSTR p = strdata->data;
|
|
UINT len = strdata->len;
|
|
|
|
/* match quotes */
|
|
if( ( (p[0]=='`') && (p[len-1]!='`') ) ||
|
|
( (p[0]=='\'') && (p[len-1]!='\'') ) )
|
|
return ERROR_FUNCTION_FAILED;
|
|
|
|
/* if there's quotes, remove them */
|
|
if( ( (p[0]=='`') && (p[len-1]=='`') ) ||
|
|
( (p[0]=='\'') && (p[len-1]=='\'') ) )
|
|
{
|
|
p++;
|
|
len -= 2;
|
|
}
|
|
*str = parser_alloc( info, (len + 1)*sizeof(WCHAR) );
|
|
if( !*str )
|
|
return ERROR_OUTOFMEMORY;
|
|
memcpy( *str, p, len*sizeof(WCHAR) );
|
|
(*str)[len]=0;
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
INT SQL_getint( void *info )
|
|
{
|
|
SQL_input* sql = (SQL_input*) info;
|
|
LPCWSTR p = &sql->command[sql->n];
|
|
INT i, r = 0;
|
|
|
|
for( i=0; i<sql->len; i++ )
|
|
{
|
|
if( '0' > p[i] || '9' < p[i] )
|
|
{
|
|
ERR("should only be numbers here!\n");
|
|
break;
|
|
}
|
|
r = (p[i]-'0') + r*10;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
static int sql_error( SQL_input *info, const char *str )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static struct expr * EXPR_wildcard( void *info )
|
|
{
|
|
struct expr *e = parser_alloc( info, sizeof *e );
|
|
if( e )
|
|
{
|
|
e->type = EXPR_WILDCARD;
|
|
}
|
|
return e;
|
|
}
|
|
|
|
static struct expr * EXPR_complex( void *info, struct expr *l, UINT op, struct expr *r )
|
|
{
|
|
struct expr *e = parser_alloc( info, sizeof *e );
|
|
if( e )
|
|
{
|
|
e->type = EXPR_COMPLEX;
|
|
e->u.expr.left = l;
|
|
e->u.expr.op = op;
|
|
e->u.expr.right = r;
|
|
}
|
|
return e;
|
|
}
|
|
|
|
static struct expr * EXPR_unary( void *info, struct expr *l, UINT op )
|
|
{
|
|
struct expr *e = parser_alloc( info, sizeof *e );
|
|
if( e )
|
|
{
|
|
e->type = EXPR_UNARY;
|
|
e->u.expr.left = l;
|
|
e->u.expr.op = op;
|
|
e->u.expr.right = NULL;
|
|
}
|
|
return e;
|
|
}
|
|
|
|
static struct expr * EXPR_column( void *info, const column_info *column )
|
|
{
|
|
struct expr *e = parser_alloc( info, sizeof *e );
|
|
if( e )
|
|
{
|
|
e->type = EXPR_COLUMN;
|
|
e->u.column.unparsed.column = column->column;
|
|
e->u.column.unparsed.table = column->table;
|
|
}
|
|
return e;
|
|
}
|
|
|
|
static struct expr * EXPR_ival( void *info, int val )
|
|
{
|
|
struct expr *e = parser_alloc( info, sizeof *e );
|
|
if( e )
|
|
{
|
|
e->type = EXPR_IVAL;
|
|
e->u.ival = val;
|
|
}
|
|
return e;
|
|
}
|
|
|
|
static struct expr * EXPR_sval( void *info, const struct sql_str *str )
|
|
{
|
|
struct expr *e = parser_alloc( info, sizeof *e );
|
|
if( e )
|
|
{
|
|
e->type = EXPR_SVAL;
|
|
if( SQL_getstring( info, str, (LPWSTR *)&e->u.sval ) != ERROR_SUCCESS )
|
|
return NULL; /* e will be freed by query destructor */
|
|
}
|
|
return e;
|
|
}
|
|
|
|
static void swap_columns( column_info **cols, column_info *A, int idx )
|
|
{
|
|
column_info *preA = NULL, *preB = NULL, *B, *ptr;
|
|
int i = 0;
|
|
|
|
B = NULL;
|
|
ptr = *cols;
|
|
while( ptr )
|
|
{
|
|
if( i++ == idx )
|
|
B = ptr;
|
|
else if( !B )
|
|
preB = ptr;
|
|
|
|
if( ptr->next == A )
|
|
preA = ptr;
|
|
|
|
ptr = ptr->next;
|
|
}
|
|
|
|
if( preB ) preB->next = A;
|
|
if( preA ) preA->next = B;
|
|
ptr = A->next;
|
|
A->next = B->next;
|
|
B->next = ptr;
|
|
if( idx == 0 )
|
|
*cols = A;
|
|
}
|
|
|
|
static BOOL SQL_MarkPrimaryKeys( column_info **cols,
|
|
column_info *keys )
|
|
{
|
|
column_info *k;
|
|
BOOL found = TRUE;
|
|
int count;
|
|
|
|
for( k = keys, count = 0; k && found; k = k->next, count++ )
|
|
{
|
|
column_info *c;
|
|
int idx;
|
|
|
|
found = FALSE;
|
|
for( c = *cols, idx = 0; c && !found; c = c->next, idx++ )
|
|
{
|
|
if( strcmpW( k->column, c->column ) )
|
|
continue;
|
|
c->type |= MSITYPE_KEY;
|
|
found = TRUE;
|
|
if (idx != count)
|
|
swap_columns( cols, c, count );
|
|
}
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
UINT MSI_ParseSQL( MSIDATABASE *db, LPCWSTR command, MSIVIEW **phview,
|
|
struct list *mem )
|
|
{
|
|
SQL_input sql;
|
|
int r;
|
|
|
|
*phview = NULL;
|
|
|
|
sql.db = db;
|
|
sql.command = command;
|
|
sql.n = 0;
|
|
sql.len = 0;
|
|
sql.r = ERROR_BAD_QUERY_SYNTAX;
|
|
sql.view = phview;
|
|
sql.mem = mem;
|
|
|
|
r = sql_parse(&sql);
|
|
|
|
TRACE("Parse returned %d\n", r);
|
|
if( r )
|
|
{
|
|
if (*sql.view)
|
|
{
|
|
(*sql.view)->ops->delete(*sql.view);
|
|
*sql.view = NULL;
|
|
}
|
|
return sql.r;
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|