source: vbox/trunk/src/bldprogs/VBoxCPP.cpp@ 76694

/* $Id: VBoxCPP.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
/** @file
 * VBox Build Tool - A mini C Preprocessor.
 *
 * Purposes to which this preprocessor will be put:
 *      - Preprocessig vm.h into dtrace/lib/vm.d so we can access the VM
 *        structure (as well as substructures) from DTrace without having
 *        to handcraft it all.
 *      - Removing \#ifdefs relating to a new feature that has become
 *        stable and no longer needs \#ifdef'ing.
 *      - Pretty printing preprocessor directives.  This will be used by
 *        SCM.
 */

/*
 * Copyright (C) 2012-2019 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */


/*********************************************************************************************************************************
*   Header Files                                                                                                                 *
*********************************************************************************************************************************/
#include <VBox/VBoxTpG.h>

#include <iprt/alloca.h>
#include <iprt/assert.h>
#include <iprt/asm.h>
#include <iprt/ctype.h>
#include <iprt/err.h>
#include <iprt/file.h>
#include <iprt/getopt.h>
#include <iprt/initterm.h>
#include <iprt/list.h>
#include <iprt/mem.h>
#include <iprt/message.h>
#include <iprt/path.h>
#include <iprt/stream.h>
#include <iprt/string.h>

#include "scmstream.h"


/*********************************************************************************************************************************
*   Defined Constants And Macros                                                                                                 *
*********************************************************************************************************************************/
/** The bitmap type. */
#define VBCPP_BITMAP_TYPE                   uint64_t
/** The bitmap size as a multiple of VBCPP_BITMAP_TYPE. */
#define VBCPP_BITMAP_SIZE                   (128 / 64)
/** Checks if a bit is set. */
#define VBCPP_BITMAP_IS_SET(a_bm, a_ch)     ASMBitTest(a_bm, (a_ch) & 0x7f)
/** Sets a bit. */
#define VBCPP_BITMAP_SET(a_bm, a_ch)        ASMBitSet(a_bm, (a_ch) & 0x7f)
/** Empties the bitmap. */
#define VBCPP_BITMAP_EMPTY(a_bm)            do { (a_bm)[0] = 0; (a_bm)[1] = 0; } while (0)
/** Joins to bitmaps by OR'ing their values.. */
#define VBCPP_BITMAP_OR(a_bm1, a_bm2)       do { (a_bm1)[0] |= (a_bm2)[0]; (a_bm1)[1] |= (a_bm2)[1]; } while (0)


/*********************************************************************************************************************************
*   Structures and Typedefs                                                                                                      *
*********************************************************************************************************************************/
/** Pointer to the C preprocessor instance data. */
typedef struct VBCPP *PVBCPP;


/**
 * Variable string buffer (very simple version of SCMSTREAM).
 */
typedef struct VBCPPSTRBUF
{
    /** The preprocessor instance (for error reporting). */
    struct VBCPP   *pThis;
    /** The length of the string in the buffer. */
    size_t          cchBuf;
    /** The string storage. */
    char           *pszBuf;
    /** Allocated buffer space. */
    size_t          cbBufAllocated;
} VBCPPSTRBUF;
/** Pointer to a variable string buffer. */
typedef VBCPPSTRBUF *PVBCPPSTRBUF;


/**
 * The preprocessor mode.
 */
typedef enum VBCPPMODE
{
    kVBCppMode_Invalid = 0,
    kVBCppMode_Standard,
    kVBCppMode_Selective,
    kVBCppMode_SelectiveD,
    kVBCppMode_End
} VBCPPMODE;


/**
 * A macro (aka define).
 */
typedef struct VBCPPMACRO
{
    /** The string space core. */
    RTSTRSPACECORE      Core;
#if 0
    /** For linking macros that have the fExpanding flag set. */
    struct VBCPPMACRO  *pUpExpanding;
#endif
    /** Whether it's a function. */
    bool                fFunction;
    /** Variable argument count. */
    bool                fVarArg;
    /** Set if originating on the command line. */
    bool                fCmdLine;
    /** Set if this macro is currently being expanded and should not be
     * recursively applied. */
    bool                fExpanding;
    /** The number of known arguments. */
    uint32_t            cArgs;
    /** Pointer to a list of argument names. */
    const char        **papszArgs;
    /** Lead character bitmap for the argument names. */
    VBCPP_BITMAP_TYPE   bmArgs[VBCPP_BITMAP_SIZE];
    /** The value length. */
    size_t              cchValue;
    /** The define value.  (This is followed by the name and arguments.) */
    char                szValue[1];
} VBCPPMACRO;
/** Pointer to a macro. */
typedef VBCPPMACRO *PVBCPPMACRO;


/**
 * Macro expansion data.
 */
typedef struct VBCPPMACROEXP
{
    /** The expansion buffer. */
    VBCPPSTRBUF     StrBuf;
#if 0
    /** List of expanding macros (Stack). */
    PVBCPPMACRO     pMacroStack;
#endif
    /** The input stream (in case we want to look for parameter lists). */
    PSCMSTREAM      pStrmInput;
    /** Array of argument values.  Used when expanding function style macros.  */
    char          **papszArgs;
    /** The number of argument values current in papszArgs. */
    uint32_t        cArgs;
    /** The number of argument values papszArgs can currently hold  */
    uint32_t        cArgsAlloced;
} VBCPPMACROEXP;
/** Pointer to macro expansion data. */
typedef VBCPPMACROEXP *PVBCPPMACROEXP;


/**
 * The vbcppMacroExpandReScan mode of operation.
 */
typedef enum VBCPPMACRORESCANMODE
{
    /** Invalid mode.  */
    kMacroReScanMode_Invalid = 0,
    /** Normal expansion mode. */
    kMacroReScanMode_Normal,
    /** Replaces known macros and heeds the 'defined' operator. */
    kMacroReScanMode_Expression,
    /** End of valid modes. */
    kMacroReScanMode_End
} VBCPPMACRORESCANMODE;


/**
 * Expression node type.
 */
typedef enum VBCPPEXPRKIND
{
    kVBCppExprKind_Invalid = 0,
    kVBCppExprKind_Unary,
    kVBCppExprKind_Binary,
    kVBCppExprKind_Ternary,
    kVBCppExprKind_SignedValue,
    kVBCppExprKind_UnsignedValue,
    kVBCppExprKind_End
} VBCPPEXPRKIND;


/** Macro used for the precedence field. */
#define VBCPPOP_PRECEDENCE(a_iPrecedence)   ((a_iPrecedence) << 8)
/** Mask for getting the precedence field value. */
#define VBCPPOP_PRECEDENCE_MASK             0xff00
/** Operator associativity - Left to right. */
#define VBCPPOP_L2R                         (1 << 16)
/** Operator associativity - Right to left. */
#define VBCPPOP_R2L                         (2 << 16)

/**
 * Unary operators.
 */
typedef enum VBCPPUNARYOP
{
    kVBCppUnaryOp_Invalid = 0,
    kVBCppUnaryOp_Pluss             = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  5,
    kVBCppUnaryOp_Minus             = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  6,
    kVBCppUnaryOp_LogicalNot        = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  7,
    kVBCppUnaryOp_BitwiseNot        = VBCPPOP_R2L | VBCPPOP_PRECEDENCE( 3) |  8,
    kVBCppUnaryOp_Parenthesis       = VBCPPOP_R2L | VBCPPOP_PRECEDENCE(15) |  9,
    kVBCppUnaryOp_End
} VBCPPUNARYOP;

/**
 * Binary operators.
 */
typedef enum VBCPPBINARYOP
{
    kVBCppBinary_Invalid = 0,
    kVBCppBinary_Multiplication     = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 5) |  2,
    kVBCppBinary_Division           = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 5) |  4,
    kVBCppBinary_Modulo             = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 5) |  5,
    kVBCppBinary_Addition           = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 6) |  6,
    kVBCppBinary_Subtraction        = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 6) |  7,
    kVBCppBinary_LeftShift          = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 7) |  8,
    kVBCppBinary_RightShift         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 7) |  9,
    kVBCppBinary_LessThan           = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 10,
    kVBCppBinary_LessThanOrEqual    = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 11,
    kVBCppBinary_GreaterThan        = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 12,
    kVBCppBinary_GreaterThanOrEqual = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 8) | 13,
    kVBCppBinary_EqualTo            = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 9) | 14,
    kVBCppBinary_NotEqualTo         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE( 9) | 15,
    kVBCppBinary_BitwiseAnd         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(10) | 16,
    kVBCppBinary_BitwiseXor         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(11) | 17,
    kVBCppBinary_BitwiseOr          = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(12) | 18,
    kVBCppBinary_LogicalAnd         = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(13) | 19,
    kVBCppBinary_LogicalOr          = VBCPPOP_L2R | VBCPPOP_PRECEDENCE(14) | 20,
    kVBCppBinary_End
} VBCPPBINARYOP;

/** The precedence of the ternary operator (expr ? true : false). */
#define VBCPPTERNAROP_PRECEDENCE   VBCPPOP_PRECEDENCE(16)


/** Pointer to an expression parsing node. */
typedef struct VBCPPEXPR *PVBCPPEXPR;
/**
 * Expression parsing node.
 */
typedef struct VBCPPEXPR
{
    /** Parent expression. */
    PVBCPPEXPR          pParent;
    /** Whether the expression is complete or not. */
    bool                fComplete;
    /** The kind of expression. */
    VBCPPEXPRKIND       enmKind;
    /** Kind specific content. */
    union
    {
        /** kVBCppExprKind_Unary */
        struct
        {
            VBCPPUNARYOP    enmOperator;
            PVBCPPEXPR      pArg;
        } Unary;

        /** kVBCppExprKind_Binary */
        struct
        {
            VBCPPBINARYOP   enmOperator;
            PVBCPPEXPR      pLeft;
            PVBCPPEXPR      pRight;
        } Binary;

        /** kVBCppExprKind_Ternary */
        struct
        {
            PVBCPPEXPR      pExpr;
            PVBCPPEXPR      pTrue;
            PVBCPPEXPR      pFalse;
        } Ternary;

        /** kVBCppExprKind_SignedValue */
        struct
        {
            int64_t         s64;
        } SignedValue;

        /** kVBCppExprKind_UnsignedValue */
        struct
        {
            uint64_t        u64;
        } UnsignedValue;
    } u;
} VBCPPEXPR;


/**
 * Operator return statuses.
 */
typedef enum VBCPPEXPRRET
{
    kExprRet_Error = -1,
    kExprRet_Ok = 0,
    kExprRet_UnaryOperator,
    kExprRet_Value,
    kExprRet_EndOfExpr,
    kExprRet_End
} VBCPPEXPRRET;

/**
 * Expression parser context.
 */
typedef struct VBCPPEXPRPARSER
{
    /** The current expression posistion. */
    const char         *pszCur;
    /** The root node. */
    PVBCPPEXPR          pRoot;
    /** The current expression node. */
    PVBCPPEXPR          pCur;
    /** Where to insert the next expression. */
    PVBCPPEXPR         *ppCur;
    /** The expression. */
    const char         *pszExpr;
    /** The number of undefined macros we've encountered while parsing. */
    size_t              cUndefined;
    /** Pointer to the C preprocessor instance. */
    PVBCPP              pThis;
} VBCPPEXPRPARSER;
/** Pointer to an expression parser context. */
typedef VBCPPEXPRPARSER *PVBCPPEXPRPARSER;


/**
 * Evaluation result.
 */
typedef enum VBCPPEVAL
{
    kVBCppEval_Invalid = 0,
    kVBCppEval_True,
    kVBCppEval_False,
    kVBCppEval_Undecided,
    kVBCppEval_End
} VBCPPEVAL;


/**
 * The condition kind.
 */
typedef enum VBCPPCONDKIND
{
    kVBCppCondKind_Invalid = 0,
    /** \#if expr  */
    kVBCppCondKind_If,
    /** \#ifdef define  */
    kVBCppCondKind_IfDef,
    /** \#ifndef define  */
    kVBCppCondKind_IfNDef,
    /** \#elif expr */
    kVBCppCondKind_ElIf,
    /** The end of valid values. */
    kVBCppCondKind_End
} VBCPPCONDKIND;


/**
 * Conditional stack entry.
 */
typedef struct VBCPPCOND
{
    /** The next conditional on the stack. */
    struct VBCPPCOND   *pUp;
    /** The kind of conditional. This changes on encountering \#elif. */
    VBCPPCONDKIND       enmKind;
    /** Evaluation result. */
    VBCPPEVAL           enmResult;
    /** The evaluation result of the whole stack. */
    VBCPPEVAL           enmStackResult;

    /** Whether we've seen the last else. */
    bool                fSeenElse;
    /** Set if we have an else if which has already been decided. */
    bool                fElIfDecided;
    /** The nesting level of this condition. */
    uint16_t            iLevel;
    /** The nesting level of this condition wrt the ones we keep. */
    uint16_t            iKeepLevel;

    /** The condition string. (Points within the stream buffer.) */
    const char         *pchCond;
    /** The condition length. */
    size_t              cchCond;
} VBCPPCOND;
/** Pointer to a conditional stack entry. */
typedef VBCPPCOND *PVBCPPCOND;


/**
 * Input buffer stack entry.
 */
typedef struct VBCPPINPUT
{
    /** Pointer to the next input on the stack. */
    struct VBCPPINPUT  *pUp;
    /** The input stream. */
    SCMSTREAM           StrmInput;
    /** Pointer into szName to the part which was specified. */
    const char         *pszSpecified;
    /** The input file name with include path. */
    char                szName[1];
} VBCPPINPUT;
/** Pointer to a input buffer stack entry */
typedef VBCPPINPUT *PVBCPPINPUT;


/**
 * The action to take with \#include.
 */
typedef enum VBCPPINCLUDEACTION
{
    kVBCppIncludeAction_Invalid = 0,
    kVBCppIncludeAction_Include,
    kVBCppIncludeAction_PassThru,
    kVBCppIncludeAction_Drop,
    kVBCppIncludeAction_End
} VBCPPINCLUDEACTION;


/**
 * C Preprocessor instance data.
 */
typedef struct VBCPP
{
    /** @name Options
     * @{ */
    /** The preprocessing mode. */
    VBCPPMODE           enmMode;
    /** Whether to keep comments. */
    bool                fKeepComments;
    /** Whether to respect source defines. */
    bool                fRespectSourceDefines;
    /** Whether to let source defines overrides the ones on the command
     *  line. */
    bool                fAllowRedefiningCmdLineDefines;
    /** Whether to pass thru defines. */
    bool                fPassThruDefines;
    /** Whether to allow undecided conditionals. */
    bool                fUndecidedConditionals;
    /** Whether to pass thru D pragmas. */
    bool                fPassThruPragmaD;
    /** Whether to pass thru STD pragmas. */
    bool                fPassThruPragmaSTD;
    /** Whether to pass thru other pragmas. */
    bool                fPassThruPragmaOther;
    /** Whether to remove dropped lines from the output. */
    bool                fRemoveDroppedLines;
    /** Whether to preforme line splicing.
     * @todo implement line splicing  */
    bool                fLineSplicing;
    /** What to do about include files. */
    VBCPPINCLUDEACTION  enmIncludeAction;

    /** The number of include directories. */
    uint32_t            cIncludes;
    /** Array of directories to search for include files. */
    char              **papszIncludes;

    /** The name of the input file. */
    const char         *pszInput;
    /** The name of the output file. NULL if stdout. */
    const char         *pszOutput;
    /** @} */

    /** The define string space. */
    RTSTRSPACE          StrSpace;
    /** The string space holding explicitly undefined macros for selective
     * preprocessing runs. */
    RTSTRSPACE          UndefStrSpace;
    /** Indicates whether a C-word might need expansion.
     * The bitmap is indexed by C-word lead character.  Bits that are set
     * indicates that the lead character is used in a \#define that we know and
     * should expand. */
    VBCPP_BITMAP_TYPE   bmDefined[VBCPP_BITMAP_SIZE];

    /** The current depth of the conditional stack. */
    uint32_t            cCondStackDepth;
    /** Conditional stack. */
    PVBCPPCOND          pCondStack;
    /** The current condition evaluates to kVBCppEval_False, don't output. */
    bool                fIf0Mode;
    /** Just dropped a line and should maybe drop the current line. */
    bool                fJustDroppedLine;

    /** Whether the current line could be a preprocessor line.
     * This is set when EOL is encountered and cleared again when a
     * non-comment-or-space character is encountered.  See vbcppPreprocess. */
    bool                fMaybePreprocessorLine;

    /** The input stack depth */
    uint32_t            cInputStackDepth;
    /** The input buffer stack. */
    PVBCPPINPUT         pInputStack;

    /** The output stream. */
    SCMSTREAM           StrmOutput;

    /** The status of the whole job, as far as we know. */
    RTEXITCODE          rcExit;
    /** Whether StrmOutput is valid (for vbcppTerm). */
    bool                fStrmOutputValid;
} VBCPP;


/*********************************************************************************************************************************
*   Internal Functions                                                                                                           *
*********************************************************************************************************************************/
static PVBCPPMACRO  vbcppMacroLookup(PVBCPP pThis, const char *pszDefine, size_t cchDefine);
static RTEXITCODE   vbcppMacroExpandIt(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t offMacro, PVBCPPMACRO pMacro, size_t offParameters);
static RTEXITCODE   vbcppMacroExpandReScan(PVBCPP pThis, PVBCPPMACROEXP pExp, VBCPPMACRORESCANMODE enmMode, size_t *pcReplacements);
static void         vbcppMacroExpandCleanup(PVBCPPMACROEXP pExp);



/*
 *
 *
 * Message Handling.
 * Message Handling.
 * Message Handling.
 * Message Handling.
 * Message Handling.
 *
 *
 */


/**
 * Displays an error message.
 *
 * @returns RTEXITCODE_FAILURE
 * @param   pThis               The C preprocessor instance.
 * @param   pszMsg              The message.
 * @param   va                  Message arguments.
 */
static RTEXITCODE vbcppErrorV(PVBCPP pThis, const char *pszMsg, va_list va)
{
    NOREF(pThis);
    if (pThis->pInputStack)
    {
        PSCMSTREAM pStrm = &pThis->pInputStack->StrmInput;

        size_t const off     = ScmStreamTell(pStrm);
        size_t const iLine   = ScmStreamTellLine(pStrm);
        ScmStreamSeekByLine(pStrm, iLine);
        size_t const offLine = ScmStreamTell(pStrm);

        RTPrintf("%s:%d:%zd: error: %N.\n", pThis->pInputStack->szName, iLine + 1, off - offLine + 1, pszMsg, va);

        size_t cchLine;
        SCMEOL enmEof;
        const char *pszLine = ScmStreamGetLineByNo(pStrm, iLine, &cchLine, &enmEof);
        if (pszLine)
            RTPrintf("  %.*s\n"
                     "  %*s^\n",
                     cchLine, pszLine, off - offLine, "");

        ScmStreamSeekAbsolute(pStrm, off);
    }
    else
        RTMsgErrorV(pszMsg, va);
    return pThis->rcExit = RTEXITCODE_FAILURE;
}


/**
 * Displays an error message.
 *
 * @returns RTEXITCODE_FAILURE
 * @param   pThis               The C preprocessor instance.
 * @param   pszMsg              The message.
 * @param   ...                 Message arguments.
 */
static RTEXITCODE vbcppError(PVBCPP pThis, const char *pszMsg, ...)
{
    va_list va;
    va_start(va, pszMsg);
    RTEXITCODE rcExit = vbcppErrorV(pThis, pszMsg, va);
    va_end(va);
    return rcExit;
}


/**
 * Displays an error message.
 *
 * @returns RTEXITCODE_FAILURE
 * @param   pThis               The C preprocessor instance.
 * @param   pszPos              Pointer to the offending character.
 * @param   pszMsg              The message.
 * @param   ...                 Message arguments.
 */
static RTEXITCODE vbcppErrorPos(PVBCPP pThis, const char *pszPos, const char *pszMsg, ...)
{
    NOREF(pszPos); NOREF(pThis);
    va_list va;
    va_start(va, pszMsg);
    RTMsgErrorV(pszMsg, va);
    va_end(va);
    return pThis->rcExit = RTEXITCODE_FAILURE;
}







/*
 *
 *
 * Variable String Buffers.
 * Variable String Buffers.
 * Variable String Buffers.
 * Variable String Buffers.
 * Variable String Buffers.
 *
 *
 */


/**
 * Initializes a string buffer.
 *
 * @param   pStrBuf             The buffer structure to initialize.
 * @param   pThis               The C preprocessor instance.
 */
static void vbcppStrBufInit(PVBCPPSTRBUF pStrBuf, PVBCPP pThis)
{
    pStrBuf->pThis              = pThis;
    pStrBuf->cchBuf             = 0;
    pStrBuf->cbBufAllocated     = 0;
    pStrBuf->pszBuf             = NULL;
}


/**
 * Deletes a string buffer.
 *
 * @param   pStrBuf             Pointer to the string buffer.
 */
static void vbcppStrBufDelete(PVBCPPSTRBUF pStrBuf)
{
    RTMemFree(pStrBuf->pszBuf);
    pStrBuf->pszBuf = NULL;
}


/**
 * Ensures that sufficient bufferspace is available, growing the buffer if
 * necessary.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pStrBuf             Pointer to the string buffer.
 * @param   cbMin               The minimum buffer size.
 */
static RTEXITCODE vbcppStrBufGrow(PVBCPPSTRBUF pStrBuf, size_t cbMin)
{
    if (pStrBuf->cbBufAllocated >= cbMin)
        return RTEXITCODE_SUCCESS;

    size_t cbNew = pStrBuf->cbBufAllocated * 2;
    if (cbNew < cbMin)
        cbNew = RT_ALIGN_Z(cbMin, _1K);
    void *pv = RTMemRealloc(pStrBuf->pszBuf, cbNew);
    if (!pv)
        return vbcppError(pStrBuf->pThis, "out of memory (%zu bytes)", cbNew);

    pStrBuf->pszBuf         = (char *)pv;
    pStrBuf->cbBufAllocated = cbNew;
    return RTEXITCODE_SUCCESS;
}


/**
 * Appends a substring.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pStrBuf             Pointer to the string buffer.
 * @param   pchSrc              Pointer to the first character in the substring.
 * @param   cchSrc              The length of the substring.
 */
static RTEXITCODE vbcppStrBufAppendN(PVBCPPSTRBUF pStrBuf, const char *pchSrc, size_t cchSrc)
{
    size_t cchBuf = pStrBuf->cchBuf;
    if (cchBuf + cchSrc + 1 > pStrBuf->cbBufAllocated)
    {
        RTEXITCODE rcExit = vbcppStrBufGrow(pStrBuf, cchBuf + cchSrc + 1);
        if (rcExit != RTEXITCODE_SUCCESS)
            return rcExit;
    }

    memcpy(&pStrBuf->pszBuf[cchBuf], pchSrc, cchSrc);
    cchBuf += cchSrc;
    pStrBuf->pszBuf[cchBuf] = '\0';
    pStrBuf->cchBuf = cchBuf;

    return RTEXITCODE_SUCCESS;
}


/**
 * Appends a character.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pStrBuf             Pointer to the string buffer.
 * @param   ch                  The charater to append.
 */
static RTEXITCODE vbcppStrBufAppendCh(PVBCPPSTRBUF pStrBuf, char ch)
{
    size_t cchBuf = pStrBuf->cchBuf;
    if (cchBuf + 2 > pStrBuf->cbBufAllocated)
    {
        RTEXITCODE rcExit = vbcppStrBufGrow(pStrBuf, cchBuf + 2);
        if (rcExit != RTEXITCODE_SUCCESS)
            return rcExit;
    }

    pStrBuf->pszBuf[cchBuf++] = ch;
    pStrBuf->pszBuf[cchBuf] = '\0';
    pStrBuf->cchBuf = cchBuf;

    return RTEXITCODE_SUCCESS;
}


/**
 * Appends a string to the buffer.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pStrBuf             Pointer to the string buffer.
 * @param   psz                 The string to append.
 */
static RTEXITCODE vbcppStrBufAppend(PVBCPPSTRBUF pStrBuf, const char *psz)
{
    return vbcppStrBufAppendN(pStrBuf, psz, strlen(psz));
}


/**
 * Gets the last char in the buffer.
 *
 * @returns Last character, 0 if empty.
 * @param   pStrBuf             Pointer to the string buffer.
 */
static char vbcppStrBufLastCh(PVBCPPSTRBUF pStrBuf)
{
    if (!pStrBuf->cchBuf)
        return '\0';
    return pStrBuf->pszBuf[pStrBuf->cchBuf - 1];
}







/*
 *
 *
 * C Identifier/Word Parsing.
 * C Identifier/Word Parsing.
 * C Identifier/Word Parsing.
 * C Identifier/Word Parsing.
 * C Identifier/Word Parsing.
 *
 *
 */


/**
 * Checks if the given character is a valid C identifier lead character.
 *
 * @returns true / false.
 * @param   ch                  The character to inspect.
 */
DECLINLINE(bool) vbcppIsCIdentifierLeadChar(char ch)
{
    return RT_C_IS_ALPHA(ch)
        || ch == '_';
}


/**
 * Checks if the given character is a valid C identifier character.
 *
 * @returns true / false.
 * @param   ch                  The character to inspect.
 */
DECLINLINE(bool) vbcppIsCIdentifierChar(char ch)
{
    return RT_C_IS_ALNUM(ch)
        || ch == '_';
}



/**
 *
 * @returns @c true if valid, @c false if not. Error message already displayed
 *          on failure.
 * @param   pThis           The C preprocessor instance.
 * @param   pchIdentifier   The start of the identifier to validate.
 * @param   cchIdentifier   The length of the identifier. RTSTR_MAX if not
 *                          known.
 */
static bool vbcppValidateCIdentifier(PVBCPP pThis, const char *pchIdentifier, size_t cchIdentifier)
{
    if (cchIdentifier == RTSTR_MAX)
        cchIdentifier = strlen(pchIdentifier);

    if (cchIdentifier == 0)
    {
        vbcppErrorPos(pThis, pchIdentifier, "Zero length identifier");
        return false;
    }

    if (!vbcppIsCIdentifierLeadChar(*pchIdentifier))
    {
        vbcppErrorPos(pThis, pchIdentifier, "Bad lead chararacter in identifier: '%.*s'", cchIdentifier, pchIdentifier);
        return false;
    }

    for (size_t off = 1; off < cchIdentifier; off++)
    {
        if (!vbcppIsCIdentifierChar(pchIdentifier[off]))
        {
            vbcppErrorPos(pThis, pchIdentifier + off, "Illegal chararacter in identifier: '%.*s' (#%zu)", cchIdentifier, pchIdentifier, off + 1);
            return false;
        }
    }

    return true;
}

#if 0

/**
 * Checks if the given character is valid C punctuation.
 *
 * @returns true / false.
 * @param   ch                  The character to inspect.
 */
DECLINLINE(bool) vbcppIsCPunctuationLeadChar(char ch)
{
    switch (ch)
    {
        case '!':
        case '#':
        case '%':
        case '&':
        case '(':
        case ')':
        case '*':
        case '+':
        case ',':
        case '-':
        case '.':
        case '/':
        case ':':
        case ';':
        case '<':
        case '=':
        case '>':
        case '?':
        case '[':
        case ']':
        case '^':
        case '{':
        case '|':
        case '}':
        case '~':
            return true;
        default:
            return false;
    }
}


/**
 * Checks if the given string start with valid C punctuation.
 *
 * @returns 0 if not, otherwise the length of the punctuation.
 * @param   pch                 The which start we should evaluate.
 * @param   cchMax              The maximum string length.
 */
static size_t vbcppIsCPunctuationLeadChar(const char *psz, size_t cchMax)
{
    if (!cchMax)
        return 0;

    switch (psz[0])
    {
        case '!':
        case '*':
        case '/':
        case '=':
        case '^':
            if (cchMax >= 2 && psz[1] == '=')
                return 2;
            return 1;

        case '#':
            if (cchMax >= 2 && psz[1] == '#')
                return 2;
            return 1;

        case '%':
            if (cchMax >= 2 && (psz[1] == '=' || psz[1] == '>'))
                return 2;
            if (cchMax >= 2 && psz[1] == ':')
            {
                if (cchMax >= 4 && psz[2] == '%' && psz[3] == ':')
                    return 4;
                return 2;
            }
            return 1;

        case '&':
            if (cchMax >= 2 && (psz[1] == '=' || psz[1] == '&'))
                return 2;
            return 1;

        case '(':
        case ')':
        case ',':
        case '?':
        case '[':
        case ']':
        case '{':
        case '}':
            return 1;

        case '+':
            if (cchMax >= 2 && (psz[1] == '=' || psz[1] == '+'))
                return 2;
            return 1;

        case '-':
            if (cchMax >= 2 && (psz[1] == '=' || psz[1] == '-' || psz[1] == '>'))
                return 2;
            return 1;

        case ':':
            if (cchMax >= 2 && psz[1] == '>')
                return 2;
            return 1;

        case ';':
            return 1;

        case '<':
            if (cchMax >= 2 && psz[1] == '<')
            {
                if (cchMax >= 3 && psz[2] == '=')
                    return 3;
                return 2;
            }
            if (cchMax >= 2 && (psz[1] == '=' || psz[1] == ':' || psz[1] == '%'))
                return 2;
            return 1;

        case '.':
            if (cchMax >= 3 && psz[1] == '.' && psz[2] == '.')
                return 3;
            return 1;

        case '>':
            if (cchMax >= 2 && psz[1] == '>')
            {
                if (cchMax >= 3 && psz[2] == '=')
                    return 3;
                return 2;
            }
            if (cchMax >= 2 && psz[1] == '=')
                return 2;
            return 1;

        case '|':
            if (cchMax >= 2 && (psz[1] == '=' || psz[1] == '|'))
                return 2;
            return 1;

        case '~':
            return 1;

        default:
            return 0;
    }
}

#endif





/*
 *
 *
 * Output
 * Output
 * Output
 * Output
 * Output
 *
 *
 */


/**
 * Outputs a character.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   ch                  The character to output.
 */
static RTEXITCODE vbcppOutputCh(PVBCPP pThis, char ch)
{
    int rc = ScmStreamPutCh(&pThis->StrmOutput, ch);
    if (RT_SUCCESS(rc))
        return RTEXITCODE_SUCCESS;
    return vbcppError(pThis, "Output error: %Rrc", rc);
}


/**
 * Outputs a string.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pch                 The string.
 * @param   cch                 The number of characters to write.
 */
static RTEXITCODE vbcppOutputWrite(PVBCPP pThis, const char *pch, size_t cch)
{
    int rc = ScmStreamWrite(&pThis->StrmOutput, pch, cch);
    if (RT_SUCCESS(rc))
        return RTEXITCODE_SUCCESS;
    return vbcppError(pThis, "Output error: %Rrc", rc);
}


static RTEXITCODE vbcppOutputComment(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart, size_t cchOutputted,
                                     size_t cchMinIndent)
{
    RT_NOREF_PV(cchMinIndent); /** @todo  cchMinIndent */

    size_t offCur = ScmStreamTell(pStrmInput);
    if (offStart < offCur)
    {
        int rc = ScmStreamSeekAbsolute(pStrmInput, offStart);
        AssertRCReturn(rc, vbcppError(pThis, "Input seek error: %Rrc", rc));

        /*
         * Use the same indent, if possible.
         */
        size_t cchIndent = offStart - ScmStreamTellOffsetOfLine(pStrmInput, ScmStreamTellLine(pStrmInput));
        if (cchOutputted < cchIndent)
            rc = ScmStreamPrintf(&pThis->StrmOutput, "%*s", cchIndent - cchOutputted, "");
        else
            rc = ScmStreamPutCh(&pThis->StrmOutput, ' ');
        if (RT_FAILURE(rc))
            return vbcppError(pThis, "Output error: %Rrc", rc);

        /*
         * Copy the bytes.
         */
        while (ScmStreamTell(pStrmInput) < offCur)
        {
            unsigned ch = ScmStreamGetCh(pStrmInput);
            if (ch == ~(unsigned)0)
                return vbcppError(pThis, "Input error: %Rrc", rc);
            rc = ScmStreamPutCh(&pThis->StrmOutput, ch);
            if (RT_FAILURE(rc))
                return vbcppError(pThis, "Output error: %Rrc", rc);
        }
    }

    return RTEXITCODE_SUCCESS;
}





/*
 *
 *
 * Input
 * Input
 * Input
 * Input
 * Input
 *
 *
 */


#if 0 /* unused */
/**
 * Skips white spaces, including escaped new-lines.
 *
 * @param   pStrmInput          The input stream.
 */
static void vbcppProcessSkipWhiteAndEscapedEol(PSCMSTREAM pStrmInput)
{
    unsigned chPrev = ~(unsigned)0;
    unsigned ch;
    while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
    {
        if (ch == '\r' || ch == '\n')
        {
            if (chPrev != '\\')
                break;
            chPrev = ch;
            ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
        }
        else if (RT_C_IS_SPACE(ch))
        {
            chPrev = ch;
            ch = ScmStreamGetCh(pStrmInput);
            Assert(ch == chPrev);
        }
        else
            break;
    }
}
#endif


/**
 * Skips white spaces, escaped new-lines and multi line comments.
 *
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 */
static RTEXITCODE vbcppProcessSkipWhiteEscapedEolAndComments(PVBCPP pThis, PSCMSTREAM pStrmInput)
{
    unsigned chPrev = ~(unsigned)0;
    unsigned ch;
    while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
    {
        if (!RT_C_IS_SPACE(ch))
        {
            /* Multi-line Comment? */
            if (ch != '/')
                break;                  /* most definitely, not. */

            size_t offSaved = ScmStreamTell(pStrmInput);
            ScmStreamGetCh(pStrmInput);
            if (ScmStreamPeekCh(pStrmInput) != '*')
            {
                ScmStreamSeekAbsolute(pStrmInput, offSaved);
                break;              /* no */
            }

            /* Skip to the end of the comment. */
            while ((ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0)
            {
                if (ch == '*')
                {
                    ch = ScmStreamGetCh(pStrmInput);
                    if (ch == '/')
                        break;
                    if (ch == ~(unsigned)0)
                        break;
                }
            }
            if (ch == ~(unsigned)0)
                return vbcppError(pThis, "unterminated multi-line comment");
            chPrev = '/';
        }
        /* New line (also matched by RT_C_IS_SPACE). */
        else if (ch == '\r' || ch == '\n')
        {
            /* Stop if not escaped. */
            if (chPrev != '\\')
                break;
            chPrev = ch;
            ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
        }
        /* Real space char. */
        else
        {
            chPrev = ch;
            ch = ScmStreamGetCh(pStrmInput);
            Assert(ch == chPrev);
        }
    }
    return RTEXITCODE_SUCCESS;
}


/**
 * Skips white spaces, escaped new-lines, and multi line comments, then checking
 * that we're at the end of a line.
 *
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 */
static RTEXITCODE vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(PVBCPP pThis, PSCMSTREAM pStrmInput)
{
    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        unsigned ch = ScmStreamPeekCh(pStrmInput);
        if (   ch != ~(unsigned)0
            && ch != '\r'
            && ch != '\n')
            rcExit = vbcppError(pThis, "Did not expected anything more on this line");
    }
    return rcExit;
}


/**
 * Skips white spaces.
 *
 * @returns The current location upon return.
 * @param   pStrmInput          The input stream.
 */
static size_t vbcppProcessSkipWhite(PSCMSTREAM pStrmInput)
{
    unsigned ch;
    while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
    {
        if (!RT_C_IS_SPACE(ch) || ch == '\r' || ch == '\n')
            break;
        unsigned chCheck = ScmStreamGetCh(pStrmInput);
        AssertBreak(chCheck == ch);
    }
    return ScmStreamTell(pStrmInput);
}


/**
 * Looks for a left parenthesis in the input stream.
 *
 * Used during macro expansion.  Will ignore comments, newlines and other
 * whitespace.
 *
 * @retval  true if found. The stream position at opening parenthesis.
 * @retval  false if not found. The stream position is unchanged.
 *
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 */
static bool vbcppInputLookForLeftParenthesis(PVBCPP pThis, PSCMSTREAM pStrmInput)
{
    size_t offSaved = ScmStreamTell(pStrmInput);
    /*RTEXITCODE rcExit =*/ vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
    unsigned ch = ScmStreamPeekCh(pStrmInput);
    if (ch == '(')
        return true;

    int rc = ScmStreamSeekAbsolute(pStrmInput, offSaved);
    AssertFatalRC(rc);
    return false;
}


/**
 * Skips input until the real end of the current directive line has been
 * reached.
 *
 * This includes multiline comments starting on the same line
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 * @param   poffComment         Where to note down the position of the final
 *                              comment. Optional.
 */
static RTEXITCODE vbcppInputSkipToEndOfDirectiveLine(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t *poffComment)
{
    if (poffComment)
        *poffComment = ~(size_t)0;

    RTEXITCODE  rcExit      = RTEXITCODE_SUCCESS;
    bool        fInComment  = false;
    unsigned    chPrev      = 0;
    unsigned    ch;
    while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
    {
        if (ch == '\r' || ch == '\n')
        {
            if (chPrev == '\\')
            {
                ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
                continue;
            }
            if (!fInComment)
                break;
            /* The expression continues after multi-line comments. Cool. :-) */
        }
        else if (!fInComment)
        {
            if (chPrev == '/' && ch == '*' )
            {
                fInComment = true;
                if (poffComment)
                    *poffComment = ScmStreamTell(pStrmInput) - 1;
            }
            else if (chPrev == '/' && ch == '/')
            {
                if (poffComment)
                    *poffComment = ScmStreamTell(pStrmInput) - 1;
                rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
                break;                  /* done */
            }
        }
        else if (ch == '/' && chPrev == '*')
            fInComment = false;

        /* advance */
        chPrev = ch;
        ch = ScmStreamGetCh(pStrmInput); Assert(ch == chPrev);
    }
    return rcExit;
}


/**
 * Processes a multi-line comment.
 *
 * Must either string the comment or keep it. If the latter, we must refrain
 * from replacing C-words in it.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 */
static RTEXITCODE vbcppProcessMultiLineComment(PVBCPP pThis, PSCMSTREAM pStrmInput)
{
    /* The open comment sequence. */
    ScmStreamGetCh(pStrmInput);         /* '*' */
    RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
    if (   pThis->fKeepComments
        && !pThis->fIf0Mode)
        rcExit = vbcppOutputWrite(pThis, "/*", 2);

    /* The comment.*/
    unsigned ch;
    while (   rcExit == RTEXITCODE_SUCCESS
           && (ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0 )
    {
        if (ch == '*')
        {
            /* Closing sequence? */
            unsigned ch2 = ScmStreamPeekCh(pStrmInput);
            if (ch2 == '/')
            {
                ScmStreamGetCh(pStrmInput);
                if (   pThis->fKeepComments
                    && !pThis->fIf0Mode)
                    rcExit = vbcppOutputWrite(pThis, "*/", 2);
                break;
            }
        }

        if (ch == '\r' || ch == '\n')
        {
            if (   (   pThis->fKeepComments
                    && !pThis->fIf0Mode)
                || !pThis->fRemoveDroppedLines
                || !ScmStreamIsAtStartOfLine(&pThis->StrmOutput))
                rcExit = vbcppOutputCh(pThis, ch);
            pThis->fJustDroppedLine       = false;
            pThis->fMaybePreprocessorLine = true;
        }
        else if (   pThis->fKeepComments
                 && !pThis->fIf0Mode)
            rcExit = vbcppOutputCh(pThis, ch);

        if (rcExit != RTEXITCODE_SUCCESS)
            break;
    }
    return rcExit;
}


/**
 * Processes a single line comment.
 *
 * Must either string the comment or keep it. If the latter, we must refrain
 * from replacing C-words in it.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 */
static RTEXITCODE vbcppProcessOneLineComment(PVBCPP pThis, PSCMSTREAM pStrmInput)
{
    RTEXITCODE  rcExit = RTEXITCODE_SUCCESS;
    SCMEOL      enmEol;
    size_t      cchLine;
    const char *pszLine = ScmStreamGetLine(pStrmInput, &cchLine, &enmEol); Assert(pszLine);
    pszLine--; cchLine++;               /* unfetching the first slash. */
    for (;;)
    {
        if (   pThis->fKeepComments
            && !pThis->fIf0Mode)
            rcExit = vbcppOutputWrite(pThis, pszLine, cchLine + enmEol);
        else if (   !pThis->fIf0Mode
                 || !pThis->fRemoveDroppedLines
                 || !ScmStreamIsAtStartOfLine(&pThis->StrmOutput) )
            rcExit = vbcppOutputWrite(pThis, pszLine + cchLine, enmEol);
        if (rcExit != RTEXITCODE_SUCCESS)
            break;
        if (   cchLine == 0
            || pszLine[cchLine - 1] != '\\')
            break;

        pszLine = ScmStreamGetLine(pStrmInput, &cchLine, &enmEol);
        if (!pszLine)
            break;
    }
    pThis->fJustDroppedLine       = false;
    pThis->fMaybePreprocessorLine = true;
    return rcExit;
}


/**
 * Processes a double quoted string.
 *
 * Must not replace any C-words in strings.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 */
static RTEXITCODE vbcppProcessStringLitteral(PVBCPP pThis, PSCMSTREAM pStrmInput)
{
    RTEXITCODE rcExit = vbcppOutputCh(pThis, '"');
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        bool fEscaped = false;
        for (;;)
        {
            unsigned ch = ScmStreamGetCh(pStrmInput);
            if (ch == ~(unsigned)0)
            {
                rcExit = vbcppError(pThis, "Unterminated double quoted string");
                break;
            }

            rcExit = vbcppOutputCh(pThis, ch);
            if (rcExit != RTEXITCODE_SUCCESS)
                break;

            if (ch == '"' && !fEscaped)
                break;
            fEscaped = !fEscaped && ch == '\\';
        }
    }
    return rcExit;
}


/**
 * Processes a single quoted constant.
 *
 * Must not replace any C-words in character constants.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 */
static RTEXITCODE vbcppProcessCharacterConstant(PVBCPP pThis, PSCMSTREAM pStrmInput)
{
    RTEXITCODE rcExit = vbcppOutputCh(pThis, '\'');
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        bool fEscaped = false;
        for (;;)
        {
            unsigned ch = ScmStreamGetCh(pStrmInput);
            if (ch == ~(unsigned)0)
            {
                rcExit = vbcppError(pThis, "Unterminated singled quoted string");
                break;
            }

            rcExit = vbcppOutputCh(pThis, ch);
            if (rcExit != RTEXITCODE_SUCCESS)
                break;

            if (ch == '\'' && !fEscaped)
                break;
            fEscaped = !fEscaped && ch == '\\';
        }
    }
    return rcExit;
}


/**
 * Processes a integer or floating point number constant.
 *
 * Must not replace the type suffix.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 * @param   chFirst             The first character.
 */
static RTEXITCODE vbcppProcessNumber(PVBCPP pThis, PSCMSTREAM pStrmInput, char chFirst)
{
    RTEXITCODE rcExit = vbcppOutputCh(pThis, chFirst);

    unsigned ch;
    while (   rcExit == RTEXITCODE_SUCCESS
           && (ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
    {
        if (   !vbcppIsCIdentifierChar(ch)
            && ch != '.')
            break;

        unsigned ch2 = ScmStreamGetCh(pStrmInput);
        AssertBreakStmt(ch2 == ch, rcExit = vbcppError(pThis, "internal error"));
        rcExit = vbcppOutputCh(pThis, ch);
    }

    return rcExit;
}


/**
 * Processes a identifier, possibly replacing it with a definition.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 */
static RTEXITCODE vbcppProcessIdentifier(PVBCPP pThis, PSCMSTREAM pStrmInput)
{
    RTEXITCODE  rcExit;
    size_t      cchDefine;
    const char *pchDefine = ScmStreamCGetWordM1(pStrmInput, &cchDefine);
    AssertReturn(pchDefine, vbcppError(pThis, "Internal error in ScmStreamCGetWordM1"));

    /*
     * Does this look like a define we know?
     */
    PVBCPPMACRO pMacro = vbcppMacroLookup(pThis, pchDefine, cchDefine);
    if (   pMacro
        && (   !pMacro->fFunction
            || vbcppInputLookForLeftParenthesis(pThis, pStrmInput)) )
    {
        /*
         * Expand it.
         */
        VBCPPMACROEXP ExpCtx;
#if 0
        ExpCtx.pMacroStack    = NULL;
#endif
        ExpCtx.pStrmInput     = pStrmInput;
        ExpCtx.papszArgs      = NULL;
        ExpCtx.cArgs          = 0;
        ExpCtx.cArgsAlloced   = 0;
        vbcppStrBufInit(&ExpCtx.StrBuf, pThis);
        rcExit = vbcppStrBufAppendN(&ExpCtx.StrBuf, pchDefine, cchDefine);
        if (rcExit == RTEXITCODE_SUCCESS)
            rcExit = vbcppMacroExpandIt(pThis, &ExpCtx, 0 /* offset */, pMacro, cchDefine);
        if (rcExit == RTEXITCODE_SUCCESS)
            rcExit = vbcppMacroExpandReScan(pThis, &ExpCtx, kMacroReScanMode_Normal, NULL);
        if (rcExit == RTEXITCODE_SUCCESS)
        {
            /*
             * Insert it into the output stream.  Make sure there is a
             * whitespace following it.
             */
            int rc = ScmStreamWrite(&pThis->StrmOutput, ExpCtx.StrBuf.pszBuf, ExpCtx.StrBuf.cchBuf);
            if (RT_SUCCESS(rc))
            {
                unsigned chAfter = ScmStreamPeekCh(pStrmInput);
                if (chAfter != ~(unsigned)0 && !RT_C_IS_SPACE(chAfter))
                    rcExit = vbcppOutputCh(pThis, ' ');
            }
            else
                rcExit = vbcppError(pThis, "Output error: %Rrc", rc);
        }
        vbcppMacroExpandCleanup(&ExpCtx);
    }
    else
    {
        /*
         * Not a macro or a function-macro name match but no invocation, just
         * output the text unchanged.
         */
        int rc = ScmStreamWrite(&pThis->StrmOutput, pchDefine, cchDefine);
        if (RT_SUCCESS(rc))
            rcExit = RTEXITCODE_SUCCESS;
        else
            rcExit = vbcppError(pThis, "Output error: %Rrc", rc);
    }
    return rcExit;
}







/*
 *
 *
 * D E F I N E S   /   M A C R O S
 * D E F I N E S   /   M A C R O S
 * D E F I N E S   /   M A C R O S
 * D E F I N E S   /   M A C R O S
 * D E F I N E S   /   M A C R O S
 *
 *
 */


/**
 * Checks if a define exists.
 *
 * @returns true or false.
 * @param   pThis               The C preprocessor instance.
 * @param   pszDefine           The define name and optionally the argument
 *                              list.
 * @param   cchDefine           The length of the name. RTSTR_MAX is ok.
 */
static bool vbcppMacroExists(PVBCPP pThis, const char *pszDefine, size_t cchDefine)
{
    return cchDefine > 0
        && VBCPP_BITMAP_IS_SET(pThis->bmDefined, *pszDefine)
        && RTStrSpaceGetN(&pThis->StrSpace, pszDefine, cchDefine) != NULL;
}


/**
 * Looks up a define.
 *
 * @returns Pointer to the define if found, NULL if not.
 * @param   pThis               The C preprocessor instance.
 * @param   pszDefine           The define name and optionally the argument
 *                              list.
 * @param   cchDefine           The length of the name. RTSTR_MAX is ok.
 */
static PVBCPPMACRO vbcppMacroLookup(PVBCPP pThis, const char *pszDefine, size_t cchDefine)
{
    if (!cchDefine)
        return NULL;
    if (!VBCPP_BITMAP_IS_SET(pThis->bmDefined, *pszDefine))
        return NULL;
    return (PVBCPPMACRO)RTStrSpaceGetN(&pThis->StrSpace, pszDefine, cchDefine);
}


static uint32_t vbcppMacroLookupArg(PVBCPPMACRO pMacro, const char *pchName, size_t cchName)
{
    Assert(cchName > 0);

    char const ch = *pchName;
    for (uint32_t i = 0; i < pMacro->cArgs; i++)
        if (   pMacro->papszArgs[i][0] == ch
            && !strncmp(pMacro->papszArgs[i], pchName, cchName)
            && pMacro->papszArgs[i][cchName] == '\0')
            return i;

    if (   pMacro->fVarArg
        && cchName == sizeof("__VA_ARGS__") - 1
        && !strncmp(pchName, "__VA_ARGS__", sizeof("__VA_ARGS__") - 1) )
        return pMacro->cArgs;

    return UINT32_MAX;
}


static RTEXITCODE vbcppMacroExpandReplace(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t off, size_t cchToReplace,
                                          const char *pchReplacement, size_t cchReplacement)
{
    RT_NOREF_PV(pThis);

    /*
     * Figure how much space we actually need.
     * (Hope this whitespace stuff is correct...)
     */
    bool const fLeadingSpace            = off > 0
                                       && !RT_C_IS_SPACE(pExp->StrBuf.pszBuf[off - 1]);
    bool const fTrailingSpace           = off + cchToReplace < pExp->StrBuf.cchBuf
                                       && !RT_C_IS_SPACE(pExp->StrBuf.pszBuf[off + cchToReplace]);
    size_t const cchActualReplacement   = fLeadingSpace + cchReplacement + fTrailingSpace;

    /*
     * Adjust the buffer size and contents.
     */
    if (cchActualReplacement > cchToReplace)
    {
        size_t const offMore = cchActualReplacement - cchToReplace;

        /* Ensure enough buffer space. */
        size_t cbMinBuf = offMore + pExp->StrBuf.cchBuf + 1;
        RTEXITCODE rcExit = vbcppStrBufGrow(&pExp->StrBuf, cbMinBuf);
        if (rcExit != RTEXITCODE_SUCCESS)
            return rcExit;

        /* Push the chars following the replacement area down to make room. */
        memmove(&pExp->StrBuf.pszBuf[off + cchToReplace + offMore],
                &pExp->StrBuf.pszBuf[off + cchToReplace],
                pExp->StrBuf.cchBuf - off - cchToReplace + 1);
        pExp->StrBuf.cchBuf += offMore;

    }
    else if (cchActualReplacement < cchToReplace)
    {
        size_t const offLess = cchToReplace - cchActualReplacement;

        /* Pull the chars following the replacement area up. */
        memmove(&pExp->StrBuf.pszBuf[off + cchToReplace - offLess],
                &pExp->StrBuf.pszBuf[off + cchToReplace],
                pExp->StrBuf.cchBuf - off - cchToReplace + 1);
        pExp->StrBuf.cchBuf -= offLess;
    }

    /*
     * Insert the replacement string.
     */
    char *pszCur = &pExp->StrBuf.pszBuf[off];
    if (fLeadingSpace)
        *pszCur++ = ' ';
    memcpy(pszCur, pchReplacement, cchReplacement);
    if (fTrailingSpace)
        *pszCur++ = ' ';

    Assert(strlen(pExp->StrBuf.pszBuf) == pExp->StrBuf.cchBuf);

    return RTEXITCODE_SUCCESS;
}


static unsigned vbcppMacroExpandPeekCh(PVBCPPMACROEXP pExp, size_t *poff)
{
    size_t off = *poff;
    if (off >= pExp->StrBuf.cchBuf)
        return pExp->pStrmInput ? ScmStreamPeekCh(pExp->pStrmInput) : ~(unsigned)0;
    return pExp->StrBuf.pszBuf[off];
}


static unsigned vbcppMacroExpandGetCh(PVBCPPMACROEXP pExp, size_t *poff)
{
    size_t off = *poff;
    if (off >= pExp->StrBuf.cchBuf)
        return pExp->pStrmInput ? ScmStreamGetCh(pExp->pStrmInput) : ~(unsigned)0;
    *poff = off + 1;
    return pExp->StrBuf.pszBuf[off];
}


static RTEXITCODE vbcppMacroExpandSkipEolEx(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff, unsigned chFirst)
{
    if (chFirst == '\r')
    {
        unsigned ch2 = vbcppMacroExpandPeekCh(pExp, poff);
        if (ch2 == '\n')
        {
            ch2 = ScmStreamGetCh(pExp->pStrmInput);
            AssertReturn(ch2 == '\n', vbcppError(pThis, "internal error"));
        }
    }
    return RTEXITCODE_SUCCESS;
}


static RTEXITCODE vbcppMacroExpandSkipEol(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff)
{
    unsigned ch = vbcppMacroExpandGetCh(pExp, poff);
    AssertReturn(ch == '\r' || ch == '\n', vbcppError(pThis, "internal error"));
    return vbcppMacroExpandSkipEolEx(pThis, pExp, poff, ch);
}


static RTEXITCODE vbcppMacroExpandSkipCommentLine(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff)
{
    unsigned ch = vbcppMacroExpandGetCh(pExp, poff);
    AssertReturn(ch == '/', vbcppError(pThis, "Internal error - expected '/' got '%c'", ch));

    unsigned chPrev = 0;
    while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
    {
        if (ch == '\r' || ch == '\n')
        {
            RTEXITCODE rcExit = vbcppMacroExpandSkipEolEx(pThis, pExp, poff, ch);
            if (rcExit != RTEXITCODE_SUCCESS)
                return rcExit;
            if (chPrev != '\\')
                break;
        }

        chPrev = ch;
    }
    return RTEXITCODE_SUCCESS;
}


static RTEXITCODE vbcppMacroExpandSkipComment(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff)
{
    unsigned ch = vbcppMacroExpandGetCh(pExp, poff);
    AssertReturn(ch == '*', vbcppError(pThis, "Internal error - expected '*' got '%c'", ch));

    unsigned chPrev2 = 0;
    unsigned chPrev  = 0;
    while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
    {
        if (ch == '/' && chPrev == '*')
            break;

        if (ch == '\r' || ch == '\n')
        {
            RTEXITCODE rcExit = vbcppMacroExpandSkipEolEx(pThis, pExp, poff, ch);
            if (rcExit != RTEXITCODE_SUCCESS)
                return rcExit;
            if (chPrev == '\\')
            {
                chPrev = chPrev2;       /* for line splicing */
                continue;
            }
        }

        chPrev2 = chPrev;
        chPrev  = ch;
    }
    return RTEXITCODE_SUCCESS;
}


static RTEXITCODE vbcppMacroExpandGrowArgArray(PVBCPP pThis, PVBCPPMACROEXP pExp, uint32_t cMinArgs)
{
    if (cMinArgs > pExp->cArgsAlloced)
    {
        void *pv = RTMemRealloc(pExp->papszArgs, cMinArgs * sizeof(char *));
        if (!pv)
            return vbcppError(pThis, "out of memory");
        pExp->papszArgs = (char **)pv;
        pExp->cArgsAlloced = cMinArgs;
    }
    return RTEXITCODE_SUCCESS;
}


static RTEXITCODE vbcppMacroExpandAddEmptyParameter(PVBCPP pThis, PVBCPPMACROEXP pExp)
{
    RTEXITCODE rcExit = vbcppMacroExpandGrowArgArray(pThis, pExp, pExp->cArgs + 1);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        char *pszArg = (char *)RTMemAllocZ(1);
        if (pszArg)
            pExp->papszArgs[pExp->cArgs++] = pszArg;
        else
            rcExit = vbcppError(pThis, "out of memory");
    }
    return rcExit;
}


static RTEXITCODE vbcppMacroExpandGatherParameters(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff, uint32_t cArgsHint)
{
    RTEXITCODE rcExit = RTEXITCODE_SUCCESS;

    /*
     * Free previous argument values.
     */
    while (pExp->cArgs > 0)
    {
        RTMemFree(pExp->papszArgs[--pExp->cArgs]);
        pExp->papszArgs[pExp->cArgs] = NULL;
    }

    /*
     * The current character should be an opening parenthsis.
     */
    unsigned    ch = vbcppMacroExpandGetCh(pExp, poff);
    if (ch != '(')
        return vbcppError(pThis, "Internal error - expected '(', found '%c' (#x)", ch, ch);

    /*
     * Parse the argument list.
     */
    char        chQuote      = 0;
    size_t      cbArgAlloc   = 0;
    size_t      cchArg       = 0;
    char       *pszArg       = NULL;
    size_t      cParentheses = 1;
    unsigned    chPrev       = 0;
    while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
    {
/** @todo check for '#directives'! */
        if (ch == ')' && !chQuote)
        {
            Assert(cParentheses >= 1);
            cParentheses--;

            /* The end? */
            if (!cParentheses)
            {
                if (cchArg)
                    while (cchArg > 0 && RT_C_IS_SPACE(pszArg[cchArg - 1]))
                        pszArg[--cchArg] = '\0';
                else if (pExp->cArgs || cArgsHint > 0)
                    rcExit = vbcppMacroExpandAddEmptyParameter(pThis, pExp);
                break;
            }
        }
        else if (ch == '('  && !chQuote)
            cParentheses++;
        else if (ch == ',' && cParentheses == 1 && !chQuote)
        {
            /* End of one argument, start of the next. */
            if (cchArg)
                while (cchArg > 0 && RT_C_IS_SPACE(pszArg[cchArg - 1]))
                    pszArg[--cchArg] = '\0';
            else
            {
                rcExit = vbcppMacroExpandAddEmptyParameter(pThis, pExp);
                if (rcExit != RTEXITCODE_SUCCESS)
                    break;
            }

            cbArgAlloc = 0;
            cchArg     = 0;
            pszArg     = NULL;
            continue;
        }
        else if (ch == '/' && !chQuote)
        {
            /* Comment? */
            unsigned ch2 = vbcppMacroExpandPeekCh(pExp, poff);
            /** @todo This ain't right wrt line splicing. */
            if (ch2 == '/' || ch == '*')
            {
                if (ch2 == '/')
                    rcExit = vbcppMacroExpandSkipCommentLine(pThis, pExp, poff);
                else
                    rcExit = vbcppMacroExpandSkipComment(pThis, pExp, poff);
                if (rcExit != RTEXITCODE_SUCCESS)
                    break;
                continue;
            }
        }
        else if (ch == '"')
        {
            if (!chQuote)
                chQuote = '"';
            else if (chPrev != '\\')
                chQuote = 0;
        }
        else if (ch == '\'')
        {
            if (!chQuote)
                chQuote = '\'';
            else if (chPrev != '\\')
                chQuote = 0;
        }
        else if (ch == '\\')
        {
            /* Splice lines? */
            unsigned ch2 = vbcppMacroExpandPeekCh(pExp, poff);
            if (ch2 == '\r' || ch2 == '\n')
            {
                rcExit = vbcppMacroExpandSkipEol(pThis, pExp, poff);
                if (rcExit != RTEXITCODE_SUCCESS)
                    break;
                continue;
            }
        }
        else if (cchArg == 0 && RT_C_IS_SPACE(ch))
            continue; /* ignore spaces leading up to an argument value */

        /* Append the character to the argument value, adding the argument
           to the output array if it's first character in it. */
        if (cchArg + 1 >= cbArgAlloc)
        {
            /* Add argument to the vector. */
            if (!cchArg)
            {
                rcExit = vbcppMacroExpandGrowArgArray(pThis, pExp, RT_MAX(pExp->cArgs + 1, cArgsHint));
                if (rcExit != RTEXITCODE_SUCCESS)
                    break;
                pExp->papszArgs[pExp->cArgs++] = pszArg;
            }

            /* Resize the argument value buffer. */
            cbArgAlloc = cbArgAlloc ? cbArgAlloc * 2 : 16;
            pszArg = (char *)RTMemRealloc(pszArg, cbArgAlloc);
            if (!pszArg)
            {
                rcExit = vbcppError(pThis, "out of memory");
                break;
            }
            pExp->papszArgs[pExp->cArgs - 1] = pszArg;
        }

        pszArg[cchArg++] = ch;
        pszArg[cchArg]   = '\0';
    }

    /*
     * Check that we're leaving on good terms.
     */
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        if (cParentheses)
            rcExit = vbcppError(pThis, "Missing ')'");
    }

    return rcExit;
}


/**
 * Expands the arguments referenced in the macro value.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pExp                The expansion context.
 * @param   pMacro              The macro.  Must be a function macro.
 * @param   pStrBuf             String buffer containing the result. The caller
 *                              should initialize and destroy this!
 */
static RTEXITCODE vbcppMacroExpandValueWithArguments(PVBCPP pThis, PVBCPPMACROEXP pExp, PVBCPPMACRO pMacro,
                                                     PVBCPPSTRBUF pStrBuf)
{
    Assert(pMacro->fFunction);

    /*
     * Empty?
     */
    if (   !pMacro->cchValue
        || (pMacro->cchValue == 1 && pMacro->szValue[0] == '#'))
        return RTEXITCODE_SUCCESS;

    /*
     * Parse the value.
     */
    RTEXITCODE  rcExit    = RTEXITCODE_SUCCESS;
    const char *pszSrc    = pMacro->szValue;
    const char *pszSrcSeq;
    char        ch;
    while ((ch = *pszSrc++) != '\0')
    {
        Assert(ch != '\r'); Assert(ch != '\n'); /* probably not true atm. */
        if (ch == '#')
        {
            if (*pszSrc == '#')
            {
                /* Concatenate operator. */
                rcExit = vbcppError(pThis, "The '##' operatore is not yet implemented");
            }
            else
            {
                /* Stringify macro argument. */
                rcExit = vbcppError(pThis, "The '#' operatore is not yet implemented");
            }
            return rcExit;
        }
        else if (ch == '"')
        {
            /* String litteral. */
            pszSrcSeq = pszSrc - 1;
            while ((ch = *pszSrc++) != '"')
            {
                if (ch == '\\')
                    ch = *pszSrc++;
                if (ch == '\0')
                {
                    rcExit = vbcppError(pThis, "String litteral is missing closing quote (\").");
                    break;
                }
            }
            rcExit = vbcppStrBufAppendN(pStrBuf, pszSrcSeq, pszSrc - pszSrcSeq);
        }
        else if (ch == '\'')
        {
            /* Character constant. */
            pszSrcSeq = pszSrc - 1;
            while ((ch = *pszSrc++) != '\'')
            {
                if (ch == '\\')
                    ch = *pszSrc++;
                if (ch == '\0')
                {
                    rcExit = vbcppError(pThis, "Character constant is missing closing quote (').");
                    break;
                }
            }
            rcExit = vbcppStrBufAppendN(pStrBuf, pszSrcSeq, pszSrc - pszSrcSeq);
        }
        else if (RT_C_IS_DIGIT(ch))
        {
            /* Process numerical constants correctly (i.e. don't mess with the suffix). */
            pszSrcSeq = pszSrc - 1;
            while (   (ch = *pszSrc) != '\0'
                   && (   vbcppIsCIdentifierChar(ch)
                       || ch == '.') )
                pszSrc++;
            rcExit = vbcppStrBufAppendN(pStrBuf, pszSrcSeq, pszSrc - pszSrcSeq);
        }
        else if (RT_C_IS_SPACE(ch))
        {
            /* join spaces */
            if (RT_C_IS_SPACE(vbcppStrBufLastCh(pStrBuf)))
                continue;
            rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
        }
        else if (vbcppIsCIdentifierLeadChar(ch))
        {
            /* Something we should replace? */
            pszSrcSeq = pszSrc - 1;
            while (   (ch = *pszSrc) != '\0'
                   && vbcppIsCIdentifierChar(ch))
                pszSrc++;
            size_t      cchDefine = pszSrc - pszSrcSeq;
            uint32_t    iArg;
            if (   VBCPP_BITMAP_IS_SET(pMacro->bmArgs, *pszSrcSeq)
                && (iArg = vbcppMacroLookupArg(pMacro, pszSrcSeq, cchDefine)) != UINT32_MAX)
            {
                /** @todo check out spaces here! */
                if (iArg < pMacro->cArgs)
                {
                    Assert(iArg < pExp->cArgs);
                    rcExit = vbcppStrBufAppend(pStrBuf, pExp->papszArgs[iArg]);
                    if (*pExp->papszArgs[iArg] != '\0' && rcExit == RTEXITCODE_SUCCESS)
                        rcExit = vbcppStrBufAppendCh(pStrBuf, ' ');
                }
                else
                {
                    /* __VA_ARGS__ */
                    if (iArg < pExp->cArgs)
                    {
                        for (;;)
                        {
                            rcExit = vbcppStrBufAppend(pStrBuf, pExp->papszArgs[iArg]);
                            if (rcExit != RTEXITCODE_SUCCESS)
                                break;
                            iArg++;
                            if (iArg >= pExp->cArgs)
                                break;
                            rcExit = vbcppStrBufAppendCh(pStrBuf, ',');
                            if (rcExit != RTEXITCODE_SUCCESS)
                                break;
                        }
                    }
                    if (rcExit == RTEXITCODE_SUCCESS)
                        rcExit = vbcppStrBufAppendCh(pStrBuf, ' ');
                }
            }
            /* Not an argument needing replacing. */
            else
                rcExit = vbcppStrBufAppendN(pStrBuf, pszSrcSeq, cchDefine);
        }
        else
        {
            rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
        }
    }

    return rcExit;
}



/**
 * Expands the given macro.
 *
 * Caller already checked if a function macro should be expanded, i.e. whether
 * there is a parameter list.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pExp                The expansion context.
 * @param   offMacro            Offset into the expansion buffer of the macro
 *                              invocation.
 * @param   pMacro              The macro.
 * @param   offParameters       The start of the parameter list if applicable.
 *                              Ignored if not function macro.  If the
 *                              parameter list starts at the current stream
 *                              position shall be at the end of the expansion
 *                              buffer.
 */
static RTEXITCODE vbcppMacroExpandIt(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t offMacro, PVBCPPMACRO pMacro,
                                     size_t offParameters)
{
    RTEXITCODE rcExit;
    Assert(offMacro + pMacro->Core.cchString <= pExp->StrBuf.cchBuf);
    Assert(!pMacro->fExpanding);

    /*
     * Function macros are kind of difficult...
     */
    if (pMacro->fFunction)
    {
        rcExit = vbcppMacroExpandGatherParameters(pThis, pExp, &offParameters, pMacro->cArgs + pMacro->fVarArg);
        if (rcExit == RTEXITCODE_SUCCESS)
        {
            if (pExp->cArgs > pMacro->cArgs && !pMacro->fVarArg)
                rcExit = vbcppError(pThis, "Too many arguments to macro '%s' - found %u, expected %u",
                                    pMacro->Core.pszString, pExp->cArgs, pMacro->cArgs);
            else if (pExp->cArgs < pMacro->cArgs)
                rcExit = vbcppError(pThis, "Too few arguments to macro '%s' - found %u, expected %u",
                                    pMacro->Core.pszString, pExp->cArgs, pMacro->cArgs);
        }
        if (rcExit == RTEXITCODE_SUCCESS)
        {
            VBCPPSTRBUF ValueBuf;
            vbcppStrBufInit(&ValueBuf, pThis);
            rcExit = vbcppMacroExpandValueWithArguments(pThis, pExp, pMacro, &ValueBuf);
            if (rcExit == RTEXITCODE_SUCCESS)
                rcExit = vbcppMacroExpandReplace(pThis, pExp, offMacro, offParameters - offMacro,
                                                 ValueBuf.pszBuf, ValueBuf.cchBuf);
            vbcppStrBufDelete(&ValueBuf);
        }
    }
    /*
     * Object-like macros are easy. :-)
     */
    else
        rcExit = vbcppMacroExpandReplace(pThis, pExp, offMacro, pMacro->Core.cchString, pMacro->szValue, pMacro->cchValue);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
#if 0 /* wrong */
        /*
         * Push the macro onto the stack.
         */
        pMacro->fExpanding   = true;
        pMacro->pUpExpanding = pExp->pMacroStack;
        pExp->pMacroStack    = pMacro;
#endif
    }

    return rcExit;
}


/**
 * Looks for a left parenthesis in the macro expansion buffer and the input
 * stream.
 *
 * @retval  true if found. The stream position at opening parenthesis.
 * @retval  false if not found. The stream position is unchanged.
 *
 * @param   pThis               The C preprocessor instance.
 * @param   pExp                The expansion context.
 * @param   poff                The current offset in the expansion context.
 *                              Will be updated on success.
 *
 * @sa vbcppInputLookForLeftParenthesis
 */
static bool vbcppMacroExpandLookForLeftParenthesis(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff)
{
    /*
     * Search the buffer first. (No comments there.)
     */
    size_t off = *poff;
    while (off < pExp->StrBuf.cchBuf)
    {
        char ch = pExp->StrBuf.pszBuf[off];
        if (!RT_C_IS_SPACE(ch))
        {
            if (ch == '(')
            {
                *poff = off;
                return true;
            }
            return false;
        }
        off++;
    }

    /*
     * Reached the end of the buffer, continue searching in the stream.
     */
    PSCMSTREAM pStrmInput = pExp->pStrmInput;
    size_t     offSaved   = ScmStreamTell(pStrmInput);
    /*RTEXITCODE rcExit = */ vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
    unsigned ch = ScmStreamPeekCh(pStrmInput);
    if (ch == '(')
    {
        *poff = pExp->StrBuf.cchBuf;
        return true;
    }

    int rc = ScmStreamSeekAbsolute(pStrmInput, offSaved);
    AssertFatalRC(rc);
    return false;
}


/**
 * Implements the 'defined' unary operator for \#if and \#elif expressions.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pExp                The expansion context.
 * @param   offStart            The expansion buffer offset where the 'defined'
 *                              occurs.
 * @param   poff                Where to store the offset at which the re-scan
 *                              shall resume upon return.
 */
static RTEXITCODE vbcppMacroExpandDefinedOperator(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t offStart, size_t *poff)
{
    Assert(!pExp->pStrmInput); /* offset usage below. */

    /*
     * Skip white space.
     */
    unsigned ch;
    while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
        if (!RT_C_IS_SPACE(ch))
            break;
    bool const fWithParenthesis = ch == '(';
    if (fWithParenthesis)
        while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
            if (!RT_C_IS_SPACE(ch))
                break;

    /*
     * Macro identifier.
     */
    if (!vbcppIsCIdentifierLeadChar(ch))
        return vbcppError(pThis, "Expected macro name after 'defined' operator");

    size_t const offDefine = *poff - 1;
    while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
        if (!vbcppIsCIdentifierChar(ch))
            break;
    size_t const cchDefine = *poff - offDefine - 1;

    /*
     * Check for closing parenthesis.
     */
    if (fWithParenthesis)
    {
        while (RT_C_IS_SPACE(ch))
            ch = vbcppMacroExpandGetCh(pExp, poff);
        if (ch != ')')
            return vbcppError(pThis, "Expected closing parenthesis after macro name");
    }

    /*
     * Do the job.
     */
    const char *pszResult = vbcppMacroExists(pThis, &pExp->StrBuf.pszBuf[offDefine], cchDefine)
                          ? "1" : "0";
    RTEXITCODE  rcExit    = vbcppMacroExpandReplace(pThis, pExp, offStart, *poff - offStart, pszResult, 1);
    *poff = offStart + 1;
    return rcExit;
}


/**
 * Re-scan the expanded macro.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pExp                The expansion context.
 * @param   enmMode             The re-scan mode.
 * @param   pcReplacements      Where to return the number of replacements
 *                              performed.  Optional.
 */
static RTEXITCODE vbcppMacroExpandReScan(PVBCPP pThis, PVBCPPMACROEXP pExp, VBCPPMACRORESCANMODE enmMode, size_t *pcReplacements)
{
    RTEXITCODE  rcExit        = RTEXITCODE_SUCCESS;
    size_t      cReplacements = 0;
    size_t      off           = 0;
    unsigned    ch;
    while (   off < pExp->StrBuf.cchBuf
           && (ch = vbcppMacroExpandGetCh(pExp, &off)) != ~(unsigned)0)
    {
        /*
         * String litteral or character constant.
         */
        if (ch == '\'' || ch == '"')
        {
            unsigned const chEndQuote = ch;
            while (   off < pExp->StrBuf.cchBuf
                   && (ch = vbcppMacroExpandGetCh(pExp, &off)) != ~(unsigned)0)
            {
                if (ch == '\\')
                {
                    ch = vbcppMacroExpandGetCh(pExp, &off);
                    if (ch == ~(unsigned)0)
                        break;
                }
                else if (ch == chEndQuote)
                    break;
            }
            if (ch == ~(unsigned)0)
                return vbcppError(pThis, "Missing end quote (%c)", chEndQuote);
        }
        /*
         * Number constant.
         */
        else if (   RT_C_IS_DIGIT(ch)
                 || (   ch == '.'
                     && off + 1 < pExp->StrBuf.cchBuf
                     && RT_C_IS_DIGIT(vbcppMacroExpandPeekCh(pExp, &off))
                    )
                )
        {
            while (   off < pExp->StrBuf.cchBuf
                   && (ch = vbcppMacroExpandPeekCh(pExp, &off)) != ~(unsigned)0
                   && vbcppIsCIdentifierChar(ch) )
                vbcppMacroExpandGetCh(pExp, &off);
        }
        /*
         * Something that can be replaced?
         */
        else if (vbcppIsCIdentifierLeadChar(ch))
        {
            size_t offDefine = off - 1;
            while (   off < pExp->StrBuf.cchBuf
                   && (ch = vbcppMacroExpandPeekCh(pExp, &off)) != ~(unsigned)0
                   && vbcppIsCIdentifierChar(ch) )
                vbcppMacroExpandGetCh(pExp, &off);
            size_t cchDefine = off - offDefine;

            PVBCPPMACRO pMacro = vbcppMacroLookup(pThis, &pExp->StrBuf.pszBuf[offDefine], cchDefine);
            if (   pMacro
                && (   !pMacro->fFunction
                    || vbcppMacroExpandLookForLeftParenthesis(pThis, pExp, &off)) )
            {
                cReplacements++;
                rcExit = vbcppMacroExpandIt(pThis, pExp, offDefine, pMacro, off);
                off = offDefine;
            }
            else
            {
                if (   !pMacro
                         && enmMode == kMacroReScanMode_Expression
                         && cchDefine == sizeof("defined") - 1
                         && !strncmp(&pExp->StrBuf.pszBuf[offDefine], "defined", cchDefine))
                {
                    cReplacements++;
                    rcExit = vbcppMacroExpandDefinedOperator(pThis, pExp, offDefine, &off);
                }
                else
                    off = offDefine + cchDefine;
            }
        }
        else
        {
            Assert(RT_C_IS_SPACE(ch) || RT_C_IS_PUNCT(ch));
            Assert(ch != '\r' && ch != '\n');
        }
    }

    if (pcReplacements)
        *pcReplacements = cReplacements;
    return rcExit;
}


/**
 * Cleans up the expansion context.
 *
 * This involves clearing VBCPPMACRO::fExpanding and VBCPPMACRO::pUpExpanding,
 * and freeing the memory resources associated with the expansion context.
 *
 * @param   pExp                The expansion context.
 */
static void vbcppMacroExpandCleanup(PVBCPPMACROEXP pExp)
{
#if 0
    while (pExp->pMacroStack)
    {
        PVBCPPMACRO pMacro = pExp->pMacroStack;
        pExp->pMacroStack = pMacro->pUpExpanding;

        pMacro->fExpanding   = false;
        pMacro->pUpExpanding = NULL;
    }
#endif

    while (pExp->cArgs > 0)
    {
        RTMemFree(pExp->papszArgs[--pExp->cArgs]);
        pExp->papszArgs[pExp->cArgs] = NULL;
    }

    RTMemFree(pExp->papszArgs);
    pExp->papszArgs = NULL;

    vbcppStrBufDelete(&pExp->StrBuf);
}



/**
 * Frees a define.
 *
 * @returns VINF_SUCCESS (used when called by RTStrSpaceDestroy)
 * @param   pStr                Pointer to the VBCPPMACRO::Core member.
 * @param   pvUser              Unused.
 */
static DECLCALLBACK(int) vbcppMacroFree(PRTSTRSPACECORE pStr, void *pvUser)
{
    RTMemFree(pStr);
    NOREF(pvUser);
    return VINF_SUCCESS;
}


/**
 * Removes a define.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pszDefine           The define name, no argument list or anything.
 * @param   cchDefine           The length of the name. RTSTR_MAX is ok.
 * @param   fExplicitUndef      Explicit undefinition, that is, in a selective
 *                              preprocessing run it will evaluate to undefined.
 */
static RTEXITCODE vbcppMacroUndef(PVBCPP pThis, const char *pszDefine, size_t cchDefine, bool fExplicitUndef)
{
    PRTSTRSPACECORE pHit = RTStrSpaceGetN(&pThis->StrSpace, pszDefine, cchDefine);
    if (pHit)
    {
        RTStrSpaceRemove(&pThis->StrSpace, pHit->pszString);
        vbcppMacroFree(pHit, NULL);
    }

    if (fExplicitUndef)
    {
        if (cchDefine == RTSTR_MAX)
            cchDefine = strlen(pszDefine);

        PRTSTRSPACECORE pStr = (PRTSTRSPACECORE)RTMemAlloc(sizeof(*pStr) + cchDefine + 1);
        if (!pStr)
            return vbcppError(pThis, "out of memory");
        char *pszDst = (char *)(pStr + 1);
        pStr->pszString = pszDst;
        memcpy(pszDst, pszDefine, cchDefine);
        pszDst[cchDefine] = '\0';
        if (!RTStrSpaceInsert(&pThis->UndefStrSpace, pStr))
            RTMemFree(pStr);
    }

    return RTEXITCODE_SUCCESS;
}


/**
 * Inserts a define (rejecting and freeing it in some case).
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pMacro              The define to insert.
 */
static RTEXITCODE vbcppMacroInsert(PVBCPP pThis, PVBCPPMACRO pMacro)
{
    /*
     * Reject illegal macro names.
     */
    if (!strcmp(pMacro->Core.pszString, "defined"))
    {
        RTEXITCODE rcExit = vbcppError(pThis, "Cannot use '%s' as a macro name", pMacro->Core.pszString);
        vbcppMacroFree(&pMacro->Core, NULL);
        return rcExit;
    }

    /*
     * Ignore in source-file defines when doing selective preprocessing.
     */
    if (   !pThis->fRespectSourceDefines
        && !pMacro->fCmdLine)
    {
        /* Ignore*/
        vbcppMacroFree(&pMacro->Core, NULL);
        return RTEXITCODE_SUCCESS;
    }

    /*
     * Insert it and update the lead character hint bitmap.
     */
    if (RTStrSpaceInsert(&pThis->StrSpace, &pMacro->Core))
        VBCPP_BITMAP_SET(pThis->bmDefined, *pMacro->Core.pszString);
    else
    {
        /*
         * Duplicate. When doing selective D preprocessing, let the command
         * line take precendece.
         */
        PVBCPPMACRO pOld = (PVBCPPMACRO)RTStrSpaceGet(&pThis->StrSpace, pMacro->Core.pszString); Assert(pOld);
        if (   pThis->fAllowRedefiningCmdLineDefines
            || pMacro->fCmdLine == pOld->fCmdLine)
        {
            if (pMacro->fCmdLine)
                RTMsgWarning("Redefining '%s'", pMacro->Core.pszString);

            RTStrSpaceRemove(&pThis->StrSpace, pOld->Core.pszString);
            vbcppMacroFree(&pOld->Core, NULL);

            bool fRc = RTStrSpaceInsert(&pThis->StrSpace, &pMacro->Core);
            Assert(fRc); NOREF(fRc);
        }
        else
        {
            RTMsgWarning("Ignoring redefinition of '%s'", pMacro->Core.pszString);
            vbcppMacroFree(&pMacro->Core, NULL);
        }
    }

    return RTEXITCODE_SUCCESS;
}


/**
 * Adds a define.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pszDefine           The define name, no parameter list.
 * @param   cchDefine           The length of the name.
 * @param   pszParams           The parameter list.
 * @param   cchParams           The length of the parameter list.
 * @param   pszValue            The value.
 * @param   cchDefine           The length of the value.
 * @param   fCmdLine            Set if originating on the command line.
 */
static RTEXITCODE vbcppMacroAddFn(PVBCPP pThis, const char *pszDefine, size_t cchDefine,
                                  const char *pszParams, size_t cchParams,
                                  const char *pszValue, size_t cchValue,
                                  bool fCmdLine)

{
    Assert(RTStrNLen(pszDefine, cchDefine) == cchDefine);
    Assert(RTStrNLen(pszParams, cchParams) == cchParams);
    Assert(RTStrNLen(pszValue,  cchValue)  == cchValue);

    /*
     * Determin the number of arguments and how much space their names
     * requires.  Performing syntax validation while parsing.
     */
    uint32_t cchArgNames = 0;
    uint32_t cArgs       = 0;
    for (size_t off = 0; off < cchParams; off++)
    {
        /* Skip blanks and maybe one comma. */
        bool fIgnoreComma = cArgs != 0;
        while (off < cchParams)
        {
            if (!RT_C_IS_SPACE(pszParams[off]))
            {
                if (pszParams[off] != ',' || !fIgnoreComma)
                {
                    if (vbcppIsCIdentifierLeadChar(pszParams[off]))
                        break;
                    /** @todo variadic macros. */
                    return vbcppErrorPos(pThis, &pszParams[off], "Unexpected character");
                }
                fIgnoreComma = false;
            }
            off++;
        }
        if (off >= cchParams)
            break;

        /* Found and argument. First character is already validated. */
        cArgs++;
        cchArgNames += 2;
        off++;
        while (   off < cchParams
               && vbcppIsCIdentifierChar(pszParams[off]))
            off++, cchArgNames++;
    }

    /*
     * Allocate a structure.
     */
    size_t    cbDef = RT_UOFFSETOF_DYN(VBCPPMACRO, szValue[cchValue + 1 + cchDefine + 1 + cchArgNames])
                    + sizeof(const char *) * cArgs;
    cbDef = RT_ALIGN_Z(cbDef, sizeof(const char *));
    PVBCPPMACRO pMacro  = (PVBCPPMACRO)RTMemAlloc(cbDef);
    if (!pMacro)
        return RTMsgErrorExit(RTEXITCODE_FAILURE, "out of memory");

    char *pszDst = &pMacro->szValue[cchValue + 1];
    pMacro->Core.pszString = pszDst;
    memcpy(pszDst, pszDefine, cchDefine);
    pszDst += cchDefine;
    *pszDst++ = '\0';
    pMacro->fFunction   = true;
    pMacro->fVarArg     = false;
    pMacro->fCmdLine    = fCmdLine;
    pMacro->fExpanding  = false;
    pMacro->cArgs       = cArgs;
    pMacro->papszArgs   = (const char **)((uintptr_t)pMacro + cbDef - sizeof(const char *) * cArgs);
    VBCPP_BITMAP_EMPTY(pMacro->bmArgs);
    pMacro->cchValue    = cchValue;
    memcpy(pMacro->szValue, pszValue, cchValue);
    pMacro->szValue[cchValue] = '\0';

    /*
     * Set up the arguments.
     */
    uint32_t iArg = 0;
    for (size_t off = 0; off < cchParams; off++)
    {
        /* Skip blanks and maybe one comma. */
        bool fIgnoreComma = cArgs != 0;
        while (off < cchParams)
        {
            if (!RT_C_IS_SPACE(pszParams[off]))
            {
                if (pszParams[off] != ',' || !fIgnoreComma)
                    break;
                fIgnoreComma = false;
            }
            off++;
        }
        if (off >= cchParams)
            break;

        /* Found and argument. First character is already validated. */
        VBCPP_BITMAP_SET(pMacro->bmArgs, pszParams[off]);
        pMacro->papszArgs[iArg] = pszDst;
        do
        {
            *pszDst++ = pszParams[off++];
        } while (   off < cchParams
                 && vbcppIsCIdentifierChar(pszParams[off]));
        *pszDst++ = '\0';
        iArg++;
    }
    Assert((uintptr_t)pszDst <= (uintptr_t)pMacro->papszArgs);

    return vbcppMacroInsert(pThis, pMacro);
}


/**
 * Adds a define.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pszDefine           The define name and optionally the argument
 *                              list.
 * @param   cchDefine           The length of the name. RTSTR_MAX is ok.
 * @param   pszValue            The value.
 * @param   cchDefine           The length of the value. RTSTR_MAX is ok.
 * @param   fCmdLine            Set if originating on the command line.
 */
static RTEXITCODE vbcppMacroAdd(PVBCPP pThis, const char *pszDefine, size_t cchDefine,
                                const char *pszValue, size_t cchValue, bool fCmdLine)
{
    /*
     * We need the lengths. Trim the input.
     */
    if (cchDefine == RTSTR_MAX)
        cchDefine = strlen(pszDefine);
    while (cchDefine > 0 && RT_C_IS_SPACE(*pszDefine))
        pszDefine++, cchDefine--;
    while (cchDefine > 0 && RT_C_IS_SPACE(pszDefine[cchDefine - 1]))
        cchDefine--;
    if (!cchDefine)
        return vbcppErrorPos(pThis, pszDefine, "The define has no name");

    if (cchValue == RTSTR_MAX)
        cchValue = strlen(pszValue);
    while (cchValue > 0 && RT_C_IS_SPACE(*pszValue))
        pszValue++, cchValue--;
    while (cchValue > 0 && RT_C_IS_SPACE(pszValue[cchValue - 1]))
        cchValue--;

    /*
     * Arguments make the job a bit more annoying.  Handle that elsewhere
     */
    const char *pszParams = (const char *)memchr(pszDefine, '(', cchDefine);
    if (pszParams)
    {
        size_t cchParams = pszDefine + cchDefine - pszParams;
        cchDefine -= cchParams;
        if (!vbcppValidateCIdentifier(pThis, pszDefine, cchDefine))
            return RTEXITCODE_FAILURE;
        if (pszParams[cchParams - 1] != ')')
            return vbcppErrorPos(pThis, pszParams + cchParams - 1, "Missing closing parenthesis");
        pszParams++;
        cchParams -= 2;
        return vbcppMacroAddFn(pThis, pszDefine, cchDefine, pszParams, cchParams, pszValue, cchValue, fCmdLine);
    }

    /*
     * Simple define, no arguments.
     */
    if (!vbcppValidateCIdentifier(pThis, pszDefine, cchDefine))
        return RTEXITCODE_FAILURE;

    PVBCPPMACRO pMacro = (PVBCPPMACRO)RTMemAlloc(RT_UOFFSETOF_DYN(VBCPPMACRO, szValue[cchValue + 1 + cchDefine + 1]));
    if (!pMacro)
        return RTMsgErrorExit(RTEXITCODE_FAILURE, "out of memory");

    pMacro->Core.pszString = &pMacro->szValue[cchValue + 1];
    memcpy((char *)pMacro->Core.pszString, pszDefine, cchDefine);
    ((char *)pMacro->Core.pszString)[cchDefine] = '\0';
    pMacro->fFunction   = false;
    pMacro->fVarArg     = false;
    pMacro->fCmdLine    = fCmdLine;
    pMacro->fExpanding  = false;
    pMacro->cArgs       = 0;
    pMacro->papszArgs   = NULL;
    VBCPP_BITMAP_EMPTY(pMacro->bmArgs);
    pMacro->cchValue    = cchValue;
    memcpy(pMacro->szValue, pszValue, cchValue);
    pMacro->szValue[cchValue] = '\0';

    return vbcppMacroInsert(pThis, pMacro);
}


/**
 * Tries to convert a define into an inline D constant.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pMacro              The macro.
 */
static RTEXITCODE vbcppMacroTryConvertToInlineD(PVBCPP pThis, PVBCPPMACRO pMacro)
{
    AssertReturn(pMacro, vbcppError(pThis, "Internal error"));
    if (pMacro->fFunction)
        return RTEXITCODE_SUCCESS;

    /*
     * Do some simple macro resolving. (Mostly to make x86.h work.)
     */
    const char *pszDefine = pMacro->Core.pszString;
    const char *pszValue  = pMacro->szValue;
    size_t      cchValue  = pMacro->cchValue;

    unsigned    i = 0;
    PVBCPPMACRO pMacro2;
    while (   i < 10
           && cchValue > 0
           && vbcppIsCIdentifierLeadChar(*pszValue)
           && (pMacro2 = vbcppMacroLookup(pThis, pszValue, cchValue)) != NULL
           && !pMacro2->fFunction )
    {
        pszValue = pMacro2->szValue;
        cchValue = pMacro2->cchValue;
        i++;
    }

    if (!pMacro->cchValue)
        return RTEXITCODE_SUCCESS;


    /*
     * A lone value?
     */
    ssize_t  cch = 0;
    uint64_t u64;
    char    *pszNext;
    int rc = RTStrToUInt64Ex(pszValue, &pszNext, 0, &u64);
    if (RT_SUCCESS(rc))
    {
        if (   rc == VWRN_TRAILING_SPACES
            || rc == VWRN_NEGATIVE_UNSIGNED
            || rc == VWRN_NUMBER_TOO_BIG)
            return RTEXITCODE_SUCCESS;
        const char *pszType;
        if (rc == VWRN_TRAILING_CHARS)
        {
            if (!strcmp(pszNext, "u") || !strcmp(pszNext, "U"))
                pszType = "uint32_t";
            else if (!strcmp(pszNext, "ul") || !strcmp(pszNext, "UL"))
                pszType = "uintptr_t";
            else if (!strcmp(pszNext, "ull") || !strcmp(pszNext, "ULL"))
                pszType = "uint64_t";
            else
                pszType = NULL;
        }
        else if (u64 <= UINT8_MAX)
            pszType = "uint8_t";
        else if (u64 <= UINT16_MAX)
            pszType = "uint16_t";
        else if (u64 <= UINT32_MAX)
            pszType = "uint32_t";
        else
            pszType = "uint64_t";
        if (!pszType)
            return RTEXITCODE_SUCCESS;
        cch = ScmStreamPrintf(&pThis->StrmOutput, "inline %s %s = %.*s;\n",
                              pszType, pszDefine, pszNext - pszValue, pszValue);
    }
    /*
     * A value wrapped in a constant macro?
     */
    else if (   (pszNext = (char *)strchr(pszValue, '(')) != NULL
             && pszValue[cchValue - 1] == ')' )
    {
        size_t      cchPrefix = pszNext - pszValue;
        size_t      cchInnerValue  = cchValue - cchPrefix - 2;
        const char *pchInnerValue  = &pszValue[cchPrefix + 1];
        while (cchInnerValue > 0 && RT_C_IS_SPACE(*pchInnerValue))
            cchInnerValue--, pchInnerValue++;
        while (cchInnerValue > 0 && RT_C_IS_SPACE(pchInnerValue[cchInnerValue - 1]))
            cchInnerValue--;
        if (!cchInnerValue || !RT_C_IS_XDIGIT(*pchInnerValue))
            return RTEXITCODE_SUCCESS;

        rc = RTStrToUInt64Ex(pchInnerValue, &pszNext, 0, &u64);
        if (   RT_FAILURE(rc)
            || rc == VWRN_TRAILING_SPACES
            || rc == VWRN_NEGATIVE_UNSIGNED
            || rc == VWRN_NUMBER_TOO_BIG)
            return RTEXITCODE_SUCCESS;

        const char *pszType;
#define MY_MATCH_STR(a_sz)  (sizeof(a_sz) - 1 == cchPrefix && !strncmp(pszValue, a_sz, sizeof(a_sz) - 1))
        if (MY_MATCH_STR("UINT8_C"))
            pszType = "uint8_t";
        else if (MY_MATCH_STR("UINT16_C"))
            pszType = "uint16_t";
        else if (MY_MATCH_STR("UINT32_C"))
            pszType = "uint32_t";
        else if (MY_MATCH_STR("UINT64_C"))
            pszType = "uint64_t";
        else
            pszType = NULL;
        if (pszType)
            cch = ScmStreamPrintf(&pThis->StrmOutput, "inline %s %s = %.*s;\n",
                                  pszType, pszDefine, cchInnerValue, pchInnerValue);
        else if (MY_MATCH_STR("RT_BIT") || MY_MATCH_STR("RT_BIT_32"))
            cch = ScmStreamPrintf(&pThis->StrmOutput, "inline uint32_t %s = 1U << %llu;\n",
                                  pszDefine, u64);
        else if (MY_MATCH_STR("RT_BIT_64"))
            cch = ScmStreamPrintf(&pThis->StrmOutput, "inline uint64_t %s = 1ULL << %llu;\n",
                                  pszDefine, u64);
        else
            return RTEXITCODE_SUCCESS;
#undef MY_MATCH_STR
    }
    /* Dunno what this is... */
    else
        return RTEXITCODE_SUCCESS;

    /*
     * Check for output error and clear the output suppression indicator.
     */
    if (cch < 0)
        return vbcppError(pThis, "Output error");

    pThis->fJustDroppedLine = false;
    return RTEXITCODE_SUCCESS;
}



/**
 * Processes a abbreviated line number directive.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 * @param   offStart            The stream position where the directive
 *                              started (for pass thru).
 */
static RTEXITCODE vbcppDirectiveDefine(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
{
    RT_NOREF_PV(offStart);

    /*
     * Parse it.
     */
    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        size_t      cchDefine;
        const char *pchDefine = ScmStreamCGetWord(pStrmInput, &cchDefine);
        if (pchDefine)
        {
            /* If it's a function style define, parse out the parameter list. */
            size_t      cchParams = 0;
            const char *pchParams = NULL;
            unsigned    ch = ScmStreamPeekCh(pStrmInput);
            if (ch == '(')
            {
                ScmStreamGetCh(pStrmInput);
                pchParams = ScmStreamGetCur(pStrmInput);

                unsigned chPrev = ch;
                while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
                {
                    if (ch == '\r' || ch == '\n')
                    {
                        if (chPrev != '\\')
                        {
                            rcExit = vbcppError(pThis, "Missing ')'");
                            break;
                        }
                        ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
                    }
                    if (ch == ')')
                    {
                        cchParams = ScmStreamGetCur(pStrmInput) - pchParams;
                        ScmStreamGetCh(pStrmInput);
                        break;
                    }
                    ScmStreamGetCh(pStrmInput);
                }
            }
            /* The simple kind. */
            else if (!RT_C_IS_SPACE(ch) && ch != ~(unsigned)0)
                rcExit = vbcppError(pThis, "Expected whitespace after macro name");

            /* Parse out the value. */
            if (rcExit == RTEXITCODE_SUCCESS)
                rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
            if (rcExit == RTEXITCODE_SUCCESS)
            {
                size_t      offValue = ScmStreamTell(pStrmInput);
                const char *pchValue = ScmStreamGetCur(pStrmInput);
                unsigned    chPrev = ch;
                while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
                {
                    if (ch == '\r' || ch == '\n')
                    {
                        if (chPrev != '\\')
                            break;
                        ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
                    }
                    chPrev = ScmStreamGetCh(pStrmInput);
                }
                size_t cchValue = ScmStreamGetCur(pStrmInput) - pchValue;

                /*
                 * Execute.
                 */
                if (pchParams)
                    rcExit = vbcppMacroAddFn(pThis, pchDefine, cchDefine, pchParams, cchParams, pchValue, cchValue, false);
                else
                    rcExit = vbcppMacroAdd(pThis, pchDefine, cchDefine, pchValue, cchValue, false);

                /*
                 * Pass thru?
                 */
                if (   rcExit == RTEXITCODE_SUCCESS
                    && pThis->fPassThruDefines)
                {
                    unsigned cchIndent = pThis->pCondStack ? pThis->pCondStack->iKeepLevel : 0;
                    ssize_t  cch;
                    if (pchParams)
                        cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sdefine %.*s(%.*s)",
                                              cchIndent, "", cchDefine, pchDefine, cchParams, pchParams);
                    else
                        cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sdefine %.*s",
                                              cchIndent, "", cchDefine, pchDefine);
                    if (cch > 0)
                        vbcppOutputComment(pThis, pStrmInput, offValue, cch, 1);
                    else
                        rcExit = vbcppError(pThis, "output error");
                }
                else if (   rcExit == RTEXITCODE_SUCCESS
                         && pThis->enmMode == kVBCppMode_SelectiveD)
                    rcExit = vbcppMacroTryConvertToInlineD(pThis, vbcppMacroLookup(pThis, pchDefine, cchDefine));
                else
                    pThis->fJustDroppedLine = true;
            }
        }
    }
    return rcExit;
}


/**
 * Processes a abbreviated line number directive.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 * @param   offStart            The stream position where the directive
 *                              started (for pass thru).
 */
static RTEXITCODE vbcppDirectiveUndef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
{
    RT_NOREF_PV(offStart);

    /*
     * Parse it.
     */
    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        size_t      cchDefine;
        const char *pchDefine = ScmStreamCGetWord(pStrmInput, &cchDefine);
        if (pchDefine)
        {
            size_t offMaybeComment = vbcppProcessSkipWhite(pStrmInput);
            rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
            if (rcExit == RTEXITCODE_SUCCESS)
            {
                /*
                 * Take action.
                 */
                PVBCPPMACRO pMacro = vbcppMacroLookup(pThis, pchDefine, cchDefine);
                if (    pMacro
                    &&  pThis->fRespectSourceDefines
                    &&  (   !pMacro->fCmdLine
                         || pThis->fAllowRedefiningCmdLineDefines ) )
                {
                    RTStrSpaceRemove(&pThis->StrSpace, pMacro->Core.pszString);
                    vbcppMacroFree(&pMacro->Core, NULL);
                }

                /*
                 * Pass thru.
                 */
                if (   rcExit == RTEXITCODE_SUCCESS
                    && pThis->fPassThruDefines)
                {
                    unsigned cchIndent = pThis->pCondStack ? pThis->pCondStack->iKeepLevel : 0;
                    ssize_t  cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sundef %.*s",
                                                   cchIndent, "", cchDefine, pchDefine);
                    if (cch > 0)
                        vbcppOutputComment(pThis, pStrmInput, offMaybeComment, cch, 1);
                    else
                        rcExit = vbcppError(pThis, "output error");
                }

            }
        }
        else
            rcExit = vbcppError(pThis, "Malformed #ifndef");
    }
    return rcExit;

}





/*
 *
 *
 * C O N D I T I O N A L S
 * C O N D I T I O N A L S
 * C O N D I T I O N A L S
 * C O N D I T I O N A L S
 * C O N D I T I O N A L S
 *
 *
 */


/**
 * Combines current stack result with the one being pushed.
 *
 * @returns Combined result.
 * @param   enmEvalPush         The result of the condition being pushed.
 * @param   enmEvalStack        The current stack result.
 */
static VBCPPEVAL vbcppCondCombine(VBCPPEVAL enmEvalPush, VBCPPEVAL enmEvalStack)
{
    if (enmEvalStack == kVBCppEval_False)
        return kVBCppEval_False;
    return enmEvalPush;
}


/**
 * Pushes an conditional onto the stack.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The current input stream.
 * @param   offStart            Not currently used, using @a pchCondition and
 *                              @a cchCondition instead.
 * @param   enmKind             The kind of conditional.
 * @param   enmResult           The result of the evaluation.
 * @param   pchCondition        The raw condition.
 * @param   cchCondition        The length of @a pchCondition.
 */
static RTEXITCODE vbcppCondPush(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart,
                                VBCPPCONDKIND enmKind, VBCPPEVAL enmResult,
                                const char *pchCondition, size_t cchCondition)
{
    RT_NOREF_PV(offStart); RT_NOREF_PV(pStrmInput);


    if (pThis->cCondStackDepth >= _64K)
        return vbcppError(pThis, "Too many nested #if/#ifdef/#ifndef statements");

    /*
     * Allocate a new entry and push it.
     */
    PVBCPPCOND pCond = (PVBCPPCOND)RTMemAlloc(sizeof(*pCond));
    if (!pCond)
        return vbcppError(pThis, "out of memory");

    PVBCPPCOND pUp = pThis->pCondStack;
    pCond->enmKind          = enmKind;
    pCond->enmResult        = enmResult;
    pCond->enmStackResult   = pUp ? vbcppCondCombine(enmResult, pUp->enmStackResult) : enmResult;
    pCond->fSeenElse        = false;
    pCond->fElIfDecided     = enmResult == kVBCppEval_True;
    pCond->iLevel           = pThis->cCondStackDepth;
    pCond->iKeepLevel       = (pUp ? pUp->iKeepLevel : 0) + enmResult == kVBCppEval_Undecided;
    pCond->pchCond          = pchCondition;
    pCond->cchCond          = cchCondition;

    pCond->pUp              = pThis->pCondStack;
    pThis->pCondStack       = pCond;
    pThis->fIf0Mode         = pCond->enmStackResult == kVBCppEval_False;

    /*
     * Do pass thru.
     */
    if (   !pThis->fIf0Mode
        && enmResult == kVBCppEval_Undecided)
    {
        /** @todo this is stripping comments of \#ifdef and \#ifndef atm. */
        const char *pszDirective;
        switch (enmKind)
        {
            case kVBCppCondKind_If:     pszDirective = "if"; break;
            case kVBCppCondKind_IfDef:  pszDirective = "ifdef"; break;
            case kVBCppCondKind_IfNDef: pszDirective = "ifndef"; break;
            case kVBCppCondKind_ElIf:   pszDirective = "elif"; break;
            default: AssertFailedReturn(RTEXITCODE_FAILURE);
        }
        ssize_t cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*s%s %.*s",
                                      pCond->iKeepLevel - 1, "", pszDirective, cchCondition, pchCondition);
        if (cch < 0)
            return vbcppError(pThis, "Output error %Rrc", (int)cch);
    }
    else
        pThis->fJustDroppedLine = true;

    return RTEXITCODE_SUCCESS;
}


/**
 * Recursively destroys the expression tree.
 *
 * @param   pExpr               The root of the expression tree to destroy.
 */
static void vbcppExprDestoryTree(PVBCPPEXPR pExpr)
{
    if (!pExpr)
        return;

    switch (pExpr->enmKind)
    {
        case kVBCppExprKind_Unary:
            vbcppExprDestoryTree(pExpr->u.Unary.pArg);
            break;
        case kVBCppExprKind_Binary:
            vbcppExprDestoryTree(pExpr->u.Binary.pLeft);
            vbcppExprDestoryTree(pExpr->u.Binary.pRight);
            break;
        case kVBCppExprKind_Ternary:
            vbcppExprDestoryTree(pExpr->u.Ternary.pExpr);
            vbcppExprDestoryTree(pExpr->u.Ternary.pExpr);
            vbcppExprDestoryTree(pExpr->u.Ternary.pFalse);
            break;
        case kVBCppExprKind_SignedValue:
        case kVBCppExprKind_UnsignedValue:
            break;
        default:
            AssertFailed();
            return;
    }
    RTMemFree(pExpr);
}


/**
 * Report error during expression parsing.
 *
 * @returns kExprRet_Error
 * @param   pParser             The parser instance.
 * @param   pszMsg              The error message.
 * @param   ...                 Format arguments.
 */
static VBCPPEXPRRET vbcppExprParseError(PVBCPPEXPRPARSER pParser, const char *pszMsg, ...)
{
    va_list va;
    va_start(va, pszMsg);
    vbcppErrorV(pParser->pThis, pszMsg, va);
    va_end(va);
    return kExprRet_Error;
}


/**
 * Skip white space.
 *
 * @param   pParser             The parser instance.
 */
static void vbcppExprParseSkipWhiteSpace(PVBCPPEXPRPARSER pParser)
{
    while (RT_C_IS_SPACE(*pParser->pszCur))
        pParser->pszCur++;
}


/**
 * Allocate a new
 *
 * @returns Pointer to the node. NULL+msg on failure.
 * @param   pParser             The parser instance.
 */
static PVBCPPEXPR vbcppExprParseAllocNode(PVBCPPEXPRPARSER pParser)
{
    PVBCPPEXPR pExpr = (PVBCPPEXPR)RTMemAllocZ(sizeof(*pExpr));
    if (!pExpr)
        vbcppExprParseError(pParser, "out of memory (expression node)");
    return pExpr;
}


/**
 * Looks for right parentheses and/or end of expression.
 *
 * @returns Expression status.
 * @retval  kExprRet_Ok
 * @retval  kExprRet_Error with msg.
 * @retval  kExprRet_EndOfExpr
 * @param   pParser             The parser instance.
 */
static VBCPPEXPRRET vbcppExprParseMaybeRParenOrEoe(PVBCPPEXPRPARSER pParser)
{
    Assert(!pParser->ppCur);
    for (;;)
    {
        vbcppExprParseSkipWhiteSpace(pParser);
        char ch = *pParser->pszCur;
        if (ch == '\0')
            return kExprRet_EndOfExpr;
        if (ch != ')')
            break;
        pParser->pszCur++;

        PVBCPPEXPR pCur = pParser->pCur;
        while (   pCur
               && (   pCur->enmKind != kVBCppExprKind_Unary
                   || pCur->u.Unary.enmOperator != kVBCppUnaryOp_Parenthesis))
        {
            switch (pCur->enmKind)
            {
                case kVBCppExprKind_SignedValue:
                case kVBCppExprKind_UnsignedValue:
                    Assert(pCur->fComplete);
                    break;
                case kVBCppExprKind_Unary:
                    AssertReturn(pCur->u.Unary.pArg, vbcppExprParseError(pParser, "internal error"));
                    pCur->fComplete = true;
                    break;
                case kVBCppExprKind_Binary:
                    AssertReturn(pCur->u.Binary.pLeft, vbcppExprParseError(pParser, "internal error"));
                    AssertReturn(pCur->u.Binary.pRight, vbcppExprParseError(pParser, "internal error"));
                    pCur->fComplete = true;
                    break;
                case kVBCppExprKind_Ternary:
#if 1 /** @todo Check out the ternary operator implementation. */
                    return vbcppExprParseError(pParser, "The ternary operator is not implemented");
#else
                    Assert(pCur->u.Ternary.pExpr);
                    if (!pCur->u.Ternary.pTrue)
                        return vbcppExprParseError(pParser, "?!?!?");
                    if (!pCur->u.Ternary.pFalse)
                        return vbcppExprParseError(pParser, "?!?!?!?");
                    pCur->fComplete = true;
#endif
                    break;
                default:
                    return vbcppExprParseError(pParser, "Internal error (enmKind=%d)", pCur->enmKind);
            }
            pCur = pCur->pParent;
        }
        if (!pCur)
            return vbcppExprParseError(pParser, "Right parenthesis without a left one");
        pCur->fComplete = true;

        while (   pCur->enmKind == kVBCppExprKind_Unary
               && pCur->u.Unary.enmOperator != kVBCppUnaryOp_Parenthesis
               && pCur->pParent)
        {
            AssertReturn(pCur->u.Unary.pArg, vbcppExprParseError(pParser, "internal error"));
            pCur->fComplete = true;
            pCur = pCur->pParent;
        }
    }

    return kExprRet_Ok;
}


/**
 * Parses an binary operator.
 *
 * @returns Expression status.
 * @retval  kExprRet_Ok
 * @retval  kExprRet_Error with msg.
 * @param   pParser             The parser instance.
 */
static VBCPPEXPRRET vbcppExprParseBinaryOperator(PVBCPPEXPRPARSER pParser)
{
    /*
     * Binary or ternary operator should follow now.
     */
    VBCPPBINARYOP enmOp;
    char ch = *pParser->pszCur;
    switch (ch)
    {
        case '*':
            if (pParser->pszCur[1] == '=')
                return vbcppExprParseError(pParser, "The assignment by product operator is not valid in a preprocessor expression");
            enmOp = kVBCppBinary_Multiplication;
            break;
        case '/':
            if (pParser->pszCur[1] == '=')
                return vbcppExprParseError(pParser, "The assignment by quotient operator is not valid in a preprocessor expression");
            enmOp = kVBCppBinary_Division;
            break;
        case '%':
            if (pParser->pszCur[1] == '=')
                return vbcppExprParseError(pParser, "The assignment by remainder operator is not valid in a preprocessor expression");
            enmOp = kVBCppBinary_Modulo;
            break;
        case '+':
            if (pParser->pszCur[1] == '=')
                return vbcppExprParseError(pParser, "The assignment by sum operator is not valid in a preprocessor expression");
            enmOp = kVBCppBinary_Addition;
            break;
        case '-':
            if (pParser->pszCur[1] == '=')
                return vbcppExprParseError(pParser, "The assignment by difference operator is not valid in a preprocessor expression");
            enmOp = kVBCppBinary_Subtraction;
            break;
        case '<':
            enmOp = kVBCppBinary_LessThan;
            if (pParser->pszCur[1] == '=')
            {
                pParser->pszCur++;
                enmOp = kVBCppBinary_LessThanOrEqual;
            }
            else if (pParser->pszCur[1] == '<')
            {
                pParser->pszCur++;
                if (pParser->pszCur[1] == '=')
                    return vbcppExprParseError(pParser, "The assignment by bitwise left shift operator is not valid in a preprocessor expression");
                enmOp = kVBCppBinary_LeftShift;
            }
            break;
        case '>':
            enmOp = kVBCppBinary_GreaterThan;
            if (pParser->pszCur[1] == '=')
            {
                pParser->pszCur++;
                enmOp = kVBCppBinary_GreaterThanOrEqual;
            }
            else if (pParser->pszCur[1] == '<')
            {
                pParser->pszCur++;
                if (pParser->pszCur[1] == '=')
                    return vbcppExprParseError(pParser, "The assignment by bitwise right shift operator is not valid in a preprocessor expression");
                enmOp = kVBCppBinary_LeftShift;
            }
            break;
        case '=':
            if (pParser->pszCur[1] != '=')
                return vbcppExprParseError(pParser, "The assignment operator is not valid in a preprocessor expression");
            pParser->pszCur++;
            enmOp = kVBCppBinary_EqualTo;
            break;

        case '!':
            if (pParser->pszCur[1] != '=')
                return vbcppExprParseError(pParser, "Expected binary operator, found the unary operator logical NOT");
            pParser->pszCur++;
            enmOp = kVBCppBinary_NotEqualTo;
            break;

        case '&':
            if (pParser->pszCur[1] == '=')
                return vbcppExprParseError(pParser, "The assignment by bitwise AND operator is not valid in a preprocessor expression");
            if (pParser->pszCur[1] == '&')
            {
                pParser->pszCur++;
                enmOp = kVBCppBinary_LogicalAnd;
            }
            else
                enmOp = kVBCppBinary_BitwiseAnd;
            break;
        case '^':
            if (pParser->pszCur[1] == '=')
                return vbcppExprParseError(pParser, "The assignment by bitwise XOR operator is not valid in a preprocessor expression");
            enmOp = kVBCppBinary_BitwiseXor;
            break;
        case '|':
            if (pParser->pszCur[1] == '=')
                return vbcppExprParseError(pParser, "The assignment by bitwise AND operator is not valid in a preprocessor expression");
            if (pParser->pszCur[1] == '|')
            {
                pParser->pszCur++;
                enmOp = kVBCppBinary_LogicalOr;
            }
            else
                enmOp = kVBCppBinary_BitwiseOr;
            break;
        case '~':
            return vbcppExprParseError(pParser, "Expected binary operator, found the unary operator bitwise NOT");

        case ':':
        case '?':
            return vbcppExprParseError(pParser, "The ternary operator is not yet implemented");

        default:
            return vbcppExprParseError(pParser, "Expected binary operator, found '%.20s'", pParser->pszCur);
    }
    pParser->pszCur++;

    /*
     * Create a binary operator node.
     */
    PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
    if (!pExpr)
        return kExprRet_Error;
    pExpr->fComplete            = true;
    pExpr->enmKind              = kVBCppExprKind_Binary;
    pExpr->u.Binary.enmOperator = enmOp;
    pExpr->u.Binary.pLeft       = NULL;
    pExpr->u.Binary.pRight      = NULL;

    /*
     * Back up the tree until we find our spot.
     */
    PVBCPPEXPR *ppPlace = NULL;
    PVBCPPEXPR  pChild  = NULL;
    PVBCPPEXPR  pParent = pParser->pCur;
    while (pParent)
    {
        if (pParent->enmKind == kVBCppExprKind_Unary)
        {
            if (pParent->u.Unary.enmOperator == kVBCppUnaryOp_Parenthesis)
            {
                ppPlace = &pParent->u.Unary.pArg;
                break;
            }
            AssertReturn(pParent->u.Unary.pArg, vbcppExprParseError(pParser, "internal error"));
            pParent->fComplete = true;
        }
        else if (pParent->enmKind == kVBCppExprKind_Binary)
        {
            AssertReturn(pParent->u.Binary.pLeft, vbcppExprParseError(pParser, "internal error"));
            AssertReturn(pParent->u.Binary.pRight, vbcppExprParseError(pParser, "internal error"));
            if ((pParent->u.Binary.enmOperator & VBCPPOP_PRECEDENCE_MASK) >= (enmOp & VBCPPOP_PRECEDENCE_MASK))
            {
                AssertReturn(pChild, vbcppExprParseError(pParser, "internal error"));

                if (pParent->u.Binary.pRight == pChild)
                    ppPlace = &pParent->u.Binary.pRight;
                else
                    ppPlace = &pParent->u.Binary.pLeft;
                AssertReturn(*ppPlace == pChild, vbcppExprParseError(pParser, "internal error"));
                break;
            }
            pParent->fComplete = true;
        }
        else if (pParent->enmKind == kVBCppExprKind_Ternary)
        {
            return vbcppExprParseError(pParser, "The ternary operator is not implemented");
        }
        else
            AssertReturn(   pParent->enmKind == kVBCppExprKind_SignedValue
                         || pParent->enmKind == kVBCppExprKind_UnsignedValue,
                         vbcppExprParseError(pParser, "internal error"));

        /* Up on level */
        pChild  = pParent;
        pParent = pParent->pParent;
    }

    /*
     * Do the rotation.
     */
    Assert(pChild);
    Assert(pChild->pParent == pParent);
    pChild->pParent       = pExpr;

    pExpr->u.Binary.pLeft = pChild;
    pExpr->pParent        = pParent;

    if (!pParent)
        pParser->pRoot    = pExpr;
    else
        *ppPlace          = pExpr;

    pParser->ppCur = &pExpr->u.Binary.pRight;
    pParser->pCur  = pExpr;

    return kExprRet_Ok;
}


/**
 * Deals with right paretheses or/and end of expression, looks for binary
 * operators.
 *
 * @returns Expression status.
 * @retval  kExprRet_Ok if binary operator was found processed.
 * @retval  kExprRet_Error with msg.
 * @retval  kExprRet_EndOfExpr
 * @param   pParser             The parser instance.
 */
static VBCPPEXPRRET vbcppExprParseBinaryOrEoeOrRparen(PVBCPPEXPRPARSER pParser)
{
    VBCPPEXPRRET enmRet = vbcppExprParseMaybeRParenOrEoe(pParser);
    if (enmRet != kExprRet_Ok)
        return enmRet;
    return vbcppExprParseBinaryOperator(pParser);
}


/**
 * Parses an identifier in the expression, replacing it by 0.
 *
 * All known identifiers has already been replaced by their macro values, so
 * what's left are unknown macros.  These are replaced by 0.
 *
 * @returns Expression status.
 * @retval  kExprRet_Value
 * @retval  kExprRet_Error with msg.
 * @param   pParser             The parser instance.
 */
static VBCPPEXPRRET vbcppExprParseIdentifier(PVBCPPEXPRPARSER pParser)
{
/** @todo don't increment if it's an actively undefined macro. Need to revise
 *        the expression related code wrt selective preprocessing. */
    pParser->cUndefined++;

    /* Find the end. */
    const char *pszMacro = pParser->pszCur;
    const char *pszNext  = pszMacro + 1;
    while (vbcppIsCIdentifierChar(*pszNext))
        pszNext++;
    size_t cchMacro = pszNext - pszMacro;

    /* Create a signed value node. */
    PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
    if (!pExpr)
        return kExprRet_Error;
    pExpr->fComplete            = true;
    pExpr->enmKind              = kVBCppExprKind_UnsignedValue;
    pExpr->u.UnsignedValue.u64  = 0;

    /* Link it. */
    pExpr->pParent              = pParser->pCur;
    pParser->pCur               = pExpr;
    *pParser->ppCur             = pExpr;
    pParser->ppCur              = NULL;

    /* Skip spaces and check for parenthesis. */
    pParser->pszCur = pszNext;
    vbcppExprParseSkipWhiteSpace(pParser);
    if (*pParser->pszCur == '(')
        return vbcppExprParseError(pParser, "Unknown unary operator '%.*s'", cchMacro, pszMacro);

    return kExprRet_Value;
}


/**
 * Parses an numeric constant in the expression.
 *
 * @returns Expression status.
 * @retval  kExprRet_Value
 * @retval  kExprRet_Error with msg.
 * @param   pParser             The parser instance.
 */
static VBCPPEXPRRET vbcppExprParseNumber(PVBCPPEXPRPARSER pParser)
{
    bool        fSigned;
    char       *pszNext;
    uint64_t    u64;
    char        ch    = *pParser->pszCur++;
    char        ch2   = *pParser->pszCur;
    if (   ch == '0'
        && (ch == 'x' || ch == 'X'))
    {
        ch2 = *++pParser->pszCur;
        if (!RT_C_IS_XDIGIT(ch2))
            return vbcppExprParseError(pParser, "Expected hex digit following '0x'");
        int rc = RTStrToUInt64Ex(pParser->pszCur, &pszNext, 16, &u64);
        if (   RT_FAILURE(rc)
            || rc == VWRN_NUMBER_TOO_BIG)
            return vbcppExprParseError(pParser, "Invalid hex value '%.20s...' (%Rrc)", pParser->pszCur, rc);
        fSigned = false;
    }
    else if (ch == '0')
    {
        int rc = RTStrToUInt64Ex(pParser->pszCur - 1, &pszNext, 8, &u64);
        if (   RT_FAILURE(rc)
            || rc == VWRN_NUMBER_TOO_BIG)
            return vbcppExprParseError(pParser, "Invalid octal value '%.20s...' (%Rrc)", pParser->pszCur, rc);
        fSigned = u64 > (uint64_t)INT64_MAX ? false : true;
    }
    else
    {
        int rc = RTStrToUInt64Ex(pParser->pszCur - 1, &pszNext, 10, &u64);
        if (   RT_FAILURE(rc)
            || rc == VWRN_NUMBER_TOO_BIG)
            return vbcppExprParseError(pParser, "Invalid decimal value '%.20s...' (%Rrc)", pParser->pszCur, rc);
        fSigned = u64 > (uint64_t)INT64_MAX ? false : true;
    }

    /* suffix. */
    if (vbcppIsCIdentifierLeadChar(*pszNext))
    {
        size_t cchSuffix = 1;
        while (vbcppIsCIdentifierLeadChar(pszNext[cchSuffix]))
            cchSuffix++;

        if (cchSuffix == '1' && (*pszNext == 'u' || *pszNext == 'U'))
            fSigned = false;
        else if (   cchSuffix == '1'
                 && (*pszNext == 'l' || *pszNext == 'L'))
            fSigned = true;
        else if (   cchSuffix == '2'
                 && (!strncmp(pszNext, "ul", 2) || !strncmp(pszNext, "UL", 2)))
            fSigned = false;
        else if (   cchSuffix == '2'
                 && (!strncmp(pszNext, "ll", 2) || !strncmp(pszNext, "LL", 2)))
            fSigned = true;
        else if (   cchSuffix == '3'
                 && (!strncmp(pszNext, "ull", 3) || !strncmp(pszNext, "ULL", 3)))
            fSigned = false;
        else
            return vbcppExprParseError(pParser, "Invalid number suffix '%.*s'", cchSuffix, pszNext);

        pszNext += cchSuffix;
    }
    pParser->pszCur = pszNext;

    /* Create a signed value node. */
    PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
    if (!pExpr)
        return kExprRet_Error;
    pExpr->fComplete            = true;
    if (fSigned)
    {
        pExpr->enmKind              = kVBCppExprKind_SignedValue;
        pExpr->u.SignedValue.s64    = (int64_t)u64;
    }
    else
    {
        pExpr->enmKind              = kVBCppExprKind_UnsignedValue;
        pExpr->u.UnsignedValue.u64  = u64;
    }

    /* Link it. */
    pExpr->pParent              = pParser->pCur;
    pParser->pCur               = pExpr;
    *pParser->ppCur             = pExpr;
    pParser->ppCur              = NULL;

    return kExprRet_Value;
}


/**
 * Parses an character constant in the expression.
 *
 * @returns Expression status.
 * @retval  kExprRet_Value
 * @retval  kExprRet_Error with msg.
 * @param   pParser             The parser instance.
 */
static VBCPPEXPRRET vbcppExprParseCharacterConstant(PVBCPPEXPRPARSER pParser)
{
    Assert(*pParser->pszCur == '\'');
    pParser->pszCur++;
    char ch2 = *pParser->pszCur++;
    if (ch2 == '\'')
        return vbcppExprParseError(pParser, "Empty character constant");
    int64_t s64;
    if (ch2 == '\\')
    {
        ch2 = *pParser->pszCur++;
        switch (ch2)
        {
            case '0': s64 = 0x00; break;
            case 'n': s64 = 0x0d; break;
            case 'r': s64 = 0x0a; break;
            case 't': s64 = 0x09; break;
            default:
                return vbcppExprParseError(pParser, "Escape character '%c' is not implemented", ch2);
        }
    }
    else
        s64 = ch2;
    if (*pParser->pszCur != '\'')
        return vbcppExprParseError(pParser, "Character constant contains more than one character");

    /* Create a signed value node. */
    PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
    if (!pExpr)
        return kExprRet_Error;
    pExpr->fComplete            = true;
    pExpr->enmKind              = kVBCppExprKind_SignedValue;
    pExpr->u.SignedValue.s64    = s64;

    /* Link it. */
    pExpr->pParent              = pParser->pCur;
    pParser->pCur               = pExpr;
    *pParser->ppCur             = pExpr;
    pParser->ppCur              = NULL;

    return kExprRet_Value;
}


/**
 * Parses a unary operator or a value.
 *
 * @returns Expression status.
 * @retval  kExprRet_Value if value was found and processed.
 * @retval  kExprRet_UnaryOperator if an unary operator was found and processed.
 * @retval  kExprRet_Error with msg.
 * @param   pParser             The parser instance.
 */
static VBCPPEXPRRET vbcppExprParseUnaryOrValue(PVBCPPEXPRPARSER pParser)
{
    vbcppExprParseSkipWhiteSpace(pParser);
    char ch = *pParser->pszCur;
    if (ch == '\0')
        return vbcppExprParseError(pParser, "Premature end of expression");

    /*
     * Value?
     */
    if (ch == '\'')
        return vbcppExprParseCharacterConstant(pParser);
    if (RT_C_IS_DIGIT(ch))
        return vbcppExprParseNumber(pParser);
    if (ch == '"')
        return vbcppExprParseError(pParser, "String litteral");
    if (vbcppIsCIdentifierLeadChar(ch))
        return vbcppExprParseIdentifier(pParser);

    /*
     * Operator?
     */
    VBCPPUNARYOP enmOperator;
    if (ch == '+')
    {
        enmOperator = kVBCppUnaryOp_Pluss;
        if (pParser->pszCur[1] == '+')
            return vbcppExprParseError(pParser, "The prefix increment operator is not valid in a preprocessor expression");
    }
    else if (ch == '-')
    {
        enmOperator = kVBCppUnaryOp_Minus;
        if (pParser->pszCur[1] == '-')
            return vbcppExprParseError(pParser, "The prefix decrement operator is not valid in a preprocessor expression");
    }
    else if (ch == '!')
        enmOperator = kVBCppUnaryOp_LogicalNot;
    else if (ch == '~')
        enmOperator = kVBCppUnaryOp_BitwiseNot;
    else if (ch == '(')
        enmOperator = kVBCppUnaryOp_Parenthesis;
    else
        return vbcppExprParseError(pParser, "Unknown token '%.*s'", 32, pParser->pszCur - 1);
    pParser->pszCur++;

    /* Create an operator node. */
    PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
    if (!pExpr)
        return kExprRet_Error;
    pExpr->fComplete            = false;
    pExpr->enmKind              = kVBCppExprKind_Unary;
    pExpr->u.Unary.enmOperator  = enmOperator;
    pExpr->u.Unary.pArg         = NULL;

    /* Link it into the tree. */
    pExpr->pParent              = pParser->pCur;
    pParser->pCur               = pExpr;
    *pParser->ppCur             = pExpr;
    pParser->ppCur              = &pExpr->u.Unary.pArg;

    return kExprRet_UnaryOperator;
}


/**
 * Parses an expanded preprocessor expression.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pszExpr             The expression to parse.
 * @param   cchExpr             The length of the expression in case we need it.
 * @param   ppExprTree          Where to return the parse tree.
 * @param   pcUndefined         Where to return the number of unknown undefined
 *                              macros.  Optional.
 */
static RTEXITCODE vbcppExprParse(PVBCPP pThis, char *pszExpr, size_t cchExpr, PVBCPPEXPR *ppExprTree, size_t *pcUndefined)
{
    RTEXITCODE rcExit = RTEXITCODE_FAILURE;
    NOREF(cchExpr);

    /*
     * Initialize the parser context structure.
     */
    VBCPPEXPRPARSER Parser;
    Parser.pszCur       = pszExpr;
    Parser.pRoot        = NULL;
    Parser.pCur         = NULL;
    Parser.ppCur        = &Parser.pRoot;
    Parser.pszExpr      = pszExpr;
    Parser.cUndefined   = 0;
    Parser.pThis        = pThis;

    /*
     * Do the parsing.
     */
    VBCPPEXPRRET enmRet;
    for (;;)
    {
        /*
         * Eat unary operators until we hit a value.
         */
        do
            enmRet = vbcppExprParseUnaryOrValue(&Parser);
        while (enmRet == kExprRet_UnaryOperator);
        if (enmRet == kExprRet_Error)
            break;
        AssertBreakStmt(enmRet == kExprRet_Value, enmRet = vbcppExprParseError(&Parser, "Expected value (enmRet=%d)", enmRet));

        /*
         * Non-unary operator, right parenthesis or end of expression is up next.
         */
        enmRet = vbcppExprParseBinaryOrEoeOrRparen(&Parser);
        if (enmRet == kExprRet_Error)
            break;
        if (enmRet == kExprRet_EndOfExpr)
        {
            /** @todo check if there are any open parentheses. */
            rcExit = RTEXITCODE_SUCCESS;
            break;
        }
        AssertBreakStmt(enmRet == kExprRet_Ok, enmRet = vbcppExprParseError(&Parser, "Expected value (enmRet=%d)", enmRet));
    }

    if (rcExit != RTEXITCODE_SUCCESS)
    {
        vbcppExprDestoryTree(Parser.pRoot);
        return rcExit;
    }

    if (pcUndefined)
        *pcUndefined = Parser.cUndefined;
    *ppExprTree = Parser.pRoot;
    return rcExit;
}


/**
 * Checks if an expression value value is evaluates to @c true or @c false.
 *
 * @returns @c true or @c false.
 * @param   pExpr               The value expression.
 */
static bool vbcppExprIsExprTrue(PVBCPPEXPR pExpr)
{
    Assert(pExpr->enmKind == kVBCppExprKind_SignedValue || pExpr->enmKind == kVBCppExprKind_UnsignedValue);

    return pExpr->enmKind == kVBCppExprKind_SignedValue
         ? pExpr->u.SignedValue.s64   != 0
         : pExpr->u.UnsignedValue.u64 != 0;
}


/**
 * Evalutes a parse (sub-)tree.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pRoot               The root of the parse (sub-)tree.
 * @param   pResult             Where to store the result value.
 */
static RTEXITCODE vbcppExprEvaluteTree(PVBCPP pThis, PVBCPPEXPR pRoot, PVBCPPEXPR pResult)
{
    RTEXITCODE rcExit;
    switch (pRoot->enmKind)
    {
        case kVBCppExprKind_SignedValue:
            pResult->enmKind                = kVBCppExprKind_SignedValue;
            pResult->u.SignedValue.s64      = pRoot->u.SignedValue.s64;
            return RTEXITCODE_SUCCESS;

        case kVBCppExprKind_UnsignedValue:
            pResult->enmKind                = kVBCppExprKind_UnsignedValue;
            pResult->u.UnsignedValue.u64    = pRoot->u.UnsignedValue.u64;
            return RTEXITCODE_SUCCESS;

        case kVBCppExprKind_Unary:
            rcExit = vbcppExprEvaluteTree(pThis, pRoot->u.Unary.pArg, pResult);
            if (rcExit != RTEXITCODE_SUCCESS)
                return rcExit;

            /* Apply the unary operator to the value */
            switch (pRoot->u.Unary.enmOperator)
            {
                case kVBCppUnaryOp_Minus:
                    if (pResult->enmKind == kVBCppExprKind_SignedValue)
                        pResult->u.SignedValue.s64   = -pResult->u.SignedValue.s64;
                    else
                        pResult->u.UnsignedValue.u64 = (uint64_t)-(int64_t)pResult->u.UnsignedValue.u64;
                    break;

                case kVBCppUnaryOp_LogicalNot:
                    if (pResult->enmKind == kVBCppExprKind_SignedValue)
                        pResult->u.SignedValue.s64   = !pResult->u.SignedValue.s64;
                    else
                        pResult->u.UnsignedValue.u64 = !pResult->u.UnsignedValue.u64;
                    break;

                case kVBCppUnaryOp_BitwiseNot:
                    if (pResult->enmKind == kVBCppExprKind_SignedValue)
                        pResult->u.SignedValue.s64   = ~pResult->u.SignedValue.s64;
                    else
                        pResult->u.UnsignedValue.u64 = ~pResult->u.UnsignedValue.u64;
                    break;

                case kVBCppUnaryOp_Pluss:
                case kVBCppUnaryOp_Parenthesis:
                    /* do nothing. */
                    break;

                default:
                    return vbcppError(pThis, "Internal error: u.Unary.enmOperator=%d", pRoot->u.Unary.enmOperator);
            }
            return RTEXITCODE_SUCCESS;

        case kVBCppExprKind_Binary:
        {
            /* Always evalute the left side. */
            rcExit = vbcppExprEvaluteTree(pThis, pRoot->u.Binary.pLeft, pResult);
            if (rcExit != RTEXITCODE_SUCCESS)
                return rcExit;

            /* If logical AND or OR we can sometimes skip evaluting the right side. */
            if (   pRoot->u.Binary.enmOperator == kVBCppBinary_LogicalAnd
                && !vbcppExprIsExprTrue(pResult))
                return RTEXITCODE_SUCCESS;

            if (   pRoot->u.Binary.enmOperator == kVBCppBinary_LogicalOr
                && vbcppExprIsExprTrue(pResult))
                return RTEXITCODE_SUCCESS;

            /* Evalute the right side. */
            VBCPPEXPR Result2;
            rcExit = vbcppExprEvaluteTree(pThis, pRoot->u.Binary.pRight, &Result2);
            if (rcExit != RTEXITCODE_SUCCESS)
                return rcExit;

            /* If one of them is unsigned, promote the other to unsigned as well. */
            if (   pResult->enmKind == kVBCppExprKind_UnsignedValue
                && Result2.enmKind  == kVBCppExprKind_SignedValue)
            {
                Result2.enmKind              = kVBCppExprKind_UnsignedValue;
                Result2.u.UnsignedValue.u64  = Result2.u.SignedValue.s64;
            }
            else if (   pResult->enmKind == kVBCppExprKind_SignedValue
                     && Result2.enmKind  == kVBCppExprKind_UnsignedValue)
            {
                pResult->enmKind             = kVBCppExprKind_UnsignedValue;
                pResult->u.UnsignedValue.u64 = pResult->u.SignedValue.s64;
            }

            /* Perform the operation. */
            if (pResult->enmKind == kVBCppExprKind_UnsignedValue)
            {
                switch (pRoot->u.Binary.enmOperator)
                {
                    case kVBCppBinary_Multiplication:
                        pResult->u.UnsignedValue.u64 *= Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_Division:
                        if (!Result2.u.UnsignedValue.u64)
                            return vbcppError(pThis, "Divide by zero");
                        pResult->u.UnsignedValue.u64 /= Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_Modulo:
                        if (!Result2.u.UnsignedValue.u64)
                            return vbcppError(pThis, "Divide by zero");
                        pResult->u.UnsignedValue.u64 %= Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_Addition:
                        pResult->u.UnsignedValue.u64 += Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_Subtraction:
                        pResult->u.UnsignedValue.u64 -= Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_LeftShift:
                        pResult->u.UnsignedValue.u64 <<= Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_RightShift:
                        pResult->u.UnsignedValue.u64 >>= Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_LessThan:
                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 < Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_LessThanOrEqual:
                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 <= Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_GreaterThan:
                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 > Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_GreaterThanOrEqual:
                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 >= Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_EqualTo:
                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 == Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_NotEqualTo:
                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 != Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_BitwiseAnd:
                        pResult->u.UnsignedValue.u64 &= Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_BitwiseXor:
                        pResult->u.UnsignedValue.u64 ^= Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_BitwiseOr:
                        pResult->u.UnsignedValue.u64 |= Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_LogicalAnd:
                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 && Result2.u.UnsignedValue.u64;
                        break;
                    case kVBCppBinary_LogicalOr:
                        pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 || Result2.u.UnsignedValue.u64;
                        break;
                    default:
                        return vbcppError(pThis, "Internal error: u.Binary.enmOperator=%d", pRoot->u.Binary.enmOperator);
                }
            }
            else
            {
                switch (pRoot->u.Binary.enmOperator)
                {
                    case kVBCppBinary_Multiplication:
                        pResult->u.SignedValue.s64 *= Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_Division:
                        if (!Result2.u.SignedValue.s64)
                            return vbcppError(pThis, "Divide by zero");
                        pResult->u.SignedValue.s64 /= Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_Modulo:
                        if (!Result2.u.SignedValue.s64)
                            return vbcppError(pThis, "Divide by zero");
                        pResult->u.SignedValue.s64 %= Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_Addition:
                        pResult->u.SignedValue.s64 += Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_Subtraction:
                        pResult->u.SignedValue.s64 -= Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_LeftShift:
                        pResult->u.SignedValue.s64 <<= Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_RightShift:
                        pResult->u.SignedValue.s64 >>= Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_LessThan:
                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 < Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_LessThanOrEqual:
                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 <= Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_GreaterThan:
                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 > Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_GreaterThanOrEqual:
                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 >= Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_EqualTo:
                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 == Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_NotEqualTo:
                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 != Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_BitwiseAnd:
                        pResult->u.SignedValue.s64 &= Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_BitwiseXor:
                        pResult->u.SignedValue.s64 ^= Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_BitwiseOr:
                        pResult->u.SignedValue.s64 |= Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_LogicalAnd:
                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 && Result2.u.SignedValue.s64;
                        break;
                    case kVBCppBinary_LogicalOr:
                        pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 || Result2.u.SignedValue.s64;
                        break;
                    default:
                        return vbcppError(pThis, "Internal error: u.Binary.enmOperator=%d", pRoot->u.Binary.enmOperator);
                }
            }
            return rcExit;
        }

        case kVBCppExprKind_Ternary:
            rcExit = vbcppExprEvaluteTree(pThis, pRoot->u.Ternary.pExpr, pResult);
            if (rcExit != RTEXITCODE_SUCCESS)
                return rcExit;
            if (vbcppExprIsExprTrue(pResult))
                return vbcppExprEvaluteTree(pThis, pRoot->u.Ternary.pTrue, pResult);
            return vbcppExprEvaluteTree(pThis, pRoot->u.Ternary.pFalse, pResult);

        default:
            return vbcppError(pThis, "Internal error: enmKind=%d", pRoot->enmKind);
    }
}


/**
 * Evalutes the expression.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pszExpr             The expression.
 * @param   cchExpr             The length of the expression.
 * @param   penmResult          Where to store the result.
 */
static RTEXITCODE vbcppExprEval(PVBCPP pThis, char *pszExpr, size_t cchExpr, size_t cReplacements, VBCPPEVAL *penmResult)
{
    Assert(strlen(pszExpr) == cchExpr);
    RT_NOREF_PV(cReplacements);

    size_t      cUndefined;
    PVBCPPEXPR  pExprTree;
    RTEXITCODE  rcExit = vbcppExprParse(pThis, pszExpr, cchExpr, &pExprTree, &cUndefined);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        if (   !cUndefined
            || pThis->enmMode == kVBCppMode_SelectiveD
            || pThis->enmMode == kVBCppMode_Standard)
        {
            VBCPPEXPR Result;
            rcExit = vbcppExprEvaluteTree(pThis, pExprTree, &Result);
            if (rcExit == RTEXITCODE_SUCCESS)
            {
                if (vbcppExprIsExprTrue(&Result))
                    *penmResult = kVBCppEval_True;
                else
                    *penmResult = kVBCppEval_False;
            }
        }
        else
            *penmResult = kVBCppEval_Undecided;
    }
    return rcExit;
}


static RTEXITCODE vbcppExtractSkipCommentLine(PVBCPP pThis, PSCMSTREAM pStrmInput)
{
    RT_NOREF_PV(pThis);

    unsigned chPrev = ScmStreamGetCh(pStrmInput); Assert(chPrev == '/');
    unsigned ch;
    while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
    {
        if (ch == '\r' || ch == '\n')
        {
            if (chPrev != '\\')
                break;
            ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
            chPrev = ch;
        }
        else
        {
            chPrev = ScmStreamGetCh(pStrmInput);
            Assert(chPrev == ch);
        }
    }
    return RTEXITCODE_SUCCESS;
}


static RTEXITCODE vbcppExtractSkipComment(PVBCPP pThis, PSCMSTREAM pStrmInput)
{
    unsigned ch = ScmStreamGetCh(pStrmInput); Assert(ch == '*');
    while ((ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0)
    {
        if (ch == '*')
        {
            ch = ScmStreamGetCh(pStrmInput);
            if (ch == '/')
                return RTEXITCODE_SUCCESS;
        }
    }
    return vbcppError(pThis, "Expected '*/'");
}


static RTEXITCODE vbcppExtractQuotedString(PVBCPP pThis, PSCMSTREAM pStrmInput, PVBCPPSTRBUF pStrBuf,
                                           char chOpen, char chClose)
{
    unsigned ch = ScmStreamGetCh(pStrmInput);
    Assert(ch == (unsigned)chOpen);

    RTEXITCODE rcExit = vbcppStrBufAppendCh(pStrBuf, chOpen);
    if (rcExit != RTEXITCODE_SUCCESS)
        return rcExit;

    for (;;)
    {
        ch = ScmStreamGetCh(pStrmInput);
        if (ch == '\\')
        {
            ch = ScmStreamGetCh(pStrmInput);
            if (ch == ~(unsigned)0)
                break;
            rcExit = vbcppStrBufAppendCh(pStrBuf, '\\');
            if (rcExit == RTEXITCODE_SUCCESS)
                rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
            if (rcExit != RTEXITCODE_SUCCESS)
                return rcExit;
        }
        else if (ch != ~(unsigned)0)
        {
            rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
            if (rcExit != RTEXITCODE_SUCCESS)
                return rcExit;
            if (ch == (unsigned)chClose)
                return RTEXITCODE_SUCCESS;
        }
        else
            break;
    }

    return vbcppError(pThis, "File ended with an open character constant");
}


/**
 * Extracts a line from the stream, stripping it for comments and maybe
 * optimzing some of the whitespace.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 * @param   pStrBuf             Where to store the extracted line. Caller must
 *                              initialize this prior to the call an delete it
 *                              after use (even on failure).
 * @param   poffComment         Where to note down the position of the final
 *                              comment. Optional.
 */
static RTEXITCODE vbcppExtractDirectiveLine(PVBCPP pThis, PSCMSTREAM pStrmInput, PVBCPPSTRBUF pStrBuf, size_t *poffComment)
{
    size_t      offComment  = ~(size_t)0;
    unsigned    ch;
    while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
    {
        RTEXITCODE rcExit;
        if (ch == '/')
        {
            /* Comment? */
            unsigned ch2 = ScmStreamGetCh(pStrmInput); Assert(ch == ch2); NOREF(ch2);
            ch = ScmStreamPeekCh(pStrmInput);
            if (ch == '*')
            {
                offComment = ScmStreamTell(pStrmInput) - 1;
                rcExit = vbcppExtractSkipComment(pThis, pStrmInput);
            }
            else if (ch == '/')
            {
                offComment = ScmStreamTell(pStrmInput) - 1;
                rcExit = vbcppExtractSkipCommentLine(pThis, pStrmInput);
            }
            else
                rcExit = vbcppStrBufAppendCh(pStrBuf, '/');
        }
        else if (ch == '\'')
        {
            offComment = ~(size_t)0;
            rcExit = vbcppExtractQuotedString(pThis, pStrmInput, pStrBuf, '\'', '\'');
        }
        else if (ch == '"')
        {
            offComment = ~(size_t)0;
            rcExit = vbcppExtractQuotedString(pThis, pStrmInput, pStrBuf, '"', '"');
        }
        else if (ch == '\r' || ch == '\n')
            break; /* done */
        else if (   RT_C_IS_SPACE(ch)
                 && (   RT_C_IS_SPACE(vbcppStrBufLastCh(pStrBuf))
                     || vbcppStrBufLastCh(pStrBuf) == '\0') )
        {
            unsigned ch2 = ScmStreamGetCh(pStrmInput);
            Assert(ch == ch2); NOREF(ch2);
            rcExit = RTEXITCODE_SUCCESS;
        }
        else
        {
            unsigned ch2 = ScmStreamGetCh(pStrmInput); Assert(ch == ch2);

            /* Escaped newline? */
            if (   ch == '\\'
                && (   (ch2 = ScmStreamPeekCh(pStrmInput)) == '\r'
                    || ch2 == '\n'))
            {
                ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
                rcExit = RTEXITCODE_SUCCESS;
            }
            else
            {
                offComment = ~(size_t)0;
                rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
            }
        }
        if (rcExit != RTEXITCODE_SUCCESS)
            return rcExit;
    }

    if (poffComment)
        *poffComment = offComment;
    return RTEXITCODE_SUCCESS;
}


/**
 * Processes a abbreviated line number directive.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 * @param   offStart            The stream position where the directive
 *                              started (for pass thru).
 * @param   enmKind             The kind of directive we're processing.
 */
static RTEXITCODE vbcppDirectiveIfOrElif(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart,
                                         VBCPPCONDKIND enmKind)
{
    /*
     * Check for missing #if if #elif.
     */
    if (   enmKind == kVBCppCondKind_ElIf
        && !pThis->pCondStack )
        return vbcppError(pThis, "#elif without #if");

    /*
     * Extract the expression string.
     */
    const char         *pchCondition = ScmStreamGetCur(pStrmInput);
    size_t              offComment;
    VBCPPMACROEXP       ExpCtx;
#if 0
    ExpCtx.pMacroStack    = NULL;
#endif
    ExpCtx.pStrmInput     = NULL;
    ExpCtx.papszArgs      = NULL;
    ExpCtx.cArgs          = 0;
    ExpCtx.cArgsAlloced   = 0;
    vbcppStrBufInit(&ExpCtx.StrBuf, pThis);
    RTEXITCODE  rcExit = vbcppExtractDirectiveLine(pThis, pStrmInput, &ExpCtx.StrBuf, &offComment);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        size_t const    cchCondition = ScmStreamGetCur(pStrmInput) - pchCondition;

        /*
         * Expand known macros in it.
         */
        size_t          cReplacements;
        rcExit = vbcppMacroExpandReScan(pThis, &ExpCtx, kMacroReScanMode_Expression, &cReplacements);
        if (rcExit == RTEXITCODE_SUCCESS)
        {
            /*
             * Strip it and check that it's not empty.
             */
            char   *pszExpr = ExpCtx.StrBuf.pszBuf;
            size_t  cchExpr = ExpCtx.StrBuf.cchBuf;
            while (cchExpr > 0 && RT_C_IS_SPACE(*pszExpr))
                pszExpr++, cchExpr--;

            while (cchExpr > 0 && RT_C_IS_SPACE(pszExpr[cchExpr - 1]))
            {
                pszExpr[--cchExpr] = '\0';
                ExpCtx.StrBuf.cchBuf--;
            }
            if (cchExpr)
            {
                /*
                 * Now, evalute the expression.
                 */
                VBCPPEVAL enmResult;
                rcExit = vbcppExprEval(pThis, pszExpr, cchExpr, cReplacements, &enmResult);
                if (rcExit == RTEXITCODE_SUCCESS)
                {
                    /*
                     * Take action.
                     */
                    if (enmKind != kVBCppCondKind_ElIf)
                        rcExit = vbcppCondPush(pThis, pStrmInput, offComment, enmKind, enmResult,
                                               pchCondition, cchCondition);
                    else
                    {
                        PVBCPPCOND pCond = pThis->pCondStack;
                        if (   pCond->enmResult != kVBCppEval_Undecided
                            && (   !pCond->pUp
                                || pCond->pUp->enmStackResult == kVBCppEval_True))
                        {
                            Assert(enmResult == kVBCppEval_True || enmResult == kVBCppEval_False);
                            if (   pCond->enmResult == kVBCppEval_False
                                && enmResult        == kVBCppEval_True
                                && !pCond->fElIfDecided)
                            {
                                pCond->enmStackResult = kVBCppEval_True;
                                pCond->fElIfDecided   = true;
                            }
                            else
                                pCond->enmStackResult = kVBCppEval_False;
                            pThis->fIf0Mode = pCond->enmStackResult == kVBCppEval_False;
                        }
                        pCond->enmKind   = kVBCppCondKind_ElIf;
                        pCond->enmResult = enmResult;
                        pCond->pchCond   = pchCondition;
                        pCond->cchCond   = cchCondition;

                        /*
                         * Do #elif pass thru.
                         */
                        if (   !pThis->fIf0Mode
                            && pCond->enmResult == kVBCppEval_Undecided)
                        {
                            ssize_t cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*selif", pCond->iKeepLevel - 1, "");
                            if (cch > 0)
                                rcExit = vbcppOutputComment(pThis, pStrmInput, offStart, cch, 2);
                            else
                                rcExit = vbcppError(pThis, "Output error %Rrc", (int)cch);
                        }
                        else
                            pThis->fJustDroppedLine = true;
                    }
                }
            }
            else
                rcExit = vbcppError(pThis, "Empty #if expression");
        }
    }
    vbcppMacroExpandCleanup(&ExpCtx);
    return rcExit;
}


/**
 * Processes a abbreviated line number directive.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 * @param   offStart            The stream position where the directive
 *                              started (for pass thru).
 */
static RTEXITCODE vbcppDirectiveIfDef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
{
    /*
     * Parse it.
     */
    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        size_t      cchDefine;
        const char *pchDefine = ScmStreamCGetWord(pStrmInput, &cchDefine);
        if (pchDefine)
        {
            rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
            if (rcExit == RTEXITCODE_SUCCESS)
            {
                /*
                 * Evaluate it.
                 */
                VBCPPEVAL enmEval;
                if (vbcppMacroExists(pThis, pchDefine, cchDefine))
                    enmEval = kVBCppEval_True;
                else if (   !pThis->fUndecidedConditionals
                         || RTStrSpaceGetN(&pThis->UndefStrSpace, pchDefine, cchDefine) != NULL)
                    enmEval = kVBCppEval_False;
                else
                    enmEval = kVBCppEval_Undecided;
                rcExit = vbcppCondPush(pThis, pStrmInput, offStart, kVBCppCondKind_IfDef, enmEval,
                                       pchDefine, cchDefine);
            }
        }
        else
            rcExit = vbcppError(pThis, "Malformed #ifdef");
    }
    return rcExit;
}


/**
 * Processes a abbreviated line number directive.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 * @param   offStart            The stream position where the directive
 *                              started (for pass thru).
 */
static RTEXITCODE vbcppDirectiveIfNDef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
{
    /*
     * Parse it.
     */
    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        size_t      cchDefine;
        const char *pchDefine = ScmStreamCGetWord(pStrmInput, &cchDefine);
        if (pchDefine)
        {
            rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
            if (rcExit == RTEXITCODE_SUCCESS)
            {
                /*
                 * Evaluate it.
                 */
                VBCPPEVAL enmEval;
                if (vbcppMacroExists(pThis, pchDefine, cchDefine))
                    enmEval = kVBCppEval_False;
                else if (   !pThis->fUndecidedConditionals
                         || RTStrSpaceGetN(&pThis->UndefStrSpace, pchDefine, cchDefine) != NULL)
                    enmEval = kVBCppEval_True;
                else
                    enmEval = kVBCppEval_Undecided;
                rcExit = vbcppCondPush(pThis, pStrmInput, offStart, kVBCppCondKind_IfNDef, enmEval,
                                       pchDefine, cchDefine);
            }
        }
        else
            rcExit = vbcppError(pThis, "Malformed #ifndef");
    }
    return rcExit;
}


/**
 * Processes a abbreviated line number directive.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 * @param   offStart            The stream position where the directive
 *                              started (for pass thru).
 */
static RTEXITCODE vbcppDirectiveElse(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
{
    /*
     * Nothing to parse, just comment positions to find and note down.
     */
    offStart = vbcppProcessSkipWhite(pStrmInput);
    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        /*
         * Execute.
         */
        PVBCPPCOND pCond = pThis->pCondStack;
        if (pCond)
        {
            if (!pCond->fSeenElse)
            {
                pCond->fSeenElse = true;
                if (   pCond->enmResult != kVBCppEval_Undecided
                    && (   !pCond->pUp
                        || pCond->pUp->enmStackResult == kVBCppEval_True))
                {
                    if (   pCond->enmResult == kVBCppEval_True
                        || pCond->fElIfDecided)

                        pCond->enmStackResult = kVBCppEval_False;
                    else
                        pCond->enmStackResult = kVBCppEval_True;
                    pThis->fIf0Mode = pCond->enmStackResult == kVBCppEval_False;
                }

                /*
                 * Do pass thru.
                 */
                if (   !pThis->fIf0Mode
                    && pCond->enmResult == kVBCppEval_Undecided)
                {
                    ssize_t cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*selse", pCond->iKeepLevel - 1, "");
                    if (cch > 0)
                        rcExit = vbcppOutputComment(pThis, pStrmInput, offStart, cch, 2);
                    else
                        rcExit = vbcppError(pThis, "Output error %Rrc", (int)cch);
                }
                else
                    pThis->fJustDroppedLine = true;
            }
            else
                rcExit = vbcppError(pThis, "Double #else or/and missing #endif");
        }
        else
            rcExit = vbcppError(pThis, "#else without #if");
    }
    return rcExit;
}


/**
 * Processes a abbreviated line number directive.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 * @param   offStart            The stream position where the directive
 *                              started (for pass thru).
 */
static RTEXITCODE vbcppDirectiveEndif(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
{
    /*
     * Nothing to parse, just comment positions to find and note down.
     */
    offStart = vbcppProcessSkipWhite(pStrmInput);
    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        /*
         * Execute.
         */
        PVBCPPCOND pCond = pThis->pCondStack;
        if (pCond)
        {
            pThis->pCondStack = pCond->pUp;
            pThis->fIf0Mode   = pCond->pUp && pCond->pUp->enmStackResult == kVBCppEval_False;

            /*
             * Do pass thru.
             */
            if (   !pThis->fIf0Mode
                && pCond->enmResult == kVBCppEval_Undecided)
            {
                ssize_t cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sendif", pCond->iKeepLevel - 1, "");
                if (cch > 0)
                    rcExit = vbcppOutputComment(pThis, pStrmInput, offStart, cch, 1);
                else
                    rcExit = vbcppError(pThis, "Output error %Rrc", (int)cch);
            }
            else
                pThis->fJustDroppedLine = true;
        }
        else
            rcExit = vbcppError(pThis, "#endif without #if");
    }
    return rcExit;
}





/*
 *
 *
 * Misc Directives
 * Misc Directives
 * Misc Directives
 * Misc Directives
 *
 *
 */


/**
 * Adds an include directory.
 *
 * @returns Program exit code, with error message on failure.
 * @param   pThis               The C preprocessor instance.
 * @param   pszDir              The directory to add.
 */
static RTEXITCODE vbcppAddInclude(PVBCPP pThis, const char *pszDir)
{
    uint32_t cIncludes = pThis->cIncludes;
    if (cIncludes >= _64K)
        return vbcppError(pThis, "Too many include directories");

    void *pv = RTMemRealloc(pThis->papszIncludes, (cIncludes + 1) * sizeof(char **));
    if (!pv)
        return vbcppError(pThis, "No memory for include directories");
    pThis->papszIncludes = (char **)pv;

    int rc = RTStrDupEx(&pThis->papszIncludes[cIncludes], pszDir);
    if (RT_FAILURE(rc))
        return vbcppError(pThis, "No string memory for include directories");

    pThis->cIncludes = cIncludes + 1;
    return RTEXITCODE_SUCCESS;
}


/**
 * Processes a abbreviated line number directive.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 * @param   offStart            The stream position where the directive
 *                              started (for pass thru).
 */
static RTEXITCODE vbcppDirectiveInclude(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
{
    RT_NOREF_PV(offStart);

    /*
     * Parse it.
     */
    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        size_t      cchFileSpec = 0;
        const char *pchFileSpec = NULL;
        size_t      cchFilename = 0;
        const char *pchFilename = NULL;

        unsigned ch = ScmStreamPeekCh(pStrmInput);
        unsigned chType = ch;
        if (ch == '"' || ch == '<')
        {
            ScmStreamGetCh(pStrmInput);
            pchFileSpec = pchFilename = ScmStreamGetCur(pStrmInput);
            unsigned chEnd  = chType == '<' ? '>' : '"';
            while (   (ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0
                   &&  ch != chEnd)
            {
                if (ch == '\r' || ch == '\n')
                {
                    rcExit = vbcppError(pThis, "Multi-line include file specfications are not supported");
                    break;
                }
            }

            if (rcExit == RTEXITCODE_SUCCESS)
            {
                if (ch != ~(unsigned)0)
                    cchFileSpec = cchFilename = ScmStreamGetCur(pStrmInput) - pchFilename - 1;
                else
                    rcExit = vbcppError(pThis, "Expected '%c'", chType);
            }
        }
        else if (vbcppIsCIdentifierLeadChar(ch))
        {
            //pchFileSpec = ScmStreamCGetWord(pStrmInput, &cchFileSpec);
            rcExit = vbcppError(pThis, "Including via a define is not implemented yet");
        }
        else
            rcExit = vbcppError(pThis, "Malformed include directive");

        /*
         * Take down the location of the next non-white space, in case we need
         * to pass thru the directive further down. Then skip to the end of the
         * line.
         */
        size_t const offIncEnd = vbcppProcessSkipWhite(pStrmInput);
        if (rcExit == RTEXITCODE_SUCCESS)
            rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);

        if (rcExit == RTEXITCODE_SUCCESS)
        {
            /*
             * Execute it.
             */
            if (pThis->enmIncludeAction == kVBCppIncludeAction_Include)
            {
                /** @todo Search for the include file and push it onto the input stack.
                 *  Not difficult, just unnecessary rigth now. */
                rcExit = vbcppError(pThis, "Includes are fully implemented");
            }
            else if (pThis->enmIncludeAction == kVBCppIncludeAction_PassThru)
            {
                /* Pretty print the passthru. */
                unsigned cchIndent = pThis->pCondStack ? pThis->pCondStack->iKeepLevel : 0;
                ssize_t  cch;
                if (chType == '<')
                    cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sinclude <%.*s>",
                                          cchIndent, "", cchFileSpec, pchFileSpec);
                else if (chType == '"')
                    cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sinclude \"%.*s\"",
                                          cchIndent, "", cchFileSpec, pchFileSpec);
                else
                    cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sinclude %.*s",
                                          cchIndent, "", cchFileSpec, pchFileSpec);
                if (cch > 0)
                    rcExit = vbcppOutputComment(pThis, pStrmInput, offIncEnd, cch, 1);
                else
                    rcExit = vbcppError(pThis, "Output error %Rrc", (int)cch);

            }
            else
            {
                Assert(pThis->enmIncludeAction == kVBCppIncludeAction_Drop);
                pThis->fJustDroppedLine = true;
            }
        }
    }
    return rcExit;
}


/**
 * Processes a abbreviated line number directive.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 * @param   offStart            The stream position where the directive
 *                              started (for pass thru).
 */
static RTEXITCODE vbcppDirectivePragma(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
{
    RT_NOREF_PV(offStart);

    /*
     * Parse out the first word.
     */
    RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        size_t      cchPragma;
        const char *pchPragma = ScmStreamCGetWord(pStrmInput, &cchPragma);
        if (pchPragma)
        {
            size_t const off2nd = vbcppProcessSkipWhite(pStrmInput);
            size_t       offComment;
            rcExit = vbcppInputSkipToEndOfDirectiveLine(pThis, pStrmInput, &offComment);
            if (rcExit == RTEXITCODE_SUCCESS)
            {
                /*
                 * What to do about this
                 */
                bool fPassThru = false;
                if (   cchPragma  == 1
                    && *pchPragma == 'D')
                    fPassThru = pThis->fPassThruPragmaD;
                else if (    cchPragma == 3
                         &&  !strncmp(pchPragma, "STD", 3))
                    fPassThru = pThis->fPassThruPragmaSTD;
                else
                    fPassThru = pThis->fPassThruPragmaOther;
                if (fPassThru)
                {
                    unsigned cchIndent = pThis->pCondStack ? pThis->pCondStack->iKeepLevel : 0;
                    ssize_t  cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*spragma %.*s",
                                                   cchIndent, "", cchPragma, pchPragma);
                    if (cch > 0)
                        rcExit = vbcppOutputComment(pThis, pStrmInput, off2nd, cch, 1);
                    else
                        rcExit = vbcppError(pThis, "output error");
                }
                else
                    pThis->fJustDroppedLine = true;
            }
        }
        else
            rcExit = vbcppError(pThis, "Malformed #pragma");
    }

    return rcExit;
}


/**
 * Processes an error directive.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 * @param   offStart            The stream position where the directive
 *                              started (for pass thru).
 */
static RTEXITCODE vbcppDirectiveError(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
{
    RT_NOREF_PV(offStart);
    RT_NOREF_PV(pStrmInput);
    return vbcppError(pThis, "Hit an #error");
}


/**
 * Processes a abbreviated line number directive.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 * @param   offStart            The stream position where the directive
 *                              started (for pass thru).
 */
static RTEXITCODE vbcppDirectiveLineNo(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
{
    RT_NOREF_PV(offStart);
    RT_NOREF_PV(pStrmInput);
    return vbcppError(pThis, "Not implemented: %s", __FUNCTION__);
}


/**
 * Processes a abbreviated line number directive.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 */
static RTEXITCODE vbcppDirectiveLineNoShort(PVBCPP pThis, PSCMSTREAM pStrmInput)
{
    RT_NOREF_PV(pStrmInput);
    return vbcppError(pThis, "Not implemented: %s", __FUNCTION__);
}


/**
 * Handles a preprocessor directive.
 *
 * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
 * @param   pThis               The C preprocessor instance.
 * @param   pStrmInput          The input stream.
 */
static RTEXITCODE vbcppProcessDirective(PVBCPP pThis, PSCMSTREAM pStrmInput)
{
    /*
     * Get the directive and do a string switch on it.
     */
    RTEXITCODE  rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
    if (rcExit != RTEXITCODE_SUCCESS)
        return rcExit;
    size_t      cchDirective;
    const char *pchDirective = ScmStreamCGetWord(pStrmInput, &cchDirective);
    if (pchDirective)
    {
        size_t const offStart = ScmStreamTell(pStrmInput);
#define IS_DIRECTIVE(a_sz) ( sizeof(a_sz) - 1 == cchDirective && strncmp(pchDirective, a_sz, sizeof(a_sz) - 1) == 0)
        if (IS_DIRECTIVE("if"))
            rcExit = vbcppDirectiveIfOrElif(pThis, pStrmInput, offStart, kVBCppCondKind_If);
        else if (IS_DIRECTIVE("elif"))
            rcExit = vbcppDirectiveIfOrElif(pThis, pStrmInput, offStart, kVBCppCondKind_ElIf);
        else if (IS_DIRECTIVE("ifdef"))
            rcExit = vbcppDirectiveIfDef(pThis, pStrmInput, offStart);
        else if (IS_DIRECTIVE("ifndef"))
            rcExit = vbcppDirectiveIfNDef(pThis, pStrmInput, offStart);
        else if (IS_DIRECTIVE("else"))
            rcExit = vbcppDirectiveElse(pThis, pStrmInput, offStart);
        else if (IS_DIRECTIVE("endif"))
            rcExit = vbcppDirectiveEndif(pThis, pStrmInput, offStart);
        else if (!pThis->fIf0Mode)
        {
            if (IS_DIRECTIVE("include"))
                rcExit = vbcppDirectiveInclude(pThis, pStrmInput, offStart);
            else if (IS_DIRECTIVE("define"))
                rcExit = vbcppDirectiveDefine(pThis, pStrmInput, offStart);
            else if (IS_DIRECTIVE("undef"))
                rcExit = vbcppDirectiveUndef(pThis, pStrmInput, offStart);
            else if (IS_DIRECTIVE("pragma"))
                rcExit = vbcppDirectivePragma(pThis, pStrmInput, offStart);
            else if (IS_DIRECTIVE("error"))
                rcExit = vbcppDirectiveError(pThis, pStrmInput, offStart);
            else if (IS_DIRECTIVE("line"))
                rcExit = vbcppDirectiveLineNo(pThis, pStrmInput, offStart);
            else
                rcExit = vbcppError(pThis, "Unknown preprocessor directive '#%.*s'", cchDirective, pchDirective);
        }
#undef IS_DIRECTIVE
    }
    else if (!pThis->fIf0Mode)
    {
        /* Could it be a # <num> "file" directive? */
        unsigned ch = ScmStreamPeekCh(pStrmInput);
        if (RT_C_IS_DIGIT(ch))
            rcExit = vbcppDirectiveLineNoShort(pThis, pStrmInput);
        else
            rcExit = vbcppError(pThis, "Malformed preprocessor directive");
    }
    return rcExit;
}


/*
 *
 *
 * M a i n   b o d y.
 * M a i n   b o d y.
 * M a i n   b o d y.
 * M a i n   b o d y.
 * M a i n   b o d y.
 *
 *
 */


/**
 * Does the actually preprocessing of the input file.
 *
 * @returns Exit code.
 * @param   pThis               The C preprocessor instance.
 */
static RTEXITCODE vbcppPreprocess(PVBCPP pThis)
{
    RTEXITCODE  rcExit = RTEXITCODE_SUCCESS;

    /*
     * Parse.
     */
    while (pThis->pInputStack)
    {
        pThis->fMaybePreprocessorLine = true;

        PSCMSTREAM  pStrmInput = &pThis->pInputStack->StrmInput;
        unsigned    ch;
        while ((ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0)
        {
            if (ch == '/')
            {
                ch = ScmStreamPeekCh(pStrmInput);
                if (ch == '*')
                    rcExit = vbcppProcessMultiLineComment(pThis, pStrmInput);
                else if (ch == '/')
                    rcExit = vbcppProcessOneLineComment(pThis, pStrmInput);
                else
                {
                    pThis->fMaybePreprocessorLine = false;
                    if (!pThis->fIf0Mode)
                        rcExit = vbcppOutputCh(pThis, '/');
                }
            }
            else if (ch == '#' && pThis->fMaybePreprocessorLine)
            {
                rcExit = vbcppProcessDirective(pThis, pStrmInput);
                pStrmInput = &pThis->pInputStack->StrmInput;
            }
            else if (ch == '\r' || ch == '\n')
            {
                if (   (   !pThis->fIf0Mode
                        && !pThis->fJustDroppedLine)
                    || !pThis->fRemoveDroppedLines
                    || !ScmStreamIsAtStartOfLine(&pThis->StrmOutput))
                    rcExit = vbcppOutputCh(pThis, ch);
                pThis->fJustDroppedLine       = false;
                pThis->fMaybePreprocessorLine = true;
            }
            else if (RT_C_IS_SPACE(ch))
            {
                if (!pThis->fIf0Mode)
                    rcExit = vbcppOutputCh(pThis, ch);
            }
            else
            {
                pThis->fMaybePreprocessorLine = false;
                if (!pThis->fIf0Mode)
                {
                    if (ch == '"')
                        rcExit = vbcppProcessStringLitteral(pThis, pStrmInput);
                    else if (ch == '\'')
                        rcExit = vbcppProcessCharacterConstant(pThis, pStrmInput);
                    else if (vbcppIsCIdentifierLeadChar(ch))
                        rcExit = vbcppProcessIdentifier(pThis, pStrmInput);
                    else if (RT_C_IS_DIGIT(ch))
                        rcExit = vbcppProcessNumber(pThis, pStrmInput, ch);
                    else
                        rcExit = vbcppOutputCh(pThis, ch);
                }
            }
            if (rcExit != RTEXITCODE_SUCCESS)
                break;
        }

        /*
         * Check for errors.
         */
        if (rcExit != RTEXITCODE_SUCCESS)
            break;

        /*
         * Pop the input stack.
         */
        PVBCPPINPUT pPopped = pThis->pInputStack;
        pThis->pInputStack = pPopped->pUp;
        RTMemFree(pPopped);
    }

    return rcExit;
}


/**
 * Opens the input and output streams.
 *
 * @returns Exit code.
 * @param   pThis               The C preprocessor instance.
 */
static RTEXITCODE vbcppOpenStreams(PVBCPP pThis)
{
    if (!pThis->pszInput)
        return vbcppError(pThis, "Preprocessing the standard input stream is currently not supported");

    size_t      cchName = strlen(pThis->pszInput);
    PVBCPPINPUT pInput = (PVBCPPINPUT)RTMemAlloc(RT_UOFFSETOF_DYN(VBCPPINPUT, szName[cchName + 1]));
    if (!pInput)
        return vbcppError(pThis, "out of memory");
    pInput->pUp          = pThis->pInputStack;
    pInput->pszSpecified = pInput->szName;
    memcpy(pInput->szName, pThis->pszInput, cchName + 1);
    pThis->pInputStack   = pInput;
    int rc = ScmStreamInitForReading(&pInput->StrmInput, pThis->pszInput);
    if (RT_FAILURE(rc))
        return vbcppError(pThis, "ScmStreamInitForReading returned %Rrc when opening input file (%s)",
                          rc, pThis->pszInput);

    rc = ScmStreamInitForWriting(&pThis->StrmOutput, &pInput->StrmInput);
    if (RT_FAILURE(rc))
        return vbcppError(pThis, "ScmStreamInitForWriting returned %Rrc", rc);

    pThis->fStrmOutputValid = true;
    return RTEXITCODE_SUCCESS;
}


/**
 * Changes the preprocessing mode.
 *
 * @param   pThis               The C preprocessor instance.
 * @param   enmMode             The new mode.
 */
static void vbcppSetMode(PVBCPP pThis, VBCPPMODE enmMode)
{
    switch (enmMode)
    {
        case kVBCppMode_Standard:
            pThis->fKeepComments                    = false;
            pThis->fRespectSourceDefines            = true;
            pThis->fAllowRedefiningCmdLineDefines   = true;
            pThis->fPassThruDefines                 = false;
            pThis->fUndecidedConditionals           = false;
            pThis->fPassThruPragmaD                 = false;
            pThis->fPassThruPragmaSTD               = true;
            pThis->fPassThruPragmaOther             = true;
            pThis->fRemoveDroppedLines              = false;
            pThis->fLineSplicing                    = true;
            pThis->enmIncludeAction                 = kVBCppIncludeAction_Include;
            break;

        case kVBCppMode_Selective:
            pThis->fKeepComments                    = true;
            pThis->fRespectSourceDefines            = false;
            pThis->fAllowRedefiningCmdLineDefines   = false;
            pThis->fPassThruDefines                 = true;
            pThis->fUndecidedConditionals           = true;
            pThis->fPassThruPragmaD                 = true;
            pThis->fPassThruPragmaSTD               = true;
            pThis->fPassThruPragmaOther             = true;
            pThis->fRemoveDroppedLines              = true;
            pThis->fLineSplicing                    = false;
            pThis->enmIncludeAction                 = kVBCppIncludeAction_PassThru;
            break;

        case kVBCppMode_SelectiveD:
            pThis->fKeepComments                    = true;
            pThis->fRespectSourceDefines            = true;
            pThis->fAllowRedefiningCmdLineDefines   = false;
            pThis->fPassThruDefines                 = false;
            pThis->fUndecidedConditionals           = false;
            pThis->fPassThruPragmaD                 = true;
            pThis->fPassThruPragmaSTD               = false;
            pThis->fPassThruPragmaOther             = false;
            pThis->fRemoveDroppedLines              = true;
            pThis->fLineSplicing                    = false;
            pThis->enmIncludeAction                 = kVBCppIncludeAction_Drop;
            break;

        default:
            AssertFailedReturnVoid();
    }
    pThis->enmMode = enmMode;
}


/**
 * Parses the command line options.
 *
 * @returns Program exit code. Exit on non-success or if *pfExit is set.
 * @param   pThis               The C preprocessor instance.
 * @param   argc                The argument count.
 * @param   argv                The argument vector.
 * @param   pfExit              Pointer to the exit indicator.
 */
static RTEXITCODE vbcppParseOptions(PVBCPP pThis, int argc, char **argv, bool *pfExit)
{
    RTEXITCODE rcExit;

    *pfExit = false;

    /*
     * Option config.
     */
    static RTGETOPTDEF const s_aOpts[] =
    {
        { "--define",                   'D',                    RTGETOPT_REQ_STRING },
        { "--include-dir",              'I',                    RTGETOPT_REQ_STRING },
        { "--undefine",                 'U',                    RTGETOPT_REQ_STRING },
        { "--keep-comments",            'C',                    RTGETOPT_REQ_NOTHING },
        { "--strip-comments",           'c',                    RTGETOPT_REQ_NOTHING },
        { "--D-strip",                  'd',                    RTGETOPT_REQ_NOTHING },
    };

    RTGETOPTUNION   ValueUnion;
    RTGETOPTSTATE   GetOptState;
    int rc = RTGetOptInit(&GetOptState, argc, argv, &s_aOpts[0], RT_ELEMENTS(s_aOpts), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
    AssertReleaseRCReturn(rc, RTEXITCODE_FAILURE);

    /*
     * Process the options.
     */
    while ((rc = RTGetOpt(&GetOptState, &ValueUnion)) != 0)
    {
        switch (rc)
        {
            case 'c':
                pThis->fKeepComments = false;
                break;

            case 'C':
                pThis->fKeepComments = false;
                break;

            case 'd':
                vbcppSetMode(pThis, kVBCppMode_SelectiveD);
                break;

            case 'D':
            {
                const char *pszEqual = strchr(ValueUnion.psz, '=');
                if (pszEqual)
                    rcExit = vbcppMacroAdd(pThis, ValueUnion.psz, pszEqual - ValueUnion.psz, pszEqual + 1, RTSTR_MAX, true);
                else
                    rcExit = vbcppMacroAdd(pThis, ValueUnion.psz, RTSTR_MAX, "1", 1, true);
                if (rcExit != RTEXITCODE_SUCCESS)
                    return rcExit;
                break;
            }

            case 'I':
                rcExit = vbcppAddInclude(pThis, ValueUnion.psz);
                if (rcExit != RTEXITCODE_SUCCESS)
                    return rcExit;
                break;

            case 'U':
                rcExit = vbcppMacroUndef(pThis, ValueUnion.psz, RTSTR_MAX, true);
                break;

            case 'h':
                RTPrintf("No help yet, sorry\n");
                *pfExit = true;
                return RTEXITCODE_SUCCESS;

            case 'V':
            {
                /* The following is assuming that svn does it's job here. */
                static const char s_szRev[] = "$Revision: 76553 $";
                const char *psz = RTStrStripL(strchr(s_szRev, ' '));
                RTPrintf("r%.*s\n", strchr(psz, ' ') - psz, psz);
                *pfExit = true;
                return RTEXITCODE_SUCCESS;
            }

            case VINF_GETOPT_NOT_OPTION:
                if (!pThis->pszInput)
                    pThis->pszInput = ValueUnion.psz;
                else if (!pThis->pszOutput)
                    pThis->pszOutput = ValueUnion.psz;
                else
                    return RTMsgErrorExit(RTEXITCODE_SYNTAX, "too many file arguments");
                break;


            /*
             * Errors and bugs.
             */
            default:
                return RTGetOptPrintError(rc, &ValueUnion);
        }
    }

    return RTEXITCODE_SUCCESS;
}


/**
 * Terminates the preprocessor.
 *
 * This may return failure if an error was delayed.
 *
 * @returns Exit code.
 * @param   pThis               The C preprocessor instance.
 */
static RTEXITCODE vbcppTerm(PVBCPP pThis)
{
    /*
     * Flush the output first.
     */
    if (pThis->fStrmOutputValid)
    {
        if (pThis->pszOutput)
        {
            int rc = ScmStreamWriteToFile(&pThis->StrmOutput, "%s", pThis->pszOutput);
            if (RT_FAILURE(rc))
                vbcppError(pThis, "ScmStreamWriteToFile failed with %Rrc when writing '%s'", rc, pThis->pszOutput);
        }
        else
        {
            int rc = ScmStreamWriteToStdOut(&pThis->StrmOutput);
            if (RT_FAILURE(rc))
                vbcppError(pThis, "ScmStreamWriteToStdOut failed with %Rrc", rc);
        }
    }

    /*
     * Cleanup.
     */
    while (pThis->pInputStack)
    {
        ScmStreamDelete(&pThis->pInputStack->StrmInput);
        void *pvFree = pThis->pInputStack;
        pThis->pInputStack = pThis->pInputStack->pUp;
        RTMemFree(pvFree);
    }

    ScmStreamDelete(&pThis->StrmOutput);

    RTStrSpaceDestroy(&pThis->StrSpace, vbcppMacroFree, NULL);
    pThis->StrSpace = NULL;

    uint32_t i = pThis->cIncludes;
    while (i-- > 0)
        RTStrFree(pThis->papszIncludes[i]);
    RTMemFree(pThis->papszIncludes);
    pThis->papszIncludes = NULL;

    return pThis->rcExit;
}


/**
 * Initializes the C preprocessor instance data.
 *
 * @param   pThis               The C preprocessor instance data.
 */
static void vbcppInit(PVBCPP pThis)
{
    vbcppSetMode(pThis, kVBCppMode_Selective);
    pThis->cIncludes        = 0;
    pThis->papszIncludes    = NULL;
    pThis->pszInput         = NULL;
    pThis->pszOutput        = NULL;
    pThis->StrSpace         = NULL;
    pThis->UndefStrSpace    = NULL;
    pThis->cCondStackDepth  = 0;
    pThis->pCondStack       = NULL;
    pThis->fIf0Mode         = false;
    pThis->fJustDroppedLine = false;
    pThis->fMaybePreprocessorLine = true;
    VBCPP_BITMAP_EMPTY(pThis->bmDefined);
    pThis->cCondStackDepth  = 0;
    pThis->pInputStack      = NULL;
    RT_ZERO(pThis->StrmOutput);
    pThis->rcExit           = RTEXITCODE_SUCCESS;
    pThis->fStrmOutputValid = false;
}



int main(int argc, char **argv)
{
    int rc = RTR3InitExe(argc, &argv, 0);
    if (RT_FAILURE(rc))
        return RTMsgInitFailure(rc);

    /*
     * Do the job.  The code says it all.
     */
    VBCPP This;
    vbcppInit(&This);
    bool fExit;
    RTEXITCODE rcExit = vbcppParseOptions(&This, argc, argv, &fExit);
    if (!fExit && rcExit == RTEXITCODE_SUCCESS)
    {
        rcExit = vbcppOpenStreams(&This);
        if (rcExit == RTEXITCODE_SUCCESS)
            rcExit = vbcppPreprocess(&This);
    }

    if (rcExit == RTEXITCODE_SUCCESS)
        rcExit = vbcppTerm(&This);
    else
        vbcppTerm(&This);
    return rcExit;
}