summaryrefslogtreecommitdiffstats
path: root/src/kmk/kmk_cc_exec.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-11 08:21:29 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-11 08:21:29 +0000
commit29cd838eab01ed7110f3ccb2e8c6a35c8a31dbcc (patch)
tree63ef546b10a81d461e5cf5ed9e98a68cd7dee1aa /src/kmk/kmk_cc_exec.c
parentInitial commit. (diff)
downloadkbuild-29cd838eab01ed7110f3ccb2e8c6a35c8a31dbcc.tar.xz
kbuild-29cd838eab01ed7110f3ccb2e8c6a35c8a31dbcc.zip
Adding upstream version 1:0.1.9998svn3589+dfsg.upstream/1%0.1.9998svn3589+dfsg
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/kmk/kmk_cc_exec.c')
-rw-r--r--src/kmk/kmk_cc_exec.c7613
1 files changed, 7613 insertions, 0 deletions
diff --git a/src/kmk/kmk_cc_exec.c b/src/kmk/kmk_cc_exec.c
new file mode 100644
index 0000000..6f60477
--- /dev/null
+++ b/src/kmk/kmk_cc_exec.c
@@ -0,0 +1,7613 @@
+#ifdef CONFIG_WITH_COMPILER
+/* $Id: kmk_cc_exec.c 3233 2018-09-24 10:39:36Z bird $ */
+/** @file
+ * kmk_cc - Make "Compiler".
+ */
+
+/*
+ * Copyright (c) 2015-2017 knut st. osmundsen <bird-kBuild-spam-xiiv@anduin.net>
+ *
+ * This file is part of kBuild.
+ *
+ * kBuild is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * kBuild is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with kBuild. If not, see <http://www.gnu.org/licenses/>
+ *
+ */
+
+
+/*********************************************************************************************************************************
+* Header Files *
+*********************************************************************************************************************************/
+#include "makeint.h"
+
+#include "dep.h"
+#include "variable.h"
+#include "rule.h"
+#include "debug.h"
+#include "hash.h"
+#include <ctype.h>
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+#include <stdarg.h>
+#include <assert.h>
+#include "k/kDefs.h"
+#include "k/kTypes.h"
+
+
+/*********************************************************************************************************************************
+* Defined Constants And Macros *
+*********************************************************************************************************************************/
+/** @def KMK_CC_WITH_STATS
+ * Enables the collection of extra statistics. */
+#ifndef KMK_CC_WITH_STATS
+# ifdef CONFIG_WITH_MAKE_STATS
+# define KMK_CC_WITH_STATS
+# endif
+#endif
+
+/** @def KMK_CC_STRICT
+ * Indicates whether assertions and other checks are enabled. */
+#ifndef KMK_CC_STRICT
+# ifndef NDEBUG
+# define KMK_CC_STRICT
+# endif
+#endif
+
+#ifdef KMK_CC_STRICT
+# ifdef _MSC_VER
+# define KMK_CC_ASSERT(a_TrueExpr) do { if (!(a_TrueExpr)) __debugbreak(); } while (0)
+# elif defined(__GNUC__) && (defined(KBUILD_ARCH_X86) || defined(KBUILD_ARCH_AMD64))
+# define KMK_CC_ASSERT(a_TrueExpr) do { if (!(a_TrueExpr)) __asm__ __volatile__("int3;nop"); } while (0)
+# else
+# define KMK_CC_ASSERT(a_TrueExpr) assert(a_TrueExpr)
+# endif
+#else
+# define KMK_CC_ASSERT(a_TrueExpr) do {} while (0)
+#endif
+#define KMK_CC_ASSERT_ALIGNED(a_uValue, a_uAlignment) \
+ KMK_CC_ASSERT( ((a_uValue) & ((a_uAlignment) - 1)) == 0 )
+
+
+/** @def KMK_CC_OFFSETOF
+ * Offsetof for simple stuff. */
+#if defined(__GNUC__)
+# define KMK_CC_OFFSETOF(a_Struct, a_Member) __builtin_offsetof(a_Struct, a_Member)
+#else
+# define KMK_CC_OFFSETOF(a_Struct, a_Member) ( (uintptr_t)&( ((a_Struct *)(void *)0)->a_Member) )
+#endif
+
+/** def KMK_CC_SIZEOF_MEMBER */
+#define KMK_CC_SIZEOF_MEMBER(a_Struct, a_Member) ( sizeof( ((a_Struct *)(void *)0x1000)->a_Member) )
+
+/** @def KMK_CC_SIZEOF_VAR_STRUCT
+ * Size of a struct with a variable sized array as the final member. */
+#define KMK_CC_SIZEOF_VAR_STRUCT(a_Struct, a_FinalArrayMember, a_cArray) \
+ ( KMK_CC_OFFSETOF(a_Struct, a_FinalArrayMember) + KMK_CC_SIZEOF_MEMBER(a_Struct, a_FinalArrayMember) * (a_cArray) )
+
+
+
+/** @def KMK_CC_STATIC_ASSERT_EX
+ * Compile time assertion with text.
+ */
+#ifdef _MSC_VER_
+# if _MSC_VER >= 1600
+# define KMK_CC_STATIC_ASSERT_EX(a_Expr, a_szExpl) static_assert(a_Expr, a_szExpl)
+# else
+# define KMK_CC_STATIC_ASSERT_EX(a_Expr, a_szExpl) typedef int RTASSERTVAR[(a_Expr) ? 1 : 0]
+# endif
+#elif defined(__GNUC__) && defined(__GXX_EXPERIMENTAL_CXX0X__)
+# define KMK_CC_STATIC_ASSERT_EX(a_Expr, a_szExpl) static_assert(a_Expr, a_szExpl)
+#elif !defined(__GNUC__) && !defined(__IBMC__) && !defined(__IBMCPP__)
+# define KMK_CC_STATIC_ASSERT_EX(a_Expr, a_szExpl) typedef int KMK_CC_STATIC_ASSERT_EX_TYPE[(a_Expr) ? 1 : 0]
+#else
+# define KMK_CC_STATIC_ASSERT_EX(a_Expr, a_szExpl) extern int KMK_CC_STATIC_ASSERT_EX_VAR[(a_Expr) ? 1 : 0]
+extern int KMK_CC_STATIC_ASSERT_EX_VAR[1];
+#endif
+/** @def KMK_CC_STATIC_ASSERT
+ * Compile time assertion, simple variant.
+ */
+#define KMK_CC_STATIC_ASSERT(a_Expr) KMK_CC_STATIC_ASSERT_EX(a_Expr, #a_Expr)
+
+
+/** Aligns a size for the block allocator. */
+#define KMK_CC_BLOCK_ALIGN_SIZE(a_cb) ( ((a_cb) + (sizeof(void *) - 1U)) & ~(uint32_t)(sizeof(void *) - 1U) )
+
+/** How to declare a no-return function.
+ * Place between scope (if any) and return type. */
+#ifdef _MSC_VER
+# define KMK_CC_FN_NO_RETURN __declspec(noreturn)
+#elif defined(__GNUC__)
+# define KMK_CC_FN_NO_RETURN __attribute__((__noreturn__))
+#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
+ * @{
+ */
+#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)
+#else
+# define KMK_CC_EVAL_DPRINTF(a) do { } while (0)
+#endif
+
+/** @name KMK_CC_EVAL_QUALIFIER_XXX - Variable qualifiers.
+ * @{ */
+#define KMK_CC_EVAL_QUALIFIER_LOCAL 1
+#define KMK_CC_EVAL_QUALIFIER_EXPORT 2
+#define KMK_CC_EVAL_QUALIFIER_OVERRIDE 4
+#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.
+ * Affects stack usage in kmk_cc_eval_compile_worker. */
+#define KMK_CC_EVAL_MAX_IF_DEPTH 32
+/** Eval: Maximum number of escaped end of line sequences to track.
+ * Affects stack usage in kmk_cc_eval_compile_worker, but not the actual
+ * number of consequtive escaped newlines in the input file/variable. */
+#define KMK_CC_EVAL_MAX_ESC_EOLS 2
+
+/** Minimum keyword length. */
+#define KMK_CC_EVAL_KEYWORD_MIN 2
+/** Maximum keyword length. */
+#define KMK_CC_EVAL_KEYWORD_MAX 16
+
+/** @name KMK_CC_EVAL_CH_XXX - flags found in g_abEvalCcChars.
+ * @{ */
+/** Normal character, nothing special. */
+#define KMK_CC_EVAL_CH_NORMAL UINT16_C(0)
+/** Blank character. */
+#define KMK_CC_EVAL_CH_BLANK UINT16_C(1)
+#define KMK_CC_EVAL_IS_BLANK(a_ch) (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & KMK_CC_EVAL_CH_BLANK)
+/** Space character. */
+#define KMK_CC_EVAL_CH_SPACE UINT16_C(2)
+#define KMK_CC_EVAL_IS_SPACE(a_ch) (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & KMK_CC_EVAL_CH_SPACE)
+/** Space character or potential EOL escape backslash. */
+#define KMK_CC_EVAL_CH_SPACE_OR_BACKSLASH UINT16_C(4)
+#define KMK_CC_EVAL_IS_SPACE_OR_BACKSLASH(a_ch) (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & KMK_CC_EVAL_CH_SPACE_OR_BACKSLASH)
+/** Anything we need to take notice of when parsing something could be a
+ * variable name or a recipe.
+ * All space characters, backslash (EOL escape), variable expansion dollar,
+ * variable assignment operator chars, recipe colon and recipe percent. */
+#define KMK_CC_EVAL_CH_SPACE_VAR_OR_RECIPE UINT16_C(8)
+#define KMK_CC_EVAL_IS_SPACE_VAR_OR_RECIPE(a_ch) (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & KMK_CC_EVAL_CH_SPACE_VAR_OR_RECIPE)
+/** Dollar character (possible variable expansion). */
+#define KMK_CC_EVAL_CH_DOLLAR UINT16_C(16)
+#define KMK_CC_EVAL_IS_DOLLAR(a_ch) (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & KMK_CC_EVAL_CH_DOLLAR)
+/** Dollar character (possible variable expansion). */
+#define KMK_CC_EVAL_CH_BACKSLASH UINT16_C(32)
+#define KMK_CC_EVAL_IS_BACKSLASH(a_ch) (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & KMK_CC_EVAL_CH_BACKSLASH)
+/** Possible EOL character. */
+#define KMK_CC_EVAL_CH_EOL_CANDIDATE UINT16_C(64)
+#define KMK_CC_EVAL_IS_EOL_CANDIDATE(a_ch) (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & KMK_CC_EVAL_CH_EOL_CANDIDATE)
+/** First character in a keyword. */
+#define KMK_CC_EVAL_CH_1ST_IN_KEYWORD UINT16_C(128)
+#define KMK_CC_EVAL_IS_1ST_IN_KEYWORD(a_ch) (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & KMK_CC_EVAL_CH_1ST_IN_KEYWORD)
+/** Second character in a keyword. */
+#define KMK_CC_EVAL_CH_2ND_IN_KEYWORD UINT16_C(256)
+#define KMK_CC_EVAL_IS_2ND_IN_KEYWORD(a_ch) (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & KMK_CC_EVAL_CH_2ND_IN_KEYWORD)
+/** First character in a variable qualifier keyword or 'define'. */
+#define KMK_CC_EVAL_CH_1ST_IN_VARIABLE_KEYWORD UINT16_C(512)
+#define KMK_CC_EVAL_IS_1ST_IN_VARIABLE_KEYWORD(a_ch) (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & KMK_CC_EVAL_CH_1ST_IN_VARIABLE_KEYWORD)
+/** Used when parsing variable names, looking for the end of a nested
+ * variable reference. Matches parentheses and backslash (escaped eol). */
+#define KMK_CC_EVAL_CH_PAREN_OR_SLASH UINT16_C(1024)
+#define KMK_CC_EVAL_IS_PAREN_OR_SLASH(a_ch) (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & KMK_CC_EVAL_CH_PAREN_OR_SLASH)
+/** Used when parsing ifeq/ifneq (,) sequences.
+ * Matches parentheses, comma and dollar (for non-plain string detection). */
+#define KMK_CC_EVAL_CH_PAREN_COMMA_OR_DOLLAR UINT16_C(2048)
+#define KMK_CC_EVAL_IS_PAREN_COMMA_OR_DOLLAR(a_ch) (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & KMK_CC_EVAL_CH_PAREN_COMMA_OR_DOLLAR)
+
+/** Test of space or dollar characters. */
+#define KMK_CC_EVAL_IS_SPACE_OR_DOLLAR(a_ch) (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & (KMK_CC_EVAL_CH_SPACE | KMK_CC_EVAL_CH_DOLLAR))
+/** Test of space, dollar or backslash (possible EOL escape) characters. */
+#define KMK_CC_EVAL_IS_SPACE_DOLLAR_OR_SLASH(a_ch) (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & (KMK_CC_EVAL_CH_SPACE | KMK_CC_EVAL_CH_DOLLAR | KMK_CC_EVAL_CH_BACKSLASH))
+/** Test of space, dollar, backslash (possible EOL escape) or variable
+ * assingment characters. */
+#define KMK_CC_EVAL_IS_SPACE_DOLLAR_SLASH_OR_ASSIGN(a_ch) \
+ (KMK_CC_EVAL_BM_GET(g_abEvalCcChars, a_ch) & (KMK_CC_EVAL_CH_SPACE | KMK_CC_EVAL_CH_SPACE_VAR_OR_RECIPE | KMK_CC_EVAL_CH_DOLLAR))
+/** @} */
+
+/** Sets a bitmap entry.
+ * @param a_abBitmap Typically g_abEvalCcChars.
+ * @param a_ch The character to set.
+ * @param a_uVal The value to OR in. */
+#define KMK_CC_EVAL_BM_OR(g_abBitmap, a_ch, a_uVal) do { (g_abBitmap)[(unsigned char)(a_ch)] |= (a_uVal); } while (0)
+
+/** Gets a bitmap entry.
+ * @returns The value corresponding to @a a_ch.
+ * @param a_abBitmap Typically g_abEvalCcChars.
+ * @param a_ch The character to set. */
+#define KMK_CC_EVAL_BM_GET(g_abBitmap, a_ch) ( (g_abBitmap)[(unsigned char)(a_ch)] )
+
+/** @} */
+
+
+/*********************************************************************************************************************************
+* Structures and Typedefs *
+*********************************************************************************************************************************/
+/**
+ * Block of instructions.
+ *
+ * To avoid wasting space on "next" pointers, as well as a lot of time walking
+ * these chains when destroying programs, we work with blocks of instructions.
+ */
+typedef struct kmk_cc_block
+{
+ /** The pointer to the next block (LIFO). */
+ struct kmk_cc_block *pNext;
+ /** The size of this block. */
+ uint32_t cbBlock;
+ /** The offset of the next free byte in the block. When set to cbBlock the
+ * block is 100% full. */
+ uint32_t offNext;
+} KMKCCBLOCK;
+typedef KMKCCBLOCK *PKMKCCBLOCK;
+
+
+/** @defgroup grp_kmk_cc_exp String Expansion
+ * @{*/
+
+/**
+ * String expansion statistics.
+ */
+typedef struct KMKCCEXPSTATS
+{
+ /** Recent average size. */
+ uint32_t cchAvg;
+} KMKCCEXPSTATS;
+typedef KMKCCEXPSTATS *PKMKCCEXPSTATS;
+
+/**
+ * Expansion instructions.
+ */
+typedef enum KMKCCEXPINSTR
+{
+ /** Copy a plain string. */
+ kKmkCcExpInstr_CopyString = 0,
+ /** Insert an expanded variable value, which name we already know. */
+ kKmkCcExpInstr_PlainVariable,
+ /** 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. (Dynamic is perhaps not such a great name, but whatever.) */
+ kKmkCcExpInstr_DynamicFunction,
+ /** Jump to a new instruction block. */
+ kKmkCcExpInstr_Jump,
+ /** We're done, return. Has no specific structure. */
+ kKmkCcExpInstr_Return,
+ /** The end of valid instructions (exclusive). */
+ kKmkCcExpInstr_End
+} KMKCCEXPINSTR;
+
+/** Instruction core. */
+typedef struct kmk_cc_exp_core
+{
+ /** The instruction opcode number (KMKCCEXPINSTR). */
+ KMKCCEXPINSTR enmOpcode;
+} KMKCCEXPCORE;
+typedef KMKCCEXPCORE *PKMKCCEXPCORE;
+
+/**
+ * String expansion subprogram.
+ */
+#pragma pack(1) /* save some precious bytes */
+typedef struct kmk_cc_exp_subprog
+{
+ /** Pointer to the first instruction. */
+ PKMKCCEXPCORE pFirstInstr;
+ /** Statistics. */
+ KMKCCEXPSTATS Stats;
+} KMKCCEXPSUBPROG;
+#pragma pack()
+typedef KMKCCEXPSUBPROG *PKMKCCEXPSUBPROG;
+KMK_CC_STATIC_ASSERT(sizeof(KMKCCEXPSUBPROG) == 12 || sizeof(void *) != 8);
+
+
+/**
+ * String expansion subprogram or plain string.
+ */
+#pragma pack(1) /* save some precious bytes */
+typedef struct kmk_cc_exp_subprog_or_string
+{
+ /** Either a plain string pointer or a subprogram. */
+ union
+ {
+ /** Subprogram for expanding this argument. */
+ KMKCCEXPSUBPROG Subprog;
+ /** Pointer to the plain string. */
+ struct
+ {
+ /** Pointer to the string. */
+ const char *psz;
+ /** String length. */
+ uint32_t cch;
+ } Plain;
+ } u;
+ /** Set if subprogram (u.Subprog), clear if plain string (u.Plain). */
+ uint8_t fSubprog;
+ /** Set if the plain string is kept in the variable_strcache.
+ * @remarks Here rather than in u.Plain to make use of alignment padding. */
+ uint8_t fPlainIsInVarStrCache;
+ /** Context/user specific. */
+ uint8_t bUser;
+ /** Context/user specific #2. */
+ uint8_t bUser2;
+} KMKCCEXPSUBPROGORPLAIN;
+#pragma pack()
+typedef KMKCCEXPSUBPROGORPLAIN *PKMKCCEXPSUBPROGORPLAIN;
+KMK_CC_STATIC_ASSERT( sizeof(void *) == 8
+ ? sizeof(KMKCCEXPSUBPROGORPLAIN) == 16
+ : sizeof(void *) == 4
+ ? sizeof(KMKCCEXPSUBPROGORPLAIN) == 12
+ : 1);
+
+/**
+ * kKmkCcExpInstr_CopyString instruction format.
+ */
+typedef struct kmk_cc_exp_copy_string
+{
+ /** The core instruction. */
+ KMKCCEXPCORE Core;
+ /** The number of bytes to copy. */
+ uint32_t cchCopy;
+ /** Pointer to the source string (not terminated at cchCopy). */
+ const char *pachSrc;
+} KMKCCEXPCOPYSTRING;
+typedef KMKCCEXPCOPYSTRING *PKMKCCEXPCOPYSTRING;
+
+/**
+ * kKmkCcExpInstr_PlainVariable instruction format.
+ */
+typedef struct kmk_cc_exp_plain_variable
+{
+ /** The core instruction. */
+ KMKCCEXPCORE Core;
+ /** 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;
+ /** The subprogram that will give us the variable name. */
+ KMKCCEXPSUBPROG Subprog;
+ /** Where to continue after this instruction. (This is necessary since the
+ * instructions of the subprogram are emitted after this instruction.) */
+ PKMKCCEXPCORE pNext;
+} KMKCCEXPDYNVAR;
+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
+{
+ /** The core instruction. */
+ KMKCCEXPCORE Core;
+ /** Number of arguments. */
+ uint32_t cArgs; /**< @todo uint16_t to save 7 bytes of unecessary alignment padding on 64-bit systems, or merge fDirty into this member. */
+ /** Set if the function could be modifying the input arguments. */
+ uint8_t fDirty;
+ /** 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;
+ /**
+ * Pointer to the function table entry.
+ *
+ * @returns New variable buffer position.
+ * @param pchDst Current variable buffer position.
+ * @param papszArgs Pointer to a NULL terminated array of argument strings.
+ * @param pszFuncName The name of the function being called.
+ */
+ char * (*pfnFunction)(char *pchDst, char **papszArgs, const char *pszFuncName);
+ /** Pointer to the function name in the variable string cache. */
+ const char *pszFuncName;
+} KMKCCEXPFUNCCORE;
+typedef KMKCCEXPFUNCCORE *PKMKCCEXPFUNCCORE;
+
+/**
+ * Instruction format for kKmkCcExpInstr_PlainFunction.
+ */
+typedef struct kmk_cc_exp_plain_function
+{
+ /** The bits comment to both plain and dynamic functions. */
+ KMKCCEXPFUNCCORE FnCore;
+ /** Variable sized argument list (cArgs + 1 in length, last entry is NULL).
+ * The string pointers are to memory following this instruction, to memory in
+ * the next block or to memory in the variable / makefile we're working on
+ * (if zero terminated appropriately). */
+ const char *apszArgs[1];
+} KMKCCEXPPLAINFUNC;
+typedef KMKCCEXPPLAINFUNC *PKMKCCEXPPLAINFUNC;
+/** Calculates the size of an KMKCCEXPPLAINFUNC structure with the apszArgs
+ * member holding a_cArgs entries plus a NULL terminator. */
+#define KMKCCEXPPLAINFUNC_SIZE(a_cArgs) KMK_CC_SIZEOF_VAR_STRUCT(KMKCCEXPDYNFUNC, aArgs, (a_cArgs) + 1)
+
+/**
+ * Instruction format for kKmkCcExpInstr_DynamicFunction.
+ */
+typedef struct kmk_cc_exp_dyn_function
+{
+ /** The bits comment to both plain and dynamic functions. */
+ KMKCCEXPFUNCCORE FnCore;
+ /** Variable sized argument list (FnCore.cArgs in length).
+ * The subprograms / strings are allocated after this array (or in the next
+ * block). */
+ KMKCCEXPSUBPROGORPLAIN aArgs[1];
+} KMKCCEXPDYNFUNC;
+typedef KMKCCEXPDYNFUNC *PKMKCCEXPDYNFUNC;
+/** Calculates the size of an KMKCCEXPDYNFUNC structure with the apszArgs
+ * member holding a_cArgs entries (no zero terminator). */
+#define KMKCCEXPDYNFUNC_SIZE(a_cArgs) KMK_CC_SIZEOF_VAR_STRUCT(KMKCCEXPDYNFUNC, aArgs, a_cArgs)
+
+/**
+ * Instruction format for kKmkCcExpInstr_Jump.
+ */
+typedef struct kmk_cc_exp_jump
+{
+ /** The core instruction. */
+ KMKCCEXPCORE Core;
+ /** Where to jump to (new instruction block, typically). */
+ PKMKCCEXPCORE pNext;
+} KMKCCEXPJUMP;
+typedef KMKCCEXPJUMP *PKMKCCEXPJUMP;
+
+/**
+ * String expansion program.
+ */
+typedef struct kmk_cc_expandprog
+{
+ /** Pointer to the first instruction for this program. */
+ PKMKCCEXPCORE pFirstInstr;
+ /** List of blocks for this program (LIFO). */
+ PKMKCCBLOCK pBlockTail;
+ /** Statistics. */
+ KMKCCEXPSTATS Stats;
+#ifdef KMK_CC_STRICT
+ /** The hash of the input string. Used to check that we get all the change
+ * notifications we require. */
+ uint32_t uInputHash;
+#endif
+ /** Reference count. */
+ uint32_t volatile cRefs;
+} KMKCCEXPPROG;
+/** Pointer to a string expansion program. */
+typedef KMKCCEXPPROG *PKMKCCEXPPROG;
+
+/** @} */
+
+
+/** @addtogroup grp_kmk_cc_evalprog
+ * @{ */
+
+/** Pointer to a makefile evaluation program. */
+typedef struct kmk_cc_evalprog *PKMKCCEVALPROG;
+
+/**
+ * Makefile evaluation instructions.
+ */
+typedef enum KMKCCEVALINSTR
+{
+ /** Jump instruction - KMKCCEVALJUMP. */
+ kKmkCcEvalInstr_jump = 0,
+
+ /** [local|override|export] variable = value - KMKCCEVALASSIGN.
+ * @note Can be used for target-specific variables. */
+ kKmkCcEvalInstr_assign_recursive,
+ /** [local|override|export] variable := value - KMKCCEVALASSIGN.
+ * Also: [local|override|export] define variable := ... endef
+ * @note Can be used for target-specific variables. */
+ kKmkCcEvalInstr_assign_simple,
+ /** [local|override|export] variable += value - KMKCCEVALASSIGN.
+ * Also: [local|override|export] define variable += ... endef
+ * @note Can be used for target-specific variables. */
+ kKmkCcEvalInstr_assign_append,
+ /** [local|override|export] variable <= value - KMKCCEVALASSIGN.
+ * Also: [local|override|export] define variable <= ... endef
+ * @note Can be used for target-specific variables. */
+ kKmkCcEvalInstr_assign_prepend,
+ /** [local|override|export] variable ?= value - KMKCCEVALASSIGN.
+ * @note Can be used for target-specific variables. */
+ kKmkCcEvalInstr_assign_if_new,
+ /* [local|override|export] define variable[=] ... endef - KMKCCEVALASSIGNDEF. */
+ kKmkCcEvalInstr_define_recursive,
+ /* [local|override|export] define variable ?= ... endef - KMKCCEVALASSIGNDEF. */
+ kKmkCcEvalInstr_define_if_new,
+
+ /** export variable1 [variable2...] - KMKCCEVALVARIABLES. */
+ kKmkCcEvalInstr_export,
+ /** unexport variable1 [variable2...] - KMKCCEVALVARIABLES. */
+ kKmkCcEvalInstr_unexport,
+ /** export - KMKCCEVALCORE. */
+ kKmkCcEvalInstr_export_all,
+ /** unexport - KMKCCEVALCORE. */
+ kKmkCcEvalInstr_unexport_all,
+ /** [local|override] undefine - KMKCCEVALVARIABLES. */
+ kKmkCcEvalInstr_undefine,
+
+ /** [else] ifdef variable - KMKCCEVALIFDEFPLAIN. */
+ kKmkCcEvalInstr_ifdef_plain,
+ /** [else] ifndef variable - KMKCCEVALIFDEFPLAIN. */
+ kKmkCcEvalInstr_ifndef_plain,
+ /** [else] ifdef variable - KMKCCEVALIFDEFDYNAMIC. */
+ kKmkCcEvalInstr_ifdef_dynamic,
+ /** [else] ifndef variable - KMKCCEVALIFDEFDYNAMIC. */
+ kKmkCcEvalInstr_ifndef_dynamic,
+ /** [else] ifeq (a,b) - KMKCCEVALIFEQ. */
+ kKmkCcEvalInstr_ifeq,
+ /** [else] ifeq (a,b) - KMKCCEVALIFEQ. */
+ kKmkCcEvalInstr_ifneq,
+ /** [else] if1of (set-a,set-b) - KMKCCEVALIF1OF. */
+ kKmkCcEvalInstr_if1of,
+ /** [else] ifn1of (set-a,set-b) - KMKCCEVALIF1OF. */
+ kKmkCcEvalInstr_ifn1of,
+ /** [else] if expr - KMKCCEVALIFEXPR. */
+ kKmkCcEvalInstr_if,
+
+ /** include file1 [file2...] - KMKCCEVALINCLUDE. */
+ kKmkCcEvalInstr_include,
+ /** [sinclude|-include] file1 [file2...] - KMKCCEVALINCLUDE. */
+ kKmkCcEvalInstr_include_silent,
+ /** includedep file1 [file2...] - KMKCCEVALINCLUDE. */
+ kKmkCcEvalInstr_includedep,
+ /** includedep-queue file1 [file2...] - KMKCCEVALINCLUDE. */
+ kKmkCcEvalInstr_includedep_queue,
+ /** includedep-flush file1 [file2...] - KMKCCEVALINCLUDE. */
+ kKmkCcEvalInstr_includedep_flush,
+
+ /** Recipe without commands (defines dependencies) - KMKCCEVALRECIPE. */
+ kKmkCcEvalInstr_recipe_no_commands,
+ /** Recipe with commands (defines dependencies) - KMKCCEVALRECIPE. */
+ kKmkCcEvalInstr_recipe_start_normal,
+ /** Recipe with commands (defines dependencies) - KMKCCEVALRECIPE. */
+ kKmkCcEvalInstr_recipe_start_double_colon,
+ /** Recipe with commands (defines dependencies) - KMKCCEVALRECIPE. */
+ kKmkCcEvalInstr_recipe_start_pattern,
+ /** Adds more commands to the current recipe - KMKCCEVALRECIPECOMMANDS. */
+ kKmkCcEvalInstr_recipe_commands,
+ /** Special instruction for indicating the end of the recipe commands - KMKCCEVALCORE. */
+ kKmkCcEvalInstr_recipe_end,
+ /** Cancel previously defined pattern rule - KMKCCEVALRECIPE. */
+ kKmkCcEvalInstr_recipe_cancel_pattern,
+
+/** @todo target variables. */
+
+ /** vpath pattern directories - KMKCCEVALVPATH. */
+ kKmkCcEvalInstr_vpath,
+ /** vpath pattern directories - KMKCCEVALVPATH. */
+ kKmkCcEvalInstr_vpath_clear_pattern,
+ /** 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). */
+ kKmkCcEvalInstr_End
+} KMKCCEVALINSTR;
+
+/**
+ * Instruction core common to all instructions.
+ */
+typedef struct kmk_cc_eval_core
+{
+ /** The instruction opcode number (KMKCCEVALINSTR). */
+ KMKCCEVALINSTR enmOpcode;
+ /** The line number in the source this statement is associated with. */
+ unsigned iLine;
+} KMKCCEVALCORE;
+/** Pointer to an instruction core structure. */
+typedef KMKCCEVALCORE *PKMKCCEVALCORE;
+
+/**
+ * Instruction format for kKmkCcEvalInstr_jump.
+ */
+typedef struct kmk_cc_eval_jump
+{
+ /** The core instruction. */
+ KMKCCEVALCORE Core;
+ /** Where to jump to (new instruction block or endif, typically). */
+ PKMKCCEVALCORE pNext;
+} KMKCCEVALJUMP;
+typedef KMKCCEVALJUMP *PKMKCCEVALJUMP;
+
+/**
+ * Instruction format for kKmkCcEvalInstr_assign_recursive,
+ * kKmkCcEvalInstr_assign_simple, kKmkCcEvalInstr_assign_append,
+ * kKmkCcEvalInstr_assign_prepend and kKmkCcEvalInstr_assign_if_new.
+ */
+typedef struct kmk_cc_eval_assign
+{
+ /** The core instruction. */
+ KMKCCEVALCORE Core;
+ /** Whether the 'export' qualifier was used. */
+ uint8_t fExport;
+ /** Whether the 'override' qualifier was used. */
+ uint8_t fOverride;
+ /** Whether the 'local' qualifier was used. */
+ uint8_t fLocal;
+ /** Whether the 'private' qualifier was used. */
+ uint8_t fPrivate;
+ /** The variable name.
+ * @remarks Plain text names are in variable_strcache. */
+ KMKCCEXPSUBPROGORPLAIN Variable;
+ /** The value or value expression. */
+ KMKCCEXPSUBPROGORPLAIN Value;
+ /** Pointer to the next instruction. */
+ PKMKCCEVALCORE pNext;
+} KMKCCEVALASSIGN;
+typedef KMKCCEVALASSIGN *PKMKCCEVALASSIGN;
+
+/**
+ * Instruction format for kKmkCcEvalInstr_define_recursive and
+ * kKmkCcEvalInstr_define_if_new.
+ */
+typedef struct kmk_cc_eval_assign_define
+{
+ /** The assignment core structure. */
+ KMKCCEVALASSIGN AssignCore;
+ /** Makefile evaluation program compiled from the define.
+ * NULL if it does not compile.
+ * @todo Let's see if this is actually doable... */
+ PKMKCCEVALPROG pEvalProg;
+} KMKCCEVALASSIGNDEF;
+typedef KMKCCEVALASSIGNDEF *PKMKCCEVALASSIGNDEF;
+
+/**
+ * Instruction format for kKmkCcEvalInstr_export, kKmkCcEvalInstr_unexport and
+ * kKmkCcEvalInstr_undefine.
+ */
+typedef struct kmk_cc_eval_variables
+{
+ /** The core instruction. */
+ KMKCCEVALCORE Core;
+ /** 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;
+ /** The variable names.
+ * Expressions will be expanded and split on space.
+ * @remarks Plain text names are in variable_strcache. */
+ KMKCCEXPSUBPROGORPLAIN aVars[1];
+} 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)
+
+/**
+ * Core structure for all conditionals (kKmkCcEvalInstr_if*).
+ */
+typedef struct kmk_cc_eval_if_core
+{
+ /** The core instruction. */
+ KMKCCEVALCORE Core;
+ /** Condition true: Pointer to the next instruction. */
+ PKMKCCEVALCORE pNextTrue;
+ /** Condition false: Pointer to the next instruction (i.e. 'else if*'
+ * or whatever follows 'else' / 'endif'. */
+ PKMKCCEVALCORE pNextFalse;
+ /** Pointer to the previous conditional for 'else if*' directives.
+ * This is only to assist the compilation process. */
+ struct kmk_cc_eval_if_core *pPrevCond;
+ /** Pointer to the jump out of the true block, if followed by 'else'.
+ * This is only to assist the compilation process. */
+ PKMKCCEVALJUMP pTrueEndJump;
+} KMKCCEVALIFCORE;
+typedef KMKCCEVALIFCORE *PKMKCCEVALIFCORE;
+
+/**
+ * Instruction format for kKmkCcEvalInstr_ifdef_plain and
+ * kKmkCcEvalInstr_ifndef_plain.
+ * The variable name is known at compilation time.
+ */
+typedef struct kmk_cc_eval_ifdef_plain
+{
+ /** The 'if' core structure. */
+ KMKCCEVALIFCORE IfCore;
+ /** The name of the variable (points into variable_strcache). */
+ const char *pszName;
+} KMKCCEVALIFDEFPLAIN;
+typedef KMKCCEVALIFDEFPLAIN *PKMKCCEVALIFDEFPLAIN;
+
+/**
+ * Instruction format for kKmkCcEvalInstr_ifdef_dynamic and
+ * kKmkCcEvalInstr_ifndef_dynamic.
+ * The variable name is dynamically expanded at run time.
+ */
+typedef struct kmk_cc_eval_ifdef_dynamic
+{
+ /** The 'if' core structure. */
+ KMKCCEVALIFCORE IfCore;
+ /** Alignment padding, MBZ. */
+ KU32 uPadding;
+ /** The subprogram that will give us the variable name. */
+ KMKCCEXPSUBPROG NameSubprog;
+} KMKCCEVALIFDEFDYNAMIC;
+typedef KMKCCEVALIFDEFDYNAMIC *PKMKCCEVALIFDEFDYNAMIC;
+
+/**
+ * Instruction format for kKmkCcEvalInstr_ifeq and kKmkCcEvalInstr_ifneq.
+ */
+typedef struct kmk_cc_eval_ifeq
+{
+ /** The 'if' core structure. */
+ KMKCCEVALIFCORE IfCore;
+ /** The left hand side string expression (dynamic or plain). */
+ KMKCCEXPSUBPROGORPLAIN Left;
+ /** The rigth hand side string expression (dynamic or plain). */
+ KMKCCEXPSUBPROGORPLAIN Right;
+} KMKCCEVALIFEQ;
+typedef KMKCCEVALIFEQ *PKMKCCEVALIFEQ;
+
+/**
+ * Instruction format for kKmkCcEvalInstr_if1of and kKmkCcEvalInstr_ifn1of.
+ *
+ * @todo This can be optimized further by pre-hashing plain text items. One of
+ * the sides are usually plain text.
+ */
+typedef struct kmk_cc_eval_if1of
+{
+ /** The 'if' core structure. */
+ KMKCCEVALIFCORE IfCore;
+ /** The left hand side string expression (dynamic or plain). */
+ KMKCCEXPSUBPROGORPLAIN Left;
+ /** The rigth hand side string expression (dynamic or plain). */
+ KMKCCEXPSUBPROGORPLAIN Right;
+} KMKCCEVALIF1OF;
+typedef KMKCCEVALIF1OF *PKMKCCEVALIF1OF;
+
+/**
+ * Instruction format for kKmkCcEvalInstr_if.
+ *
+ * @todo Parse and compile the expression. At least strip whitespace in it.
+ */
+typedef struct kmk_cc_eval_if_expr
+{
+ /** The 'if' core structure. */
+ KMKCCEVALIFCORE IfCore;
+ /** The expression string length. */
+ uint16_t cchExpr;
+ /** The expression string. */
+ char szExpr[1];
+} KMKCCEVALIFEXPR;
+typedef KMKCCEVALIFEXPR *PKMKCCEVALIFEXPR;
+/** Calculates the size of an KMKCCEVALIFEXPR structure for @a a_cchExpr long
+ * expression string (terminator is automatically added). */
+#define KMKCCEVALIFEXPR_SIZE(a_cchExpr) KMK_CC_BLOCK_ALIGN_SIZE(KMK_CC_SIZEOF_VAR_STRUCT(KMKCCEVALIFEXPR, szExpr, (a_cchExpr) + 1))
+
+/**
+ * Instruction format for kKmkCcEvalInstr_include,
+ * kKmkCcEvalInstr_include_silent, kKmkCcEvalInstr_includedep,
+ * kKmkCcEvalInstr_includedep_queue, kKmkCcEvalInstr_includedep_flush.
+ */
+typedef struct kmk_cc_eval_include
+{
+ /** The core instruction. */
+ KMKCCEVALCORE Core;
+ /** The number of files. */
+ uint32_t cFiles;
+ /** Pointer to the next instruction (subprogs and strings after this one). */
+ PKMKCCEVALCORE pNext;
+ /** The files to be included.
+ * Expressions will be expanded and split on space.
+ * @todo Plain text file name could be replaced by file string cache entries. */
+ KMKCCEXPSUBPROGORPLAIN aFiles[1];
+} KMKCCEVALINCLUDE;
+typedef KMKCCEVALINCLUDE *PKMKCCEVALINCLUDE;
+/** Calculates the size of an KMKCCEVALINCLUDE structure for @a a_cFiles files. */
+#define KMKCCEVALINCLUDE_SIZE(a_cFiles) KMK_CC_SIZEOF_VAR_STRUCT(KMKCCEVALINCLUDE, aFiles, a_cFiles)
+
+/**
+ * Instruction format for kKmkCcEvalInstr_recipe_no_commands,
+ * kKmkCcEvalInstr_recipe_start_normal,
+ * kKmkCcEvalInstr_recipe_start_double_colon, kKmkCcEvalInstr_includedep_queue,
+ * kKmkCcEvalInstr_recipe_start_pattern.
+ */
+typedef struct kmk_cc_eval_recipe
+{
+ /** The core instruction. */
+ KMKCCEVALCORE Core;
+ /** The total number of files and dependencies in aFilesAndDeps. */
+ uint16_t cFilesAndDeps;
+
+ /** Number of targets (from index 0).
+ * This is always 1 if this is an explicit multitarget or pattern recipe,
+ * indicating the main target. */
+ uint16_t cTargets;
+ /** Explicit multitarget & patterns: First always made target. */
+ uint16_t iFirstAlwaysMadeTargets;
+ /** Explicit multitarget & patterns: Number of always targets. */
+ uint16_t cAlwaysMadeTargets;
+ /** Explicit multitarget: First maybe made target. */
+ uint16_t iFirstMaybeTarget;
+ /** Explicit multitarget: Number of maybe made targets. */
+ uint16_t cMaybeTargets;
+
+ /** First dependency. */
+ uint16_t iFirstDep;
+ /** Number of ordinary dependencies. */
+ uint16_t cDeps;
+ /** First order only dependency. */
+ uint16_t iFirstOrderOnlyDep;
+ /** Number of ordinary dependencies. */
+ uint16_t cOrderOnlyDeps;
+
+ /** Pointer to the next instruction (subprogs and strings after this one). */
+ PKMKCCEVALCORE pNext;
+ /** The .MUST_MAKE variable value, if present.
+ * If not present, this is a zero length plain string. */
+ KMKCCEXPSUBPROGORPLAIN MustMake;
+ /** The target files and dependencies.
+ * This is sorted into several sections, as defined by the above indexes and
+ * counts. Expressions will be expanded and split on space.
+ *
+ * The KMKCCEXPSUBPROGORPLAIN::bUser member one of KMKCCEVALRECIPE_FD_XXX.
+ *
+ * @todo Plain text file name could be replaced by file string cache entries. */
+ KMKCCEXPSUBPROGORPLAIN aFilesAndDeps[1];
+} KMKCCEVALRECIPE;
+typedef KMKCCEVALRECIPE *PKMKCCEVALRECIPE;
+/** Calculates the size of an KMKCCEVALRECIPE structure for @a a_cFiles
+ * files. */
+#define KMKCCEVALRECIPE_SIZE(a_cFilesAndDeps) KMK_CC_SIZEOF_VAR_STRUCT(KMKCCEVALRECIPE, aFilesAndDeps, a_cFilesAndDeps)
+/** @name KMKCCEVALRECIPE_FD_XXX - Values for KMKCCEVALRECIPE::aFilesAndDeps[x].bUser
+ * @{ */
+#define KMKCCEVALRECIPE_FD_NORMAL 0
+#define KMKCCEVALRECIPE_FD_SEC_EXP 1
+#define KMKCCEVALRECIPE_FD_SPECIAL_POSIX 2
+#define KMKCCEVALRECIPE_FD_SPECIAL_SECONDEXPANSION 3
+#define KMKCCEVALRECIPE_FD_SPECIAL_ONESHELL 4
+/** @} */
+
+
+/**
+ * Instruction format for kKmkCcEvalInstr_recipe_commands.
+ */
+typedef struct kmk_cc_eval_recipe_commands
+{
+ /** The core instruction. */
+ KMKCCEVALCORE Core;
+ /** 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 newline? */
+ KMKCCEXPSUBPROGORPLAIN aCommands[1];
+} KMKCCEVALRECIPECOMMANDS;
+typedef KMKCCEVALRECIPECOMMANDS *PKMKCCEVALRECIPECOMMANDS;
+/** Calculates the size of an KMKCCEVALRECIPECOMMANDS structure for
+ * @a a_cCommands commands. */
+#define KMKCCEVALRECIPECOMMANDS_SIZE(a_cCommands) KMK_CC_SIZEOF_VAR_STRUCT(KMKCCEVALRECIPECOMMANDS, aCommands, a_cCommands)
+
+/**
+ * Instruction format for kKmkCcEvalInstr_vpath and
+ * kKmkCcEvalInstr_vpath_clear_pattern.
+ */
+typedef struct kmk_cc_eval_vpath
+{
+ /** The core instruction. */
+ KMKCCEVALCORE Core;
+ /** The number of search directories.
+ * This will be zero for kKmkCcEvalInstr_vpath_clear_pattern. */
+ uint32_t cDirs;
+ /** Pointer to the next instruction (subprogs and strings after this one). */
+ PKMKCCEVALCORE pNext;
+ /** The pattern. */
+ KMKCCEXPSUBPROGORPLAIN Pattern;
+ /** The directory. Expressions will be expanded and split on space. */
+ KMKCCEXPSUBPROGORPLAIN aDirs[1];
+} KMKCCEVALVPATH;
+typedef KMKCCEVALVPATH *PKMKCCEVALVPATH;
+/** 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;
+
+
+/**
+ * Makefile evaluation program.
+ */
+typedef struct kmk_cc_evalprog
+{
+ /** Pointer to the first instruction for this program. */
+ PKMKCCEVALCORE pFirstInstr;
+ /** List of blocks for this program (LIFO). */
+ PKMKCCBLOCK pBlockTail;
+ /** The name of the file containing this program. */
+ const char *pszFilename;
+ /** The name of the variable containing this program, if applicable. */
+ const char *pszVarName;
+#ifdef KMK_CC_STRICT
+ /** The hash of the input string. Used to check that we get all the change
+ * notifications we require. */
+ uint32_t uInputHash;
+#endif
+ /** Reference count. */
+ uint32_t volatile cRefs;
+} KMKCCEVALPROG;
+typedef KMKCCEVALPROG *PKMKCCEVALPROG;
+
+/** @} */
+
+
+/*********************************************************************************************************************************
+* Global Variables *
+*********************************************************************************************************************************/
+static uint32_t g_cVarForExpandCompilations = 0;
+static uint32_t g_cVarForExpandExecs = 0;
+static uint32_t g_cVarForEvalCompilations = 0;
+static uint32_t g_cVarForEvalExecs = 0;
+static uint32_t g_cFileForEvalCompilations = 0;
+static uint32_t g_cFileForEvalExecs = 0;
+#ifdef KMK_CC_WITH_STATS
+static uint32_t g_cBlockAllocated = 0;
+static uint32_t g_cbAllocated = 0;
+
+static uint32_t g_cBlocksAllocatedExpProgs = 0;
+static uint32_t g_cbAllocatedExpProgs = 0;
+static uint32_t g_cSingleBlockExpProgs = 0;
+static uint32_t g_cTwoBlockExpProgs = 0;
+static uint32_t g_cMultiBlockExpProgs = 0;
+static uint32_t g_cbUnusedMemExpProgs = 0;
+
+static uint32_t g_cBlocksAllocatedEvalProgs = 0;
+static uint32_t g_cbAllocatedEvalProgs = 0;
+static uint32_t g_cSingleBlockEvalProgs = 0;
+static uint32_t g_cTwoBlockEvalProgs = 0;
+static uint32_t g_cMultiBlockEvalProgs = 0;
+static uint32_t g_cbUnusedMemEvalProgs = 0;
+
+#endif
+
+/** Generic character classification, taking an 'unsigned char' index.
+ * ASSUMES unsigned char is 8-bits. */
+static uint16_t g_abEvalCcChars[256];
+
+
+/**
+ * Makefile evaluation keywords.
+ */
+static const char * const g_apszEvalKeywords[] =
+{
+ "define",
+ "export",
+ "else",
+ "endef",
+ "endif",
+ "ifdef",
+ "ifndef",
+ "ifeq",
+ "ifneq",
+ "if1of",
+ "ifn1of",
+ "if",
+ "include",
+ "includedep",
+ "includedep-queue",
+ "includedep-flush",
+ "local",
+ "override",
+ "private",
+ "sinclude",
+ "unexport",
+ "undefine",
+ "vpath",
+ "-include",
+};
+
+
+/** This is parallel to KMKCCEVALINSTR. */
+static const char * const g_apszEvalInstrNms[] =
+{
+ "jump",
+ "assign_recursive",
+ "assign_simple",
+ "assign_append",
+ "assign_prepend",
+ "assign_if_new",
+ "define_recursive",
+ "define_if_new",
+ "export",
+ "unexport",
+ "export_all",
+ "unexport_all",
+ "undefine",
+ "ifdef_plain",
+ "ifndef_plain",
+ "ifdef_dynamic",
+ "ifndef_dynamic",
+ "ifeq",
+ "ifneq",
+ "if1of",
+ "ifn1of",
+ "if",
+ "include",
+ "include_silent",
+ "includedep",
+ "includedep_queue",
+ "includedep_flush",
+ "recipe_no_commands",
+ "recipe_start_normal",
+ "recipe_start_double_colon",
+ "recipe_start_pattern",
+ "recipe_commands",
+ "recipe_end",
+ "recipe_cancel_pattern",
+ "vpath",
+ "vpath_clear_pattern",
+ "vpath_clear_all",
+};
+
+/*********************************************************************************************************************************
+* Internal Functions *
+*********************************************************************************************************************************/
+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);
+
+
+/**
+ * Initializes global variables for the 'compiler'.
+ */
+void kmk_cc_init(void)
+{
+ unsigned i;
+
+ /*
+ * Initialize the bitmap.
+ */
+ memset(g_abEvalCcChars, 0, sizeof(g_abEvalCcChars));
+
+ /* blank chars */
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, ' ', KMK_CC_EVAL_CH_BLANK);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '\t', KMK_CC_EVAL_CH_BLANK);
+
+ /* space chars and zero terminator. */
+#define MY_SPACE_BITS KMK_CC_EVAL_CH_SPACE | KMK_CC_EVAL_CH_SPACE_OR_BACKSLASH | KMK_CC_EVAL_CH_SPACE_VAR_OR_RECIPE
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, ' ', MY_SPACE_BITS);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '\t', MY_SPACE_BITS);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '\n', MY_SPACE_BITS | KMK_CC_EVAL_CH_EOL_CANDIDATE);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '\v', MY_SPACE_BITS);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '\f', MY_SPACE_BITS);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '\r', MY_SPACE_BITS | KMK_CC_EVAL_CH_EOL_CANDIDATE);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '\\', KMK_CC_EVAL_CH_SPACE_OR_BACKSLASH | KMK_CC_EVAL_CH_SPACE_VAR_OR_RECIPE);
+#undef MY_SPACE_BITS
+
+ /* keywords */
+ 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);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, g_apszEvalKeywords[i][1], KMK_CC_EVAL_CH_2ND_IN_KEYWORD);
+ }
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, 'd', KMK_CC_EVAL_CH_1ST_IN_VARIABLE_KEYWORD); /* define */
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, 'e', KMK_CC_EVAL_CH_1ST_IN_VARIABLE_KEYWORD); /* export, endef */
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, 'l', KMK_CC_EVAL_CH_1ST_IN_VARIABLE_KEYWORD); /* local */
+ 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, unexport */
+
+ /* Assignment punctuation and recipe stuff. */
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '=', KMK_CC_EVAL_CH_SPACE_VAR_OR_RECIPE);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, ':', KMK_CC_EVAL_CH_SPACE_VAR_OR_RECIPE);
+
+ /* For locating the end of variable expansion. */
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '(', KMK_CC_EVAL_CH_PAREN_OR_SLASH);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, ')', KMK_CC_EVAL_CH_PAREN_OR_SLASH);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '{', KMK_CC_EVAL_CH_PAREN_OR_SLASH);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '}', KMK_CC_EVAL_CH_PAREN_OR_SLASH);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '\\', KMK_CC_EVAL_CH_PAREN_OR_SLASH);
+
+ /* For parsing ifeq and if1of expressions. (GNU weirdly does not respect {} style function references.) */
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '(', KMK_CC_EVAL_CH_PAREN_COMMA_OR_DOLLAR);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, ')', KMK_CC_EVAL_CH_PAREN_COMMA_OR_DOLLAR);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, ',', KMK_CC_EVAL_CH_PAREN_COMMA_OR_DOLLAR);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '$', KMK_CC_EVAL_CH_PAREN_COMMA_OR_DOLLAR);
+
+ /* Misc. */
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '$', KMK_CC_EVAL_CH_DOLLAR);
+ KMK_CC_EVAL_BM_OR(g_abEvalCcChars, '\\', KMK_CC_EVAL_CH_BACKSLASH);
+
+ /*
+ * Check that the eval instruction names match up.
+ */
+ KMK_CC_ASSERT(strcmp(g_apszEvalInstrNms[kKmkCcEvalInstr_ifneq], "ifneq") == 0);
+ KMK_CC_ASSERT(strcmp(g_apszEvalInstrNms[kKmkCcEvalInstr_vpath_clear_all], "vpath_clear_all") == 0);
+}
+
+
+/**
+ * Prints stats (for kmk -p).
+ */
+void kmk_cc_print_stats(void)
+{
+#ifdef KMK_CC_WITH_STATS
+ uint32_t const cEvalCompilations = g_cFileForEvalCompilations + g_cVarForEvalCompilations;
+#endif
+
+ puts(_("\n# The kmk 'compiler' and kmk 'program executor':\n"));
+
+ printf(_("# Variables compiled for string expansion: %6u\n"), g_cVarForExpandCompilations);
+ printf(_("# Variables string expansion runs: %6u\n"), g_cVarForExpandExecs);
+ printf(_("# String expansion runs per compile: %6u\n"), g_cVarForExpandExecs / g_cVarForExpandCompilations);
+#ifdef KMK_CC_WITH_STATS
+ printf(_("# Single alloc block exp progs: %6u (%u%%)\n"
+ "# Two alloc block exp progs: %6u (%u%%)\n"
+ "# Three or more alloc block exp progs: %6u (%u%%)\n"
+ ),
+ g_cSingleBlockExpProgs, (uint32_t)((uint64_t)g_cSingleBlockExpProgs * 100 / g_cVarForExpandCompilations),
+ g_cTwoBlockExpProgs, (uint32_t)((uint64_t)g_cTwoBlockExpProgs * 100 / g_cVarForExpandCompilations),
+ g_cMultiBlockExpProgs, (uint32_t)((uint64_t)g_cMultiBlockExpProgs * 100 / g_cVarForExpandCompilations));
+ printf(_("# Total amount of memory for exp progs: %8u bytes\n"
+ "# in: %6u blocks\n"
+ "# avg block size: %6u bytes\n"
+ "# unused memory: %8u bytes (%u%%)\n"
+ "# avg unused memory per block: %6u bytes\n"
+ "\n"),
+ g_cbAllocatedExpProgs, g_cBlocksAllocatedExpProgs, g_cbAllocatedExpProgs / g_cBlocksAllocatedExpProgs,
+ g_cbUnusedMemExpProgs, (uint32_t)((uint64_t)g_cbUnusedMemExpProgs * 100 / g_cbAllocatedExpProgs),
+ g_cbUnusedMemExpProgs / g_cBlocksAllocatedExpProgs);
+ puts("");
+#endif
+ printf(_("# Variables compiled for string eval: %6u\n"), g_cVarForEvalCompilations);
+ printf(_("# Variables string eval runs: %6u\n"), g_cVarForEvalExecs);
+ printf(_("# String evals runs per compile: %6u\n"), g_cVarForEvalExecs / g_cVarForEvalCompilations);
+ printf(_("# Files compiled: %6u\n"), g_cFileForEvalCompilations);
+ printf(_("# Files runs: %6u\n"), g_cFileForEvalExecs);
+ printf(_("# Files eval runs per compile: %6u\n"), g_cFileForEvalExecs / g_cFileForEvalCompilations);
+#ifdef KMK_CC_WITH_STATS
+ printf(_("# Single alloc block eval progs: %6u (%u%%)\n"
+ "# Two alloc block eval progs: %6u (%u%%)\n"
+ "# Three or more alloc block eval progs: %6u (%u%%)\n"
+ ),
+ g_cSingleBlockEvalProgs, (uint32_t)((uint64_t)g_cSingleBlockEvalProgs * 100 / cEvalCompilations),
+ g_cTwoBlockEvalProgs, (uint32_t)((uint64_t)g_cTwoBlockEvalProgs * 100 / cEvalCompilations),
+ g_cMultiBlockEvalProgs, (uint32_t)((uint64_t)g_cMultiBlockEvalProgs * 100 / cEvalCompilations));
+ printf(_("# Total amount of memory for eval progs: %8u bytes\n"
+ "# in: %6u blocks\n"
+ "# avg block size: %6u bytes\n"
+ "# unused memory: %8u bytes (%u%%)\n"
+ "# avg unused memory per block: %6u bytes\n"
+ "\n"),
+ g_cbAllocatedEvalProgs, g_cBlocksAllocatedEvalProgs, g_cbAllocatedEvalProgs / g_cBlocksAllocatedEvalProgs,
+ g_cbUnusedMemEvalProgs, (uint32_t)((uint64_t)g_cbUnusedMemEvalProgs * 100 / g_cbAllocatedEvalProgs),
+ g_cbUnusedMemEvalProgs / g_cBlocksAllocatedEvalProgs);
+ puts("");
+ printf(_("# Total amount of block mem allocated: %8u bytes\n"), g_cbAllocated);
+ printf(_("# Total number of block allocated: %8u\n"), g_cBlockAllocated);
+ printf(_("# Average block size: %8u byte\n"), g_cbAllocated / g_cBlockAllocated);
+#endif
+
+ puts("");
+}
+
+
+/*
+ *
+ * Various utility functions.
+ * Various utility functions.
+ * Various utility functions.
+ *
+ */
+
+/**
+ * Counts the number of dollar chars in the string.
+ *
+ * @returns Number of dollar chars.
+ * @param pchStr The string to search (does not need to be zero
+ * terminated).
+ * @param cchStr The length of the string.
+ */
+static uint32_t kmk_cc_count_dollars(const char *pchStr, uint32_t cchStr)
+{
+ uint32_t cDollars = 0;
+ const char *pch;
+ while ((pch = memchr(pchStr, '$', cchStr)) != NULL)
+ {
+ cDollars++;
+ cchStr -= pch - pchStr + 1;
+ pchStr = pch + 1;
+ }
+ return cDollars;
+}
+
+#ifdef KMK_CC_STRICT
+/**
+ * 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_cc_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;
+}
+
+/**
+ * Used to check that function arguments are left alone.
+ * @returns Updated hash.
+ * @param uHash The current hash value.
+ * @param pch The string to hash, not terminated.
+ * @param cch The number of chars to hash.
+ */
+static uint32_t kmk_cc_debug_string_hash_n(uint32_t uHash, const char *pch, uint32_t cch)
+{
+ while (cch-- > 0)
+ {
+ unsigned char ch = *(unsigned char const *)pch++;
+ uHash = (uHash << 6) + (uHash << 16) - uHash + (unsigned char)ch;
+ }
+ return uHash;
+}
+
+#endif
+
+
+
+/*
+ *
+ * The allocator.
+ * The allocator.
+ * The allocator.
+ *
+ */
+
+
+/**
+ * For the first allocation using the block allocator.
+ *
+ * @returns Pointer to the first allocation (@a cbFirst in size).
+ * @param ppBlockTail Where to return the pointer to the first block.
+ * @param cbFirst The size of the first allocation.
+ * @param cbHint Hint about how much memory we might be needing.
+ */
+static void *kmk_cc_block_alloc_first(PKMKCCBLOCK *ppBlockTail, size_t cbFirst, size_t cbHint)
+{
+ uint32_t cbBlock;
+ PKMKCCBLOCK pNewBlock;
+
+ KMK_CC_ASSERT_ALIGNED(cbFirst, sizeof(void *));
+ KMK_CC_ASSERT(cbFirst <= 128);
+
+ /*
+ * Turn the hint into a block size.
+ */
+ cbHint += cbFirst;
+ if (cbHint <= 512)
+ {
+ if (cbHint <= 256)
+ {
+ if (cbFirst <= 64)
+ cbBlock = 128;
+ else
+ cbBlock = 256;
+ }
+ else
+ cbBlock = 256;
+ }
+ else if (cbHint < 2048)
+ cbBlock = 1024;
+ else if (cbHint < 3072)
+ cbBlock = 2048;
+ else
+ cbBlock = 4096;
+
+ /*
+ * Allocate and initialize the first block.
+ */
+ pNewBlock = (PKMKCCBLOCK)xmalloc(cbBlock);
+ pNewBlock->cbBlock = cbBlock;
+ pNewBlock->offNext = sizeof(*pNewBlock) + cbFirst;
+ pNewBlock->pNext = NULL;
+ *ppBlockTail = pNewBlock;
+
+#ifdef KMK_CC_WITH_STATS
+ g_cBlockAllocated++;
+ g_cbAllocated += cbBlock;
+#endif
+
+ return pNewBlock + 1;
+}
+
+
+/**
+ * Used for getting the address of the next instruction.
+ *
+ * @returns Pointer to the next allocation.
+ * @param pBlockTail The allocator tail pointer.
+ */
+static void *kmk_cc_block_get_next_ptr(PKMKCCBLOCK pBlockTail)
+{
+ return (char *)pBlockTail + pBlockTail->offNext;
+}
+
+
+/**
+ * Realigns the allocator after doing byte or string allocations.
+ *
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ */
+static void kmk_cc_block_realign(PKMKCCBLOCK *ppBlockTail)
+{
+ PKMKCCBLOCK pBlockTail = *ppBlockTail;
+ 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));
+ }
+}
+
+
+/**
+ * Grows the allocation with another block, byte allocator case.
+ *
+ * @returns Pointer to the byte allocation.
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ * @param cb The number of bytes to allocate.
+ */
+static void *kmk_cc_block_byte_alloc_grow(PKMKCCBLOCK *ppBlockTail, uint32_t cb)
+{
+ PKMKCCBLOCK pOldBlock = *ppBlockTail;
+ PKMKCCBLOCK pPrevBlock = pOldBlock->pNext;
+ PKMKCCBLOCK pNewBlock;
+ uint32_t cbBlock;
+
+ /*
+ * Check if there accidentally is some space left in the previous block first.
+ */
+ if ( pPrevBlock
+ && pPrevBlock->cbBlock - pPrevBlock->offNext >= cb)
+ {
+ 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;
+ }
+
+ /*
+ * Allocate a new block.
+ */
+
+ /* Figure the block size. */
+ cbBlock = pOldBlock->cbBlock;
+ while (cbBlock - sizeof(KMKCCEXPJUMP) - sizeof(*pNewBlock) < cb)
+ cbBlock *= 2;
+
+ /* Allocate and initialize the block it with the new instruction already accounted for. */
+ pNewBlock = (PKMKCCBLOCK)xmalloc(cbBlock);
+ pNewBlock->cbBlock = cbBlock;
+ pNewBlock->offNext = sizeof(*pNewBlock) + cb;
+ pNewBlock->pNext = pOldBlock;
+ *ppBlockTail = pNewBlock;
+
+#ifdef KMK_CC_WITH_STATS
+ g_cBlockAllocated++;
+ g_cbAllocated += cbBlock;
+#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;
+}
+
+
+/**
+ * Make a byte allocation.
+ *
+ * Must call kmk_cc_block_realign() when done doing byte and string allocations.
+ *
+ * @returns Pointer to the byte allocation (byte aligned).
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ * @param cb The number of bytes to allocate.
+ */
+static void *kmk_cc_block_byte_alloc(PKMKCCBLOCK *ppBlockTail, uint32_t cb)
+{
+ PKMKCCBLOCK pBlockTail = *ppBlockTail;
+ uint32_t cbLeft = pBlockTail->cbBlock - pBlockTail->offNext;
+
+ KMK_CC_ASSERT(cbLeft >= sizeof(KMKCCEXPJUMP));
+ if (cbLeft >= cb + sizeof(KMKCCEXPJUMP))
+ {
+ 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;
+ }
+ return kmk_cc_block_byte_alloc_grow(ppBlockTail, cb);
+}
+
+
+/**
+ * Duplicates the given string in a byte allocation.
+ *
+ * Must call kmk_cc_block_realign() when done doing byte and string allocations.
+ *
+ * @returns Pointer to the byte allocation (byte aligned).
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ * @param cb The number of bytes to allocate.
+ */
+static const char *kmk_cc_block_strdup(PKMKCCBLOCK *ppBlockTail, const char *pachStr, uint32_t cchStr)
+{
+ char *pszCopy;
+ if (cchStr)
+ {
+ pszCopy = kmk_cc_block_byte_alloc(ppBlockTail, cchStr + 1);
+ memcpy(pszCopy, pachStr, cchStr);
+ pszCopy[cchStr] = '\0';
+ return pszCopy;
+ }
+ return "";
+}
+
+
+/**
+ * Grows the allocation with another block, string expansion program case.
+ *
+ * @returns Pointer to a string expansion instruction core.
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ * @param cb The number of bytes to allocate.
+ */
+static PKMKCCEXPCORE kmk_cc_block_alloc_exp_grow(PKMKCCBLOCK *ppBlockTail, uint32_t cb)
+{
+ PKMKCCBLOCK pOldBlock = *ppBlockTail;
+ PKMKCCBLOCK pNewBlock;
+ PKMKCCEXPCORE pRet;
+ PKMKCCEXPJUMP pJump;
+
+ /* Figure the block size. */
+ uint32_t cbBlock = !pOldBlock->pNext ? 128 : pOldBlock->cbBlock;
+ while (cbBlock - sizeof(KMKCCEXPJUMP) - sizeof(*pNewBlock) < cb)
+ cbBlock *= 2;
+
+ /* Allocate and initialize the block it with the new instruction already accounted for. */
+ pNewBlock = (PKMKCCBLOCK)xmalloc(cbBlock);
+ pNewBlock->cbBlock = cbBlock;
+ pNewBlock->offNext = sizeof(*pNewBlock) + cb;
+ pNewBlock->pNext = pOldBlock;
+ *ppBlockTail = pNewBlock;
+
+#ifdef KMK_CC_WITH_STATS
+ g_cBlockAllocated++;
+ g_cbAllocated += cbBlock;
+#endif
+
+ pRet = (PKMKCCEXPCORE)(pNewBlock + 1);
+ KMK_CC_ASSERT(((size_t)pRet & (sizeof(void *) - 1)) == 0);
+
+ /* Emit jump. */
+ pJump = (PKMKCCEXPJUMP)((char *)pOldBlock + pOldBlock->offNext);
+ pJump->Core.enmOpcode = kKmkCcExpInstr_Jump;
+ pJump->pNext = pRet;
+ pOldBlock->offNext += sizeof(*pJump);
+ 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;
+}
+
+
+/**
+ * Allocates a string expansion instruction of size @a cb.
+ *
+ * @returns Pointer to a string expansion instruction core.
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ * @param cb The number of bytes to allocate.
+ */
+static PKMKCCEXPCORE kmk_cc_block_alloc_exp(PKMKCCBLOCK *ppBlockTail, uint32_t cb)
+{
+ PKMKCCBLOCK pBlockTail = *ppBlockTail;
+ uint32_t cbLeft = pBlockTail->cbBlock - pBlockTail->offNext;
+
+ 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))
+ {
+ PKMKCCEXPCORE pRet = (PKMKCCEXPCORE)((char *)pBlockTail + pBlockTail->offNext);
+ 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;
+ }
+ return kmk_cc_block_alloc_exp_grow(ppBlockTail, cb);
+}
+
+
+/**
+ * Grows the allocation with another block, makefile evaluation program case.
+ *
+ * @returns Pointer to a makefile evaluation instruction core.
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ * @param cb The number of bytes to allocate.
+ */
+static PKMKCCEVALCORE kmk_cc_block_alloc_eval_grow(PKMKCCBLOCK *ppBlockTail, uint32_t cb)
+{
+ PKMKCCBLOCK pOldBlock = *ppBlockTail;
+ PKMKCCBLOCK pNewBlock;
+ PKMKCCEVALCORE pRet;
+ PKMKCCEVALJUMP pJump;
+
+ /* Figure the block size. */
+ uint32_t cbBlock = !pOldBlock->pNext ? 128 : pOldBlock->cbBlock;
+ while (cbBlock - sizeof(KMKCCEVALJUMP) - sizeof(*pNewBlock) < cb)
+ cbBlock *= 2;
+
+ /* Allocate and initialize the block it with the new instruction already accounted for. */
+ pNewBlock = (PKMKCCBLOCK)xmalloc(cbBlock);
+ pNewBlock->cbBlock = cbBlock;
+ pNewBlock->offNext = sizeof(*pNewBlock) + cb;
+ pNewBlock->pNext = pOldBlock;
+ *ppBlockTail = pNewBlock;
+
+#ifdef KMK_CC_WITH_STATS
+ g_cBlockAllocated++;
+ g_cbAllocated += cbBlock;
+#endif
+
+ pRet = (PKMKCCEVALCORE)(pNewBlock + 1);
+
+ /* Emit jump. */
+ pJump = (PKMKCCEVALJUMP)((char *)pOldBlock + pOldBlock->offNext);
+ pJump->Core.enmOpcode = kKmkCcEvalInstr_jump;
+ pJump->pNext = pRet;
+ 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;
+}
+
+
+/**
+ * Allocates a makefile evaluation instruction of size @a cb.
+ *
+ * @returns Pointer to a makefile evaluation instruction core.
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ * @param cb The number of bytes to allocate.
+ */
+static PKMKCCEVALCORE kmk_cc_block_alloc_eval(PKMKCCBLOCK *ppBlockTail, uint32_t cb)
+{
+ PKMKCCBLOCK pBlockTail = *ppBlockTail;
+ uint32_t cbLeft = pBlockTail->cbBlock - pBlockTail->offNext;
+
+ 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))
+ {
+ 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;
+ }
+ return kmk_cc_block_alloc_eval_grow(ppBlockTail, cb);
+}
+
+
+/**
+ * Frees all memory used by an allocator.
+ *
+ * @param ppBlockTail The allocator tail pointer.
+ */
+static void kmk_cc_block_free_list(PKMKCCBLOCK pBlockTail)
+{
+ while (pBlockTail)
+ {
+ PKMKCCBLOCK pThis = pBlockTail;
+ pBlockTail = pBlockTail->pNext;
+ free(pThis);
+ }
+}
+
+
+/*
+ *
+ * The string expansion compiler.
+ * The string expansion compiler.
+ * The string expansion compiler.
+ *
+ */
+
+
+/**
+ * Emits a kKmkCcExpInstr_Return.
+ *
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ */
+static void kmk_cc_exp_emit_return(PKMKCCBLOCK *ppBlockTail)
+{
+ PKMKCCEXPCORE pCore = kmk_cc_block_alloc_exp(ppBlockTail, sizeof(*pCore));
+ pCore->enmOpcode = kKmkCcExpInstr_Return;
+ kmk_cc_block_realign(ppBlockTail);
+}
+
+
+/**
+ * Checks if a function is known to mess up the arguments its given.
+ *
+ * When executing calls to "dirty" functions, all arguments must be duplicated
+ * on the heap.
+ *
+ * @returns 1 if dirty, 0 if clean.
+ * @param pszFunction The function name.
+ */
+static uint8_t kmk_cc_is_dirty_function(const char *pszFunction)
+{
+ switch (pszFunction[0])
+ {
+ default:
+ return 0;
+
+ case 'e':
+ if (!strcmp(pszFunction, "eval"))
+ return 1;
+ if (!strcmp(pszFunction, "evalctx"))
+ return 1;
+ return 0;
+
+ case 'f':
+ if (!strcmp(pszFunction, "filter"))
+ return 1;
+ if (!strcmp(pszFunction, "filter-out"))
+ return 1;
+ if (!strcmp(pszFunction, "for"))
+ return 1;
+ return 0;
+
+ case 's':
+ if (!strcmp(pszFunction, "sort"))
+ return 1;
+ return 0;
+ }
+}
+
+
+/**
+ * Emits a function call instruction taking arguments that needs expanding.
+ *
+ * @returns 0 on success, non-zero on failure.
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ * @param pszFunction The function name (const string from function.c).
+ * @param pchArgs Pointer to the arguments expression string, leading
+ * any blanks has been stripped.
+ * @param cchArgs The length of the arguments expression string.
+ * @param cArgs Number of arguments found.
+ * @param chOpen The char used to open the function call.
+ * @param chClose The char used to close the function call.
+ * @param pfnFunction The function implementation.
+ * @param cMaxArgs Maximum number of arguments the function takes.
+ */
+static int kmk_cc_exp_emit_dyn_function(PKMKCCBLOCK *ppBlockTail, const char *pszFunction,
+ const char *pchArgs, uint32_t cchArgs, uint32_t cArgs, char chOpen, char chClose,
+ make_function_ptr_t pfnFunction, unsigned char cMaxArgs)
+{
+ uint32_t iArg;
+
+ /*
+ * The function instruction has variable size. The maximum argument count
+ * isn't quite like the minium one. Zero means no limit. While a non-zero
+ * value means that any commas beyond the max will be taken to be part of
+ * the final argument.
+ */
+ uint32_t cActualArgs = cArgs <= cMaxArgs || !cMaxArgs ? cArgs : cMaxArgs;
+ PKMKCCEXPDYNFUNC pInstr = (PKMKCCEXPDYNFUNC)kmk_cc_block_alloc_exp(ppBlockTail, KMKCCEXPDYNFUNC_SIZE(cActualArgs));
+ pInstr->FnCore.Core.enmOpcode = kKmkCcExpInstr_DynamicFunction;
+ pInstr->FnCore.cArgs = cActualArgs;
+ pInstr->FnCore.pfnFunction = pfnFunction;
+ pInstr->FnCore.pszFuncName = pszFunction;
+ pInstr->FnCore.fDirty = kmk_cc_is_dirty_function(pszFunction);
+
+ /*
+ * Parse the arguments. Plain arguments gets duplicated in the program
+ * memory so that they are terminated and no extra processing is necessary
+ * later on. ASSUMES that the function implementations do NOT change
+ * argument memory. Other arguments the compiled into their own expansion
+ * sub programs.
+ */
+ iArg = 0;
+ for (;;)
+ {
+ /* Find the end of the argument. Check for $. */
+ char ch = '\0';
+ uint8_t fDollar = 0;
+ int32_t cDepth = 0;
+ uint32_t cchThisArg = 0;
+ while (cchThisArg < cchArgs)
+ {
+ ch = pchArgs[cchThisArg];
+ if (ch == chClose)
+ {
+ KMK_CC_ASSERT(cDepth > 0);
+ if (cDepth > 0)
+ cDepth--;
+ }
+ else if (ch == chOpen)
+ cDepth++;
+ else if (ch == ',' && cDepth == 0 && iArg + 1 < cActualArgs)
+ break;
+ else if (ch == '$')
+ fDollar = 1;
+ cchThisArg++;
+ }
+
+ pInstr->aArgs[iArg].fSubprog = fDollar;
+ if (fDollar)
+ {
+ /* Compile it. */
+ int rc;
+ kmk_cc_block_realign(ppBlockTail);
+ rc = kmk_cc_exp_compile_subprog(ppBlockTail, pchArgs, cchThisArg, &pInstr->aArgs[iArg].u.Subprog);
+ if (rc != 0)
+ return rc;
+ }
+ else
+ {
+ /* Duplicate it. */
+ pInstr->aArgs[iArg].u.Plain.psz = kmk_cc_block_strdup(ppBlockTail, pchArgs, cchThisArg);
+ pInstr->aArgs[iArg].u.Plain.cch = cchThisArg;
+ }
+ iArg++;
+ if (ch != ',')
+ break;
+ pchArgs += cchThisArg + 1;
+ cchArgs -= cchThisArg + 1;
+ }
+ KMK_CC_ASSERT(iArg == cActualArgs);
+
+ /*
+ * Realign the allocator and take down the address of the next instruction.
+ */
+ kmk_cc_block_realign(ppBlockTail);
+ pInstr->FnCore.pNext = (PKMKCCEXPCORE)kmk_cc_block_get_next_ptr(*ppBlockTail);
+ return 0;
+}
+
+
+/**
+ * Emits a function call instruction taking plain arguments.
+ *
+ * @returns 0 on success, non-zero on failure.
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ * @param pszFunction The function name (const string from function.c).
+ * @param pchArgs Pointer to the arguments string, leading any blanks
+ * has been stripped.
+ * @param cchArgs The length of the arguments string.
+ * @param cArgs Number of arguments found.
+ * @param chOpen The char used to open the function call.
+ * @param chClose The char used to close the function call.
+ * @param pfnFunction The function implementation.
+ * @param cMaxArgs Maximum number of arguments the function takes.
+ */
+static void kmk_cc_exp_emit_plain_function(PKMKCCBLOCK *ppBlockTail, const char *pszFunction,
+ const char *pchArgs, uint32_t cchArgs, uint32_t cArgs, char chOpen, char chClose,
+ make_function_ptr_t pfnFunction, unsigned char cMaxArgs)
+{
+ uint32_t iArg;
+
+ /*
+ * The function instruction has variable size. The maximum argument count
+ * isn't quite like the minium one. Zero means no limit. While a non-zero
+ * value means that any commas beyond the max will be taken to be part of
+ * the final argument.
+ */
+ uint32_t cActualArgs = cArgs <= cMaxArgs || !cMaxArgs ? cArgs : cMaxArgs;
+ PKMKCCEXPPLAINFUNC pInstr = (PKMKCCEXPPLAINFUNC)kmk_cc_block_alloc_exp(ppBlockTail, KMKCCEXPPLAINFUNC_SIZE(cActualArgs));
+ pInstr->FnCore.Core.enmOpcode = kKmkCcExpInstr_PlainFunction;
+ pInstr->FnCore.cArgs = cActualArgs;
+ pInstr->FnCore.pfnFunction = pfnFunction;
+ pInstr->FnCore.pszFuncName = pszFunction;
+ pInstr->FnCore.fDirty = kmk_cc_is_dirty_function(pszFunction);
+
+ /*
+ * Parse the arguments. Plain arguments gets duplicated in the program
+ * memory so that they are terminated and no extra processing is necessary
+ * later on. ASSUMES that the function implementations do NOT change
+ * argument memory.
+ */
+ iArg = 0;
+ for (;;)
+ {
+ /* Find the end of the argument. */
+ char ch = '\0';
+ int32_t cDepth = 0;
+ uint32_t cchThisArg = 0;
+ while (cchThisArg < cchArgs)
+ {
+ ch = pchArgs[cchThisArg];
+ if (ch == chClose)
+ {
+ KMK_CC_ASSERT(cDepth > 0);
+ if (cDepth > 0)
+ cDepth--;
+ }
+ else if (ch == chOpen)
+ cDepth++;
+ else if (ch == ',' && cDepth == 0 && iArg + 1 < cActualArgs)
+ break;
+ cchThisArg++;
+ }
+
+ /* Duplicate it. */
+ pInstr->apszArgs[iArg++] = kmk_cc_block_strdup(ppBlockTail, pchArgs, cchThisArg);
+ if (ch != ',')
+ break;
+ pchArgs += cchThisArg + 1;
+ cchArgs -= cchThisArg + 1;
+ }
+
+ KMK_CC_ASSERT(iArg == cActualArgs);
+ pInstr->apszArgs[iArg] = NULL;
+
+ /*
+ * Realign the allocator and take down the address of the next instruction.
+ */
+ kmk_cc_block_realign(ppBlockTail);
+ pInstr->FnCore.pNext = (PKMKCCEXPCORE)kmk_cc_block_get_next_ptr(*ppBlockTail);
+}
+
+
+/**
+ * Emits a kKmkCcExpInstr_DynamicVariable.
+ *
+ * @returns 0 on success, non-zero on failure.
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ * @param pchNameExpr The name of the variable (ASSUMED presistent
+ * thru-out the program life time).
+ * @param cchNameExpr The length of the variable name. If zero,
+ * nothing will be emitted.
+ */
+static int kmk_cc_exp_emit_dyn_variable(PKMKCCBLOCK *ppBlockTail, const char *pchNameExpr, uint32_t cchNameExpr)
+{
+ PKMKCCEXPDYNVAR pInstr;
+ int rc;
+ KMK_CC_ASSERT(cchNameExpr > 0);
+
+ pInstr = (PKMKCCEXPDYNVAR)kmk_cc_block_alloc_exp(ppBlockTail, sizeof(*pInstr));
+ pInstr->Core.enmOpcode = kKmkCcExpInstr_DynamicVariable;
+
+ rc = kmk_cc_exp_compile_subprog(ppBlockTail, pchNameExpr, cchNameExpr, &pInstr->Subprog);
+
+ pInstr->pNext = (PKMKCCEXPCORE)kmk_cc_block_get_next_ptr(*ppBlockTail);
+ return rc;
+}
+
+
+/**
+ * Emits either a kKmkCcExpInstr_PlainVariable or
+ * kKmkCcExpInstr_SearchAndReplacePlainVariable instruction.
+ *
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ * @param pchName The name of the variable. (Does not need to be
+ * valid beyond the call.)
+ * @param cchName The length of the variable name. If zero,
+ * nothing will be emitted.
+ */
+static void kmk_cc_exp_emit_plain_variable_maybe_sr(PKMKCCBLOCK *ppBlockTail, const char *pchName, uint32_t cchName)
+{
+ if (cchName > 0)
+ {
+ /*
+ * 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);
+ }
+ }
+}
+
+
+/**
+ * Emits a kKmkCcExpInstr_CopyString.
+ *
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ * @param pchStr The string to emit (ASSUMED presistent thru-out
+ * the program life time).
+ * @param cchStr The number of chars to copy. If zero, nothing
+ * will be emitted.
+ */
+static void kmk_cc_exp_emit_copy_string(PKMKCCBLOCK *ppBlockTail, const char *pchStr, uint32_t cchStr)
+{
+ if (cchStr > 0)
+ {
+ PKMKCCEXPCOPYSTRING pInstr = (PKMKCCEXPCOPYSTRING)kmk_cc_block_alloc_exp(ppBlockTail, sizeof(*pInstr));
+ pInstr->Core.enmOpcode = kKmkCcExpInstr_CopyString;
+ pInstr->cchCopy = cchStr;
+ pInstr->pachSrc = pchStr;
+ }
+}
+
+
+/**
+ * String expansion compilation function common to both normal and sub programs.
+ *
+ * @returns 0 on success, non-zero on failure.
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ * @param pchStr The expression to compile.
+ * @param cchStr The length of the expression to compile.
+ */
+static int kmk_cc_exp_compile_common(PKMKCCBLOCK *ppBlockTail, const char *pchStr, uint32_t cchStr)
+{
+ /*
+ * Process the string.
+ */
+ while (cchStr > 0)
+ {
+ /* Look for dollar sign, marks variable expansion or dollar-escape. */
+ int rc;
+ const char *pchDollar = memchr(pchStr, '$', cchStr);
+ if (pchDollar)
+ {
+ /*
+ * Check for multiple dollar chars.
+ */
+ uint32_t offDollar = (uint32_t)(pchDollar - pchStr);
+ uint32_t cDollars = 1;
+ while ( offDollar + cDollars < cchStr
+ && pchStr[offDollar + cDollars] == '$')
+ cDollars++;
+
+ /*
+ * Emit a string copy for any preceeding stuff, including half of
+ * the dollars we found (dollar escape: $$ -> $).
+ * (kmk_cc_exp_emit_copy_string ignore zero length strings).
+ */
+ kmk_cc_exp_emit_copy_string(ppBlockTail, pchStr, offDollar + cDollars / 2);
+ pchStr += offDollar + cDollars;
+ cchStr -= offDollar + cDollars;
+
+ /*
+ * Odd number of dollar chars means there is a variable to expand
+ * or function to call.
+ */
+ if (cDollars & 1)
+ {
+ if (cchStr > 0)
+ {
+ char const chOpen = *pchStr;
+ if (chOpen == '(' || chOpen == '{')
+ {
+ /* There are several alternative ways of finding the ending
+ 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;
+ unsigned char cMaxArgs;
+ unsigned char cMinArgs;
+ char fExpandArgs;
+ char const chClose = chOpen == '(' ? ')' : '}';
+ char ch = 0;
+ uint32_t cchName = 0;
+ uint32_t cDepth = 1;
+ uint32_t cMaxDepth = 1;
+ cDollars = 0;
+
+ pchStr++;
+ cchStr--;
+
+ /* First loop: Identify potential function calls and dynamic expansion. */
+ KMK_CC_ASSERT(!func_char_map[(unsigned char)chOpen]);
+ KMK_CC_ASSERT(!func_char_map[(unsigned char)chClose]);
+ KMK_CC_ASSERT(!func_char_map[(unsigned char)'$']);
+ while (cchName < cchStr)
+ {
+ ch = pchStr[cchName];
+ if (!func_char_map[(unsigned char)ch])
+ break;
+ cchName++;
+ }
+
+ if ( cchName >= MIN_FUNCTION_LENGTH
+ && cchName <= MAX_FUNCTION_LENGTH
+ && (ISBLANK(ch) || ch == chClose || cchName == cchStr)
+ && (pfnFunction = lookup_function_for_compiler(pchStr, cchName, &cMinArgs, &cMaxArgs,
+ &fExpandArgs, &pszFunction)) != NULL)
+ {
+ /*
+ * It's a function invocation, we should count parameters while
+ * looking for the end.
+ * Note! We use cchName for the length of the argument list.
+ */
+ uint32_t cArgs = 1;
+ if (ch != chClose)
+ {
+ /* Skip leading spaces before the first arg. */
+ cchName++;
+ while (cchName < cchStr && ISBLANK(pchStr[cchName]))
+ cchName++;
+
+ pchStr += cchName;
+ cchStr -= cchName;
+ cchName = 0;
+
+ while (cchName < cchStr)
+ {
+ ch = pchStr[cchName];
+ if (ch == ',')
+ {
+ if (cDepth == 1)
+ cArgs++;
+ }
+ else if (ch == chClose)
+ {
+ if (!--cDepth)
+ break;
+ }
+ else if (ch == chOpen)
+ {
+ if (++cDepth > cMaxDepth)
+ cMaxDepth = cDepth;
+ }
+ else if (ch == '$')
+ cDollars++;
+ cchName++;
+ }
+ }
+ else
+ {
+ pchStr += cchName;
+ cchStr -= cchName;
+ cchName = 0;
+ }
+ if (cArgs < cMinArgs)
+ {
+ fatal(NULL, _("Function '%s' takes a minimum of %d arguments: %d given"),
+ pszFunction, (int)cMinArgs, (int)cArgs);
+ return -1; /* not reached */
+ }
+ if (cDepth != 0)
+ {
+ fatal(NULL, chOpen == '('
+ ? _("Missing closing parenthesis calling '%s'") : _("Missing closing braces calling '%s'"),
+ pszFunction);
+ return -1; /* not reached */
+ }
+ if (cMaxDepth > 16 && fExpandArgs)
+ {
+ fatal(NULL, _("Too many levels of nested function arguments expansions: %s"), pszFunction);
+ return -1; /* not reached */
+ }
+ if (!fExpandArgs || cDollars == 0)
+ kmk_cc_exp_emit_plain_function(ppBlockTail, pszFunction, pchStr, cchName,
+ cArgs, chOpen, chClose, pfnFunction, cMaxArgs);
+ else
+ {
+ rc = kmk_cc_exp_emit_dyn_function(ppBlockTail, pszFunction, pchStr, cchName,
+ cArgs, chOpen, chClose, pfnFunction, cMaxArgs);
+ if (rc != 0)
+ return rc;
+ }
+ }
+ else
+ {
+ /*
+ * Variable, find the end while checking whether anything needs expanding.
+ */
+ if (ch == chClose)
+ cDepth = 0;
+ else if (cchName < cchStr)
+ {
+ if (ch != '$')
+ {
+ /* Second loop: Look for things that needs expanding. */
+ while (cchName < cchStr)
+ {
+ ch = pchStr[cchName];
+ if (ch == chClose)
+ {
+ if (!--cDepth)
+ break;
+ }
+ else if (ch == chOpen)
+ {
+ if (++cDepth > cMaxDepth)
+ cMaxDepth = cDepth;
+ }
+ else if (ch == '$')
+ break;
+ cchName++;
+ }
+ }
+ if (ch == '$')
+ {
+ /* Third loop: Something needs expanding, just find the end. */
+ cDollars = 1;
+ cchName++;
+ while (cchName < cchStr)
+ {
+ ch = pchStr[cchName];
+ if (ch == chClose)
+ {
+ if (!--cDepth)
+ break;
+ }
+ else if (ch == chOpen)
+ {
+ if (++cDepth > cMaxDepth)
+ cMaxDepth = cDepth;
+ }
+ cchName++;
+ }
+ }
+ }
+ if (cDepth > 0) /* After warning, we just assume they're all there. */
+ error(NULL, chOpen == '(' ? _("Missing closing parenthesis ") : _("Missing closing braces"));
+ if (cMaxDepth >= 16)
+ {
+ fatal(NULL, _("Too many levels of nested variable expansions: '%.*s'"), (int)cchName + 2, pchStr - 1);
+ return -1; /* not reached */
+ }
+ if (cDollars == 0)
+ kmk_cc_exp_emit_plain_variable_maybe_sr(ppBlockTail, pchStr, cchName);
+ else
+ {
+ rc = kmk_cc_exp_emit_dyn_variable(ppBlockTail, pchStr, cchName);
+ if (rc != 0)
+ return rc;
+ }
+ }
+ pchStr += cchName + 1;
+ cchStr -= cchName + (cDepth == 0);
+ }
+ else
+ {
+ /* Single character variable name. */
+ kmk_cc_exp_emit_plain_variable_maybe_sr(ppBlockTail, pchStr, 1);
+ pchStr++;
+ cchStr--;
+ }
+ }
+ else
+ {
+ error(NULL, _("Unexpected end of string after $"));
+ break;
+ }
+ }
+ }
+ else
+ {
+ /*
+ * Nothing more to expand, the remainder is a simple string copy.
+ */
+ kmk_cc_exp_emit_copy_string(ppBlockTail, pchStr, cchStr);
+ break;
+ }
+ }
+
+ /*
+ * Emit final instruction.
+ */
+ kmk_cc_exp_emit_return(ppBlockTail);
+ return 0;
+}
+
+
+/**
+ * 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;
+}
+
+
+/**
+ * Compiles a string expansion subprogram.
+ *
+ * The caller typically make a call to kmk_cc_block_get_next_ptr after this
+ * function returns to figure out where to continue executing.
+ *
+ * @returns 0 on success, non-zero on failure.
+ * @param ppBlockTail Pointer to the allocator tail pointer.
+ * @param pchStr Pointer to the string to compile an expansion
+ * program for (ASSUMED to be valid for the
+ * lifetime of the program).
+ * @param cchStr The length of the string to compile. Expected to
+ * be at least on char long.
+ * @param pSubprog The subprogram structure to initialize.
+ */
+static int kmk_cc_exp_compile_subprog(PKMKCCBLOCK *ppBlockTail, const char *pchStr, uint32_t cchStr, PKMKCCEXPSUBPROG pSubprog)
+{
+ KMK_CC_ASSERT(cchStr > 0);
+ pSubprog->pFirstInstr = (PKMKCCEXPCORE)kmk_cc_block_get_next_ptr(*ppBlockTail);
+ kmk_cc_exp_stats_init(&pSubprog->Stats);
+ return kmk_cc_exp_compile_common(ppBlockTail, pchStr, cchStr);
+}
+
+
+/**
+ * Compiles a string expansion program.
+ *
+ * @returns Pointer to the program on success, NULL on failure.
+ * @param pchStr Pointer to the string to compile an expansion
+ * program for (ASSUMED to be valid for the
+ * lifetime of the program).
+ * @param cchStr The length of the string to compile. Expected to
+ * be at least on char long.
+ */
+static PKMKCCEXPPROG kmk_cc_exp_compile(const char *pchStr, uint32_t cchStr)
+{
+ /*
+ * Estimate block size, allocate one and initialize it.
+ */
+ PKMKCCEXPPROG pProg;
+ PKMKCCBLOCK pBlock;
+ pProg = kmk_cc_block_alloc_first(&pBlock, sizeof(*pProg),
+ (kmk_cc_count_dollars(pchStr, cchStr) + 4) * 8);
+ if (pProg)
+ {
+ pProg->pBlockTail = pBlock;
+ pProg->pFirstInstr = (PKMKCCEXPCORE)kmk_cc_block_get_next_ptr(pBlock);
+ kmk_cc_exp_stats_init(&pProg->Stats);
+ pProg->cRefs = 1;
+#ifdef KMK_CC_STRICT
+ pProg->uInputHash = kmk_cc_debug_string_hash_n(0, pchStr, cchStr);
+#endif
+
+ /*
+ * Join forces with the subprogram compilation code.
+ */
+ if (kmk_cc_exp_compile_common(&pProg->pBlockTail, pchStr, cchStr) == 0)
+ {
+#ifdef KMK_CC_WITH_STATS
+ pBlock = pProg->pBlockTail;
+ if (!pBlock->pNext)
+ g_cSingleBlockExpProgs++;
+ else if (!pBlock->pNext->pNext)
+ g_cTwoBlockExpProgs++;
+ else
+ g_cMultiBlockExpProgs++;
+ for (; pBlock; pBlock = pBlock->pNext)
+ {
+ g_cBlocksAllocatedExpProgs++;
+ g_cbAllocatedExpProgs += pBlock->cbBlock;
+ g_cbUnusedMemExpProgs += pBlock->cbBlock - pBlock->offNext;
+ }
+#endif
+ return pProg;
+ }
+ kmk_cc_block_free_list(pProg->pBlockTail);
+ }
+ return NULL;
+}
+
+
+/**
+ * Updates the recursive_without_dollar member of a variable structure.
+ *
+ * This avoid compiling string expansion programs with only a CopyString
+ * instruction. By setting recursive_without_dollar to 1, code calling
+ * kmk_cc_compile_variable_for_expand and kmk_exec_expand_to_var_buf will
+ * instead treat start treating it as a simple variable, which is faster.
+ *
+ * @returns The updated recursive_without_dollar value.
+ * @param pVar Pointer to the variable.
+ */
+static int kmk_cc_update_variable_recursive_without_dollar(struct variable *pVar)
+{
+ int fValue;
+ KMK_CC_ASSERT(pVar->recursive_without_dollar == 0);
+
+ if (memchr(pVar->value, '$', pVar->value_length))
+ fValue = -1;
+ else
+ fValue = 1;
+ pVar->recursive_without_dollar = fValue;
+
+ return fValue;
+}
+
+
+/**
+ * Compiles a variable for string expansion.
+ *
+ * @returns Pointer to the string expansion program on success, NULL if no
+ * program was created.
+ * @param pVar Pointer to the variable.
+ */
+struct kmk_cc_expandprog *kmk_cc_compile_variable_for_expand(struct variable *pVar)
+{
+ KMK_CC_ASSERT(strlen(pVar->value) == pVar->value_length);
+ KMK_CC_ASSERT(!pVar->expandprog);
+ KMK_CC_ASSERT(pVar->recursive_without_dollar <= 0);
+
+ if ( !pVar->expandprog
+ && pVar->recursive)
+ {
+ if ( pVar->recursive_without_dollar < 0
+ || ( pVar->recursive_without_dollar == 0
+ && kmk_cc_update_variable_recursive_without_dollar(pVar) < 0) )
+ {
+ pVar->expandprog = kmk_cc_exp_compile(pVar->value, pVar->value_length);
+ g_cVarForExpandCompilations++;
+ }
+ }
+ return pVar->expandprog;
+}
+
+
+/**
+ * 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 || IS_VARIABLE_RECURSIVE_WITHOUT_DOLLAR(pVar))
+ 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;
+ uint32_t iArg;
+ if (!pInstr->FnCore.fDirty)
+ {
+#ifdef KMK_CC_STRICT
+ uint32_t uCrcBefore = 0;
+ uint32_t uCrcAfter = 0;
+ iArg = pInstr->FnCore.cArgs;
+ while (iArg-- > 0)
+ uCrcBefore = kmk_cc_debug_string_hash(uCrcBefore, pInstr->apszArgs[iArg]);
+#endif
+
+ pchDst = pInstr->FnCore.pfnFunction(pchDst, (char **)&pInstr->apszArgs[0], pInstr->FnCore.pszFuncName);
+
+#ifdef KMK_CC_STRICT
+ iArg = pInstr->FnCore.cArgs;
+ while (iArg-- > 0)
+ uCrcAfter = kmk_cc_debug_string_hash(uCrcAfter, pInstr->apszArgs[iArg]);
+ KMK_CC_ASSERT(uCrcBefore == uCrcAfter);
+#endif
+ }
+ else
+ {
+ char **papszShadowArgs = xmalloc((pInstr->FnCore.cArgs * 2 + 1) * sizeof(papszShadowArgs[0]));
+ char **papszArgs = &papszShadowArgs[pInstr->FnCore.cArgs];
+
+ iArg = pInstr->FnCore.cArgs;
+ papszArgs[iArg] = NULL;
+ while (iArg-- > 0)
+ papszArgs[iArg] = papszShadowArgs[iArg] = xstrdup(pInstr->apszArgs[iArg]);
+
+ pchDst = pInstr->FnCore.pfnFunction(pchDst, (char **)&pInstr->apszArgs[0], pInstr->FnCore.pszFuncName);
+
+ iArg = pInstr->FnCore.cArgs;
+ while (iArg-- > 0)
+ free(papszShadowArgs[iArg]);
+ free(papszShadowArgs);
+ }
+
+ pInstrCore = pInstr->FnCore.pNext;
+ break;
+ }
+
+ case kKmkCcExpInstr_DynamicFunction:
+ {
+ PKMKCCEXPDYNFUNC pInstr = (PKMKCCEXPDYNFUNC)pInstrCore;
+ char **papszArgsShadow = xmalloc( (pInstr->FnCore.cArgs * 2 + 1) * sizeof(char *));
+ char **papszArgs = &papszArgsShadow[pInstr->FnCore.cArgs];
+ uint32_t iArg;
+
+ if (!pInstr->FnCore.fDirty)
+ {
+#ifdef KMK_CC_STRICT
+ uint32_t uCrcBefore = 0;
+ uint32_t uCrcAfter = 0;
+#endif
+ iArg = pInstr->FnCore.cArgs;
+ papszArgs[iArg] = NULL;
+ while (iArg-- > 0)
+ {
+ char *pszArg;
+ if (pInstr->aArgs[iArg].fSubprog)
+ pszArg = kmk_exec_expand_subprog_to_tmp(&pInstr->aArgs[iArg].u.Subprog, NULL);
+ else
+ pszArg = (char *)pInstr->aArgs[iArg].u.Plain.psz;
+ papszArgsShadow[iArg] = pszArg;
+ papszArgs[iArg] = pszArg;
+#ifdef KMK_CC_STRICT
+ uCrcBefore = kmk_cc_debug_string_hash(uCrcBefore, pszArg);
+#endif
+ }
+ pchDst = pInstr->FnCore.pfnFunction(pchDst, papszArgs, pInstr->FnCore.pszFuncName);
+
+ iArg = pInstr->FnCore.cArgs;
+ while (iArg-- > 0)
+ {
+#ifdef KMK_CC_STRICT
+ KMK_CC_ASSERT(papszArgsShadow[iArg] == papszArgs[iArg]);
+ uCrcAfter = kmk_cc_debug_string_hash(uCrcAfter, papszArgsShadow[iArg]);
+#endif
+ if (pInstr->aArgs[iArg].fSubprog)
+ free(papszArgsShadow[iArg]);
+ }
+ KMK_CC_ASSERT(uCrcBefore == uCrcAfter);
+ }
+ else
+ {
+ iArg = pInstr->FnCore.cArgs;
+ papszArgs[iArg] = NULL;
+ while (iArg-- > 0)
+ {
+ char *pszArg;
+ if (pInstr->aArgs[iArg].fSubprog)
+ pszArg = kmk_exec_expand_subprog_to_tmp(&pInstr->aArgs[iArg].u.Subprog, NULL);
+ else
+ pszArg = xstrdup(pInstr->aArgs[iArg].u.Plain.psz);
+ papszArgsShadow[iArg] = pszArg;
+ papszArgs[iArg] = pszArg;
+ }
+
+ pchDst = pInstr->FnCore.pfnFunction(pchDst, papszArgs, pInstr->FnCore.pszFuncName);
+
+ iArg = pInstr->FnCore.cArgs;
+ while (iArg-- > 0)
+ free(papszArgsShadow[iArg]);
+ }
+ free(papszArgsShadow);
+
+ pInstrCore = pInstr->FnCore.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)
+{
+ /*
+ * The average is simplified and not an exact average for every
+ * expansion that has taken place.
+ */
+ pStats->cchAvg = (pStats->cchAvg * 7 + cchResult) / 8;
+}
+
+
+/**
+ * Execute a string expansion subprogram, outputting to a new heap buffer.
+ *
+ * @returns Pointer to the output buffer (hand to free when done).
+ * @param pSubprog The subprogram 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 subprogram.
+ */
+ 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);
+
+ variable_buffer = pchOldVarBuf;
+ variable_buffer_length = 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);
+
+ KMK_CC_ASSERT(pProg->cRefs > 0);
+ pProg->cRefs++;
+
+ pchDst = kmk_exec_expand_instruction_stream_to_var_buf(pProg->pFirstInstr, pchDst);
+
+ pProg->cRefs--;
+ KMK_CC_ASSERT(pProg->cRefs > 0);
+
+ cchResult = (uint32_t)(pchDst - variable_buffer);
+ KMK_CC_ASSERT(cchResult >= offStart);
+ cchResult -= offStart;
+ kmk_cc_exp_stats_update(&pProg->Stats, cchResult);
+ g_cVarForExpandExecs++;
+
+ return pchDst;
+}
+
+
+/**
+ * Expands a variable into a variable buffer using its expandprog.
+ *
+ * @returns The new variable buffer position.
+ * @param pVar Pointer to the variable. Must have a program.
+ * @param pchDst Pointer to the current variable buffer position.
+ */
+char *kmk_exec_expand_to_var_buf(struct variable *pVar, char *pchDst)
+{
+ KMK_CC_ASSERT(pVar->expandprog);
+ KMK_CC_ASSERT(pVar->expandprog->uInputHash == kmk_cc_debug_string_hash(0, pVar->value));
+ return kmk_exec_expand_prog_to_var_buf(pVar->expandprog, pchDst);
+}
+
+
+
+
+
+/*
+ *
+ * Makefile evaluation programs.
+ * Makefile evaluation programs.
+ * Makefile evaluation programs.
+ *
+ */
+
+static size_t kmk_cc_eval_detect_eol_style(char *pchFirst, char *pchSecond, const char *pszContent, size_t cchContent)
+{
+ /* Look for LF first. */
+ const char *pszTmp = (const char *)memchr(pszContent, '\n', cchContent);
+ if (pszTmp)
+ {
+ /* CRLF? */
+ if (pszTmp != pszContent && pszTmp[-1] == '\r')
+ {
+ *pchFirst = '\r';
+ *pchSecond = '\n';
+ return 2;
+ }
+
+ /* No, LF or LFCR. (pszContent is zero terminated, so no bounds checking necessary.) */
+ *pchFirst = '\n';
+ if (pszTmp[1] != '\r')
+ {
+ *pchSecond = 0;
+ return 1;
+ }
+ *pchSecond = '\r';
+ return 2;
+ }
+
+ /* Probably no EOLs here. */
+ if (memchr(pszContent, '\r', cchContent) == NULL)
+ {
+ *pchSecond = *pchFirst = 0;
+ return 0;
+ }
+
+ /* kind of unlikely */
+ *pchFirst = '\r';
+ *pchSecond = 0;
+ return 1;
+}
+
+
+#if 0
+/**
+ * Checks whether we've got an EOL escape sequence or not.
+ *
+ * @returns non-zero if escaped EOL, 0 if not (i.e. actual EOL).
+ * @param pszContent The string pointer @a offEol is relative to.
+ * @param offEol The offset of the first EOL char.
+ */
+static unsigned kmk_cc_eval_is_eol_escape_seq(const char *pszContent, size_t offEol)
+{
+ /* The caller has already checked out two backslashes. */
+ size_t offFirstBackslash = offEol;
+ KMK_CC_ASSERT(offFirstBackslash >= 2);
+ offFirstBackslash -= 2;
+
+ /* Find the first backslash. */
+ while (offFirstBackslash > 0 && pszContent[offFirstBackslash - 1] == '\\')
+ offFirstBackslash--;
+
+ /* Odd number -> escaped EOL; Even number -> real EOL; */
+ return (offEol - offFirstBackslash) & 1;
+}
+#endif
+
+
+
+/**
+ * Tokens (for KMKCCEVALWORD).
+ */
+typedef enum kmk_cc_eval_token
+{
+ /** Invalid token value 0. */
+ kKmkCcEvalToken_Invalid = 0,
+
+ /** Plain word. */
+ kKmkCcEvalToken_WordPlain,
+ /** Plain word with one or more escaped EOLs. (Currently not possible.) */
+ kKmkCcEvalToken_WordPlainWithEscEol,
+ /** Word that maybe in need of expanding. */
+ kKmkCcEvalToken_WordWithDollar,
+ /** Word that is in need of expanding and include one or more escped EOLs. */
+ kKmkCcEvalToken_WordWithDollarAndEscEol,
+
+ /** 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;
+
+/**
+ * A tokenized word.
+ */
+typedef struct kmk_cc_eval_word
+{
+ /** The token word (lexeme). */
+ const char *pchWord;
+ /** The length of the word (lexeme). */
+ uint32_t cchWord;
+ /** The token classification. */
+ KMKCCEVALTOKEN enmToken;
+} KMKCCEVALWORD;
+typedef KMKCCEVALWORD *PKMKCCEVALWORD;
+typedef KMKCCEVALWORD const *PCKMKCCEVALWORD;
+
+
+/**
+ * Escaped end-of-line sequence in the current line.
+ */
+typedef struct KMKCCEVALESCEOL
+{
+ /** Offset at which the EOL escape sequence starts for a non-command line. */
+ size_t offEsc;
+ /** Offset of the newline sequence. */
+ size_t offEol;
+} KMKCCEVALESCEOL;
+typedef KMKCCEVALESCEOL *PKMKCCEVALESCEOL;
+
+
+/**
+ * String copy segment.
+ */
+typedef struct KMKCCEVALSTRCPYSEG
+{
+ /** The start. */
+ const char *pchSrc;
+ /** The number of chars to copy and whether to prepend space.
+ * Negative values indicates that we should prepend a space. */
+ ssize_t cchSrcAndPrependSpace;
+} KMKCCEVALSTRCPYSEG;
+typedef KMKCCEVALSTRCPYSEG *PKMKCCEVALSTRCPYSEG;
+typedef KMKCCEVALSTRCPYSEG const *PCKMKCCEVALSTRCPYSEG;
+
+
+typedef struct KMKCCEVALCOMPILER
+{
+ /** Pointer to the KMKCCEVALPROG::pBlockTail member. */
+ PKMKCCBLOCK *ppBlockTail;
+
+ /** @name Line parsing state.
+ * @{ */
+ /** Offset of newline escape sequences in the current line.
+ * This is only applicable if cEscEols is not zero. */
+ PKMKCCEVALESCEOL paEscEols;
+ /** The number of number of paEscEols entries we've allocated. */
+ unsigned cEscEolsAllocated;
+ /** Number of escaped EOLs (line count - 1). */
+ unsigned cEscEols;
+ /** The paEscEols entry corresponding to the current parsing location.
+ * Still to be seen how accurate this can be made to be. */
+ unsigned iEscEol;
+
+ /** The current line number for error handling / debugging (1-based). */
+ unsigned iLine;
+ /** The start offset (into pchContent) of the current line. */
+ size_t offLine;
+ /** Length of the current line, sans the final EOL and comments. */
+ size_t cchLine;
+ /** Length of the current line, sans the final EOL but with comments. */
+ size_t cchLineWithComments;
+ /** For 'define' only, the start offset of the next line. Modified to the
+ * line following 'endef'. */
+ size_t offNext;
+
+ /** The first char in an EOL sequence.
+ * We ASSUMES that this char won't appear in any other sequence in the file,
+ * thus skipping matching any subsequent chars. */
+ char chFirstEol;
+ /** The second char in an EOL sequence, if applicable. */
+ char chSecondEol;
+
+ /** The length of the EOL sequence. */
+ size_t cchEolSeq;
+ /** The minimum length of an esacped EOL sequence (cchEolSeq + 1). */
+ size_t cchEscEolSeq;
+
+ /** String copy segments. */
+ PKMKCCEVALSTRCPYSEG paStrCopySegs;
+ /** The number of segments that has been prepared. */
+ unsigned cStrCopySegs;
+ /** The number of segments we've allocated. */
+ unsigned cStrCopySegsAllocated;
+ /** @} */
+
+
+ /** @name Recipe state.
+ * @{ */
+ /** Set if we're working on a recipe. */
+ PKMKCCEVALRECIPE pRecipe;
+ /** Set for ignoring recipes without targets (SunOS 4 Make). */
+ uint8_t fNoTargetRecipe;
+ /** The command prefix character. */
+ char chCmdPrefix;
+ /** @} */
+
+ /** @name Tokenzied words.
+ * @{ */
+ unsigned cWords;
+ unsigned cWordsAllocated;
+ PKMKCCEVALWORD paWords;
+ /** @} */
+
+ /** @name Conditionals.
+ * @{ */
+ /** Current conditional stack depth. */
+ unsigned cIfs;
+ /** The conditional directive stack. */
+ PKMKCCEVALIFCORE apIfs[KMK_CC_EVAL_MAX_IF_DEPTH];
+ /** @} */
+
+ /** The program being compiled. */
+ PKMKCCEVALPROG pEvalProg;
+ /** Pointer to the content. */
+ const char *pszContent;
+ /** The amount of input to parse. */
+ size_t cchContent;
+} KMKCCEVALCOMPILER;
+typedef KMKCCEVALCOMPILER *PKMKCCEVALCOMPILER;
+
+
+static void kmk_cc_eval_init_compiler(PKMKCCEVALCOMPILER pCompiler, PKMKCCEVALPROG pEvalProg, unsigned iLine,
+ const char *pszContent, size_t cchContent)
+{
+ pCompiler->ppBlockTail = &pEvalProg->pBlockTail;
+
+ pCompiler->pRecipe = NULL;
+ pCompiler->fNoTargetRecipe = 0;
+ pCompiler->chCmdPrefix = cmd_prefix;
+
+ pCompiler->cWordsAllocated = 0;
+ pCompiler->paWords = NULL;
+
+ pCompiler->cEscEolsAllocated = 0;
+ pCompiler->paEscEols = NULL;
+ pCompiler->iLine = iLine;
+
+ pCompiler->cStrCopySegsAllocated = 0;
+ pCompiler->paStrCopySegs = NULL;
+
+ pCompiler->cIfs = 0;
+
+ pCompiler->pEvalProg = pEvalProg;
+ pCompiler->pszContent = pszContent;
+ pCompiler->cchContent = cchContent;
+
+ /* Detect EOL style. */
+ pCompiler->cchEolSeq = kmk_cc_eval_detect_eol_style(&pCompiler->chFirstEol, &pCompiler->chSecondEol,
+ pszContent, cchContent);
+ pCompiler->cchEscEolSeq = 1 + pCompiler->cchEolSeq;
+}
+
+
+static void kmk_cc_eval_delete_compiler(PKMKCCEVALCOMPILER pCompiler)
+{
+ if (pCompiler->paWords)
+ free(pCompiler->paWords);
+ if (pCompiler->paEscEols)
+ free(pCompiler->paEscEols);
+}
+
+
+/**
+ * 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;
+ 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: *** fatal parsing error in %s: ",
+ pCompiler->pEvalProg->pszFilename, iLine, iColumn, pCompiler->pEvalProg->pszVarName);
+ else
+ fprintf(stderr, "%s:%u:%u: *** fatal parsing error: ",
+ pCompiler->pEvalProg->pszFilename, iLine, iColumn);
+ }
+ else if (pCompiler->pEvalProg->pszVarName)
+ fprintf(stderr, "%s:%u: *** fatal parsing error in %s: ",
+ pCompiler->pEvalProg->pszFilename, pCompiler->iLine, pCompiler->pEvalProg->pszVarName);
+ else
+ fprintf(stderr, "%s:%u: *** fatal parsing error: ",
+ pCompiler->pEvalProg->pszFilename, pCompiler->iLine);
+
+ /*
+ * Print the message and die.
+ */
+ va_start(va, pszMsg);
+ vfprintf(stderr, pszMsg, va);
+ va_end(va);
+ fputs(". Stop.\n", stderr);
+
+ for (;;)
+ die(2);
+}
+
+
+static KMK_CC_FN_NO_RETURN void
+kmk_cc_eval_fatal_eol(PKMKCCEVALCOMPILER pCompiler, const char *pchEol, unsigned iLine, size_t offLine)
+{
+ pCompiler->iLine = iLine;
+ pCompiler->offLine = offLine;
+
+ for (;;)
+ kmk_cc_eval_fatal(pCompiler, pchEol, "Missing 2nd EOL character: found %#x instead of %#x\n",
+ pchEol, pCompiler->chSecondEol);
+}
+
+
+static void kmk_cc_eval_warn(PKMKCCEVALCOMPILER pCompiler, const char *pchWhere, const char *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);
+}
+
+
+/**
+ * Compiles a string expansion subprogram.
+ *
+ * @param pCompiler The compiler state.
+ * @param pszExpr The expression to compile.
+ * @param cchExpr The length of the expression.
+ * @param pSubprog The subprogram to compile.
+ */
+static void kmk_cc_eval_compile_string_exp_subprog(PKMKCCEVALCOMPILER pCompiler, const char *pszExpr, size_t cchExpr,
+ PKMKCCEXPSUBPROG pSubprog)
+{
+ int rc = kmk_cc_exp_compile_subprog(pCompiler->ppBlockTail, pszExpr, cchExpr, pSubprog);
+ if (rc == 0)
+ return;
+ kmk_cc_eval_fatal(pCompiler, NULL, "String expansion compile error");
+}
+
+
+/**
+ * Initializes a subprogam or plain operand structure.
+ *
+ * @param pCompiler The compiler state.
+ * @param pOperand The subprogram or plain structure to init.
+ * @param pszString The string.
+ * @param cchString The length of the string.
+ * @param fPlain Whether it's plain or not. If not, we'll compile it.
+ */
+static void kmk_cc_eval_init_subprogram_or_plain(PKMKCCEVALCOMPILER pCompiler, PKMKCCEXPSUBPROGORPLAIN pOperand,
+ const char *pszString, size_t cchString, int fPlain)
+{
+ pOperand->fPlainIsInVarStrCache = 0;
+ pOperand->bUser = 0;
+ pOperand->bUser2 = 0;
+ pOperand->fSubprog = fPlain;
+ if (fPlain)
+ {
+ pOperand->u.Plain.cch = cchString;
+ pOperand->u.Plain.psz = pszString;
+ }
+ else
+ kmk_cc_eval_compile_string_exp_subprog(pCompiler, pszString, cchString, &pOperand->u.Subprog);
+}
+
+/**
+ * Initializes an array of subprogram-or-plain (spp) operands from a word array.
+ *
+ * The words will be duplicated and the caller must therefore call
+ * kmk_cc_block_realign() when done (it's not done here as the caller may
+ * initialize several string operands and we don't want any unnecessary
+ * fragmentation).
+ *
+ * @param pCompiler The compiler state.
+ * @param cWords The number of words to copy.
+ * @param paSrc The source words.
+ * @param paDst The destination subprogram-or-plain array.
+ */
+static void kmk_cc_eval_init_spp_array_from_duplicated_words(PKMKCCEVALCOMPILER pCompiler, unsigned cWords,
+ PKMKCCEVALWORD paSrc, PKMKCCEXPSUBPROGORPLAIN paDst)
+{
+ unsigned i;
+ for (i = 0; i < cWords; i++)
+ {
+ const char *pszCopy = kmk_cc_block_strdup(pCompiler->ppBlockTail, paSrc[i].pchWord, paSrc[i].cchWord);
+ paDst[i].fPlainIsInVarStrCache = 0;
+ paDst[i].bUser = 0;
+ paDst[i].bUser2 = 0;
+ if (paSrc[i].enmToken == kKmkCcEvalToken_WordWithDollar)
+ {
+ 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);
+ }
+ else
+ {
+ paDst[i].fSubprog = 0;
+ paDst[i].u.Plain.cch = paSrc[i].cchWord;
+ paDst[i].u.Plain.psz = pszCopy;
+ }
+ KMK_CC_EVAL_DPRINTF((" %s\n", pszCopy));
+ }
+}
+
+
+
+/** @name KMK_CC_WORD_COMP_CONST_XXX - Optimal(/insane) constant work matching.
+ * @{
+ */
+#if (defined(KBUILD_ARCH_X86) || defined(KBUILD_ARCH_AMD64)) /* Unaligned access is reasonably cheap. */ \
+ && !defined(GCC_ADDRESS_SANITIZER)
+# define KMK_CC_WORD_COMP_CONST_2(a_pchLine, a_pszWord) \
+ ( *(uint16_t const *)(a_pchLine) == *(uint16_t const *)(a_pszWord) )
+# define KMK_CC_WORD_COMP_CONST_3(a_pchLine, a_pszWord) \
+ ( *(uint16_t const *)(a_pchLine) == *(uint16_t const *)(a_pszWord) \
+ && (a_pchLine)[2] == (a_pszWord)[2] )
+# define KMK_CC_WORD_COMP_CONST_4(a_pchLine, a_pszWord) \
+ ( *(uint32_t const *)(a_pchLine) == *(uint32_t const *)(a_pszWord) )
+# define KMK_CC_WORD_COMP_CONST_5(a_pchLine, a_pszWord) \
+ ( *(uint32_t const *)(a_pchLine) == *(uint32_t const *)(a_pszWord) \
+ && (a_pchLine)[4] == (a_pszWord)[4] )
+# 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] == ((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] == ((uint16_t const *)(a_pszWord))[2] \
+ && (a_pchLine)[6] == (a_pszWord)[6] )
+# define KMK_CC_WORD_COMP_CONST_8(a_pchLine, a_pszWord) \
+ ( *(uint64_t const *)(a_pchLine) == *(uint64_t const *)(a_pszWord) )
+# define KMK_CC_WORD_COMP_CONST_10(a_pchLine, a_pszWord) \
+ ( *(uint64_t const *)(a_pchLine) == *(uint64_t const *)(a_pszWord) \
+ && ((uint16_t const *)(a_pchLine))[4] == ((uint16_t const *)(a_pszWord))[4] )
+# define KMK_CC_WORD_COMP_CONST_16(a_pchLine, a_pszWord) \
+ ( *(uint64_t const *)(a_pchLine) == *(uint64_t const *)(a_pszWord) \
+ && ((uint64_t const *)(a_pchLine))[1] == ((uint64_t const *)(a_pszWord))[1] )
+#else
+# define KMK_CC_WORD_COMP_CONST_2(a_pchLine, a_pszWord) \
+ ( (a_pchLine)[0] == (a_pszWord)[0] \
+ && (a_pchLine)[1] == (a_pszWord)[1] )
+# define KMK_CC_WORD_COMP_CONST_3(a_pchLine, a_pszWord) \
+ ( (a_pchLine)[0] == (a_pszWord)[0] \
+ && (a_pchLine)[1] == (a_pszWord)[1] \
+ && (a_pchLine)[2] == (a_pszWord)[2] )
+# define KMK_CC_WORD_COMP_CONST_4(a_pchLine, a_pszWord) \
+ ( (a_pchLine)[0] == (a_pszWord)[0] \
+ && (a_pchLine)[1] == (a_pszWord)[1] \
+ && (a_pchLine)[2] == (a_pszWord)[2] \
+ && (a_pchLine)[3] == (a_pszWord)[3] )
+# define KMK_CC_WORD_COMP_CONST_5(a_pchLine, a_pszWord) \
+ ( (a_pchLine)[0] == (a_pszWord)[0] \
+ && (a_pchLine)[1] == (a_pszWord)[1] \
+ && (a_pchLine)[2] == (a_pszWord)[2] \
+ && (a_pchLine)[3] == (a_pszWord)[3] \
+ && (a_pchLine)[4] == (a_pszWord)[4] )
+# define KMK_CC_WORD_COMP_CONST_6(a_pchLine, a_pszWord) \
+ ( (a_pchLine)[0] == (a_pszWord)[0] \
+ && (a_pchLine)[1] == (a_pszWord)[1] \
+ && (a_pchLine)[2] == (a_pszWord)[2] \
+ && (a_pchLine)[3] == (a_pszWord)[3] \
+ && (a_pchLine)[4] == (a_pszWord)[4] \
+ && (a_pchLine)[5] == (a_pszWord)[5] )
+# define KMK_CC_WORD_COMP_CONST_7(a_pchLine, a_pszWord) \
+ ( (a_pchLine)[0] == (a_pszWord)[0] \
+ && (a_pchLine)[1] == (a_pszWord)[1] \
+ && (a_pchLine)[2] == (a_pszWord)[2] \
+ && (a_pchLine)[3] == (a_pszWord)[3] \
+ && (a_pchLine)[4] == (a_pszWord)[4] \
+ && (a_pchLine)[5] == (a_pszWord)[5] \
+ && (a_pchLine)[6] == (a_pszWord)[6] )
+# define KMK_CC_WORD_COMP_CONST_8(a_pchLine, a_pszWord) \
+ ( (a_pchLine)[0] == (a_pszWord)[0] \
+ && (a_pchLine)[1] == (a_pszWord)[1] \
+ && (a_pchLine)[2] == (a_pszWord)[2] \
+ && (a_pchLine)[3] == (a_pszWord)[3] \
+ && (a_pchLine)[4] == (a_pszWord)[4] \
+ && (a_pchLine)[5] == (a_pszWord)[5] \
+ && (a_pchLine)[6] == (a_pszWord)[6] \
+ && (a_pchLine)[7] == (a_pszWord)[7] )
+# define KMK_CC_WORD_COMP_CONST_10(a_pchLine, a_pszWord) \
+ ( (a_pchLine)[0] == (a_pszWord)[0] \
+ && (a_pchLine)[1] == (a_pszWord)[1] \
+ && (a_pchLine)[2] == (a_pszWord)[2] \
+ && (a_pchLine)[3] == (a_pszWord)[3] \
+ && (a_pchLine)[4] == (a_pszWord)[4] \
+ && (a_pchLine)[5] == (a_pszWord)[5] \
+ && (a_pchLine)[6] == (a_pszWord)[6] \
+ && (a_pchLine)[7] == (a_pszWord)[7] \
+ && (a_pchLine)[8] == (a_pszWord)[8] \
+ && (a_pchLine)[9] == (a_pszWord)[9] )
+# define KMK_CC_WORD_COMP_CONST_16(a_pchLine, a_pszWord) \
+ ( (a_pchLine)[0] == (a_pszWord)[0] \
+ && (a_pchLine)[1] == (a_pszWord)[1] \
+ && (a_pchLine)[2] == (a_pszWord)[2] \
+ && (a_pchLine)[3] == (a_pszWord)[3] \
+ && (a_pchLine)[4] == (a_pszWord)[4] \
+ && (a_pchLine)[5] == (a_pszWord)[5] \
+ && (a_pchLine)[6] == (a_pszWord)[6] \
+ && (a_pchLine)[7] == (a_pszWord)[7] \
+ && (a_pchLine)[8] == (a_pszWord)[8] \
+ && (a_pchLine)[9] == (a_pszWord)[9] \
+ && (a_pchLine)[10] == (a_pszWord)[10] \
+ && (a_pchLine)[11] == (a_pszWord)[11] \
+ && (a_pchLine)[12] == (a_pszWord)[12] \
+ && (a_pchLine)[13] == (a_pszWord)[13] \
+ && (a_pchLine)[14] == (a_pszWord)[14] \
+ && (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_EVAL_WORD_COMP_IS_EOL(a_pCompiler, a_pchLine, a_cchLine) \
+ ( (a_cchLine) == 0 \
+ || KMK_CC_EVAL_IS_SPACE((a_pchLine)[0]) \
+ || ((a_pchLine)[0] == '\\' && (a_pchLine)[1] == (a_pCompiler)->chFirstEol) ) \
+
+/** See if a starting of a given length starts with a constant word. */
+#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) \
+ || KMK_CC_EVAL_IS_SPACE((a_pchLine)[a_cchWord]) \
+ || ((a_pchLine)[a_cchWord] == '\\' && (a_pchLine)[(a_cchWord) + 1] == (a_pCompiler)->chFirstEol) ) \
+ && KMK_CC_WORD_COMP_CONST_##a_cchWord(a_pchLine, a_pszWord) )
+/** @} */
+
+
+/**
+ * Checks if a_ch is a space after a word.
+ *
+ * Since there is always a terminating zero, the user can safely access a char
+ * beyond @a a_cchLeft. However, that byte isn't necessarily a zero terminator
+ * character, so we have to check @a a_cchLeft whether we're at the end of the
+ * parsing input string.
+ *
+ * @returns true / false.
+ * @param a_pCompiler The compiler instance data.
+ * @param a_ch The character to inspect.
+ * @param a_ch2 The character following it, in case of escaped EOL.
+ * @param a_cchLeft The number of chars left to parse (from @a a_ch).
+ */
+#define KMK_CC_EVAL_IS_SPACE_AFTER_WORD(a_pCompiler, a_ch, a_ch2, a_cchLeft) \
+ ( a_cchLeft == 0 \
+ || KMK_CC_EVAL_IS_SPACE(a_ch) \
+ || ((a_ch) == '\\' && (a_ch2) == (a_pCompiler)->chFirstEol) )
+
+
+/**
+ * Common path for space skipping worker functions when escaped EOLs may be
+ * involed.
+ *
+ * @returns Points to the first non-space character or end of input.
+ * @param pchWord The current position. There is some kind of char
+ * @param cchLeft The current number of chars left to parse in the
+ * current line.
+ * @param pcchLeft Where to store the updated @a cchLeft value.
+ * @param pCompiler The compiler instance data.
+ */
+static const char *kmk_cc_eval_skip_spaces_with_esc_eol(const char *pchWord, size_t cchLeft, size_t *pcchLeft,
+ PKMKCCEVALCOMPILER pCompiler)
+{
+ /*
+ * Skip further spaces. We unrolls 4 loops here.
+ * ASSUMES cchEscEolSeq is either 2 or 3!
+ */
+ KMK_CC_ASSERT(pCompiler->cchEscEolSeq == 2 || pCompiler->cchEscEolSeq == 3);
+ KMK_CC_ASSERT(pCompiler->iEscEol < pCompiler->cEscEols);
+ while (cchLeft >= 4)
+ {
+ /* First char. */
+ char ch = pchWord[0];
+ if (KMK_CC_EVAL_IS_SPACE(ch))
+ { /* maybe likely */ }
+ else if ( ch == '\\'
+ && pchWord[1] == pCompiler->chFirstEol)
+ {
+ pchWord += pCompiler->cchEscEolSeq;
+ cchLeft -= pCompiler->cchEscEolSeq;
+ pCompiler->iEscEol++;
+ continue;
+ }
+ else
+ {
+ *pcchLeft = cchLeft;
+ return pchWord;
+ }
+
+ /* Second char. */
+ ch = pchWord[1];
+ if (KMK_CC_EVAL_IS_SPACE(ch))
+ { /* maybe likely */ }
+ else if ( ch == '\\'
+ && pchWord[2] == pCompiler->chFirstEol)
+ {
+ pchWord += 1 + pCompiler->cchEscEolSeq;
+ cchLeft -= 1 + pCompiler->cchEscEolSeq;
+ pCompiler->iEscEol++;
+ continue;
+ }
+ else
+ {
+ *pcchLeft = cchLeft - 1;
+ return pchWord + 1;
+ }
+
+ /* Third char. */
+ ch = pchWord[2];
+ if (KMK_CC_EVAL_IS_SPACE(ch))
+ { /* maybe likely */ }
+ else if ( ch == '\\'
+ && pchWord[3] == pCompiler->chFirstEol
+ && cchLeft >= 2 + pCompiler->cchEscEolSeq)
+ {
+ pchWord += 2 + pCompiler->cchEscEolSeq;
+ cchLeft -= 2 + pCompiler->cchEscEolSeq;
+ pCompiler->iEscEol++;
+ continue;
+ }
+ else
+ {
+ *pcchLeft = cchLeft - 2;
+ return pchWord + 2;
+ }
+
+ /* Third char. */
+ ch = pchWord[3];
+ if (KMK_CC_EVAL_IS_SPACE(ch))
+ {
+ pchWord += 4;
+ cchLeft -= 4;
+ }
+ else if ( ch == '\\'
+ && cchLeft >= 3 + pCompiler->cchEscEolSeq
+ && pchWord[4] == pCompiler->chFirstEol)
+ {
+ pchWord += 3 + pCompiler->cchEscEolSeq;
+ cchLeft -= 3 + pCompiler->cchEscEolSeq;
+ pCompiler->iEscEol++;
+ }
+ else
+ {
+ *pcchLeft = cchLeft - 3;
+ return pchWord + 3;
+ }
+ }
+
+ /*
+ * Simple loop for the final three chars.
+ */
+ while (cchLeft > 0)
+ {
+ /* First char. */
+ char ch = *pchWord;
+ if (KMK_CC_EVAL_IS_SPACE(ch))
+ {
+ pchWord += 1;
+ cchLeft -= 1;
+ }
+ else if ( ch == '\\'
+ && cchLeft > pCompiler->cchEolSeq
+ && pchWord[1] == pCompiler->chFirstEol)
+ {
+ pchWord += pCompiler->cchEscEolSeq;
+ cchLeft -= pCompiler->cchEscEolSeq;
+ pCompiler->iEscEol++;
+ }
+ else
+ break;
+ }
+
+ *pcchLeft = cchLeft;
+ return pchWord;
+}
+
+
+/**
+ * Common path for space skipping worker functions when no escaped EOLs need
+ * considering.
+ *
+ * @returns Points to the first non-space character or end of input.
+ * @param pchWord The current position. There is some kind of char
+ * @param cchLeft The current number of chars left to parse in the
+ * current line.
+ * @param pcchLeft Where to store the updated @a cchLeft value.
+ * @param pCompiler The compiler instance data.
+ */
+static const char *kmk_cc_eval_skip_spaces_without_esc_eol(const char *pchWord, size_t cchLeft, size_t *pcchLeft,
+ PKMKCCEVALCOMPILER pCompiler)
+{
+ /*
+ * 4x loop unroll.
+ */
+ while (cchLeft >= 4)
+ {
+ if (KMK_CC_EVAL_IS_SPACE(pchWord[0]))
+ {
+ if (KMK_CC_EVAL_IS_SPACE(pchWord[1]))
+ {
+ if (KMK_CC_EVAL_IS_SPACE(pchWord[2]))
+ {
+ if (KMK_CC_EVAL_IS_SPACE(pchWord[3]))
+ {
+ pchWord += 4;
+ cchLeft -= 4;
+ }
+ else
+ {
+ *pcchLeft = cchLeft - 3;
+ return pchWord + 3;
+ }
+ }
+ else
+ {
+ *pcchLeft = cchLeft - 2;
+ return pchWord + 2;
+ }
+ }
+ else
+ {
+ *pcchLeft = cchLeft - 1;
+ return pchWord + 1;
+ }
+ }
+ else
+ {
+ *pcchLeft = cchLeft;
+ return pchWord;
+ }
+ }
+
+ /*
+ * The last 3. Not entirely sure if this yield good code.
+ */
+ switch (cchLeft & 3)
+ {
+ case 3:
+ if (!KMK_CC_EVAL_IS_SPACE(*pchWord))
+ break;
+ pchWord++;
+ cchLeft--;
+ case 2:
+ if (!KMK_CC_EVAL_IS_SPACE(*pchWord))
+ break;
+ pchWord++;
+ cchLeft--;
+ case 1:
+ if (!KMK_CC_EVAL_IS_SPACE(*pchWord))
+ break;
+ pchWord++;
+ cchLeft--;
+ case 0:
+ break;
+ }
+
+ *pcchLeft = cchLeft;
+ return pchWord;
+}
+
+
+/**
+ * Used to skip spaces after a word.
+ *
+ * We ASSUME that the first char is a space or that we've reached the end of the
+ * string (a_cchLeft == 0).
+ *
+ * @param a_pCompiler The compiler instance data.
+ * @param a_pchWord The current input position, this will be moved to
+ * the start of the next word or end of the input.
+ * @param a_cchLeft The number of chars left to parse. This will be
+ * updated.
+ */
+#define KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(a_pCompiler, a_pchWord, a_cchLeft) \
+ do { \
+ /* Skip the first char which is known to be a space, end of line or end of input. */ \
+ if ((a_cchLeft) > 0) \
+ { \
+ char const chSkipBlanksFirst = *(a_pchWord); \
+ KMK_CC_ASSERT(KMK_CC_EVAL_IS_SPACE_AFTER_WORD(a_pCompiler, chSkipBlanksFirst, (a_pchWord)[1], a_cchLeft)); \
+ if (chSkipBlanksFirst != '\\') \
+ { \
+ (a_pchWord) += 1; \
+ (a_cchLeft) -= 1; \
+ \
+ /* Another space or escaped EOL? Then there are probably more then, so call worker function. */ \
+ if ((a_cchLeft) > 0) \
+ { \
+ char const chSkipBlanksSecond = *(a_pchWord); \
+ if (KMK_CC_EVAL_IS_SPACE_OR_BACKSLASH(chSkipBlanksSecond)) \
+ (a_pchWord) = kmk_cc_eval_skip_spaces_after_word_slow(a_pchWord, &(a_cchLeft), \
+ chSkipBlanksSecond, a_pCompiler); \
+ } \
+ } \
+ else /* escape sequences can be complicated. */ \
+ (a_pchWord) = kmk_cc_eval_skip_spaces_after_word_slow(a_pchWord, &(a_cchLeft), \
+ chSkipBlanksFirst, a_pCompiler); \
+ } \
+ } while (0)
+
+/**
+ * The slow path of KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD.
+ *
+ * This is called to handles escaped EOL sequences, as these can involve
+ * multiple backslashes and therefore doesn't led themselves well to inlined
+ * code.
+ *
+ * The other case this is used for is to handle more than once space, since it's
+ * likely that when there are two there might be more. No point in inlining
+ * that, better do some loop unrolling instead.
+ *
+ * @returns Points to the first non-space character or end of input.
+ * @param pchWord The current position. There is some kind of char
+ * @param pcchLeft Pointer to the cchLeft variable, this is both
+ * input and output.
+ * @param ch The current character.
+ * @param pCompiler The compiler instance data.
+ */
+static const char *kmk_cc_eval_skip_spaces_after_word_slow(const char *pchWord, size_t *pcchLeft, char ch,
+ PKMKCCEVALCOMPILER pCompiler)
+{
+ size_t cchLeft = *pcchLeft;
+
+ /*
+ * It's all very simple when we don't have to consider escaped EOLs.
+ */
+ if (pCompiler->iEscEol >= pCompiler->cEscEols)
+ {
+ if (ch != '\\')
+ {
+ pchWord += 1;
+ cchLeft -= 1;
+ }
+ else
+ return pchWord;
+ return kmk_cc_eval_skip_spaces_without_esc_eol(pchWord, cchLeft, pcchLeft, pCompiler);
+ }
+
+ /*
+ * Skip the pending space or EOL found by the caller. We need to
+ * confirm the EOL.
+ *
+ * Note! We only need to care about simple backslash+EOL sequences here
+ * since we're either at the end of a validated word, or we've already
+ * skipped one space. In the former case, someone else has already
+ * validated the escape esequence, in the latter case multiple
+ * backslashes would indicate a new word that that we should return.
+ */
+ if (ch != '\\')
+ {
+ pchWord += 1;
+ cchLeft -= 1;
+ }
+ else if ( cchLeft >= pCompiler->cchEscEolSeq
+ && pchWord[1] == pCompiler->chFirstEol)
+ {
+ KMK_CC_ASSERT(pCompiler->cchEolSeq == 1 || pchWord[2] == pCompiler->chSecondEol);
+ pchWord += pCompiler->cchEscEolSeq;
+ cchLeft -= pCompiler->cchEscEolSeq;
+ pCompiler->iEscEol++;
+
+ if (pCompiler->iEscEol < pCompiler->cEscEols)
+ { /* likely */ }
+ else return kmk_cc_eval_skip_spaces_without_esc_eol(pchWord, cchLeft, pcchLeft, pCompiler);
+ }
+ else
+ return pchWord;
+ return kmk_cc_eval_skip_spaces_with_esc_eol(pchWord, cchLeft, pcchLeft, pCompiler);
+}
+
+
+/**
+ * Skip zero or more spaces.
+ *
+ * This macro deals with a single space, if there are more or we're hittin some
+ * possible escaped EOL sequence, work is deferred to a worker function.
+ *
+ * @param a_pCompiler The compiler state.
+ * @param a_pchWord The current input position. Advanced past spaces.
+ * @param a_cchLeft The amount of input left to parse. Will be updated.
+ */
+#define KMK_CC_EVAL_SKIP_SPACES(a_pCompiler, a_pchWord, a_cchLeft) \
+ do { \
+ if ((a_cchLeft) > 0) \
+ { \
+ char chSkipSpaces = *(a_pchWord); \
+ if (KMK_CC_EVAL_IS_SPACE_OR_BACKSLASH(chSkipSpaces)) \
+ { \
+ if (chSkipSpaces != '\\') \
+ { \
+ (a_pchWord) += 1; \
+ (a_cchLeft) -= 1; \
+ chSkipSpaces = *(a_pchWord); \
+ if (KMK_CC_EVAL_IS_SPACE_OR_BACKSLASH(chSkipSpaces)) \
+ (a_pchWord) = kmk_cc_eval_skip_spaces_slow(a_pchWord, &(a_cchLeft), chSkipSpaces, a_pCompiler); \
+ } \
+ else \
+ (a_pchWord) = kmk_cc_eval_skip_spaces_slow(a_pchWord, &(a_cchLeft), chSkipSpaces, a_pCompiler); \
+ } \
+ } \
+ } while (0)
+
+
+/**
+ * Worker for KMK_CC_EVAL_SKIP_SPACES.
+ *
+ * @returns Points to the first non-space character or end of input.
+ * @param pchWord The current position. There is some kind of char
+ * @param pcchLeft Pointer to the cchLeft variable, this is both
+ * input and output.
+ * @param ch The current character.
+ * @param pCompiler The compiler instance data.
+ */
+static const char *kmk_cc_eval_skip_spaces_slow(const char *pchWord, size_t *pcchLeft, char ch, PKMKCCEVALCOMPILER pCompiler)
+{
+ size_t cchLeft = *pcchLeft;
+#ifdef KMK_CC_STRICT
+ size_t offWordCcStrict = pchWord - pCompiler->pszContent;
+#endif
+ KMK_CC_ASSERT(cchLeft > 0);
+ KMK_CC_ASSERT(cchLeft <= pCompiler->cchLine);
+ KMK_CC_ASSERT(*pchWord == ch);
+ KMK_CC_ASSERT(KMK_CC_EVAL_IS_SPACE_OR_BACKSLASH(ch));
+ KMK_CC_ASSERT(offWordCcStrict >= pCompiler->offLine);
+ KMK_CC_ASSERT(offWordCcStrict < pCompiler->offLine + pCompiler->cchLine);
+ KMK_CC_ASSERT( pCompiler->iEscEol >= pCompiler->cEscEols
+ || offWordCcStrict <= pCompiler->paEscEols[pCompiler->iEscEol].offEsc);
+ KMK_CC_ASSERT( pCompiler->iEscEol >= pCompiler->cEscEols
+ || pCompiler->iEscEol == 0
+ || offWordCcStrict >= pCompiler->paEscEols[pCompiler->iEscEol - 1].offEol + pCompiler->cchEolSeq);
+
+ /*
+ * If we don't need to consider escaped EOLs, things are much much simpler.
+ */
+ if (pCompiler->iEscEol >= pCompiler->cEscEols)
+ {
+ if (ch != '\\')
+ {
+ pchWord++;
+ cchLeft--;
+ }
+ else
+ return pchWord;
+ return kmk_cc_eval_skip_spaces_without_esc_eol(pchWord, cchLeft, pcchLeft, pCompiler);
+ }
+
+ /*
+ * Possible escaped EOL complications.
+ */
+ if (ch != '\\')
+ {
+ pchWord++;
+ cchLeft--;
+ }
+ else
+ {
+ size_t cchSkip;
+ size_t offWord;
+ unsigned iEscEol = pCompiler->iEscEol;
+ if (iEscEol >= pCompiler->cEscEols)
+ return pchWord;
+
+ offWord = pchWord - pCompiler->pszContent;
+ if (offWord < pCompiler->paEscEols[iEscEol].offEsc)
+ return pchWord;
+ KMK_CC_ASSERT(offWord == pCompiler->paEscEols[iEscEol].offEsc);
+
+ cchSkip = pCompiler->paEscEols[iEscEol].offEol + pCompiler->cchEolSeq - offWord;
+ pchWord += cchSkip;
+ cchLeft -= cchSkip;
+ pCompiler->iEscEol = ++iEscEol;
+
+ if (iEscEol < pCompiler->cEscEols)
+ { /* likely */ }
+ else return kmk_cc_eval_skip_spaces_without_esc_eol(pchWord, cchLeft, pcchLeft, pCompiler);
+ }
+ return kmk_cc_eval_skip_spaces_with_esc_eol(pchWord, cchLeft, pcchLeft, pCompiler);
+}
+
+
+#if 0 /* unused - probably forever. */
+/**
+ * Skips to the end of a variable name.
+ *
+ * This may advance pCompiler->iEscEol.
+ *
+ * @returns Pointer to the first char after the variable name.
+ * @param pCompiler The compiler state.
+ * @param pchWord The current position. Must be at the start of the
+ * variable name.
+ * @param cchLeft The number of chars left to parse in the current line.
+ * @param pcchLeft The to store the updated count of characters left to
+ * parse.
+ * @param pfPlain Where to store the plain variable name indicator.
+ * Returns 0 if plain, and 1 if there are variable
+ * references in it.
+ */
+static const char *kmk_cc_eval_skip_var_name(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft,
+ size_t *pcchLeft, int *pfPlain)
+{
+ const char * const pszContent = pCompiler->pszContent;
+ size_t off = pchWord - pszContent;
+ size_t const offLineEnd = off + cchLeft;
+ int fPlain = 1;
+ unsigned iEscEol = pCompiler->iEscEol;
+
+ /* Check our expectations. */
+ KMK_CC_ASSERT(cchLeft);
+ KMK_CC_ASSERT(!KMK_CC_EVAL_IS_SPACE(*pchWord));
+ KMK_CC_ASSERT(iEscEol <= pCompiler->cEscEols);
+ KMK_CC_ASSERT( iEscEol >= pCompiler->cEscEols
+ || off < pCompiler->paEscEols[iEscEol].offEol);
+ KMK_CC_ASSERT(off >= (iEscEol == 0 ? pCompiler->offLine : pCompiler->paEscEols[iEscEol - 1].offEol + pCompiler->cchEolSeq));
+
+ /*
+ * The outer loop parses plain text. Variable expansion ($) is handled
+ * by the inner loop.
+ */
+ while (off < offLineEnd)
+ {
+ char ch = pszContent[off];
+ if (!KMK_CC_EVAL_IS_SPACE_DOLLAR_OR_SLASH(ch))
+ off++;
+ else if (KMK_CC_EVAL_IS_SPACE(ch))
+ break;
+ else if (ch == '$')
+ {
+ off++;
+ if (off < offLineEnd)
+ {
+ char const chOpen = pszContent[off];
+ if (chOpen == '(' || chOpen == '{')
+ {
+ /*
+ * 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.
+ */
+ size_t const offStart = off - 1;
+ char const chClose = chOpen == '(' ? ')' : '}';
+ unsigned cOpen = 1;
+ off++;
+ for (;;)
+ {
+ if (off < offLineEnd)
+ {
+ ch = pszContent[off];
+ if (!(KMK_CC_EVAL_IS_PAREN_OR_SLASH(ch)))
+ off++;
+ else
+ {
+ off++;
+ if (ch == chClose)
+ {
+ if (--cOpen == 0)
+ break;
+ }
+ else if (ch == chOpen)
+ cOpen++;
+ else if ( ch == '\\'
+ && iEscEol < pCompiler->cEscEols
+ && off == pCompiler->paEscEols[iEscEol].offEsc)
+ {
+ off = pCompiler->paEscEols[iEscEol].offEol + pCompiler->cchEolSeq;
+ pCompiler->iEscEol = ++iEscEol;
+ }
+ }
+ }
+ else if (cOpen == 1)
+ kmk_cc_eval_fatal(pCompiler, &pszContent[offStart],
+ "Variable reference is missing '%c'", chClose);
+ else
+ kmk_cc_eval_fatal(pCompiler, &pszContent[offStart],
+ "%u variable references are missing '%c'", cOpen, chClose);
+ }
+ }
+ /* Single char variable name. */
+ else if (!KMK_CC_EVAL_IS_SPACE(chOpen))
+ { /* likely */ }
+ else
+ kmk_cc_eval_fatal(pCompiler, &pszContent[off], "Expected variable name after '$', not end of line");
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, &pszContent[off], "Expected variable name after '$', not end of line");
+ fPlain = 0;
+ }
+ /* Deal with potential escaped EOL. */
+ else if ( ch != '\\'
+ || iEscEol >= pCompiler->cEscEols
+ || off != pCompiler->paEscEols[iEscEol].offEsc )
+ off++;
+ else
+ break;
+ }
+
+ *pcchLeft = offLineEnd - off;
+ *pfPlain = fPlain;
+ return &pszContent[off];
+}
+#endif /* unused */
+
+
+#if 0 /* unused atm */
+/**
+ * Prepares for copying a command line.
+ *
+ * The current version of this code will not modify any of the paEscEols
+ * entries, unlike our kmk_cc_eval_prep_normal_line sibling function.
+ *
+ * @returns The number of chars that will be copied by
+ * kmk_cc_eval_copy_prepped_command_line().
+ * @param pCompiler The compiler instance data.
+ * @param pchLeft Pointer to the first char to copy from the current line.
+ * This does not have to the start of a word.
+ * @param cchLeft The number of chars left on the current line starting at
+ * @a pchLeft.
+ */
+static size_t kmk_cc_eval_prep_command_line(PKMKCCEVALCOMPILER pCompiler, const char * const pchLeft, size_t cchLeft)
+{
+ size_t cchRet;
+ unsigned iEscEol = pCompiler->iEscEol;
+ unsigned const cEscEols = pCompiler->cEscEols;
+
+ KMK_CC_ASSERT(cchLeft > 0);
+ KMK_CC_ASSERT(iEscEol <= cEscEols);
+
+ if (iEscEol >= cEscEols)
+ {
+ /*
+ * No escaped EOLs left, dead simple.
+ */
+ cchRet = cchLeft;
+ }
+ else
+ {
+ /*
+ * Compared to the normal prepping of a line, this is actually
+ * really simple. We need to account for two kind of conversions:
+ * - One leading tab is skipped after escaped EOL.
+ * - Convert EOL to LF.
+ */
+ const char * const pszContent = pCompiler->pszContent;
+ size_t const cchEolSeq = pCompiler->cchEolSeq;
+
+#ifdef KMK_CC_STRICT
+ size_t const offLeft = pchLeft - pszContent;
+ KMK_CC_ASSERT(offLeft + cchLeft <= pCompiler->offLine + pCompiler->cchLine);
+ KMK_CC_ASSERT(offLeft + cchLeft <= pCompiler->cchContent);
+ KMK_CC_ASSERT(offLeft < pCompiler->paEscEols[iEscEol].offEsc);
+ KMK_CC_ASSERT(offLeft >= (iEscEol ? pCompiler->paEscEols[cEscEols - 1].offEol + pCompiler->cchEolSeq : pCompiler->offLine));
+#endif
+
+ cchRet = cchLeft;
+ if (cchEolSeq > 1)
+ cchRet -= (cchEolSeq - 1) * cEscEols;
+ do
+ {
+ if (pszContent[pCompiler->paEscEols[cchEolSeq].offEol])
+ cchRet--;
+ iEscEol++;
+ } while (iEscEol < cEscEols);
+ }
+ return cchRet;
+}
+
+
+/**
+ * Copies a command line to the buffer @a pszDst points to.
+ *
+ * Must only be used immediately after kmk_cc_eval_prep_command_line().
+ *
+ * @returns
+ * @param pCompiler The compiler instance data.
+ * @param pchLeft Pointer to the first char to copy from the current line.
+ * This does not have to the start of a word.
+ * @param cchPrepped The return value of kmk_cc_eval_prep_command_line().
+ * @param pszDst The destination buffer, must be at least @a cchPrepped
+ * plus one (terminator) char big.
+ */
+static void kmk_cc_eval_copy_prepped_command_line(PKMKCCEVALCOMPILER pCompiler, const char *pchLeft,
+ size_t cchPrepped, char *pszDst)
+{
+ unsigned iEscEol = pCompiler->iEscEol;
+ unsigned const cEscEols = pCompiler->cEscEols;
+ if (iEscEol >= cEscEols)
+ {
+ /* Single line. */
+ memcpy(pszDst, pchLeft, cchPrepped);
+ pszDst[cchPrepped] = '\0';
+ }
+ else
+ {
+ /* Multiple lines with normalized EOL and maybe one stripped leading TAB. */
+ char * const pszDstStart = pszDst;
+ const char * const pszContent = pCompiler->pszContent;
+ size_t const cchEolSeq = pCompiler->cchEolSeq;
+ size_t offLeft = pchLeft - pCompiler->pszContent;
+ size_t cchCopy;
+
+ do
+ {
+ size_t offEol = pCompiler->paEscEols[iEscEol].offEsc;
+ cchCopy = offEol - offLeft;
+ KMK_CC_ASSERT(offEol >= offLeft);
+
+ memcpy(pszDst, &pszContent[offLeft], cchCopy);
+ pszDst += cchCopy;
+ *pszDst += '\n';
+
+ offLeft = offEol + cchEolSeq;
+ if (pszContent[offLeft] == '\t')
+ offLeft++;
+ } while (iEscEol < cEscEols);
+
+ cchCopy = cchPrepped - (pszDst - pszDstStart);
+ KMK_CC_ASSERT(cchCopy <= cchPrepped);
+ memcpy(pszDst, &pszContent[offLeft], cchCopy);
+ pszDst += cchCopy;
+
+ *pszDst = '\0';
+ KMK_CC_ASSERT(pszDst == &pszDstStart[cchPrepped]);
+ }
+}
+#endif /* unused atm */
+
+
+static size_t kmk_cc_eval_parse_var_exp(PKMKCCEVALCOMPILER pCompiler, const char *pch, size_t cchLeft, size_t off)
+{
+ off++;
+ if (off < cchLeft)
+ {
+ char const chOpen = pch[++off];
+ if (chOpen == '(' || chOpen == '{')
+ {
+ /*
+ * 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.
+ */
+ size_t const offStart = off - 1;
+ char const chClose = chOpen == '(' ? ')' : '}';
+ unsigned cOpen = 1;
+ off++;
+ for (;;)
+ {
+ if (off < cchLeft)
+ {
+ char ch = pch[off];
+ if (!(KMK_CC_EVAL_IS_PAREN_OR_SLASH(ch)))
+ off++;
+ else
+ {
+ off++;
+ if (ch == chClose)
+ {
+ if (--cOpen == 0)
+ break;
+ }
+ else if (ch == chOpen)
+ cOpen++;
+ else if ( ch == '\\'
+ && pCompiler->iEscEol < pCompiler->cEscEols
+ && (size_t)(&pch[off] - pCompiler->pszContent)
+ == pCompiler->paEscEols[pCompiler->iEscEol].offEsc)
+ {
+ off += pCompiler->paEscEols[pCompiler->iEscEol].offEol
+ - pCompiler->paEscEols[pCompiler->iEscEol].offEsc
+ + pCompiler->cchEolSeq;
+ pCompiler->iEscEol++;
+ }
+ }
+ }
+ else if (cOpen == 1)
+ kmk_cc_eval_fatal(pCompiler, &pch[offStart], "Variable reference is missing '%c'", chClose);
+ else
+ kmk_cc_eval_fatal(pCompiler, &pch[offStart],
+ "%u variable references are missing '%c'", cOpen, chClose);
+ }
+ }
+ /* Single char variable name. */
+ else if (!KMK_CC_EVAL_IS_SPACE(chOpen))
+ { /* likely */ }
+ else
+ kmk_cc_eval_fatal(pCompiler, &pch[off], "Expected variable name after '$', not space ");
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, &pch[off], "Expected variable name after '$', end of line");
+ return off;
+}
+
+/**
+ * Helper for ensuring that we've got sufficient number of words allocated.
+ */
+#define KMK_CC_EVAL_ENSURE_WORDS(a_pCompiler, a_cRequiredWords) \
+ do { \
+ if ((a_cRequiredWords) < (a_pCompiler)->cWordsAllocated) \
+ { /* likely */ } \
+ else \
+ { \
+ unsigned cEnsureWords = ((a_cRequiredWords) + 3 /*15*/) & ~(unsigned)3/*15*/; \
+ KMK_CC_ASSERT((a_cRequiredWords) < 0x8000); \
+ (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;
+}
+
+
+/**
+ * Parses the remainder of the line into simple words.
+ *
+ * The resulting words are classified as either kKmkCcEvalToken_WordPlain,
+ * kKmkCcEvalToken_WordWithDollar, or kKmkCcEvalToken_WordWithDollarAndEscEol.
+ *
+ * @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_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 == '$')
+ {
+#ifdef XXXX
+ cchWord = kmk_cc_eval_parse_var_exp(pCompiler, pchWord, cchLeft, cchWord);
+ enmToken = kKmkCcEvalToken_WordWithDollar;
+#else
+ enmToken = kKmkCcEvalToken_WordWithDollar;
+ cchWord = kmk_cc_eval_parse_along_dollar_simple(pCompiler, cchWord, pchWord, cchLeft);
+#endif
+ }
+ 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 == '$')
+#ifdef XXXX
+ {
+ const unsigned iEscEolBefore = pCompiler->iEscEol;
+ cchWord = kmk_cc_eval_parse_var_exp(pCompiler, pchWord, cchLeft, cchWord);
+ enmToken = pCompiler->iEscEol == iEscEolBefore
+ ? kKmkCcEvalToken_WordWithDollar : kKmkCcEvalToken_WordWithDollarAndEscEol;
+ }
+#else
+ {
+ enmToken = kKmkCcEvalToken_WordWithDollar;
+ cchWord = kmk_cc_eval_parse_along_dollar_esc_eol(pCompiler, cchWord, pchWord, cchLeft);
+ }
+#endif
+ 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;
+ }
+ }
+
+ /* 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;
+ }
+ }
+
+ /* 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;
+}
+
+
+
+
+/**
+ * Gather string from segments and optional space insertion trick.
+ *
+ * @param pszDst The destination buffer.
+ * @param paSegs The source segments.
+ * @param cSegs The number of segments.
+ * @param cchDstPrepped The size of pszDst, excluding the terminator.
+ */
+static void kmk_cc_eval_strcpyv(char *pszDst, PCKMKCCEVALSTRCPYSEG paSegs, unsigned cSegs, size_t cchDstPrepped)
+{
+ const char *pszDstStart = pszDst;
+ unsigned iSeg = 0;
+ while (iSeg < cSegs)
+ {
+ size_t cchToCopy;
+ if (paSegs[iSeg].cchSrcAndPrependSpace >= 0)
+ cchToCopy = paSegs[iSeg].cchSrcAndPrependSpace;
+ else
+ {
+ cchToCopy = -paSegs[iSeg].cchSrcAndPrependSpace;
+ *pszDst++ = ' ';
+ }
+
+ memcpy(pszDst, paSegs[iSeg].pchSrc, cchToCopy);
+ pszDst += cchToCopy;
+
+ iSeg++;
+ }
+ *pszDst = '\0';
+ KMK_CC_ASSERT(pszDst == &pszDstStart[cchDstPrepped]); K_NOREF(pszDstStart); K_NOREF(cchDstPrepped);
+}
+
+
+/**
+ * Allocate a byte buffer and ocpy the prepared string segments into it.
+ *
+ * The caller must call kmk_cc_block_realign!
+ *
+ * @returns Pointer to the duplicated string.
+ * @param pCompiler The compiler instance data.
+ * @param cchPrepped The length of the prepped string segments.
+ */
+static char *kmk_cc_eval_strdup_prepped(PKMKCCEVALCOMPILER pCompiler, size_t cchPrepped)
+{
+ char *pszCopy = kmk_cc_block_byte_alloc(pCompiler->ppBlockTail, cchPrepped + 1);
+ kmk_cc_eval_strcpyv(pszCopy, pCompiler->paStrCopySegs, pCompiler->cStrCopySegs, cchPrepped);
+ return pszCopy;
+}
+
+
+/**
+ * Strip trailing spaces from prepped copy
+ *
+ * @param paSegs The segments to strip trailing chars from.
+ * @param pcSegs The number of segments (in/out).
+ * @param pcchDstPrepped The total number of chars prepped (in/out).
+ */
+static void kmk_cc_eval_strip_right_v(PKMKCCEVALSTRCPYSEG paSegs, unsigned *pcSegs, size_t *pcchDstPrepped)
+{
+ /*
+ * Work our way thru the segments, from the end obviously.
+ */
+ size_t cchDstPrepped = *pcchDstPrepped;
+ unsigned cSegs = *pcSegs;
+ while (cSegs > 0)
+ {
+ unsigned iSeg = cSegs - 1;
+ const char *pszSrc = paSegs[iSeg].pchSrc;
+ size_t cchSrc = paSegs[iSeg].cchSrcAndPrependSpace >= 0
+ ? paSegs[iSeg].cchSrcAndPrependSpace : -paSegs[iSeg].cchSrcAndPrependSpace;
+ if (cchSrc)
+ {
+ /*
+ * Check for trailing spaces.
+ */
+ size_t cchSrcOrg;
+ if (!KMK_CC_EVAL_IS_SPACE(pszSrc[cchSrc - 1]))
+ {
+ /* Special case: No trailing spaces at all. No need to update
+ input/output variables. */
+ if (cSegs == *pcSegs)
+ return;
+ break;
+ }
+
+ /* Skip the rest of the trailing spaces. */
+ cchSrcOrg = cchSrc;
+ do
+ cchSrc--;
+ while (cchSrc > 0 && KMK_CC_EVAL_IS_SPACE(pszSrc[cchSrc - 1]));
+
+ if (cchSrc > 0)
+ {
+ /*
+ * There are non-space chars in this segment. So, update the
+ * segment and total char count and we're done.
+ */
+ cchDstPrepped -= cchSrcOrg - cchSrc;
+ if (paSegs[iSeg].cchSrcAndPrependSpace < 0)
+ paSegs[iSeg].cchSrcAndPrependSpace = -(ssize_t)cchSrc;
+ else
+ paSegs[iSeg].cchSrcAndPrependSpace = cchSrc;
+ break;
+ }
+
+ /*
+ * Skip the whole segment.
+ */
+ cchDstPrepped -= cchSrcOrg + (paSegs[iSeg].cchSrcAndPrependSpace < 0);
+ }
+ cSegs--;
+ }
+ *pcchDstPrepped = cchDstPrepped;
+ *pcSegs = cSegs;
+}
+
+/**
+ * Helper for ensuring that we've got sufficient number of string copy segments.
+ */
+#define KMK_CC_EVAL_ENSURE_STRCOPY_SEGS(a_pCompiler, a_cRequiredSegs) \
+ do { \
+ if ((a_cRequiredSegs) < (a_pCompiler)->cStrCopySegsAllocated) \
+ { /* likely */ } \
+ else \
+ { \
+ unsigned cEnsureSegs = ((a_cRequiredSegs) + 3 /*15*/) & ~(unsigned)3/*15*/; \
+ KMK_CC_ASSERT((a_cRequiredSegs) < 0x8000); \
+ (a_pCompiler)->paStrCopySegs = (PKMKCCEVALSTRCPYSEG)xmalloc(cEnsureSegs * sizeof((a_pCompiler)->paStrCopySegs)[0]); \
+ } \
+ } while (0)
+
+
+/**
+ * Prepares for copying a normal line, extended version.
+ *
+ * This does not assume that we start on a word, it can handle any starting
+ * character. It can also prepare partial copies.
+ *
+ * In addition to the returned information, this will store instruction in
+ * paEscEols for the following kmk_cc_eval_strcpyv() call.
+ *
+ * This will advance pCompiler->iEscEol, so that it's possible to use the common
+ * macros and helpers for parsing what comes afterwards.
+ *
+ * @returns The number of chars that will be copied by kmk_cc_eval_strcpyv().
+ * @param pCompiler The compiler instance data.
+ * @param pchWord Pointer to the first char to copy from the
+ * current line. This must be the start of a
+ * word.
+ * @param cchLeft The number of chars left on the current line
+ * starting at @a pchWord.
+ */
+static size_t kmk_cc_eval_prep_normal_line_ex(PKMKCCEVALCOMPILER pCompiler, const char * const pchWord, size_t cchLeft)
+{
+ size_t cchRet;
+ unsigned iEscEol = pCompiler->iEscEol;
+ unsigned const cEscEols = pCompiler->cEscEols;
+
+ KMK_CC_ASSERT(iEscEol <= cEscEols);
+
+ if (cchLeft > 0)
+ {
+ /*
+ * If there are no escaped EOLs left, just copy exactly
+ * what was passed in.
+ */
+ if (iEscEol >= cEscEols)
+ {
+ KMK_CC_EVAL_ENSURE_STRCOPY_SEGS(pCompiler, 1);
+ pCompiler->cStrCopySegs = 1;
+ pCompiler->paStrCopySegs[0].pchSrc = pchWord;
+ pCompiler->paStrCopySegs[0].cchSrcAndPrependSpace = cchRet = cchLeft;
+ }
+ /*
+ * Ok, we have to deal with escaped EOLs and do the proper
+ * replacement of escaped newlines with space. The deal is that we
+ * collaps all whitespace before and after one or more newlines into a
+ * single space. (FreeBSD make does this differently, by the by.)
+ */
+ else
+ {
+ const char * const pszContent = pCompiler->pszContent;
+ size_t offWord = pchWord - pCompiler->pszContent;
+ size_t const offLineEnd = offWord + cchLeft; /* Note! Not necessarily end of line.*/
+ size_t offEsc;
+ size_t fPendingSpace = 0;
+ unsigned cSegs = 0;
+ size_t cchSeg;
+
+ /* Go nuts checking our preconditions here. */
+ KMK_CC_ASSERT(offWord >= pCompiler->offLine);
+ KMK_CC_ASSERT(offWord + cchLeft <= pCompiler->offLine + pCompiler->cchLine);
+ KMK_CC_ASSERT(offWord + cchLeft <= pCompiler->cchContent);
+ KMK_CC_ASSERT(offWord <= pCompiler->paEscEols[iEscEol].offEsc);
+ KMK_CC_ASSERT(offWord >= (iEscEol ? pCompiler->paEscEols[cEscEols - 1].offEol + pCompiler->cchEolSeq
+ : pCompiler->offLine));
+ KMK_CC_ASSERT(offWord < offLineEnd);
+
+ /* Make sure we've got more than enough segments to fill in. */
+ KMK_CC_EVAL_ENSURE_STRCOPY_SEGS(pCompiler, cEscEols - iEscEol + 2);
+
+ /*
+ * All but the last line.
+ */
+ cchRet = 0;
+ do
+ {
+ KMK_CC_ASSERT(offWord < offLineEnd);
+ offEsc = pCompiler->paEscEols[iEscEol].offEsc;
+ if (offWord < offEsc)
+ {
+ /* Strip trailing spaces. */
+ while (offEsc > offWord && KMK_CC_EVAL_IS_SPACE(pszContent[offEsc - 1]))
+ offEsc--;
+ cchSeg = offEsc - offWord;
+ if (cchSeg)
+ {
+ /* Add segment. */
+ pCompiler->paStrCopySegs[cSegs].pchSrc = &pszContent[offWord];
+ if (offEsc < offLineEnd)
+ {
+ pCompiler->paStrCopySegs[cSegs].cchSrcAndPrependSpace = fPendingSpace
+ ? -(ssize_t)cchSeg : (ssize_t)cchSeg;
+ cchRet += cchSeg + fPendingSpace;
+ cSegs += 1;
+ fPendingSpace = 1;
+ }
+ else
+ {
+ cchSeg = offLineEnd - offWord;
+ pCompiler->paStrCopySegs[cSegs].cchSrcAndPrependSpace = fPendingSpace
+ ? -(ssize_t)cchSeg : (ssize_t)cchSeg;
+ pCompiler->cStrCopySegs = cSegs + 1;
+ pCompiler->iEscEol = iEscEol;
+ return cchRet + cchSeg + fPendingSpace;
+ }
+ }
+ }
+ else
+ KMK_CC_ASSERT(offWord == offEsc);
+
+ /* Next line. */
+ offWord = pCompiler->paEscEols[iEscEol].offEol + pCompiler->cchEolSeq;
+ iEscEol++;
+
+ /* Strip leading spaces. */
+ while (offWord < offLineEnd && KMK_CC_EVAL_IS_SPACE(pszContent[offWord]))
+ offWord++;
+ if (offWord >= offLineEnd)
+ {
+ pCompiler->cStrCopySegs = cSegs;
+ pCompiler->iEscEol = iEscEol;
+ return cchRet;
+ }
+ } while (iEscEol < cEscEols);
+
+ /*
+ * The last line.
+ */
+ cchSeg = offLineEnd - offWord;
+ cchRet += cchSeg;
+ pCompiler->paStrCopySegs[cSegs].pchSrc = &pszContent[offWord];
+ pCompiler->paStrCopySegs[cSegs].cchSrcAndPrependSpace = fPendingSpace
+ ? -(ssize_t)cchSeg : (ssize_t)cchSeg;
+ pCompiler->cStrCopySegs = cSegs + 1;
+ pCompiler->iEscEol = iEscEol;
+ }
+ }
+ /*
+ * Odd case: Nothing to copy.
+ */
+ else
+ {
+ cchRet = 0;
+ pCompiler->cStrCopySegs = 0;
+ }
+ return cchRet;
+}
+
+
+/**
+ * Prepares for copying a normal line, from the given position all the way to
+ * the end.
+ *
+ * In addition to the returned information, this will store instruction in
+ * paStrCopySegs and cSTrCopySeg for the following kmk_cc_eval_strcpyv() call.
+ *
+ * @returns The number of chars that will be copied by kmk_cc_eval_strcpyv().
+ * @param pCompiler The compiler instance data.
+ * @param pchWord Pointer to the first char to copy from the
+ * current line. This must be the start of a
+ * word.
+ * @param cchLeft The number of chars left on the current line
+ * starting at @a pchWord.
+ */
+static size_t kmk_cc_eval_prep_normal_line(PKMKCCEVALCOMPILER pCompiler, const char * const pchWord, size_t cchLeft)
+{
+ size_t cchRet;
+ unsigned iEscEol = pCompiler->iEscEol;
+ unsigned const cEscEols = pCompiler->cEscEols;
+
+ KMK_CC_ASSERT(cchLeft > 0);
+ KMK_CC_ASSERT(!KMK_CC_EVAL_IS_SPACE(*pchWord)); /* The fact that we're standing at a word, is exploited below. */
+ KMK_CC_ASSERT(iEscEol <= cEscEols);
+
+ /*
+ * If there are no escaped EOLs left, just copy what was specified,
+ * optionally sans any trailing spaces.
+ */
+ if (iEscEol >= cEscEols)
+ {
+ cchRet = cchLeft;
+
+ KMK_CC_EVAL_ENSURE_STRCOPY_SEGS(pCompiler, 1);
+ pCompiler->cStrCopySegs = 1;
+ pCompiler->paStrCopySegs[0].pchSrc = pchWord;
+ pCompiler->paStrCopySegs[0].cchSrcAndPrependSpace = cchRet;
+ }
+ /*
+ * Ok, we have to deal with escaped EOLs and do the proper
+ * replacement of escaped newlines with space. The deal is that we
+ * collaps all whitespace before and after one or more newlines into a
+ * single space. (FreeBSD make does this differently, by the by.)
+ */
+ else
+ {
+ const char *pszContent = pCompiler->pszContent;
+ size_t offWord = pchWord - pCompiler->pszContent;
+ size_t offEsc;
+ size_t fPendingSpace;
+ size_t cchSeg;
+ unsigned cSegs = 0;
+
+ /* Go nuts checking our preconditions here. */
+ KMK_CC_ASSERT(offWord >= pCompiler->offLine);
+ KMK_CC_ASSERT(offWord + cchLeft <= pCompiler->offLine + pCompiler->cchLine);
+ KMK_CC_ASSERT(offWord + cchLeft <= pCompiler->cchContent);
+ KMK_CC_ASSERT(offWord < pCompiler->paEscEols[iEscEol].offEsc);
+ KMK_CC_ASSERT(offWord >= (iEscEol ? pCompiler->paEscEols[iEscEol - 1].offEol + pCompiler->cchEolSeq : pCompiler->offLine));
+
+ /* Make sure we've got more than enough segments to fill in. */
+ KMK_CC_EVAL_ENSURE_STRCOPY_SEGS(pCompiler, cEscEols - iEscEol + 2);
+
+ /*
+ * First line - We're at the start of a word, so no left stripping needed.
+ */
+ offEsc = pCompiler->paEscEols[iEscEol].offEsc;
+ KMK_CC_ASSERT(offEsc > offWord);
+ while (KMK_CC_EVAL_IS_SPACE(pszContent[offEsc - 1]))
+ offEsc--;
+ KMK_CC_ASSERT(offEsc > offWord);
+
+ fPendingSpace = 1;
+ cchRet = offEsc - offWord;
+ pCompiler->paStrCopySegs[cSegs].cchSrcAndPrependSpace = cchRet;
+ pCompiler->paStrCopySegs[cSegs].pchSrc = pchWord;
+ cSegs++;
+
+ offWord = pCompiler->paEscEols[iEscEol].offEol + pCompiler->cchEolSeq;
+ iEscEol++;
+
+ /*
+ * All but the last line.
+ */
+ while (iEscEol < cEscEols)
+ {
+ offEsc = pCompiler->paEscEols[iEscEol].offEsc;
+
+ /* Strip leading spaces. */
+ while (offWord < offEsc && KMK_CC_EVAL_IS_SPACE(pszContent[offWord]))
+ offWord++;
+
+ if (offWord < offEsc)
+ {
+ /* Strip trailing spaces. */
+ while (KMK_CC_EVAL_IS_SPACE(pszContent[offEsc - 1]))
+ offEsc--;
+ cchSeg = offEsc - offWord;
+ pCompiler->paStrCopySegs[cSegs].cchSrcAndPrependSpace = fPendingSpace ? -(ssize_t)cchSeg : (ssize_t)cchSeg;
+ cchRet += cchSeg + fPendingSpace;
+ pCompiler->paStrCopySegs[cSegs].pchSrc = &pszContent[offWord];
+ cSegs += 1;
+ fPendingSpace = 1;
+ }
+
+ /* Next. */
+ offWord = pCompiler->paEscEols[iEscEol].offEol + pCompiler->cchEolSeq;
+ iEscEol++;
+ }
+
+ /*
+ * Final line. We must calculate the end of line offset our selves here.
+ */
+ offEsc = &pchWord[cchLeft] - pszContent;
+ while (offWord < offEsc && KMK_CC_EVAL_IS_SPACE(pszContent[offWord]))
+ offWord++;
+
+ if (offWord < offEsc)
+ {
+ cchSeg = offEsc - offWord;
+ pCompiler->paStrCopySegs[cSegs].cchSrcAndPrependSpace = fPendingSpace ? -(ssize_t)cchSeg : (ssize_t)cchSeg;
+ cchRet += cchSeg + fPendingSpace;
+ pCompiler->paStrCopySegs[cSegs].pchSrc = &pszContent[offWord];
+ cSegs += 1;
+ }
+
+ pCompiler->cStrCopySegs = cSegs;
+ }
+ return cchRet;
+}
+
+
+/**
+ * Common worker for all kmk_cc_eval_do_if*() functions.
+ *
+ * @param pCompiler The compiler state.
+ * @param pIfCore The new IF statement.
+ * @param fInElse Set if this is an 'else if' (rather than just 'if').
+ */
+static void kmk_cc_eval_do_if_core(PKMKCCEVALCOMPILER pCompiler, PKMKCCEVALIFCORE pIfCore, int fInElse)
+{
+ unsigned iIf = pCompiler->cIfs;
+ if (!fInElse)
+ {
+ /* Push an IF statement. */
+ if (iIf < KMK_CC_EVAL_MAX_IF_DEPTH)
+ {
+ pCompiler->cIfs = iIf + 1;
+ pCompiler->apIfs[iIf] = pIfCore;
+ pIfCore->pPrevCond = NULL;
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, NULL, "Too deep IF nesting");
+ }
+ else if (iIf > 0)
+ {
+ /* Link an IF statement. */
+ iIf--;
+ pIfCore->pPrevCond = pCompiler->apIfs[iIf];
+ pCompiler->apIfs[iIf] = pIfCore;
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, NULL, "'else if' without 'if'");
+ pIfCore->pNextTrue = (PKMKCCEVALCORE)kmk_cc_block_get_next_ptr(*pCompiler->ppBlockTail);
+ pIfCore->pNextFalse = NULL; /* This is set by else or endif. */
+ pIfCore->pTrueEndJump = NULL; /* This is set by else or endif. */
+}
+
+
+/**
+ * Deals with 'if expr' and 'else if expr' statements.
+ *
+ * @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 'if'.
+ * @param cchLeft The number of chars left to parse on this line.
+ * @param fInElse Set if this is an 'else if' (rather than just 'if').
+ */
+static int kmk_cc_eval_do_if(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft, int fInElse)
+{
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+ if (cchLeft)
+ {
+ PKMKCCEVALIFEXPR pInstr;
+ size_t cchExpr = kmk_cc_eval_prep_normal_line(pCompiler, pchWord, cchLeft);
+ kmk_cc_eval_strip_right_v(pCompiler->paStrCopySegs, &pCompiler->cStrCopySegs, &cchExpr);
+
+ pInstr = (PKMKCCEVALIFEXPR)kmk_cc_block_alloc_eval(pCompiler->ppBlockTail, KMKCCEVALIFEXPR_SIZE(cchExpr));
+ kmk_cc_eval_strcpyv(pInstr->szExpr, pCompiler->paStrCopySegs, pCompiler->cStrCopySegs, cchExpr);
+ pInstr->cchExpr = cchExpr;
+ pInstr->IfCore.Core.enmOpcode = kKmkCcEvalInstr_if;
+ pInstr->IfCore.Core.iLine = pCompiler->iLine;
+ kmk_cc_eval_do_if_core(pCompiler, &pInstr->IfCore, fInElse);
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, pchWord, "Expected expression after 'if' directive");
+ return 1;
+}
+
+
+/**
+ * Deals with 'ifdef var', 'ifndef var', 'else ifdef var' and 'else ifndef var'
+ * statements.
+ *
+ * @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 'if[n]def'.
+ * @param cchLeft The number of chars left to parse on this line.
+ * @param fInElse Set if this is an 'else if' (rather than just 'if').
+ * @param fPositiveStmt Set if 'ifdef', clear if 'ifndef'.
+ */
+static int kmk_cc_eval_do_ifdef(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft, int fInElse, int fPositiveStmt)
+{
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+ if (cchLeft)
+ {
+ /*
+ * Skip to the end of the variable name.
+ * GNU make just does normal word parsing, so lets do that too.
+ */
+ unsigned const iSavedEscEol = pCompiler->iEscEol;
+ unsigned cWords = kmk_cc_eval_parse_words(pCompiler, pchWord, cchLeft);
+ if (cWords == 0)
+ {
+ PCKMKCCEVALWORD pWord = pCompiler->paWords;
+ if (pWord->enmToken == kKmkCcEvalToken_WordPlain)
+ {
+ PKMKCCEVALIFDEFPLAIN pInstr;
+ pInstr = (PKMKCCEVALIFDEFPLAIN)kmk_cc_block_alloc_eval(pCompiler->ppBlockTail, sizeof(*pInstr));
+ pInstr->IfCore.Core.enmOpcode = fPositiveStmt ? kKmkCcEvalInstr_ifdef_plain : kKmkCcEvalInstr_ifndef_plain;
+ pInstr->IfCore.Core.iLine = pCompiler->iLine;
+ pInstr->pszName = strcache2_add(&variable_strcache, pWord->pchWord, pWord->cchWord);
+ kmk_cc_eval_do_if_core(pCompiler, &pInstr->IfCore, fInElse);
+ }
+ else
+ {
+ PKMKCCEVALIFDEFDYNAMIC pInstr;
+ size_t cchCopy;
+ char const *pszCopy;
+
+ pInstr = (PKMKCCEVALIFDEFDYNAMIC)kmk_cc_block_alloc_eval(pCompiler->ppBlockTail, sizeof(*pInstr));
+
+ /** @todo Make the subprogram embed necessary strings. */
+ if (pWord->enmToken != kKmkCcEvalToken_WordWithDollar)
+ {
+ pszCopy = kmk_cc_block_strdup(pCompiler->ppBlockTail, pWord->pchWord, pWord->cchWord);
+ cchCopy = pWord->cchWord;
+ }
+ else
+ {
+ KMK_CC_ASSERT(pWord->enmToken == kKmkCcEvalToken_WordWithDollarAndEscEol);
+ pCompiler->iEscEol = iSavedEscEol;
+ cchCopy = kmk_cc_eval_prep_normal_line_ex(pCompiler, pWord->pchWord, cchLeft);
+ pszCopy = kmk_cc_eval_strdup_prepped(pCompiler, cchCopy);
+ }
+ kmk_cc_block_realign(pCompiler->ppBlockTail);
+
+ 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);
+
+ kmk_cc_eval_do_if_core(pCompiler, &pInstr->IfCore, fInElse);
+ }
+ }
+ else
+ {
+ KMK_CC_ASSERT(cWords > 1);
+ kmk_cc_eval_fatal(pCompiler, pCompiler->paWords[1].pchWord,
+ "Bogus stuff after 'if%sdef' variable name", fPositiveStmt ? "" : "n");
+ }
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, pchWord, "Expected expression after 'if' directive");
+ return 1;
+}
+
+
+/**
+ * Deals with 'ifeq (a,b)', 'ifeq "a" "b"', 'ifneq (a,b)', 'ifneq "a" "b"',
+ * 'else ifeq (a,b)', 'else ifeq "a" "b"', 'else ifneq (a,b)' and
+ * 'else ifneq "a" "b"' statements.
+ *
+ * @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 'if[n]eq'.
+ * @param cchLeft The number of chars left to parse on this line.
+ * @param fInElse Set if this is an 'else if' (rather than just 'if').
+ * @param fPositiveStmt Set if 'ifeq', clear if 'ifneq'.
+ */
+static int kmk_cc_eval_do_ifeq(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft, int fInElse, int fPositiveStmt)
+{
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+ if (cchLeft)
+ {
+ /*
+ * There are two forms:
+ *
+ * ifeq (string1, string2)
+ * ifeq "string1" 'string2'
+ *
+ */
+ const char * const pchEnd = &pchWord[cchLeft];
+ PKMKCCEVALIFEQ pInstr = (PKMKCCEVALIFEQ)kmk_cc_block_alloc_eval(pCompiler->ppBlockTail, sizeof(*pInstr));
+
+ struct
+ {
+ char *pszCopy;
+ size_t cchCopy;
+ int fPlain;
+ } Left, Right;
+
+ char ch = *pchWord;
+ if (ch == '(')
+ {
+ int cCounts;
+ size_t off;
+
+ /*
+ * The left side ends with a comma. We respect parentheses, but
+ * not curly brackets.
+ */
+
+ /* Skip the parenthesis. */
+ pchWord++;
+ cchLeft--;
+
+ /* Find the comma, checking for non-plainness. */
+ cCounts = 0;
+ Left.fPlain = 1;
+ for (off = 0; off < cchLeft; off++)
+ {
+ ch = pchWord[off];
+ if (!KMK_CC_EVAL_IS_PAREN_COMMA_OR_DOLLAR(ch))
+ { /* likely */ }
+ else if (ch == '$')
+ Left.fPlain = 0;
+ else if (ch == '(')
+ cCounts++;
+ else if (ch == ')')
+ cCounts--; /** @todo warn if it goes negative. */
+ else if (ch == ',' && cCounts == 0)
+ break;
+ else
+ KMK_CC_ASSERT(cCounts > 0);
+ }
+ if (ch == ',' && cCounts == 0) { /* likely */ }
+ else kmk_cc_eval_fatal(pCompiler, &pchWord[off], "Expected ',' before end of line");
+
+ /* Copy out the string. */
+ Left.cchCopy = kmk_cc_eval_prep_normal_line_ex(pCompiler, pchWord, off);
+ kmk_cc_eval_strip_right_v(pCompiler->paStrCopySegs, &pCompiler->cStrCopySegs, &Left.cchCopy);
+ Left.pszCopy = kmk_cc_eval_strdup_prepped(pCompiler, Left.cchCopy);
+
+ /* Skip past the comma and any following spaces. */
+ pchWord += off + 1;
+ cchLeft -= off + 1;
+ if ( cchLeft /** @todo replace with straight 'isspace' that takes escaped EOLs into account. */
+ && KMK_CC_EVAL_IS_SPACE_AFTER_WORD(pCompiler, pchWord[0], pchWord[1], cchLeft))
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+
+ /*
+ * Ditto for the right side, only it ends with a closing parenthesis.
+ */
+ cCounts = 1;
+ Right.fPlain = 1;
+ for (off = 0; off < cchLeft; off++)
+ {
+ ch = pchWord[off];
+ if (!KMK_CC_EVAL_IS_PAREN_COMMA_OR_DOLLAR(ch))
+ { /* likely */ }
+ else if (ch == '$')
+ Right.fPlain = 0;
+ else if (ch == '(')
+ cCounts++;
+ else if (ch == ')')
+ {
+ if (--cCounts == 0)
+ break;
+ }
+ else
+ KMK_CC_ASSERT(cCounts > 0 || ch == ',');
+ }
+ if (ch == ')' && cCounts == 0) { /* likely */ }
+ else kmk_cc_eval_fatal(pCompiler, &pchWord[off], "Expected ')' before end of line");
+
+ /* Copy out the string. */
+ Right.cchCopy = kmk_cc_eval_prep_normal_line_ex(pCompiler, pchWord, off);
+ kmk_cc_eval_strip_right_v(pCompiler->paStrCopySegs, &pCompiler->cStrCopySegs, &Right.cchCopy);
+ Right.pszCopy = kmk_cc_eval_strdup_prepped(pCompiler, Right.cchCopy);
+
+ /* Skip past the parenthesis. */
+ pchWord += off + 1;
+ cchLeft -= off + 1;
+ }
+ else if (ch == '"' || ch == '\'')
+ {
+ const char *pchTmp;
+
+ /*
+ * Quoted left side.
+ */
+ /* Skip leading quote. */
+ pchWord++;
+ cchLeft--;
+
+ /* Locate the end quote. */
+ pchTmp = (const char *)memchr(pchWord, ch, cchLeft);
+ if (pchTmp) { /* likely */ }
+ else kmk_cc_eval_fatal(pCompiler, pchWord - 1, "Unbalanced quote in first if%seq string", fPositiveStmt ? "" : "n");
+
+ Left.cchCopy = kmk_cc_eval_prep_normal_line_ex(pCompiler, pchWord, pchTmp - pchWord);
+ Left.pszCopy = kmk_cc_eval_strdup_prepped(pCompiler, Left.cchCopy);
+ Left.fPlain = memchr(Left.pszCopy, '$', Left.cchCopy) == NULL;
+
+ /* skip end quote */
+ pchWord = pchTmp + 1;
+ cchLeft = pchEnd - pchWord;
+
+ /* Skip anything inbetween the left and right hand side (not mandatory). */
+ if ( cchLeft /** @todo replace with straight 'isspace' that takes escaped EOLs into account. */
+ && KMK_CC_EVAL_IS_SPACE_AFTER_WORD(pCompiler, pchWord[0], pchWord[1], cchLeft))
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+
+ /*
+ * Quoted right side.
+ */
+ if ( cchLeft > 0
+ && ( (ch = *pchWord) != '"' || ch == '\'') )
+ {
+ /* Skip leading quote. */
+ pchWord++;
+ cchLeft--;
+
+ /* Locate the end quote. */
+ pchTmp = (const char *)memchr(pchWord, ch, cchLeft);
+ if (pchTmp) { /* likely */ }
+ else kmk_cc_eval_fatal(pCompiler, pchWord - 1, "Unbalanced quote in second if%seq string", fPositiveStmt ? "" : "n");
+
+ Right.cchCopy = kmk_cc_eval_prep_normal_line_ex(pCompiler, pchWord, pchTmp - pchWord);
+ Right.pszCopy = kmk_cc_eval_strdup_prepped(pCompiler, Right.cchCopy);
+ Right.fPlain = memchr(Right.pszCopy, '$', Right.cchCopy) == NULL;
+
+ /* skip end quote */
+ pchWord = pchTmp + 1;
+ cchLeft = pchEnd - pchWord;
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, pchWord, "Expected a second quoted string for 'if%seq'",
+ fPositiveStmt ? "" : "n");
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, pchWord, "Expected parentheses or quoted string after 'if%seq'",
+ fPositiveStmt ? "" : "n");
+ kmk_cc_block_realign(pCompiler->ppBlockTail);
+
+ /*
+ * Initialize the instruction.
+ */
+ pInstr->IfCore.Core.enmOpcode = fPositiveStmt ? kKmkCcEvalInstr_ifeq : kKmkCcEvalInstr_ifneq;
+ pInstr->IfCore.Core.iLine = pCompiler->iLine;
+ kmk_cc_eval_init_subprogram_or_plain(pCompiler, &pInstr->Left, Left.pszCopy, Left.cchCopy, Left.fPlain);
+ kmk_cc_eval_init_subprogram_or_plain(pCompiler, &pInstr->Right, Right.pszCopy, Right.cchCopy, Right.fPlain);
+ kmk_cc_eval_do_if_core(pCompiler, &pInstr->IfCore, fInElse);
+
+ /*
+ * Make sure there is nothing following the variable name.
+ */
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+ if (cchLeft)
+ kmk_cc_eval_fatal(pCompiler, pchWord, "Bogus stuff after 'if%sdef' variable name", fPositiveStmt ? "" : "n");
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, pchWord, "Expected expression after 'if' directive");
+ return 1;
+}
+
+
+/**
+ * Deals with 'if1of (set-a,set-b)', 'ifn1of (set-a,set-b)',
+ * 'else if1of (set-a,set-b)' and 'else ifn1of (set-a,set-b)' statements.
+ *
+ * @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 'if[n]1of'.
+ * @param cchLeft The number of chars left to parse on this line.
+ * @param fInElse Set if this is an 'else if' (rather than just 'if').
+ * @param fPositiveStmt Set if 'if1of', clear if 'ifn1of'.
+ */
+static int kmk_cc_eval_do_if1of(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft, int fInElse, int fPositiveStmt)
+{
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+ if (cchLeft)
+ {
+ /*
+ * This code is (currently) very similar to kmk_cc_eval_do_ifeq.
+ * However, we may want to add hashing optimizations of plain text,
+ * and we don't want to support the quoted form as it is not necessary
+ * and may interfere with support for quoted words later on.
+ */
+ PKMKCCEVALIF1OF pInstr = (PKMKCCEVALIF1OF)kmk_cc_block_alloc_eval(pCompiler->ppBlockTail, sizeof(*pInstr));
+
+ struct
+ {
+ char *pszCopy;
+ size_t cchCopy;
+ int fPlain;
+ } Left, Right;
+
+ char ch = *pchWord;
+ if (ch == '(')
+ {
+ int cCounts;
+ size_t off;
+
+ /*
+ * The left side ends with a comma. We respect parentheses, but
+ * not curly brackets.
+ */
+
+ /* Skip the parenthesis. */
+ pchWord++;
+ cchLeft--;
+
+ /* Find the comma, checking for non-plainness. */
+ cCounts = 0;
+ Left.fPlain = 1;
+ for (off = 0; off < cchLeft; off++)
+ {
+ ch = pchWord[off];
+ if (!KMK_CC_EVAL_IS_PAREN_COMMA_OR_DOLLAR(ch))
+ { /* likely */ }
+ else if (ch == '$')
+ Left.fPlain = 0;
+ else if (ch == '(')
+ cCounts++;
+ else if (ch == ')')
+ cCounts--; /** @todo warn if it goes negative. */
+ else if (ch == ',' && cCounts == 0)
+ break;
+ else
+ KMK_CC_ASSERT(cCounts > 0);
+ }
+ if (ch == ',' && cCounts == 0) { /* likely */ }
+ else kmk_cc_eval_fatal(pCompiler, &pchWord[off], "Expected ',' before end of line");
+
+ /* Copy out the string. */
+ Left.cchCopy = kmk_cc_eval_prep_normal_line_ex(pCompiler, pchWord, off);
+ kmk_cc_eval_strip_right_v(pCompiler->paStrCopySegs, &pCompiler->cStrCopySegs, &Left.cchCopy);
+ Left.pszCopy = kmk_cc_eval_strdup_prepped(pCompiler, Left.cchCopy);
+
+ /* Skip past the comma and any following spaces. */
+ pchWord += off + 1;
+ cchLeft -= off + 1;
+ if ( cchLeft /** @todo replace with straight 'isspace' that takes escaped EOLs into account. */
+ && KMK_CC_EVAL_IS_SPACE_AFTER_WORD(pCompiler, pchWord[0], pchWord[1], cchLeft))
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+
+ /*
+ * Ditto for the right side, only it ends with a closing parenthesis.
+ */
+ cCounts = 1;
+ Right.fPlain = 1;
+ for (off = 0; off < cchLeft; off++)
+ {
+ ch = pchWord[off];
+ if (!KMK_CC_EVAL_IS_PAREN_COMMA_OR_DOLLAR(ch))
+ { /* likely */ }
+ else if (ch == '$')
+ Right.fPlain = 0;
+ else if (ch == '(')
+ cCounts++;
+ else if (ch == ')')
+ {
+ if (--cCounts == 0)
+ break;
+ }
+ else
+ KMK_CC_ASSERT(cCounts > 0 || ch == ',');
+ }
+ if (ch == ')' && cCounts == 0) { /* likely */ }
+ else kmk_cc_eval_fatal(pCompiler, &pchWord[off], "Expected ')' before end of line");
+
+ /* Copy out the string. */
+ Right.cchCopy = kmk_cc_eval_prep_normal_line_ex(pCompiler, pchWord, off);
+ kmk_cc_eval_strip_right_v(pCompiler->paStrCopySegs, &pCompiler->cStrCopySegs, &Right.cchCopy);
+ Right.pszCopy = kmk_cc_eval_strdup_prepped(pCompiler, Right.cchCopy);
+
+ /* Skip past the parenthesis. */
+ pchWord += off + 1;
+ cchLeft -= off + 1;
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, pchWord, "Expected parentheses after 'if%s1of'", fPositiveStmt ? "" : "n");
+ kmk_cc_block_realign(pCompiler->ppBlockTail);
+
+ /*
+ * Initialize the instruction.
+ */
+ pInstr->IfCore.Core.enmOpcode = fPositiveStmt ? kKmkCcEvalInstr_if1of : kKmkCcEvalInstr_ifn1of;
+ pInstr->IfCore.Core.iLine = pCompiler->iLine;
+ kmk_cc_eval_init_subprogram_or_plain(pCompiler, &pInstr->Left, Left.pszCopy, Left.cchCopy, Left.fPlain);
+ kmk_cc_eval_init_subprogram_or_plain(pCompiler, &pInstr->Right, Right.pszCopy, Right.cchCopy, Right.fPlain);
+ kmk_cc_eval_do_if_core(pCompiler, &pInstr->IfCore, fInElse);
+
+ /*
+ * Make sure there is nothing following the variable name.
+ */
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+ if (cchLeft)
+ kmk_cc_eval_fatal(pCompiler, pchWord, "Bogus stuff after 'if%s1of' variable name", fPositiveStmt ? "" : "n");
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, pchWord, "Expected expression after 'if' directive");
+ return 1;
+}
+
+
+/**
+ * Deals with 'else' and 'else ifxxx' statements.
+ *
+ * @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_do_else(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft)
+{
+ /*
+ * There must be an 'if' on the stack.
+ */
+ unsigned iIf = pCompiler->cIfs;
+ if (iIf > 0)
+ {
+ PKMKCCEVALIFCORE pIfCore = pCompiler->apIfs[--iIf];
+ if (!pIfCore->pTrueEndJump)
+ {
+ /* Emit a jump instruction that will take us from the 'True' block to the 'endif'. */
+ PKMKCCEVALJUMP pInstr = (PKMKCCEVALJUMP)kmk_cc_block_alloc_eval(pCompiler->ppBlockTail, sizeof(*pInstr));
+ pInstr->Core.enmOpcode = kKmkCcEvalInstr_jump;
+ pInstr->Core.iLine = pCompiler->iLine;
+ pInstr->pNext = NULL;
+ pIfCore->pTrueEndJump = pInstr;
+
+ /* The next instruction is the first in the 'False' block of the current 'if'.
+ Should this be an 'else if', this will be the 'if' instruction emitted below. */
+ pIfCore->pNextFalse = (PKMKCCEVALCORE)kmk_cc_block_get_next_ptr(*pCompiler->ppBlockTail);
+ }
+ else if (iIf == 0)
+ kmk_cc_eval_fatal(pCompiler, pchWord, "2nd 'else' for 'if' at line %u", pIfCore->Core.iLine);
+ else
+ kmk_cc_eval_fatal(pCompiler, pchWord, "2nd 'else' in a row - missing 'endif' for 'if' at line %u?",
+ pIfCore->Core.iLine);
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, pchWord, "'else' without 'if'");
+
+ /*
+ * Check for 'else ifxxx'. There can be nothing else following an else.
+ */
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+ if (cchLeft)
+ {
+ if ( cchLeft > 2
+ && KMK_CC_WORD_COMP_CONST_2(pchWord, "if"))
+ {
+ pchWord += 2;
+ cchLeft -= 2;
+
+ 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_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_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_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_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_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_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 */);
+
+ pchWord -= 2;
+ cchLeft += 2;
+ }
+ kmk_cc_eval_fatal(pCompiler, pchWord, "Bogus stuff after 'else'");
+ }
+
+ return 1;
+}
+
+
+/**
+ * Deals with the 'endif' statement.
+ *
+ * @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_do_endif(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft)
+{
+ /*
+ * There must be an 'if' on the stack. We'll POP it.
+ */
+ unsigned iIf = pCompiler->cIfs;
+ if (iIf > 0)
+ {
+ PKMKCCEVALCORE pNextInstr;
+ PKMKCCEVALIFCORE pIfCore = pCompiler->apIfs[--iIf];
+ pCompiler->cIfs = iIf; /* POP! */
+
+ /* Update the jump targets for all IFs at this level. */
+ pNextInstr = (PKMKCCEVALCORE)kmk_cc_block_get_next_ptr(*pCompiler->ppBlockTail);
+ do
+ {
+ if (pIfCore->pTrueEndJump)
+ {
+ /* Make the true block jump here, to the 'endif'. The false block is already here. */
+ pIfCore->pTrueEndJump->pNext = pNextInstr;
+ KMK_CC_ASSERT(pIfCore->pNextFalse);
+ }
+ else
+ {
+ /* No 'else'. The false-case jump here, to the 'endif'. */
+ KMK_CC_ASSERT(!pIfCore->pNextFalse);
+ pIfCore->pNextFalse = pNextInstr;
+ }
+
+ pIfCore = pIfCore->pPrevCond;
+ } while (pIfCore);
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, pchWord, "'endif' without 'if'");
+
+ /*
+ * There shouldn't be anything trailing an 'endif'.
+ */
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+ if (!cchLeft) { /* likely */ }
+ else kmk_cc_eval_fatal(pCompiler, pchWord, "Bogus stuff after 'else'");
+
+ return 1;
+}
+
+
+/**
+ * Parses a 'include file...', 'sinclude file...', '-include file...',
+ * 'includedep file...', 'includedep-queue file...' and
+ * 'includedep-flush file...'
+ *
+ * @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 the include directive.
+ * @param cchLeft The number of chars left to parse on this line.
+ * @param enmOpcode The opcode for the include directive we're parsing.
+ */
+static int kmk_cc_eval_do_include(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft, KMKCCEVALINSTR enmOpcode)
+{
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+ if (cchLeft)
+ {
+ /*
+ * Split what's left up into words.
+ */
+/** @todo GNU make supports escape sequences for spaces here (they confusingly refers to this as quoting). So, it's possible
+ * to include C:/Program\ Files/kBuild/footer.kmk if we wanted to. It my intention to add support for double and/or single
+ * quoted files names to offer an alternative way of addressing this. */
+ unsigned cWords = kmk_cc_eval_parse_words(pCompiler, pchWord, cchLeft);
+ KMK_CC_EVAL_DPRINTF(("%s: cWords=%d\n", g_apszEvalInstrNms[enmOpcode], cWords));
+ if (cWords)
+ {
+ PKMKCCEVALINCLUDE pInstr = (PKMKCCEVALINCLUDE)kmk_cc_block_alloc_eval(pCompiler->ppBlockTail,
+ KMKCCEVALINCLUDE_SIZE(cWords));
+ pInstr->Core.enmOpcode = enmOpcode;
+ pInstr->Core.iLine = pCompiler->iLine;
+ pInstr->cFiles = cWords;
+ kmk_cc_eval_init_spp_array_from_duplicated_words(pCompiler, cWords, pCompiler->paWords, pInstr->aFiles);
+ kmk_cc_block_realign(pCompiler->ppBlockTail);
+ }
+ else
+ KMK_CC_ASSERT(0);
+ }
+ else
+ KMK_CC_EVAL_DPRINTF(("%s: include without args\n", g_apszEvalInstrNms[enmOpcode]));
+ return 1;
+}
+
+
+static int kmk_cc_eval_do_vpath(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft)
+{
+ kmk_cc_eval_fatal(pCompiler, NULL, "vpath directive is not implemented\n");
+ return 1;
+}
+
+
+/**
+ * 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)
+{
+ kmk_cc_eval_fatal(pCompiler, pchWord, "command handling not implemented yet");
+}
+
+
+/**
+ * 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,
+ KMKCCEVALTOKEN enmToken0, const char *pchColon, size_t cchLeft)
+{
+ kmk_cc_eval_fatal(pCompiler, pchWord0, "recipe handling not implemented yet (#1)");
+ return 1;
+}
+
+
+/**
+ * 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)
+{
+// const char *pchColon = memchr()
+
+ kmk_cc_eval_fatal(pCompiler, pchWord, "recipe handling not implemented yet (#2)");
+ return 1;
+}
+
+
+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.");
+
+}
+
+
+
+/**
+ * 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);
+#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)
+ {
+ 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
+ * have to extract the variable names now.
+ *
+ * @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_undefine(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft, unsigned fQualifiers)
+{
+ 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
+ * 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_unexport(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft, unsigned fQualifiers)
+{
+ PKMKCCEVALCORE pInstr;
+
+ /*
+ * 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.
+ */
+ pInstr = kmk_cc_block_alloc_eval(pCompiler->ppBlockTail, sizeof(*pInstr));
+ pInstr->enmOpcode = kKmkCcEvalInstr_unexport_all;
+ pInstr->iLine = pCompiler->iLine;
+ return 1;
+}
+
+
+/**
+ * Parse the value of a 'define' at pCompiler->offNext.
+ *
+ * This will update 'offNext' to the start of the line following the 'endef'
+ * matching the 'define' of the value.
+ *
+ * The value is prepared for kmk_cc_eval_strcpyv.
+ *
+ * @returns The value length that we've prepared for copying.
+ * @param pCompiler The compiler state.
+ * @param pfPlainValue Where to return whether this is a plain value or
+ * one needing expansion.
+ */
+static size_t kmk_cc_eval_parse_define_value(PKMKCCEVALCOMPILER pCompiler, int *pfPlainValue)
+{
+ /*
+ * Now we need to find the matching 'endef', we support nested ones.
+ *
+ * We look for the lines starting with 'endef' and 'define', like GNU
+ * make does even if we really should also be checking for variable
+ * qualifiers too.
+ *
+ * As we go on looking, we prepare the value in paStrCopySegs.
+ *
+ * Note! We duplicate code/logic from the top level compile loop here.
+ */
+ const char * const pszContent = pCompiler->pszContent;
+ size_t cchContent = pCompiler->cchContent;
+ int const chFirstEol = pCompiler->chFirstEol;
+ size_t const cchEolSeq = pCompiler->cchEolSeq;
+
+ unsigned cNestings = 1;
+ size_t offNext = pCompiler->offNext;
+ unsigned iLine = pCompiler->iLine;
+
+ unsigned cSegs = 0;
+ size_t cchValue = 0;
+ int fPlainValue = 1;
+
+ for (;;)
+ {
+ /*
+ * Find end of line, preparing to copy it.
+ */
+ if (offNext < cchContent)
+ {
+ unsigned const cSegsAtStartOfLine = cSegs;
+ size_t const cchValueStartOfLine = cchValue;
+ size_t offFirstWord = offNext;
+ const char *pchLine = &pszContent[offNext];
+ size_t cchLine;
+ const char *pchTmp;
+
+ pCompiler->cEscEols = 0;
+ pCompiler->iEscEol = 0;
+
+ /* Add newline if necessary and make sure we've got a segment handy. */
+ KMK_CC_EVAL_ENSURE_STRCOPY_SEGS(pCompiler, cSegs + 2);
+ if (cSegs)
+ {
+ cchValue++;
+ pCompiler->paStrCopySegs[cSegs].cchSrcAndPrependSpace = 1;
+ pCompiler->paStrCopySegs[cSegs].pchSrc = "\n";
+ cSegs++;
+ }
+
+ /* Simple case: No escaped EOL, nor the end of the input. */
+ pchTmp = (const char *)memchr(&pszContent[offNext], chFirstEol, cchContent - offNext);
+ if ( pchTmp
+ && ( &pszContent[offNext] == pchTmp
+ || pchTmp[-1] != '\\'))
+ {
+ if ( cchEolSeq == 1
+ || pchTmp[1] == pCompiler->chSecondEol)
+ {
+ offNext = pchTmp - pszContent;
+ cchLine = pchTmp - pchLine;
+
+ cchValue += cchLine;
+ pCompiler->paStrCopySegs[cSegs].cchSrcAndPrependSpace = cchLine;
+ pCompiler->paStrCopySegs[cSegs].pchSrc = pchLine;
+ cSegs++;
+
+ while (offFirstWord < offNext && KMK_CC_EVAL_IS_SPACE(pszContent[offFirstWord]))
+ offFirstWord++;
+
+ offNext += cchEolSeq;
+ }
+ else
+ kmk_cc_eval_fatal_eol(pCompiler, pchTmp, iLine, offNext);
+ }
+ /* The complicated, less common cases. */
+ else
+ {
+ size_t fPendingSpace = 0;
+ for (;;)
+ {
+ /* Find the first non-space char on this line. We always need it. */
+ size_t offThisFirstWord = offNext;
+ size_t offEol = pchTmp ? pchTmp - pszContent : cchContent;
+ if (offFirstWord == offNext)
+ {
+ while (offFirstWord < offEol && KMK_CC_EVAL_IS_SPACE(pszContent[offFirstWord]))
+ offFirstWord++;
+ if (pCompiler->cEscEols > 0)
+ offThisFirstWord = offFirstWord;
+ }
+ else
+ while (offThisFirstWord < offEol && KMK_CC_EVAL_IS_SPACE(pszContent[offThisFirstWord]))
+ offThisFirstWord++;
+
+ /* We normally need one, so just make sure once. */
+ KMK_CC_EVAL_ENSURE_STRCOPY_SEGS(pCompiler, cSegs + 1);
+
+ if (pchTmp)
+ {
+ if ( cchEolSeq == 1
+ || pchTmp[1] == pCompiler->chSecondEol)
+ {
+ size_t const offThis = offNext;
+ size_t offEsc;
+ int fDone;
+ offNext = pchTmp - pszContent;
+
+ /* Is it an escape sequence? */
+ if ( !offNext
+ || pchTmp[-1] != '\\')
+ fDone = 1;
+ else if (offNext < 2 || pchTmp[-2] != '\\')
+ {
+ offEsc = offNext - 1;
+ fDone = 0;
+ }
+ else
+ {
+ /* Count how many backslashes there are. Must be odd number to be an escape
+ sequence. Normally we keep half of them, except for command lines. */
+ size_t cSlashes = 2;
+ while (offNext >= cSlashes && pchTmp[0 - cSlashes] == '\\')
+ cSlashes--;
+ fDone = !(cSlashes & 1);
+ offEsc = offNext - (cSlashes >> 1);
+ }
+
+ /* Anything to copy? */
+/** @todo fixme tomorrow! */
+ cchLine = offThisFirstWord - offNext;
+ if (cchLine)
+ {
+ pCompiler->paStrCopySegs[cSegs].cchSrcAndPrependSpace = fPendingSpace
+ ? -(ssize_t)cchLine : (ssize_t)cchLine;
+ pCompiler->paStrCopySegs[cSegs].pchSrc = &pszContent[offThisFirstWord];
+ cSegs++;
+ }
+
+ if (fDone)
+ {
+ cchLine = &pszContent[offNext] - pchLine;
+ offNext += cchEolSeq;
+ break;
+ }
+
+ /* Record it. */
+ if (pCompiler->cEscEols < pCompiler->cEscEolsAllocated) { /* likely */ }
+ else
+ {
+ KMK_CC_ASSERT(pCompiler->cEscEols == pCompiler->cEscEolsAllocated);
+ pCompiler->cEscEolsAllocated = pCompiler->cEscEolsAllocated
+ ? pCompiler->cEscEolsAllocated * 2 : 2;
+ pCompiler->paEscEols = (PKMKCCEVALESCEOL)xrealloc(pCompiler->paEscEols,
+ pCompiler->cEscEolsAllocated
+ * sizeof(pCompiler->paEscEols[0]));
+ }
+ pCompiler->paEscEols[pCompiler->cEscEols].offEsc = offEsc;
+ pCompiler->paEscEols[pCompiler->cEscEols].offEol = offNext;
+ pCompiler->cEscEols++;
+
+ /* Anything to copy? */
+ cchLine = offThisFirstWord - offNext;
+ if (cchLine)
+ {
+ }
+
+ /* Advance. */
+ offNext += cchEolSeq;
+ if (offFirstWord == offEsc)
+ {
+ offFirstWord = offNext;
+ pCompiler->iEscEol++;
+ }
+ }
+ else
+ kmk_cc_eval_fatal_eol(pCompiler, pchTmp, pCompiler->iLine, off);
+ }
+ else
+ {
+ /* End of input. Happens only once per compilation, nothing to optimize for. */
+
+ if (offFirstWord == offNext)
+ while (offFirstWord < cchContent && KMK_CC_EVAL_IS_SPACE(pszContent[offFirstWord]))
+ offFirstWord++;
+
+ KMK_CC_EVAL_ENSURE_STRCOPY_SEGS(pCompiler, cSegs + 2);
+ if (cSegs == cSegsAtStartOfLine)
+ {
+ /* No escaped EOLs. */
+ cchLine = &pszContent[cchContent] - pchLine;
+ cchValue += cchLine;
+ pCompiler->paStrCopySegs[cSegs].cchSrcAndPrependSpace = cchLine;
+ pCompiler->paStrCopySegs[cSegs].pchSrc = pchLine;
+ cSegs++;
+ }
+ else
+ {
+ if (offFirstWordThisLine < cchContent)
+ {
+ cchLine = cchContent - offFirstWordThisLine;
+ cchValue += cchLine;
+ pCompiler->paStrCopySegs[cSegs].cchSrcAndPrependSpace = fPendingSpace
+ ? -(ssize_t)cchLine : (ssize_t)cchLine;
+ pCompiler->paStrCopySegs[cSegs].pchSrc = &pszContent[offFirstWordThisLine];
+ cSegs++;
+ }
+ cchLine = &pszContent[cchContent] - pchLine;
+ }
+ offNext = cchContent;
+ break;
+ }
+ pchTmp = (const char *)memchr(&pszContent[offNext], chFirstEol, cchContent - offNext);
+ }
+ }
+ KMK_CC_ASSERT(offNext <= cchContent);
+ KMK_CC_ASSERT(offNext >= off + cchLine);
+ KMK_CC_ASSERT(off + cchLine <= cchContent && cchLine <= cchContent);
+ KMK_CC_ASSERT(offFirstWord <= off + cchLine);
+ KMK_CC_ASSERT(offFirstWord >= off);
+ KMK_CC_ASSERT(pszContent[offFirstWord] != ' ' && pszContent[offFirstWord] != '\t');
+
+ KMK_CC_EVAL_DPRINTF(("#%03u: %*.*s\n", pCompiler->iLine, (int)cchLine, (int)cchLine, &pszContent[off]));
+
+ /*
+ * Look for 'endef' and 'define' directives.
+ */
+ cchLine -= offFirstWord - off;
+ if ( cchLine >= 5 /* shortest word is 5 chars ('endef', 'local') */
+ && pchLine[0] != pCompiler->chCmdPrefix)
+ {
+ pchTmp = &pszContent[offFirstWord];
+ if (!KMK_CC_EVAL_IS_1ST_IN_VARIABLE_KEYWORD(*pchTmp))
+ { /* Kind of likely (and saves one indent). */ }
+ else if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchTmp, cchLine, "endef", 5))
+ {
+ cNestings--;
+ if (cNestings == 0)
+ {
+ cchValue = cchValueStartOfLine;
+ cSegs = cSegsAtStartOfLine;
+ break;
+ }
+ }
+ else
+ for (;;)
+ {
+ if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchTmp, cchLine, "define", 6))
+ {
+ cNestings++;
+ break;
+ }
+
+ /* GNU make doesn't do this, but I think it makes sense. */
+ if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchTmp, cchLine, "local", 5))
+ {
+ pchTmp += 5;
+ cchLine -= 5;
+ }
+ else if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchTmp, cchLine, "export", 6))
+ {
+ pchTmp += 6;
+ cchLine -= 6;
+ }
+ else if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchTmp, cchLine, "private", 7))
+ {
+ pchTmp += 7;
+ cchLine -= 7;
+ }
+ else if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchTmp, cchLine, "override", 8))
+ {
+ pchTmp += 8;
+ cchLine -= 8;
+ }
+ else
+ break;
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchTmp, cchLine);
+ }
+ }
+
+ /*
+ * Advance to the next line.
+ */
+ iLine += pCompiler->cEscEols + 1;
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, NULL, )
+ }
+
+ /*
+ * Update globals and return values.
+ */
+ pCompiler->offNext = offNext;
+ pCompiler->iLine = iLine;
+ pCompiler->cStrCopySegs = cSegs;
+
+ *pfPlainValue = fPlainValue;
+ return cchValue;
+}
+
+/**
+ * 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)
+{
+ /*
+ * Now comes the variable name. It may optionally be followed by an
+ * assignment operator to indicate what kind of variable is being defined.
+ */
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+ unsigned cWords = cchLeft ? kmk_cc_eval_parse_words(pCompiler, pchWord, cchLeft) : 0;
+ if (cWords >= 1)
+ {
+ /*
+ * Check for variable assignment operator. Kind of tedious...
+ */
+ KMKCCEVALINSTR enmOpcode;
+ PKMKCCEVALWORD pVarWord = pCompiler->paWords;
+ if ( cWords == 1
+ && ( pVarWord->cchWord == 0
+ || pVarWord->pchWord[pVarWord->cchWord - 1] != '='))
+ enmOpcode = kKmkCcEvalInstr_define_recursive; /* very likely */
+ else if ( pVarWord->cchWord > 0
+ && pVarWord->pchWord[pVarWord->cchWord - 1] == '=')
+ {
+ if (pVarWord->cchWord == 1)
+ enmOpcode = kKmkCcEvalInstr_define_recursive;
+ else
+ {
+ char chPenultimate = pVarWord->pchWord[pVarWord->cchWord - 2];
+ if (chPenultimate == '?')
+ enmOpcode = kKmkCcEvalInstr_define_if_new;
+ else if (chPenultimate == ':')
+ enmOpcode = kKmkCcEvalInstr_assign_simple;
+ else if (chPenultimate == '+')
+ enmOpcode = kKmkCcEvalInstr_assign_append;
+ else if (chPenultimate == '<')
+ enmOpcode = kKmkCcEvalInstr_assign_prepend;
+ else
+ enmOpcode = kKmkCcEvalInstr_define_recursive;
+ }
+ pVarWord->cchWord -= enmOpcode == kKmkCcEvalInstr_define_recursive ? 1 : 2;
+ if (cWords > 1)
+ kmk_cc_eval_fatal(pCompiler, pCompiler->paWords[1].pchWord,
+ "Bogus stuff after 'define' variable name and assignment operator");
+ }
+ else
+ {
+ PCKMKCCEVALWORD pOpWord = &pCompiler->paWords[1];
+ KMK_CC_ASSERT(cWords > 1);
+ if ( pOpWord->cchWord == 1
+ && pOpWord->pchWord[0] == '=')
+ enmOpcode = kKmkCcEvalInstr_define_recursive;
+ else if ( pOpWord->cchWord == 2
+ && pOpWord->pchWord[1] == '=')
+ {
+ char chFirst = pVarWord->pchWord[0];
+ if (chFirst == '?')
+ enmOpcode = kKmkCcEvalInstr_define_if_new;
+ else if (chFirst == ':')
+ enmOpcode = kKmkCcEvalInstr_assign_simple;
+ else if (chFirst == '+')
+ enmOpcode = kKmkCcEvalInstr_assign_append;
+ else if (chFirst == '<')
+ enmOpcode = kKmkCcEvalInstr_assign_prepend;
+ else
+ kmk_cc_eval_fatal(pCompiler, pOpWord->pchWord, "Bogus stuff after 'define' variable name");
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, pOpWord->pchWord, "Bogus stuff after 'define' variable name");
+ if (cWords > 2)
+ kmk_cc_eval_fatal(pCompiler, pCompiler->paWords[2].pchWord,
+ "Bogus stuff after 'define' variable name and assignment operator");
+ }
+
+ /*
+ * The variable name must not be empty.
+ */
+ if (pVarWord->cchWord)
+ {
+ int const fPlainVarNm = pVarWord->enmToken == kKmkCcEvalToken_WordPlain;
+ const char * pchVarNm = pVarWord->pchWord;
+ size_t cchVarNm = pVarWord->cchWord;
+ PKMKCCEVALASSIGN pInstr;
+ size_t cchValue;
+ const char *pszValue;
+ int fPlainValue;
+
+ if ( enmOpcode == kKmkCcEvalInstr_define_recursive
+ || enmOpcode == kKmkCcEvalInstr_define_if_new)
+ {
+ PKMKCCEVALASSIGNDEF pInstrDef;
+ pInstrDef = (PKMKCCEVALASSIGNDEF)kmk_cc_block_alloc_eval(pCompiler->ppBlockTail, sizeof(*pInstrDef));
+ pInstr = &pInstrDef->AssignCore;
+ pInstrDef->pEvalProg = NULL; /** @todo consider this later at some point, need some trial and error approach. */
+ }
+ else
+ pInstr = (PKMKCCEVALASSIGN)kmk_cc_block_alloc_eval(pCompiler->ppBlockTail, sizeof(*pInstr));
+
+ pInstr->Core.enmOpcode = enmOpcode;
+ pInstr->Core.iLine = pCompiler->iLine;
+ pInstr->fExport = (fQualifiers & KMK_CC_EVAL_QUALIFIER_EXPORT) != 0;
+ pInstr->fOverride = (fQualifiers & KMK_CC_EVAL_QUALIFIER_OVERRIDE) != 0;
+ pInstr->fPrivate = (fQualifiers & KMK_CC_EVAL_QUALIFIER_PRIVATE) != 0;
+ pInstr->fLocal = (fQualifiers & KMK_CC_EVAL_QUALIFIER_LOCAL) != 0;
+
+ cchValue = kmk_cc_eval_parse_define_value(pCompiler, &fPlainValue);
+ pszValue = kmk_cc_eval_strdup_prepped(pCompiler, cchValue);
+ if (fPlainVarNm)
+ pchVarNm = strcache2_add(&variable_strcache, pchVarNm, cchVarNm);
+ else
+ {
+/** @todo fix work copying. */
+// pCompiler->iEscEol = iEscEolVarNm;
+ cchVarNm = kmk_cc_eval_prep_normal_line_ex(pCompiler, pchVarNm, cchVarNm);
+ pchVarNm = kmk_cc_eval_strdup_prepped(pCompiler, cchVarNm);
+ }
+ kmk_cc_block_realign(pCompiler->ppBlockTail);
+ KMK_CC_EVAL_DPRINTF(("%s: define '%s'\n%s\nendef\n", g_apszEvalInstrNms[enmOpcode], pchVarNm, pszValue));
+
+ kmk_cc_eval_init_subprogram_or_plain(pCompiler, &pInstr->Variable, pchVarNm, cchVarNm, fPlainVarNm);
+ kmk_cc_eval_init_subprogram_or_plain(pCompiler, &pInstr->Value, pszValue, cchValue, fPlainValue);
+
+ pInstr->pNext = (PKMKCCEVALCORE)kmk_cc_block_get_next_ptr(*pCompiler->ppBlockTail);
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, pchWord, "Empty variable name after 'define'");
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, pchWord, "Expected variable name after 'define'");
+ 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;
+}
+
+
+static int kmk_cc_eval_handle_assignment_or_recipe(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft,
+ unsigned fQualifiers)
+{
+ /*
+ * We're currently at a word which may or may not be a variable name
+ * followed by an assignment operator, alternatively it must be a recipe.
+ * We need to figure this out and deal with it in the most efficient
+ * manner as this is a very common occurence.
+ */
+ unsigned const iEscEolVarNm = pCompiler->iEscEol;
+ int fPlainVarNm = 1;
+ const char *pchVarNm = pchWord;
+ size_t cchVarNm;
+ size_t cch = 0;
+ size_t cchSubprog = 0;
+ char ch;
+
+ /*
+ * The variable name. Complicate by there being no requirement of a space
+ * preceeding the assignment operator, as well as that the variable name
+ * may include variable references with spaces (function++) in them.
+ */
+ for (;;)
+ {
+ if (cch < cchLeft)
+ { /*likely*/ }
+ else
+ {
+ /* Single word, join paths with word + whitespace. */
+ KMK_CC_ASSERT(cch == cchLeft);
+ cchVarNm = cch;
+ pchWord += cch;
+ cchLeft -= cch;
+ break;
+ }
+
+ ch = pchWord[cch];
+ if (!KMK_CC_EVAL_IS_SPACE_DOLLAR_SLASH_OR_ASSIGN(ch))
+ cch++;
+ /* Space? */
+ else if (KMK_CC_EVAL_IS_SPACE(ch))
+ {
+ cchVarNm = cch;
+ pchWord += cch;
+ cchLeft -= cch;
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+ break;
+ }
+ /* Variable expansion may contain spaces, so handle specially. */
+ else if (ch == '$')
+ {
+ size_t const offStart = cch;
+ cch = kmk_cc_eval_parse_var_exp(pCompiler, pchWord, cchLeft, cch);
+ cchSubprog += cch - offStart;
+ fPlainVarNm = 0;
+ }
+ /* Check out potential recipe, simple assignment or DOS drive letter separator. */
+ else if (ch == ':')
+ {
+ if ( cch + 1 < cchLeft
+ && pchWord[cch + 1] != '=')
+ {
+ cchVarNm = cch;
+ pchWord += cch;
+ cchLeft -= cch;
+ break;
+ }
+#ifdef HAVE_DOS_PATHS
+ /* Don't confuse the first colon in:
+ C:/Windows/System32/Kernel32.dll: C:/Windows/System32/NtDll.dll
+ for a recipe, it is only the second one which counts. */
+ if ( cch == 1
+ && isalpha((unsigned char)pchWord[0]))
+ cch++;
+ else
+#endif
+ 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 > 0)
+ {
+ char chPrev = pchWord[cch - 1];
+ if (chPrev == ':' || chPrev == '+' || chPrev == '?' || chPrev == '<')
+ cch--;
+ cchVarNm = cch;
+ pchWord += cch;
+ cchLeft -= cch;
+ break;
+ }
+ kmk_cc_eval_fatal(pCompiler, pchWord, "Empty variable name.");
+ }
+ /* Check out potential escaped EOL sequence. */
+ else if (ch == '\\')
+ {
+ unsigned const iEscEol = pCompiler->iEscEol;
+ if (iEscEol >= pCompiler->cEscEols)
+ cch++;
+ else
+ {
+ size_t offCur = &pchWord[cch] - pCompiler->pszContent;
+ if (offCur < pCompiler->paEscEols[iEscEol].offEol)
+ cch++;
+ else
+ {
+ cchVarNm = cch;
+ KMK_CC_ASSERT(offCur == pCompiler->paEscEols[iEscEol].offEol);
+ cch = pCompiler->paEscEols[iEscEol].offEol + pCompiler->cchEolSeq - offCur;
+ pCompiler->iEscEol = iEscEol + 1;
+ pchWord += cch;
+ cchLeft -= cch;
+ KMK_CC_EVAL_SKIP_SPACES(pCompiler, pchWord, cchLeft);
+ break;
+ }
+ }
+ }
+ else
+ KMK_CC_ASSERT(0);
+ }
+
+ /*
+ * Check for assignment operator.
+ */
+ if (cchLeft)
+ {
+ size_t cchValue;
+ PKMKCCEVALASSIGN pInstr;
+ KMKCCEVALINSTR enmOpcode;
+ int fPlainValue;
+ char *pszValue;
+
+ ch = *pchWord;
+ if (ch == '=')
+ {
+ enmOpcode = kKmkCcEvalInstr_assign_recursive;
+ pchWord++;
+ cchLeft--;
+ }
+ else if (cchLeft >= 2 && pchWord[1] == '=')
+ {
+ if (ch == ':')
+ enmOpcode = kKmkCcEvalInstr_assign_simple;
+ else if (ch == '+')
+ enmOpcode = kKmkCcEvalInstr_assign_append;
+ else if (ch == '<')
+ enmOpcode = kKmkCcEvalInstr_assign_prepend;
+ 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 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 0; /* retry without preceding keywords */
+
+ /*
+ * Skip leading spaces, if any and prep the value for copying.
+ */
+ KMK_CC_EVAL_SKIP_SPACES(pCompiler, pchWord, cchLeft);
+ cchValue = kmk_cc_eval_prep_normal_line(pCompiler, pchWord, cchLeft);
+ fPlainValue = memchr(pchWord, '$', cchLeft) == NULL;
+
+ /*
+ * Emit the instruction.
+ */
+ kmk_cc_eval_end_of_recipe(pCompiler, pchWord);
+
+ pInstr = (PKMKCCEVALASSIGN)kmk_cc_block_alloc_eval(pCompiler->ppBlockTail, sizeof(*pInstr));
+ pInstr->Core.enmOpcode = enmOpcode;
+ pInstr->Core.iLine = pCompiler->iLine;
+ pInstr->fExport = (fQualifiers & KMK_CC_EVAL_QUALIFIER_EXPORT) != 0;
+ pInstr->fOverride = (fQualifiers & KMK_CC_EVAL_QUALIFIER_OVERRIDE) != 0;
+ pInstr->fPrivate = (fQualifiers & KMK_CC_EVAL_QUALIFIER_PRIVATE) != 0;
+ pInstr->fLocal = (fQualifiers & KMK_CC_EVAL_QUALIFIER_LOCAL) != 0;
+
+ /* We copy the value before messing around with the variable name since
+ we have to do more iEolEsc saves & restores the other way around. */
+ pszValue = kmk_cc_eval_strdup_prepped(pCompiler, cchValue);
+ if (fPlainVarNm)
+ pchVarNm = strcache2_add(&variable_strcache, pchVarNm, cchVarNm);
+ else
+ {
+ pCompiler->iEscEol = iEscEolVarNm;
+ cchVarNm = kmk_cc_eval_prep_normal_line_ex(pCompiler, pchVarNm, cchVarNm);
+ pchVarNm = kmk_cc_eval_strdup_prepped(pCompiler, cchVarNm);
+ }
+ kmk_cc_block_realign(pCompiler->ppBlockTail);
+ KMK_CC_EVAL_DPRINTF(("%s: '%s' '%s'\n", g_apszEvalInstrNms[enmOpcode], pchVarNm, pszValue));
+
+ kmk_cc_eval_init_subprogram_or_plain(pCompiler, &pInstr->Variable, pchVarNm, cchVarNm, fPlainVarNm);
+ kmk_cc_eval_init_subprogram_or_plain(pCompiler, &pInstr->Value, pszValue, cchValue, fPlainValue);
+
+ 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");
+ return 1;
+}
+
+
+/**
+ * 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
+ * the moment. Should any be added later, they will have to come after 'local'.
+ *
+ * @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 'local'.
+ * @param cchLeft The number of chars left to parse on this line.
+ * @param fQualifiers The qualifiers.
+ */
+static int kmk_cc_eval_do_var_local(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft)
+{
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+ if (cchLeft)
+ {
+ /*
+ * Check for 'local define' and 'local undefine'
+ */
+ 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;
+}
+
+
+/**
+ * We've found one variable qualification keyword, now continue parsing and see
+ * if this is some kind of variable assignment expression or not.
+ *
+ * @returns 1 if variable assignment, 0 if not.
+ * @param pCompiler The compiler state.
+ * @param pchWord First char after the first qualifier.
+ * @param cchLeft The number of chars left to parse on this line.
+ * @param fQualifiers The qualifier.
+ */
+static int kmk_cc_eval_try_handle_var_with_keywords(PKMKCCEVALCOMPILER pCompiler, const char *pchWord, size_t cchLeft,
+ unsigned fQualifiers)
+{
+ for (;;)
+ {
+ KMK_CC_EVAL_SKIP_SPACES_AFTER_WORD(pCompiler, pchWord, cchLeft);
+ if (cchLeft)
+ {
+ char ch = *pchWord;
+ if (KMK_CC_EVAL_IS_1ST_IN_VARIABLE_KEYWORD(ch))
+ {
+ 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_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))
+ fQualifiers |= KMK_CC_EVAL_QUALIFIER_EXPORT;
+ else
+ kmk_cc_eval_warn(pCompiler, pchWord, "'export' qualifier repeated");
+ pchWord += 6;
+ cchLeft -= 6;
+ continue;
+ }
+
+ if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "override", 8))
+ {
+ if (!(fQualifiers & KMK_CC_EVAL_QUALIFIER_OVERRIDE))
+ fQualifiers |= KMK_CC_EVAL_QUALIFIER_OVERRIDE;
+ else
+ kmk_cc_eval_warn(pCompiler, pchWord, "'override' qualifier repeated");
+ pchWord += 8;
+ cchLeft -= 8;
+ continue;
+ }
+
+ if (KMK_CC_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "private", 7))
+ {
+ if (!(fQualifiers & KMK_CC_EVAL_QUALIFIER_PRIVATE))
+ fQualifiers |= KMK_CC_EVAL_QUALIFIER_PRIVATE;
+ else
+ kmk_cc_eval_warn(pCompiler, pchWord, "'private' qualifier repeated");
+ pchWord += 7;
+ cchLeft -= 7;
+ continue;
+ }
+ }
+
+ /*
+ * Not a keyword, likely variable name followed by an assignment
+ * operator and a value. Do a rough check for the assignment operator
+ * and join paths with the unqualified assignment handling code.
+ */
+ {
+ const char *pchEqual = (const char *)memchr(pchWord, '=', cchLeft);
+ if (pchEqual)
+ return kmk_cc_eval_handle_assignment_or_recipe(pCompiler, pchWord, cchLeft, fQualifiers);
+ }
+ return 0;
+ }
+ else
+ kmk_cc_eval_fatal(pCompiler, NULL,
+ "Expected assignment operator or variable directive after variable qualifier(s)\n");
+ }
+}
+
+
+/**
+ * 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)
+ {
+ unsigned iSavedEscEol;
+ unsigned cWords;
+
+ /*
+ * 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.
+ */
+ iSavedEscEol = pCompiler->iEscEol;
+ cWords = kmk_cc_eval_parse_words(pCompiler, pchWord, cchLeft);
+ if (cWords)
+ {
+ PKMKCCEVALVARIABLES pInstr;
+ 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.)
+ */
+ 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.
+ *
+ * @returns 1 if make directive or qualified variable assignment, 0 if neither.
+ * @param pCompiler The compiler state.
+ * @param ch The first char.
+ * @param pchWord Pointer to the first word.
+ * @param cchLeft Number of characters left to parse starting at
+ * @a cchLeft.
+ */
+int kmk_cc_eval_try_handle_keyword(PKMKCCEVALCOMPILER pCompiler, char ch, const char *pchWord, size_t cchLeft)
+{
+ unsigned iSavedEscEol = pCompiler->iEscEol;
+
+ KMK_CC_ASSERT(cchLeft >= 2);
+ KMK_CC_ASSERT(ch == pchWord[0]);
+ KMK_CC_ASSERT(KMK_CC_EVAL_IS_1ST_IN_KEYWORD(pchWord[0]));
+ KMK_CC_ASSERT(KMK_CC_EVAL_IS_2ND_IN_KEYWORD(pchWord[1]));
+
+ /*
+ * If it's potentially a variable related keyword, check that out first.
+ */
+ if (KMK_CC_EVAL_IS_1ST_IN_VARIABLE_KEYWORD(ch))
+ {
+ 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_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_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_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))
+ return 1;
+ pCompiler->iEscEol = iSavedEscEol;
+ }
+ 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))
+ return 1;
+ pCompiler->iEscEol = iSavedEscEol;
+ }
+ }
+
+ /*
+ * Check out the other keywords.
+ */
+ if (ch == 'i') /* Lots of directives starting with 'i'. */
+ {
+ char ch2 = pchWord[1];
+ pchWord += 2;
+ cchLeft -= 2;
+
+ /* 'if...' */
+ if (ch2 == 'f')
+ {
+ 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_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_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_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_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_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_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 */);
+ }
+ /* include... */
+ else if (ch2 == 'n' && cchLeft >= 5 && KMK_CC_WORD_COMP_CONST_5(pchWord, "clude") ) /* 'in...' */
+ {
+ pchWord += 5;
+ cchLeft -= 5;
+ 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"))
+ {
+ pchWord += 3;
+ cchLeft -= 3;
+ 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_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_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "-flush", 6))
+ return kmk_cc_eval_do_include(pCompiler, pchWord + 6, cchLeft - 6, kKmkCcEvalInstr_includedep_flush);
+ }
+ }
+ }
+ else if (ch == 'e') /* A few directives starts with 'e'. */
+ {
+ 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_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_EVAL_WORD_COMP_CONST(pCompiler, pchWord, cchLeft, "export", 6));
+
+ }
+ else /* the rest. */
+ {
+ 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_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_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));
+ }
+
+ pCompiler->iEscEol = iSavedEscEol;
+ return 0;
+}
+
+
+
+
+static int kmk_cc_eval_compile_worker(PKMKCCEVALPROG pEvalProg, const char *pszContent, size_t cchContent, unsigned iLine)
+{
+ const char *pchTmp;
+
+ /*
+ * Compiler state.
+ */
+ KMKCCEVALCOMPILER Compiler;
+ kmk_cc_eval_init_compiler(&Compiler, pEvalProg, iLine, pszContent, cchContent);
+ KMK_CC_EVAL_DPRINTF(("\nkmk_cc_eval_compile_worker - begin (%s/%s/%d)\n", pEvalProg->pszFilename, pEvalProg->pszVarName, iLine));
+
+ {
+ /*
+ * Line state.
+ */
+ size_t cchLine; /* The length of the current line (w/o comments). */
+ size_t offNext = 0; /* The offset of the next line. */
+ size_t off = 0; /* The offset into pszContent of the current line. */
+
+ /* Try for some register/whatever optimzations. */
+ int const chFirstEol = Compiler.chFirstEol;
+ size_t const cchEolSeq = Compiler.cchEolSeq;
+
+ /*
+ * Process input lines.
+ *
+ * The code here concerns itself with getting the next line in an efficient
+ * manner, very basic classification and trying out corresponding handlers.
+ * The real work is done in the handlers.
+ */
+ while (offNext < cchContent)
+ {
+ size_t offFirstWord;
+
+ /*
+ * Find the end of the next line.
+ */
+ KMK_CC_ASSERT(off == offNext);
+
+ /* Simple case: No escaped EOL, nor the end of the input. */
+ pchTmp = (const char *)memchr(&pszContent[offNext], chFirstEol, cchContent - offNext);
+ if ( pchTmp
+ && ( &pszContent[offNext] == pchTmp
+ || pchTmp[-1] != '\\') )
+ {
+ if ( cchEolSeq == 1
+ || pchTmp[1] == Compiler.chSecondEol)
+ {
+ /* Frequent: Blank line. */
+ if (&pszContent[offNext] == pchTmp)
+ {
+ KMK_CC_EVAL_DPRINTF(("#%03u: <empty>\n", Compiler.iLine));
+ Compiler.iLine++;
+ off = offNext += cchEolSeq;
+ continue;
+ }
+ if (pszContent[offNext] == '#')
+ {
+ KMK_CC_EVAL_DPRINTF(("#%03u: <comment-col-0>\n", Compiler.iLine));
+ Compiler.iLine++;
+ offNext = pchTmp - pszContent;
+ off = offNext += cchEolSeq;
+ continue;
+ }
+
+ offNext = pchTmp - pszContent;
+ cchLine = offNext - off;
+
+ offFirstWord = off;
+ while (offFirstWord < offNext && KMK_CC_EVAL_IS_SPACE(pszContent[offFirstWord]))
+ offFirstWord++;
+
+ offNext += cchEolSeq;
+ Compiler.cEscEols = 0;
+ Compiler.iEscEol = 0;
+ }
+ else
+ kmk_cc_eval_fatal_eol(&Compiler, pchTmp, Compiler.iLine, off);
+ }
+ /* The complicated, less common cases. */
+ else
+ {
+ Compiler.cEscEols = 0;
+ Compiler.iEscEol = 0;
+ offFirstWord = offNext;
+ for (;;)
+ {
+ if (pchTmp)
+ {
+ if ( cchEolSeq == 1
+ || pchTmp[1] == Compiler.chSecondEol)
+ {
+ size_t offEsc;
+ if (offFirstWord != offNext)
+ offNext = pchTmp - pszContent;
+ else
+ {
+ offNext = pchTmp - pszContent;
+ while (offFirstWord < offNext && KMK_CC_EVAL_IS_SPACE(pszContent[offFirstWord]))
+ offFirstWord++;
+ }
+
+
+ /* Is it an escape sequence? */
+ if ( !offNext
+ || pchTmp[-1] != '\\')
+ {
+ cchLine = offNext - off;
+ offNext += cchEolSeq;
+ break;
+ }
+ if (offNext < 2 || pchTmp[-2] != '\\')
+ offEsc = offNext - 1;
+ else
+ {
+ /* Count how many backslashes there are. Must be odd number to be an escape
+ sequence. Normally we keep half of them, except for command lines. */
+ size_t cSlashes = 2;
+ while (offNext >= cSlashes && pchTmp[0 - cSlashes] == '\\')
+ cSlashes--;
+ if (!(cSlashes & 1))
+ {
+ cchLine = offNext - off;
+ offNext += cchEolSeq;
+ break;
+ }
+ offEsc = offNext - (cSlashes >> 1);
+ }
+
+ /* Record it. */
+ if (Compiler.cEscEols < Compiler.cEscEolsAllocated) { /* likely */ }
+ else
+ {
+ KMK_CC_ASSERT(Compiler.cEscEols == Compiler.cEscEolsAllocated);
+ Compiler.cEscEolsAllocated = Compiler.cEscEolsAllocated
+ ? Compiler.cEscEolsAllocated * 2 : 2;
+ Compiler.paEscEols = (PKMKCCEVALESCEOL)xrealloc(Compiler.paEscEols,
+ Compiler.cEscEolsAllocated
+ * sizeof(Compiler.paEscEols[0]));
+ }
+ Compiler.paEscEols[Compiler.cEscEols].offEsc = offEsc;
+ Compiler.paEscEols[Compiler.cEscEols].offEol = offNext;
+ Compiler.cEscEols++;
+
+ /* Advance. */
+ offNext += cchEolSeq;
+ if (offFirstWord == offEsc)
+ {
+ offFirstWord = offNext;
+ Compiler.iEscEol++;
+ }
+ }
+ else
+ kmk_cc_eval_fatal_eol(&Compiler, pchTmp, Compiler.iLine, off);
+ }
+ else
+ {
+ /* End of input. Happens only once per compilation, nothing to optimize for. */
+ if (offFirstWord == offNext)
+ while (offFirstWord < cchContent && KMK_CC_EVAL_IS_SPACE(pszContent[offFirstWord]))
+ offFirstWord++;
+ offNext = cchContent;
+ cchLine = cchContent - off;
+ break;
+ }
+ pchTmp = (const char *)memchr(&pszContent[offNext], chFirstEol, cchContent - offNext);
+ }
+ }
+ KMK_CC_ASSERT(offNext <= cchContent);
+ KMK_CC_ASSERT(offNext >= off + cchLine);
+ KMK_CC_ASSERT(off + cchLine <= cchContent && cchLine <= cchContent);
+ KMK_CC_ASSERT(offFirstWord <= off + cchLine);
+ KMK_CC_ASSERT(offFirstWord >= off);
+ KMK_CC_ASSERT(pszContent[offFirstWord] != ' ' && pszContent[offFirstWord] != '\t');
+
+ KMK_CC_EVAL_DPRINTF(("#%03u: %*.*s\n", Compiler.iLine, (int)cchLine, (int)cchLine, &pszContent[off]));
+
+ /*
+ * Skip blank lines.
+ */
+ if (offFirstWord < off + cchLine)
+ {
+ /*
+ * Command? Ignore command prefix if no open recipe (SunOS 4 behavior).
+ */
+ if ( pszContent[off] == Compiler.chCmdPrefix
+ && (Compiler.pRecipe || Compiler.fNoTargetRecipe))
+ {
+ if (!Compiler.fNoTargetRecipe)
+ kmk_cc_eval_handle_command(&Compiler, &pszContent[off], cchLine);
+ }
+ /*
+ * Since it's not a command line, we can now skip comment lines
+ * even with a tab indentation. If it's not a comment line, we
+ * tentatively strip any trailing comment.
+ */
+ else if (pszContent[offFirstWord] != '#')
+ {
+ const char *pchWord = &pszContent[offFirstWord];
+ size_t cchLeft = off + cchLine - offFirstWord;
+ char ch;
+
+ Compiler.cchLineWithComments = cchLine;
+ pchTmp = (const char *)memchr(pchWord, '#', cchLeft);
+ if (pchTmp)
+ {
+ cchLeft = pchTmp - pchWord;
+ cchLine = pchTmp - &pszContent[off];
+ }
+ Compiler.cchLine = cchLine; /** @todo only used by assertions. */
+ Compiler.offLine = off; /** @todo only used by fatal errors. */
+
+#ifdef KMK_CC_STRICT
+ Compiler.cWords = 0x424242;
+#endif
+
+ /*
+ * If not a directive or variable qualifier, it's either a variable
+ * assignment or a recipe.
+ */
+ ch = *pchWord;
+ if ( !KMK_CC_EVAL_IS_1ST_IN_KEYWORD(ch)
+ || !KMK_CC_EVAL_IS_2ND_IN_KEYWORD(pchWord[1]))
+ {
+ if (memchr(pchWord, '=', cchLeft))
+ kmk_cc_eval_handle_assignment_or_recipe(&Compiler, pchWord, cchLeft, 0 /*fQualifiers*/);
+ else
+ kmk_cc_eval_handle_recipe(&Compiler, pchWord, cchLeft);
+ }
+ else
+ {
+ /* Possible directive or variable qualifier. */
+ Compiler.offNext = offNext;
+ if (kmk_cc_eval_try_handle_keyword(&Compiler, ch, pchWord, cchLeft))
+ offNext = Compiler.offNext;
+ /* No, that wasn't it... */
+ else if (memchr(pchWord, '=', cchLeft))
+ kmk_cc_eval_handle_assignment_or_recipe(&Compiler, pchWord, cchLeft, 0 /*fQualifiers*/);
+ else
+ kmk_cc_eval_handle_recipe(&Compiler, pchTmp, pchWord, cchLeft);
+ }
+ }
+ }
+
+ /*
+ * Advance to the next line.
+ */
+ off = offNext;
+ Compiler.iLine += Compiler.cEscEols + 1;
+ }
+ }
+
+ /*
+ * Check whether
+ */
+
+ kmk_cc_eval_delete_compiler(&Compiler);
+ KMK_CC_EVAL_DPRINTF(("kmk_cc_eval_compile_worker - done (%s/%s)\n\n", pEvalProg->pszFilename, pEvalProg->pszVarName));
+ return 0;
+}
+
+
+
+static PKMKCCEVALPROG kmk_cc_eval_compile(const char *pszContent, size_t cchContent,
+ const char *pszFilename, unsigned iLine, const char *pszVarName)
+{
+ /*
+ * Estimate block size, allocate one and initialize it.
+ */
+ PKMKCCEVALPROG pEvalProg;
+ PKMKCCBLOCK pBlock;
+ pEvalProg = kmk_cc_block_alloc_first(&pBlock, sizeof(*pEvalProg), cchContent / 32); /** @todo adjust */
+ if (pEvalProg)
+ {
+ pEvalProg->pBlockTail = pBlock;
+ pEvalProg->pFirstInstr = (PKMKCCEVALCORE)kmk_cc_block_get_next_ptr(pBlock);
+ pEvalProg->pszFilename = pszFilename ? pszFilename : "<unknown>";
+ pEvalProg->pszVarName = pszVarName;
+ pEvalProg->cRefs = 1;
+#ifdef KMK_CC_STRICT
+ pEvalProg->uInputHash = kmk_cc_debug_string_hash_n(0, pszContent, cchContent);
+#endif
+
+ /*
+ * Do the actual compiling.
+ */
+#ifdef CONFIG_WITH_EVAL_COMPILER
+ if (kmk_cc_eval_compile_worker(pEvalProg, pszContent, cchContent, iLine) == 0)
+#else
+ if (0)
+#endif
+ {
+#ifdef KMK_CC_WITH_STATS
+ pBlock = pEvalProg->pBlockTail;
+ if (!pBlock->pNext)
+ g_cSingleBlockEvalProgs++;
+ else if (!pBlock->pNext->pNext)
+ g_cTwoBlockEvalProgs++;
+ else
+ g_cMultiBlockEvalProgs++;
+ for (; pBlock; pBlock = pBlock->pNext)
+ {
+ g_cBlocksAllocatedEvalProgs++;
+ g_cbAllocatedEvalProgs += pBlock->cbBlock;
+ g_cbUnusedMemEvalProgs += pBlock->cbBlock - pBlock->offNext;
+ }
+#endif
+ return pEvalProg;
+ }
+ kmk_cc_block_free_list(pEvalProg->pBlockTail);
+ }
+ return NULL;
+}
+
+
+/**
+ * Compiles a variable direct evaluation as is, setting v->evalprog on success.
+ *
+ * @returns Pointer to the program on success, NULL if no program was created.
+ * @param pVar Pointer to the variable.
+ */
+struct kmk_cc_evalprog *kmk_cc_compile_variable_for_eval(struct variable *pVar)
+{
+ PKMKCCEVALPROG pEvalProg = pVar->evalprog;
+ if (!pEvalProg)
+ {
+#ifdef CONFIG_WITH_EVAL_COMPILER
+ pEvalProg = kmk_cc_eval_compile(pVar->value, pVar->value_length,
+ pVar->fileinfo.filenm, pVar->fileinfo.lineno, pVar->name);
+ pVar->evalprog = pEvalProg;
+#endif
+ g_cVarForEvalCompilations++;
+ }
+ return pEvalProg;
+}
+
+
+/**
+ * Compiles a makefile for
+ *
+ * @returns Pointer to the program on success, NULL if no program was created.
+ * @param pVar Pointer to the variable.
+ */
+struct kmk_cc_evalprog *kmk_cc_compile_file_for_eval(FILE *pFile, const char *pszFilename)
+{
+ PKMKCCEVALPROG pEvalProg;
+
+ /*
+ * Read the entire file into a zero terminate memory buffer.
+ */
+ size_t cchContent = 0;
+ char *pszContent = NULL;
+ struct stat st;
+ if (!fstat(fileno(pFile), &st))
+ {
+ 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 %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);
+
+ cchContent = fread(pszContent, 1, cchContent, pFile);
+ if (ferror(pFile))
+ fatal(NULL, _("Read error: %s"), strerror(errno));
+ }
+ else
+ {
+ size_t cbAllocated = 2048;
+ do
+ {
+ cbAllocated *= 2;
+ 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);
+ if (ferror(pFile))
+ fatal(NULL, _("Read error: %s"), strerror(errno));
+ } while (!feof(pFile));
+ }
+ pszContent[cchContent] = '\0';
+
+ /*
+ * Call common function to do the compilation.
+ */
+ pEvalProg = kmk_cc_eval_compile(pszContent, cchContent, pszFilename, 1, NULL /*pszVarName*/);
+ g_cFileForEvalCompilations++;
+
+ free(pszContent);
+ if (!pEvalProg)
+ fseek(pFile, 0, SEEK_SET);
+ return pEvalProg;
+}
+
+
+/**
+ * Equivalent of eval_buffer, only it's using the evalprog of the variable.
+ *
+ * @param pVar Pointer to the variable. Must have a program.
+ */
+void kmk_exec_eval_variable(struct variable *pVar)
+{
+ KMK_CC_ASSERT(pVar->evalprog);
+ assert(0);
+}
+
+
+/**
+ * Worker for eval_makefile.
+ *
+ * @param pEvalProg The program pointer.
+ */
+void kmk_exec_eval_file(struct kmk_cc_evalprog *pEvalProg)
+{
+ KMK_CC_ASSERT(pEvalProg);
+ assert(0);
+
+}
+
+
+
+/*
+ *
+ * Program destruction hooks.
+ * Program destruction hooks.
+ * Program destruction hooks.
+ *
+ */
+
+
+/**
+ * Called when a variable with expandprog or/and evalprog changes.
+ *
+ * @param pVar Pointer to the variable.
+ */
+void kmk_cc_variable_changed(struct variable *pVar)
+{
+ PKMKCCEXPPROG pProg = pVar->expandprog;
+
+ KMK_CC_ASSERT(pVar->evalprog || pProg);
+
+ if (pVar->evalprog)
+ {
+ kmk_cc_block_free_list(pVar->evalprog->pBlockTail);
+ pVar->evalprog = NULL;
+ }
+
+ if (pProg)
+ {
+ if (pProg->cRefs == 1)
+ kmk_cc_block_free_list(pProg->pBlockTail);
+ else
+ fatal(NULL, _("Modifying a variable (%s) while its expansion program is running is not supported"), pVar->name);
+ pVar->expandprog = NULL;
+ }
+}
+
+
+/**
+ * Called when a variable with expandprog or/and evalprog is deleted.
+ *
+ * @param pVar Pointer to the variable.
+ */
+void kmk_cc_variable_deleted(struct variable *pVar)
+{
+ PKMKCCEXPPROG pProg = pVar->expandprog;
+
+ KMK_CC_ASSERT(pVar->evalprog || pProg);
+
+ if (pVar->evalprog)
+ {
+ kmk_cc_block_free_list(pVar->evalprog->pBlockTail);
+ pVar->evalprog = NULL;
+ }
+
+ if (pProg)
+ {
+ if (pProg->cRefs == 1)
+ kmk_cc_block_free_list(pProg->pBlockTail);
+ else
+ fatal(NULL, _("Deleting a variable (%s) while its expansion program is running is not supported"), pVar->name);
+ pVar->expandprog = NULL;
+ }
+}
+
+
+
+
+
+
+
+#endif /* CONFIG_WITH_COMPILER */
+