#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:

Classes
struct	format

struct	form_str

class	stack< _Tp, _Sequence >

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)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msi)

static struct stack *	create_stack (void)

static void	free_stack (struct stack *stack)

static void	stack_push (struct stack stack, struct form_str str)

static struct form_str *	stack_pop (struct stack *stack)

static struct form_str *	stack_find (struct stack *stack, int type)

static struct form_str *	stack_peek (struct stack *stack)

static const WCHAR *	get_formstr_data (struct format format, struct form_str str)

static WCHAR *	dup_formstr (struct format format, struct form_str str, int *ret_len)

static WCHAR *	deformat_index (struct format format, struct form_str str, int *ret_len)

static WCHAR *	deformat_property (struct format format, struct form_str str, int *ret_len)

static WCHAR *	deformat_component (struct format format, struct form_str str, int *ret_len)

static WCHAR *	deformat_file (struct format format, struct form_str str, BOOL shortname, int *ret_len)

static WCHAR *	deformat_environment (struct format format, struct form_str str, int *ret_len)

static WCHAR *	deformat_literal (struct format format, struct form_str 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 (struct format format, struct form_str *out)

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

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

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

static UINT	replace_stack (struct format format, struct stack stack, struct 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.

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 = malloc( 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 = realloc( ret, size * sizeof(*ret) )))
        {
            free( ret );
            return NULL;
        }
        ret = tmp;
        lstrcatW( ret, buf );
    }
    return ret;
}

Referenced by MSI_FormatRecordW().

◆ create_stack()

static struct stack * create_stack ( void )

static

Definition at line 84 of file format.c.

{
    struct stack *stack = malloc(sizeof(*stack));
    list_init(&stack->items);
    return stack;
}

Referenced by deformat_string_internal().

◆ deformat_component()

static WCHAR * deformat_component	(	struct format *	format,
		struct form_str *	str,
		int *	ret_len
	)

static

Definition at line 206 of file format.c.

{
    WCHAR *key, *ret;
    MSICOMPONENT *comp;
 
    if (!(key = malloc( (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 )))
    {
        free( key );
        return NULL;
    }
    if (comp->Action == INSTALLSTATE_SOURCE)
        ret = msi_resolve_source_folder( format->package, comp->Directory, NULL );
    else
        ret = wcsdup( msi_get_target_folder( format->package, comp->Directory ) );
 
    if (ret) *ret_len = lstrlenW( ret );
    else *ret_len = 0;
    free( key );
    return ret;
}

Referenced by deformat_literal().

◆ deformat_environment()

static WCHAR * deformat_environment	(	struct format *	format,
		struct form_str *	str,
		int *	ret_len
	)

static

Definition at line 260 of file format.c.

{
    WCHAR *key, *ret = NULL;
    DWORD len;
 
    if (!(key = malloc((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 = malloc( len * sizeof(WCHAR) )))
            *ret_len = GetEnvironmentVariableW( key, ret, len );
    }
    free( key );
    return ret;
}

Referenced by deformat_literal().

◆ deformat_file()

static WCHAR * deformat_file	(	struct format *	format,
		struct form_str *	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 = malloc( (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 = wcsdup( file->TargetPath ))) len = lstrlenW( ret );
        goto done;
    }
    if (!(len = GetShortPathNameW(file->TargetPath, NULL, 0)))
    {
        if ((ret = wcsdup( file->TargetPath ))) len = lstrlenW( ret );
        goto done;
    }
    len++;
    if ((ret = malloc( len * sizeof(WCHAR) )))
        len = GetShortPathNameW( file->TargetPath, ret, len );
 
done:
    free( key );
    *ret_len = len;
    return ret;
}

Referenced by deformat_literal().

◆ deformat_index()

static WCHAR * deformat_index	(	struct format *	format,
		struct form_str *	str,
		int *	ret_len
	)

static

Definition at line 157 of file format.c.

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

Referenced by replace_stack_prop().

◆ deformat_literal()

static WCHAR * deformat_literal	(	struct format *	format,
		struct form_str *	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 = malloc( 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	(	struct format *	format,
		struct form_str *	str,
		int *	ret_len
	)

static

Definition at line 183 of file format.c.

{
    WCHAR *prop, *ret;
    DWORD len = 0;
    UINT r;
 
    if (!(prop = malloc( (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)
    {
        free( prop );
        return NULL;
    }
    len++;
    if ((ret = malloc( len * sizeof(WCHAR) )))
        msi_get_property( format->package->db, prop, ret, &len );
    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 = malloc( ++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(), dialog_send_event(), dialog_set_property_event(), expand_any_path(), get_deformatted_field(), 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(), listview_add_item(), load_appid(), load_class(), parse_value(), publish_install_properties(), 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.

{
    struct format format;
    struct form_str *str = NULL;
    struct stack *stack, *temp;
    struct form_str *node;
    int type;
 
    if (!ptr)
    {
        *data = NULL;
        *len = 0;
        return ERROR_SUCCESS;
    }
 
    *data = wcsdup(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;
 
    free(str);
    free_stack(stack);
    free_stack(temp);
 
    return ERROR_SUCCESS;
}

Referenced by MSI_FormatRecordW().

◆ dup_formstr()

static WCHAR * dup_formstr	(	struct format *	format,
		struct form_str *	str,
		int *	ret_len
	)

static

Definition at line 143 of file format.c.

{
    WCHAR *val;
 
    if (!str->len) return NULL;
    if ((val = malloc( (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	(	struct format *	format,
		struct form_str **	out
	)

static

Definition at line 392 of file format.c.

{
    int type, len = 1;
    struct form_str *str;
    LPCWSTR data;
    WCHAR ch;
 
    *out = NULL;
 
    if (!format->deformatted)
        return FORMAT_NULL;
 
    *out = calloc(1, sizeof(**out));
    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 struct form_str * format_replace	(	struct format *	format,
		BOOL	propfound,
		BOOL	nonprop,
		int	oldsize,
		int	type,
		WCHAR *	replace,
		int	len
	)

static

Definition at line 476 of file format.c.

{
    struct form_str *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)
    {
        free(format->deformatted);
        format->deformatted = NULL;
        format->len = 0;
        return NULL;
    }
 
    str = malloc(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));
 
    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 = calloc(1, sizeof(*ret));
    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 ( struct stack * stack )

static

Definition at line 91 of file format.c.

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

Referenced by deformat_string_internal().

◆ get_formstr_data()

static const WCHAR * get_formstr_data	(	struct format *	format,
		struct form_str *	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);
            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:
    free( format );
    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 = malloc(++len * sizeof(WCHAR));
    if (!value)
        goto done;
 
    r = MSI_FormatRecordW(package, rec, value, &len);
    if (!r)
        r = msi_strncpyWtoA(value, len, buf, sz, FALSE);
 
    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	(	struct format *	format,
		struct stack *	stack,
		struct stack *	values
	)

static

Definition at line 679 of file format.c.

{
    WCHAR *replaced = NULL;
    struct form_str *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 );
    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;
 
            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	(	struct format *	format,
		struct stack *	values,
		BOOL *	propfound,
		BOOL *	nonprop,
		int *	oldsize,
		int *	type,
		int *	len
	)

static

Definition at line 549 of file format.c.

{
    WCHAR *replaced;
    struct form_str *content, *node;
    int n;
 
    *nonprop = FALSE;
    *propfound = FALSE;
 
    node = stack_pop(values);
    n = node->n;
    *oldsize = node->len;
    free(node);
 
    while ((node = stack_pop(values)))
    {
        *oldsize += node->len;
 
        if (node->nonprop)
            *nonprop = TRUE;
 
        if (node->propfound)
            *propfound = TRUE;
 
        free(node);
    }
 
    content = calloc(1, sizeof(*content));
    content->n = n;
    content->len = *oldsize;
    content->type = FORMAT_LITERAL;
 
    if (!format->groupfailed && (*oldsize == 2 ||
        (format->propfailed && !*nonprop)))
    {
        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;
    free(content);
 
    if (format->groups == 0)
        format->propfailed = FALSE;
 
    return replaced;
}

Referenced by replace_stack().

◆ replace_stack_prop()

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

static

Definition at line 619 of file format.c.

{
    WCHAR *replaced;
    struct form_str *content, *node;
    int n;
 
    *propfound = FALSE;
    *nonprop = FALSE;
 
    node = stack_pop(values);
    n = node->n;
    *oldsize = node->len;
    *type = stack_peek(values)->type;
    free(node);
 
    while ((node = stack_pop(values)))
    {
        *oldsize += node->len;
 
        if (*type != FORMAT_ESCAPE &&
            stack_peek(values) && node->type != *type)
            *type = FORMAT_LITERAL;
 
        free(node);
    }
 
    content = calloc(1, sizeof(*content));
    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 );
    }
    free(content);
    return replaced;
}

Referenced by replace_stack().

◆ stack_find()

static struct form_str * stack_find	(	struct stack *	stack,
		int	type
	)

static

Definition at line 120 of file format.c.

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

Referenced by deformat_string_internal().

◆ stack_peek()

static struct form_str * stack_peek ( struct stack * stack )

static

Definition at line 133 of file format.c.

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

Referenced by replace_stack(), and replace_stack_prop().

◆ stack_pop()

static struct form_str * stack_pop ( struct stack * stack )

static

Definition at line 108 of file format.c.

{
    struct form_str *ret;
 
    if (list_empty(&stack->items))
        return NULL;
 
    ret = LIST_ENTRY(list_head(&stack->items), struct form_str, 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	(	struct stack *	stack,
		struct form_str *	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 )

Classes

Macros

Functions

Macro Definition Documentation

◆ COBJMACROS

◆ FORMAT_ERROR

◆ FORMAT_ESCAPE

◆ FORMAT_FAIL

◆ FORMAT_LBRACE

◆ FORMAT_LBRACK

◆ FORMAT_LITERAL

◆ FORMAT_NULL

◆ FORMAT_NUMBER

◆ FORMAT_PROPNULL

◆ FORMAT_RBRACE

◆ FORMAT_RBRACK

◆ left_type

Function Documentation

◆ build_default_format()

◆ create_stack()

◆ deformat_component()

◆ deformat_environment()

◆ deformat_file()

◆ deformat_index()

◆ deformat_literal()

◆ deformat_property()

◆ deformat_string()

◆ deformat_string_internal()

◆ dup_formstr()

◆ format_is_alpha()

◆ format_is_literal()

◆ format_is_number()

◆ format_lex()

◆ format_replace()

◆ format_str_is_number()

◆ free_stack()

◆ get_formstr_data()

◆ MSI_FormatRecordW()

◆ MsiFormatRecordA()

◆ MsiFormatRecordW()

◆ replace_stack()

◆ replace_stack_group()

◆ replace_stack_prop()

◆ stack_find()

◆ stack_peek()

◆ stack_pop()

◆ stack_push()

◆ verify_format()

◆ WINE_DEFAULT_DEBUG_CHANNEL()