Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-04-18 03:34:11 +00:00
Code Issues Projects Releases Packages Wiki Activity

Sync to Wine-20050310:

Browse source 
Ulrich Czekalla <ulrich@codeweavers.com>
- Add support for radio buttons.
- Allocate space for terminating null.
- Fix a memory leak.
- Prevent accessing freed memory in failure case.
Mike McCormack <mike@codeweavers.com>
- Add a border to the edit control, add some more controls.
- Implement SQL delete query.
- Move product, feature and component enumeration functions to
  registry.c.
- Make sure strings are null terminated.
- Fix up the summary information code a little.
- Allow MsiViewExecute to be called twice on the same query.
- Implement MsiDatabaseGetPrimaryKeys.
- MsiGetComponentPath should allow null pointers for pcchBuf and
  lpPathBuf.
- Remove const declaration from non-const function.
Jose Manuel Ferrer Ortiz <jmfo1982@yahoo.es>
- Added MSI Spanish resources.
Juan Lang <juan_lang@yahoo.com>
- Implement MsiEnumRelatedProducts.
- make sure msihandle2msiinfo is correctly matched with msiobj_release
- don't do redundant NULL checks
- Don't hardcode windows or system directories, correct a typo.
- Fix a regression in AppSearch.
Jonathan Ernst <Jonathan@ErnstFamily.ch>
- Add French resources.
Henning Gerhardt <henning.gerhardt@web.de>
- Add/updated German resources.
Marcelo Duarte <wine-devel@bol.com.br>
- Update the resources for Portuguese.
Francois Gouget <fgouget@free.fr>
- Assorted spelling fixes.
Alexandre Julliard <julliard@winehq.org>
- Avoid spaces before preprocessor directives, that's not portable.
Aric Stewart <aric@codeweavers.com>
- Text reformatting patch to clean up all the static strings.
- Implement the action RegisterFonts.
- Add the ExecuteAction handler.
- Store the keypath, and do refcounting and registration of SharedDLLs.
- Fix a bug with handing dword values in the registry.
- Fix bugs with writing registry keys where value == NULL.
- Make use of msidefs.h.
- Lay some groundwork for uninstalls.
- Update the installed state for components during CostFinalize. Laying
  groundwork to be able to start processing uninstall logic as well.
- Fixed problems with my code for finding the PackageCode.
- Stubs for MsiUseFeature.
- Do some basic work with registry component paths.
- Make sure formats like [\\]] and [\\[] work properly.
Steven Edwards <steven@codeweavers.com>
- Correct typo.
Marcus Meissner <marcus@jet.franken.de>
- Output some more informations.
- Mark one global variable static.

svn path=/trunk/; revision=14081
This commit is contained in:
Gé van Geldorp 2005-03-14 22:54:57 +00:00
parent 9cc503a1b2
commit 5df62c8577
26 changed files with 8137 additions and 6701 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
reactos/lib/msi/Makefile.in
View file

@ -11,6 +11,7 @@ C_SRCS = \
appsearch.c \
create.c \
custom.c \
delete.c \
dialog.c \
distinct.c \
format.c \

12842
reactos/lib/msi/action.c
View file

File diff suppressed because it is too large Load diff

3
reactos/lib/msi/action.h
View file

@ -53,6 +53,9 @@ typedef struct tagMSICOMPONENT
BOOL Enabled;
INT Cost;
INT RefCount;
LPWSTR FullKeypath;
} MSICOMPONENT;
typedef struct tagMSIFOLDER

4
reactos/lib/msi/appsearch.c
View file

@ -629,7 +629,7 @@ static BOOL ACTION_IsFullPath(LPCWSTR path)
WCHAR first = toupperW(path[0]);
BOOL ret;
if (first >= 'A' && first <= 'A' && path[1] == ':')
if (first >= 'A' && first <= 'Z' && path[1] == ':')
ret = TRUE;
else if (path[0] == '\\' && path[1] == '\\')
ret = TRUE;
@ -644,6 +644,7 @@ static UINT ACTION_SearchDirectory(MSIPACKAGE *package, MSISIGNATURE *sig,
UINT rc;
BOOL found;
TRACE("%p, %p, %s, %d\n", package, sig, debugstr_w(expanded), depth);
if (ACTION_IsFullPath(expanded))
{
if (sig->File)
@ -681,6 +682,7 @@ static UINT ACTION_SearchDirectory(MSIPACKAGE *package, MSISIGNATURE *sig,
}
}
}
TRACE("returning %d\n", rc);
return rc;
}

218
reactos/lib/msi/delete.c Normal file
View file

@ -0,0 +1,218 @@
/*
* Implementation of the Microsoft Installer (msi.dll)
*
* Copyright 2002-2005 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "wine/debug.h"
#include "msi.h"
#include "msiquery.h"
#include "objbase.h"
#include "objidl.h"
#include "msipriv.h"
#include "winnls.h"
#include "query.h"
WINE_DEFAULT_DEBUG_CHANNEL(msi);
/*
* Code to delete rows from a table.
*
* We delete rows by blanking them out rather than trying to remove the row.
* This appears to be what the native MSI does (or tries to do). For the query:
*
* delete from Property
*
* some non-zero entries are left in the table by native MSI. I'm not sure if
* that's a bug in the way I'm running the query, or a just a bug.
*/
typedef struct tagMSIDELETEVIEW
{
MSIVIEW view;
MSIDATABASE *db;
MSIVIEW *table;
} MSIDELETEVIEW;
static UINT DELETE_fetch_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT *val )
{
MSIDELETEVIEW *dv = (MSIDELETEVIEW*)view;
TRACE("%p %d %d %p\n", dv, row, col, val );
return ERROR_FUNCTION_FAILED;
}
static UINT DELETE_fetch_stream( struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm)
{
MSIDELETEVIEW *dv = (MSIDELETEVIEW*)view;
TRACE("%p %d %d %p\n", dv, row, col, stm );
return ERROR_FUNCTION_FAILED;
}
static UINT DELETE_set_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT val )
{
MSIDELETEVIEW *dv = (MSIDELETEVIEW*)view;
TRACE("%p %d %d %04x\n", dv, row, col, val );
return ERROR_FUNCTION_FAILED;
}
static UINT DELETE_insert_row( struct tagMSIVIEW *view, UINT *num )
{
MSIDELETEVIEW *dv = (MSIDELETEVIEW*)view;
TRACE("%p %p\n", dv, num );
return ERROR_FUNCTION_FAILED;
}
static UINT DELETE_execute( struct tagMSIVIEW *view, MSIRECORD *record )
{
MSIDELETEVIEW *dv = (MSIDELETEVIEW*)view;
UINT r, i, j, rows = 0, cols = 0;
TRACE("%p %p\n", dv, record);
if( !dv->table )
return ERROR_FUNCTION_FAILED;
r = dv->table->ops->execute( dv->table, record );
if( r != ERROR_SUCCESS )
return r;
r = dv->table->ops->get_dimensions( dv->table, &rows, &cols );
if( r != ERROR_SUCCESS )
return r;
TRACE("blanking %d rows\n", rows);
/* blank out all the rows that match */
for( i=0; i<rows; i++ )
for( j=1; j<=cols; j++ )
dv->table->ops->set_int( dv->table, i, j, 0 );
return ERROR_SUCCESS;
}
static UINT DELETE_close( struct tagMSIVIEW *view )
{
MSIDELETEVIEW *dv = (MSIDELETEVIEW*)view;
TRACE("%p\n", dv );
if( !dv->table )
return ERROR_FUNCTION_FAILED;
return dv->table->ops->close( dv->table );
}
static UINT DELETE_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols )
{
MSIDELETEVIEW *dv = (MSIDELETEVIEW*)view;
TRACE("%p %p %p\n", dv, rows, cols );
if( !dv->table )
return ERROR_FUNCTION_FAILED;
*rows = 0;
return dv->table->ops->get_dimensions( dv->table, NULL, cols );
}
static UINT DELETE_get_column_info( struct tagMSIVIEW *view,
UINT n, LPWSTR *name, UINT *type )
{
MSIDELETEVIEW *dv = (MSIDELETEVIEW*)view;
TRACE("%p %d %p %p\n", dv, n, name, type );
if( !dv->table )
return ERROR_FUNCTION_FAILED;
return dv->table->ops->get_column_info( dv->table, n, name, type );
}
static UINT DELETE_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode,
MSIRECORD *rec )
{
MSIDELETEVIEW *dv = (MSIDELETEVIEW*)view;
TRACE("%p %d %p\n", dv, eModifyMode, rec );
return ERROR_FUNCTION_FAILED;
}
static UINT DELETE_delete( struct tagMSIVIEW *view )
{
MSIDELETEVIEW *dv = (MSIDELETEVIEW*)view;
TRACE("%p\n", dv );
if( dv->table )
dv->table->ops->delete( dv->table );
HeapFree( GetProcessHeap(), 0, dv );
return ERROR_SUCCESS;
}
MSIVIEWOPS delete_ops =
{
DELETE_fetch_int,
DELETE_fetch_stream,
DELETE_set_int,
DELETE_insert_row,
DELETE_execute,
DELETE_close,
DELETE_get_dimensions,
DELETE_get_column_info,
DELETE_modify,
DELETE_delete
};
UINT DELETE_CreateView( MSIDATABASE *db, MSIVIEW **view, MSIVIEW *table )
{
MSIDELETEVIEW *dv = NULL;
TRACE("%p\n", dv );
dv = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof *dv );
if( !dv )
return ERROR_FUNCTION_FAILED;
/* fill the structure */
dv->view.ops = &delete_ops;
dv->db = db;
dv->table = table;
*view = &dv->view;
return ERROR_SUCCESS;
}

171
reactos/lib/msi/dialog.c
View file

@ -41,6 +41,9 @@ const WCHAR szMsiDialogClass[] = {
'M','s','i','D','i','a','l','o','g','C','l','o','s','e','C','l','a','s','s',0
};
const static WCHAR szStatic[] = { 'S','t','a','t','i','c',0 };
const static WCHAR szButton[] = { 'B','U','T','T','O','N', 0 };
const static WCHAR szButtonData[] = { 'M','S','I','D','A','T','A',0 };
struct msi_control_tag;
typedef struct msi_control_tag msi_control;
@ -83,10 +86,19 @@ struct control_handler
msi_dialog_control_func func;
};
typedef struct
{
msi_dialog* dialog;
msi_control *parent;
DWORD attributes;
} radio_button_group_descr;
static UINT msi_dialog_checkbox_handler( msi_dialog *, msi_control *, WPARAM );
static void msi_dialog_checkbox_sync_state( msi_dialog *, msi_control * );
static UINT msi_dialog_button_handler( msi_dialog *, msi_control *, WPARAM );
static UINT msi_dialog_edit_handler( msi_dialog *, msi_control *, WPARAM );
static UINT msi_dialog_radiogroup_handler( msi_dialog *, msi_control *, WPARAM param );
static LRESULT WINAPI MSIRadioGroup_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
INT msi_dialog_scale_unit( msi_dialog *dialog, INT val )
@ -275,7 +287,6 @@ static UINT msi_dialog_text_control( msi_dialog *dialog, MSIRECORD *rec )
static UINT msi_dialog_button_control( msi_dialog *dialog, MSIRECORD *rec )
{
const static WCHAR szButton[] = { 'B','U','T','T','O','N', 0 };
msi_control *control;
TRACE("%p %p\n", dialog, rec);
@ -288,7 +299,6 @@ static UINT msi_dialog_button_control( msi_dialog *dialog, MSIRECORD *rec )
static UINT msi_dialog_checkbox_control( msi_dialog *dialog, MSIRECORD *rec )
{
const static WCHAR szButton[] = { 'B','U','T','T','O','N', 0 };
msi_control *control;
LPCWSTR prop;
@ -319,7 +329,7 @@ static UINT msi_dialog_scrolltext_control( msi_dialog *dialog, MSIRECORD *rec )
TRACE("%p %p\n", dialog, rec);
msi_dialog_add_control( dialog, rec, szEdit,
msi_dialog_add_control( dialog, rec, szEdit, WS_BORDER |
ES_MULTILINE | WS_VSCROLL | ES_READONLY | ES_AUTOVSCROLL );
return ERROR_SUCCESS;
@ -350,7 +360,7 @@ static UINT msi_dialog_edit_control( msi_dialog *dialog, MSIRECORD *rec )
LPCWSTR prop;
LPWSTR val;
control = msi_dialog_add_control( dialog, rec, szEdit, 0 );
control = msi_dialog_add_control( dialog, rec, szEdit, WS_BORDER );
control->handler = msi_dialog_edit_handler;
prop = MSI_RecordGetString( rec, 9 );
if( prop )
@ -361,8 +371,125 @@ static UINT msi_dialog_edit_control( msi_dialog *dialog, MSIRECORD *rec )
return ERROR_SUCCESS;
}
static UINT msi_dialog_pathedit_control( msi_dialog *dialog, MSIRECORD *rec )
{
FIXME("not implemented properly\n");
return msi_dialog_edit_control( dialog, rec );
}
static UINT msi_dialog_create_radiobutton( MSIRECORD *rec, LPVOID param )
{
radio_button_group_descr *group = (radio_button_group_descr *)param;
msi_dialog *dialog = group->dialog;
msi_control *control;
LPCWSTR prop;
DWORD x, y, width, height, style;
DWORD attributes = group->attributes;
LPCWSTR text, name;
LPWSTR font = NULL, title = NULL;
style = WS_CHILD | BS_AUTORADIOBUTTON | BS_MULTILINE;
name = MSI_RecordGetString( rec, 3 );
control = HeapAlloc( GetProcessHeap(), 0,
sizeof *control + strlenW(name)*sizeof(WCHAR) );
strcpyW( control->name, name );
control->next = dialog->control_list;
dialog->control_list = control;
x = MSI_RecordGetInteger( rec, 4 );
y = MSI_RecordGetInteger( rec, 5 );
width = MSI_RecordGetInteger( rec, 6 );
height = MSI_RecordGetInteger( rec, 7 );
text = MSI_RecordGetString( rec, 8 );
x = msi_dialog_scale_unit( dialog, x );
y = msi_dialog_scale_unit( dialog, y );
width = msi_dialog_scale_unit( dialog, width );
height = msi_dialog_scale_unit( dialog, height );
if( attributes & 1 )
style |= WS_VISIBLE;
if( ~attributes & 2 )
style |= WS_DISABLED;
if( text )
{
font = msi_dialog_get_style( &text );
deformat_string( dialog->package, text, &title );
}
control->hwnd = CreateWindowW( szButton, title, style, x, y, width, height,
group->parent->hwnd, NULL, NULL, NULL );
TRACE("Dialog %s control %s hwnd %p\n", debugstr_w(dialog->name), debugstr_w(text), control->hwnd);
msi_dialog_set_font( dialog, control->hwnd,
font ? font : dialog->default_font );
HeapFree( GetProcessHeap(), 0, font );
HeapFree( GetProcessHeap(), 0, title );
control->handler = msi_dialog_radiogroup_handler;
prop = MSI_RecordGetString( rec, 1 );
if( prop )
control->property = dupstrW( prop );
return ERROR_SUCCESS;
}
static UINT msi_dialog_radiogroup_control( msi_dialog *dialog, MSIRECORD *rec )
{
static const WCHAR query[] = {
'S','E','L','E','C','T',' ','*',' ',
'F','R','O','M',' ','R','a','d','i','o','B','u','t','t','o','n',' ',
'W','H','E','R','E',' ',
'`','P','r','o','p','e','r','t','y','`',' ','=',' ','\'','%','s','\'',0};
UINT r;
LPCWSTR prop;
msi_control *control;
MSIQUERY *view = NULL;
radio_button_group_descr group;
MSIPACKAGE *package = dialog->package;
prop = MSI_RecordGetString( rec, 9 );
TRACE("%p %p %s\n", dialog, rec, debugstr_w( prop ));
/* Create parent group box to hold radio buttons */
control = msi_dialog_add_control( dialog, rec, szButton, BS_OWNERDRAW );
if (control->hwnd)
{
WNDPROC oldproc = (WNDPROC) SetWindowLongPtrW(control->hwnd, GWLP_WNDPROC,
(LONG_PTR)MSIRadioGroup_WndProc);
SetPropW(control->hwnd, szButtonData, oldproc);
}
if( prop )
control->property = dupstrW( prop );
/* query the Radio Button table for all control in this group */
r = MSI_OpenQuery( package->db, &view, query, prop );
if( r != ERROR_SUCCESS )
{
ERR("query failed for dialog %s radio group %s\n",
debugstr_w(dialog->name), debugstr_w(prop));
return ERROR_INVALID_PARAMETER;
}
group.dialog = dialog;
group.parent = control;
group.attributes = MSI_RecordGetInteger( rec, 8 );
r = MSI_IterateRecords( view, 0, msi_dialog_create_radiobutton, &group );
msiobj_release( &view->hdr );
return r;
}
static const WCHAR szText[] = { 'T','e','x','t',0 };
static const WCHAR szButton[] = { 'P','u','s','h','B','u','t','t','o','n',0 };
static const WCHAR szPushButton[] = { 'P','u','s','h','B','u','t','t','o','n',0 };
static const WCHAR szLine[] = { 'L','i','n','e',0 };
static const WCHAR szBitmap[] = { 'B','i','t','m','a','p',0 };
static const WCHAR szCheckBox[] = { 'C','h','e','c','k','B','o','x',0 };
@ -371,11 +498,14 @@ static const WCHAR szScrollableText[] = {
static const WCHAR szComboBox[] = { 'C','o','m','b','o','B','o','x',0 };
static const WCHAR szEdit[] = { 'E','d','i','t',0 };
static const WCHAR szMaskedEdit[] = { 'M','a','s','k','e','d','E','d','i','t',0 };
static const WCHAR szPathEdit[] = { 'P','a','t','h','E','d','i','t',0 };
static const WCHAR szRadioButtonGroup[] = {
'R','a','d','i','o','B','u','t','t','o','n','G','r','o','u','p',0 };
struct control_handler msi_dialog_handler[] =
{
{ szText, msi_dialog_text_control },
{ szButton, msi_dialog_button_control },
{ szPushButton, msi_dialog_button_control },
{ szLine, msi_dialog_line_control },
{ szBitmap, msi_dialog_bitmap_control },
{ szCheckBox, msi_dialog_checkbox_control },
@ -383,6 +513,8 @@ struct control_handler msi_dialog_handler[] =
{ szComboBox, msi_dialog_combo_control },
{ szEdit, msi_dialog_edit_control },
{ szMaskedEdit, msi_dialog_edit_control },
{ szPathEdit, msi_dialog_pathedit_control },
{ szRadioButtonGroup, msi_dialog_radiogroup_control },
};
#define NUM_CONTROL_TYPES (sizeof msi_dialog_handler/sizeof msi_dialog_handler[0])
@ -791,6 +923,20 @@ static UINT msi_dialog_edit_handler( msi_dialog *dialog,
return ERROR_SUCCESS;
}
static UINT msi_dialog_radiogroup_handler( msi_dialog *dialog,
msi_control *control, WPARAM param )
{
if( HIWORD(param) != BN_CLICKED )
return ERROR_SUCCESS;
TRACE("clicked radio button %s, set %s\n", debugstr_w(control->name),
debugstr_w(control->property));
MSI_SetPropertyW( dialog->package, control->property, control->name );
return msi_dialog_button_handler( dialog, control, param );
}
static LRESULT msi_dialog_oncommand( msi_dialog *dialog, WPARAM param, HWND hwnd )
{
msi_control *control;
@ -816,6 +962,7 @@ static LRESULT WINAPI MSIDialog_WndProc( HWND hwnd, UINT msg,
{
msi_dialog *dialog = (LPVOID) GetWindowLongPtrW( hwnd, GWLP_USERDATA );
TRACE(" 0x%04x\n", msg);
switch (msg)
{
case WM_CREATE:
@ -971,3 +1118,15 @@ void msi_dialog_unregister_class( void )
{
UnregisterClassW( szMsiDialogClass, NULL );
}
static LRESULT WINAPI MSIRadioGroup_WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
WNDPROC oldproc = (WNDPROC) GetPropW(hWnd, szButtonData);
TRACE("hWnd %p msg %04x wParam 0x%08x lParam 0x%08lx\n", hWnd, msg, wParam, lParam);
if (msg == WM_COMMAND) /* Forward notifications to dialog */
SendMessageW(GetParent(hWnd), msg, wParam, lParam);
return CallWindowProcW(oldproc, hWnd, msg, wParam, lParam);
}

18
reactos/lib/msi/format.c
View file

@ -231,13 +231,13 @@ static BOOL find_next_outermost_key(LPCWSTR source, DWORD len_remaining,
*nested = FALSE;
for (i = 1; (*mark - source) + i < len_remaining && count > 0; i++)
{
if ((*mark)[i] == '[')
if ((*mark)[i] == '[' && (*mark)[i-1] != '\\')
{
count ++;
total_count ++;
*nested = TRUE;
}
else if ((*mark)[i] == ']')
else if ((*mark)[i] == ']' && (*mark)[i-1] != '\\')
{
count --;
}
@ -538,11 +538,8 @@ UINT WINAPI MsiFormatRecordW( MSIHANDLE hInstall, MSIHANDLE hRecord,
package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
if( record )
{
r = MSI_FormatRecordW( package, record, szResult, sz );
msiobj_release( &record->hdr );
}
r = MSI_FormatRecordW( package, record, szResult, sz );
msiobj_release( &record->hdr );
if (package)
msiobj_release( &package->hdr );
return r;
@ -572,11 +569,8 @@ UINT WINAPI MsiFormatRecordA( MSIHANDLE hInstall, MSIHANDLE hRecord,
package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
if( record )
{
r = MSI_FormatRecordA( package, record, szResult, sz );
msiobj_release( &record->hdr );
}
r = MSI_FormatRecordA( package, record, szResult, sz );
msiobj_release( &record->hdr );
if (package)
msiobj_release( &package->hdr );
return r;

359
reactos/lib/msi/msi.c
View file

@ -487,6 +487,11 @@ UINT WINAPI MsiConfigureProductExW(LPCWSTR szProduct, int iInstallLevel,
goto end;
package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
if (!package)
{
rc = ERROR_INVALID_HANDLE;
goto end;
}
sz = strlenW(szInstalled);
@ -865,7 +870,7 @@ INSTALLUI_HANDLERW WINAPI MsiSetExternalUIW(INSTALLUI_HANDLERW puiHandler,
* id [I] id of the string to be loaded
* lpBuffer [O] buffer for the string to be written to
* nBufferMax [I] maximum size of the buffer in characters
* lang [I] the prefered language for the string
* lang [I] the preferred language for the string
*
* RETURNS
*
@ -973,219 +978,6 @@ UINT WINAPI MsiMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uT
return ERROR_CALL_NOT_IMPLEMENTED;
}
UINT WINAPI MsiEnumProductsA(DWORD index, LPSTR lpguid)
{
DWORD r;
WCHAR szwGuid[GUID_SIZE];
TRACE("%ld %p\n",index,lpguid);
if (NULL == lpguid) {
return ERROR_INVALID_PARAMETER;
}
r = MsiEnumProductsW(index, szwGuid);
if( r == ERROR_SUCCESS )
WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
return r;
}
UINT WINAPI MsiEnumProductsW(DWORD index, LPWSTR lpguid)
{
HKEY hkeyFeatures = 0;
DWORD r;
WCHAR szKeyName[33];
TRACE("%ld %p\n",index,lpguid);
if (NULL == lpguid)
return ERROR_INVALID_PARAMETER;
r = MSIREG_OpenFeatures(&hkeyFeatures);
if( r != ERROR_SUCCESS )
goto end;
r = RegEnumKeyW(hkeyFeatures, index, szKeyName, GUID_SIZE);
unsquash_guid(szKeyName, lpguid);
end:
if( hkeyFeatures )
RegCloseKey(hkeyFeatures);
return r;
}
UINT WINAPI MsiEnumFeaturesA(LPCSTR szProduct, DWORD index,
LPSTR szFeature, LPSTR szParent)
{
DWORD r;
WCHAR szwFeature[GUID_SIZE], szwParent[GUID_SIZE];
LPWSTR szwProduct = NULL;
TRACE("%s %ld %p %p\n",debugstr_a(szProduct),index,szFeature,szParent);
if( szProduct )
{
UINT len = MultiByteToWideChar( CP_ACP, 0, szProduct, -1, NULL, 0 );
szwProduct = HeapAlloc( GetProcessHeap(), 0, len * sizeof (WCHAR) );
if( szwProduct )
MultiByteToWideChar( CP_ACP, 0, szProduct, -1, szwProduct, len );
else
return ERROR_FUNCTION_FAILED;
}
r = MsiEnumFeaturesW(szwProduct, index, szwFeature, szwParent);
if( r == ERROR_SUCCESS )
{
WideCharToMultiByte(CP_ACP, 0, szwFeature, -1,
szFeature, GUID_SIZE, NULL, NULL);
WideCharToMultiByte(CP_ACP, 0, szwParent, -1,
szParent, GUID_SIZE, NULL, NULL);
}
HeapFree( GetProcessHeap(), 0, szwProduct);
return r;
}
UINT WINAPI MsiEnumFeaturesW(LPCWSTR szProduct, DWORD index,
LPWSTR szFeature, LPWSTR szParent)
{
HKEY hkeyProduct = 0;
DWORD r, sz;
TRACE("%s %ld %p %p\n",debugstr_w(szProduct),index,szFeature,szParent);
r = MSIREG_OpenFeaturesKey(szProduct,&hkeyProduct,FALSE);
if( r != ERROR_SUCCESS )
goto end;
sz = GUID_SIZE;
r = RegEnumValueW(hkeyProduct, index, szFeature, &sz, NULL, NULL, NULL, NULL);
end:
if( hkeyProduct )
RegCloseKey(hkeyProduct);
return r;
}
UINT WINAPI MsiEnumComponentsA(DWORD index, LPSTR lpguid)
{
DWORD r;
WCHAR szwGuid[GUID_SIZE];
TRACE("%ld %p\n",index,lpguid);
r = MsiEnumComponentsW(index, szwGuid);
if( r == ERROR_SUCCESS )
WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
return r;
}
UINT WINAPI MsiEnumComponentsW(DWORD index, LPWSTR lpguid)
{
HKEY hkeyComponents = 0;
DWORD r;
WCHAR szKeyName[33];
TRACE("%ld %p\n",index,lpguid);
r = MSIREG_OpenComponents(&hkeyComponents);
if( r != ERROR_SUCCESS )
goto end;
r = RegEnumKeyW(hkeyComponents, index, szKeyName, GUID_SIZE);
unsquash_guid(szKeyName, lpguid);
end:
if( hkeyComponents )
RegCloseKey(hkeyComponents);
return r;
}
UINT WINAPI MsiEnumClientsA(LPCSTR szComponent, DWORD index, LPSTR szProduct)
{
DWORD r;
WCHAR szwProduct[GUID_SIZE];
LPWSTR szwComponent = NULL;
TRACE("%s %ld %p\n",debugstr_a(szComponent),index,szProduct);
if( szComponent )
{
UINT len = MultiByteToWideChar( CP_ACP, 0, szComponent, -1, NULL, 0 );
szwComponent = HeapAlloc( GetProcessHeap(), 0, len * sizeof (WCHAR) );
if( szwComponent )
MultiByteToWideChar( CP_ACP, 0, szComponent, -1, szwComponent, len );
else
return ERROR_FUNCTION_FAILED;
}
r = MsiEnumClientsW(szComponent?szwComponent:NULL, index, szwProduct);
if( r == ERROR_SUCCESS )
{
WideCharToMultiByte(CP_ACP, 0, szwProduct, -1,
szProduct, GUID_SIZE, NULL, NULL);
}
HeapFree( GetProcessHeap(), 0, szwComponent);
return r;
}
UINT WINAPI MsiEnumClientsW(LPCWSTR szComponent, DWORD index, LPWSTR szProduct)
{
HKEY hkeyComp = 0;
DWORD r, sz;
WCHAR szValName[GUID_SIZE];
TRACE("%s %ld %p\n",debugstr_w(szComponent),index,szProduct);
r = MSIREG_OpenComponentsKey(szComponent,&hkeyComp,FALSE);
if( r != ERROR_SUCCESS )
goto end;
sz = GUID_SIZE;
r = RegEnumValueW(hkeyComp, index, szValName, &sz, NULL, NULL, NULL, NULL);
if( r != ERROR_SUCCESS )
goto end;
unsquash_guid(szValName, szProduct);
end:
if( hkeyComp )
RegCloseKey(hkeyComp);
return r;
}
UINT WINAPI MsiEnumComponentQualifiersA( LPSTR szComponent, DWORD iIndex,
LPSTR lpQualifierBuf, DWORD* pcchQualifierBuf,
LPSTR lpApplicationDataBuf, DWORD* pcchApplicationDataBuf)
{
FIXME("%s %08lx %p %p %p %p\n", debugstr_a(szComponent), iIndex,
lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
pcchApplicationDataBuf);
return ERROR_CALL_NOT_IMPLEMENTED;
}
UINT WINAPI MsiEnumComponentQualifiersW( LPWSTR szComponent, DWORD iIndex,
LPWSTR lpQualifierBuf, DWORD* pcchQualifierBuf,
LPWSTR lpApplicationDataBuf, DWORD* pcchApplicationDataBuf )
{
FIXME("%s %08lx %p %p %p %p\n", debugstr_w(szComponent), iIndex,
lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
pcchApplicationDataBuf);
return ERROR_CALL_NOT_IMPLEMENTED;
}
UINT WINAPI MsiProvideAssemblyA( LPCSTR szAssemblyName, LPCSTR szAppContext,
DWORD dwInstallMode, DWORD dwAssemblyInfo, LPSTR lpPathBuf,
DWORD* pcchPathBuf )
@ -1343,41 +1135,72 @@ INSTALLSTATE WINAPI MsiGetComponentPathW(LPCWSTR szProduct, LPCWSTR szComponent,
WCHAR squished_pc[GUID_SIZE];
UINT rc;
INSTALLSTATE rrc = INSTALLSTATE_UNKNOWN;
HKEY hkey=0;
HKEY hkey = 0;
LPWSTR path = NULL;
DWORD sz, type;
TRACE("%s %s %p %p\n", debugstr_w(szProduct),
debugstr_w(szComponent), lpPathBuf, pcchBuf);
if( lpPathBuf && !pcchBuf )
return INSTALLSTATE_INVALIDARG;
squash_guid(szProduct,squished_pc);
rc = MSIREG_OpenProductsKey(szProduct,&hkey,FALSE);
if (rc != ERROR_SUCCESS)
rc = MSIREG_OpenProductsKey( szProduct, &hkey, FALSE);
if( rc != ERROR_SUCCESS )
goto end;
RegCloseKey(hkey);
rc = MSIREG_OpenComponentsKey(szComponent,&hkey,FALSE);
if (rc != ERROR_SUCCESS)
rc = MSIREG_OpenComponentsKey( szComponent, &hkey, FALSE);
if( rc != ERROR_SUCCESS )
goto end;
*pcchBuf *= sizeof(WCHAR);
rc = RegQueryValueExW(hkey,squished_pc,NULL,NULL,(LPVOID)lpPathBuf,
pcchBuf);
*pcchBuf /= sizeof(WCHAR);
sz = 0;
type = 0;
rc = RegQueryValueExW( hkey, squished_pc, NULL, &type, NULL, &sz );
if( rc != ERROR_SUCCESS )
goto end;
if( type != REG_SZ )
goto end;
if (rc!= ERROR_SUCCESS)
sz += sizeof(WCHAR);
path = HeapAlloc( GetProcessHeap(), 0, sz );
if( !path )
goto end;
rc = RegQueryValueExW( hkey, squished_pc, NULL, NULL, (LPVOID) path, &sz );
if( rc != ERROR_SUCCESS )
goto end;
TRACE("found path of (%s:%s)(%s)\n", debugstr_w(szComponent),
debugstr_w(szProduct), debugstr_w(lpPathBuf));
debugstr_w(szProduct), debugstr_w(path));
FIXME("Only working for installed files, not registry keys\n");
if (GetFileAttributesW(lpPathBuf) != INVALID_FILE_ATTRIBUTES)
rrc = INSTALLSTATE_LOCAL;
if (path[0]=='0')
{
FIXME("Registry entry.. check entry\n");
rrc = INSTALLSTATE_LOCAL;
}
else
rrc = INSTALLSTATE_ABSENT;
{
/* PROBABLY a file */
if ( GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES )
rrc = INSTALLSTATE_LOCAL;
else
rrc = INSTALLSTATE_ABSENT;
}
if( pcchBuf )
{
sz = sz / sizeof(WCHAR);
if( *pcchBuf >= sz )
strcpyW( lpPathBuf, path );
*pcchBuf = sz;
}
end:
HeapFree(GetProcessHeap(), 0, path );
RegCloseKey(hkey);
return rrc;
}
@ -1421,7 +1244,10 @@ INSTALLSTATE WINAPI MsiQueryFeatureStateA(LPCSTR szProduct, LPCSTR szFeature)
INSTALLSTATE WINAPI MsiQueryFeatureStateW(LPCWSTR szProduct, LPCWSTR szFeature)
{
FIXME("%s %s\n", debugstr_w(szProduct), debugstr_w(szFeature));
return INSTALLSTATE_UNKNOWN;
/*
* Iterates all the features components and the features parents components
*/
return INSTALLSTATE_LOCAL;
}
UINT WINAPI MsiGetFileVersionA(LPCSTR szFilePath, LPSTR lpVersionBuf,
@ -1655,22 +1481,6 @@ BOOL WINAPI MSI_DllCanUnloadNow(void)
return S_FALSE;
}
UINT WINAPI MsiEnumRelatedProductsW(LPCWSTR szUpgradeCode, DWORD dwReserved,
DWORD iProductIndex, LPWSTR lpProductBuf)
{
FIXME("%s %lu %lu %p\n", debugstr_w(szUpgradeCode), dwReserved,
iProductIndex, lpProductBuf);
return ERROR_CALL_NOT_IMPLEMENTED;
}
UINT WINAPI MsiEnumRelatedProductsA(LPCSTR szUpgradeCode, DWORD dwReserved,
DWORD iProductIndex, LPSTR lpProductBuf)
{
FIXME("%s %lu %lu %p\n", debugstr_a(szUpgradeCode), dwReserved,
iProductIndex, lpProductBuf);
return ERROR_CALL_NOT_IMPLEMENTED;
}
UINT WINAPI MsiGetFeatureUsageW(LPCWSTR szProduct, LPCWSTR szFeature,
DWORD* pdwUseCount, WORD* pwDateUsed)
{
@ -1687,11 +1497,42 @@ UINT WINAPI MsiGetFeatureUsageA(LPCSTR szProduct, LPCSTR szFeature,
return ERROR_CALL_NOT_IMPLEMENTED;
}
UINT WINAPI MsiUseFeatureExW(LPCWSTR szProduct, LPCWSTR szFeature,
INSTALLSTATE WINAPI MsiUseFeatureExW(LPCWSTR szProduct, LPCWSTR szFeature,
DWORD dwInstallMode, DWORD dwReserved)
{
FIXME("%s %s %li %li\n", debugstr_w(szProduct), debugstr_w(szFeature),
dwInstallMode, dwReserved);
/*
* Polls all the components of the feature to find install state and then
* writes:
* Software\\Microsoft\\Windows\\CurrentVersion\\
* Installer\\Products\\<squishguid>\\<feature>
* "Usage"=dword:........
*/
return INSTALLSTATE_LOCAL;
}
INSTALLSTATE WINAPI MsiUseFeatureExA(LPCSTR szProduct, LPCSTR szFeature,
DWORD dwInstallMode, DWORD dwReserved)
{
FIXME("%s %s %li %li\n", debugstr_a(szProduct), debugstr_a(szFeature),
dwInstallMode, dwReserved);
return INSTALLSTATE_LOCAL;
}
INSTALLSTATE WINAPI MsiUseFeatureW(LPCWSTR szProduct, LPCWSTR szFeature)
{
FIXME("%s %s\n", debugstr_w(szProduct), debugstr_w(szFeature));
return INSTALLSTATE_LOCAL;
}
INSTALLSTATE WINAPI MsiUseFeatureA(LPCSTR szProduct, LPCSTR szFeature)
{
FIXME("%s %s\n", debugstr_a(szProduct), debugstr_a(szFeature));
return INSTALLSTATE_LOCAL;
}
@ -1749,17 +1590,33 @@ UINT WINAPI MsiCreateAndVerifyInstallerDirectory(void)
}
UINT WINAPI MsiGetShortcutTargetA( LPCSTR szShortcutTarget,
LPSTR szProductCode, LPSTR szFeatureId,
LPSTR szComponentCode)
LPSTR szProductCode, LPSTR szFeatureId,
LPSTR szComponentCode )
{
FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
UINT WINAPI MsiGetShortcutTargetW( LPCWSTR szShortcutTarget,
LPWSTR szProductCode, LPWSTR szFeatureId,
LPWSTR szComponentCode)
LPWSTR szProductCode, LPWSTR szFeatureId,
LPWSTR szComponentCode )
{
FIXME("\n");
return ERROR_CALL_NOT_IMPLEMENTED;
}
UINT WINAPI MsiReinstallFeatureW( LPCWSTR szProduct, LPCWSTR szFeature,
DWORD dwReinstallMode )
{
FIXME("%s %s %li\n", debugstr_w(szProduct), debugstr_w(szFeature),
dwReinstallMode);
return ERROR_SUCCESS;
}
UINT WINAPI MsiReinstallFeatureA( LPCSTR szProduct, LPCSTR szFeature,
DWORD dwReinstallMode )
{
FIXME("%s %s %li\n", debugstr_a(szProduct), debugstr_a(szFeature),
dwReinstallMode);
return ERROR_SUCCESS;
}

4
reactos/lib/msi/msi.rc
View file

@ -27,4 +27,8 @@ LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL
#include "version.rc"
#include "msi_De.rc"
#include "msi_En.rc"
#include "msi_Es.rc"
#include "msi_Fr.rc"
#include "msi_Pt.rc"

10
reactos/lib/msi/msi.spec
View file

@ -123,10 +123,10 @@
123 stdcall MsiRecordSetStreamW(long long wstr)
124 stdcall MsiRecordSetStringA(long long str)
125 stdcall MsiRecordSetStringW(long long wstr)
126 stub MsiReinstallFeatureA
126 stdcall MsiReinstallFeatureA(str str long)
127 stub MsiReinstallFeatureFromDescriptorA
128 stub MsiReinstallFeatureFromDescriptorW
129 stub MsiReinstallFeatureW
129 stdcall MsiReinstallFeatureW(wstr wstr long)
130 stdcall MsiReinstallProductA(str long)
131 stdcall MsiReinstallProductW(wstr long)
132 stub MsiSequenceA
@ -151,8 +151,8 @@
151 stdcall MsiSummaryInfoPersist(long)
152 stdcall MsiSummaryInfoSetPropertyA(long long long long ptr str)
153 stdcall MsiSummaryInfoSetPropertyW(long long long long ptr wstr)
154 stub MsiUseFeatureA
155 stub MsiUseFeatureW
154 stdcall MsiUseFeatureA(str str)
155 stdcall MsiUseFeatureW(wstr wstr)
156 stdcall MsiVerifyPackageA(str)
157 stdcall MsiVerifyPackageW(wstr)
158 stdcall MsiViewClose(long)
@ -189,7 +189,7 @@
189 stdcall MsiConfigureProductExA(str long long str)
190 stdcall MsiConfigureProductExW(wstr long long wstr)
191 stub MsiInvalidateFeatureCache
192 stub MsiUseFeatureExA
192 stdcall MsiUseFeatureExA(str str long long)
193 stdcall MsiUseFeatureExW(wstr wstr long long)
194 stdcall MsiGetFileVersionA(str str ptr str ptr)
195 stdcall MsiGetFileVersionW(wstr wstr ptr wstr ptr)

33
reactos/lib/msi/msi_De.rc Normal file
View file

@ -0,0 +1,33 @@
/*
* German resources for MSI
*
* Copyright 2005 Henning Gerhardt
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
LANGUAGE LANG_GERMAN, SUBLANG_DEFAULT
STRINGTABLE DISCARDABLE
{
5 "Der Pfad %s wurde nicht gefunden."
9 "Bitte Disk %s einlegen."
10 "schlechte Parameter"
11 "Geben Sie das Verzeichnis ein, dass %s enthält."
12 "Die Installationsquelle für das Feature fehlt."
13 "Das Netzwerklaufwerk für das Feature fehlt."
14 "Feature von:"
15 "Wählen Sie das Verzeichnis aus, dass %s enthält."
}

33
reactos/lib/msi/msi_Es.rc Normal file
View file

@ -0,0 +1,33 @@
/*
* Spanish resources for MSI
*
* Copyright 2005 José Manuel Ferrer Ortiz
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
LANGUAGE LANG_SPANISH, SUBLANG_DEFAULT
STRINGTABLE DISCARDABLE
{
5 "ruta %s no encontrada"
9 "inserte el disco %s"
10 "parámetros incorrectos"
11 "introduzca qué carpeta contiene %s"
12 "instalar fuente para característica ausente"
13 "unidad de red para característica ausente"
14 "característica de:"
15 "elija qué carpeta contiene %s"
}

33
reactos/lib/msi/msi_Fr.rc Normal file
View file

@ -0,0 +1,33 @@
/*
* French resources for MSI
*
* Copyright 2005 Jonathan Ernst
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
LANGUAGE LANG_FRENCH, SUBLANG_DEFAULT
STRINGTABLE DISCARDABLE
{
5 "Le chemin %s est introuvable"
9 "insérez le disque %s"
10 "mauvais paramètres"
11 "saisissez le nom du dossier contenant %s"
12 "source d'installation pour la fonctionnalité manquante"
13 "lecteur réseau pour la fonctionnalité manquant"
14 "fonctionnalité depuis:"
15 "sélectionnez le dossier contenant %s"
}

33
reactos/lib/msi/msi_Pt.rc Normal file
View file

@ -0,0 +1,33 @@
/*
* Portuguese resources for MSI
*
* Copyright 2005 Marcelo Duarte
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
LANGUAGE LANG_PORTUGUESE, SUBLANG_DEFAULT
STRINGTABLE DISCARDABLE
{
5 "caminho %s não encontrado"
9 "insira disco %s"
10 "parâmetros inválidos"
11 "entre qual pasta contém %s"
12 "instalar fonte para característica faltando"
13 "drive de rede para característica faltando"
14 "característica de:"
15 "escolha qual pasta contém %s"
}

3
reactos/lib/msi/msipriv.h
View file

@ -214,6 +214,8 @@ typedef struct tagMSIPACKAGE
UINT CurrentInstallState;
msi_dialog *dialog;
LPWSTR next_dialog;
BOOL ExecuteSequenceRun;
} MSIPACKAGE;
typedef struct tagMSIPREVIEW
@ -362,6 +364,7 @@ extern UINT MSIREG_OpenComponents(HKEY* key);
extern UINT MSIREG_OpenComponentsKey(LPCWSTR szComponent, HKEY* key, BOOL create);
extern UINT MSIREG_OpenProductsKey(LPCWSTR szProduct, HKEY* key, BOOL create);
extern UINT MSIREG_OpenUserFeaturesKey(LPCWSTR szProduct, HKEY* key, BOOL create);
extern UINT MSIREG_OpenUpgradeCodesKey(LPCWSTR szProduct, HKEY* key, BOOL create);
/* msi dialog interface */
typedef VOID (*msi_dialog_event_handler)( MSIPACKAGE*, LPCWSTR, LPCWSTR, msi_dialog* );

133
reactos/lib/msi/msiquery.c
View file

@ -1,7 +1,7 @@
/*
* Implementation of the Microsoft Installer (msi.dll)
*
* Copyright 2002-2004 Mike McCormack for CodeWeavers
* Copyright 2002-2005 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
@ -212,6 +212,9 @@ UINT MSI_IterateRecords( MSIQUERY *view, DWORD *count,
if( count )
*count = n;
if( r == ERROR_NO_MORE_ITEMS )
r = ERROR_SUCCESS;
return r;
}
@ -420,8 +423,7 @@ UINT WINAPI MsiViewExecute(MSIHANDLE hView, MSIHANDLE hRec)
msiobj_unlock( &rec->hdr );
out:
if( query )
msiobj_release( &query->hdr );
msiobj_release( &query->hdr );
if( rec )
msiobj_release( &rec->hdr );
@ -460,7 +462,10 @@ UINT WINAPI MsiViewGetColumnInfo(MSIHANDLE hView, MSICOLINFO info, MSIHANDLE *hR
rec = MSI_CreateRecord( count );
if( !rec )
return ERROR_FUNCTION_FAILED;
{
r = ERROR_FUNCTION_FAILED;
goto out;
}
for( i=0; i<count; i++ )
{
@ -475,8 +480,7 @@ UINT WINAPI MsiViewGetColumnInfo(MSIHANDLE hView, MSICOLINFO info, MSIHANDLE *hR
*hRec = alloc_msihandle( &rec->hdr );
out:
if( query )
msiobj_release( &query->hdr );
msiobj_release( &query->hdr );
if( rec )
msiobj_release( &rec->hdr );
@ -514,8 +518,7 @@ UINT WINAPI MsiViewModify( MSIHANDLE hView, MSIMODIFY eModifyMode,
r = view->ops->modify( view, eModifyMode, rec );
out:
if( query )
msiobj_release( &query->hdr );
msiobj_release( &query->hdr );
if( rec )
msiobj_release( &rec->hdr );
@ -574,18 +577,116 @@ UINT WINAPI MsiDatabaseCommit( MSIHANDLE hdb )
return r;
}
UINT WINAPI MsiDatabaseGetPrimaryKeysA(MSIHANDLE hdb,
LPCSTR table, MSIHANDLE* rec)
struct msi_primary_key_record_info
{
FIXME("%ld %s %p\n", hdb, debugstr_a(table), rec);
return ERROR_CALL_NOT_IMPLEMENTED;
DWORD n;
MSIRECORD *rec;
};
static UINT msi_primary_key_iterator( MSIRECORD *rec, LPVOID param )
{
struct msi_primary_key_record_info *info = param;
LPCWSTR name;
DWORD type;
type = MSI_RecordGetInteger( rec, 4 );
if( type & MSITYPE_KEY )
{
info->n++;
if( info->rec )
{
name = MSI_RecordGetString( rec, 3 );
MSI_RecordSetStringW( info->rec, info->n, name );
}
}
return ERROR_SUCCESS;
}
UINT WINAPI MsiDatabaseGetPrimaryKeysW(MSIHANDLE hdb,
LPCWSTR table, MSIHANDLE* rec)
UINT MSI_DatabaseGetPrimaryKeys( MSIDATABASE *db,
LPCWSTR table, MSIRECORD **prec )
{
FIXME("%ld %s %p\n", hdb, debugstr_w(table), rec);
return ERROR_CALL_NOT_IMPLEMENTED;
static const WCHAR sql[] = {
's','e','l','e','c','t',' ','*',' ',
'f','r','o','m',' ','`','_','C','o','l','u','m','n','s','`',' ',
'w','h','e','r','e',' ',
'`','T','a','b','l','e','`',' ','=',' ','\'','%','s','\'',0 };
struct msi_primary_key_record_info info;
MSIQUERY *query = NULL;
MSIVIEW *view;
UINT r;
r = MSI_OpenQuery( db, &query, sql, table );
if( r != ERROR_SUCCESS )
return r;
view = query->view;
/* count the number of primary key records */
info.n = 0;
info.rec = 0;
r = MSI_IterateRecords( query, 0, msi_primary_key_iterator, &info );
if( r == ERROR_SUCCESS )
{
TRACE("Found %ld primary keys\n", info.n );
/* allocate a record and fill in the names of the tables */
info.rec = MSI_CreateRecord( info.n );
info.n = 0;
r = MSI_IterateRecords( query, 0, msi_primary_key_iterator, &info );
if( r == ERROR_SUCCESS )
*prec = info.rec;
else
msiobj_release( &info.rec->hdr );
}
msiobj_release( &query->hdr );
return r;
}
UINT WINAPI MsiDatabaseGetPrimaryKeysW( MSIHANDLE hdb,
LPCWSTR table, MSIHANDLE* phRec )
{
MSIRECORD *rec = NULL;
MSIDATABASE *db;
UINT r;
TRACE("%ld %s %p\n", hdb, debugstr_w(table), phRec);
db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE );
if( !db )
return ERROR_INVALID_HANDLE;
r = MSI_DatabaseGetPrimaryKeys( db, table, &rec );
if( r == ERROR_SUCCESS )
{
*phRec = alloc_msihandle( &rec->hdr );
msiobj_release( &rec->hdr );
}
msiobj_release( &db->hdr );
return r;
}
UINT WINAPI MsiDatabaseGetPrimaryKeysA(MSIHANDLE hdb,
LPCSTR table, MSIHANDLE* phRec)
{
LPWSTR szwTable = NULL;
DWORD len;
UINT r;
TRACE("%ld %s %p\n", hdb, debugstr_a(table), phRec);
if( table )
{
len = MultiByteToWideChar( CP_ACP, 0, table, -1, NULL, 0 );
szwTable = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
MultiByteToWideChar( CP_ACP, 0, table, -1, szwTable, len );
}
r = MsiDatabaseGetPrimaryKeysW( hdb, szwTable, phRec );
HeapFree( GetProcessHeap(), 0, szwTable );
return r;
}
UINT WINAPI MsiDatabaseIsTablePersistentA(

7
reactos/lib/msi/package.c
View file

@ -60,7 +60,7 @@ void MSI_FreePackage( MSIOBJECTHDR *arg)
msiobj_release( &package->db->hdr );
}
static const UINT clone_properties(MSIDATABASE *db)
static UINT clone_properties(MSIDATABASE *db)
{
MSIQUERY * view = NULL;
UINT rc;
@ -617,7 +617,7 @@ INT WINAPI MsiProcessMessage( MSIHANDLE hInstall, INSTALLMESSAGE eMessageType,
package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
if( !package )
goto out;
return ERROR_INVALID_HANDLE;
record = msihandle2msiinfo( hRecord, MSIHANDLETYPE_RECORD );
if( !record )
@ -626,8 +626,7 @@ INT WINAPI MsiProcessMessage( MSIHANDLE hInstall, INSTALLMESSAGE eMessageType,
ret = MSI_ProcessMessage( package, eMessageType, record );
out:
if( package )
msiobj_release( &package->hdr );
msiobj_release( &package->hdr );
if( record )
msiobj_release( &record->hdr );

1
reactos/lib/msi/preview.c
View file

@ -77,6 +77,7 @@ UINT WINAPI MsiEnableUIPreview( MSIHANDLE hdb, MSIHANDLE* phPreview )
msiobj_release( &preview->hdr );
r = ERROR_SUCCESS;
}
msiobj_release( &db->hdr );
return r;
}

2
reactos/lib/msi/query.h
View file

@ -131,6 +131,8 @@ UINT INSERT_CreateView( MSIDATABASE *db, MSIVIEW **view, LPWSTR table,
UINT UPDATE_CreateView( MSIDATABASE *db, MSIVIEW **, LPWSTR table,
column_assignment *list, struct expr *expr );
UINT DELETE_CreateView( MSIDATABASE *db, MSIVIEW **view, MSIVIEW *table );
void delete_expr( struct expr *e );
void delete_string_list( string_list *sl );
void delete_value_list( value_list *vl );

1
reactos/lib/msi/record.c
View file

@ -210,6 +210,7 @@ UINT WINAPI MsiRecordClearData( MSIHANDLE handle )
rec->fields[i].u.iVal = 0;
}
msiobj_unlock( &rec->hdr );
msiobj_release( &rec->hdr );
return ERROR_SUCCESS;
}

315
reactos/lib/msi/registry.c
View file

@ -117,6 +117,23 @@ static const WCHAR szInstaller_Products_fmt[] = {
'P','r','o','d','u','c','t','s','\\',
'%','s',0};
static const WCHAR szInstaller_UpgradeCodes[] = {
'S','o','f','t','w','a','r','e','\\',
'M','i','c','r','o','s','o','f','t','\\',
'W','i','n','d','o','w','s','\\',
'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
'I','n','s','t','a','l','l','e','r','\\',
'U','p','g','r','a','d','e','C','o','d','e','s',0};
static const WCHAR szInstaller_UpgradeCodes_fmt[] = {
'S','o','f','t','w','a','r','e','\\',
'M','i','c','r','o','s','o','f','t','\\',
'W','i','n','d','o','w','s','\\',
'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
'I','n','s','t','a','l','l','e','r','\\',
'U','p','g','r','a','d','e','C','o','d','e','s','\\',
'%','s',0};
BOOL unsquash_guid(LPCWSTR in, LPWSTR out)
{
DWORD i,n=0;
@ -389,6 +406,26 @@ UINT MSIREG_OpenProductsKey(LPCWSTR szProduct, HKEY* key, BOOL create)
return rc;
}
UINT MSIREG_OpenUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create)
{
UINT rc;
WCHAR squished_pc[GUID_SIZE];
WCHAR keypath[0x200];
TRACE("%s\n",debugstr_w(szUpgradeCode));
squash_guid(szUpgradeCode,squished_pc);
TRACE("squished (%s)\n", debugstr_w(squished_pc));
sprintfW(keypath,szInstaller_UpgradeCodes_fmt,squished_pc);
if (create)
rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,keypath,key);
else
rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,keypath,key);
return rc;
}
/*************************************************************************
* MsiDecomposeDescriptorW [MSI.@]
*
@ -484,3 +521,281 @@ UINT WINAPI MsiDecomposeDescriptorA( LPCSTR szDescriptor, LPSTR szProduct,
return r;
}
UINT WINAPI MsiEnumProductsA(DWORD index, LPSTR lpguid)
{
DWORD r;
WCHAR szwGuid[GUID_SIZE];
TRACE("%ld %p\n",index,lpguid);
if (NULL == lpguid)
return ERROR_INVALID_PARAMETER;
r = MsiEnumProductsW(index, szwGuid);
if( r == ERROR_SUCCESS )
WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
return r;
}
UINT WINAPI MsiEnumProductsW(DWORD index, LPWSTR lpguid)
{
HKEY hkeyFeatures = 0;
DWORD r;
WCHAR szKeyName[33];
TRACE("%ld %p\n",index,lpguid);
if (NULL == lpguid)
return ERROR_INVALID_PARAMETER;
r = MSIREG_OpenFeatures(&hkeyFeatures);
if( r != ERROR_SUCCESS )
goto end;
r = RegEnumKeyW(hkeyFeatures, index, szKeyName, GUID_SIZE);
unsquash_guid(szKeyName, lpguid);
end:
if( hkeyFeatures )
RegCloseKey(hkeyFeatures);
return r;
}
UINT WINAPI MsiEnumFeaturesA(LPCSTR szProduct, DWORD index,
LPSTR szFeature, LPSTR szParent)
{
DWORD r;
WCHAR szwFeature[GUID_SIZE], szwParent[GUID_SIZE];
LPWSTR szwProduct = NULL;
TRACE("%s %ld %p %p\n",debugstr_a(szProduct),index,szFeature,szParent);
if( szProduct )
{
UINT len = MultiByteToWideChar( CP_ACP, 0, szProduct, -1, NULL, 0 );
szwProduct = HeapAlloc( GetProcessHeap(), 0, len * sizeof (WCHAR) );
if( szwProduct )
MultiByteToWideChar( CP_ACP, 0, szProduct, -1, szwProduct, len );
else
return ERROR_FUNCTION_FAILED;
}
r = MsiEnumFeaturesW(szwProduct, index, szwFeature, szwParent);
if( r == ERROR_SUCCESS )
{
WideCharToMultiByte(CP_ACP, 0, szwFeature, -1,
szFeature, GUID_SIZE, NULL, NULL);
WideCharToMultiByte(CP_ACP, 0, szwParent, -1,
szParent, GUID_SIZE, NULL, NULL);
}
HeapFree( GetProcessHeap(), 0, szwProduct);
return r;
}
UINT WINAPI MsiEnumFeaturesW(LPCWSTR szProduct, DWORD index,
LPWSTR szFeature, LPWSTR szParent)
{
HKEY hkeyProduct = 0;
DWORD r, sz;
TRACE("%s %ld %p %p\n",debugstr_w(szProduct),index,szFeature,szParent);
r = MSIREG_OpenFeaturesKey(szProduct,&hkeyProduct,FALSE);
if( r != ERROR_SUCCESS )
goto end;
sz = GUID_SIZE;
r = RegEnumValueW(hkeyProduct, index, szFeature, &sz, NULL, NULL, NULL, NULL);
end:
if( hkeyProduct )
RegCloseKey(hkeyProduct);
return r;
}
UINT WINAPI MsiEnumComponentsA(DWORD index, LPSTR lpguid)
{
DWORD r;
WCHAR szwGuid[GUID_SIZE];
TRACE("%ld %p\n",index,lpguid);
r = MsiEnumComponentsW(index, szwGuid);
if( r == ERROR_SUCCESS )
WideCharToMultiByte(CP_ACP, 0, szwGuid, -1, lpguid, GUID_SIZE, NULL, NULL);
return r;
}
UINT WINAPI MsiEnumComponentsW(DWORD index, LPWSTR lpguid)
{
HKEY hkeyComponents = 0;
DWORD r;
WCHAR szKeyName[33];
TRACE("%ld %p\n",index,lpguid);
r = MSIREG_OpenComponents(&hkeyComponents);
if( r != ERROR_SUCCESS )
goto end;
r = RegEnumKeyW(hkeyComponents, index, szKeyName, GUID_SIZE);
unsquash_guid(szKeyName, lpguid);
end:
if( hkeyComponents )
RegCloseKey(hkeyComponents);
return r;
}
UINT WINAPI MsiEnumClientsA(LPCSTR szComponent, DWORD index, LPSTR szProduct)
{
DWORD r;
WCHAR szwProduct[GUID_SIZE];
LPWSTR szwComponent = NULL;
TRACE("%s %ld %p\n",debugstr_a(szComponent),index,szProduct);
if( szComponent )
{
UINT len = MultiByteToWideChar( CP_ACP, 0, szComponent, -1, NULL, 0 );
szwComponent = HeapAlloc( GetProcessHeap(), 0, len * sizeof (WCHAR) );
if( szwComponent )
MultiByteToWideChar( CP_ACP, 0, szComponent, -1, szwComponent, len );
else
return ERROR_FUNCTION_FAILED;
}
r = MsiEnumClientsW(szComponent?szwComponent:NULL, index, szwProduct);
if( r == ERROR_SUCCESS )
{
WideCharToMultiByte(CP_ACP, 0, szwProduct, -1,
szProduct, GUID_SIZE, NULL, NULL);
}
HeapFree( GetProcessHeap(), 0, szwComponent);
return r;
}
UINT WINAPI MsiEnumClientsW(LPCWSTR szComponent, DWORD index, LPWSTR szProduct)
{
HKEY hkeyComp = 0;
DWORD r, sz;
WCHAR szValName[GUID_SIZE];
TRACE("%s %ld %p\n",debugstr_w(szComponent),index,szProduct);
r = MSIREG_OpenComponentsKey(szComponent,&hkeyComp,FALSE);
if( r != ERROR_SUCCESS )
goto end;
sz = GUID_SIZE;
r = RegEnumValueW(hkeyComp, index, szValName, &sz, NULL, NULL, NULL, NULL);
if( r != ERROR_SUCCESS )
goto end;
unsquash_guid(szValName, szProduct);
end:
if( hkeyComp )
RegCloseKey(hkeyComp);
return r;
}
UINT WINAPI MsiEnumComponentQualifiersA( LPSTR szComponent, DWORD iIndex,
LPSTR lpQualifierBuf, DWORD* pcchQualifierBuf,
LPSTR lpApplicationDataBuf, DWORD* pcchApplicationDataBuf)
{
FIXME("%s %08lx %p %p %p %p\n", debugstr_a(szComponent), iIndex,
lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
pcchApplicationDataBuf);
return ERROR_CALL_NOT_IMPLEMENTED;
}
UINT WINAPI MsiEnumComponentQualifiersW( LPWSTR szComponent, DWORD iIndex,
LPWSTR lpQualifierBuf, DWORD* pcchQualifierBuf,
LPWSTR lpApplicationDataBuf, DWORD* pcchApplicationDataBuf )
{
FIXME("%s %08lx %p %p %p %p\n", debugstr_w(szComponent), iIndex,
lpQualifierBuf, pcchQualifierBuf, lpApplicationDataBuf,
pcchApplicationDataBuf);
return ERROR_CALL_NOT_IMPLEMENTED;
}
UINT WINAPI MsiEnumRelatedProductsW(LPCWSTR szUpgradeCode, DWORD dwReserved,
DWORD iProductIndex, LPWSTR lpProductBuf)
{
UINT rc;
HKEY hkey;
WCHAR szKeyName[33];
TRACE("%s %lu %lu %p\n", debugstr_w(szUpgradeCode), dwReserved,
iProductIndex, lpProductBuf);
if (NULL == szUpgradeCode)
return ERROR_INVALID_PARAMETER;
if (NULL == lpProductBuf)
return ERROR_INVALID_PARAMETER;
rc = MSIREG_OpenUpgradeCodesKey(szUpgradeCode, &hkey, FALSE);
if (rc != ERROR_SUCCESS)
{
rc = ERROR_NO_MORE_ITEMS;
goto end;
}
rc = RegEnumKeyW(hkey, iProductIndex, szKeyName,
sizeof(szKeyName) / sizeof(szKeyName[0]));
unsquash_guid(szKeyName, lpProductBuf);
RegCloseKey(hkey);
end:
return rc;
}
UINT WINAPI MsiEnumRelatedProductsA(LPCSTR szUpgradeCode, DWORD dwReserved,
DWORD iProductIndex, LPSTR lpProductBuf)
{
UINT rc;
int len;
LPWSTR szUpgradeCodeW = NULL;
TRACE("%s %lu %lu %p\n", debugstr_a(szUpgradeCode), dwReserved,
iProductIndex, lpProductBuf);
if (!szUpgradeCode)
return ERROR_INVALID_PARAMETER;
len = MultiByteToWideChar(CP_ACP, 0, szUpgradeCode, -1, NULL, 0);
szUpgradeCodeW = (LPWSTR)HeapAlloc(GetProcessHeap(), 0,
len * sizeof(WCHAR));
if (szUpgradeCodeW)
{
WCHAR productW[39];
MultiByteToWideChar(CP_ACP, 0, szUpgradeCode, -1, szUpgradeCodeW, len);
rc = MsiEnumRelatedProductsW(szUpgradeCodeW, dwReserved,
iProductIndex, productW);
if (rc == ERROR_SUCCESS)
{
LPWSTR ptr;
for (ptr = productW; *ptr; )
*lpProductBuf++ = *ptr++;
}
HeapFree(GetProcessHeap(), 0, szUpgradeCodeW);
}
else
rc = ERROR_OUTOFMEMORY;
return rc;
}

547
reactos/lib/msi/sql.tab.c
View file

@ -562,18 +562,18 @@ union yyalloc
#endif
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 23
#define YYFINAL 27
/* YYLAST -- Last index in YYTABLE. */
#define YYLAST 126
#define YYLAST 128
/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS 147
/* YYNNTS -- Number of nonterminals. */
#define YYNNTS 25
#define YYNNTS 26
/* YYNRULES -- Number of rules. */
#define YYNRULES 63
#define YYNRULES 65
/* YYNRULES -- Number of states. */
#define YYNSTATES 123
#define YYNSTATES 126
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
#define YYUNDEFTOK 2
@ -633,53 +633,53 @@ static const unsigned char yytranslate[] =
YYRHS. */
static const unsigned char yyprhs[] =
{
0, 0, 3, 5, 7, 9, 11, 22, 34, 41,
49, 56, 61, 66, 69, 71, 74, 76, 80, 82,
87, 89, 91, 93, 95, 97, 99, 104, 106, 110,
115, 117, 121, 123, 126, 131, 135, 139, 143, 147,
151, 155, 159, 163, 167, 171, 175, 180, 182, 184,
186, 190, 192, 196, 200, 202, 205, 207, 209, 211,
215, 217, 219, 221
0, 0, 3, 5, 7, 9, 11, 13, 24, 36,
43, 51, 58, 61, 66, 71, 74, 76, 79, 81,
85, 87, 92, 94, 96, 98, 100, 102, 104, 109,
111, 115, 120, 122, 126, 128, 131, 136, 140, 144,
148, 152, 156, 160, 164, 168, 172, 176, 180, 185,
187, 189, 191, 195, 197, 201, 205, 207, 210, 212,
214, 216, 220, 222, 224, 226
};
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
static const short yyrhs[] =
{
148, 0, -1, 158, -1, 150, -1, 149, -1, 151,
-1, 67, 72, 170, 83, 160, 110, 134, 83, 164,
110, -1, 67, 72, 170, 83, 160, 110, 134, 83,
164, 110, 122, -1, 31, 121, 170, 83, 152, 110,
-1, 31, 121, 170, 83, 152, 110, 59, -1, 130,
170, 114, 165, 137, 162, -1, 153, 102, 77, 160,
-1, 153, 24, 169, 154, -1, 169, 154, -1, 155,
-1, 155, 86, -1, 156, -1, 156, 90, 92, -1,
19, -1, 19, 83, 157, 110, -1, 82, -1, 115,
-1, 69, -1, 81, -1, 93, -1, 70, -1, 159,
99, 16, 160, -1, 159, -1, 112, 160, 161, -1,
112, 38, 160, 161, -1, 169, -1, 169, 24, 160,
-1, 118, -1, 52, 170, -1, 52, 170, 137, 162,
-1, 83, 162, 110, -1, 168, 45, 168, -1, 162,
7, 162, -1, 162, 97, 162, -1, 168, 45, 163,
-1, 168, 57, 163, -1, 168, 85, 163, -1, 168,
78, 163, -1, 168, 54, 163, -1, 168, 89, 163,
-1, 168, 73, 92, -1, 168, 73, 90, 92, -1,
168, -1, 167, -1, 167, -1, 167, 24, 164, -1,
166, -1, 166, 24, 165, -1, 169, 45, 167, -1,
70, -1, 88, 70, -1, 120, -1, 138, -1, 169,
-1, 170, 39, 171, -1, 171, -1, 171, -1, 66,
-1, 120, -1
148, 0, -1, 159, -1, 150, -1, 149, -1, 151,
-1, 152, -1, 67, 72, 171, 83, 161, 110, 134,
83, 165, 110, -1, 67, 72, 171, 83, 161, 110,
134, 83, 165, 110, 122, -1, 31, 121, 171, 83,
153, 110, -1, 31, 121, 171, 83, 153, 110, 59,
-1, 130, 171, 114, 166, 137, 163, -1, 35, 162,
-1, 154, 102, 77, 161, -1, 154, 24, 170, 155,
-1, 170, 155, -1, 156, -1, 156, 86, -1, 157,
-1, 157, 90, 92, -1, 19, -1, 19, 83, 158,
110, -1, 82, -1, 115, -1, 69, -1, 81, -1,
93, -1, 70, -1, 160, 99, 16, 161, -1, 160,
-1, 112, 161, 162, -1, 112, 38, 161, 162, -1,
170, -1, 170, 24, 161, -1, 118, -1, 52, 171,
-1, 52, 171, 137, 163, -1, 83, 163, 110, -1,
169, 45, 169, -1, 163, 7, 163, -1, 163, 97,
163, -1, 169, 45, 164, -1, 169, 57, 164, -1,
169, 85, 164, -1, 169, 78, 164, -1, 169, 54,
164, -1, 169, 89, 164, -1, 169, 73, 92, -1,
169, 73, 90, 92, -1, 169, -1, 168, -1, 168,
-1, 168, 24, 165, -1, 167, -1, 167, 24, 166,
-1, 170, 45, 168, -1, 70, -1, 88, 70, -1,
120, -1, 138, -1, 170, -1, 171, 39, 172, -1,
172, -1, 172, -1, 66, -1, 120, -1
};
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
static const unsigned short yyrline[] =
{
0, 142, 142, 147, 152, 157, 165, 173, 184, 194,
207, 218, 228, 247, 259, 263, 271, 275, 282, 286,
290, 294, 298, 302, 306, 313, 324, 335, 339, 353,
371, 384, 397, 404, 415, 434, 438, 442, 446, 450,
454, 458, 462, 466, 470, 474, 478, 485, 486, 490,
502, 517, 518, 527, 543, 547, 551, 555, 562, 569,
573, 580, 587, 591
0, 143, 143, 148, 153, 158, 163, 171, 179, 190,
200, 213, 224, 235, 245, 264, 276, 280, 288, 292,
299, 303, 307, 311, 315, 319, 323, 330, 341, 352,
356, 370, 388, 401, 414, 421, 432, 451, 455, 459,
463, 467, 471, 475, 479, 483, 487, 491, 495, 502,
503, 507, 519, 534, 535, 544, 560, 564, 568, 572,
579, 586, 590, 597, 604, 608
};
#endif
@ -716,11 +716,11 @@ static const char *const yytname[] =
"TK_USING", "TK_VACUUM", "TK_VALUES", "TK_VIEW", "TK_WHEN", "TK_WHERE",
"TK_WILDCARD", "AGG_FUNCTION.", "COLUMN", "FUNCTION", "COMMENT",
"UNCLOSED_STRING", "SPACE", "ILLEGAL", "END_OF_FILE", "$accept",
"onequery", "oneinsert", "onecreate", "oneupdate", "table_def",
"column_def", "column_type", "data_type_l", "data_type", "data_count",
"oneselect", "unorderedsel", "selcollist", "from", "expr", "val",
"constlist", "update_assign_list", "column_assignment", "const_val",
"column_val", "column", "table", "string_or_id", 0
"onequery", "oneinsert", "onecreate", "oneupdate", "onedelete",
"table_def", "column_def", "column_type", "data_type_l", "data_type",
"data_count", "oneselect", "unorderedsel", "selcollist", "from", "expr",
"val", "constlist", "update_assign_list", "column_assignment",
"const_val", "column_val", "column", "table", "string_or_id", 0
};
#endif
@ -750,25 +750,25 @@ static const unsigned short yytoknum[] =
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const unsigned char yyr1[] =
{
0, 147, 148, 148, 148, 148, 149, 149, 150, 150,
151, 152, 153, 153, 154, 154, 155, 155, 156, 156,
156, 156, 156, 156, 156, 157, 158, 158, 159, 159,
160, 160, 160, 161, 161, 162, 162, 162, 162, 162,
162, 162, 162, 162, 162, 162, 162, 163, 163, 164,
164, 165, 165, 166, 167, 167, 167, 167, 168, 169,
169, 170, 171, 171
0, 147, 148, 148, 148, 148, 148, 149, 149, 150,
150, 151, 152, 153, 154, 154, 155, 155, 156, 156,
157, 157, 157, 157, 157, 157, 157, 158, 159, 159,
160, 160, 161, 161, 161, 162, 162, 163, 163, 163,
163, 163, 163, 163, 163, 163, 163, 163, 163, 164,
164, 165, 165, 166, 166, 167, 168, 168, 168, 168,
169, 170, 170, 171, 172, 172
};
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
static const unsigned char yyr2[] =
{
0, 2, 1, 1, 1, 1, 10, 11, 6, 7,
6, 4, 4, 2, 1, 2, 1, 3, 1, 4,
1, 1, 1, 1, 1, 1, 4, 1, 3, 4,
1, 3, 1, 2, 4, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 4, 1, 1, 1,
3, 1, 3, 3, 1, 2, 1, 1, 1, 3,
1, 1, 1, 1
0, 2, 1, 1, 1, 1, 1, 10, 11, 6,
7, 6, 2, 4, 4, 2, 1, 2, 1, 3,
1, 4, 1, 1, 1, 1, 1, 1, 4, 1,
3, 4, 1, 3, 1, 2, 4, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 4, 1,
1, 1, 3, 1, 3, 3, 1, 2, 1, 1,
1, 3, 1, 1, 1, 1
};
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
@ -776,113 +776,113 @@ static const unsigned char yyr2[] =
means the default is an error. */
static const unsigned char yydefact[] =
{
0, 0, 0, 0, 0, 0, 4, 3, 5, 2,
27, 0, 0, 0, 62, 32, 63, 0, 30, 0,
60, 0, 61, 1, 0, 0, 0, 0, 0, 28,
0, 0, 0, 0, 0, 0, 29, 33, 31, 59,
0, 51, 0, 26, 0, 0, 0, 0, 0, 0,
0, 0, 8, 0, 0, 18, 22, 23, 20, 24,
21, 13, 14, 16, 0, 0, 34, 0, 58, 10,
52, 54, 0, 56, 57, 53, 9, 0, 0, 0,
15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 55, 12, 11, 25, 0, 17, 0,
35, 37, 38, 56, 39, 48, 36, 43, 47, 40,
0, 45, 42, 41, 44, 19, 0, 49, 46, 6,
0, 7, 50
0, 0, 0, 0, 0, 0, 0, 4, 3, 5,
6, 2, 29, 0, 0, 12, 0, 0, 64, 34,
65, 0, 32, 0, 62, 0, 63, 1, 0, 0,
35, 0, 0, 30, 0, 0, 0, 0, 0, 0,
0, 31, 33, 61, 0, 53, 0, 28, 0, 0,
0, 0, 36, 0, 60, 0, 0, 0, 0, 9,
0, 0, 20, 24, 25, 22, 26, 23, 15, 16,
18, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 11, 54, 56, 0, 58, 59, 55, 10,
0, 0, 0, 17, 0, 37, 39, 40, 58, 41,
50, 38, 45, 49, 42, 0, 47, 44, 43, 46,
0, 57, 14, 13, 27, 0, 19, 48, 0, 21,
0, 51, 7, 0, 8, 52
};
/* YYDEFGOTO[NTERM-NUM]. */
static const yysigned_char yydefgoto[] =
{
-1, 5, 6, 7, 8, 44, 45, 61, 62, 63,
97, 9, 10, 17, 29, 66, 104, 116, 40, 41,
105, 67, 68, 19, 20
-1, 6, 7, 8, 9, 10, 48, 49, 68, 69,
70, 115, 11, 12, 21, 15, 52, 99, 120, 44,
45, 100, 53, 54, 23, 24
};
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
#define YYPACT_NINF -104
#define YYPACT_NINF -106
static const yysigned_char yypact[] =
{
-30, -103, -52, -34, -51, 21, -104, -104, -104, -104,
-70, -51, -51, -57, -104, -104, -104, -26, 11, -6,
-1, -69, -104, -104, 32, -25, -15, -26, -51, -104,
-57, -51, -51, -57, -51, -57, -104, -71, -104, -104,
-67, 47, 27, -104, -36, -19, -17, -29, -53, -53,
-51, -63, 26, -51, 17, -10, -104, -104, -104, -104,
-104, -104, 5, 7, -35, -53, -4, 35, -104, -4,
-104, -104, 37, -104, -104, -104, -104, -17, -57, 39,
-104, 18, 28, -7, -53, -53, -60, -60, -60, -73,
-60, -60, -60, -104, -104, -104, -104, 4, -104, -63,
-104, -4, -4, 77, -104, -104, -104, -104, -104, -104,
25, -104, -104, -104, -104, -104, 8, 95, -104, 0,
-63, -104, -104
-30, -105, -33, -54, -34, -51, 22, -106, -106, -106,
-106, -106, -79, -51, -51, -106, -51, -60, -106, -106,
-106, -33, 17, 10, 11, -63, -106, -106, 41, -24,
-75, -13, -33, -106, -60, -51, -51, -60, -51, -45,
-60, -106, -106, -106, -65, 50, 32, -106, -32, -15,
-17, -45, -4, 26, -106, -22, -45, -51, -59, 30,
-51, 24, 19, -106, -106, -106, -106, -106, -106, 21,
15, -7, -45, -45, -53, -53, -53, -78, -53, -53,
-53, -28, -4, -106, -106, 46, -106, -106, -106, -106,
-17, -60, 47, -106, 27, -106, -4, -4, 79, -106,
-106, -106, -106, -106, -106, 28, -106, -106, -106, -106,
38, -106, -106, -106, -106, 12, -106, -106, -59, -106,
13, 100, 3, -59, -106, -106
};
/* YYPGOTO[NTERM-NUM]. */
static const yysigned_char yypgoto[] =
{
-104, -104, -104, -104, -104, -104, -104, 44, -104, -104,
-104, -104, -104, 1, 96, -38, 14, 6, 75, -104,
-43, -37, 9, 12, 84
-106, -106, -106, -106, -106, -106, -106, -106, 36, -106,
-106, -106, -106, -106, -10, 7, -25, 16, 4, 71,
-106, -50, 34, 6, 40, 20
};
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
positive, shift that token. If negative, reduce the rule which
number is the opposite. If zero, do what YYDEFACT says.
If YYTABLE_NINF, syntax error. */
#define YYTABLE_NINF -64
#define YYTABLE_NINF -66
static const yysigned_char yytable[] =
{
84, 1, 55, 84, 13, 53, 14, 71, 75, 14,
71, 69, 18, 14, 27, 14, 21, 110, 11, 111,
12, 23, 18, 25, 26, 72, 28, 83, 72, 24,
65, 38, 14, 31, 43, 30, 47, 2, -61, 18,
37, 42, 18, 46, 18, 32, 101, 102, 33, 106,
108, 108, 56, 108, 108, 108, 117, 73, 34, 42,
103, 15, 77, 16, 57, 58, 48, 16, 35, 16,
49, 50, 51, 79, 52, 74, 59, 117, 74, 95,
86, 64, 3, 54, 15, 76, 16, 18, 22, 87,
85, 80, 88, 85, 78, 22, 22, 81, 60, 82,
4, 107, 109, 100, 112, 113, 114, 93, 89, 96,
98, 99, 22, 90, 115, 39, -63, 118, 119, 120,
91, 94, 121, 36, 92, 70, 122
72, 1, 62, 72, 17, 2, 18, 32, 88, 60,
22, 84, 105, 18, 106, 18, 13, 84, 16, 14,
28, 18, 27, 22, 42, 26, 71, 47, 33, 85,
55, 82, 18, 26, 26, 85, 26, 3, 51, 41,
22, 34, 46, 22, 50, 25, 22, 96, 97, 35,
-63, 36, 63, 29, 30, 43, 31, 37, 19, 38,
20, 86, 39, 46, 64, 65, 90, 98, 121, 20,
40, 74, 56, 121, 57, 20, 66, 58, 59, 87,
75, 113, 4, 76, 19, 87, 20, 61, 81, 89,
73, 102, 104, 73, 107, 108, 109, 22, 67, 77,
5, 91, 92, 95, 78, 94, 110, 93, 101, 103,
103, 79, 103, 103, 103, 80, 111, 114, -65, 116,
117, 118, 119, 122, 123, 124, 112, 125, 83
};
static const unsigned char yycheck[] =
{
7, 31, 19, 7, 38, 24, 66, 70, 51, 66,
70, 49, 3, 66, 13, 66, 4, 90, 121, 92,
72, 0, 13, 11, 12, 88, 52, 65, 88, 99,
83, 30, 66, 39, 33, 24, 35, 67, 39, 30,
28, 32, 33, 34, 35, 114, 84, 85, 16, 86,
87, 88, 69, 90, 91, 92, 99, 120, 83, 50,
120, 118, 53, 120, 81, 82, 137, 120, 83, 120,
137, 24, 45, 83, 110, 138, 93, 120, 138, 78,
45, 110, 112, 102, 118, 59, 120, 78, 4, 54,
97, 86, 57, 97, 77, 11, 12, 90, 115, 134,
130, 87, 88, 110, 90, 91, 92, 70, 73, 70,
92, 83, 28, 78, 110, 31, 39, 92, 110, 24,
85, 77, 122, 27, 89, 50, 120
7, 31, 19, 7, 38, 35, 66, 17, 58, 24,
4, 70, 90, 66, 92, 66, 121, 70, 72, 52,
99, 66, 0, 17, 34, 5, 51, 37, 21, 88,
40, 56, 66, 13, 14, 88, 16, 67, 83, 32,
34, 24, 36, 37, 38, 5, 40, 72, 73, 39,
39, 114, 69, 13, 14, 35, 16, 16, 118, 83,
120, 120, 137, 57, 81, 82, 60, 120, 118, 120,
83, 45, 137, 123, 24, 120, 93, 45, 110, 138,
54, 91, 112, 57, 118, 138, 120, 102, 110, 59,
97, 75, 76, 97, 78, 79, 80, 91, 115, 73,
130, 77, 83, 110, 78, 90, 134, 86, 74, 75,
76, 85, 78, 79, 80, 89, 70, 70, 39, 92,
92, 83, 110, 110, 24, 122, 90, 123, 57
};
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
static const unsigned char yystos[] =
{
0, 31, 67, 112, 130, 148, 149, 150, 151, 158,
159, 121, 72, 38, 66, 118, 120, 160, 169, 170,
171, 170, 171, 0, 99, 170, 170, 160, 52, 161,
24, 39, 114, 16, 83, 83, 161, 170, 160, 171,
165, 166, 169, 160, 152, 153, 169, 160, 137, 137,
24, 45, 110, 24, 102, 19, 69, 81, 82, 93,
115, 154, 155, 156, 110, 83, 162, 168, 169, 162,
165, 70, 88, 120, 138, 167, 59, 169, 77, 83,
86, 90, 134, 162, 7, 97, 45, 54, 57, 73,
78, 85, 89, 70, 154, 160, 70, 157, 92, 83,
110, 162, 162, 120, 163, 167, 168, 163, 168, 163,
90, 92, 163, 163, 163, 110, 164, 167, 92, 110,
24, 122, 164
0, 31, 35, 67, 112, 130, 148, 149, 150, 151,
152, 159, 160, 121, 52, 162, 72, 38, 66, 118,
120, 161, 170, 171, 172, 171, 172, 0, 99, 171,
171, 171, 161, 162, 24, 39, 114, 16, 83, 137,
83, 162, 161, 172, 166, 167, 170, 161, 153, 154,
170, 83, 163, 169, 170, 161, 137, 24, 45, 110,
24, 102, 19, 69, 81, 82, 93, 115, 155, 156,
157, 163, 7, 97, 45, 54, 57, 73, 78, 85,
89, 110, 163, 166, 70, 88, 120, 138, 168, 59,
170, 77, 83, 86, 90, 110, 163, 163, 120, 164,
168, 169, 164, 169, 164, 90, 92, 164, 164, 164,
134, 70, 155, 161, 70, 158, 92, 92, 83, 110,
165, 168, 110, 24, 122, 165
};
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
@ -1493,7 +1493,7 @@ yyreduce:
switch (yyn)
{
case 2:
#line 143 "./sql.y"
#line 144 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
*sql->view = yyvsp[0].query;
@ -1501,7 +1501,7 @@ yyreduce:
break;
case 3:
#line 148 "./sql.y"
#line 149 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
*sql->view = yyvsp[0].query;
@ -1509,7 +1509,7 @@ yyreduce:
break;
case 4:
#line 153 "./sql.y"
#line 154 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
*sql->view = yyvsp[0].query;
@ -1517,7 +1517,7 @@ yyreduce:
break;
case 5:
#line 158 "./sql.y"
#line 159 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
*sql->view = yyvsp[0].query;
@ -1525,7 +1525,15 @@ yyreduce:
break;
case 6:
#line 166 "./sql.y"
#line 164 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
*sql->view = yyvsp[0].query;
;}
break;
case 7:
#line 172 "./sql.y"
{
SQL_input *sql = (SQL_input*) info;
MSIVIEW *insert = NULL;
@ -1535,8 +1543,8 @@ yyreduce:
;}
break;
case 7:
#line 174 "./sql.y"
case 8:
#line 180 "./sql.y"
{
SQL_input *sql = (SQL_input*) info;
MSIVIEW *insert = NULL;
@ -1546,8 +1554,8 @@ yyreduce:
;}
break;
case 8:
#line 185 "./sql.y"
case 9:
#line 191 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
MSIVIEW *create = NULL;
@ -1559,8 +1567,8 @@ yyreduce:
;}
break;
case 9:
#line 195 "./sql.y"
case 10:
#line 201 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
MSIVIEW *create = NULL;
@ -1572,8 +1580,8 @@ yyreduce:
;}
break;
case 10:
#line 208 "./sql.y"
case 11:
#line 214 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
MSIVIEW *update = NULL;
@ -1583,8 +1591,19 @@ yyreduce:
;}
break;
case 11:
#line 219 "./sql.y"
case 12:
#line 225 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
MSIVIEW *delete = NULL;
DELETE_CreateView( sql->db, &delete, yyvsp[0].query );
yyval.query = delete;
;}
break;
case 13:
#line 236 "./sql.y"
{
if( SQL_MarkPrimaryKeys( yyvsp[-3].column_info, yyvsp[0].column_list ) )
yyval.column_info = yyvsp[-3].column_info;
@ -1593,8 +1612,8 @@ yyreduce:
;}
break;
case 12:
#line 229 "./sql.y"
case 14:
#line 246 "./sql.y"
{
create_col_info *ci;
@ -1615,8 +1634,8 @@ yyreduce:
;}
break;
case 13:
#line 248 "./sql.y"
case 15:
#line 265 "./sql.y"
{
yyval.column_info = HeapAlloc( GetProcessHeap(), 0, sizeof *yyval.column_info );
if( ! yyval.column_info )
@ -1627,86 +1646,86 @@ yyreduce:
;}
break;
case 14:
#line 260 "./sql.y"
case 16:
#line 277 "./sql.y"
{
yyval.column_type = yyvsp[0].column_type | MSITYPE_VALID;
;}
break;
case 15:
#line 264 "./sql.y"
case 17:
#line 281 "./sql.y"
{
FIXME("LOCALIZABLE ignored\n");
yyval.column_type = yyvsp[-1].column_type | MSITYPE_VALID;
;}
break;
case 16:
#line 272 "./sql.y"
case 18:
#line 289 "./sql.y"
{
yyval.column_type |= MSITYPE_NULLABLE;
;}
break;
case 17:
#line 276 "./sql.y"
case 19:
#line 293 "./sql.y"
{
yyval.column_type = yyvsp[-2].column_type;
;}
break;
case 18:
#line 283 "./sql.y"
case 20:
#line 300 "./sql.y"
{
yyval.column_type = MSITYPE_STRING | 1;
;}
break;
case 19:
#line 287 "./sql.y"
case 21:
#line 304 "./sql.y"
{
yyval.column_type = MSITYPE_STRING | 0x400 | yyvsp[-1].column_type;
;}
break;
case 20:
#line 291 "./sql.y"
{
yyval.column_type = 2;
;}
break;
case 21:
#line 295 "./sql.y"
{
yyval.column_type = 2;
;}
break;
case 22:
#line 299 "./sql.y"
#line 308 "./sql.y"
{
yyval.column_type = 2;
;}
break;
case 23:
#line 303 "./sql.y"
#line 312 "./sql.y"
{
yyval.column_type = 2;
;}
break;
case 24:
#line 316 "./sql.y"
{
yyval.column_type = 2;
;}
break;
case 25:
#line 320 "./sql.y"
{
yyval.column_type = 4;
;}
break;
case 24:
#line 307 "./sql.y"
case 26:
#line 324 "./sql.y"
{
yyval.column_type = 0;
;}
break;
case 25:
#line 314 "./sql.y"
case 27:
#line 331 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
int val = SQL_getint(sql);
@ -1716,8 +1735,8 @@ yyreduce:
;}
break;
case 26:
#line 325 "./sql.y"
case 28:
#line 342 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
@ -1730,8 +1749,8 @@ yyreduce:
;}
break;
case 28:
#line 340 "./sql.y"
case 30:
#line 357 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
if( !yyvsp[0].query )
@ -1747,8 +1766,8 @@ yyreduce:
;}
break;
case 29:
#line 354 "./sql.y"
case 31:
#line 371 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
MSIVIEW *view = yyvsp[0].query;
@ -1765,8 +1784,8 @@ yyreduce:
;}
break;
case 30:
#line 372 "./sql.y"
case 32:
#line 389 "./sql.y"
{
string_list *list;
@ -1781,8 +1800,8 @@ yyreduce:
;}
break;
case 31:
#line 385 "./sql.y"
case 33:
#line 402 "./sql.y"
{
string_list *list;
@ -1797,15 +1816,15 @@ yyreduce:
;}
break;
case 32:
#line 398 "./sql.y"
case 34:
#line 415 "./sql.y"
{
yyval.column_list = NULL;
;}
break;
case 33:
#line 405 "./sql.y"
case 35:
#line 422 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
UINT r;
@ -1818,8 +1837,8 @@ yyreduce:
;}
break;
case 34:
#line 416 "./sql.y"
case 36:
#line 433 "./sql.y"
{
SQL_input* sql = (SQL_input*) info;
MSIVIEW *view = NULL;
@ -1837,92 +1856,92 @@ yyreduce:
;}
break;
case 35:
#line 435 "./sql.y"
case 37:
#line 452 "./sql.y"
{
yyval.expr = yyvsp[-1].expr;
;}
break;
case 36:
#line 439 "./sql.y"
case 38:
#line 456 "./sql.y"
{
yyval.expr = EXPR_complex( yyvsp[-2].expr, OP_EQ, yyvsp[0].expr );
;}
break;
case 37:
#line 443 "./sql.y"
case 39:
#line 460 "./sql.y"
{
yyval.expr = EXPR_complex( yyvsp[-2].expr, OP_AND, yyvsp[0].expr );
;}
break;
case 38:
#line 447 "./sql.y"
case 40:
#line 464 "./sql.y"
{
yyval.expr = EXPR_complex( yyvsp[-2].expr, OP_OR, yyvsp[0].expr );
;}
break;
case 39:
#line 451 "./sql.y"
case 41:
#line 468 "./sql.y"
{
yyval.expr = EXPR_complex( yyvsp[-2].expr, OP_EQ, yyvsp[0].expr );
;}
break;
case 40:
#line 455 "./sql.y"
case 42:
#line 472 "./sql.y"
{
yyval.expr = EXPR_complex( yyvsp[-2].expr, OP_GT, yyvsp[0].expr );
;}
break;
case 41:
#line 459 "./sql.y"
case 43:
#line 476 "./sql.y"
{
yyval.expr = EXPR_complex( yyvsp[-2].expr, OP_LT, yyvsp[0].expr );
;}
break;
case 42:
#line 463 "./sql.y"
case 44:
#line 480 "./sql.y"
{
yyval.expr = EXPR_complex( yyvsp[-2].expr, OP_LE, yyvsp[0].expr );
;}
break;
case 43:
#line 467 "./sql.y"
case 45:
#line 484 "./sql.y"
{
yyval.expr = EXPR_complex( yyvsp[-2].expr, OP_GE, yyvsp[0].expr );
;}
break;
case 44:
#line 471 "./sql.y"
case 46:
#line 488 "./sql.y"
{
yyval.expr = EXPR_complex( yyvsp[-2].expr, OP_NE, yyvsp[0].expr );
;}
break;
case 45:
#line 475 "./sql.y"
case 47:
#line 492 "./sql.y"
{
yyval.expr = EXPR_complex( yyvsp[-2].expr, OP_ISNULL, NULL );
;}
break;
case 46:
#line 479 "./sql.y"
case 48:
#line 496 "./sql.y"
{
yyval.expr = EXPR_complex( yyvsp[-3].expr, OP_NOTNULL, NULL );
;}
break;
case 49:
#line 491 "./sql.y"
case 51:
#line 508 "./sql.y"
{
value_list *vals;
@ -1936,8 +1955,8 @@ yyreduce:
;}
break;
case 50:
#line 503 "./sql.y"
case 52:
#line 520 "./sql.y"
{
value_list *vals;
@ -1951,8 +1970,8 @@ yyreduce:
;}
break;
case 52:
#line 519 "./sql.y"
case 54:
#line 536 "./sql.y"
{
yyvsp[-2].update_col_info.col_list->next = yyvsp[0].update_col_info.col_list;
yyvsp[-2].update_col_info.val_list->next = yyvsp[0].update_col_info.val_list;
@ -1960,8 +1979,8 @@ yyreduce:
;}
break;
case 53:
#line 528 "./sql.y"
case 55:
#line 545 "./sql.y"
{
yyval.update_col_info.col_list = HeapAlloc( GetProcessHeap(), 0, sizeof *yyval.update_col_info.col_list );
if( !yyval.update_col_info.col_list )
@ -1976,71 +1995,71 @@ yyreduce:
;}
break;
case 54:
#line 544 "./sql.y"
case 56:
#line 561 "./sql.y"
{
yyval.expr = EXPR_ival( &yyvsp[0].str, 1 );
;}
break;
case 55:
#line 548 "./sql.y"
case 57:
#line 565 "./sql.y"
{
yyval.expr = EXPR_ival( &yyvsp[0].str, -1 );
;}
break;
case 56:
#line 552 "./sql.y"
case 58:
#line 569 "./sql.y"
{
yyval.expr = EXPR_sval( &yyvsp[0].str );
;}
break;
case 57:
#line 556 "./sql.y"
case 59:
#line 573 "./sql.y"
{
yyval.expr = EXPR_wildcard();
;}
break;
case 58:
#line 563 "./sql.y"
case 60:
#line 580 "./sql.y"
{
yyval.expr = EXPR_column( yyvsp[0].string );
;}
break;
case 59:
#line 570 "./sql.y"
case 61:
#line 587 "./sql.y"
{
yyval.string = yyvsp[0].string; /* FIXME */
;}
break;
case 60:
#line 574 "./sql.y"
{
yyval.string = yyvsp[0].string;
;}
break;
case 61:
#line 581 "./sql.y"
{
yyval.string = yyvsp[0].string;
;}
break;
case 62:
#line 588 "./sql.y"
#line 591 "./sql.y"
{
yyval.string = yyvsp[0].string;
;}
break;
case 63:
#line 598 "./sql.y"
{
yyval.string = yyvsp[0].string;
;}
break;
case 64:
#line 605 "./sql.y"
{
yyval.string = SQL_getstring( &yyvsp[0].str );
;}
break;
case 63:
#line 592 "./sql.y"
case 65:
#line 609 "./sql.y"
{
yyval.string = SQL_getstring( &yyvsp[0].str );
;}
@ -2050,7 +2069,7 @@ yyreduce:
}
/* Line 999 of yacc.c. */
#line 2054 "sql.tab.c"
#line 2073 "sql.tab.c"
yyvsp -= yylen;
yyssp -= yylen;
@ -2256,7 +2275,7 @@ yyreturn:
}
#line 597 "./sql.y"
#line 614 "./sql.y"
int SQL_lex( void *SQL_lval, SQL_input *sql)

19
reactos/lib/msi/sql.y
View file

@ -129,7 +129,8 @@ static struct expr * EXPR_wildcard();
%type <string> column table string_or_id
%type <column_list> selcollist
%type <query> from unorderedsel oneselect onequery onecreate oneinsert oneupdate
%type <query> from unorderedsel oneselect onequery onecreate oneinsert
%type <query> oneupdate onedelete
%type <expr> expr val column_val const_val
%type <column_type> column_type data_type data_type_l data_count
%type <column_info> column_def table_def
@ -159,6 +160,11 @@ onequery:
SQL_input* sql = (SQL_input*) info;
*sql->view = $1;
}
| onedelete
{
SQL_input* sql = (SQL_input*) info;
*sql->view = $1;
}
;
oneinsert:
@ -214,6 +220,17 @@ oneupdate:
}
;
onedelete:
TK_DELETE from
{
SQL_input* sql = (SQL_input*) info;
MSIVIEW *delete = NULL;
DELETE_CreateView( sql->db, &delete, $2 );
$$ = delete;
}
;
table_def:
column_def TK_PRIMARY TK_KEY selcollist
{

42
reactos/lib/msi/suminfo.c
View file

@ -110,11 +110,9 @@ UINT WINAPI MsiGetSummaryInformationW(MSIHANDLE hDatabase,
if( FAILED( r ) )
{
ERR("IStorage -> IPropertySetStorage failed\n");
if (db)
msiobj_release(&db->hdr);
return ERROR_FUNCTION_FAILED;
ret = ERROR_FUNCTION_FAILED;
goto end;
}
ERR("storage = %p propertysetstorage = %p\n", db->storage, psstg);
grfMode = STGM_READ | STGM_SHARE_EXCLUSIVE;
r = IPropertySetStorage_Open( psstg, &FMTID_SummaryInformation, grfMode, &ps );
@ -137,7 +135,7 @@ UINT WINAPI MsiGetSummaryInformationW(MSIHANDLE hDatabase,
suminfo->propstg = ps;
handle = alloc_msihandle( &suminfo->hdr );
if( handle )
*phSummaryInfo = handle;
*phSummaryInfo = handle;
else
ret = ERROR_FUNCTION_FAILED;
msiobj_release( &suminfo->hdr );
@ -147,7 +145,7 @@ end:
IPropertyStorage_Release(ps);
if( psstg )
IPropertySetStorage_Release(psstg);
if (db)
if( db )
msiobj_release(&db->hdr);
return ret;
@ -163,6 +161,7 @@ UINT WINAPI MsiSummaryInfoGetPropertyCount(MSIHANDLE hSummaryInfo, UINT *pCount)
if( !suminfo )
return ERROR_INVALID_HANDLE;
msiobj_release( &suminfo->hdr );
return ERROR_CALL_NOT_IMPLEMENTED;
}
@ -174,6 +173,7 @@ UINT WINAPI MsiSummaryInfoGetPropertyA(
HRESULT r;
PROPSPEC spec;
PROPVARIANT var;
UINT rc = ERROR_SUCCESS;
TRACE("%ld %d %p %p %p %p %p\n",
hSummaryInfo, uiProperty, puiDataType, piValue,
@ -188,7 +188,10 @@ UINT WINAPI MsiSummaryInfoGetPropertyA(
r = IPropertyStorage_ReadMultiple( suminfo->propstg, 1, &spec, &var);
if( FAILED(r) )
return ERROR_FUNCTION_FAILED;
{
rc = ERROR_FUNCTION_FAILED;
goto end;
}
if( puiDataType )
*puiDataType = var.vt;
@ -217,7 +220,9 @@ UINT WINAPI MsiSummaryInfoGetPropertyA(
break;
}
return ERROR_SUCCESS;
end:
msiobj_release( &suminfo->hdr );
return rc;
}
UINT WINAPI MsiSummaryInfoGetPropertyW(
@ -228,6 +233,7 @@ UINT WINAPI MsiSummaryInfoGetPropertyW(
HRESULT r;
PROPSPEC spec;
PROPVARIANT var;
UINT rc = ERROR_SUCCESS;
TRACE("%ld %d %p %p %p %p %p\n",
hSummaryInfo, uiProperty, puiDataType, piValue,
@ -242,7 +248,10 @@ UINT WINAPI MsiSummaryInfoGetPropertyW(
r = IPropertyStorage_ReadMultiple( suminfo->propstg, 1, &spec, &var);
if( FAILED(r) )
return ERROR_FUNCTION_FAILED;
{
rc = ERROR_FUNCTION_FAILED;
goto end;
}
if( puiDataType )
*puiDataType = var.vt;
@ -272,24 +281,31 @@ UINT WINAPI MsiSummaryInfoGetPropertyW(
break;
}
return ERROR_SUCCESS;
end:
msiobj_release( &suminfo->hdr );
return rc;
}
UINT WINAPI MsiSummaryInfoSetPropertyA( MSIHANDLE hSummaryInfo, UINT uiProperty,
UINT uiDataType, INT iValue,
FILETIME* pftValue, LPSTR szValue)
FILETIME* pftValue, LPSTR szValue )
{
FIXME("%ld %u %u %i %p %s\n", hSummaryInfo, uiProperty,
uiDataType, iValue, pftValue, debugstr_a(szValue) );
return ERROR_CALL_NOT_IMPLEMENTED;
}
UINT WINAPI MsiSummaryInfoSetPropertyW( MSIHANDLE hSummaryInfo, UINT uiProperty,
UINT uiDataType, INT iValue,
FILETIME* pftValue, LPWSTR szValue)
FILETIME* pftValue, LPWSTR szValue )
{
FIXME("%ld %u %u %i %p %s\n", hSummaryInfo, uiProperty,
uiDataType, iValue, pftValue, debugstr_w(szValue) );
return ERROR_CALL_NOT_IMPLEMENTED;
}
UINT WINAPI MsiSummaryInfoPersist(MSIHANDLE hSummaryInfo)
UINT WINAPI MsiSummaryInfoPersist( MSIHANDLE hSummaryInfo )
{
FIXME("%ld\n", hSummaryInfo );
return ERROR_CALL_NOT_IMPLEMENTED;
}

5
reactos/lib/msi/table.c
View file

@ -1220,7 +1220,10 @@ static UINT TABLE_execute( struct tagMSIVIEW *view, MSIRECORD *record )
TRACE("%p %p\n", tv, record);
if( tv->table )
return ERROR_FUNCTION_FAILED;
{
release_table( tv->db, tv->table );
tv->table = NULL;
}
r = get_table( tv->db, tv->name, &tv->table );
if( r != ERROR_SUCCESS )

1
reactos/lib/msi/where.c
View file

@ -247,6 +247,7 @@ static UINT WHERE_execute( struct tagMSIVIEW *view, MSIRECORD *record )
if( !wv->reorder )
return ERROR_FUNCTION_FAILED;
wv->row_count = 0;
for( i=0; i<count; i++ )
{
val = 0;