format.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "wine/debug.h"
#include "msi.h"
#include "winnls.h"
#include "objbase.h"
#include "oleauto.h"
#include "msipriv.h"
#include "winemsi_s.h"
#include "wine/exception.h"

Include dependency graph for format.c:

Go to the source code of this file.

Classes
struct	_tagFORMAT
struct	_tagFORMSTR
struct	_tagSTACK

Macros
#define	COBJMACROS
#define	FORMAT_NULL   0x0001
#define	FORMAT_LITERAL   0x0002
#define	FORMAT_NUMBER   0x0004
#define	FORMAT_LBRACK   0x0010
#define	FORMAT_LBRACE   0x0020
#define	FORMAT_RBRACK   0x0011
#define	FORMAT_RBRACE   0x0021
#define	FORMAT_ESCAPE   0x0040
#define	FORMAT_PROPNULL   0x0080
#define	FORMAT_ERROR   0x1000
#define	FORMAT_FAIL   0x2000
#define	left_type(x)   (x & 0xF0)

Typedefs
typedef struct _tagFORMAT	FORMAT
typedef struct _tagFORMSTR	FORMSTR
typedef struct _tagSTACK	STACK

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msi)
static STACK *	create_stack (void)
static void	free_stack (STACK *stack)
static void	stack_push (STACK *stack, FORMSTR *str)
static FORMSTR *	stack_pop (STACK *stack)
static FORMSTR *	stack_find (STACK *stack, int type)
static FORMSTR *	stack_peek (STACK *stack)
static LPCWSTR	get_formstr_data (FORMAT *format, FORMSTR *str)
static WCHAR *	dup_formstr (FORMAT *format, FORMSTR *str, int *ret_len)
static WCHAR *	deformat_index (FORMAT *format, FORMSTR *str, int *ret_len)
static WCHAR *	deformat_property (FORMAT *format, FORMSTR *str, int *ret_len)
static WCHAR *	deformat_component (FORMAT *format, FORMSTR *str, int *ret_len)
static WCHAR *	deformat_file (FORMAT *format, FORMSTR *str, BOOL shortname, int *ret_len)
static WCHAR *	deformat_environment (FORMAT *format, FORMSTR *str, int *ret_len)
static WCHAR *	deformat_literal (FORMAT *format, FORMSTR *str, BOOL *propfound, int *type, int *len)
static WCHAR *	build_default_format (const MSIRECORD *record)
static BOOL	format_is_number (WCHAR x)
static BOOL	format_str_is_number (LPWSTR str)
static BOOL	format_is_alpha (WCHAR x)
static BOOL	format_is_literal (WCHAR x)
static int	format_lex (FORMAT *format, FORMSTR **out)
static FORMSTR *	format_replace (FORMAT *format, BOOL propfound, BOOL nonprop, int oldsize, int type, WCHAR *replace, int len)
static WCHAR *	replace_stack_group (FORMAT *format, STACK *values, BOOL *propfound, BOOL *nonprop, int *oldsize, int *type, int *len)
static WCHAR *	replace_stack_prop (FORMAT *format, STACK *values, BOOL *propfound, BOOL *nonprop, int *oldsize, int *type, int *len)
static UINT	replace_stack (FORMAT *format, STACK *stack, STACK *values)
static BOOL	verify_format (LPWSTR data)
static DWORD	deformat_string_internal (MSIPACKAGE *package, LPCWSTR ptr, WCHAR **data, DWORD *len, MSIRECORD *record)
UINT	MSI_FormatRecordW (MSIPACKAGE *package, MSIRECORD *record, LPWSTR buffer, LPDWORD size)
UINT WINAPI	MsiFormatRecordW (MSIHANDLE hInstall, MSIHANDLE hRecord, WCHAR *szResult, DWORD *sz)
UINT WINAPI	MsiFormatRecordA (MSIHANDLE hinst, MSIHANDLE hrec, char *buf, DWORD *sz)
DWORD	deformat_string (MSIPACKAGE *package, const WCHAR *fmt, WCHAR **data)

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 25 of file format.c.

FORMAT_ERROR

#define FORMAT_ERROR   0x1000

Definition at line 52 of file format.c.

FORMAT_ESCAPE

#define FORMAT_ESCAPE   0x0040

Definition at line 50 of file format.c.

FORMAT_FAIL

#define FORMAT_FAIL   0x2000

Definition at line 53 of file format.c.

FORMAT_LBRACE

#define FORMAT_LBRACE   0x0020

Definition at line 47 of file format.c.

FORMAT_LBRACK

#define FORMAT_LBRACK   0x0010

Definition at line 46 of file format.c.

FORMAT_LITERAL

#define FORMAT_LITERAL   0x0002

Definition at line 44 of file format.c.

FORMAT_NULL

#define FORMAT_NULL   0x0001

Definition at line 43 of file format.c.

FORMAT_NUMBER

#define FORMAT_NUMBER   0x0004

Definition at line 45 of file format.c.

FORMAT_PROPNULL

#define FORMAT_PROPNULL   0x0080

Definition at line 51 of file format.c.

FORMAT_RBRACE

#define FORMAT_RBRACE   0x0021

Definition at line 49 of file format.c.

FORMAT_RBRACK

#define FORMAT_RBRACK   0x0011

Definition at line 48 of file format.c.

left_type

#define left_type

(

x

)

(x & 0xF0)

Definition at line 55 of file format.c.

Typedef Documentation

FORMAT

typedef struct _tagFORMAT FORMAT

FORMSTR

typedef struct _tagFORMSTR FORMSTR

STACK

typedef struct _tagSTACK STACK

Function Documentation

build_default_format()

static WCHAR * build_default_format ( const MSIRECORD *  record )

static

Definition at line 342 of file format.c.

{
    int i, count = MSI_RecordGetFieldCount( record );
    WCHAR *ret, *tmp, buf[26];
    DWORD size = 1;
 
    if (!(ret = msi_alloc( sizeof(*ret) ))) return NULL;
    ret[0] = 0;
 
    for (i = 1; i <= count; i++)
    {
        size += swprintf( buf, ARRAY_SIZE(buf), L"%d: [%d] ", i, i );
        if (!(tmp = msi_realloc( ret, size * sizeof(*ret) )))
        {
            msi_free( ret );
            return NULL;
        }
        ret = tmp;
        lstrcatW( ret, buf );
    }
    return ret;
}

Referenced by MSI_FormatRecordW().

create_stack()

static STACK * create_stack ( void  )

static

Definition at line 84 of file format.c.

{
    STACK *stack = msi_alloc(sizeof(STACK));
    list_init(&stack->items);
    return stack;
}

Referenced by deformat_string_internal().

deformat_component()

static WCHAR * deformat_component ( FORMAT *  format, FORMSTR *  str, int *  ret_len  )

static

Definition at line 206 of file format.c.

{
    WCHAR *key, *ret;
    MSICOMPONENT *comp;
 
    if (!(key = msi_alloc( (str->len + 1) * sizeof(WCHAR) ))) return NULL;
    lstrcpynW(key, get_formstr_data(format, str), str->len + 1);
 
    if (!(comp = msi_get_loaded_component( format->package, key )))
    {
        msi_free( key );
        return NULL;
    }
    if (comp->Action == INSTALLSTATE_SOURCE)
        ret = msi_resolve_source_folder( format->package, comp->Directory, NULL );
    else
        ret = strdupW( msi_get_target_folder( format->package, comp->Directory ) );
 
    if (ret) *ret_len = lstrlenW( ret );
    else *ret_len = 0;
    msi_free( key );
    return ret;
}

Referenced by deformat_literal().

deformat_environment()

static WCHAR * deformat_environment ( FORMAT *  format, FORMSTR *  str, int *  ret_len  )

static

Definition at line 260 of file format.c.

{
    WCHAR *key, *ret = NULL;
    DWORD len;
 
    if (!(key = msi_alloc((str->len + 1) * sizeof(WCHAR)))) return NULL;
    lstrcpynW(key, get_formstr_data(format, str), str->len + 1);
 
    if ((len = GetEnvironmentVariableW( key, NULL, 0 )))
    {
        len++;
        if ((ret = msi_alloc( len * sizeof(WCHAR) )))
            *ret_len = GetEnvironmentVariableW( key, ret, len );
    }
    msi_free( key );
    return ret;
}

Referenced by deformat_literal().

deformat_file()

static WCHAR * deformat_file ( FORMAT *  format, FORMSTR *  str, BOOL  shortname, int *  ret_len  )

static

Definition at line 230 of file format.c.

{
    WCHAR *key, *ret = NULL;
    const MSIFILE *file;
    DWORD len = 0;
 
    if (!(key = msi_alloc( (str->len + 1) * sizeof(WCHAR) ))) return NULL;
    lstrcpynW(key, get_formstr_data(format, str), str->len + 1);
 
    if (!(file = msi_get_loaded_file( format->package, key ))) goto done;
    if (!shortname)
    {
        if ((ret = strdupW( file->TargetPath ))) len = lstrlenW( ret );
        goto done;
    }
    if (!(len = GetShortPathNameW(file->TargetPath, NULL, 0)))
    {
        if ((ret = strdupW( file->TargetPath ))) len = lstrlenW( ret );
        goto done;
    }
    len++;
    if ((ret = msi_alloc( len * sizeof(WCHAR) )))
        len = GetShortPathNameW( file->TargetPath, ret, len );
 
done:
    msi_free( key );
    *ret_len = len;
    return ret;
}

Referenced by deformat_literal().

deformat_index()

static WCHAR * deformat_index ( FORMAT *  format, FORMSTR *  str, int *  ret_len  )

static

Definition at line 157 of file format.c.

{
    WCHAR *val, *ret;
    DWORD len;
    int field;
 
    if (!(val = msi_alloc( (str->len + 1) * sizeof(WCHAR) ))) return NULL;
    lstrcpynW(val, get_formstr_data(format, str), str->len + 1);
    field = wcstol( val, NULL, 10 );
    msi_free( val );
 
    if (MSI_RecordIsNull( format->record, field ) ||
        MSI_RecordGetStringW( format->record, field, NULL, &len )) return NULL;
 
    len++;
    if (!(ret = msi_alloc( len * sizeof(WCHAR) ))) return NULL;
    ret[0] = 0;
    if (MSI_RecordGetStringW( format->record, field, ret, &len ))
    {
        msi_free( ret );
        return NULL;
    }
    *ret_len = len;
    return ret;
}

Referenced by replace_stack_prop().

deformat_literal()

static WCHAR * deformat_literal ( FORMAT *  format, FORMSTR *  str, BOOL *  propfound, int *  type, int *  len  )

static

Definition at line 278 of file format.c.

{
    LPCWSTR data = get_formstr_data(format, str);
    WCHAR *replaced = NULL;
    char ch = data[0];
 
    if (ch == '\\')
    {
        str->n++;
        if (str->len == 1)
        {
            str->len = 0;
            replaced = NULL;
        }
        else
        {
            str->len = 1;
            replaced = dup_formstr( format, str, len );
        }
    }
    else if (ch == '~')
    {
        if (str->len != 1)
            replaced = NULL;
        else if ((replaced = msi_alloc( sizeof(WCHAR) )))
        {
            *replaced = 0;
            *len = 0;
        }
    }
    else if (ch == '%' || ch == '#' || ch == '!' || ch == '$')
    {
        str->n++;
        str->len--;
 
        switch (ch)
        {
        case '%':
            replaced = deformat_environment( format, str, len ); break;
        case '#':
            replaced = deformat_file( format, str, FALSE, len ); break;
        case '!':
            replaced = deformat_file( format, str, TRUE, len ); break;
        case '$':
            replaced = deformat_component( format, str, len ); break;
        }
 
        *type = FORMAT_LITERAL;
    }
    else
    {
        replaced = deformat_property( format, str, len );
        *type = FORMAT_LITERAL;
 
        if (replaced)
            *propfound = TRUE;
        else
            format->propfailed = TRUE;
    }
 
    return replaced;
}

Referenced by replace_stack_prop().

deformat_property()

static WCHAR * deformat_property ( FORMAT *  format, FORMSTR *  str, int *  ret_len  )

static

Definition at line 183 of file format.c.

{
    WCHAR *prop, *ret;
    DWORD len = 0;
    UINT r;
 
    if (!(prop = msi_alloc( (str->len + 1) * sizeof(WCHAR) ))) return NULL;
    lstrcpynW( prop, get_formstr_data(format, str), str->len + 1 );
 
    r = msi_get_property( format->package->db, prop, NULL, &len );
    if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
    {
        msi_free( prop );
        return NULL;
    }
    len++;
    if ((ret = msi_alloc( len * sizeof(WCHAR) )))
        msi_get_property( format->package->db, prop, ret, &len );
    msi_free( prop );
    *ret_len = len;
    return ret;
}

Referenced by deformat_literal().

deformat_string()

DWORD deformat_string	(	MSIPACKAGE *	package,
		const WCHAR *	fmt,
		WCHAR **	data
	)

Definition at line 1016 of file format.c.

{
    DWORD len;
    MSIRECORD *rec;
 
    *data = NULL;
    if (!fmt) return 0;
    if (!(rec = MSI_CreateRecord( 1 ))) return 0;
 
    MSI_RecordSetStringW( rec, 0, fmt );
    MSI_FormatRecordW( package, rec, NULL, &len );
    if (!(*data = msi_alloc( ++len * sizeof(WCHAR) )))
    {
        msiobj_release( &rec->hdr );
        return 0;
    }
    MSI_FormatRecordW( package, rec, *data, &len );
    msiobj_release( &rec->hdr );
    return len;
}

Referenced by ACTION_CustomAction(), dialog_create_window(), dialog_handle_event(), expand_any_path(), HANDLE_CustomType18(), HANDLE_CustomType19(), HANDLE_CustomType2(), HANDLE_CustomType34(), HANDLE_CustomType50(), internal_ui_handler(), ITERATE_BindImage(), ITERATE_CreateShortcuts(), ITERATE_DeleteService(), ITERATE_InstallService(), ITERATE_LaunchConditions(), iterate_load_verb(), ITERATE_RemoveEnvironmentString(), ITERATE_RemoveExistingProducts(), ITERATE_RemoveIniValuesOnInstall(), ITERATE_RemoveIniValuesOnUninstall(), ITERATE_RemoveRegistryValuesOnInstall(), ITERATE_RemoveRegistryValuesOnUninstall(), ITERATE_StartService(), ITERATE_StopService(), ITERATE_WriteEnvironmentString(), ITERATE_WriteIniValues(), ITERATE_WriteRegistryValues(), load_appid(), load_class(), msi_dialog_send_event(), msi_dialog_set_property_event(), msi_get_deformatted_field(), msi_listview_add_item(), msi_publish_install_properties(), parse_value(), resolve_keypath(), and search_reg().

deformat_string_internal()

static DWORD deformat_string_internal ( MSIPACKAGE *  package, LPCWSTR  ptr, WCHAR **  data, DWORD *  len, MSIRECORD *  record  )

static

Definition at line 756 of file format.c.

{
    FORMAT format;
    FORMSTR *str = NULL;
    STACK *stack, *temp;
    FORMSTR *node;
    int type;
 
    if (!ptr)
    {
        *data = NULL;
        *len = 0;
        return ERROR_SUCCESS;
    }
 
    *data = strdupW(ptr);
    *len = lstrlenW(ptr);
 
    ZeroMemory(&format, sizeof(FORMAT));
    format.package = package;
    format.record = record;
    format.deformatted = *data;
    format.len = *len;
 
    if (!verify_format(*data))
        return ERROR_SUCCESS;
 
    stack = create_stack();
    temp = create_stack();
 
    while ((type = format_lex(&format, &str)) != FORMAT_NULL)
    {
        if (type == FORMAT_LBRACK || type == FORMAT_LBRACE ||
            type == FORMAT_LITERAL || type == FORMAT_NUMBER ||
            type == FORMAT_ESCAPE || type == FORMAT_PROPNULL)
        {
            if (type == FORMAT_LBRACE)
            {
                format.propfailed = FALSE;
                format.groups++;
            }
            else if (type == FORMAT_ESCAPE &&
                     !stack_find(stack, FORMAT_LBRACK))
            {
                format.n -= str->len - 1;
                str->len = 1;
            }
 
            stack_push(stack, str);
        }
        else if (type == FORMAT_RBRACK || type == FORMAT_RBRACE)
        {
            if (type == FORMAT_RBRACE)
                format.groups--;
 
            stack_push(stack, str);
 
            if (stack_find(stack, left_type(type)))
            {
                do
                {
                    node = stack_pop(stack);
                    stack_push(temp, node);
                } while (node->type != left_type(type));
 
                replace_stack(&format, stack, temp);
            }
        }
    }
 
    *data = format.deformatted;
    *len = format.len;
 
    msi_free(str);
    free_stack(stack);
    free_stack(temp);
 
    return ERROR_SUCCESS;
}

Referenced by MSI_FormatRecordW().

dup_formstr()

static WCHAR * dup_formstr ( FORMAT *  format, FORMSTR *  str, int *  ret_len  )

static

Definition at line 143 of file format.c.

{
    WCHAR *val;
 
    if (!str->len) return NULL;
    if ((val = msi_alloc( (str->len + 1) * sizeof(WCHAR) )))
    {
        memcpy( val, get_formstr_data(format, str), str->len * sizeof(WCHAR) );
        val[str->len] = 0;
        *ret_len = str->len;
    }
    return val;
}

Referenced by deformat_literal(), replace_stack_group(), and replace_stack_prop().

format_is_alpha()

static BOOL format_is_alpha ( WCHAR  x )

static

Definition at line 381 of file format.c.

{
    return (!format_is_number(x) && x != '\0' &&
            x != '[' && x != ']' && x != '{' && x != '}');
}

Referenced by format_is_literal(), and format_lex().

format_is_literal()

static BOOL format_is_literal ( WCHAR  x )

static

Definition at line 387 of file format.c.

{
    return (format_is_alpha(x) || format_is_number(x));
}

Referenced by format_lex().

format_is_number()

static BOOL format_is_number ( WCHAR  x )

static

Definition at line 365 of file format.c.

{
    return ((x >= '0') && (x <= '9'));
}

Referenced by format_is_alpha(), format_is_literal(), format_lex(), and format_str_is_number().

format_lex()

static int format_lex ( FORMAT *  format, FORMSTR **  out  )

static

Definition at line 392 of file format.c.

{
    int type, len = 1;
    FORMSTR *str;
    LPCWSTR data;
    WCHAR ch;
 
    *out = NULL;
 
    if (!format->deformatted)
        return FORMAT_NULL;
 
    *out = msi_alloc_zero(sizeof(FORMSTR));
    if (!*out)
        return FORMAT_FAIL;
 
    str = *out;
    str->n = format->n;
    str->len = 1;
    data = get_formstr_data(format, str);
 
    ch = data[0];
    switch (ch)
    {
        case '{': type = FORMAT_LBRACE; break;
        case '}': type = FORMAT_RBRACE; break;
        case '[': type = FORMAT_LBRACK; break;
        case ']': type = FORMAT_RBRACK; break;
        case '~': type = FORMAT_PROPNULL; break;
        case '\0': type = FORMAT_NULL; break;
 
        default:
            type = 0;
    }
 
    if (type)
    {
        str->type = type;
        format->n++;
        return type;
    }
 
    if (ch == '\\')
    {
        while (data[len] && data[len] != ']')
            len++;
 
        type = FORMAT_ESCAPE;
    }
    else if (format_is_alpha(ch))
    {
        while (format_is_literal(data[len]))
            len++;
 
        type = FORMAT_LITERAL;
    }
    else if (format_is_number(ch))
    {
        while (format_is_number(data[len]))
            len++;
 
        type = FORMAT_NUMBER;
 
        if (data[len] != ']')
        {
            while (format_is_literal(data[len]))
                len++;
 
            type = FORMAT_LITERAL;
        }
    }
    else
    {
        ERR("Got unknown character %c(%x)\n", ch, ch);
        return FORMAT_ERROR;
    }
 
    format->n += len;
    str->len = len;
    str->type = type;
 
    return type;
}

Referenced by deformat_string_internal().

format_replace()

static FORMSTR * format_replace ( FORMAT *  format, BOOL  propfound, BOOL  nonprop, int  oldsize, int  type, WCHAR *  replace, int  len  )

static

Definition at line 476 of file format.c.

{
    FORMSTR *ret;
    LPWSTR str, ptr;
    DWORD size = 0;
    int n;
 
    if (replace)
    {
        if (!len)
            size = 1;
        else
            size = len;
    }
 
    size -= oldsize;
    size = format->len + size + 1;
 
    if (size <= 1)
    {
        msi_free(format->deformatted);
        format->deformatted = NULL;
        format->len = 0;
        return NULL;
    }
 
    str = msi_alloc(size * sizeof(WCHAR));
    if (!str)
        return NULL;
 
    str[0] = '\0';
    memcpy(str, format->deformatted, format->n * sizeof(WCHAR));
    n = format->n;
 
    if (replace)
    {
        if (!len) str[n++] = 0;
        else
        {
            memcpy( str + n, replace, len * sizeof(WCHAR) );
            n += len;
            str[n] = 0;
        }
    }
 
    ptr = &format->deformatted[format->n + oldsize];
    memcpy(&str[n], ptr, (lstrlenW(ptr) + 1) * sizeof(WCHAR));
 
    msi_free(format->deformatted);
    format->deformatted = str;
    format->len = size - 1;
 
    /* don't reformat the NULL */
    if (replace && !len)
        format->n++;
 
    if (!replace)
        return NULL;
 
    ret = msi_alloc_zero(sizeof(FORMSTR));
    if (!ret)
        return NULL;
 
    ret->len = len;
    ret->type = type;
    ret->n = format->n;
    ret->propfound = propfound;
    ret->nonprop = nonprop;
 
    return ret;
}

Referenced by replace_stack().

format_str_is_number()

static BOOL format_str_is_number ( LPWSTR  str )

static

Definition at line 370 of file format.c.

{
    LPWSTR ptr;
 
    for (ptr = str; *ptr; ptr++)
        if (!format_is_number(*ptr))
            return FALSE;
 
    return TRUE;
}

Referenced by replace_stack_prop().

free_stack()

static void free_stack ( STACK *  stack )

static

Definition at line 91 of file format.c.

{
    while (!list_empty(&stack->items))
    {
        FORMSTR *str = LIST_ENTRY(list_head(&stack->items), FORMSTR, entry);
        list_remove(&str->entry);
        msi_free(str);
    }
 
    msi_free(stack);
}

Referenced by deformat_string_internal().

get_formstr_data()

static LPCWSTR get_formstr_data ( FORMAT *  format, FORMSTR *  str  )

static

Definition at line 138 of file format.c.

{
    return &format->deformatted[str->n];
}

Referenced by deformat_component(), deformat_environment(), deformat_file(), deformat_index(), deformat_literal(), deformat_property(), dup_formstr(), and format_lex().

MSI_FormatRecordW()

UINT MSI_FormatRecordW	(	MSIPACKAGE *	package,
		MSIRECORD *	record,
		LPWSTR	buffer,
		LPDWORD	size
	)

Definition at line 838 of file format.c.

{
    WCHAR *format, *deformated = NULL;
    UINT rc = ERROR_INVALID_PARAMETER;
    DWORD len;
    MSIRECORD *record_deformated;
    int field_count, i;
 
    TRACE("%p %p %p %p\n", package, record, buffer, size);
    dump_record(record);
 
    if (!(format = msi_dup_record_field( record, 0 )))
        format = build_default_format( record );
 
    field_count = MSI_RecordGetFieldCount(record);
    record_deformated = MSI_CloneRecord(record);
    if (!record_deformated)
    {
        rc = ERROR_OUTOFMEMORY;
        goto end;
    }
    MSI_RecordSetStringW(record_deformated, 0, format);
    for (i = 1; i <= field_count; i++)
    {
        if (MSI_RecordGetString(record, i))
        {
            deformat_string_internal(package, MSI_RecordGetString(record, i), &deformated, &len, NULL);
            MSI_RecordSetStringW(record_deformated, i, deformated);
            msi_free(deformated);
        }
    }
 
    deformat_string_internal(package, format, &deformated, &len, record_deformated);
    if (buffer)
    {
        if (*size>len)
        {
            memcpy(buffer,deformated,len*sizeof(WCHAR));
            rc = ERROR_SUCCESS;
            buffer[len] = 0;
        }
        else
        {
            if (*size > 0)
            {
                memcpy(buffer,deformated,(*size)*sizeof(WCHAR));
                buffer[(*size)-1] = 0;
            }
            rc = ERROR_MORE_DATA;
        }
    }
    else rc = ERROR_SUCCESS;
 
    *size = len;
    msiobj_release(&record_deformated->hdr);
end:
    msi_free( format );
    msi_free( deformated );
    return rc;
}

Referenced by deformat_string(), MSI_ProcessMessageVerbatim(), MsiFormatRecordA(), and MsiFormatRecordW().

MsiFormatRecordA()

UINT WINAPI MsiFormatRecordA	(	MSIHANDLE	hinst,
		MSIHANDLE	hrec,
		char *	buf,
		DWORD *	sz
	)

Definition at line 955 of file format.c.

{
    MSIPACKAGE *package;
    MSIRECORD *rec;
    LPWSTR value;
    DWORD len;
    UINT r;
 
    TRACE( "%lu, %lu, %p, %p\n", hinst, hrec, buf, sz );
 
    rec = msihandle2msiinfo(hrec, MSIHANDLETYPE_RECORD);
    if (!rec)
        return ERROR_INVALID_HANDLE;
 
    package = msihandle2msiinfo(hinst, MSIHANDLETYPE_PACKAGE);
    if (!package)
    {
        LPWSTR value = NULL;
        MSIHANDLE remote;
 
        if ((remote = msi_get_remote(hinst)))
        {
            __TRY
            {
                r = remote_FormatRecord(remote, (struct wire_record *)&rec->count, &value);
            }
            __EXCEPT(rpc_filter)
            {
                r = GetExceptionCode();
            }
            __ENDTRY
 
            if (!r)
                r = msi_strncpyWtoA(value, -1, buf, sz, TRUE);
 
            midl_user_free(value);
            msiobj_release(&rec->hdr);
            return r;
        }
    }
 
    r = MSI_FormatRecordW(package, rec, NULL, &len);
    if (r != ERROR_SUCCESS)
        return r;
 
    value = msi_alloc(++len * sizeof(WCHAR));
    if (!value)
        goto done;
 
    r = MSI_FormatRecordW(package, rec, value, &len);
    if (!r)
        r = msi_strncpyWtoA(value, len, buf, sz, FALSE);
 
    msi_free(value);
done:
    msiobj_release(&rec->hdr);
    if (package) msiobj_release(&package->hdr);
    return r;
}

Referenced by query_file_path(), test_format_record(), test_formatrecord(), test_formatrecord2(), test_formatrecord_package(), and test_formatrecord_tables().

MsiFormatRecordW()

UINT WINAPI MsiFormatRecordW	(	MSIHANDLE	hInstall,
		MSIHANDLE	hRecord,
		WCHAR *	szResult,
		DWORD *	sz
	)

Definition at line 900 of file format.c.

{
    UINT r = ERROR_INVALID_HANDLE;
    MSIPACKAGE *package;
    MSIRECORD *record;
 
    TRACE( "%lu, %lu, %p, %p\n", hInstall, hRecord, szResult, sz );
 
    record = msihandle2msiinfo(hRecord, MSIHANDLETYPE_RECORD);
    if (!record)
        return ERROR_INVALID_HANDLE;
 
    package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
    if (!package)
    {
        LPWSTR value = NULL;
        MSIHANDLE remote;
 
        if ((remote = msi_get_remote(hInstall)))
        {
            __TRY
            {
                r = remote_FormatRecord(remote, (struct wire_record *)&record->count, &value);
            }
            __EXCEPT(rpc_filter)
            {
                r = GetExceptionCode();
            }
            __ENDTRY
 
            if (!r)
                r = msi_strncpyW(value, -1, szResult, sz);
 
            midl_user_free(value);
            msiobj_release(&record->hdr);
            return r;
        }
    }
 
    if (!sz)
    {
        msiobj_release( &record->hdr );
        if (szResult)
            return ERROR_INVALID_PARAMETER;
        else
            return ERROR_SUCCESS;
    }
 
    r = MSI_FormatRecordW( package, record, szResult, sz );
    msiobj_release( &record->hdr );
    if (package)
        msiobj_release( &package->hdr );
    return r;
}

Referenced by s_remote_FormatRecord(), and test_format_record().

replace_stack()

static UINT replace_stack ( FORMAT *  format, STACK *  stack, STACK *  values  )

static

Definition at line 679 of file format.c.

{
    WCHAR *replaced = NULL;
    FORMSTR *beg, *top, *node;
    BOOL propfound = FALSE, nonprop = FALSE, group = FALSE;
    int type, n, len = 0, oldsize = 0;
 
    node = stack_peek(values);
    type = node->type;
    n = node->n;
 
    if (type == FORMAT_LBRACK)
        replaced = replace_stack_prop( format, values, &propfound,
                                       &nonprop, &oldsize, &type, &len );
    else if (type == FORMAT_LBRACE)
    {
        replaced = replace_stack_group( format, values, &propfound,
                                        &nonprop, &oldsize, &type, &len );
        group = TRUE;
    }
 
    format->n = n;
    beg = format_replace( format, propfound, nonprop, oldsize, type, replaced, len );
    msi_free(replaced);
    if (!beg)
        return ERROR_SUCCESS;
 
    format->n = beg->n + beg->len;
 
    top = stack_peek(stack);
    if (top)
    {
        type = top->type;
 
        if ((type == FORMAT_LITERAL || type == FORMAT_NUMBER) &&
            type == beg->type)
        {
            top->len += beg->len;
 
            if (group)
                top->nonprop = FALSE;
 
            if (type == FORMAT_LITERAL)
                top->nonprop = beg->nonprop;
 
            if (beg->propfound)
                top->propfound = TRUE;
 
            msi_free(beg);
            return ERROR_SUCCESS;
        }
    }
 
    stack_push(stack, beg);
    return ERROR_SUCCESS;
}

Referenced by deformat_string_internal().

replace_stack_group()

static WCHAR * replace_stack_group ( FORMAT *  format, STACK *  values, BOOL *  propfound, BOOL *  nonprop, int *  oldsize, int *  type, int *  len  )

static

Definition at line 549 of file format.c.

{
    WCHAR *replaced;
    FORMSTR *content, *node;
    int n;
 
    *nonprop = FALSE;
    *propfound = FALSE;
 
    node = stack_pop(values);
    n = node->n;
    *oldsize = node->len;
    msi_free(node);
 
    while ((node = stack_pop(values)))
    {
        *oldsize += node->len;
 
        if (node->nonprop)
            *nonprop = TRUE;
 
        if (node->propfound)
            *propfound = TRUE;
 
        msi_free(node);
    }
 
    content = msi_alloc_zero(sizeof(FORMSTR));
    content->n = n;
    content->len = *oldsize;
    content->type = FORMAT_LITERAL;
 
    if (!format->groupfailed && (*oldsize == 2 ||
        (format->propfailed && !*nonprop)))
    {
        msi_free(content);
        return NULL;
    }
    else if (format->deformatted[content->n + 1] == '{' &&
             format->deformatted[content->n + content->len - 2] == '}')
    {
        format->groupfailed = FALSE;
        content->len = 0;
    }
    else if (*propfound && !*nonprop &&
             !format->groupfailed && format->groups == 0)
    {
        content->n++;
        content->len -= 2;
    }
    else
    {
        if (format->groups != 0)
            format->groupfailed = TRUE;
 
        *nonprop = TRUE;
    }
 
    replaced = dup_formstr( format, content, len );
    *type = content->type;
    msi_free(content);
 
    if (format->groups == 0)
        format->propfailed = FALSE;
 
    return replaced;
}

Referenced by replace_stack().

replace_stack_prop()

static WCHAR * replace_stack_prop ( FORMAT *  format, STACK *  values, BOOL *  propfound, BOOL *  nonprop, int *  oldsize, int *  type, int *  len  )

static

Definition at line 619 of file format.c.

{
    WCHAR *replaced;
    FORMSTR *content, *node;
    int n;
 
    *propfound = FALSE;
    *nonprop = FALSE;
 
    node = stack_pop(values);
    n = node->n;
    *oldsize = node->len;
    *type = stack_peek(values)->type;
    msi_free(node);
 
    while ((node = stack_pop(values)))
    {
        *oldsize += node->len;
 
        if (*type != FORMAT_ESCAPE &&
            stack_peek(values) && node->type != *type)
            *type = FORMAT_LITERAL;
 
        msi_free(node);
    }
 
    content = msi_alloc_zero(sizeof(FORMSTR));
    content->n = n + 1;
    content->len = *oldsize - 2;
    content->type = *type;
 
    if (*type == FORMAT_NUMBER && format->record)
    {
        replaced = deformat_index( format, content, len );
        if (replaced)
            *propfound = TRUE;
        else
            format->propfailed = TRUE;
 
        if (replaced)
            *type = format_str_is_number(replaced) ?
                FORMAT_NUMBER : FORMAT_LITERAL;
    }
    else if (format->package)
    {
        replaced = deformat_literal( format, content, propfound, type, len );
    }
    else
    {
        *nonprop = TRUE;
        content->n--;
        content->len += 2;
        replaced = dup_formstr( format, content, len );
    }
    msi_free(content);
    return replaced;
}

Referenced by replace_stack().

stack_find()

static FORMSTR * stack_find ( STACK *  stack, int  type  )

static

Definition at line 120 of file format.c.

{
    FORMSTR *str;
 
    LIST_FOR_EACH_ENTRY(str, &stack->items, FORMSTR, entry)
    {
        if (str->type == type)
            return str;
    }
 
    return NULL;
}

Referenced by deformat_string_internal().

stack_peek()

static FORMSTR * stack_peek ( STACK *  stack )

static

Definition at line 133 of file format.c.

{
    return LIST_ENTRY(list_head(&stack->items), FORMSTR, entry);
}

Referenced by replace_stack(), and replace_stack_prop().

stack_pop()

static FORMSTR * stack_pop ( STACK *  stack )

static

Definition at line 108 of file format.c.

{
    FORMSTR *ret;
 
    if (list_empty(&stack->items))
        return NULL;
 
    ret = LIST_ENTRY(list_head(&stack->items), FORMSTR, entry);
    list_remove(&ret->entry);
    return ret;
}

Referenced by deformat_string_internal(), replace_stack_group(), and replace_stack_prop().

stack_push()

static void stack_push ( STACK *  stack, FORMSTR *  str  )

static

Definition at line 103 of file format.c.

{
    list_add_head(&stack->items, &str->entry);
}

Referenced by deformat_string_internal(), and replace_stack().

verify_format()

static BOOL verify_format ( LPWSTR  data )

static

Definition at line 736 of file format.c.

{
    int count = 0;
 
    while (*data)
    {
        if (*data == '[' && *(data - 1) != '\\')
            count++;
        else if (*data == ']')
            count--;
 
        data++;
    }
 
    if (count > 0)
        return FALSE;
 
    return TRUE;
}

Referenced by deformat_string_internal().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msi

)