outstream.c File Reference

Console I/O utility API – Output. More...

#include <stdlib.h>
#include <windef.h>
#include <winbase.h>
#include <wincon.h>
#include <winnls.h>
#include <strsafe.h>
#include <pseh/pseh2.h>
#include "conutils.h"
#include "stream.h"
#include "stream_private.h"

Include dependency graph for outstream.c:

Go to the source code of this file.

Macros
#define	UNICODE
#define	_UNICODE
#define	CON_RC_STRING_MAX_SIZE   4096

Functions
ConStreamWrite
Writes a counted string to a stream. Parameters [in] Stream Stream to which the write operation is issued. [in] szStr Pointer to the counted string to write. [in] len Length of the string pointed by szStr, specified in number of characters. Returns Numbers of characters successfully written to Stream.
INT	ConStreamWrite (IN PCON_STREAM Stream, IN PCTCH szStr, IN DWORD len)
ConPuts
Writes a NULL-terminated string to a stream. Parameters [in] Stream Stream to which the write operation is issued. [in] szStr Pointer to the NULL-terminated string to write. Returns Numbers of characters successfully written to Stream. Remarks Contrary to the CRT puts() function, ConPuts() does not append a terminating new-line character. In this way it behaves more like the CRT fputs() function.
INT	ConPuts (IN PCON_STREAM Stream, IN PCWSTR szStr)
ConPrintfV
Formats and writes a NULL-terminated string to a stream. Parameters [in] Stream Stream to which the write operation is issued. [in] szStr Pointer to the NULL-terminated format string, that follows the same specifications as the szStr format string in ConPrintf(). [in] args Parameter describing a variable number of arguments, initialized with va_start(), that can be expected by the function, depending on the szStr format string. Each argument is used to replace a format specifier in the format string. Returns Numbers of characters successfully written to Stream. See also ConPrintf(), printf(), vprintf()
INT	ConPrintfV (IN PCON_STREAM Stream, IN PCWSTR szStr, IN va_list args)
ConPrintf
Formats and writes a NULL-terminated string to a stream. Parameters [in] Stream Stream to which the write operation is issued. [in] szStr Pointer to the NULL-terminated format string, that follows the same specifications as the format string in printf(). This string can optionally contain embedded format specifiers that are replaced by the values specified in subsequent additional arguments and formatted as requested. [in] ... Additional arguments that can be expected by the function, depending on the szStr format string. Each argument is used to replace a format specifier in the format string. Returns Numbers of characters successfully written to Stream. See also ConPrintfV(), printf(), vprintf()
INT __cdecl	ConPrintf (IN PCON_STREAM Stream, IN PCWSTR szStr,...)
ConResPutsEx
Writes a string resource to a stream. Parameters [in] Stream Stream to which the write operation is issued. [in] hInstance Optional handle to an instance of the module whose executable file contains the string resource. Can be set to NULL to get the handle to the application itself. [in] uID The identifier of the string to be written. [in] LanguageId The language identifier of the resource. If this parameter is MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), the current language associated with the calling thread is used. To specify a language other than the current language, use the MAKELANGID macro to create this parameter. Returns Numbers of characters successfully written to Stream. Remarks Similarly to ConPuts(), no terminating new-line character is appended. See also ConPuts(), ConResPuts()
INT	ConResPutsEx (IN PCON_STREAM Stream, IN HINSTANCE hInstance OPTIONAL, IN UINT uID, IN LANGID LanguageId)
ConResPuts
Writes a string resource contained in the current application to a stream. Parameters [in] Stream Stream to which the write operation is issued. [in] uID The identifier of the string to be written. Returns Numbers of characters successfully written to Stream. Remarks Similarly to ConPuts(), no terminating new-line character is appended. See also ConPuts(), ConResPutsEx()
INT	ConResPuts (IN PCON_STREAM Stream, IN UINT uID)
ConResPrintfExV
Formats and writes a string resource to a stream. Parameters [in] Stream Stream to which the write operation is issued. [in] hInstance Optional handle to an instance of the module whose executable file contains the string resource. Can be set to NULL to get the handle to the application itself. [in] uID The identifier of the format string. The format string follows the same specifications as the szStr format string in ConPrintf(). [in] LanguageId The language identifier of the resource. If this parameter is MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), the current language associated with the calling thread is used. To specify a language other than the current language, use the MAKELANGID macro to create this parameter. [in] args Parameter describing a variable number of arguments, initialized with va_start(), that can be expected by the function, depending on the szStr format string. Each argument is used to replace a format specifier in the format string. Returns Numbers of characters successfully written to Stream. See also ConPrintf(), ConResPrintfEx(), ConResPrintfV(), ConResPrintf()
INT	ConResPrintfExV (IN PCON_STREAM Stream, IN HINSTANCE hInstance OPTIONAL, IN UINT uID, IN LANGID LanguageId, IN va_list args)
ConResPrintfV
Formats and writes a string resource contained in the current application to a stream. Parameters [in] Stream Stream to which the write operation is issued. [in] uID The identifier of the format string. The format string follows the same specifications as the szStr format string in ConPrintf(). [in] args Parameter describing a variable number of arguments, initialized with va_start(), that can be expected by the function, depending on the szStr format string. Each argument is used to replace a format specifier in the format string. Returns Numbers of characters successfully written to Stream. See also ConPrintf(), ConResPrintfExV(), ConResPrintfEx(), ConResPrintf()
INT	ConResPrintfV (IN PCON_STREAM Stream, IN UINT uID, IN va_list args)
ConResPrintfEx
Formats and writes a string resource to a stream. Parameters [in] Stream Stream to which the write operation is issued. [in] hInstance Optional handle to an instance of the module whose executable file contains the string resource. Can be set to NULL to get the handle to the application itself. [in] uID The identifier of the format string. The format string follows the same specifications as the szStr format string in ConPrintf(). [in] LanguageId The language identifier of the resource. If this parameter is MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), the current language associated with the calling thread is used. To specify a language other than the current language, use the MAKELANGID macro to create this parameter. [in] ... Additional arguments that can be expected by the function, depending on the szStr format string. Each argument is used to replace a format specifier in the format string. Returns Numbers of characters successfully written to Stream. See also ConPrintf(), ConResPrintfExV(), ConResPrintfV(), ConResPrintf()
INT __cdecl	ConResPrintfEx (IN PCON_STREAM Stream, IN HINSTANCE hInstance OPTIONAL, IN UINT uID, IN LANGID LanguageId,...)
ConResPrintf
Formats and writes a string resource contained in the current application to a stream. Parameters [in] Stream Stream to which the write operation is issued. [in] uID The identifier of the format string. The format string follows the same specifications as the szStr format string in ConPrintf(). [in] ... Additional arguments that can be expected by the function, depending on the szStr format string. Each argument is used to replace a format specifier in the format string. Returns Numbers of characters successfully written to Stream. See also ConPrintf(), ConResPrintfExV(), ConResPrintfEx(), ConResPrintfV()
INT __cdecl	ConResPrintf (IN PCON_STREAM Stream, IN UINT uID,...)
ConMsgPuts
Writes a message string to a stream without formatting. The function requires a message definition as input. The message definition can come from a buffer passed to the function. It can come from a message table resource in an already-loaded module, or the caller can ask the function to search the system's message table resource(s) for the message definition. Please refer to the Win32 FormatMessage() function for more details. Parameters [in] Stream Stream to which the write operation is issued. [in] dwFlags The formatting options, and how to interpret the lpSource parameter. See FormatMessage() for more details. The FORMAT_MESSAGE_ALLOCATE_BUFFER and FORMAT_MESSAGE_ARGUMENT_ARRAY flags are always ignored. The function implicitly uses the FORMAT_MESSAGE_IGNORE_INSERTS flag to implement its behaviour. [in] lpSource The location of the message definition. The type of this parameter depends upon the settings in the dwFlags parameter. [in] dwMessageId The message identifier for the requested message. This parameter is ignored if dwFlags includes FORMAT_MESSAGE_FROM_STRING. [in] dwLanguageId The language identifier for the requested message. This parameter is ignored if dwFlags includes FORMAT_MESSAGE_FROM_STRING. Returns Numbers of characters successfully written to Stream. Remarks Similarly to ConPuts(), no terminating new-line character is appended. See also ConPuts(), ConResPuts() and associated functions, FormatMessage() (on MSDN)
INT	ConMsgPuts (IN PCON_STREAM Stream, IN DWORD dwFlags, IN LPCVOID lpSource OPTIONAL, IN DWORD dwMessageId, IN DWORD dwLanguageId)
ConMsgPrintf2V
Formats and writes a message string to a stream. Remarks For internal use only. See also ConMsgPrintfV()
INT	ConMsgPrintf2V (IN PCON_STREAM Stream, IN DWORD dwFlags, IN LPCVOID lpSource OPTIONAL, IN DWORD dwMessageId, IN DWORD dwLanguageId, IN va_list args)
ConMsgPrintfV
Formats and writes a message string to a stream. The function requires a message definition as input. The message definition can come from a buffer passed to the function. It can come from a message table resource in an already-loaded module, or the caller can ask the function to search the system's message table resource(s) for the message definition. Please refer to the Win32 FormatMessage() function for more details. Parameters [in] Stream Stream to which the write operation is issued. [in] dwFlags The formatting options, and how to interpret the lpSource parameter. See FormatMessage() for more details. The FORMAT_MESSAGE_ALLOCATE_BUFFER flag is always ignored. [in] lpSource The location of the message definition. The type of this parameter depends upon the settings in the dwFlags parameter. [in] dwMessageId The message identifier for the requested message. This parameter is ignored if dwFlags includes FORMAT_MESSAGE_FROM_STRING. [in] dwLanguageId The language identifier for the requested message. This parameter is ignored if dwFlags includes FORMAT_MESSAGE_FROM_STRING. [in] Arguments Optional pointer to an array of values describing a variable number of arguments, depending on the message string. Each argument is used to replace an insert sequence in the message string. By default, the Arguments parameter is of type va_list*, initialized with va_start(). The state of the va_list argument is undefined upon return from the function. To use the va_list again, destroy the variable argument list pointer using va_end() and reinitialize it with va_start(). If you do not have a pointer of type va_list*, then specify the FORMAT_MESSAGE_ARGUMENT_ARRAY flag and pass a pointer to an array of DWORD_PTR values; those values are input to the message formatted as the insert values. Each insert must have a corresponding element in the array. Remarks Contrary to printf(), ConPrintf(), ConResPrintf() and associated functions, the ConMsg* functions work on format strings that contain insert sequences. These sequences extend the standard format specifiers as they allow to specify an insert number referring which precise value given in arguments to use. Returns Numbers of characters successfully written to Stream. See also ConPrintf(), ConResPrintf() and associated functions, ConMsgPrintf(), FormatMessage() (on MSDN)
INT	ConMsgPrintfV (IN PCON_STREAM Stream, IN DWORD dwFlags, IN LPCVOID lpSource OPTIONAL, IN DWORD dwMessageId, IN DWORD dwLanguageId, IN va_list *Arguments OPTIONAL)
ConMsgPrintf
Formats and writes a message string to a stream. The function requires a message definition as input. The message definition can come from a buffer passed to the function. It can come from a message table resource in an already-loaded module, or the caller can ask the function to search the system's message table resource(s) for the message definition. Please refer to the Win32 FormatMessage() function for more details. Parameters [in] Stream Stream to which the write operation is issued. [in] dwFlags The formatting options, and how to interpret the lpSource parameter. See FormatMessage() for more details. The FORMAT_MESSAGE_ALLOCATE_BUFFER and FORMAT_MESSAGE_ARGUMENT_ARRAY flags are always ignored. [in] lpSource The location of the message definition. The type of this parameter depends upon the settings in the dwFlags parameter. [in] dwMessageId The message identifier for the requested message. This parameter is ignored if dwFlags includes FORMAT_MESSAGE_FROM_STRING. [in] dwLanguageId The language identifier for the requested message. This parameter is ignored if dwFlags includes FORMAT_MESSAGE_FROM_STRING. [in] ... Additional arguments that can be expected by the function, depending on the message string. Each argument is used to replace an insert sequence in the message string. Remarks Contrary to printf(), ConPrintf(), ConResPrintf() and associated functions, the ConMsg* functions work on format strings that contain insert sequences. These sequences extend the standard format specifiers as they allow to specify an insert number referring which precise value given in arguments to use. Returns Numbers of characters successfully written to Stream. See also ConPrintf(), ConResPrintf() and associated functions, ConMsgPrintfV(), FormatMessage() (on MSDN)
INT __cdecl	ConMsgPrintf (IN PCON_STREAM Stream, IN DWORD dwFlags, IN LPCVOID lpSource OPTIONAL, IN DWORD dwMessageId, IN DWORD dwLanguageId,...)
ConResMsgPrintfExV
Formats and writes a message string to a stream. The function requires a message definition as input. Contrary to the ConMsg* or the Win32 FormatMessage() functions, the message definition comes from a resource string table, much like the strings for ConResPrintf(), but is formatted according to the rules of ConMsgPrintf(). Parameters [in] Stream Stream to which the write operation is issued. [in] hInstance Optional handle to an instance of the module whose executable file contains the string resource. Can be set to NULL to get the handle to the application itself. [in] dwFlags The formatting options, see FormatMessage() for more details. The only valid flags are FORMAT_MESSAGE_ARGUMENT_ARRAY, FORMAT_MESSAGE_IGNORE_INSERTS and FORMAT_MESSAGE_MAX_WIDTH_MASK. All the other flags are internally overridden by the function to implement its behaviour. [in] uID The identifier of the message string. The format string follows the same specifications as the lpSource format string in ConMsgPrintf(). [in] LanguageId The language identifier of the resource. If this parameter is MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), the current language associated with the calling thread is used. To specify a language other than the current language, use the MAKELANGID macro to create this parameter. [in] Arguments Optional pointer to an array of values describing a variable number of arguments, depending on the message string. Each argument is used to replace an insert sequence in the message string. By default, the Arguments parameter is of type va_list*, initialized with va_start(). The state of the va_list argument is undefined upon return from the function. To use the va_list again, destroy the variable argument list pointer using va_end() and reinitialize it with va_start(). If you do not have a pointer of type va_list*, then specify the FORMAT_MESSAGE_ARGUMENT_ARRAY flag and pass a pointer to an array of DWORD_PTR values; those values are input to the message formatted as the insert values. Each insert must have a corresponding element in the array. Remarks Contrary to printf(), ConPrintf(), ConResPrintf() and associated functions, the ConMsg* functions work on format strings that contain insert sequences. These sequences extend the standard format specifiers as they allow to specify an insert number referring which precise value given in arguments to use. Returns Numbers of characters successfully written to Stream. See also ConPrintf(), ConResPrintf() and associated functions, ConMsgPrintf(), FormatMessage() (on MSDN)
INT	ConResMsgPrintfExV (IN PCON_STREAM Stream, IN HINSTANCE hInstance OPTIONAL, IN DWORD dwFlags, IN UINT uID, IN LANGID LanguageId, IN va_list *Arguments OPTIONAL)
ConResMsgPrintfV
Formats and writes a message string to a stream. The function requires a message definition as input. Contrary to the ConMsg* or the Win32 FormatMessage() functions, the message definition comes from a resource string table, much like the strings for ConResPrintf(), but is formatted according to the rules of ConMsgPrintf(). Parameters [in] Stream Stream to which the write operation is issued. [in] dwFlags The formatting options, see FormatMessage() for more details. The only valid flags are FORMAT_MESSAGE_ARGUMENT_ARRAY, FORMAT_MESSAGE_IGNORE_INSERTS and FORMAT_MESSAGE_MAX_WIDTH_MASK. All the other flags are internally overridden by the function to implement its behaviour. [in] uID The identifier of the message string. The format string follows the same specifications as the lpSource format string in ConMsgPrintf(). [in] Arguments Optional pointer to an array of values describing a variable number of arguments, depending on the message string. Each argument is used to replace an insert sequence in the message string. By default, the Arguments parameter is of type va_list*, initialized with va_start(). The state of the va_list argument is undefined upon return from the function. To use the va_list again, destroy the variable argument list pointer using va_end() and reinitialize it with va_start(). If you do not have a pointer of type va_list*, then specify the FORMAT_MESSAGE_ARGUMENT_ARRAY flag and pass a pointer to an array of DWORD_PTR values; those values are input to the message formatted as the insert values. Each insert must have a corresponding element in the array. Remarks Contrary to printf(), ConPrintf(), ConResPrintf() and associated functions, the ConMsg* functions work on format strings that contain insert sequences. These sequences extend the standard format specifiers as they allow to specify an insert number referring which precise value given in arguments to use. Returns Numbers of characters successfully written to Stream. See also ConPrintf(), ConResPrintf() and associated functions, ConMsgPrintf(), FormatMessage() (on MSDN)
INT	ConResMsgPrintfV (IN PCON_STREAM Stream, IN DWORD dwFlags, IN UINT uID, IN va_list *Arguments OPTIONAL)
ConResMsgPrintfEx
Formats and writes a message string to a stream. The function requires a message definition as input. Contrary to the ConMsg* or the Win32 FormatMessage() functions, the message definition comes from a resource string table, much like the strings for ConResPrintf(), but is formatted according to the rules of ConMsgPrintf(). Parameters [in] Stream Stream to which the write operation is issued. [in] hInstance Optional handle to an instance of the module whose executable file contains the string resource. Can be set to NULL to get the handle to the application itself. [in] dwFlags The formatting options, see FormatMessage() for more details. The only valid flags are FORMAT_MESSAGE_IGNORE_INSERTS and FORMAT_MESSAGE_MAX_WIDTH_MASK. All the other flags are internally overridden by the function to implement its behaviour. [in] uID The identifier of the message string. The format string follows the same specifications as the lpSource format string in ConMsgPrintf(). [in] LanguageId The language identifier of the resource. If this parameter is MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), the current language associated with the calling thread is used. To specify a language other than the current language, use the MAKELANGID macro to create this parameter. [in] ... Additional arguments that can be expected by the function, depending on the message string. Each argument is used to replace an insert sequence in the message string. Remarks Contrary to printf(), ConPrintf(), ConResPrintf() and associated functions, the ConMsg* functions work on format strings that contain insert sequences. These sequences extend the standard format specifiers as they allow to specify an insert number referring which precise value given in arguments to use. Returns Numbers of characters successfully written to Stream. See also ConPrintf(), ConResPrintf() and associated functions, ConMsgPrintf(), FormatMessage() (on MSDN)
INT __cdecl	ConResMsgPrintfEx (IN PCON_STREAM Stream, IN HINSTANCE hInstance OPTIONAL, IN DWORD dwFlags, IN UINT uID, IN LANGID LanguageId,...)
ConResMsgPrintf
Formats and writes a message string to a stream. The function requires a message definition as input. Contrary to the ConMsg* or the Win32 FormatMessage() functions, the message definition comes from a resource string table, much like the strings for ConResPrintf(), but is formatted according to the rules of ConMsgPrintf(). Parameters [in] Stream Stream to which the write operation is issued. [in] dwFlags The formatting options, see FormatMessage() for more details. The only valid flags are FORMAT_MESSAGE_IGNORE_INSERTS and FORMAT_MESSAGE_MAX_WIDTH_MASK. All the other flags are internally overridden by the function to implement its behaviour. [in] uID The identifier of the message string. The format string follows the same specifications as the lpSource format string in ConMsgPrintf(). [in] ... Additional arguments that can be expected by the function, depending on the message string. Each argument is used to replace an insert sequence in the message string. Remarks Contrary to printf(), ConPrintf(), ConResPrintf() and associated functions, the ConMsg* functions work on format strings that contain insert sequences. These sequences extend the standard format specifiers as they allow to specify an insert number referring which precise value given in arguments to use. Returns Numbers of characters successfully written to Stream. See also ConPrintf(), ConResPrintf() and associated functions, ConMsgPrintf(), FormatMessage() (on MSDN)
INT __cdecl	ConResMsgPrintf (IN PCON_STREAM Stream, IN DWORD dwFlags, IN UINT uID,...)
VOID	ConClearLine (IN PCON_STREAM Stream)

ConWrite
Writes a counted string to a stream. Parameters [in] Stream Stream to which the write operation is issued. [in] szStr Pointer to the counted string to write. [in] len Length of the string pointed by szStr, specified in number of characters. Returns Numbers of characters successfully written to Stream. Note This function is used as an internal function. Use the ConStreamWrite() function instead. Remarks Should be called with the stream locked.
#define	CON_STREAM_WRITE_CALL(Stream, Str, Len)    (Stream)->WriteFunc((Stream), (Str), (Len))
#define	CON_STREAM_WRITE2(Stream, Str, Len, RetLen)
#define	CON_STREAM_WRITE(Stream, Str, Len)
INT __stdcall	ConWrite (IN PCON_STREAM Stream, IN PCTCH szStr, IN DWORD len)

Detailed Description

Console I/O utility API – Output.

Definition in file outstream.c.

Macro Definition Documentation

_UNICODE

#define _UNICODE

Definition at line 28 of file outstream.c.

CON_RC_STRING_MAX_SIZE

#define CON_RC_STRING_MAX_SIZE   4096

Definition at line 55 of file outstream.c.

CON_STREAM_WRITE

#define CON_STREAM_WRITE	(		Stream,
			Str,
			Len
	)

Value:

do { \
    EnterCriticalSection(&(Stream)->Lock); \
    CON_STREAM_WRITE_CALL((Stream), (Str), (Len)); \
    LeaveCriticalSection(&(Stream)->Lock); \
} while(0)

Definition at line 359 of file outstream.c.

CON_STREAM_WRITE2

#define CON_STREAM_WRITE2	(		Stream,
			Str,
			Len,
			RetLen
	)

Value:

do { \
    EnterCriticalSection(&(Stream)->Lock); \
    (RetLen) = CON_STREAM_WRITE_CALL((Stream), (Str), (Len)); \
    LeaveCriticalSection(&(Stream)->Lock); \
} while(0)

Definition at line 352 of file outstream.c.

CON_STREAM_WRITE_CALL

#define CON_STREAM_WRITE_CALL	(		Stream,
			Str,
			Len
	)		(Stream)->WriteFunc((Stream), (Str), (Len))

Definition at line 346 of file outstream.c.

UNICODE

#define UNICODE

NOTE: Experimental! Don't use USE_CRT yet because output to console is a bit broken

Definition at line 27 of file outstream.c.

Function Documentation

ConClearLine()

VOID ConClearLine

(

IN PCON_STREAM

Stream

)

Definition at line 1480 of file outstream.c.

{
    HANDLE hOutput = ConStreamGetOSHandle(Stream);
 
    /*
     * Erase the full line where the cursor is, and move
     * the cursor back to the beginning of the line.
     */
 
    if (IsConsoleHandle(hOutput))
    {
        CONSOLE_SCREEN_BUFFER_INFO csbi;
        DWORD dwWritten;
 
        GetConsoleScreenBufferInfo(hOutput, &csbi);
 
        csbi.dwCursorPosition.X = 0;
        // csbi.dwCursorPosition.Y;
 
        FillConsoleOutputCharacterW(hOutput, L' ',
                                    csbi.dwSize.X,
                                    csbi.dwCursorPosition,
                                    &dwWritten);
        SetConsoleCursorPosition(hOutput, csbi.dwCursorPosition);
    }
    else if (IsTTYHandle(hOutput))
    {
        ConPuts(Stream, L"\x1B[2K\x1B[1G"); // FIXME: Just use WriteFile
    }
    // else, do nothing for files
}

Referenced by PagePrompt().

ConMsgPrintf()

INT __cdecl ConMsgPrintf	(	IN PCON_STREAM	Stream,
		IN DWORD	dwFlags,
		IN LPCVOID lpSource	OPTIONAL,
		IN DWORD	dwMessageId,
		IN DWORD	dwLanguageId,
			...
	)

Definition at line 1128 of file outstream.c.

{
    INT Len;
    va_list args;
 
    /* Sanitize dwFlags */
    dwFlags &= ~FORMAT_MESSAGE_ARGUMENT_ARRAY;
 
    va_start(args, dwLanguageId);
    Len = ConMsgPrintfV(Stream,
                        dwFlags,
                        lpSource,
                        dwMessageId,
                        dwLanguageId,
                        &args);
    va_end(args);
 
    return Len;
}

ConMsgPrintf2V()

INT ConMsgPrintf2V	(	IN PCON_STREAM	Stream,
		IN DWORD	dwFlags,
		IN LPCVOID lpSource	OPTIONAL,
		IN DWORD	dwMessageId,
		IN DWORD	dwLanguageId,
		IN va_list	args
	)

Definition at line 907 of file outstream.c.

{
    INT Len;
    DWORD dwLength  = 0;
    LPWSTR lpMsgBuf = NULL;
 
    /*
     * Sanitize dwFlags. This version always ignores explicitly the inserts.
     * The string that we will return to the user will not be pre-formatted.
     */
    dwFlags |= FORMAT_MESSAGE_ALLOCATE_BUFFER; // Always allocate an internal buffer.
    dwFlags |= FORMAT_MESSAGE_IGNORE_INSERTS;  // Ignore inserts for FormatMessage.
    dwFlags &= ~FORMAT_MESSAGE_ARGUMENT_ARRAY;
 
    /*
     * Retrieve the message string without appending extra newlines.
     * Wrap in SEH to protect from invalid string parameters.
     */
    _SEH2_TRY
    {
        dwLength = FormatMessageW(dwFlags,
                                  lpSource,
                                  dwMessageId,
                                  dwLanguageId,
                                  (LPWSTR)&lpMsgBuf,
                                  0,
                                  NULL);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    Len = (INT)dwLength;
 
    if (!lpMsgBuf)
    {
        // ASSERT(dwLength == 0);
    }
    else
    {
        // ASSERT(dwLength != 0);
 
        /* lpMsgBuf is NULL-terminated by FormatMessage */
        Len = ConPrintfV(Stream, lpMsgBuf, args);
        // CON_STREAM_WRITE2(Stream, lpMsgBuf, dwLength, Len);
 
        /* Fixup returned length in case of errors */
        if (Len < 0)
            Len = 0;
 
        /* Free the buffer allocated by FormatMessage */
        LocalFree(lpMsgBuf);
    }
 
    return Len;
}

ConMsgPrintfV()

INT ConMsgPrintfV	(	IN PCON_STREAM	Stream,
		IN DWORD	dwFlags,
		IN LPCVOID lpSource	OPTIONAL,
		IN DWORD	dwMessageId,
		IN DWORD	dwLanguageId,
		IN va_list *Arguments	OPTIONAL
	)

Definition at line 1028 of file outstream.c.

{
    INT Len;
    DWORD dwLength  = 0;
    LPWSTR lpMsgBuf = NULL;
 
    /* Sanitize dwFlags */
    dwFlags |= FORMAT_MESSAGE_ALLOCATE_BUFFER; // Always allocate an internal buffer.
 
    /*
     * Retrieve the message string without appending extra newlines.
     * Use the "safe" FormatMessage version (SEH-protected) to protect
     * from invalid string parameters.
     */
    dwLength = FormatMessageSafeW(dwFlags,
                                  lpSource,
                                  dwMessageId,
                                  dwLanguageId,
                                  (LPWSTR)&lpMsgBuf,
                                  0,
                                  Arguments);
 
    Len = (INT)dwLength;
 
    if (!lpMsgBuf)
    {
        // ASSERT(dwLength == 0);
    }
    else
    {
        // ASSERT(dwLength != 0);
 
        CON_STREAM_WRITE2(Stream, lpMsgBuf, dwLength, Len);
 
        /* Fixup returned length in case of errors */
        if (Len < 0)
            Len = 0;
 
        /* Free the buffer allocated by FormatMessage */
        LocalFree(lpMsgBuf);
    }
 
    return Len;
}

Referenced by ConFormatMessage(), ConMsgPrintf(), and ErrorMessage().

ConMsgPuts()

INT ConMsgPuts	(	IN PCON_STREAM	Stream,
		IN DWORD	dwFlags,
		IN LPCVOID lpSource	OPTIONAL,
		IN DWORD	dwMessageId,
		IN DWORD	dwLanguageId
	)

Definition at line 835 of file outstream.c.

{
    INT Len;
    DWORD dwLength  = 0;
    LPWSTR lpMsgBuf = NULL;
 
    /*
     * Sanitize dwFlags. This version always ignores explicitly the inserts
     * as we emulate the behaviour of the (f)puts function.
     */
    dwFlags |= FORMAT_MESSAGE_ALLOCATE_BUFFER; // Always allocate an internal buffer.
    dwFlags |= FORMAT_MESSAGE_IGNORE_INSERTS;  // Ignore inserts for FormatMessage.
    dwFlags &= ~FORMAT_MESSAGE_ARGUMENT_ARRAY;
 
    /*
     * Retrieve the message string without appending extra newlines.
     * Wrap in SEH to protect from invalid string parameters.
     */
    _SEH2_TRY
    {
        dwLength = FormatMessageW(dwFlags,
                                  lpSource,
                                  dwMessageId,
                                  dwLanguageId,
                                  (LPWSTR)&lpMsgBuf,
                                  0,
                                  NULL);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
    }
    _SEH2_END;
 
    Len = (INT)dwLength;
 
    if (!lpMsgBuf)
    {
        // ASSERT(dwLength == 0);
    }
    else
    {
        // ASSERT(dwLength != 0);
 
        /* lpMsgBuf is NULL-terminated by FormatMessage */
        // Len = ConPuts(Stream, lpMsgBuf);
        CON_STREAM_WRITE2(Stream, lpMsgBuf, dwLength, Len);
 
        /* Fixup returned length in case of errors */
        if (Len < 0)
            Len = 0;
 
        /* Free the buffer allocated by FormatMessage */
        LocalFree(lpMsgBuf);
    }
 
    return Len;
}

Referenced by DisplayError(), DoFormatMessage(), HelpCommand(), PrintError(), and PrintWin32Error().

ConPrintf()

INT __cdecl ConPrintf	(	IN PCON_STREAM	Stream,
		IN PCWSTR	szStr,
			...
	)

Definition at line 519 of file outstream.c.

{
    INT Len;
    va_list args;
 
    // Len = vfwprintf(Stream->fStream, szMsgBuf, args); // vfprintf for direct ANSI
 
    // StringCchPrintfW
    va_start(args, szStr);
    Len = ConPrintfV(Stream, szStr, args);
    va_end(args);
 
    return Len;
}

ConPrintfV()

INT ConPrintfV	(	IN PCON_STREAM	Stream,
		IN PCWSTR	szStr,
		IN va_list	args
	)

Definition at line 465 of file outstream.c.

{
    INT Len;
    WCHAR bufSrc[CON_RC_STRING_MAX_SIZE];
 
    // Len = vfwprintf(Stream->fStream, szStr, args); // vfprintf for direct ANSI
 
    /*
     * Re-use szStr as the pointer to end-of-string, so as
     * to compute the string length instead of calling wcslen().
     */
    // StringCchVPrintfW(bufSrc, ARRAYSIZE(bufSrc), szStr, args);
    // Len = wcslen(bufSrc);
    StringCchVPrintfExW(bufSrc, ARRAYSIZE(bufSrc), (PWSTR*)&szStr, NULL, 0, szStr, args);
    Len = szStr - bufSrc;
 
    CON_STREAM_WRITE2(Stream, bufSrc, Len, Len);
 
    /* Fixup returned length in case of errors */
    if (Len < 0)
        Len = 0;
 
    return Len;
}

Referenced by ConMsgPrintf2V(), ConPrintf(), ConResPrintfExV(), DirPrintf(), PrintMessage(), and PrintRow().

ConPuts()

INT ConPuts	(	IN PCON_STREAM	Stream,
		IN PCWSTR	szStr
	)

Definition at line 426 of file outstream.c.

{
    INT Len;
 
    Len = (INT)wcslen(szStr);
    CON_STREAM_WRITE2(Stream, szStr, (DWORD)Len, Len);
 
    /* Fixup returned length in case of errors */
    if (Len < 0)
        Len = 0;
 
    return Len;
}

Referenced by ConClearLine().

ConResMsgPrintf()

INT __cdecl ConResMsgPrintf	(	IN PCON_STREAM	Stream,
		IN DWORD	dwFlags,
		IN UINT	uID,
			...
	)

Definition at line 1458 of file outstream.c.

{
    INT Len;
    va_list args;
 
    /* Sanitize dwFlags */
    dwFlags &= ~FORMAT_MESSAGE_ARGUMENT_ARRAY;
 
    va_start(args, uID);
    Len = ConResMsgPrintfV(Stream, dwFlags, uID, &args);
    va_end(args);
 
    return Len;
}

Referenced by EnumProcessAndPrint(), HandleFindCommand(), HandleInfoCommand(), HandleInstallCommand(), HandleSetupCommand(), PagePrompt(), and ProcessArguments().

ConResMsgPrintfEx()

INT __cdecl ConResMsgPrintfEx	(	IN PCON_STREAM	Stream,
		IN HINSTANCE hInstance	OPTIONAL,
		IN DWORD	dwFlags,
		IN UINT	uID,
		IN LANGID	LanguageId,
			...
	)

Definition at line 1391 of file outstream.c.

{
    INT Len;
    va_list args;
 
    /* Sanitize dwFlags */
    dwFlags &= ~FORMAT_MESSAGE_ARGUMENT_ARRAY;
 
    va_start(args, LanguageId);
    Len = ConResMsgPrintfExV(Stream,
                             hInstance,
                             dwFlags,
                             uID,
                             LanguageId,
                             &args);
    va_end(args);
 
    return Len;
}

ConResMsgPrintfExV()

INT ConResMsgPrintfExV	(	IN PCON_STREAM	Stream,
		IN HINSTANCE hInstance	OPTIONAL,
		IN DWORD	dwFlags,
		IN UINT	uID,
		IN LANGID	LanguageId,
		IN va_list *Arguments	OPTIONAL
	)

Definition at line 1216 of file outstream.c.

{
    INT Len;
    DWORD dwLength  = 0;
    LPWSTR lpMsgBuf = NULL;
    WCHAR bufSrc[CON_RC_STRING_MAX_SIZE];
 
    /* Retrieve the string from the resource string table */
    // NOTE: We may use the special behaviour where nBufMaxSize == 0
    Len = K32LoadStringExW(hInstance, uID, LanguageId, bufSrc, ARRAYSIZE(bufSrc));
    if (Len == 0)
        return Len;
 
    /* Sanitize dwFlags */
    dwFlags |= FORMAT_MESSAGE_ALLOCATE_BUFFER; // Always allocate an internal buffer.
 
    /* The string has already been manually loaded */
    dwFlags &= ~(FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_FROM_SYSTEM);
    dwFlags |= FORMAT_MESSAGE_FROM_STRING;
 
    /*
     * Retrieve the message string without appending extra newlines.
     * Use the "safe" FormatMessage version (SEH-protected) to protect
     * from invalid string parameters.
     */
    dwLength = FormatMessageSafeW(dwFlags,
                                  bufSrc,
                                  0, 0,
                                  (LPWSTR)&lpMsgBuf,
                                  0,
                                  Arguments);
 
    Len = (INT)dwLength;
 
    if (!lpMsgBuf)
    {
        // ASSERT(dwLength == 0);
    }
    else
    {
        // ASSERT(dwLength != 0);
 
        CON_STREAM_WRITE2(Stream, lpMsgBuf, dwLength, Len);
 
        /* Fixup returned length in case of errors */
        if (Len < 0)
            Len = 0;
 
        /* Free the buffer allocated by FormatMessage */
        LocalFree(lpMsgBuf);
    }
 
    return Len;
}

Referenced by ConResMsgPrintfEx(), and ConResMsgPrintfV().

ConResMsgPrintfV()

INT ConResMsgPrintfV	(	IN PCON_STREAM	Stream,
		IN DWORD	dwFlags,
		IN UINT	uID,
		IN va_list *Arguments	OPTIONAL
	)

Definition at line 1327 of file outstream.c.

{
    return ConResMsgPrintfExV(Stream, NULL, dwFlags, uID,
                              MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
                              Arguments);
}

Referenced by ConResMsgPrintf().

ConResPrintf()

INT __cdecl ConResPrintf	(	IN PCON_STREAM	Stream,
		IN UINT	uID,
			...
	)

Definition at line 779 of file outstream.c.

{
    INT Len;
    va_list args;
 
    va_start(args, uID);
    Len = ConResPrintfV(Stream, uID, args);
    va_end(args);
 
    return Len;
}

ConResPrintfEx()

INT __cdecl ConResPrintfEx	(	IN PCON_STREAM	Stream,
		IN HINSTANCE hInstance	OPTIONAL,
		IN UINT	uID,
		IN LANGID	LanguageId,
			...
	)

Definition at line 738 of file outstream.c.

{
    INT Len;
    va_list args;
 
    va_start(args, LanguageId);
    Len = ConResPrintfExV(Stream, hInstance, uID, LanguageId, args);
    va_end(args);
 
    return Len;
}

ConResPrintfExV()

INT ConResPrintfExV	(	IN PCON_STREAM	Stream,
		IN HINSTANCE hInstance	OPTIONAL,
		IN UINT	uID,
		IN LANGID	LanguageId,
		IN va_list	args
	)

Definition at line 652 of file outstream.c.

{
    INT Len;
    WCHAR bufSrc[CON_RC_STRING_MAX_SIZE];
 
    // NOTE: We may use the special behaviour where nBufMaxSize == 0
    Len = K32LoadStringExW(hInstance, uID, LanguageId, bufSrc, ARRAYSIZE(bufSrc));
    if (Len)
        Len = ConPrintfV(Stream, bufSrc, args);
 
    return Len;
}

Referenced by ConResPrintfEx(), ConResPrintfV(), and PrintMessageFromModule().

ConResPrintfV()

INT ConResPrintfV	(	IN PCON_STREAM	Stream,
		IN UINT	uID,
		IN va_list	args
	)

Definition at line 694 of file outstream.c.

{
    return ConResPrintfExV(Stream, NULL, uID,
                           MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), args);
}

Referenced by ConResPrintf(), PrintParserError(), and UnderlinedResPrintf().

ConResPuts()

INT ConResPuts	(	IN PCON_STREAM	Stream,
		IN UINT	uID
	)

Definition at line 609 of file outstream.c.

{
    return ConResPutsEx(Stream, NULL, uID,
                        MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL));
}

ConResPutsEx()

INT ConResPutsEx	(	IN PCON_STREAM	Stream,
		IN HINSTANCE hInstance	OPTIONAL,
		IN UINT	uID,
		IN LANGID	LanguageId
	)

Definition at line 568 of file outstream.c.

{
    INT Len;
    PWCHAR szStr = NULL;
 
    Len = K32LoadStringExW(hInstance, uID, LanguageId, (PWSTR)&szStr, 0);
    if (szStr && Len)
        // Len = ConPuts(Stream, szStr);
        CON_STREAM_WRITE2(Stream, szStr, Len, Len);
 
    /* Fixup returned length in case of errors */
    if (Len < 0)
        Len = 0;
 
    return Len;
}

Referenced by ConResPuts().

ConStreamWrite()

INT ConStreamWrite	(	IN PCON_STREAM	Stream,
		IN PCTCH	szStr,
		IN DWORD	len
	)

Definition at line 397 of file outstream.c.

{
    INT Len;
    CON_STREAM_WRITE2(Stream, szStr, len, Len);
    return Len;
}

Referenced by MorePagerLine(), PagePrompt(), and UnderlinedResPrintf().

ConWrite()

INT __stdcall ConWrite	(	IN PCON_STREAM	Stream,
		IN PCTCH	szStr,
		IN DWORD	len
	)

Definition at line 84 of file outstream.c.

{
#ifndef USE_CRT
    DWORD TotalLen = len, dwNumBytes = 0;
    LPCVOID p;
 
    /* If we do not write anything, just return */
    if (!szStr || len == 0)
        return 0;
 
    /* Check whether we are writing to a console */
    // if (IsConsoleHandle(Stream->hHandle))
    if (Stream->IsConsole)
    {
        // TODO: Check if (Stream->Mode == WideText or UTF16Text) ??
 
        /*
         * This code is inspired from _cputws, in particular from the fact that,
         * according to MSDN: https://learn.microsoft.com/en-us/windows/console/writeconsole
         * the buffer size must be less than 64 KB.
         *
         * A similar code can be used for implementing _cputs too.
         */
 
        DWORD cchWrite;
        TotalLen = len, dwNumBytes = 0;
 
        while (len > 0)
        {
            cchWrite = min(len, 65535 / sizeof(WCHAR));
 
            // FIXME: Check return value!
            WriteConsole(Stream->hHandle, szStr, cchWrite, &dwNumBytes, NULL);
 
            szStr += cchWrite;
            len -= cchWrite;
        }
 
        return (INT)TotalLen; // FIXME: Really return the number of chars written!
    }
 
    /*
     * We are redirected and writing to a file or pipe instead of the console.
     * Convert the string from TCHARs to the desired output format, if the two differ.
     *
     * Implementation NOTE:
     *   MultiByteToWideChar (resp. WideCharToMultiByte) are equivalent to
     *   OemToCharBuffW (resp. CharToOemBuffW), but these latter functions
     *   uselessly depend on user32.dll, while MultiByteToWideChar and
     *   WideCharToMultiByte only need kernel32.dll.
     */
    if ((Stream->Mode == WideText) || (Stream->Mode == UTF16Text))
    {
#ifndef _UNICODE // UNICODE means that TCHAR == WCHAR == UTF-16
        /* Convert from the current process/thread's code page to UTF-16 */
        PWCHAR buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(WCHAR));
        if (!buffer)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return 0;
        }
        len = (DWORD)MultiByteToWideChar(CP_THREAD_ACP, // CP_ACP, CP_OEMCP
                                         0, szStr, (INT)len, buffer, (INT)len);
        szStr = (PVOID)buffer;
#else
        /*
         * Do not perform any conversion since we are already in UTF-16,
         * that is the same encoding as the stream.
         */
#endif
 
        /*
         * Find any newline character in the buffer,
         * write the part BEFORE the newline, then emit
         * a carriage-return + newline sequence and finally
         * write the remaining part of the buffer.
         *
         * This fixes output in files and serial console.
         */
        while (len > 0)
        {
            /* Loop until we find a newline character */
            p = szStr;
            while (len > 0 && *(PCWCH)p != L'\n')
            {
                /* Advance one character */
                p = (LPCVOID)((PCWCH)p + 1);
                --len;
            }
 
            /* Write everything up to \n */
            dwNumBytes = (DWORD)(((PCWCH)p - (PCWCH)szStr) * sizeof(WCHAR));
            WriteFile(Stream->hHandle, szStr, dwNumBytes, &dwNumBytes, NULL);
 
            /*
             * If we hit a newline and the previous character is not a carriage-return,
             * emit a carriage-return + newline sequence, otherwise just emit the newline.
             */
            if (len > 0 && *(PCWCH)p == L'\n')
            {
                if (p == (LPCVOID)szStr || (p > (LPCVOID)szStr && *((PCWCH)p - 1) != L'\r'))
                    WriteFile(Stream->hHandle, L"\r\n", 2 * sizeof(WCHAR), &dwNumBytes, NULL);
                else
                    WriteFile(Stream->hHandle, L"\n", sizeof(WCHAR), &dwNumBytes, NULL);
 
                /* Skip \n */
                p = (LPCVOID)((PCWCH)p + 1);
                --len;
            }
            szStr = p;
        }
 
#ifndef _UNICODE
        HeapFree(GetProcessHeap(), 0, buffer);
#endif
    }
    else if ((Stream->Mode == UTF8Text) || (Stream->Mode == AnsiText))
    {
        UINT CodePage;
        PCHAR buffer;
 
        /*
         * Resolve the current code page if it has not been assigned yet
         * (we do this only if the stream is in ANSI mode; in UTF8 mode
         * the code page is always set to CP_UTF8). Otherwise use the
         * current stream's code page.
         */
        if (/*(Stream->Mode == AnsiText) &&*/ (Stream->CodePage == INVALID_CP))
            CodePage = GetConsoleOutputCP(); // CP_ACP, CP_OEMCP
        else
            CodePage = Stream->CodePage;
 
#ifdef _UNICODE // UNICODE means that TCHAR == WCHAR == UTF-16
        /* Convert from UTF-16 to either UTF-8 or ANSI, using the stream code page */
        // NOTE: MB_LEN_MAX defined either in limits.h or in stdlib.h .
        buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * MB_LEN_MAX);
        if (!buffer)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return 0;
        }
        len = WideCharToMultiByte(CodePage, 0,
                                  szStr, len, buffer, len * MB_LEN_MAX,
                                  NULL, NULL);
        szStr = (PVOID)buffer;
#else
        /*
         * Convert from the current process/thread's code page to either
         * UTF-8 or ANSI, using the stream code page.
         * We need to perform a double conversion, by going through UTF-16.
         */
        // TODO!
        #error "Need to implement double conversion!"
#endif
 
        /*
         * Find any newline character in the buffer,
         * write the part BEFORE the newline, then emit
         * a carriage-return + newline sequence and finally
         * write the remaining part of the buffer.
         *
         * This fixes output in files and serial console.
         */
        while (len > 0)
        {
            /* Loop until we find a newline character */
            p = szStr;
            while (len > 0 && *(PCCH)p != '\n')
            {
                /* Advance one character */
                p = (LPCVOID)((PCCH)p + 1);
                --len;
            }
 
            /* Write everything up to \n */
            dwNumBytes = (DWORD)(((PCCH)p - (PCCH)szStr) * sizeof(CHAR));
            WriteFile(Stream->hHandle, szStr, dwNumBytes, &dwNumBytes, NULL);
 
            /*
             * If we hit a newline and the previous character is not a carriage-return,
             * emit a carriage-return + newline sequence, otherwise just emit the newline.
             */
            if (len > 0 && *(PCCH)p == '\n')
            {
                if (p == (LPCVOID)szStr || (p > (LPCVOID)szStr && *((PCCH)p - 1) != '\r'))
                    WriteFile(Stream->hHandle, "\r\n", 2, &dwNumBytes, NULL);
                else
                    WriteFile(Stream->hHandle, "\n", 1, &dwNumBytes, NULL);
 
                /* Skip \n */
                p = (LPCVOID)((PCCH)p + 1);
                --len;
            }
            szStr = p;
        }
 
#ifdef _UNICODE
        HeapFree(GetProcessHeap(), 0, buffer);
#else
        // TODO!
#endif
    }
    else // if (Stream->Mode == Binary)
    {
        /* Directly output the string */
        WriteFile(Stream->hHandle, szStr, len, &dwNumBytes, NULL);
    }
 
    // FIXME!
    return (INT)TotalLen;
 
#else /* defined(USE_CRT) */
 
    DWORD total = len;
    DWORD written = 0;
 
    /* If we do not write anything, just return */
    if (!szStr || len == 0)
        return 0;
 
#if 1
    /*
     * There is no "counted" printf-to-stream or puts-like function, therefore
     * we use this trick to output the counted string to the stream.
     */
    while (1)
    {
        written = fwprintf(Stream->fStream, L"%.*s", total, szStr);
        if (written < total)
        {
            /*
             * Some embedded NULL or special character
             * was encountered, print it apart.
             */
            if (written == 0)
            {
                fputwc(*szStr, Stream->fStream);
                written++;
            }
 
            szStr += written;
            total -= written;
        }
        else
        {
            break;
        }
    }
    return (INT)len;
#else
    /* ANSI text or Binary output only */
    _setmode(_fileno(Stream->fStream), _O_TEXT); // _O_BINARY
    return fwrite(szStr, sizeof(*szStr), len, Stream->fStream);
#endif
 
#endif /* defined(USE_CRT) */
}

Referenced by ConErrChar(), ConOutChar(), ConStreamInit(), and ConStreamInitEx().