Changeset 3154 in kBuild

Timestamp:

Mar 15, 2018 11:35:33 PM (7 years ago)

Author:

bird

Message:

kmk_cc_exec: Some more work.

Location:

trunk/src/kmk

Files:

• Makefile.kmk (modified) (1 diff)
• kmk_cc_exec.c (modified) (61 diffs)
• kmk_cc_exec.h (modified) (2 diffs)
• testcase (added)
• testcase-assignments.kmk (added)
• testcase-ifeq-escape.kmk (added)
• testcase/testcase-export.kmk (added)

trunk/src/kmk/Makefile.kmk

@@ -228 +228 @@
  kmk_DEFS += CONFIG_WITH_COMPILE_EVERYTHING
 endif
+#ifeq ($(KBUILD_TYPE).$(USERNAME),debug.bird)
+# kmk_DEFS += CONFIG_WITH_COMPILER CONFIG_WITH_EVAL_COMPILER CONFIG_WITH_COMPILE_EVERYTHING
+#endif
 
 kmk_SOURCES = \

trunk/src/kmk/kmk_cc_exec.c

@@ -6 +6 @@
 
 /*
- * Copyright (c) 2015 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
+ * Copyright (c) 2015-2017 knut st. osmundsen <bird-kBuild-spam-xiiv@anduin.net>
  *
  * This file is part of kBuild.
@@ -132 +132 @@
 #endif
 
+/** Block allocator logging.   */
+//#define KMK_CC_BLOCK_LOGGING_ENABLED
+#ifdef KMK_CC_BLOCK_LOGGING_ENABLED
+# define KMK_CC_BLOCK_DPRINTF_UNPACK(...)           __VA_ARGS__
+# define KMK_CC_BLOCK_DPRINTF(a)                    fprintf(stderr, KMK_CC_BLOCK_DPRINTF_UNPACK a)
+#else
+# define KMK_CC_BLOCK_DPRINTF(a)                    do { } while (0)
+#endif
+
 
 /** @defgroup grp_kmk_cc_evalprog Makefile Evaluation
  * @{
  */
-#if 1
+#define KMK_CC_EVAL_LOGGING_ENABLED
+#ifdef KMK_CC_EVAL_LOGGING_ENABLED
 # define KMK_CC_EVAL_DPRINTF_UNPACK(...)            __VA_ARGS__
 # define KMK_CC_EVAL_DPRINTF(a)                     fprintf(stderr, KMK_CC_EVAL_DPRINTF_UNPACK a)
@@ -150 +160 @@
 #define KMK_CC_EVAL_QUALIFIER_PRIVATE       8
 /** @} */
+
+/** Eval: Max makefile size we accept as input (in bytes). */
+#define KMK_CC_EVAL_MAX_COMPILE_SIZE        (16*1024*1024)
 
 /** Eval: Max nesting depth of makefile conditionals.
@@ -239 +252 @@
 *********************************************************************************************************************************/
 /**
- * Block of expand instructions.
+ * Block of instructions.
  *
  * To avoid wasting space on "next" pointers, as well as a lot of time walking
@@ -567 +580 @@
     kKmkCcEvalInstr_undefine,
 
-
     /** [else] ifdef variable - KMKCCEVALIFDEFPLAIN. */
     kKmkCcEvalInstr_ifdef_plain,
@@ -613 +625 @@
     kKmkCcEvalInstr_recipe_cancel_pattern,
 
+/** @todo target variables. */
+
     /** vpath pattern directories - KMKCCEVALVPATH. */
     kKmkCcEvalInstr_vpath,
@@ -619 +633 @@
     /** vpath - KMKCCEVALCORE. */
     kKmkCcEvalInstr_vpath_clear_all,
+
+    /** Make 'code' needing expanding and evaluation - KMKCCEVALEXPAND.
+     * @note That this could in theory be used to start a recipe.  This will be
+     *       detected by the interpreter and loading will for now fail.  A
+     *       strategy for implement support for it would require picking up
+     *       potential commands following the statements too. */
+    kKmkCcEvalInstr_expand,
 
     /** The end of valid instructions (exclusive). */
@@ -757 +778 @@
     /** The 'if' core structure. */
     KMKCCEVALIFCORE         IfCore;
+    /** Alignment padding, MBZ. */
+    KU32                    uPadding;
     /** The subprogram that will give us the variable name. */
     KMKCCEXPSUBPROG         NameSubprog;
@@ -862 +885 @@
     /** First dependency. */
     uint16_t                iFirstDep;
-    /** Number of ordinary dependnecies. */
+    /** Number of ordinary dependencies. */
     uint16_t                cDeps;
     /** First order only dependency. */
     uint16_t                iFirstOrderOnlyDep;
-    /** Number of ordinary dependnecies. */
+    /** Number of ordinary dependencies. */
     uint16_t                cOrderOnlyDeps;
 
@@ -904 +927 @@
     /** The core instruction. */
     KMKCCEVALCORE           Core;
-    /** The number of search directories. */
+    /** The number of commands. */
     uint32_t                cCommands;
     /** Pointer to the next instruction (subprogs and strings after this one). */
     PKMKCCEVALCORE          pNext;
     /** Commands to add to the current recipe.
-     * Expressions will be expanded and split on space. */
+     * Expressions will be expanded and split on newline? */
     KMKCCEXPSUBPROGORPLAIN  aCommands[1];
 } KMKCCEVALRECIPECOMMANDS;
@@ -938 +961 @@
 /** Calculates the size of an KMKCCEVALVPATH structure for @a a_cFiles files. */
 #define KMKCCEVALVPATH_SIZE(a_cFiles) KMK_CC_SIZEOF_VAR_STRUCT(KMKCCEVALVPATH, aDirs, a_cDirs)
+
+
+/**
+ * Instruction format for kKmkCcEvalInstr_expand.
+ */
+typedef struct kmk_cc_eval_expand
+{
+    /** The core instruction. */
+    KMKCCEVALCORE           Core;
+    /** Alignment padding, MBZ. */
+    KU32                    uPadding;
+    /** The expansion subprogram that to execute and evaluate the output of. */
+    KMKCCEXPSUBPROG         Subprog;
+} KMKCCEVALEXPAND;
+typedef KMKCCEVALEXPAND *PKMKCCEVALEXPAND;
 
 
@@ -1110 +1148 @@
     for (i = 0; i < K_ELEMENTS(g_apszEvalKeywords); i++)
     {
+#ifdef KMK_CC_STRICT
         size_t cch = strlen(g_apszEvalKeywords[i]);
         KMK_CC_ASSERT(cch >= KMK_CC_EVAL_KEYWORD_MIN);
         KMK_CC_ASSERT(cch <= KMK_CC_EVAL_KEYWORD_MAX);
+#endif
 
         KMK_CC_EVAL_BM_OR(g_abEvalCcChars, g_apszEvalKeywords[i][0], KMK_CC_EVAL_CH_1ST_IN_KEYWORD);
@@ -1370 +1410 @@
 {
     PKMKCCBLOCK pBlockTail = *ppBlockTail;
-    if (pBlockTail->offNext & (sizeof(void *) - 1U))
-    {
-        pBlockTail->offNext = KMK_CC_BLOCK_ALIGN_SIZE(pBlockTail->offNext);
+    uint32_t    offNext    = pBlockTail->offNext;
+    if (offNext & (sizeof(void *) - 1U))
+    {
+        pBlockTail->offNext = KMK_CC_BLOCK_ALIGN_SIZE(offNext);
+        KMK_CC_BLOCK_DPRINTF(("kmk_cc_block_realign: offNext=%#x -> %#x\n", offNext, pBlockTail->offNext));
         KMK_CC_ASSERT(pBlockTail->cbBlock - pBlockTail->offNext >= sizeof(KMKCCEXPJUMP));
     }
@@ -1400 +1442 @@
         void *pvRet = (char *)pPrevBlock + pPrevBlock->offNext;
         pPrevBlock->offNext += cb;
+        KMK_CC_BLOCK_DPRINTF(("kmk_cc_block_byte_alloc_grow: %p LB %#x offNext=%#x [prev]\n", pvRet, cb, pPrevBlock->offNext));
         return pvRet;
     }
@@ -1424 +1467 @@
 #endif
 
+    KMK_CC_BLOCK_DPRINTF(("kmk_cc_block_byte_alloc_grow: %p LB %#x offNext=%#x\n", pNewBlock + 1, cb, pNewBlock->offNext));
     return pNewBlock + 1;
 }
@@ -1447 +1491 @@
         void *pvRet = (char *)pBlockTail + pBlockTail->offNext;
         pBlockTail->offNext += cb;
+        KMK_CC_BLOCK_DPRINTF(("kmk_cc_block_byte_alloc: %p LB %#x offNext=%#x\n", pvRet, cb, pBlockTail->offNext));
         return pvRet;
     }
@@ -1517 +1562 @@
     KMK_CC_ASSERT(pOldBlock->offNext <= pOldBlock->cbBlock);
 
+    KMK_CC_BLOCK_DPRINTF(("kmk_cc_block_alloc_exp_grow: %p LB %#x offNext=%#x\n", pRet, cb, pNewBlock->offNext));
     return pRet;
 }
@@ -1535 +1581 @@
     KMK_CC_ASSERT(cbLeft >= sizeof(KMKCCEXPJUMP));
     KMK_CC_ASSERT( (cb & (sizeof(void *) - 1)) == 0 || cb == sizeof(KMKCCEXPCORE) /* final */ );
+    KMK_CC_ASSERT((pBlockTail->offNext & (sizeof(void *) - 1)) == 0);
 
     if (cbLeft >= cb + sizeof(KMKCCEXPJUMP))
@@ -1541 +1588 @@
         pBlockTail->offNext += cb;
         KMK_CC_ASSERT(((size_t)pRet & (sizeof(void *) - 1)) == 0);
+        KMK_CC_BLOCK_DPRINTF(("kmk_cc_block_alloc_exp: %p LB %#x offNext=%#x\n", pRet, cb, pBlockTail->offNext));
         return pRet;
     }
@@ -1586 +1634 @@
     pOldBlock->offNext += sizeof(*pJump);
     KMK_CC_ASSERT(pOldBlock->offNext <= pOldBlock->cbBlock);
-
+    KMK_CC_ASSERT((pNewBlock->offNext & (sizeof(void *) - 1)) == 0);
+
+    KMK_CC_BLOCK_DPRINTF(("kmk_cc_block_alloc_eval_grow: %p LB %#x offNext=%#x (*ppBlockTail=%p, was %p)\n",
+                          pRet, cb, pNewBlock->offNext, *ppBlockTail, pOldBlock));
     return pRet;
 }
@@ -1605 +1656 @@
     KMK_CC_ASSERT(cbLeft >= sizeof(KMKCCEVALJUMP));
     KMK_CC_ASSERT( (cb & (sizeof(void *) - 1)) == 0 );
+    KMK_CC_ASSERT((pBlockTail->offNext & (sizeof(void *) - 1)) == 0);
 
     if (cbLeft >= cb + sizeof(KMKCCEVALJUMP))
@@ -1610 +1662 @@
         PKMKCCEVALCORE pRet = (PKMKCCEVALCORE)((char *)pBlockTail + pBlockTail->offNext);
         pBlockTail->offNext += cb;
+        KMK_CC_BLOCK_DPRINTF(("kmk_cc_block_alloc_eval: %p LB %#x offNext=%#x\n", pRet, cb, pBlockTail->offNext));
         return pRet;
     }
@@ -2912 +2965 @@
 
 
+/**
+ * Tokens (for KMKCCEVALWORD).
+ */
 typedef enum kmk_cc_eval_token
 {
-    /** Invalid token . */
+    /** Invalid token value 0. */
     kKmkCcEvalToken_Invalid = 0,
-
-    /** Assignment: '=' */
-    kKmkCcEvalToken_AssignRecursive,
-    /** Assignment: ':=' */
-    kKmkCcEvalToken_AssignSimple,
-    /** Assignment: '+=' */
-    kKmkCcEvalToken_AssignAppend,
-    /** Assignment: '<=' */
-    kKmkCcEvalToken_AssignPrepend,
-    /** Assignment: '?=' */
-    kKmkCcEvalToken_AssignIfNew,
-    /** Assignment: 'define' */
-    kKmkCcEvalToken_define,
-    /** Unassignment: 'undefine' */
-    kKmkCcEvalToken_undefine,
-
-    /* Assignment modifier: 'local'  */
-    kKmkCcEvalToken_local,
-    /* Assignment modifier: 'override' */
-    kKmkCcEvalToken_override,
-    /* Assignment modifier: 'private' (target variable not inh by deps) */
-    kKmkCcEvalToken_private,
-    /* Assignment modifier / other variable thing: 'export' */
-    kKmkCcEvalToken_export,
-    /* Other variable thing: 'unexport' */
-    kKmkCcEvalToken_unexport,
-
-    kKmkCcEvalToken_ifdef,
-    kKmkCcEvalToken_ifndef,
-    kKmkCcEvalToken_ifeq,
-    kKmkCcEvalToken_ifneq,
-    kKmkCcEvalToken_if1of,
-    kKmkCcEvalToken_ifn1of,
-    kKmkCcEvalToken_if,
-    kKmkCcEvalToken_else,
-    kKmkCcEvalToken_endif,
-
-    kKmkCcEvalToken_include,
-    kKmkCcEvalToken_include_silent,
-    kKmkCcEvalToken_includedep,
-    kKmkCcEvalToken_includedep_queue,
-    kKmkCcEvalToken_includedep_flush,
-
-    kKmkCcEvalToken_colon,
-    kKmkCcEvalToken_double_colon,
-    kKmkCcEvalToken_plus,
-    kKmkCcEvalToken_plus_maybe,
-
-    kKmkCcEvalToken_vpath,
 
     /** Plain word. */
@@ -2971 +2978 @@
     kKmkCcEvalToken_WordWithDollar,
 
+    /** Recipe colon. */
+    kKmkCcEvalToken_colon,
+    /** Recipe double colon.   */
+    kKmkCcEvalToken_double_colon,
+    /** Recipe multi target plus. */
+    kKmkCcEvalToken_plus,
+    /** Recipe multi target plus-maybe (+|). */
+    kKmkCcEvalToken_plus_maybe,
+    /** Recipe semicolon. */
+    kKmkCcEvalToken_semicolon,
+
+    /** End of valid token values (not included). */
     kKmkCcEvalToken_End
 } KMKCCEVALTOKEN;
@@ -3036 +3055 @@
     unsigned            iEscEol;
 
-    /** The current line number (for error handling / debugging). */
+    /** The current line number for error handling / debugging (1-based). */
     unsigned            iLine;
-    /** The start offset of the current line. */
+    /** The start offset (into pchContent) of the current line. */
     size_t              offLine;
     /** Length of the current line, sans the final EOL and comments. */
@@ -3070 +3089 @@
     /** Set if we're working on a recipe. */
     PKMKCCEVALRECIPE    pRecipe;
-    /** Set for ignoring recipes without targets (Sun OS 4 Make). */
+    /** Set for ignoring recipes without targets (SunOS 4 Make). */
     uint8_t             fNoTargetRecipe;
     /** The command prefix character. */
@@ -3141 +3160 @@
 }
 
+
+/**
+ * Translates a makefile source pointer to a line number and offset.
+ *
+ * @returns Line number (1-based)
+ * @param   pCompiler   The compiler state.
+ * @param   pszWhere    There location to translate.
+ * @param   piColumn    Where to return the line offset (1-based).
+ */
+static unsigned kmk_cc_eval_translate_location(PKMKCCEVALCOMPILER pCompiler, const char *pchWhere, unsigned *piColumn)
+{
+    unsigned iLine   = pCompiler->iLine;
+    size_t   offLine = pCompiler->offLine;
+    size_t   off     = pchWhere - pCompiler->pszContent;
+    unsigned i       = 0;
+    while (   i   < pCompiler->cEscEols
+           && off > pCompiler->paEscEols[i].offEol)
+    {
+        offLine = pCompiler->paEscEols[i].offEol + 1 + pCompiler->cchEolSeq;
+        iLine++;
+        i++;
+    }
+    KMK_CC_ASSERT(off <= pCompiler->cchContent);
+    if (piColumn)
+        *piColumn = (unsigned)(off - offLine) + 1;
+    return iLine;
+}
+
+
 static void KMK_CC_FN_NO_RETURN kmk_cc_eval_fatal(PKMKCCEVALCOMPILER pCompiler, const char *pchWhere, const char *pszMsg, ...)
 {
     va_list  va;
-    unsigned iLine = pCompiler->iLine;
-
     log_working_directory(1);
 
@@ -3153 +3199 @@
     if (pchWhere)
     {
-        size_t   offLine = pCompiler->offLine;
-        size_t   off     = pchWhere - pCompiler->pszContent;
-        unsigned i       = 0;
-        while (   i   < pCompiler->cEscEols
-               && off > pCompiler->paEscEols[i].offEol)
-        {
-            offLine = pCompiler->paEscEols[i].offEol + 1 + pCompiler->cchEolSeq;
-            iLine++;
-            i++;
-        }
-        KMK_CC_ASSERT(off <= pCompiler->cchContent);
+        unsigned iColumn;
+        unsigned iLine = kmk_cc_eval_translate_location(pCompiler, pchWhere, &iColumn);
 
         if (pCompiler->pEvalProg->pszVarName)
             fprintf(stderr, "%s:%u:%u: *** fatal parsing error in %s: ",
-                    pCompiler->pEvalProg->pszFilename, iLine, (unsigned)(off - offLine), pCompiler->pEvalProg->pszVarName);
+                    pCompiler->pEvalProg->pszFilename, iLine, iColumn, pCompiler->pEvalProg->pszVarName);
         else
             fprintf(stderr, "%s:%u:%u: *** fatal parsing error: ",
-                    pCompiler->pEvalProg->pszFilename, iLine, (unsigned)(off - offLine));
+                    pCompiler->pEvalProg->pszFilename, iLine, iColumn);
     }
     else if (pCompiler->pEvalProg->pszVarName)
         fprintf(stderr, "%s:%u: *** fatal parsing error in %s: ",
-                pCompiler->pEvalProg->pszFilename, iLine, pCompiler->pEvalProg->pszVarName);
+                pCompiler->pEvalProg->pszFilename, pCompiler->iLine, pCompiler->pEvalProg->pszVarName);
     else
         fprintf(stderr, "%s:%u: *** fatal parsing error: ",
-                pCompiler->pEvalProg->pszFilename, iLine);
+                pCompiler->pEvalProg->pszFilename, pCompiler->iLine);
 
     /*
@@ -3206 +3243 @@
 static void kmk_cc_eval_warn(PKMKCCEVALCOMPILER pCompiler, const char *pchWhere, const char *pszMsg, ...)
 {
-    /** @todo warnings.   */
-    (void)pchWhere;
-    (void)pCompiler;
-    (void)pszMsg;
+    va_list  va;
+
+    log_working_directory(1);
+
+    /*
+     * If we have a pointer location, use it to figure out the exact line and column.
+     */
+    if (pchWhere)
+    {
+        unsigned iColumn;
+        unsigned iLine = kmk_cc_eval_translate_location(pCompiler, pchWhere, &iColumn);
+
+        if (pCompiler->pEvalProg->pszVarName)
+            fprintf(stderr, "%s:%u:%u: *** warning in %s: ",
+                    pCompiler->pEvalProg->pszFilename, iLine, iColumn, pCompiler->pEvalProg->pszVarName);
+        else
+            fprintf(stderr, "%s:%u:%u: *** warning: ",
+                    pCompiler->pEvalProg->pszFilename, iLine, iColumn);
+    }
+    else if (pCompiler->pEvalProg->pszVarName)
+        fprintf(stderr, "%s:%u: *** warning in %s: ",
+                pCompiler->pEvalProg->pszFilename, pCompiler->iLine, pCompiler->pEvalProg->pszVarName);
+    else
+        fprintf(stderr, "%s:%u: *** warning: ",
+                pCompiler->pEvalProg->pszFilename, pCompiler->iLine);
+
+    /*
+     * Print the message.
+     */
+    va_start(va, pszMsg);
+    vfprintf(stderr, pszMsg, va);
+    va_end(va);
+    fputs(".\n", stderr);
 }
 
@@ -3282 +3348 @@
         {
             paDst[i].fSubprog    = 1;
+            kmk_cc_block_realign(pCompiler->ppBlockTail);
             kmk_cc_eval_compile_string_exp_subprog(pCompiler, pszCopy, paSrc[i].cchWord, &paDst[i].u.Subprog);
         }
@@ -3313 +3380 @@
 # define KMK_CC_WORD_COMP_CONST_6(a_pchLine, a_pszWord) \
         (   *(uint32_t const *)(a_pchLine)     == *(uint32_t const *)(a_pszWord) \
-         && ((uint16_t const *)(a_pchLine))[2] == ((uint32_t const *)(a_pszWord))[2] )
+         && ((uint16_t const *)(a_pchLine))[2] == ((uint16_t const *)(a_pszWord))[2] )
 # define KMK_CC_WORD_COMP_CONST_7(a_pchLine, a_pszWord) \
         (   *(uint32_t const *)(a_pchLine)     == *(uint32_t const *)(a_pszWord) \
-         && ((uint16_t const *)(a_pchLine))[2] == ((uint32_t const *)(a_pszWord))[2] \
+         && ((uint16_t const *)(a_pchLine))[2] == ((uint16_t const *)(a_pszWord))[2] \
          && (a_pchLine)[6]                     == (a_pszWord)[6] )
 # define KMK_CC_WORD_COMP_CONST_8(a_pchLine, a_pszWord) \
@@ -4131 +4198 @@
             unsigned cEnsureWords = ((a_cRequiredWords) + 3 /*15*/) & ~(unsigned)3/*15*/; \
             KMK_CC_ASSERT((a_cRequiredWords) < 0x8000); \
-            (a_pCompiler)->paWords = (PKMKCCEVALWORD)xmalloc(cEnsureWords * sizeof((a_pCompiler)->paWords)[0]); \
+            (a_pCompiler)->paWords = (PKMKCCEVALWORD)xrealloc((a_pCompiler)->paWords, \
+                                                              cEnsureWords * sizeof((a_pCompiler)->paWords)[0]); \
         } \
     } while (0)
+
+
+/**
+ * Word parser helper function for dealing with dollars, simple variant that
+ * doesn't need to take multiple lines into account.
+ *
+ * @returns New word length placing us after the
+ * @param   pCompiler   The compiler state.
+ * @param   cchWord     Offset of the dollar into pchWord.
+ * @param   pchWord     The word we're currently parsing.
+ * @param   cchLeft     How much we've got left to parse.
+ */
+K_INLINE size_t kmk_cc_eval_parse_along_dollar_simple(PKMKCCEVALCOMPILER pCompiler, size_t cchWord,
+                                                      const char *pchWord, size_t cchLeft)
+{
+    const size_t cchStart = cchWord;
+    cchWord++;
+    if (cchWord < cchLeft)
+    {
+        /*
+         * Got a $(VAR) or ${VAR} to deal with here.  This may include nested variable
+         * references and span multiple lines (at least for function calls).
+         *
+         * We scan forward till we've found the corresponding closing parenthesis,
+         * considering any open parentheses of the same kind as worth counting, even
+         * if there are no dollar preceeding them, just like GNU make does.
+         *
+         * We leave the other parenthesis type to the expansion compiler to deal with.
+         */
+        unsigned   cOpens = 1;
+        char const chOpen = pchWord[cchWord++];
+        if (chOpen == '(')
+        {
+            for (;;)
+            {
+                if (cchWord < cchLeft)
+                {
+                    char const ch = pchWord[cchWord++];
+                    if (!KMK_CC_EVAL_IS_PAREN_OR_SLASH(ch))
+                    { /* likely */ }
+                    else if (ch == ')')
+                    {
+                        if (--cOpens == 0)
+                            return cchWord;
+                    }
+                    else if (ch == '(')
+                       cOpens++;
+                }
+                else
+                    break;
+            }
+        }
+        else if (chOpen == '{')
+        {
+            for (;;)
+            {
+                if (cchWord < cchLeft)
+                {
+                    char const ch = pchWord[cchWord++];
+                    if (!KMK_CC_EVAL_IS_PAREN_OR_SLASH(ch))
+                    { /* likely */ }
+                    else if (ch == '}')
+                    {
+                        if (--cOpens == 0)
+                            return cchWord;
+                    }
+                    else if (ch == '{')
+                       cOpens++;
+                }
+                else
+                    break;
+            }
+        }
+        else
+            return cchWord;
+
+        /* Unterminated. */
+        if (cOpens == 1)
+            kmk_cc_eval_fatal(pCompiler, &pchWord[cchStart],
+                              "Variable reference is missing '%c'", chOpen == '(' ? ')' : '}');
+        else
+            kmk_cc_eval_fatal(pCompiler, &pchWord[cchStart],
+                              "%u variable references are missing '%c'", cOpens, chOpen == '(' ? ')' : '}');
+    }
+    else
+        kmk_cc_eval_warn(pCompiler, &pchWord[cchWord - 1], "found '$' at end of line");
+    return cchWord;
+}
+
+
+/**
+ * Word parser helper function for dealing with dollars, complicated variant
+ * that takes escaped EOLs into account.
+ *
+ * @returns New word length placing us after the
+ * @param   pCompiler   The compiler state.
+ * @param   cchWord     Offset of the dollar into pchWord.
+ * @param   pchWord     The word we're currently parsing.
+ * @param   cchLeft     How much we've got left to parse.
+ */
+static size_t kmk_cc_eval_parse_along_dollar_esc_eol(PKMKCCEVALCOMPILER pCompiler, size_t cchWord,
+                                                     const char *pchWord, size_t cchLeft)
+{
+    const size_t cchStart = cchWord;
+    cchWord++;
+    if (cchWord < cchLeft)
+    {
+        /*
+         * Got a $(VAR) or ${VAR} to deal with here.  This may include nested variable
+         * references and span multiple lines (at least for function calls).
+         *
+         * We scan forward till we've found the corresponding closing parenthesis,
+         * considering any open parentheses of the same kind as worth counting, even
+         * if there are no dollar preceeding them, just like GNU make does.
+         *
+         * We leave the other parenthesis type to the expansion compiler to deal with.
+         */
+        unsigned   cOpens = 1;
+        char const chOpen = pchWord[cchWord++];
+        if (chOpen == '(')
+        {
+            for (;;)
+            {
+                if (cchWord < cchLeft)
+                {
+                    char const ch = pchWord[cchWord++];
+                    if (!KMK_CC_EVAL_IS_PAREN_OR_SLASH(ch))
+                    { /* likely */ }
+                    else if (ch == ')')
+                    {
+                        if (--cOpens == 0)
+                            return cchWord;
+                    }
+                    else if (ch == '(')
+                       cOpens++;
+                    else if (ch == '\\')
+                    {
+                        unsigned const iEscEol = pCompiler->iEscEol;
+                        if (   iEscEol < pCompiler->cEscEols
+                            && (size_t)(&pchWord[cchWord] - pCompiler->pszContent) == pCompiler->paEscEols[iEscEol].offEsc)
+                        {
+                            cchWord += pCompiler->paEscEols[iEscEol].offEol
+                                     - pCompiler->paEscEols[iEscEol].offEsc
+                                     + pCompiler->cchEolSeq;
+                            pCompiler->iEscEol = iEscEol + 1;
+                        }
+                    }
+                }
+                else
+                    break;
+            }
+        }
+        else if (chOpen == '{')
+        {
+            for (;;)
+            {
+                if (cchWord < cchLeft)
+                {
+                    char const ch = pchWord[cchWord++];
+                    if (!KMK_CC_EVAL_IS_PAREN_OR_SLASH(ch))
+                    { /* likely */ }
+                    else if (ch == '}')
+                    {
+                        if (--cOpens == 0)
+                            return cchWord;
+                    }
+                    else if (ch == '{')
+                       cOpens++;
+                    else if (ch == '\\')
+                    {
+                        unsigned const iEscEol = pCompiler->iEscEol;
+                        if (   iEscEol < pCompiler->cEscEols
+                            && (size_t)(&pchWord[cchWord] - pCompiler->pszContent) == pCompiler->paEscEols[iEscEol].offEsc)
+                        {
+                            cchWord += pCompiler->paEscEols[iEscEol].offEol
+                                     - pCompiler->paEscEols[iEscEol].offEsc
+                                     + pCompiler->cchEolSeq;
+                            pCompiler->iEscEol = iEscEol + 1;
+                        }
+                    }
+                }
+                else
+                    break;
+            }
+        }
+        else
+            return cchWord;
+
+        /* Unterminated. */
+        if (cOpens == 1)
+            kmk_cc_eval_fatal(pCompiler, &pchWord[cchStart],
+                              "Variable reference is missing '%c'", chOpen == '(' ? ')' : '}');
+        else
+            kmk_cc_eval_fatal(pCompiler, &pchWord[cchStart],
+                              "%u variable references are missing '%c'", cOpens, chOpen == '(' ? ')' : '}');
+    }
+    else
+        kmk_cc_eval_warn(pCompiler, &pchWord[cchWord - 1], "found '$' at end of line");
+    return cchWord;
+}
+
 
 /**
@@ -4168 +4437 @@
         {
             size_t          cchSkipAfter = 0;
-            size_t          cchWord      = 1;
+            size_t          cchWord      = 0;
             KMKCCEVALTOKEN  enmToken     = kKmkCcEvalToken_WordPlain;
 
@@ -4176 +4445 @@
                 char ch = pchWord[cchWord];
                 if (!KMK_CC_EVAL_IS_SPACE_OR_DOLLAR(ch))
-                { /* likely */ }
+                    cchWord++;
                 else if (ch == '$')
+                {
                     enmToken = kKmkCcEvalToken_WordWithDollar;
+                    cchWord = kmk_cc_eval_parse_along_dollar_simple(pCompiler, cchWord, pchWord, cchLeft);
+                }
                 else
                     break;
-                cchWord++;
             }
 
@@ -4207 +4478 @@
         {
             size_t          cchSkipAfter = 0;
-            size_t          cchWord      = 1;
+            size_t          cchWord      = 0;
             KMKCCEVALTOKEN  enmToken     = kKmkCcEvalToken_WordPlain;
 
@@ -4215 +4486 @@
                 char ch = pchWord[cchWord];
                 if (!KMK_CC_EVAL_IS_SPACE_DOLLAR_OR_SLASH(ch))
-                { /* likely */ }
+                    cchWord++;
                 else if (ch == '$')
+                {
                     enmToken = kKmkCcEvalToken_WordWithDollar;
+                    cchWord = kmk_cc_eval_parse_along_dollar_esc_eol(pCompiler, cchWord, pchWord, cchLeft);
+                }
                 else if (ch != '\\')
                     break;
-                else if ((size_t)(&pchWord[cchWord] - pszContent) == pCompiler->paEscEols[iEscEol].offEsc)
+                else if ((size_t)(&pchWord[cchWord] - pszContent) != pCompiler->paEscEols[iEscEol].offEsc)
+                    cchWord++;
+                else
                 {
                     cchSkipAfter = pCompiler->paEscEols[iEscEol].offEol - pCompiler->paEscEols[iEscEol].offEsc
@@ -4227 +4503 @@
                     break;
                 }
-                cchWord++;
+            }
+
+            /* Add the word. */
+            KMK_CC_EVAL_ENSURE_WORDS(pCompiler, cWords + 1);
+            pCompiler->paWords[cWords].pchWord  = pchWord;
+            pCompiler->paWords[cWords].cchWord  = cchWord;
+            pCompiler->paWords[cWords].enmToken = enmToken;
+            cWords++;
+
+            /* Skip the work and any trailing blanks. */
+            cchWord += cchSkipAfter;
+            pchWord += cchWord;
+            cchLeft -= cchWord;
+            KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+        } while (cchLeft > 0);
+    }
+    pCompiler->cWords = cWords;
+    return cWords;
+}
+
+
+/**
+ * Parses the remainder of the line into target words.
+ *
+ * The resulting words are classified as either kKmkCcEvalToken_WordPlain or
+ * kKmkCcEvalToken_WordWithDollar.
+ *
+ * @returns Number of words.
+ * @param   pCompiler   The compiler state.
+ * @param   pchWord     Where to start, we expect this to be at a word.
+ * @param   cchLeft     The number of chars left to parse on this line.
+ *                      This is expected to be non-zero.
+ */
+static unsigned kmk_cc_eval_parse_recipe_words(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft)
+{
+    unsigned iEscEol  = pCompiler->iEscEol;
+    unsigned cEscEols = pCompiler->cEscEols;
+    unsigned cWords   = 0;
+
+    /* Precoditions. */
+    KMK_CC_ASSERT(cchLeft > 0);
+    KMK_CC_ASSERT(!KMK_CC_EVAL_IS_SPACE(*pchWord));
+
+    /*
+     * If we don't have to deal with escaped EOLs, the find-end-of word search
+     * becomes a little bit simpler.  Since this function will be used a lot
+     * for simple lines with single words, this could maybe save a nano second
+     * or two.
+     */
+    if (iEscEol >= cEscEols)
+    {
+        do
+        {
+            size_t          cchSkipAfter = 0;
+            size_t          cchWord      = 0;
+            KMKCCEVALTOKEN  enmToken     = kKmkCcEvalToken_WordPlain;
+
+            /* Find the end of the current word. */
+            while (cchWord < cchLeft)
+            {
+                char ch = pchWord[cchWord];
+                if (!KMK_CC_EVAL_IS_SPACE_OR_DOLLAR(ch))
+                    cchWord++;
+                else if (ch == '$')
+                {
+                    enmToken = kKmkCcEvalToken_WordWithDollar;
+                    cchWord = kmk_cc_eval_parse_along_dollar_simple(pCompiler, cchWord, pchWord, cchLeft);
+                }
+                else
+                    break;
+            }
+
+            /* Add the word. */
+            KMK_CC_EVAL_ENSURE_WORDS(pCompiler, cWords + 1);
+            pCompiler->paWords[cWords].pchWord  = pchWord;
+            pCompiler->paWords[cWords].cchWord  = cchWord;
+            pCompiler->paWords[cWords].enmToken = enmToken;
+            cWords++;
+
+            /* Skip the work and any trailing blanks. */
+            cchWord += cchSkipAfter;
+            pchWord += cchWord;
+            cchLeft -= cchWord;
+            KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+        } while (cchLeft > 0);
+    }
+    /*
+     * Have to deal with escaped EOLs.
+     */
+    else
+    {
+        const char *pszContent = pCompiler->pszContent;
+        do
+        {
+            size_t          cchSkipAfter = 0;
+            size_t          cchWord      = 0;
+            KMKCCEVALTOKEN  enmToken     = kKmkCcEvalToken_WordPlain;
+
+            /* Find the end of the current word. */
+            while (cchWord < cchLeft)
+            {
+                char ch = pchWord[cchWord];
+                if (!KMK_CC_EVAL_IS_SPACE_DOLLAR_OR_SLASH(ch))
+                    cchWord++;
+                else if (ch == '$')
+                {
+                    enmToken = kKmkCcEvalToken_WordWithDollar;
+                    cchWord = kmk_cc_eval_parse_along_dollar_esc_eol(pCompiler, cchWord, pchWord, cchLeft);
+                }
+                else if (ch != '\\')
+                    break;
+                else if ((size_t)(&pchWord[cchWord] - pszContent) != pCompiler->paEscEols[iEscEol].offEsc)
+                    cchWord++;
+                else
+                {
+                    cchSkipAfter = pCompiler->paEscEols[iEscEol].offEol - pCompiler->paEscEols[iEscEol].offEsc
+                                 + pCompiler->cchEolSeq;
+                    iEscEol++;
+                    break;
+                }
             }
 
@@ -4788 +5183 @@
             pInstr->IfCore.Core.enmOpcode = fPositiveStmt ? kKmkCcEvalInstr_ifdef_dynamic : kKmkCcEvalInstr_ifndef_dynamic;
             pInstr->IfCore.Core.iLine     = pCompiler->iLine;
+            pInstr->uPadding              = 0;
             kmk_cc_eval_compile_string_exp_subprog(pCompiler, pszCopy, cchCopy, &pInstr->NameSubprog);
 
@@ -5334 +5730 @@
 
 
+/**
+ * Called when any previous recipe must have ended and can be finalized.
+ *
+ * This occurs when encountering an assignement, a new recipe or the end of the
+ * complication unit.
+ *
+ * @param   pCompiler   The compiler state.
+ */
+static void kmk_cc_eval_end_of_recipe(PKMKCCEVALCOMPILER pCompiler, const char *pchWord)
+{
+    if (pCompiler->pRecipe)
+    {
+        /** @todo do stuff here. */
+        kmk_cc_eval_fatal(pCompiler, pchWord, "end-of-recipe handling not implemented yet");
+    }
+}
+
+
 static void kmk_cc_eval_handle_command(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft)
 {
@@ -5340 +5754 @@
 
 
+/**
+ * Pick up the recipe parsing at the colon.
+ *
+ * @returns 1 to indicate we've handled a keyword (see
+ *          kmk_cc_eval_try_handle_keyword).
+ * @param   pCompiler   The compiler state.
+ * @param   pchWord0    The first word.
+ * @param   cchWord0    The length of the first word.
+ * @param   enmToken0   The classification of the first word.
+ * @param   pchColon    The colon.
+ * @param   cchLeft     How much is left, starting at the colon.
+ */
 static int kmk_cc_eval_handle_recipe_cont_colon(PKMKCCEVALCOMPILER pCompiler, const char *pchWord0, size_t cchWord0,
-                                                const char *pchColon, size_t cchLeft, unsigned fQualifiers)
+                                                KMKCCEVALTOKEN enmToken0, const char *pchColon, size_t cchLeft)
 {
     kmk_cc_eval_fatal(pCompiler, pchWord0, "recipe handling not implemented yet (#1)");
@@ -5348 +5774 @@
 
 
+/**
+ * Pick up the recipe parsing at the 2nd word (after it was determined not to be
+ * an assignment operator after all).
+ *
+ * @returns 1 to indicate we've handled a keyword (see
+ *          kmk_cc_eval_try_handle_keyword).
+ * @param   pCompiler   The compiler state.
+ * @param   pchWord0    The first word.
+ * @param   cchWord0    The length of the first word.
+ * @param   pchWord     Where to continue parsing.
+ * @param   cchLeft     How much is left to parse.
+ */
 static int kmk_cc_eval_handle_recipe_cont_2nd_word(PKMKCCEVALCOMPILER pCompiler, const char *pchWord0, size_t cchWord0,
-                                                   const char *pchWord, size_t cchLeft, unsigned fQualifiers)
-{
+                                                   const char *pchWord, size_t cchLeft)
+{
+//    const char *pchColon = memchr()
+
     kmk_cc_eval_fatal(pCompiler, pchWord, "recipe handling not implemented yet (#2)");
     return 1;
@@ -5356 +5796 @@
 
 
-static void kmk_cc_eval_handle_recipe(PKMKCCEVALCOMPILER pCompiler, const char *pszEqual, const char *pchWord, size_t cchLeft)
-{
-    kmk_cc_eval_fatal(pCompiler, pchWord, "recipe handling not implemented yet (#3)");
-}
-
-static void kmk_cc_eval_end_of_recipe(PKMKCCEVALCOMPILER pCompiler)
-{
-    if (pCompiler->pRecipe)
-    {
-        /** @todo do stuff here. */
-    }
-}
+static void kmk_cc_eval_handle_recipe(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft)
+{
+    const char *pszColon = NULL;//memchr(pchWord, cchLeft);
+    if (pszColon)
+    {
+
+
+        kmk_cc_eval_fatal(pCompiler, pchWord, "recipe handling not implemented yet (#3)");
+    }
+    else if (pchWord[0] == '$')
+    {
+
+    }
+    else
+        kmk_cc_eval_fatal(pCompiler, pchWord,
+                          "Not variable assignment. Could be a complicated indirect recipe definition, however that's currently not supported.");
+
+}
+
 
 
@@ -5392 +5839 @@
          */
         unsigned cWords = kmk_cc_eval_parse_words(pCompiler, pchWord, cchLeft);
+#ifdef KMK_CC_EVAL_LOGGING_ENABLED
+        unsigned iWord;
         KMK_CC_EVAL_DPRINTF(("%s: cWords=%d\n", g_apszEvalInstrNms[enmOpcode], cWords));
+        for (iWord = 0; iWord < cWords; iWord++)
+            KMK_CC_EVAL_DPRINTF(("  word[%u]: len=%#05x t=%d '%*.*s'\n", iWord, (int)pCompiler->paWords[iWord].cchWord,
+                                 (int)pCompiler->paWords[iWord].enmToken, (int)pCompiler->paWords[iWord].cchWord,
+                                 (int)pCompiler->paWords[iWord].cchWord, pCompiler->paWords[iWord].pchWord));
+#endif
         if (cWords)
         {
@@ -5399 +5853 @@
             pInstr->Core.enmOpcode = enmOpcode;
             pInstr->Core.iLine     = pCompiler->iLine;
-            pInstr->cVars         = cWords;
+            pInstr->cVars          = cWords;
             kmk_cc_eval_init_spp_array_from_duplicated_words(pCompiler, cWords, pCompiler->paWords, pInstr->aVars);
             kmk_cc_block_realign(pCompiler->ppBlockTail);
@@ -5487 +5941 @@
 static int kmk_cc_eval_do_var_define(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft, unsigned fQualifiers)
 {
-
     KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
     kmk_cc_eval_fatal(pCompiler, pchWord, "define handling not implemented yet");
+    return 1;
+}
+
+
+/**
+ * Emits a 'expand(-and-eval)' instruction.
+ *
+ * @returns 1 to indicate we've handled a keyword (see
+ *          kmk_cc_eval_try_handle_keyword).
+ * @param   pCompiler   The compiler state.
+ * @param   pchSubprog  The subprogram that needs expanding.
+ * @param   cchSubprog  The length of the subprogram.
+ * @param   iEscEol     The escaped EOL index corresponding to pchSubprog.
+ */
+static int kmk_cc_eval_emit_expand(PKMKCCEVALCOMPILER pCompiler, const char *pchSubprog, size_t cchSubprog, unsigned iEscEolVarNm)
+{
+    /*
+     * We're unexporting all variables.
+     */
+    size_t           cchCopy;
+    char            *pszCopy;
+    PKMKCCEVALEXPAND pInstr;
+
+    pCompiler->iEscEol = iEscEolVarNm;
+    cchCopy = kmk_cc_eval_prep_normal_line_ex(pCompiler, pchSubprog, cchSubprog);
+    pszCopy = kmk_cc_eval_strdup_prepped(pCompiler, cchCopy);
+    kmk_cc_block_realign(pCompiler->ppBlockTail);
+
+    pInstr = (PKMKCCEVALEXPAND)kmk_cc_block_alloc_eval(pCompiler->ppBlockTail, sizeof(*pInstr));
+    pInstr->Core.enmOpcode = kKmkCcEvalInstr_expand;
+    pInstr->Core.iLine     = pCompiler->iLine;
+    pInstr->uPadding       = 0;
+    /** @todo Make the subprogram embed necessary strings. */
+    kmk_cc_eval_compile_string_exp_subprog(pCompiler, pszCopy, cchCopy, &pInstr->Subprog);
+
     return 1;
 }
@@ -5508 +5996 @@
     size_t          cchVarNm;
     size_t          cch = 0;
+    size_t          cchSubprog = 0;
     char            ch;
 
@@ -5520 +6009 @@
         { /*likely*/ }
         else
-            kmk_cc_eval_fatal(pCompiler, &pchWord[cch], "Neither recipe nor variable assignment");
+        {
+            /* Single word, join paths with word + whitespace. */
+            KMK_CC_ASSERT(cch == cchLeft);
+            cchVarNm = cch;
+            pchWord += cch;
+            cchLeft -= cch;
+            break;
+        }
 
         ch = pchWord[cch];
@@ -5537 +6033 @@
         else if (ch == '$')
         {
+            size_t const offStart = cch;
             cch++;
             if (cch < cchLeft)
@@ -5602 +6099 @@
                 kmk_cc_eval_fatal(pCompiler, &pchWord[cch], "Neither recipe nor variable assignment");
             fPlainVarNm = 0;
+            cchSubprog += cch - offStart;
         }
-        /* Check out potential recipe. */
+        /* Check out potential recipe, simple assignment or DOS drive letter separator. */
         else if (ch == ':')
         {
@@ -5618 +6116 @@
                     C:/Windows/System32/Kernel32.dll: C:/Windows/System32/NtDll.dll
                for a recipe, it is only the second one which counts. */
-            else if (   cch == 1
-                     && isalpha((unsigned char)pchWord[0]))
+            if (   cch == 1
+                && isalpha((unsigned char)pchWord[0]))
                 cch++;
+            else
 #endif
-            else
-                return kmk_cc_eval_handle_recipe_cont_colon(pCompiler, pchWord, cch, pchWord + cch, cchLeft - cch, fQualifiers);
+            if (!fQualifiers)
+                return kmk_cc_eval_handle_recipe_cont_colon(pCompiler, pchWord, cch,
+                                                            fPlainVarNm
+                                                            ? kKmkCcEvalToken_WordPlain : kKmkCcEvalToken_WordWithDollar,
+                                                            pchWord + cch, cchLeft - cch);
+            /** @todo we may have words already preparsed here so restarting is easy...  */
+            return 0; /* retry with preceeding keywords */
         }
         /* Check out assignment operator. */
         else if (ch == '=')
         {
-            if (cch)
+            if (cch > 0)
             {
                 char chPrev = pchWord[cch - 1];
@@ -5638 +6142 @@
                 break;
             }
-            else
-                kmk_cc_eval_fatal(pCompiler, pchWord, "Empty variable name.");
+            kmk_cc_eval_fatal(pCompiler, pchWord, "Empty variable name.");
         }
         /* Check out potential escaped EOL sequence. */
@@ -5697 +6200 @@
             else if (ch == '?')
                 enmOpCode = kKmkCcEvalInstr_assign_if_new;
+            else if (!fQualifiers)
+                return kmk_cc_eval_handle_recipe_cont_2nd_word(pCompiler, pchVarNm, cchVarNm, pchWord, cchLeft);
             else
-                return kmk_cc_eval_handle_recipe_cont_2nd_word(pCompiler, pchVarNm, cchVarNm, pchWord, cchLeft, fQualifiers);
+                return 0; /* retry without preceding keywords */
             pchWord += 2;
             cchLeft -= 2;
         }
+        else if (!fQualifiers)
+            return kmk_cc_eval_handle_recipe_cont_2nd_word(pCompiler, pchVarNm, cchVarNm, pchWord, cchLeft);
         else
-            return kmk_cc_eval_handle_recipe_cont_2nd_word(pCompiler, pchVarNm, cchVarNm, pchWord, cchLeft, fQualifiers);
+            return 0; /* retry without preceding keywords */
 
         /*
@@ -5712 +6219 @@
         fPlainValue = memchr(pchWord, '$', cchLeft) == NULL;
 
-
         /*
          * Emit the instruction.
          */
-        kmk_cc_eval_end_of_recipe(pCompiler);
+        kmk_cc_eval_end_of_recipe(pCompiler, pchWord);
 
         pInstr = (PKMKCCEVALASSIGN)kmk_cc_block_alloc_eval(pCompiler->ppBlockTail, sizeof(*pInstr));
@@ -5745 +6251 @@
         pInstr->pNext = (PKMKCCEVALCORE)kmk_cc_block_get_next_ptr(*pCompiler->ppBlockTail);
     }
+    /*
+     * This could be one or more function calls.
+     */
+    else if (!fPlainVarNm && cchVarNm == cchSubprog && fQualifiers == 0)
+        return kmk_cc_eval_emit_expand(pCompiler, pchVarNm, cchVarNm, iEscEolVarNm);
+    else if (!fPlainVarNm)
+        kmk_cc_eval_fatal(pCompiler, pchWord,
+                          "Not variable assignment. Could be a complicated indirect recipe definition, however that's currently not supported.");
     else
         kmk_cc_eval_fatal(pCompiler, pchWord, "Neither recipe nor variable assignment");
@@ -6181 +6695 @@
                     if (pszContent[offNext] == '#')
                     {
-                        KMK_CC_EVAL_DPRINTF(("#%03u: <comment>\n", Compiler.iLine));
+                        KMK_CC_EVAL_DPRINTF(("#%03u: <comment-col-0>\n", Compiler.iLine));
                         Compiler.iLine++;
                         offNext = pchTmp - pszContent;
@@ -6332 +6846 @@
                     char        ch;
 
-                    Compiler.cchLineWithComments =  cchLine;
+                    Compiler.cchLineWithComments = cchLine;
                     pchTmp = (const char *)memchr(pchWord, '#', cchLeft);
                     if (pchTmp)
@@ -6341 +6855 @@
                     Compiler.cchLine = cchLine;
                     Compiler.offLine = off;
+
+#ifdef KMK_CC_STRICT
+                    Compiler.cWords = 0x424242;
+#endif
 
                     /*
@@ -6355 +6873 @@
                             kmk_cc_eval_handle_assignment_or_recipe(&Compiler, pchWord, cchLeft, 0 /*fQualifiers*/);
                         else
-                            kmk_cc_eval_handle_recipe(&Compiler, pchTmp, pchWord, cchLeft);
+                            kmk_cc_eval_handle_recipe(&Compiler, pchWord, cchLeft);
                     }
                     /* else: handled a keyword expression */
@@ -6472 +6990 @@
     if (!fstat(fileno(pFile), &st))
     {
-        if (   st.st_size > (off_t)16*1024*1024
+        if (   st.st_size > (off_t)KMK_CC_EVAL_MAX_COMPILE_SIZE
             && st.st_size < 0)
-            fatal(NULL, _("Makefile too large to compile: %ld bytes (%#lx) - max 16MB"), (long)st.st_size, (long)st.st_size);
+            fatal(NULL, _("Makefile too large to compile: %ld bytes (%#lx) - max %uMB"),
+                  (long)st.st_size, (long)st.st_size, KMK_CC_EVAL_MAX_COMPILE_SIZE / 1024 / 1024);
         cchContent = (size_t)st.st_size;
         pszContent = (char *)xmalloc(cchContent + 1);
@@ -6488 +7007 @@
         {
             cbAllocated *= 2;
-            if (cbAllocated > 16*1024*1024)
-                fatal(NULL, _("Makefile too large to compile: max 16MB"));
+            if (cbAllocated > KMK_CC_EVAL_MAX_COMPILE_SIZE)
+                fatal(NULL, _("Makefile too large to compile: max %uMB"), KMK_CC_EVAL_MAX_COMPILE_SIZE / 1024 / 1024);
             pszContent = (char *)xrealloc(pszContent, cbAllocated);
             cchContent += fread(&pszContent[cchContent], 1, cbAllocated - 1 - cchContent, pFile);
@@ -6532 +7051 @@
     KMK_CC_ASSERT(pEvalProg);
     assert(0);
+
 }
 

trunk/src/kmk/kmk_cc_exec.h

@@ -5 +5 @@
 
 /*
- * Copyright (c) 2015 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
+ * Copyright (c) 2015-2017 knut st. osmundsen <bird-kBuild-spam-xviiv@anduin.net>
  *
  * This file is part of kBuild.
@@ -24 +24 @@
  */
 
-#ifndef ___kmk_cc_and_exech
-#define ___kmk_cc_and_exech
+#ifndef ___kmk_cc_and_exec_h
+#define ___kmk_cc_and_exec_h
 #ifdef CONFIG_WITH_COMPILER