Index: trunk/src/kmk/expand.c
===================================================================
--- trunk/src/kmk/expand.c	(revision 2768)
+++ trunk/src/kmk/expand.c	(revision 2769)
@@ -212,9 +212,9 @@
 
 #ifdef CONFIG_WITH_VALUE_LENGTH
-/* Static worker for reference_variable() that expands the recursive
+/* Worker for reference_variable() and kmk_exec_* that expands the recursive
    variable V. The main difference between this and
    recursively_expand[_for_file] is that this worker avoids the temporary
    buffer and outputs directly into the current variable buffer (O).  */
-static char *
+char *
 reference_recursive_variable (char *o, struct variable *v)
 {
@@ -1218,6 +1218,40 @@
 }
 
-/* Restore a previously-saved variable_buffer setting (free the current one).
- */
+#ifdef CONFIG_WITH_COMPILER
+/* Same as install_variable_buffer, except we supply a size hint.  */
+
+char *
+install_variable_buffer_with_hint (char **bufp, unsigned int *lenp, unsigned int size_hint)
+{
+  struct recycled_buffer *recycled;
+  char *buf;
+
+  *bufp = variable_buffer;
+  *lenp = variable_buffer_length;
+
+  recycled = recycled_head;
+  if (recycled)
+    {
+      recycled_head = recycled->next;
+      variable_buffer_length = recycled->length;
+      variable_buffer = buf = (char *)recycled;
+    }
+  else
+    {
+      if (size_hint < 512)
+        variable_buffer_length = (size_hint + 1 + 63) & ~(unsigned int)63;
+      else if (size_hint < 4096)
+        variable_buffer_length = (size_hint + 1 + 1023) & ~(unsigned int)1023;
+      else
+        variable_buffer_length = (size_hint + 1 + 4095) & ~(unsigned int)4095;
+      variable_buffer = buf = xmalloc (variable_buffer_length);
+    }
+  buf[0] = '\0';
+  return buf;
+}
+#endif /* CONFIG_WITH_COMPILER */
+
+/* Restore a previously-saved variable_buffer setting (free the
+   current one). */
 
 void
@@ -1234,2 +1268,23 @@
   variable_buffer_length = len;
 }
+
+
+/* Used to make sure there is at least SIZE bytes of buffer space
+   available starting at PTR.  */
+char *
+ensure_variable_buffer_space(char *ptr, unsigned int size)
+{
+  unsigned int offset = (unsigned int)(ptr - variable_buffer);
+  assert(offset <= variable_buffer_length);
+  if (variable_buffer_length - offset < size)
+    {
+      unsigned minlen = size + offset;
+      variable_buffer_length *= 2;
+      if (variable_buffer_length < minlen + 100)
+        variable_buffer_length = (minlen + 100 + 63) & ~(unsigned int)63;
+      variable_buffer = xrealloc (variable_buffer, variable_buffer_length);
+      ptr = variable_buffer + offset;
+    }
+  return ptr;
+}
+
Index: trunk/src/kmk/kmk_cc_exec.c
===================================================================
--- trunk/src/kmk/kmk_cc_exec.c	(revision 2768)
+++ trunk/src/kmk/kmk_cc_exec.c	(revision 2769)
@@ -65,5 +65,19 @@
 typedef KMKCCBLOCK *PKMKCCBLOCK;
 
-/** Expansion instructions. */
+/**
+ * String expansion statistics.
+ */
+typedef struct KMKCCEXPSTATS
+{
+    /** Max expanded size. */
+    uint32_t                    cchMax;
+    /** Recent average size. */
+    uint32_t                    cchAvg;
+} KMKCCEXPSTATS;
+typedef KMKCCEXPSTATS *PKMKCCEXPSTATS;
+
+/**
+ * Expansion instructions.
+ */
 typedef enum KMKCCEXPINSTR
 {
@@ -74,8 +88,11 @@
     /** Insert an expanded variable value, the name is dynamic (sub prog). */
     kKmkCcExpInstr_DynamicVariable,
+    /** Insert an expanded variable value, which name we already know, doing
+     * search an replace on a string. */
+    kKmkCcExpInstr_SearchAndReplacePlainVariable,
     /** Insert the output of function that requires no argument expansion. */
     kKmkCcExpInstr_PlainFunction,
     /** Insert the output of function that requires dynamic expansion of one ore
-     * more arguments. */
+     * more arguments.  (Dynamic is perhaps not such a great name, but whatever.) */
     kKmkCcExpInstr_DynamicFunction,
     /** Jump to a new instruction block. */
@@ -95,15 +112,19 @@
 typedef KMKCCEXPCORE *PKMKCCEXPCORE;
 
+/**
+ * String expansion sub program.
+ */
 typedef struct kmk_cc_exp_subprog
 {
     /** Pointer to the first instruction. */
     PKMKCCEXPCORE           pFirstInstr;
-    /** Max expanded size. */
-    uint32_t                cbMax;
-    /** Recent average size. */
-    uint32_t                cbAvg;
+    /** Statistics. */
+    KMKCCEXPSTATS           Stats;
 } KMKCCEXPSUBPROG;
 typedef KMKCCEXPSUBPROG *PKMKCCEXPSUBPROG;
 
+/**
+ * kKmkCcExpInstr_CopyString instruction format.
+ */
 typedef struct kmk_cc_exp_copy_string
 {
@@ -117,21 +138,25 @@
 typedef KMKCCEXPCOPYSTRING *PKMKCCEXPCOPYSTRING;
 
+/**
+ * kKmkCcExpInstr_PlainVariable instruction format.
+ */
 typedef struct kmk_cc_exp_plain_variable
 {
     /** The core instruction. */
     KMKCCEXPCORE            Core;
-    /** The variable strcache entry for this variable. */
-    struct strcache2_entry const *pNameEntry;
+    /** The name of the variable (points into variable_strcache). */
+    const char             *pszName;
 } KMKCCEXPPLAINVAR;
 typedef KMKCCEXPPLAINVAR *PKMKCCEXPPLAINVAR;
 
+/**
+ * kKmkCcExpInstr_DynamicVariable instruction format.
+ */
 typedef struct kmk_cc_exp_dynamic_variable
 {
     /** The core instruction. */
     KMKCCEXPCORE            Core;
-    /** Where to continue after this instruction.  This is necessary since the
-     * subprogram is allocated after us in the instruction block.  Since the sub
-     * program is of variable size, we don't even know if we're still in the same
-     * instruction block.  So, we include a jump here. */
+    /** Where to continue after this instruction.  (This is necessary since the
+     * instructions of the subprogram are emitted after this instruction.) */
     PKMKCCEXPCORE           pNext;
     /** The subprogram that will give us the variable name. */
@@ -140,4 +165,31 @@
 typedef KMKCCEXPDYNVAR *PKMKCCEXPDYNVAR;
 
+/**
+ * kKmkCcExpInstr_SearchAndReplacePlainVariable instruction format.
+ */
+typedef struct kmk_cc_exp_sr_plain_variable
+{
+    /** The core instruction. */
+    KMKCCEXPCORE            Core;
+    /** Where to continue after this instruction.  (This is necessary since the
+     * instruction contains string data of variable size.) */
+    PKMKCCEXPCORE           pNext;
+    /** The name of the variable (points into variable_strcache). */
+    const char             *pszName;
+    /** Search pattern.  */
+    const char             *pszSearchPattern;
+    /** Replacement pattern. */
+    const char             *pszReplacePattern;
+    /** Offset into pszSearchPattern of the significant '%' char. */
+    uint32_t                offPctSearchPattern;
+    /** Offset into pszReplacePattern of the significant '%' char. */
+    uint32_t                offPctReplacePattern;
+} KMKCCEXPSRPLAINVAR;
+typedef KMKCCEXPSRPLAINVAR *PKMKCCEXPSRPLAINVAR;
+
+/**
+ * Instruction format parts common to both kKmkCcExpInstr_PlainFunction and
+ * kKmkCcExpInstr_DynamicFunction.
+ */
 typedef struct kmk_cc_exp_function_core
 {
@@ -146,7 +198,6 @@
     /** Number of arguments. */
     uint32_t                cArgs;
-    /** Where to continue after this instruction.  This is necessary since the
-     * instruction is of variable size and we don't even know if we're still in the
-     * same instruction block.  So, we include a jump here. */
+    /** Where to continue after this instruction.  (This is necessary since the
+     * instructions are of variable size and may be followed by string data.) */
     PKMKCCEXPCORE           pNext;
     /**
@@ -164,4 +215,7 @@
 typedef KMKCCEXPFUNCCORE *PKMKCCEXPFUNCCORE;
 
+/**
+ * Instruction format for kKmkCcExpInstr_PlainFunction.
+ */
 typedef struct kmk_cc_exp_plain_function
 {
@@ -178,4 +232,7 @@
 #define KMKCCEXPPLAINFUNC_SIZE(a_cArgs)  (sizeof(KMKCCEXPFUNCCORE) + (a_cArgs + 1) * sizeof(const char *))
 
+/**
+ * Instruction format for kKmkCcExpInstr_DynamicFunction.
+ */
 typedef struct kmk_cc_exp_dyn_function
 {
@@ -209,4 +266,7 @@
                                           + (a_cArgs) * sizeof(((PKMKCCEXPDYNFUNC)(uintptr_t)42)->aArgs[0]) )
 
+/**
+ * Instruction format for kKmkCcExpInstr_Jump.
+ */
 typedef struct kmk_cc_exp_jump
 {
@@ -227,8 +287,6 @@
     /** List of blocks for this program (LIFO). */
     PKMKCCBLOCK             pBlockTail;
-    /** Max expanded size. */
-    uint32_t                cbMax;
-    /** Recent average size. */
-    uint32_t                cbAvg;
+    /** Statistics. */
+    KMKCCEXPSTATS           Stats;
 } KMKCCEXPPROG;
 /** Pointer to a string expansion program. */
@@ -245,4 +303,5 @@
 *******************************************************************************/
 static int kmk_cc_exp_compile_subprog(PKMKCCBLOCK *ppBlockTail, const char *pchStr, uint32_t cchStr, PKMKCCEXPSUBPROG pSubProg);
+static char *kmk_exec_expand_subprog_to_tmp(PKMKCCEXPSUBPROG pSubProg, uint32_t *pcch);
 
 
@@ -741,5 +800,6 @@
 
 /**
- * Emits a kKmkCcExpInstr_PlainVariable.
+ * Emits either a kKmkCcExpInstr_PlainVariable or
+ * kKmkCcExpInstr_SearchAndReplacePlainVariable instruction.
  *
  * @returns 0 on success, non-zero on failure.
@@ -750,11 +810,85 @@
  *                              nothing will be emitted.
  */
-static int kmk_cc_exp_emit_plain_variable(PKMKCCBLOCK *ppBlockTail, const char *pchName, uint32_t cchName)
+static int kmk_cc_exp_emit_plain_variable_maybe_sr(PKMKCCBLOCK *ppBlockTail, const char *pchName, uint32_t cchName)
 {
     if (cchName > 0)
     {
-        PKMKCCEXPPLAINVAR pInstr = (PKMKCCEXPPLAINVAR)kmk_cc_block_alloc_exp(ppBlockTail, sizeof(*pInstr));
-        pInstr->Core.enmOpCode = kKmkCcExpInstr_PlainVariable;
-        pInstr->pNameEntry = strcache2_get_entry(&variable_strcache, strcache2_add(&variable_strcache, pchName, cchName));
+        /*
+         * Hopefully, we're not expected to do any search and replace on the
+         * expanded variable string later...  Requires both ':' and '='.
+         */
+        const char *pchEqual;
+        const char *pchColon = (const char *)memchr(pchName, ':', cchName);
+        if (   pchColon == NULL
+            || (pchEqual = (const char *)memchr(pchColon + 1, ':', cchName - (pchColon - pchName - 1))) == NULL
+            || pchEqual == pchEqual + 1)
+        {
+            PKMKCCEXPPLAINVAR pInstr = (PKMKCCEXPPLAINVAR)kmk_cc_block_alloc_exp(ppBlockTail, sizeof(*pInstr));
+            pInstr->Core.enmOpCode = kKmkCcExpInstr_PlainVariable;
+            pInstr->pszName = strcache2_add(&variable_strcache, pchName, cchName);
+        }
+        else if (pchColon != pchName)
+        {
+            /*
+             * Okay, we need to do search and replace the variable value.
+             * This is performed by patsubst_expand_pat using '%' patterns.
+             */
+            uint32_t            cchName2   = (uint32_t)(pchColon - pchName);
+            uint32_t            cchSearch  = (uint32_t)(pchEqual - pchColon - 1);
+            uint32_t            cchReplace = cchName - cchName2 - cchSearch - 2;
+            const char         *pchPct;
+            char               *psz;
+            PKMKCCEXPSRPLAINVAR pInstr;
+
+            pInstr = (PKMKCCEXPSRPLAINVAR)kmk_cc_block_alloc_exp(ppBlockTail, sizeof(*pInstr));
+            pInstr->Core.enmOpCode = kKmkCcExpInstr_SearchAndReplacePlainVariable;
+            pInstr->pszName = strcache2_add(&variable_strcache, pchName, cchName2);
+
+            /* Figure out the search pattern, unquoting percent chars.. */
+            psz = (char *)kmk_cc_block_byte_alloc(ppBlockTail, cchSearch + 2);
+            psz[0] = '%';
+            memcpy(psz + 1, pchColon + 1, cchSearch);
+            psz[1 + cchSearch] = '\0';
+            pchPct = find_percent(psz + 1); /* also performs unquoting */
+            if (pchPct)
+            {
+                pInstr->pszSearchPattern    = psz + 1;
+                pInstr->offPctSearchPattern = (uint32_t)(pchPct - psz - 1);
+            }
+            else
+            {
+                pInstr->pszSearchPattern    = psz;
+                pInstr->offPctSearchPattern = 0;
+            }
+
+            /* Figure out the replacement pattern, unquoting percent chars.. */
+            if (cchReplace == 0)
+            {
+                pInstr->pszReplacePattern    = "%";
+                pInstr->offPctReplacePattern = 0;
+            }
+            else
+            {
+                psz = (char *)kmk_cc_block_byte_alloc(ppBlockTail, cchReplace + 2);
+                psz[0] = '%';
+                memcpy(psz + 1, pchEqual + 1, cchReplace);
+                psz[1 + cchReplace] = '\0';
+                pchPct = find_percent(psz + 1); /* also performs unquoting */
+                if (pchPct)
+                {
+                    pInstr->pszReplacePattern    = psz + 1;
+                    pInstr->offPctReplacePattern = (uint32_t)(pchPct - psz - 1);
+                }
+                else
+                {
+                    pInstr->pszReplacePattern    = psz;
+                    pInstr->offPctReplacePattern = 0;
+                }
+            }
+
+            /* Note down where the next instruction is after realigning the allocator. */
+            kmk_cc_block_realign(ppBlockTail);
+            pInstr->pNext = (PKMKCCEXPCORE)kmk_cc_block_get_next_ptr(*ppBlockTail);
+        }
     }
     return 0;
@@ -837,8 +971,19 @@
                     {
                         /* There are several alternative ways of finding the ending
-                           parenthesis / braces.  GNU make only consideres open &
-                           close chars of the one we're processing, and it does not
-                           matter whether the opening paren / braces are preceeded by
-                           any dollar char.  Simple and efficient.  */
+                           parenthesis / braces.
+
+                           GNU make does one thing for functions and variable containing
+                           any '$' chars before the first closing char.  While for
+                           variables where a closing char comes before any '$' char, a
+                           simplified approach is taken.  This means that for example:
+
+                                Given VAR=var, the expressions "$(var())" and
+                                "$($(VAR)())" would be expanded differently.
+                                In the first case the variable "var(" would be
+                                used and in the second "var()".
+
+                           This code will not duplicate this weird behavior, but work
+                           the same regardless of whether there is a '$' char before
+                           the first closing char. */
                         make_function_ptr_t pfnFunction;
                         const char         *pszFunction;
@@ -865,4 +1010,5 @@
                             cchName++;
                         }
+
                         if (   cchName >= MIN_FUNCTION_LENGTH
                             && cchName <= MAX_FUNCTION_LENGTH
@@ -1002,5 +1148,5 @@
                             }
                             if (cDollars == 0)
-                                rc = kmk_cc_exp_emit_plain_variable(ppBlockTail, pchStr, cchName);
+                                rc = kmk_cc_exp_emit_plain_variable_maybe_sr(ppBlockTail, pchStr, cchName);
                             else
                                 rc = kmk_cc_exp_emit_dyn_variable(ppBlockTail, pchStr, cchName);
@@ -1012,5 +1158,5 @@
                     {
                         /* Single character variable name. */
-                        rc = kmk_cc_exp_emit_plain_variable(ppBlockTail, pchStr, 1);
+                        rc = kmk_cc_exp_emit_plain_variable_maybe_sr(ppBlockTail, pchStr, 1);
                         pchStr++;
                         cchStr--;
@@ -1046,4 +1192,15 @@
 
 /**
+ * Initializes string expansion program statistics.
+ * @param   pStats              Pointer to the statistics structure to init.
+ */
+static void kmk_cc_exp_stats_init(PKMKCCEXPSTATS pStats)
+{
+    pStats->cchAvg = 0;
+    pStats->cchMax = 0;
+}
+
+
+/**
  * Compiles a string expansion sub program.
  *
@@ -1064,6 +1221,5 @@
     assert(cchStr);
     pSubProg->pFirstInstr = (PKMKCCEXPCORE)kmk_cc_block_get_next_ptr(*ppBlockTail);
-    pSubProg->cbMax = 0;
-    pSubProg->cbAvg = 0;
+    kmk_cc_exp_stats_init(&pSubProg->Stats);
     return kmk_cc_exp_compile_common(ppBlockTail, pchStr, cchStr);
 }
@@ -1095,6 +1251,5 @@
         pProg->pBlockTail   = pBlock;
         pProg->pFirstInstr  = (PKMKCCEXPCORE)kmk_cc_block_get_next_ptr(pBlock);
-        pProg->cbMax        = 0;
-        pProg->cbAvg        = 0;
+        kmk_cc_exp_stats_init(&pProg->Stats);
 
         /*
@@ -1145,4 +1300,353 @@
 
 
+#ifndef NDEBUG
+/**
+ * Used to check that function arguments are left alone.
+ * @returns Updated hash.
+ * @param   uHash       The current hash value.
+ * @param   psz         The string to hash.
+ */
+static uint32_t kmk_exec_debug_string_hash(uint32_t uHash, const char *psz)
+{
+    unsigned char ch;
+    while ((ch = *(unsigned char const *)psz++) != '\0')
+        uHash = (uHash << 6) + (uHash << 16) - uHash + (unsigned char)ch;
+    return uHash;
+}
+#endif
+
+
+/**
+ * String expansion execution worker for outputting a variable.
+ *
+ * @returns The new variable buffer position.
+ * @param   pVar        The variable to reference.
+ * @param   pchDst      The current variable buffer position.
+ */
+static char *kmk_exec_expand_worker_reference_variable(struct variable *pVar, char *pchDst)
+{
+    if (pVar->value_length > 0)
+    {
+        if (!pVar->recursive)
+            pchDst = variable_buffer_output(pchDst, pVar->value, pVar->value_length);
+        else
+            pchDst = reference_recursive_variable(pchDst, pVar);
+    }
+    else if (pVar->append)
+        pchDst = reference_recursive_variable(pchDst, pVar);
+    return pchDst;
+}
+
+
+/**
+ * Executes a stream string expansion instructions, outputting to the current
+ * varaible buffer.
+ *
+ * @returns The new variable buffer position.
+ * @param   pInstrCore      The instruction to start executing at.
+ * @param   pchDst          The current variable buffer position.
+ */
+static char *kmk_exec_expand_instruction_stream_to_var_buf(PKMKCCEXPCORE pInstrCore, char *pchDst)
+{
+    for (;;)
+    {
+        switch (pInstrCore->enmOpCode)
+        {
+            case kKmkCcExpInstr_CopyString:
+            {
+                PKMKCCEXPCOPYSTRING pInstr = (PKMKCCEXPCOPYSTRING)pInstrCore;
+                pchDst = variable_buffer_output(pchDst, pInstr->pachSrc, pInstr->cchCopy);
+
+                pInstrCore = &(pInstr + 1)->Core;
+                break;
+            }
+
+            case kKmkCcExpInstr_PlainVariable:
+            {
+                PKMKCCEXPPLAINVAR pInstr = (PKMKCCEXPPLAINVAR)pInstrCore;
+                struct variable  *pVar = lookup_variable_strcached(pInstr->pszName);
+                if (pVar)
+                    pchDst = kmk_exec_expand_worker_reference_variable(pVar, pchDst);
+                else
+                    warn_undefined(pInstr->pszName, strcache2_get_len(&variable_strcache, pInstr->pszName));
+
+                pInstrCore = &(pInstr + 1)->Core;
+                break;
+            }
+
+            case kKmkCcExpInstr_DynamicVariable:
+            {
+                PKMKCCEXPDYNVAR  pInstr = (PKMKCCEXPDYNVAR)pInstrCore;
+                struct variable *pVar;
+                uint32_t         cchName;
+                char            *pszName = kmk_exec_expand_subprog_to_tmp(&pInstr->SubProg, &cchName);
+                char            *pszColon = (char *)memchr(pszName, ':', cchName);
+                char            *pszEqual;
+                if (   pszColon == NULL
+                    || (pszEqual = (char *)memchr(pszColon + 1, '=', &pszName[cchName] - pszColon - 1)) == NULL
+                    || pszEqual == pszColon + 1)
+                {
+                    pVar = lookup_variable(pszName, cchName);
+                    if (pVar)
+                        pchDst = kmk_exec_expand_worker_reference_variable(pVar, pchDst);
+                    else
+                        warn_undefined(pszName, cchName);
+                }
+                else if (pszColon != pszName)
+                {
+                    /*
+                     * Oh, we have to do search and replace. How tedious.
+                     * Since the variable name is a temporary buffer, we can transform
+                     * the strings into proper search and replacement patterns directly.
+                     */
+                    pVar = lookup_variable(pszName, pszColon - pszName);
+                    if (pVar)
+                    {
+                        char const *pszExpandedVarValue = pVar->recursive ? recursively_expand(pVar) : pVar->value;
+                        char       *pszSearchPat  = pszColon + 1;
+                        char       *pszReplacePat = pszEqual + 1;
+                        const char *pchPctSearchPat;
+                        const char *pchPctReplacePat;
+
+                        *pszEqual = '\0';
+                        pchPctSearchPat = find_percent(pszSearchPat);
+                        pchPctReplacePat = find_percent(pszReplacePat);
+
+                        if (!pchPctReplacePat)
+                        {
+                            if (pszReplacePat[-2] != '\0') /* On the offchance that a pct was unquoted by find_percent. */
+                            {
+                                memmove(pszName + 1, pszSearchPat, pszReplacePat - pszSearchPat);
+                                if (pchPctSearchPat)
+                                    pchPctSearchPat -= pszSearchPat - &pszName[1];
+                                pszSearchPat = &pszName[1];
+                            }
+                            pchPctReplacePat = --pszReplacePat;
+                            *pszReplacePat = '%';
+                        }
+
+                        if (!pchPctSearchPat)
+                        {
+                            pchPctSearchPat = --pszSearchPat;
+                            *pszSearchPat = '%';
+                        }
+
+                        pchDst = patsubst_expand_pat(pchDst, pszExpandedVarValue,
+                                                     pszSearchPat, pszReplacePat,
+                                                     pchPctSearchPat, pchPctReplacePat);
+
+                        if (pVar->recursive)
+                            free((void *)pszExpandedVarValue);
+                    }
+                    else
+                        warn_undefined(pszName, pszColon - pszName);
+                }
+                free(pszName);
+
+                pInstrCore = pInstr->pNext;
+                break;
+            }
+
+
+            case kKmkCcExpInstr_SearchAndReplacePlainVariable:
+            {
+                PKMKCCEXPSRPLAINVAR pInstr = (PKMKCCEXPSRPLAINVAR)pInstrCore;
+                struct variable    *pVar = lookup_variable_strcached(pInstr->pszName);
+                if (pVar)
+                {
+                    char const *pszExpandedVarValue = pVar->recursive ? recursively_expand(pVar) : pVar->value;
+                    pchDst = patsubst_expand_pat(pchDst,
+                                                 pszExpandedVarValue,
+                                                 pInstr->pszSearchPattern,
+                                                 pInstr->pszReplacePattern,
+                                                 &pInstr->pszSearchPattern[pInstr->offPctSearchPattern],
+                                                 &pInstr->pszReplacePattern[pInstr->offPctReplacePattern]);
+                    if (pVar->recursive)
+                        free((void *)pszExpandedVarValue);
+                }
+                else
+                    warn_undefined(pInstr->pszName, strcache2_get_len(&variable_strcache, pInstr->pszName));
+
+                pInstrCore = pInstr->pNext;
+                break;
+            }
+
+            case kKmkCcExpInstr_PlainFunction:
+            {
+                PKMKCCEXPPLAINFUNC pInstr = (PKMKCCEXPPLAINFUNC)pInstrCore;
+#ifndef NDEBUG
+                uint32_t uCrcBefore = 0;
+                uint32_t uCrcAfter = 0;
+                uint32_t iArg = pInstr->Core.cArgs;
+                while (iArg-- > 0)
+                    uCrcBefore = kmk_exec_debug_string_hash(uCrcBefore, pInstr->apszArgs[iArg]);
+#endif
+
+                pchDst = pInstr->Core.pfnFunction(pchDst, (char **)&pInstr->apszArgs[0], pInstr->Core.pszFuncName);
+
+#ifndef NDEBUG
+                iArg = pInstr->Core.cArgs;
+                while (iArg-- > 0)
+                    uCrcAfter = kmk_exec_debug_string_hash(uCrcAfter, pInstr->apszArgs[iArg]);
+                assert(uCrcBefore == uCrcAfter);
+#endif
+
+                pInstrCore = pInstr->Core.pNext;
+                break;
+            }
+
+            case kKmkCcExpInstr_DynamicFunction:
+            {
+                PKMKCCEXPDYNFUNC pInstr = (PKMKCCEXPDYNFUNC)pInstrCore;
+                char           **papszArgsShadow = xmalloc( (pInstr->Core.cArgs * 2 + 1) * sizeof(char *));
+                char           **papszArgs = &papszArgsShadow[pInstr->Core.cArgs];
+                uint32_t         iArg;
+#ifndef NDEBUG
+                uint32_t         uCrcBefore = 0;
+                uint32_t         uCrcAfter = 0;
+#endif
+                iArg = pInstr->Core.cArgs;
+                papszArgs[iArg] = NULL;
+                while (iArg-- > 0)
+                {
+                    char *pszArg;
+                    if (pInstr->aArgs[iArg].fPlain)
+                        pszArg = (char *)pInstr->aArgs[iArg].u.Plain.pszArg;
+                    else
+                        pszArg = kmk_exec_expand_subprog_to_tmp(&pInstr->aArgs[iArg].u.SubProg, NULL);
+                    papszArgsShadow[iArg] = pszArg;
+                    papszArgs[iArg]       = pszArg;
+#ifndef NDEBUG
+                    uCrcBefore = kmk_exec_debug_string_hash(uCrcBefore, pszArg);
+#endif
+                }
+
+                pchDst = pInstr->Core.pfnFunction(pchDst, papszArgs, pInstr->Core.pszFuncName);
+
+                iArg = pInstr->Core.cArgs;
+                while (iArg-- > 0)
+                {
+#ifndef NDEBUG
+                    assert(papszArgsShadow[iArg] == papszArgs[iArg]);
+                    uCrcAfter = kmk_exec_debug_string_hash(uCrcAfter, papszArgsShadow[iArg]);
+#endif
+                    if (!pInstr->aArgs[iArg].fPlain)
+                        free(papszArgsShadow);
+                }
+                assert(uCrcBefore == uCrcAfter);
+                free(papszArgsShadow);
+
+                pInstrCore = pInstr->Core.pNext;
+                break;
+            }
+
+            case kKmkCcExpInstr_Jump:
+            {
+                PKMKCCEXPJUMP pInstr = (PKMKCCEXPJUMP)pInstrCore;
+                pInstrCore = pInstr->pNext;
+                break;
+            }
+
+            case kKmkCcExpInstr_Return:
+                return pchDst;
+
+            default:
+                fatal(NULL, _("Unknown string expansion opcode: %d (%#x)"),
+                      (int)pInstrCore->enmOpCode, (int)pInstrCore->enmOpCode);
+                return NULL;
+        }
+    }
+}
+
+
+/**
+ * Updates the string expansion statistics.
+ *
+ * @param   pStats              The statistics structure to update.
+ * @param   cchResult           The result lenght.
+ */
+void kmk_cc_exp_stats_update(PKMKCCEXPSTATS pStats, uint32_t cchResult)
+{
+    /*
+     * Keep statistics on output size.  The average is simplified and not an
+     * exact average for every expansion that has taken place.
+     */
+    if (cchResult > pStats->cchMax)
+    {
+        if (pStats->cchMax)
+            pStats->cchAvg = cchResult;
+        pStats->cchMax = cchResult;
+    }
+    pStats->cchAvg = (pStats->cchAvg * 7 + cchResult) / 8;
+}
+
+
+/**
+ * Execute a string expansion sub-program, outputting to a new heap buffer.
+ *
+ * @returns Pointer to the output buffer (hand to free when done).
+ * @param   pSubProg          The sub-program to execute.
+ * @param   pcchResult        Where to return the size of the result. Optional.
+ */
+static char *kmk_exec_expand_subprog_to_tmp(PKMKCCEXPSUBPROG pSubProg, uint32_t *pcchResult)
+{
+    char           *pchOldVarBuf;
+    unsigned int    cbOldVarBuf;
+    char           *pchDst;
+    char           *pszResult;
+    uint32_t        cchResult;
+
+    /*
+     * Temporarily replace the variable buffer while executing the instruction
+     * stream for this sub program.
+     */
+    pchDst = install_variable_buffer_with_hint(&pchOldVarBuf, &cbOldVarBuf,
+                                               pSubProg->Stats.cchAvg ? pSubProg->Stats.cchAvg + 32 : 256);
+
+    pchDst = kmk_exec_expand_instruction_stream_to_var_buf(pSubProg->pFirstInstr, pchDst);
+
+    /* Ensure that it's terminated. */
+    pchDst = variable_buffer_output(pchDst, "\0", 1) - 1;
+
+    /* Grab the result buffer before restoring the previous one. */
+    pszResult = variable_buffer;
+    cchResult = (uint32_t)(pchDst - pszResult);
+    if (pcchResult)
+        *pcchResult = cchResult;
+    kmk_cc_exp_stats_update(&pSubProg->Stats, cchResult);
+
+    restore_variable_buffer(pchOldVarBuf, cbOldVarBuf);
+
+    return pszResult;
+}
+
+
+/**
+ * Execute a string expansion program, outputting to the current variable
+ * buffer.
+ *
+ * @returns New variable buffer position.
+ * @param   pProg               The program to execute.
+ * @param   pchDst              The current varaible buffer position.
+ */
+static char *kmk_exec_expand_prog_to_var_buf(PKMKCCEXPPROG pProg, char *pchDst)
+{
+    uint32_t cchResult;
+    uint32_t offStart = (uint32_t)(pchDst - variable_buffer);
+
+    if (pProg->Stats.cchAvg >= variable_buffer_length - offStart)
+        pchDst = ensure_variable_buffer_space(pchDst, offStart + pProg->Stats.cchAvg + 32);
+
+    pchDst = kmk_exec_expand_instruction_stream_to_var_buf(pProg->pFirstInstr, pchDst);
+
+    cchResult = (uint32_t)(pchDst - variable_buffer);
+    assert(cchResult >= offStart);
+    cchResult -= offStart;
+    kmk_cc_exp_stats_update(&pProg->Stats, cchResult);
+
+    return pchDst;
+}
+
+
 /**
  * Equivalent of eval_buffer, only it's using the evalprog of the variable.
@@ -1167,6 +1671,5 @@
 {
     assert(pVar->expandprog);
-    assert(0);
-    return pchDst;
+    return kmk_exec_expand_prog_to_var_buf(pVar->expandprog, pchDst);
 }
 
@@ -1180,4 +1683,16 @@
 {
     assert(pVar->evalprog || pVar->expandprog);
+#if 0
+    if (pVar->evalprog)
+    {
+        kmk_cc_block_free_list(pVar->evalprog->pBlockTail);
+        pVar->evalprog = NULL;
+    }
+#endif
+    if (pVar->expandprog)
+    {
+        kmk_cc_block_free_list(pVar->expandprog->pBlockTail);
+        pVar->expandprog = NULL;
+    }
 }
 
@@ -1191,4 +1706,16 @@
 {
     assert(pVar->evalprog || pVar->expandprog);
+#if 0
+    if (pVar->evalprog)
+    {
+        kmk_cc_block_free_list(pVar->evalprog->pBlockTail);
+        pVar->evalprog = NULL;
+    }
+#endif
+    if (pVar->expandprog)
+    {
+        kmk_cc_block_free_list(pVar->expandprog->pBlockTail);
+        pVar->expandprog = NULL;
+    }
 }
 
Index: trunk/src/kmk/variable.c
===================================================================
--- trunk/src/kmk/variable.c	(revision 2768)
+++ trunk/src/kmk/variable.c	(revision 2769)
@@ -1035,4 +1035,74 @@
   return 0;
 }
+
+#ifdef CONFIG_WITH_STRCACHE2
+/* Alternative version of lookup_variable that takes a name that's already in
+   the variable string cache. */
+struct variable *
+lookup_variable_strcached (const char *name)
+{
+  struct variable *v;
+#if 1 /*FIX THIS - ndef KMK*/
+  const struct variable_set_list *setlist;
+  struct variable var_key;
+#endif /* KMK */
+  int is_parent = 0;
+
+#ifndef NDEBUG
+  strcache2_verify_entry (&variable_strcache, name);
+#endif
+
+#ifdef KMK
+  /* Check for kBuild-define- local variable accesses and handle these first. */
+  if (strcache2_get_len(&variable_strcache, name) > 3 && name[0] == '[')
+    {
+      v = lookup_kbuild_object_variable_accessor(name, strcache2_get_len(&variable_strcache, name));
+      if (v != VAR_NOT_KBUILD_ACCESSOR)
+        {
+          MAKE_STATS_2 (v->references++);
+          return v;
+        }
+    }
+#endif
+
+#if 1  /*FIX THIS - ndef KMK */
+
+  var_key.name = (char *) name;
+  var_key.length = strcache2_get_len(&variable_strcache, name);
+
+  for (setlist = current_variable_set_list;
+       setlist != 0; setlist = setlist->next)
+    {
+      const struct variable_set *set = setlist->set;
+
+      v = (struct variable *) hash_find_item_strcached ((struct hash_table *) &set->table, &var_key);
+      if (v && (!is_parent || !v->private_var))
+        {
+# ifdef KMK
+          RESOLVE_ALIAS_VARIABLE(v);
+# endif
+          MAKE_STATS_2 (v->references++);
+	   return v->special ? lookup_special_var (v) : v;
+        }
+
+      is_parent |= setlist->next_is_parent;
+    }
+
+#else  /* KMK - need for speed */
+
+  v = lookup_cached_variable (name);
+  assert (lookup_variable_for_assert(name, length) == v);
+#ifdef VMS
+  if (v)
+#endif
+    return v;
+#endif /* KMK - need for speed */
+#ifdef VMS
+# error "Port me (split out the relevant code from lookup_varaible and call it)"
+#endif
+  return 0;
+}
+#endif
+
 
 
Index: trunk/src/kmk/variable.h
===================================================================
--- trunk/src/kmk/variable.h	(revision 2768)
+++ trunk/src/kmk/variable.h	(revision 2769)
@@ -244,5 +244,7 @@
 #endif /* CONFIG_WITH_VALUE_LENGTH */
 void install_variable_buffer (char **bufp, unsigned int *lenp);
+char *install_variable_buffer_with_hint (char **bufp, unsigned int *lenp, unsigned int size_hint);
 void restore_variable_buffer (char *buf, unsigned int len);
+char *ensure_variable_buffer_space(char *ptr, unsigned int size);
 #ifdef CONFIG_WITH_VALUE_LENGTH
 void append_expanded_string_to_variable (struct variable *v, const char *value,
@@ -325,4 +327,7 @@
                                    unsigned int *value_lenp);
 #define recursively_expand(v)   recursively_expand_for_file (v, NULL, NULL)
+#endif
+#ifdef CONFIG_WITH_COMPILER
+char *reference_recursive_variable (char *o, struct variable *v);
 #endif
 
@@ -369,4 +374,7 @@
 struct variable *lookup_variable_in_set (const char *name, unsigned int length,
                                          const struct variable_set *set);
+#ifdef CONFIG_WITH_STRCACHE2
+struct variable *lookup_variable_strcached (const char *name);
+#endif
 
 #ifdef CONFIG_WITH_VALUE_LENGTH
