format_msg.c File Reference

#include "config.h"
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "ntstatus.h"
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "winternl.h"
#include "winuser.h"
#include "winnls.h"
#include "wine/unicode.h"
#include "kernel_private.h"
#include "wine/debug.h"

Include dependency graph for format_msg.c:

Go to the source code of this file.

Classes
struct	format_args
struct	_format_message_data

Macros
#define	WIN32_NO_STATUS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (resource)
static LPWSTR	load_message (HMODULE module, UINT id, WORD lang)
static LPWSTR	search_message (DWORD flags, HMODULE module, UINT id, WORD lang)
static ULONG_PTR	get_arg (int nr, DWORD flags, struct format_args *args)
static LPCWSTR	format_insert (BOOL unicode_caller, int insert, LPCWSTR format, DWORD flags, struct format_args *args, LPWSTR *result)
static void	format_add_char (struct _format_message_data *fmd, WCHAR c)
static LPWSTR	format_message (BOOL unicode_caller, DWORD dwFlags, LPCWSTR fmtstr, struct format_args *format_args)
DWORD WINAPI	FormatMessageA (DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, __ms_va_list *args)
DWORD WINAPI	FormatMessageW (DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPWSTR lpBuffer, DWORD nSize, __ms_va_list *args)

Macro Definition Documentation

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 41 of file format_msg.c.

Function Documentation

format_add_char()

static void format_add_char ( struct _format_message_data *  fmd, WCHAR  c  )

static

Definition at line 313 of file format_msg.c.

{
    *fmd->t++ = c;
    if (fmd->width && fmd->width != FORMAT_MESSAGE_MAX_WIDTH_MASK)
    {
        switch (c) {
        case '\r':
        case '\n':
            fmd->space = NULL;
            fmd->inspace = FALSE;
            fmd->w = 0;
            break;
        case ' ':
            if (!fmd->inspace)
                fmd->space = fmd->t - 1;
            fmd->inspace = TRUE;
            fmd->w++;
            break;
        default:
            fmd->inspace = FALSE;
            fmd->w++;
        }
        if (fmd->w == fmd->width) {
            LPWSTR notspace;
            if (fmd->space) {
                notspace = fmd->space;
                while (notspace != fmd->t && *notspace == ' ')
                    notspace++;
            } else
                notspace = fmd->space = fmd->t;
            fmd->w = fmd->t - notspace;
            memmove(fmd->space+2, notspace, fmd->w * sizeof(*fmd->t));
            *fmd->space++ = '\r';
            *fmd->space++ = '\n';
            fmd->t = fmd->space + fmd->w;
            fmd->space = NULL;
            fmd->inspace = FALSE;
        }
    }
    if ((DWORD)(fmd->t - fmd->formatted) == fmd->size) {
        DWORD_PTR ispace = fmd->space - fmd->formatted;
        /* Allocate two extra characters so we can insert a '\r\n' in
         * the middle of a word.
         */
        fmd->formatted = HeapReAlloc(GetProcessHeap(), 0, fmd->formatted, (fmd->size * 2 + 2) * sizeof(WCHAR));
        fmd->t = fmd->formatted + fmd->size;
        if (fmd->space)
            fmd->space = fmd->formatted + ispace;
        fmd->size *= 2;
    }
}

Referenced by format_message().

format_insert()

static LPCWSTR format_insert ( BOOL  unicode_caller, int  insert, LPCWSTR  format, DWORD  flags, struct format_args *  args, LPWSTR *  result  )

static

Definition at line 165 of file format_msg.c.

{
    static const WCHAR fmt_u[] = {'%','u',0};
    WCHAR *wstring = NULL, *p, fmt[256];
    ULONG_PTR arg;
    int size;
 
    if (*format != '!')  /* simple string */
    {
        arg = get_arg( insert, flags, args );
        if (unicode_caller || !arg)
        {
            static const WCHAR nullW[] = {'(','n','u','l','l',')',0};
            const WCHAR *str = (const WCHAR *)arg;
 
            if (!str) str = nullW;
            *result = HeapAlloc( GetProcessHeap(), 0, (strlenW(str) + 1) * sizeof(WCHAR) );
            strcpyW( *result, str );
        }
        else
        {
            const char *str = (const char *)arg;
            DWORD length = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
            *result = HeapAlloc( GetProcessHeap(), 0, length * sizeof(WCHAR) );
            MultiByteToWideChar( CP_ACP, 0, str, -1, *result, length );
        }
        return format;
    }
 
    format++;
    p = fmt;
    *p++ = '%';
 
    while (*format == '0' ||
           *format == '+' ||
           *format == '-' ||
           *format == ' ' ||
           *format == '*' ||
           *format == '#')
    {
        if (*format == '*')
        {
            p += sprintfW( p, fmt_u, get_arg( insert, flags, args ));
            insert = -1;
            format++;
        }
        else *p++ = *format++;
    }
    while (isdigitW(*format)) *p++ = *format++;
 
    if (*format == '.')
    {
        *p++ = *format++;
        if (*format == '*')
        {
            p += sprintfW( p, fmt_u, get_arg( insert, flags, args ));
            insert = -1;
            format++;
        }
        else
            while (isdigitW(*format)) *p++ = *format++;
    }
 
    /* replicate MS bug: drop an argument when using va_list with width/precision */
    if (insert == -1 && args->list) args->last--;
    arg = get_arg( insert, flags, args );
 
    /* check for ascii string format */
    if ((format[0] == 'h' && format[1] == 's') ||
        (format[0] == 'h' && format[1] == 'S') ||
        (unicode_caller && format[0] == 'S') ||
        (!unicode_caller && format[0] == 's'))
    {
        DWORD len = MultiByteToWideChar( CP_ACP, 0, (char *)arg, -1, NULL, 0 );
        wstring = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
        MultiByteToWideChar( CP_ACP, 0, (char *)arg, -1, wstring, len );
        arg = (ULONG_PTR)wstring;
        *p++ = 's';
    }
    /* check for ascii character format */
    else if ((format[0] == 'h' && format[1] == 'c') ||
             (format[0] == 'h' && format[1] == 'C') ||
             (unicode_caller && format[0] == 'C') ||
             (!unicode_caller && format[0] == 'c'))
    {
        char ch = arg;
        wstring = HeapAlloc( GetProcessHeap(), 0, 2 * sizeof(WCHAR) );
        MultiByteToWideChar( CP_ACP, 0, &ch, 1, wstring, 1 );
        wstring[1] = 0;
        arg = (ULONG_PTR)wstring;
        *p++ = 's';
    }
    /* check for wide string format */
    else if ((format[0] == 'l' && format[1] == 's') ||
             (format[0] == 'l' && format[1] == 'S') ||
             (format[0] == 'w' && format[1] == 's') ||
             (!unicode_caller && format[0] == 'S'))
    {
        *p++ = 's';
    }
    /* check for wide character format */
    else if ((format[0] == 'l' && format[1] == 'c') ||
             (format[0] == 'l' && format[1] == 'C') ||
             (format[0] == 'w' && format[1] == 'c') ||
             (!unicode_caller && format[0] == 'C'))
    {
        *p++ = 'c';
    }
    /* FIXME: handle I64 etc. */
    else while (*format && *format != '!') *p++ = *format++;
 
    *p = 0;
    size = 256;
    for (;;)
    {
        WCHAR *ret = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) );
        int needed = snprintfW( ret, size, fmt, arg );
        if (needed == -1 || needed >= size)
        {
            HeapFree( GetProcessHeap(), 0, ret );
            size = max( needed + 1, size * 2 );
        }
        else
        {
            *result = ret;
            break;
        }
    }
 
    while (*format && *format != '!') format++;
    if (*format == '!') format++;
 
    HeapFree( GetProcessHeap(), 0, wstring );
    return format;
}

Referenced by format_message().

format_message()

static LPWSTR format_message ( BOOL  unicode_caller, DWORD  dwFlags, LPCWSTR  fmtstr, struct format_args *  format_args  )

static

Definition at line 368 of file format_msg.c.

{
    struct _format_message_data fmd;
    LPCWSTR f;
    BOOL eos = FALSE;
 
    fmd.size = 100;
    fmd.formatted = fmd.t = HeapAlloc( GetProcessHeap(), 0, (fmd.size + 2) * sizeof(WCHAR) );
 
    fmd.width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
    fmd.w = 0;
    fmd.inspace = FALSE;
    fmd.space = NULL;
    f = fmtstr;
    while (*f && !eos) {
        if (*f=='%') {
            int insertnr;
            WCHAR *str,*x;
 
            f++;
            switch (*f) {
            case '1':case '2':case '3':case '4':case '5':
            case '6':case '7':case '8':case '9':
                if (dwFlags & FORMAT_MESSAGE_IGNORE_INSERTS)
                    goto ignore_inserts;
                else if (((dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY) && !format_args->args) ||
                        (!(dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY) && !format_args->list))
                {
                    SetLastError(ERROR_INVALID_PARAMETER);
                    HeapFree(GetProcessHeap(), 0, fmd.formatted);
                    return NULL;
                }
                insertnr = *f-'0';
                switch (f[1]) {
                case '0':case '1':case '2':case '3':
                case '4':case '5':case '6':case '7':
                case '8':case '9':
                    f++;
                    insertnr = insertnr*10 + *f-'0';
                    f++;
                    break;
                default:
                    f++;
                    break;
                }
                f = format_insert( unicode_caller, insertnr, f, dwFlags, format_args, &str );
                for (x = str; *x; x++) format_add_char(&fmd, *x);
                HeapFree( GetProcessHeap(), 0, str );
                break;
            case 'n':
                format_add_char(&fmd, '\r');
                format_add_char(&fmd, '\n');
                f++;
                break;
            case 'r':
                format_add_char(&fmd, '\r');
                f++;
                break;
            case 't':
                format_add_char(&fmd, '\t');
                f++;
                break;
            case '0':
                eos = TRUE;
                f++;
                break;
            case '\0':
                SetLastError(ERROR_INVALID_PARAMETER);
                HeapFree(GetProcessHeap(), 0, fmd.formatted);
                return NULL;
            ignore_inserts:
            default:
                if (dwFlags & FORMAT_MESSAGE_IGNORE_INSERTS)
                    format_add_char(&fmd, '%');
                format_add_char(&fmd, *f++);
                break;
            }
        } else {
            WCHAR ch = *f;
            f++;
            if (ch == '\r') {
                if (*f == '\n')
                    f++;
                if(fmd.width)
                    format_add_char(&fmd, ' ');
                else
                {
                    format_add_char(&fmd, '\r');
                    format_add_char(&fmd, '\n');
                }
            } else {
                if (ch == '\n')
                {
                    if(fmd.width)
                        format_add_char(&fmd, ' ');
                    else
                    {
                        format_add_char(&fmd, '\r');
                        format_add_char(&fmd, '\n');
                    }
                }
                else
                    format_add_char(&fmd, ch);
            }
        }
    }
    *fmd.t = '\0';
 
    return fmd.formatted;
}

Referenced by FormatMessageA(), and FormatMessageW().

FormatMessageA()

DWORD WINAPI FormatMessageA	(	DWORD	dwFlags,
		LPCVOID	lpSource,
		DWORD	dwMessageId,
		DWORD	dwLanguageId,
		LPSTR	lpBuffer,
		DWORD	nSize,
		__ms_va_list *	args
	)

Definition at line 483 of file format_msg.c.

{
    struct format_args format_args;
    DWORD ret = 0;
    LPWSTR  target;
    DWORD   destlength;
    LPWSTR  from;
 
    TRACE("(0x%x,%p,%d,0x%x,%p,%d,%p)\n",
          dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
 
    if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
    {
        if (!lpBuffer)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return 0;
        }
        else
            *(LPSTR *)lpBuffer = NULL;
    }
 
    if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
    {
        format_args.args = (ULONG_PTR *)args;
        format_args.list = NULL;
        format_args.last = 0;
    }
    else
    {
        format_args.args = NULL;
        format_args.list = args;
        format_args.last = 0;
    }
 
    from = NULL;
    if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
    {
        DWORD length = MultiByteToWideChar(CP_ACP, 0, lpSource, -1, NULL, 0);
        from = HeapAlloc( GetProcessHeap(), 0, length * sizeof(WCHAR) );
        MultiByteToWideChar(CP_ACP, 0, lpSource, -1, from, length);
    }
    else if (dwFlags & (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_FROM_SYSTEM))
    {
        from = search_message( dwFlags, (HMODULE)lpSource, dwMessageId, dwLanguageId );
        if (!from) return 0;
    }
    else
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    target = format_message( FALSE, dwFlags, from, &format_args );
    if (!target)
        goto failure;
 
    TRACE("-- %s\n", debugstr_w(target));
 
    /* Only try writing to an output buffer if there are processed characters
     * in the temporary output buffer. */
    if (*target)
    {
        destlength = WideCharToMultiByte(CP_ACP, 0, target, -1, NULL, 0, NULL, NULL);
        if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
        {
            LPSTR buf = LocalAlloc(LMEM_ZEROINIT, max(nSize, destlength));
            WideCharToMultiByte(CP_ACP, 0, target, -1, buf, destlength, NULL, NULL);
            *((LPSTR*)lpBuffer) = buf;
        }
        else
        {
            if (nSize < destlength)
            {
                SetLastError(ERROR_INSUFFICIENT_BUFFER);
                goto failure;
            }
            WideCharToMultiByte(CP_ACP, 0, target, -1, lpBuffer, destlength, NULL, NULL);
        }
        ret = destlength - 1; /* null terminator */
    }
 
failure:
    HeapFree(GetProcessHeap(),0,target);
    HeapFree(GetProcessHeap(),0,from);
    if (!(dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)) HeapFree( GetProcessHeap(), 0, format_args.args );
    TRACE("-- returning %u\n", ret);
    return ret;
}

Referenced by doit(), error(), ATL::ChTraitsCRT< char >::FormatMessageV(), CVfdShExt::GetCommandString(), OutputError(), ReportLastError(), ShellMessageBoxA(), test_format_message(), test_message_allocate_buffer(), test_message_from_hmodule(), test_message_from_string(), test_message_ignore_inserts(), test_message_insufficient_buffer(), test_message_invalid_flags(), test_message_null_buffer(), test_message_wrap(), and TestDceErrorInqText().

FormatMessageW()

DWORD WINAPI FormatMessageW	(	DWORD	dwFlags,
		LPCVOID	lpSource,
		DWORD	dwMessageId,
		DWORD	dwLanguageId,
		LPWSTR	lpBuffer,
		DWORD	nSize,
		__ms_va_list *	args
	)

Definition at line 583 of file format_msg.c.

{
    struct format_args format_args;
    DWORD ret = 0;
    LPWSTR target;
    DWORD talloced;
    LPWSTR from;
 
    TRACE("(0x%x,%p,%d,0x%x,%p,%d,%p)\n",
          dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
 
    if (!lpBuffer)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
        *(LPWSTR *)lpBuffer = NULL;
 
    if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
    {
        format_args.args = (ULONG_PTR *)args;
        format_args.list = NULL;
        format_args.last = 0;
    }
    else
    {
        format_args.args = NULL;
        format_args.list = args;
        format_args.last = 0;
    }
 
    from = NULL;
    if (dwFlags & FORMAT_MESSAGE_FROM_STRING) {
        from = HeapAlloc( GetProcessHeap(), 0, (strlenW(lpSource) + 1) *
            sizeof(WCHAR) );
        strcpyW( from, lpSource );
    }
    else if (dwFlags & (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_FROM_SYSTEM))
    {
        from = search_message( dwFlags, (HMODULE)lpSource, dwMessageId, dwLanguageId );
        if (!from) return 0;
    }
    else
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
 
    target = format_message( TRUE, dwFlags, from, &format_args );
    if (!target)
        goto failure;
 
    talloced = strlenW(target)+1;
    TRACE("-- %s\n",debugstr_w(target));
 
    /* Only allocate a buffer if there are processed characters in the
     * temporary output buffer. If a caller supplies the buffer, then
     * a null terminator will be written to it. */
    if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
    {
        if (*target)
        {
            /* nSize is the MINIMUM size */
            *((LPVOID*)lpBuffer) = LocalAlloc(LMEM_ZEROINIT, max(nSize, talloced)*sizeof(WCHAR));
            strcpyW(*(LPWSTR*)lpBuffer, target);
        }
    }
    else
    {
        if (nSize < talloced)
        {
            SetLastError(ERROR_INSUFFICIENT_BUFFER);
            goto failure;
        }
        strcpyW(lpBuffer, target);
    }
 
    ret = talloced - 1; /* null terminator */
failure:
    HeapFree(GetProcessHeap(),0,target);
    HeapFree(GetProcessHeap(),0,from);
    if (!(dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)) HeapFree( GetProcessHeap(), 0, format_args.args );
    TRACE("-- returning %u\n", ret);
    return ret;
}

Referenced by _SetOperationTexts(), build_systeminfo_tree(), CFn_WMCommand(), CheckForError(), cmdHelpMsg(), ConMsgPrintf2V(), ConMsgPuts(), DceErrorInqTextW(), DisplayError(), DisplayWin32Error(), dlg_win32error(), do_error_dialog(), doitW(), ErrorBox(), ErrorMessageBox(), export_validate_filename(), field_format_public_key(), format_message(), FormatMessageBox(), FormatMessageSafeW(), ATL::ChTraitsCRT< _CharType >::FormatMessageV(), FormatString(), get_file_handle(), CVfdShExt::GetCommandString(), GetCountryFromCountryCode(), GetError(), GetLastErrorText(), GetMessageStringFromDll(), import_validate_filename(), last_error::last_error(), LoadAndFormatString(), LoadAndFormatStringsCat(), LogToFile(), ntstatus_error::ntstatus_error(), OleUIAddVerbMenuW(), output_formatstring(), OutputText(), ParseLogonHours(), PRINTDLG_UpdatePrintDlgW(), PrintError(), PrintErrorMessage(), PrintErrorText(), PrintMessageString(), PrintMessageStringV(), PrintNetMessage(), PrintPaddedMessageString(), PrintWin32Error(), promptdisk_init(), SHELL_ConfirmDialogW(), SHELL_ErrorBoxHelper(), ShellMessageBoxW(), ShellMessageBoxWrapW(), ShowError(), CZipExtract::ShowExtractError(), ShowItemError(), ShowLastError(), ShowLastWin32Error(), ShowOutOfMemory(), ShowStepError(), ShowWin32Error(), START_TEST(), StatusBarLoadAndFormatString(), taskkill_vprintfW(), test_message_allocate_buffer_wide(), test_message_from_string_wide(), test_message_ignore_inserts_wide(), test_message_insufficient_buffer_wide(), test_message_invalid_flags_wide(), test_message_null_buffer_wide(), VarListLoadAndFormatString(), XCOPY_FailMessage(), and XCOPY_wprintf().

get_arg()

static ULONG_PTR get_arg ( int  nr, DWORD  flags, struct format_args *  args  )

static

Definition at line 149 of file format_msg.c.

{
    if (nr == -1) nr = args->last + 1;
    if (args->list)
    {
        if (!args->args) args->args = HeapAlloc( GetProcessHeap(), 0, 99 * sizeof(ULONG_PTR) );
        while (nr > args->last)
            args->args[args->last++] = va_arg( *args->list, ULONG_PTR );
    }
    if (nr > args->last) args->last = nr;
    return args->args[nr - 1];
}

Referenced by array_access(), exec_script(), and format_insert().

load_message()

static LPWSTR load_message ( HMODULE  module, UINT  id, WORD  lang  )

static

Definition at line 88 of file format_msg.c.

{
#ifdef __REACTOS__
    MESSAGE_RESOURCE_ENTRY *mre;
#else
    const MESSAGE_RESOURCE_ENTRY *mre;
#endif
    WCHAR *buffer;
    NTSTATUS status;
 
    TRACE("module = %p, id = %08x\n", module, id );
 
    if (!module) module = GetModuleHandleW( NULL );
#ifdef __REACTOS__
    status = RtlFindMessage(module, (ULONG_PTR)RT_MESSAGETABLE, lang, id, &mre);
    if (!NT_SUCCESS(status))
#else
    if ((status = RtlFindMessage( module, RT_MESSAGETABLE, lang, id, &mre )) != STATUS_SUCCESS)
#endif
    {
        SetLastError( RtlNtStatusToDosError(status) );
        return NULL;
    }
 
    if (mre->Flags & MESSAGE_RESOURCE_UNICODE)
    {
        int len = (strlenW( (const WCHAR *)mre->Text ) + 1) * sizeof(WCHAR);
        if (!(buffer = HeapAlloc( GetProcessHeap(), 0, len ))) return NULL;
        memcpy( buffer, mre->Text, len );
    }
    else
    {
        int len = MultiByteToWideChar( CP_ACP, 0, (const char *)mre->Text, -1, NULL, 0 );
        if (!(buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return NULL;
        MultiByteToWideChar( CP_ACP, 0, (const char*)mre->Text, -1, buffer, len );
    }
    TRACE("returning %s\n", wine_dbgstr_w(buffer));
    return buffer;
}

Referenced by search_message().

search_message()

static LPWSTR search_message ( DWORD  flags, HMODULE  module, UINT  id, WORD  lang  )

static

Definition at line 128 of file format_msg.c.

{
    LPWSTR from = NULL;
    if (flags & FORMAT_MESSAGE_FROM_HMODULE)
        from = load_message( module, id, lang );
    if (!from && (flags & FORMAT_MESSAGE_FROM_SYSTEM))
    {
        /* Fold win32 hresult to its embedded error code. */
        if (HRESULT_SEVERITY(id) == SEVERITY_ERROR &&
            HRESULT_FACILITY(id) == FACILITY_WIN32)
        {
            id = HRESULT_CODE(id);
        }
        from = load_message( kernel32_handle, id, lang );
    }
    return from;
}

Referenced by FormatMessageA(), and FormatMessageW().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

resource

)