diff options
Diffstat (limited to 'src/kmk/kmk_cc_exec.c')
| -rw-r--r-- | src/kmk/kmk_cc_exec.c | 7613 |
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 */ + |