Index: trunk/src/kmk/kmk_cc_exec.c
===================================================================
--- trunk/src/kmk/kmk_cc_exec.c	(revision 2801)
+++ trunk/src/kmk/kmk_cc_exec.c	(revision 2802)
@@ -556,7 +556,7 @@
     kKmkCcEvalInstr_assign_define,
 
-    /** export variable1 [variable2...] - KMKCCEVALEXPORT. */
+    /** export variable1 [variable2...] - KMKCCEVALVARIABLES. */
     kKmkCcEvalInstr_export,
-    /** unexport variable1 [variable2...] - KMKCCEVALEXPORT. */
+    /** unexport variable1 [variable2...] - KMKCCEVALVARIABLES. */
     kKmkCcEvalInstr_unexport,
     /** export - KMKCCEVALCORE. */
@@ -564,4 +564,7 @@
     /** unexport - KMKCCEVALCORE. */
     kKmkCcEvalInstr_unexport_all,
+    /** [local|override] undefine - KMKCCEVALVARIABLES. */
+    kKmkCcEvalInstr_undefine,
+
 
     /** [else] ifdef variable - KMKCCEVALIFDEFPLAIN. */
@@ -688,7 +691,8 @@
 
 /**
- * Instruction format for kKmkCcEvalInstr_export and kKmkCcEvalInstr_unexport.
- */
-typedef struct kmk_cc_eval_export
+ * Instruction format for kKmkCcEvalInstr_export, kKmkCcEvalInstr_unexport and
+ * kKmkCcEvalInstr_undefine.
+ */
+typedef struct kmk_cc_eval_variables
 {
     /** The core instruction. */
@@ -696,4 +700,6 @@
     /** The number of variables named in aVars. */
     uint32_t                cVars;
+    /** Whether the 'local' qualifier was used (undefine only). */
+    uint8_t                 fLocal;
     /** Pointer to the next instruction. */
     PKMKCCEVALCORE          pNext;
@@ -702,8 +708,8 @@
      * @remarks Plain text names are in variable_strcache. */
     KMKCCEXPSUBPROGORPLAIN  aVars[1];
-} KMKCCEVALEXPORT;
-typedef KMKCCEVALEXPORT *PKMKCCEVALEXPORT;
-/** Calculates the size of an KMKCCEVALEXPORT structure for @a a_cVars. */
-#define KMKCCEVALEXPORT_SIZE(a_cVars) KMK_CC_SIZEOF_VAR_STRUCT(KMKCCEVALVPATH, aVars, a_cVars)
+} KMKCCEVALVARIABLES;
+typedef KMKCCEVALVARIABLES *PKMKCCEVALVARIABLES;
+/** Calculates the size of an KMKCCEVALVARIABLES structure for @a a_cVars. */
+#define KMKCCEVALVARIABLES_SIZE(a_cVars) KMK_CC_SIZEOF_VAR_STRUCT(KMKCCEVALVARIABLES, aVars, a_cVars)
 
 /**
@@ -1115,5 +1121,5 @@
     KMK_CC_EVAL_BM_OR(g_abEvalCcChars, 'o', KMK_CC_EVAL_CH_1ST_IN_VARIABLE_KEYWORD); /* override */
     KMK_CC_EVAL_BM_OR(g_abEvalCcChars, 'p', KMK_CC_EVAL_CH_1ST_IN_VARIABLE_KEYWORD); /* private */
-    KMK_CC_EVAL_BM_OR(g_abEvalCcChars, 'u', KMK_CC_EVAL_CH_1ST_IN_VARIABLE_KEYWORD); /* undefine */
+    KMK_CC_EVAL_BM_OR(g_abEvalCcChars, 'u', KMK_CC_EVAL_CH_1ST_IN_VARIABLE_KEYWORD); /* undefine, unexport */
 
     /* Assignment punctuation and recipe stuff. */
@@ -3391,6 +3397,12 @@
          && (a_pchLine)[15] == (a_pszWord)[15])
 #endif
+
+/** See if the given string match a constant string. */
+#define KMK_CC_STRCMP_CONST(a_pchLeft, a_cchLeft, a_pszConst, a_cchConst) \
+    (   (a_cchLeft) == (a_cchConst) \
+     && KMK_CC_WORD_COMP_CONST_##a_cchConst(a_pchLeft, a_pszConst) )
+
 /** See if a starting of a given length starts with a constant word. */
-#define KMK_CC_WORD_COMP_IS_EOL(a_pCompiler, a_pchLine, a_cchLine) \
+#define KMK_CC_EVAL_WORD_COMP_IS_EOL(a_pCompiler, a_pchLine, a_cchLine) \
     (   (a_cchLine) == 0 \
      || KMK_CC_EVAL_IS_SPACE((a_pchLine)[0]) \
@@ -3398,5 +3410,5 @@
 
 /** See if a starting of a given length starts with a constant word. */
-#define KMK_CC_WORD_COMP_CONST(a_pCompiler, a_pchLine, a_cchLine, a_pszWord, a_cchWord) \
+#define KMK_CC_EVAL_WORD_COMP_CONST(a_pCompiler, a_pchLine, a_cchLine, a_pszWord, a_cchWord) \
     (    (a_cchLine) >= (a_cchWord) \
       && (   (a_cchLine) == (a_cchWord) \
@@ -5187,23 +5199,23 @@
             cchLeft -= 2;
 
-            if (KMK_CC_WORD_COMP_IS_EOL(pCompiler, pchWord, cchLeft))
+            if (KMK_CC_EVAL_WORD_COMP_IS_EOL(pCompiler, pchWord, cchLeft))
                 return kmk_cc_eval_do_if(pCompiler, pchWord, cchLeft, 1 /* in else */);
 
-            if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "eq", 2))
+            if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "eq", 2))
                 return kmk_cc_eval_do_ifeq( pCompiler, pchWord + 2, cchLeft - 2, 1 /* in else */, 1 /* positive */);
 
-            if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "def", 3))
+            if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "def", 3))
                 return kmk_cc_eval_do_ifdef(pCompiler, pchWord + 3, cchLeft - 3, 1 /* in else */, 1 /* positive */);
 
-            if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "neq", 3))
+            if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "neq", 3))
                 return kmk_cc_eval_do_ifeq( pCompiler, pchWord + 3, cchLeft - 3, 1 /* in else */, 0 /* positive */);
 
-            if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "1of", 3))
+            if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "1of", 3))
                 return kmk_cc_eval_do_if1of(pCompiler, pchWord + 3, cchLeft - 3, 1 /* in else */, 1 /* positive */);
 
-            if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "ndef", 4))
+            if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "ndef", 4))
                 return kmk_cc_eval_do_ifdef(pCompiler, pchWord + 4, cchLeft - 4, 1 /* in else */, 0 /* positive */);
 
-            if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "n1of", 4))
+            if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "n1of", 4))
                 return kmk_cc_eval_do_if1of(pCompiler, pchWord + 4, cchLeft - 4, 1 /* in else */, 0 /* positive */);
 
@@ -5300,5 +5312,5 @@
                                                                                   KMKCCEVALINCLUDE_SIZE(cWords));
             pInstr->Core.enmOpcode = enmOpcode;
-            pInstr->Core.iLine     = 0;
+            pInstr->Core.iLine     = pCompiler->iLine;
             pInstr->cFiles         = cWords;
             kmk_cc_eval_init_spp_array_from_duplicated_words(pCompiler, cWords, pCompiler->paWords, pInstr->aFiles);
@@ -5330,5 +5342,5 @@
                                                 const char *pchColon, size_t cchLeft, unsigned fQualifiers)
 {
-    kmk_cc_eval_fatal(pCompiler, pchWord0, "recipe handling not implemented yet");
+    kmk_cc_eval_fatal(pCompiler, pchWord0, "recipe handling not implemented yet (#1)");
     return 1;
 }
@@ -5338,5 +5350,5 @@
                                                    const char *pchWord, size_t cchLeft, unsigned fQualifiers)
 {
-    kmk_cc_eval_fatal(pCompiler, pchWord, "recipe handling not implemented yet");
+    kmk_cc_eval_fatal(pCompiler, pchWord, "recipe handling not implemented yet (#2)");
     return 1;
 }
@@ -5345,5 +5357,5 @@
 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");
+    kmk_cc_eval_fatal(pCompiler, pchWord, "recipe handling not implemented yet (#3)");
 }
 
@@ -5358,5 +5370,46 @@
 
 /**
- * Parses a 'undefine variable [..]' expression.
+ * Common worker for handling export (non-assign), undefine and unexport.
+ *
+ * For instructions using the KMKCCEVALVARIABLES structure.
+ *
+ * @returns 1 to indicate we've handled a keyword (see
+ *          kmk_cc_eval_try_handle_keyword).
+ * @param   pCompiler   The compiler state.
+ * @param   pchWord     First non-space chare after the keyword.
+ * @param   cchLeft     The number of chars left to parse on this line.
+ * @param   fQualifiers The qualifiers.
+ */
+static int kmk_cc_eval_do_with_variable_list(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft,
+                                             KMKCCEVALINSTR enmOpcode, unsigned fQualifiers)
+{
+    if (cchLeft)
+    {
+        /*
+         * Parse the variable name list.  GNU make is using normal word
+         * handling here, so we can share code with the include directives.
+         */
+        unsigned cWords = kmk_cc_eval_parse_words(pCompiler, pchWord, cchLeft);
+        KMK_CC_EVAL_DPRINTF(("%s: cWords=%d\n", g_apszEvalInstrNms[enmOpcode], cWords));
+        if (cWords)
+        {
+            PKMKCCEVALVARIABLES pInstr = (PKMKCCEVALVARIABLES)kmk_cc_block_alloc_eval(pCompiler->ppBlockTail,
+                                                                                      KMKCCEVALVARIABLES_SIZE(cWords));
+            pInstr->Core.enmOpcode = enmOpcode;
+            pInstr->Core.iLine     = pCompiler->iLine;
+            pInstr->cVars         = cWords;
+            kmk_cc_eval_init_spp_array_from_duplicated_words(pCompiler, cWords, pCompiler->paWords, pInstr->aVars);
+            kmk_cc_block_realign(pCompiler->ppBlockTail);
+        }
+        else
+            KMK_CC_ASSERT(0);
+    }
+    /* else: NOP */
+    return 1;
+}
+
+
+/**
+ * Parses a '[qualifiers] undefine variable [..]' expression.
  *
  * A 'undefine' directive is final, any qualifiers must preceed it.  So, we just
@@ -5372,15 +5425,20 @@
 static int kmk_cc_eval_do_var_undefine(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft, unsigned fQualifiers)
 {
-    kmk_cc_eval_fatal(pCompiler, pchWord, "undefine handling not implemented yet");
-    return 1;
-}
-
-
-/**
- * Parses a 'define variable' expression.
- *
- * A 'define' directive is final, any qualifiers must preceed it.  So, we just
- * have to extract the variable name now, well and find the corresponding
- * 'endef'.
+    KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+    if (!cchLeft)
+        kmk_cc_eval_fatal(pCompiler, pchWord, "undefine requires a variable name");
+
+    /** @todo GNU make doesn't actually do the list thing for undefine, it seems
+     *        to assume everything after it is a single variable...  Going with
+     *        simple common code for now. */
+    return kmk_cc_eval_do_with_variable_list(pCompiler, pchWord, cchLeft, kKmkCcEvalInstr_undefine, fQualifiers);
+}
+
+
+/**
+ * Parses a '[qualifiers] unexport variable [..]' expression.
+ *
+ * A 'unexport' directive is final, any qualifiers must preceed it.  So, we just
+ * have to extract the variable names now.
  *
  * @returns 1 to indicate we've handled a keyword (see
@@ -5391,4 +5449,37 @@
  * @param   fQualifiers The qualifiers.
  */
+static int kmk_cc_eval_do_var_unexport(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft, unsigned fQualifiers)
+{
+    /*
+     * Join paths with undefine and export, unless it's an unexport all directive.
+     */
+    KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+    if (cchLeft)
+        return kmk_cc_eval_do_with_variable_list(pCompiler, pchWord, cchLeft, kKmkCcEvalInstr_unexport, fQualifiers);
+
+    /*
+     * We're unexporting all variables.
+     */
+    PKMKCCEVALCORE pInstr = kmk_cc_block_alloc_eval(pCompiler->ppBlockTail, sizeof(*pInstr));
+    pInstr->enmOpcode = kKmkCcEvalInstr_unexport_all;
+    pInstr->iLine     = pCompiler->iLine;
+    return 1;
+}
+
+
+/**
+ * Parses a 'define variable' expression.
+ *
+ * A 'define' directive is final, any qualifiers must preceed it.  So, we just
+ * have to extract the variable name now, well and find the corresponding
+ * 'endef'.
+ *
+ * @returns 1 to indicate we've handled a keyword (see
+ *          kmk_cc_eval_try_handle_keyword).
+ * @param   pCompiler   The compiler state.
+ * @param   pchWord     First char after 'define'.
+ * @param   cchLeft     The number of chars left to parse on this line.
+ * @param   fQualifiers The qualifiers.
+ */
 static int kmk_cc_eval_do_var_define(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft, unsigned fQualifiers)
 {
@@ -5400,6 +5491,6 @@
 
 
-static int kmk_cc_eval_handle_assignment_or_recipe(PKMKCCEVALCOMPILER pCompiler, const char *pchTmp,
-                                                   const char *pchWord, size_t cchLeft, unsigned fQualifiers)
+static int kmk_cc_eval_handle_assignment_or_recipe(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft,
+                                                   unsigned fQualifiers)
 {
     /*
@@ -5618,4 +5709,5 @@
         fPlainValue = memchr(pchWord, '$', cchLeft) == NULL;
 
+
         /*
          * Emit the instruction.
@@ -5657,5 +5749,6 @@
 
 /**
- * Parses a 'local [override] variable = value' expression.
+ * Parses a 'local [override] variable = value', 'local define variable', and
+ * 'local undefine variable [...]' expressions.
  *
  * The 'local' directive must be first and it does not permit any qualifiers at
@@ -5675,31 +5768,18 @@
     {
         /*
-         * Find the end of the variable name.
+         * Check for 'local define' and 'local undefine'
          */
-
-    }
-    else
-        kmk_cc_eval_fatal(pCompiler, pchWord, "Expected variable name, assignment operator and value after 'local'");
-    return 1;
-}
-
-
-/**
- * Parses 'export [variable]' and 'export [qualifiers] variable = value'
- * expressions.
- *
- * When we find the 'export' directive at the start of a line, we need to
- * continue parsing with till we can tell the difference between the two forms.
- *
- * @returns 1 to indicate we've handled a keyword (see
- *          kmk_cc_eval_try_handle_keyword).
- * @param   pCompiler   The compiler state.
- * @param   pchWord     First char after 'define'.
- * @param   cchLeft     The number of chars left to parse on this line.
- * @param   fQualifiers The qualifiers.
- */
-static int kmk_cc_eval_handle_var_export(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft, unsigned fQualifiers)
-{
-    kmk_cc_eval_fatal(pCompiler, pchWord, "export not implemented yet");
+        if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "define", 6))   /* final */
+            return kmk_cc_eval_do_var_define(pCompiler, pchWord + 6, cchLeft + 6, KMK_CC_EVAL_QUALIFIER_LOCAL);
+        if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "undefine", 8))   /* final */
+            return kmk_cc_eval_do_var_undefine(pCompiler, pchWord + 8, cchLeft + 8, KMK_CC_EVAL_QUALIFIER_LOCAL);
+
+        /*
+         * Simpler to just join paths with the rest here, even if we could
+         * probably optimize the parsing a little if we liked.
+         */
+        return kmk_cc_eval_handle_assignment_or_recipe(pCompiler, pchWord, cchLeft, KMK_CC_EVAL_QUALIFIER_LOCAL);
+    }
+    kmk_cc_eval_fatal(pCompiler, pchWord, "Expected variable name, assignment operator and value after 'local'");
     return 1;
 }
@@ -5727,11 +5807,14 @@
             if (KMK_CC_EVAL_IS_1ST_IN_VARIABLE_KEYWORD(ch))
             {
-                if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "define", 6))   /* final */
+                if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "define", 6))   /* final */
                     return kmk_cc_eval_do_var_define(pCompiler, pchWord + 6, cchLeft - 6, fQualifiers);
 
-                if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "undefine", 8)) /* final */
-                    return kmk_cc_eval_do_var_undefine(pCompiler, pchWord + 6, cchLeft - 6, fQualifiers);
-
-                if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "export", 6))
+                if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "undefine", 8)) /* final */
+                    return kmk_cc_eval_do_var_undefine(pCompiler, pchWord + 8, cchLeft -86, fQualifiers);
+
+                if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "unexport", 8)) /* final */
+                    return kmk_cc_eval_do_var_unexport(pCompiler, pchWord + 8, cchLeft - 8, fQualifiers);
+
+                if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "export", 6))
                 {
                     if (!(fQualifiers & KMK_CC_EVAL_QUALIFIER_EXPORT))
@@ -5744,5 +5827,5 @@
                 }
 
-                if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "override", 8))
+                if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "override", 8))
                 {
                     if (!(fQualifiers & KMK_CC_EVAL_QUALIFIER_OVERRIDE))
@@ -5755,5 +5838,5 @@
                 }
 
-                if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "private", 7))
+                if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "private", 7))
                 {
                     if (!(fQualifiers & KMK_CC_EVAL_QUALIFIER_PRIVATE))
@@ -5775,5 +5858,5 @@
                 const char *pchEqual = (const char *)memchr(pchWord, '=', cchLeft);
                 if (pchEqual)
-                    return kmk_cc_eval_handle_assignment_or_recipe(pCompiler, pchEqual, pchWord, cchLeft, fQualifiers);
+                    return kmk_cc_eval_handle_assignment_or_recipe(pCompiler, pchWord, cchLeft, fQualifiers);
             }
             return 0;
@@ -5787,4 +5870,117 @@
 
 /**
+ * Parses 'export [variable]' and 'export [qualifiers] variable = value'
+ * expressions.
+ *
+ * When we find the 'export' directive at the start of a line, we need to
+ * continue parsing with till we can tell the difference between the two forms.
+ *
+ * @returns 1 to indicate we've handled a keyword (see
+ *          kmk_cc_eval_try_handle_keyword).
+ * @param   pCompiler   The compiler state.
+ * @param   pchWord     First char after 'define'.
+ * @param   cchLeft     The number of chars left to parse on this line.
+ */
+static int kmk_cc_eval_handle_var_export(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft)
+{
+    KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+
+    if (cchLeft)
+    {
+        /*
+         * We need to figure out whether this is an assignment or a export statement,
+         * in the latter case join paths with 'export' and 'undefine'.
+         */
+        const char *pchEqual = (const char *)memchr(pchWord, '=', cchLeft);
+        if (!pchEqual)
+            return kmk_cc_eval_do_with_variable_list(pCompiler, pchWord, cchLeft, kKmkCcEvalInstr_export, 0 /*fQualifiers*/);
+
+        /*
+         * Found an '=', could be an assignment.  Let's take the easy way out
+         * and just parse the whole statement into words like we would do if
+         * it wasn't an assignment, and then check the words out for
+         * assignment keywords and operators.
+         */
+        unsigned iSavedEscEol = pCompiler->iEscEol;
+        unsigned cWords       = kmk_cc_eval_parse_words(pCompiler, pchWord, cchLeft);
+        if (cWords)
+        {
+            PKMKCCEVALWORD pWord = pCompiler->paWords;
+            unsigned       iWord = 0;
+            while (iWord < cWords)
+            {
+                /* Trailing assignment operator or terminal assignment directive ('undefine'
+                   and 'unexport' makes no sense here but GNU make ignores that). */
+                if (   (   pWord->cchWord > 1
+                        && pWord->pchWord[pWord->cchWord - 1] == '=')
+                    || KMK_CC_STRCMP_CONST(pWord->pchWord, pWord->cchWord, "define", 6)
+                    || KMK_CC_STRCMP_CONST(pWord->pchWord, pWord->cchWord, "undefine", 8)
+                    || KMK_CC_STRCMP_CONST(pWord->pchWord, pWord->cchWord, "unexport", 8) )
+                {
+                    pCompiler->iEscEol = iSavedEscEol;
+                    return kmk_cc_eval_try_handle_var_with_keywords(pCompiler, pchWord, cchLeft, KMK_CC_EVAL_QUALIFIER_EXPORT);
+                }
+
+                /* If not a variable assignment qualifier, it must be a variable name
+                   followed by an assignment operator. */
+                if (iWord + 1 < cWords)
+                {
+                    if (   !KMK_CC_STRCMP_CONST(pWord->pchWord, pWord->cchWord, "export", 6)
+                        && !KMK_CC_STRCMP_CONST(pWord->pchWord, pWord->cchWord, "private", 7)
+                        && !KMK_CC_STRCMP_CONST(pWord->pchWord, pWord->cchWord, "override", 8))
+                    {
+                        pWord++;
+                        if (   pWord->cchWord > 0
+                            && (   pWord->pchWord[0] == '='
+                                || (   pWord->cchWord > 1
+                                    && pWord->pchWord[1] == '='
+                                    && (   pWord->pchWord[0] == ':'
+                                        || pWord->pchWord[0] == '+'
+                                        || pWord->pchWord[0] == '?'
+                                        || pWord->pchWord[0] == '<') ) ) )
+                        {
+                            pCompiler->iEscEol = iSavedEscEol;
+                            return kmk_cc_eval_try_handle_var_with_keywords(pCompiler, pchWord, cchLeft,
+                                                                            KMK_CC_EVAL_QUALIFIER_EXPORT);
+                        }
+                        break;
+                    }
+                }
+                else
+                    break;
+                /* next */
+                pWord++;
+                iWord++;
+            }
+
+            /*
+             * It's not an assignment.
+             * (This is the same as kmk_cc_eval_do_with_variable_list does.)
+             */
+            PKMKCCEVALVARIABLES pInstr = (PKMKCCEVALVARIABLES)kmk_cc_block_alloc_eval(pCompiler->ppBlockTail,
+                                                                                      KMKCCEVALVARIABLES_SIZE(cWords));
+            pInstr->Core.enmOpcode = kKmkCcEvalInstr_export;
+            pInstr->Core.iLine     = pCompiler->iLine;
+            pInstr->cVars          = cWords;
+            kmk_cc_eval_init_spp_array_from_duplicated_words(pCompiler, cWords, pCompiler->paWords, pInstr->aVars);
+            kmk_cc_block_realign(pCompiler->ppBlockTail);
+        }
+        else
+            KMK_CC_ASSERT(0);
+    }
+    else
+    {
+        /*
+         * We're exporting all variables.
+         */
+        PKMKCCEVALCORE pInstr = kmk_cc_block_alloc_eval(pCompiler->ppBlockTail, sizeof(*pInstr));
+        pInstr->enmOpcode = kKmkCcEvalInstr_export_all;
+        pInstr->iLine     = pCompiler->iLine;
+    }
+    return 1;
+}
+
+
+/**
  * When entering this function we know that the first two character in the first
  * word both independently occurs in keywords.
@@ -5811,13 +6007,15 @@
     if (KMK_CC_EVAL_IS_1ST_IN_VARIABLE_KEYWORD(ch))
     {
-        if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "local", 5))
+        if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "local", 5))
             return kmk_cc_eval_do_var_local(pCompiler, pchWord + 5, cchLeft - 5);
-        if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "define", 6))
+        if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "define", 6))
             return kmk_cc_eval_do_var_define(pCompiler, pchWord + 6, cchLeft - 6, 0);
-        if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "export", 6))
-            return kmk_cc_eval_handle_var_export(pCompiler, pchWord + 6, cchLeft - 6, 0);
-        if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "undefine", 8))
+        if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "export", 6))
+            return kmk_cc_eval_handle_var_export(pCompiler, pchWord + 6, cchLeft - 6);
+        if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "undefine", 8))
             return kmk_cc_eval_do_var_undefine(pCompiler, pchWord + 8, cchLeft - 8, 0);
-        if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "override", 8))
+        if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "unexport", 8))
+            return kmk_cc_eval_do_var_unexport(pCompiler, pchWord + 8, cchLeft - 8, 0);
+        if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "override", 8))
         {
             if (kmk_cc_eval_try_handle_var_with_keywords(pCompiler, pchWord + 8, cchLeft - 8, KMK_CC_EVAL_QUALIFIER_OVERRIDE))
@@ -5825,5 +6023,5 @@
             pCompiler->iEscEol = iSavedEscEol;
         }
-        else if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "private", 7))
+        else if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "private", 7))
         {
             if (kmk_cc_eval_try_handle_var_with_keywords(pCompiler, pchWord + 7, cchLeft - 7, KMK_CC_EVAL_QUALIFIER_PRIVATE))
@@ -5845,23 +6043,23 @@
         if (ch2 == 'f')
         {
-            if (KMK_CC_WORD_COMP_IS_EOL(pCompiler, pchWord, cchLeft))
+            if (KMK_CC_EVAL_WORD_COMP_IS_EOL(pCompiler, pchWord, cchLeft))
                 return kmk_cc_eval_do_if(pCompiler, pchWord, cchLeft, 0 /* in else */);
 
-            if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "eq", 2))
+            if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "eq", 2))
                 return kmk_cc_eval_do_ifeq( pCompiler, pchWord + 2, cchLeft - 2, 0 /* in else */, 1 /* positive */);
 
-            if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "def", 3))
+            if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "def", 3))
                 return kmk_cc_eval_do_ifdef(pCompiler, pchWord + 3, cchLeft - 3, 0 /* in else */, 1 /* positive */);
 
-            if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "neq", 3))
+            if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "neq", 3))
                 return kmk_cc_eval_do_ifeq( pCompiler, pchWord + 3, cchLeft - 3, 0 /* in else */, 0 /* positive */);
 
-            if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "1of", 3))
+            if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "1of", 3))
                 return kmk_cc_eval_do_if1of(pCompiler, pchWord + 3, cchLeft - 3, 0 /* in else */, 1 /* positive */);
 
-            if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "ndef", 4))
+            if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "ndef", 4))
                 return kmk_cc_eval_do_ifdef(pCompiler, pchWord + 4, cchLeft - 4, 0 /* in else */, 0 /* positive */);
 
-            if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "n1of", 4))
+            if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "n1of", 4))
                 return kmk_cc_eval_do_if1of(pCompiler, pchWord + 4, cchLeft - 4, 0 /* in else */, 0 /* positive */);
         }
@@ -5871,5 +6069,5 @@
             pchWord += 5;
             cchLeft -= 5;
-            if (KMK_CC_WORD_COMP_IS_EOL(pCompiler, pchWord, cchLeft))
+            if (KMK_CC_EVAL_WORD_COMP_IS_EOL(pCompiler, pchWord, cchLeft))
                 return kmk_cc_eval_do_include(pCompiler, pchWord, cchLeft, kKmkCcEvalInstr_include);
             if (cchLeft >= 3 && KMK_CC_WORD_COMP_CONST_3(pchWord, "dep"))
@@ -5877,9 +6075,9 @@
                 pchWord += 3;
                 cchLeft -= 3;
-                if (KMK_CC_WORD_COMP_IS_EOL(pCompiler, pchWord, cchLeft))
+                if (KMK_CC_EVAL_WORD_COMP_IS_EOL(pCompiler, pchWord, cchLeft))
                     return kmk_cc_eval_do_include(pCompiler, pchWord, cchLeft, kKmkCcEvalInstr_includedep);
-                if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "-queue", 6))
+                if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "-queue", 6))
                     return kmk_cc_eval_do_include(pCompiler, pchWord + 6, cchLeft - 6, kKmkCcEvalInstr_includedep_queue);
-                if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "-flush", 6))
+                if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "-flush", 6))
                     return kmk_cc_eval_do_include(pCompiler, pchWord + 6, cchLeft - 6, kKmkCcEvalInstr_includedep_flush);
             }
@@ -5888,26 +6086,26 @@
     else if (ch == 'e') /* A few directives starts with 'e'. */
     {
-        if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "else", 4))
+        if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "else", 4))
             return kmk_cc_eval_do_else(pCompiler, pchWord + 4, cchLeft - 4);
-        if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "endif", 5))
+        if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "endif", 5))
             return kmk_cc_eval_do_endif(pCompiler, pchWord + 5, cchLeft - 5);
         /* export and endef are handled elsewhere, though stray endef's may end up here... */
-        KMK_CC_ASSERT(!KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "export", 6));
+        KMK_CC_ASSERT(!KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "export", 6));
 
     }
     else /* the rest. */
     {
-        if (   KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "sinclude", 8)
-            || KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "-include", 8))
+        if (   KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "sinclude", 8)
+            || KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "-include", 8))
             return kmk_cc_eval_do_include(pCompiler, pchWord + 8, cchLeft - 8, kKmkCcEvalInstr_include_silent);
-        if (KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "vpath", 5))
+        if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "vpath", 5))
             return kmk_cc_eval_do_vpath(pCompiler, pchWord + 5, cchLeft - 5);
 
-        KMK_CC_ASSERT(!KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "local", 5));
-        KMK_CC_ASSERT(!KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "define", 6));
-        KMK_CC_ASSERT(!KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "private", 7));
-        KMK_CC_ASSERT(!KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "override", 8));
-        KMK_CC_ASSERT(!KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "unexport", 8));
-        KMK_CC_ASSERT(!KMK_CC_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "undefine", 8));
+        KMK_CC_ASSERT(!KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "local", 5));
+        KMK_CC_ASSERT(!KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "define", 6));
+        KMK_CC_ASSERT(!KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "private", 7));
+        KMK_CC_ASSERT(!KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "override", 8));
+        KMK_CC_ASSERT(!KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "unexport", 8));
+        KMK_CC_ASSERT(!KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "undefine", 8));
     }
 
@@ -6149,5 +6347,5 @@
                         pchTmp = (const char *)memchr(pchWord, '=', cchLeft);
                         if (pchTmp)
-                            kmk_cc_eval_handle_assignment_or_recipe(&Compiler, pchTmp, pchWord, cchLeft, 0);
+                            kmk_cc_eval_handle_assignment_or_recipe(&Compiler, pchWord, cchLeft, 0 /*fQualifiers*/);
                         else
                             kmk_cc_eval_handle_recipe(&Compiler, pchTmp, pchWord, cchLeft);
