Changeset 41179 in vbox for trunk

Timestamp:

May 6, 2012 8:31:02 PM (13 years ago)

Author:

vboxsync

Message:

More CPP core.

Location:

trunk/src/bldprogs

Files:

• Makefile.kmk (modified) (1 diff)
• VBoxCPP.cpp (modified) (16 diffs)
• scmstream.cpp (modified) (3 diffs)
• scmstream.h (modified) (1 diff)

trunk/src/bldprogs/Makefile.kmk

@@ -50 +50 @@
         scmstream.cpp
 
- #BLDPROGS += VBoxCPP
+ BLDPROGS += VBoxCPP
  VBoxCPP_TEMPLATE = VBoxAdvBldProg
  VBoxCPP_SOURCES = \

trunk/src/bldprogs/VBoxCPP.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * VBox Build Tool - A mini C Preprocessor.
+ * VBox Build Tool - A mini C Preprocessor. 
+ *  
+ * This is not attempting to be standard compliant, just get the job done! 
  */
 
@@ -24 +26 @@
 #include <iprt/alloca.h>
 #include <iprt/assert.h>
+#include <iprt/asm.h>
 #include <iprt/ctype.h>
-#include <iprt/env.h>
 #include <iprt/err.h>
 #include <iprt/file.h>
@@ -34 +36 @@
 #include <iprt/message.h>
 #include <iprt/path.h>
-#include <iprt/process.h>
 #include <iprt/stream.h>
 #include <iprt/string.h>
-#include <iprt/uuid.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)
 
 
@@ -72 +88 @@
     /** The number of known arguments.*/
     uint32_t            cArgs;
-
-    /** @todo More to come later some day... Currently, only care about selective
-     *        preprocessing. */
-
-    /** The define value.  (This is followed by the name). */
+    /** 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 define value.  (This is followed by the name and arguments.) */
     char                szValue[1];
 } VBCPPDEF;
@@ -84 +100 @@
 
 /**
+ * Expansion context.
+ */
+typedef struct VBCPPCTX
+{
+    /** The next context on the stack. */
+    struct VBCPPCTX    *pUp;
+    /** The define being expanded. */
+    PVBCPPDEF           pDef;
+    /** Arguments. */
+    struct VBCPPCTXARG
+    {
+        /** The value. */
+        const char *pchValue;
+        /** The value length. */
+        const char *cchValue;
+    }                   aArgs[1];
+} VBCPPCTX;
+/** Pointer to an define expansion context. */
+typedef VBCPPCTX *PVBCPPCTX;
+
+
+/**
  * C Preprocessor instance data.
  */
@@ -91 +129 @@
      * @{ */ 
     /** The preprocessing mode. */
-    VBCPPMODE       enmMode;
+    VBCPPMODE           enmMode;
     /** Whether to keep comments. */
-    bool            fKeepComments;
+    bool                fKeepComments;
 
     /** The number of include directories. */
-    uint32_t        cIncludes;
+    uint32_t            cIncludes;
     /** Array of directories to search for include files. */
-    const char    **papszIncludes;
+    char              **papszIncludes;
 
     /** The name of the input file. */
-    const char     *pszInput;
+    const char         *pszInput;
     /** The name of the output file. NULL if stdout. */
-    const char     *pszOutput;
+    const char         *pszOutput;
     /** @} */
     
     /** The define string space. */
-    RTSTRSPACE      StrSpace;
+    RTSTRSPACE          StrSpace;
     /** 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. */ 
-    uint32_t        bmDefined[256/32];
+    VBCPP_BITMAP_TYPE   bmDefined[VBCPP_BITMAP_SIZE];
+    /** Indicates whether a C-word might need argument expansion.
+     * The bitmap is indexed by C-word lead character.  Bits that are set 
+     * indicates that the lead character is used in an argument of an currently 
+     * expanding  \#define. */
+    VBCPP_BITMAP_TYPE   bmArgs[VBCPP_BITMAP_SIZE];
+
+    /** Expansion context stack. */
+    PVBCPPCTX           pStack;
+    /** The current stack depth. */
+    uint32_t            cStackDepth;
+    /** 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 current input stream. */
+    PSCMSTREAM          pCurStrmInput;
+    /** The input stream. */
+    SCMSTREAM           StrmInput;
+    /** 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;
 /** Pointer to the C preprocessor instance data. */
@@ -134 +198 @@
     pThis->pszOutput        = NULL;
     pThis->StrSpace         = NULL;
-    RT_ZERO(pThis->bmDefined);
-
+    pThis->pStack           = NULL;
+    pThis->cStackDepth      = 0;
+    VBCPP_BITMAP_EMPTY(pThis->bmDefined);
+    VBCPP_BITMAP_EMPTY(pThis->bmArgs);
+    RT_ZERO(pThis->StrmInput);
+    RT_ZERO(pThis->StrmOutput);
+    pThis->rcExit           = RTEXITCODE_SUCCESS;
+    pThis->fStrmOutputValid = false;
+}
+
+
+/**
+ * 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, ...)
+{
+    NOREF(pThis);
+    va_list va;
+    va_start(va, pszMsg);
+    RTMsgErrorV(pszMsg, va);
+    va_end(va);
+    return pThis->rcExit = RTEXITCODE_FAILURE;
+}
+
+
+/**
+ * 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;
+}
+
+
+/**
+ * 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;
+}
+
+
+/**
+ * Frees a define. 
+ *  
+ * @returns VINF_SUCCESS (used when called by RTStrSpaceDestroy)
+ * @param   pStr                Pointer to the VBCPPDEF::Core member.
+ * @param   pvUser              Unused.
+ */
+static DECLCALLBACK(int) vbcppFreeDefine(PRTSTRSPACECORE pStr, void *pvUser)
+{
+    RTMemFree(pStr);
+    NOREF(pvUser);
+    return VINF_SUCCESS;
 }
 
@@ -143 +333 @@
  *  
  * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
- * @param   pThis               The C processor instance.
+ * @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.
@@ -153 +343 @@
     {
         RTStrSpaceRemove(&pThis->StrSpace, pHit->pszString);
-        RTMemFree(pHit);
+        vbcppFreeDefine(pHit, NULL);
     }
     return RTEXITCODE_SUCCESS;
 }
 
+/**
+ * Inserts a define. 
+ *  
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pDef                The define to insert.
+ */
+static RTEXITCODE vbcppInsertDefine(PVBCPP pThis, PVBCPPDEF pDef)
+{
+    if (RTStrSpaceInsert(&pThis->StrSpace, &pDef->Core))
+        VBCPP_BITMAP_SET(pThis->bmDefined, *pDef->Core.pszString);
+    else
+    {
+        RTMsgWarning("Redefining '%s'\n", pDef->Core.pszString);
+        PVBCPPDEF pOld = (PVBCPPDEF)vbcppRemoveDefine(pThis, pDef->Core.pszString, pDef->Core.cchString);
+        bool fRc = RTStrSpaceInsert(&pThis->StrSpace, &pDef->Core);
+        Assert(fRc); Assert(pOld);
+        vbcppFreeDefine(&pOld->Core, NULL);
+    }
+
+    return RTEXITCODE_SUCCESS;
+}
+
 
 /**
@@ -163 +376 @@
  *  
  * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
- * @param   pThis               The C processor instance.
+ * @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.
+ */
+static RTEXITCODE vbcppAddDefineFn(PVBCPP pThis, const char *pszDefine, size_t cchDefine, 
+                                   const char *pszParams, size_t cchParams,
+                                   const char *pszValue, size_t cchValue)
+
+{
+    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_OFFSETOF(VBCPPDEF, szValue[cchValue + 1 + cchDefine + 1 + cchArgNames])
+                    + sizeof(const char *) * cArgs;
+    cbDef = RT_ALIGN_Z(cbDef, sizeof(const char *));
+    PVBCPPDEF pDef  = (PVBCPPDEF)RTMemAlloc(cbDef);
+    if (!pDef)
+        return RTMsgErrorExit(RTEXITCODE_FAILURE, "out of memory");
+
+    char *pszDst = &pDef->szValue[cchValue + 1];
+    pDef->Core.pszString = pszDst;
+    memcpy(pszDst, pszDefine, cchDefine);
+    pszDst += cchDefine;
+    *pszDst++ = '\0';
+    pDef->fFunction = true;
+    pDef->fVarArg   = false;
+    pDef->cArgs     = cArgs;
+    pDef->papszArgs = (const char **)((uintptr_t)pDef + cbDef - sizeof(const char *) * cArgs);
+    VBCPP_BITMAP_EMPTY(pDef->bmArgs);
+    memcpy(pDef->szValue, pszValue, cchValue);
+    pDef->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. */
+        pDef->papszArgs[iArg] = pszDst;
+        do
+        {
+            *pszDst++ = pszParams[off++];
+        } while (   off < cchParams
+                 && vbcppIsCIdentifierChar(pszParams[off]));
+        *pszDst++ = '\0';
+        iArg++;
+    }
+    Assert((uintptr_t)pszDst <= (uintptr_t)pDef->papszArgs);
+
+    return vbcppInsertDefine(pThis, pDef);
+}
+
+
+/**
+ * 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.
@@ -173 +504 @@
                                  const char *pszValue, size_t cchValue)
 {
+    /*
+     * 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);
-
-    const char *pszParan = (const char *)memchr(pszDefine, '(', cchDefine);
-    if (pszParan)
-        return RTMsgErrorExit(RTEXITCODE_FAILURE, "function defines are not implemented. sorry");
-
-    PVBCPPDEF pDef = (PVBCPPDEF)RTMemAlloc(sizeof(*pDef) + cchValue + cchDefine + 2);
+    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 vbcppAddDefineFn(pThis, pszDefine, cchDefine, pszParams, cchParams, pszValue, cchValue);
+    }
+
+    /*
+     * Simple define, no arguments.
+     */
+    if (vbcppValidateCIdentifier(pThis, pszDefine, cchDefine))
+        return RTEXITCODE_FAILURE;
+
+    PVBCPPDEF pDef = (PVBCPPDEF)RTMemAlloc(RT_OFFSETOF(VBCPPDEF, szValue[cchValue + 1 + cchDefine + 1]));
     if (!pDef)
         return RTMsgErrorExit(RTEXITCODE_FAILURE, "out of memory");
 
+    pDef->Core.pszString = &pDef->szValue[cchValue + 1];
+    memcpy((char *)pDef->Core.pszString, pszDefine, cchDefine);
+    ((char *)pDef->Core.pszString)[cchDefine] = '\0';
     pDef->fFunction = false;
     pDef->fVarArg   = false;
     pDef->cArgs     = 0;
+    pDef->papszArgs = NULL;
+    VBCPP_BITMAP_EMPTY(pDef->bmArgs);
     memcpy(pDef->szValue, pszValue, cchValue);
     pDef->szValue[cchValue] = '\0';
-    pDef->Core.pszString = &pDef->szValue[cchValue + 1];
-    memcpy(&pDef->szValue[cchValue + 1], pszDefine, cchDefine);
-    pDef->szValue[cchValue + 1 + cchDefine] = '\0';
-
-    if (!RTStrSpaceInsert(&pThis->StrSpace, &pDef->Core))
-    {
-        RTMsgWarning("Redefining '%s'\n", pDef->Core.pszString);
-        vbcppRemoveDefine(pThis, pDef->Core.pszString, cchDefine);
-        RTStrSpaceInsert(&pThis->StrSpace, &pDef->Core);
-    }
-    return RTEXITCODE_SUCCESS;
-}
-
+
+    return vbcppInsertDefine(pThis, pDef);
+}
+
+
+/**
+ * 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;
 }
@@ -233 +615 @@
         { "--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 },
     };
@@ -248 +632 @@
         switch (rc)
         {
+            case 'c':
+                pThis->fKeepComments = false;
+                break;
+
+            case 'C':
+                pThis->fKeepComments = false;
+                break;
+
             case 'd':
                 pThis->enmMode = kVBCppMode_SelectiveD;
+                pThis->fKeepComments = true;
                 break;
 
@@ -311 +704 @@
 
 
+/**
+ * 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");
+
+    int rc = ScmStreamInitForReading(&pThis->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, &pThis->StrmInput);
+    if (RT_FAILURE(rc))
+        return vbcppError(pThis, "ScmStreamInitForWriting returned %Rrc", rc);
+
+    pThis->fStrmOutputValid = true;
+    return RTEXITCODE_SUCCESS;
+}
+
+
+/**
+ * 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");
+}
+
+
+/**
+ * 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");
+}
+
+
+/**
+ * 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)
+        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)
+                    rcExit = vbcppOutputWrite(pThis, "*/", 2);
+                break;
+            }
+        }
+
+        if (pThis->fKeepComments || ch == '\r' || ch == '\n')
+        {
+            rcExit = vbcppOutputCh(pThis, ch);
+            if (rcExit != RTEXITCODE_SUCCESS)
+                break;
+
+            /* Reset the maybe-preprocessor-line indicator when necessary. */
+            if (ch == '\r' || ch == '\n')
+                pThis->fMaybePreprocessorLine = true;
+        }
+    }
+    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;
+    SCMEOL      enmEol;
+    size_t      cchLine;
+    const char *pszLine = ScmStreamGetLine(pStrmInput, &cchLine, &enmEol); Assert(pszLine);
+    pszLine--; cchLine++;               /* unfetching the first slash. */
+    for (;;)
+    {
+        if (pThis->fKeepComments)
+            rcExit = vbcppOutputWrite(pThis, pszLine, cchLine + enmEol);
+        else
+            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->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 vbcppProcessDoubleQuotedString(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 litteral.
+ *  
+ * 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 vbcppProcessSingledQuotedString(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 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)
+{
+#if 0
+    size_t const offStart = ScmStreamTell(pStrmInput);
+
+    /* 
+     * Skip spaces.
+     */
+    unsigned chPrev = ~(unsigned)0;
+    unsigned ch;                 
+    while ((ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0)
+    {
+        if (!RT_C_IS_SPACE(ch))
+        {
+            if ()
+            {
+            }
+        }
+        ch = chPrev;
+    }
+#endif
+    return vbcppError(pThis, "Not implemented");
+}
+
+
+/**
+ * Processes a C word, possibly replacing it with a definition.
+ *  
+ * @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
+ * @param   pThis               The C preprocessor instance.
+ * @param   pStrmInput          The input stream.
+ * @param   ch                  The first character.
+ */
+static RTEXITCODE vbcppProcessCWord(PVBCPP pThis, PSCMSTREAM pStrmInput, char ch)
+{
+    /** @todo Implement this... */
+    return vbcppOutputCh(pThis, ch);
+}
+
+
+/**
+ * Does the actually preprocessing of the input file.
+ *  
+ * @returns Exit code.
+ * @param   pThis               The C preprocessor instance. 
+ * @param   pStrmInput          The input stream. 
+ */
+static RTEXITCODE vbcppPreprocess(PVBCPP pThis, PSCMSTREAM pStrmInput)
+{
+    /* 
+     * Push.
+     */
+    PSCMSTREAM pStrmInputOld = pThis->pCurStrmInput;
+    pThis->pCurStrmInput = pStrmInput;
+    pThis->fMaybePreprocessorLine = true;
+
+    /* 
+     * Parse.
+     */ 
+    RTEXITCODE  rcExit = RTEXITCODE_SUCCESS;
+    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;
+                rcExit = vbcppOutputCh(pThis, '/');
+            }
+        }
+        else if (ch == '#' && pThis->fMaybePreprocessorLine)
+            rcExit = vbcppProcessDirective(pThis, pStrmInput);
+        else if (ch == '\r' || ch == '\n')
+        {
+            pThis->fMaybePreprocessorLine = true;
+            rcExit = vbcppOutputCh(pThis, ch);
+        }
+        else if (RT_C_IS_SPACE(ch))
+            rcExit = vbcppOutputCh(pThis, ch);
+        else
+        {
+            pThis->fMaybePreprocessorLine = false;
+            if (ch == '"')
+                rcExit = vbcppProcessDoubleQuotedString(pThis, pStrmInput);
+            else if (ch == '\'')
+                rcExit = vbcppProcessSingledQuotedString(pThis, pStrmInput);
+            else if (vbcppIsCIdentifierLeadChar(ch))
+                rcExit = vbcppProcessCWord(pThis, pStrmInput, ch);
+            else
+                rcExit = vbcppOutputCh(pThis, ch);
+        }
+        if (rcExit != RTEXITCODE_SUCCESS)
+            break;
+    }
+    
+    /*
+     * Pop.
+     */
+    pThis->pCurStrmInput = pStrmInputOld;
+    pThis->fMaybePreprocessorLine = true;
+    return rcExit;
+}
+
+
+/**
+ * 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.
+     */
+    ScmStreamDelete(&pThis->StrmInput);
+    ScmStreamDelete(&pThis->StrmOutput);
+
+    RTStrSpaceDestroy(&pThis->StrSpace, vbcppFreeDefine, 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;
+}
+
 
 
@@ -319 +1097 @@
         return RTMsgInitFailure(rc);
 
-    /* 
-     * Parse options.
+    /*
+     * Do the job.  The code says it all.
      */
     VBCPP This;
@@ -328 +1106 @@
     if (!fExit && rcExit == RTEXITCODE_SUCCESS)
     {
-        /*
-         * Process the input file.
-         */
-
-    }
-
+        rcExit = vbcppOpenStreams(&This);
+        if (rcExit == RTEXITCODE_SUCCESS)
+            rcExit = vbcppPreprocess(&This, &This.StrmInput);
+    }
+
+    if (rcExit == RTEXITCODE_SUCCESS)
+        rcExit = vbcppTerm(&This);
+    else
+        vbcppTerm(&This);
     return rcExit;
 }

trunk/src/bldprogs/scmstream.cpp

@@ -21 +21 @@
 #include <iprt/assert.h>
 #include <iprt/ctype.h>
+#include <iprt/err.h>
 #include <iprt/file.h>
-#include <iprt/err.h>
+#include <iprt/handle.h>
 #include <iprt/mem.h>
+#include <iprt/pipe.h>
 #include <iprt/string.h>
 
@@ -328 +330 @@
 
 /**
+ * Writes the stream to standard output.
+ *
+ * @returns IPRT status code
+ * @param   pStream             The stream.
+ */
+int ScmStreamWriteToStdOut(PSCMSTREAM pStream)
+{
+    int rc;
+
+#ifdef RT_STRICT
+    /*
+     * Check that what we're going to write makes sense first.
+     */
+    rc = ScmStreamCheckItegrity(pStream);
+    if (RT_FAILURE(rc))
+        return rc;
+#endif
+
+    /*
+     * Do the actual writing.
+     */
+    RTHANDLE h;
+    rc = RTHandleGetStandard(RTHANDLESTD_OUTPUT, &h);
+    if (RT_SUCCESS(rc))
+    {
+        switch (h.enmType)
+        {
+            case RTHANDLETYPE_FILE:
+                rc = RTFileWrite(h.u.hFile, pStream->pch, pStream->cb, NULL);
+                break;
+            case RTHANDLETYPE_PIPE:
+                rc = RTPipeWriteBlocking(h.u.hPipe, pStream->pch, pStream->cb, NULL);
+                break;
+            default:
+                rc = VERR_INVALID_HANDLE;
+                break;
+        }
+    }
+    return rc;
+}
+
+/**
  * Worker for ScmStreamGetLine that builds the line number index while parsing
  * the stream.
@@ -642 +686 @@
 const char *ScmStreamGetLine(PSCMSTREAM pStream, size_t *pcchLine, PSCMEOL penmEol)
 {
-    /** @todo this doesn't work when pStream->off !=
-     *        pStream->paLines[pStream->iLine-1].off. */
     if (!pStream->fFullyLineated)
         return scmStreamGetLineInternal(pStream, pcchLine, penmEol);
-    return ScmStreamGetLineByNo(pStream, pStream->iLine, pcchLine, penmEol);
+
+    size_t      offCur   = pStream->off;
+    size_t      iCurLine = pStream->iLine;
+    const char *pszLine  = ScmStreamGetLineByNo(pStream, iCurLine, pcchLine, penmEol);
+    if (   pszLine 
+        && pStream->paLines[iCurLine].off < offCur)
+    {
+        offCur -= pStream->paLines[iCurLine].off;
+        Assert(offCur <= pStream->paLines[iCurLine].off);
+        *pcchLine -= offCur;
+        pszLine   += offCur;
+    }
+    return pszLine;
 }
 

trunk/src/bldprogs/scmstream.h

@@ -98 +98 @@
 int         ScmStreamCheckItegrity(PSCMSTREAM pStream);
 int         ScmStreamWriteToFile(PSCMSTREAM pStream, const char *pszFilenameFmt, ...);
+int         ScmStreamWriteToStdOut(PSCMSTREAM pStream);
 size_t      ScmStreamTell(PSCMSTREAM pStream);
 size_t      ScmStreamTellLine(PSCMSTREAM pStream);