kbuild.c@ 2837

Last change on this file since 2837 was 2837, checked in by bird, 8 years ago
kbuild_apply_defpath: Fixed heap corruption when DEFPATH isn't absolute.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 97.3 KB

Line
1	/* $Id: kbuild.c 2837 2016-08-24 12:11:24Z bird $ */
2	/** @file
3	* kBuild specific make functionality.
4	*/
5
6	/*
7	* Copyright (c) 2006-2010 knut st. osmundsen <[email protected]>
8	*
9	* This file is part of kBuild.
10	*
11	* kBuild is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 3 of the License, or
14	* (at your option) any later version.
15	*
16	* kBuild is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.
20	*
21	* You should have received a copy of the GNU General Public License
22	* along with kBuild. If not, see <http://www.gnu.org/licenses/>
23	*
24	*/
25
26	/* No GNU coding style here! */
27
28	/*******************************************************************************
29	* Header Files *
30	*******************************************************************************/
31	#include "make.h"
32	#include "filedef.h"
33	#include "variable.h"
34	#include "dep.h"
35	#include "debug.h"
36	#ifdef WINDOWS32
37	# include "pathstuff.h"
38	# include <Windows.h>
39	#endif
40	#if defined(__APPLE__)
41	# include <mach-o/dyld.h>
42	#endif
43	#if defined(__FreeBSD__)
44	# include <dlfcn.h>
45	# include <sys/link_elf.h>
46	#endif
47
48	#include "kbuild.h"
49
50	#include <assert.h>
51
52
53	/*******************************************************************************
54	* Defined Constants And Macros *
55	*******************************************************************************/
56	/** Helper for passing a string constant to kbuild_get_variable_n. */
57	#define ST(strconst) strconst, sizeof(strconst) - 1
58
59	#if 1
60	# define my_memcpy(dst, src, len) \
61	do { \
62	if (len > 8) \
63	memcpy(dst, src, len); \
64	else \
65	switch (len) \
66	{ \
67	case 8: dst[7] = src[7]; \
68	case 7: dst[6] = src[6]; \
69	case 6: dst[5] = src[5]; \
70	case 5: dst[4] = src[4]; \
71	case 4: dst[3] = src[3]; \
72	case 3: dst[2] = src[2]; \
73	case 2: dst[1] = src[1]; \
74	case 1: dst[0] = src[0]; \
75	case 0: break; \
76	} \
77	} while (0)
78	#elif defined(__GNUC__)
79	# define my_memcpy __builtin_memcpy
80	#elif defined(_MSC_VER)
81	# pragma instrinic(memcpy)
82	# define my_memcpy memcpy
83	#endif
84
85
86	/*******************************************************************************
87	* Global Variables *
88	*******************************************************************************/
89	/** The argv[0] passed to main. */
90	static const char *g_pszExeName;
91	/** The initial working directory. */
92	static char *g_pszInitialCwd;
93
94
95	/**
96	* Initialize kBuild stuff.
97	*
98	* @param argc Number of arguments to main().
99	* @param argv The main() argument vector.
100	*/
101	void init_kbuild(int argc, char **argv)
102	{
103	int rc;
104	PATH_VAR(szTmp);
105
106	/*
107	* Get the initial cwd for use in my_abspath.
108	*/
109	#ifdef WINDOWS32
110	if (getcwd_fs(szTmp, GET_PATH_MAX) != 0)
111	#else
112	if (getcwd(szTmp, GET_PATH_MAX) != 0)
113	#endif
114	g_pszInitialCwd = xstrdup(szTmp);
115	else
116	fatal(NILF, _("getcwd failed"));
117
118	/*
119	* Determin the executable name.
120	*/
121	rc = -1;
122	#if defined(__APPLE__)
123	{
124	const char *pszImageName = _dyld_get_image_name(0);
125	if (pszImageName)
126	{
127	size_t cchImageName = strlen(pszImageName);
128	if (cchImageName < GET_PATH_MAX)
129	{
130	memcpy(szTmp, pszImageName, cchImageName + 1);
131	rc = 0;
132	}
133	}
134	}
135
136	#elif defined(__FreeBSD__)
137	rc = readlink("/proc/curproc/file", szTmp, GET_PATH_MAX - 1);
138	if (rc < 0 \|\| rc == GET_PATH_MAX - 1)
139	{
140	rc = -1;
141	# if 0 /* doesn't work because l_name isn't always absolute, it's just argv0 from exec or something. */
142	/* /proc is optional, try rtdl. */
143	void *hExe = dlopen(NULL, 0);
144	rc = -1;
145	if (hExe)
146	{
147	struct link_map const *pLinkMap = 0;
148	if (dlinfo(hExe, RTLD_DI_LINKMAP, &pLinkMap) == 0)
149	{
150	const char *pszImageName = pLinkMap->l_name;
151	size_t cchImageName = strlen(pszImageName);
152	if (cchImageName < GET_PATH_MAX)
153	{
154	memcpy(szTmp, pszImageName, cchImageName + 1);
155	rc = 0;
156	}
157	}
158
159	}
160	# endif
161	}
162	else
163	szTmp[rc] = '\0';
164
165	#elif defined(__gnu_linux__) \|\| defined(__linux__)
166	rc = readlink("/proc/self/exe", szTmp, GET_PATH_MAX - 1);
167	if (rc < 0 \|\| rc == GET_PATH_MAX - 1)
168	rc = -1;
169	else
170	szTmp[rc] = '\0';
171
172	#elif defined(__OS2__)
173	_execname(szTmp, GET_PATH_MAX);
174	rc = 0;
175
176	#elif defined(__sun__)
177	{
178	char szTmp2[64];
179	snprintf(szTmp2, sizeof(szTmp2), "/proc/%ld/path/a.out", (long)getpid());
180	rc = readlink(szTmp2, szTmp, GET_PATH_MAX - 1);
181	if (rc < 0 \|\| rc == GET_PATH_MAX - 1)
182	rc = -1;
183	else
184	szTmp[rc] = '\0';
185	}
186
187	#elif defined(WINDOWS32)
188	if (GetModuleFileName(GetModuleHandle(NULL), szTmp, GET_PATH_MAX))
189	rc = 0;
190
191	#endif
192
193	#if !defined(__OS2__) && !defined(WINDOWS32)
194	/* fallback, try use the path to locate the binary. */
195	if ( rc < 0
196	&& access(argv[0], X_OK))
197	{
198	size_t cchArgv0 = strlen(argv[0]);
199	const char *pszPath = getenv("PATH");
200	char *pszCopy = xstrdup(pszPath ? pszPath : ".");
201	char *psz = pszCopy;
202	while (*psz)
203	{
204	size_t cch;
205	char *pszEnd = strchr(psz, PATH_SEPARATOR_CHAR);
206	if (!pszEnd)
207	pszEnd = strchr(psz, '\0');
208	cch = pszEnd - psz;
209	if (cch + cchArgv0 + 2 <= GET_PATH_MAX)
210	{
211	memcpy(szTmp, psz, cch);
212	szTmp[cch] = '/';
213	memcpy(&szTmp[cch + 1], argv[0], cchArgv0 + 1);
214	if (!access(szTmp, X_OK))
215	{
216	rc = 0;
217	break;
218	}
219	}
220
221	/* next */
222	psz = pszEnd;
223	while (*psz == PATH_SEPARATOR_CHAR)
224	psz++;
225	}
226	free(pszCopy);
227	}
228	#endif
229
230	if (rc < 0)
231	g_pszExeName = argv[0];
232	else
233	g_pszExeName = xstrdup(szTmp);
234
235	(void)argc;
236	}
237
238
239	/**
240	* Wrapper that ensures correct starting_directory.
241	*/
242	static char my_abspath(const char pszIn, char *pszOut)
243	{
244	char pszSaved, pszRet;
245
246	pszSaved = starting_directory;
247	starting_directory = g_pszInitialCwd;
248	pszRet = abspath(pszIn, pszOut);
249	starting_directory = pszSaved;
250
251	return pszRet;
252	}
253
254
255	/**
256	* Determin the KBUILD_PATH value.
257	*
258	* @returns Pointer to static a buffer containing the value (consider it read-only).
259	*/
260	const char *get_kbuild_path(void)
261	{
262	static const char *s_pszPath = NULL;
263	if (!s_pszPath)
264	{
265	PATH_VAR(szTmpPath);
266	const char *pszEnvVar = getenv("KBUILD_PATH");
267	if ( !pszEnvVar
268	\|\| !my_abspath(pszEnvVar, szTmpPath))
269	{
270	pszEnvVar = getenv("PATH_KBUILD");
271	if ( !pszEnvVar
272	\|\| !my_abspath(pszEnvVar, szTmpPath))
273	{
274	#ifdef KBUILD_PATH
275	return s_pszPath = KBUILD_PATH;
276	#else
277	/* $(abspath $(KBUILD_BIN_PATH)/../..)*/
278	size_t cch = strlen(get_kbuild_bin_path());
279	char *pszTmp2 = alloca(cch + sizeof("/../.."));
280	strcat(strcpy(pszTmp2, get_kbuild_bin_path()), "/../..");
281	if (!my_abspath(pszTmp2, szTmpPath))
282	fatal(NILF, _("failed to determin KBUILD_PATH"));
283	#endif
284	}
285	}
286	s_pszPath = xstrdup(szTmpPath);
287	}
288	return s_pszPath;
289	}
290
291
292	/**
293	* Determin the KBUILD_BIN_PATH value.
294	*
295	* @returns Pointer to static a buffer containing the value (consider it read-only).
296	*/
297	const char *get_kbuild_bin_path(void)
298	{
299	static const char *s_pszPath = NULL;
300	if (!s_pszPath)
301	{
302	PATH_VAR(szTmpPath);
303
304	const char *pszEnvVar = getenv("KBUILD_BIN_PATH");
305	if ( !pszEnvVar
306	\|\| !my_abspath(pszEnvVar, szTmpPath))
307	{
308	pszEnvVar = getenv("PATH_KBUILD_BIN");
309	if ( !pszEnvVar
310	\|\| !my_abspath(pszEnvVar, szTmpPath))
311	{
312	#ifdef KBUILD_PATH
313	return s_pszPath = KBUILD_BIN_PATH;
314	#else
315	/* $(abspath $(dir $(ARGV0)).) */
316	size_t cch = strlen(g_pszExeName);
317	char *pszTmp2 = alloca(cch + sizeof("."));
318	char *pszSep = pszTmp2 + cch - 1;
319	memcpy(pszTmp2, g_pszExeName, cch);
320	# ifdef HAVE_DOS_PATHS
321	while (pszSep >= pszTmp2 && pszSep != '/' && pszSep != '\\' && *pszSep != ':')
322	# else
323	while (pszSep >= pszTmp2 && *pszSep != '/')
324	# endif
325	pszSep--;
326	if (pszSep >= pszTmp2)
327	strcpy(pszSep + 1, ".");
328	else
329	strcpy(pszTmp2, ".");
330
331	if (!my_abspath(pszTmp2, szTmpPath))
332	fatal(NILF, _("failed to determin KBUILD_BIN_PATH (pszTmp2=%s szTmpPath=%s)"), pszTmp2, szTmpPath);
333	#endif /* !KBUILD_PATH */
334	}
335	}
336	s_pszPath = xstrdup(szTmpPath);
337	}
338	return s_pszPath;
339	}
340
341
342	/**
343	* Determin the location of default kBuild shell.
344	*
345	* @returns Pointer to static a buffer containing the location (consider it read-only).
346	*/
347	const char *get_default_kbuild_shell(void)
348	{
349	static char *s_pszDefaultShell = NULL;
350	if (!s_pszDefaultShell)
351	{
352	#if defined(__OS2__) \|\| defined(_WIN32) \|\| defined(WINDOWS32)
353	static const char s_szShellName[] = "/kmk_ash.exe";
354	#else
355	static const char s_szShellName[] = "/kmk_ash";
356	#endif
357	const char *pszBin = get_kbuild_bin_path();
358	size_t cchBin = strlen(pszBin);
359	s_pszDefaultShell = xmalloc(cchBin + sizeof(s_szShellName));
360	memcpy(s_pszDefaultShell, pszBin, cchBin);
361	memcpy(&s_pszDefaultShell[cchBin], s_szShellName, sizeof(s_szShellName));
362	}
363	return s_pszDefaultShell;
364	}
365
366	#ifdef KMK_HELPERS
367
368	/**
369	* Applies the specified default path to any relative paths in *ppsz.
370	*
371	* @param pDefPath The default path.
372	* @param ppsz Pointer to the string pointer. If we expand anything, *ppsz
373	* will be replaced and the caller is responsible for calling free() on it.
374	* @param pcch IN: *pcch contains the current string length.
375	* OUT: *pcch contains the new string length.
376	* @param pcchAlloc *pcchAlloc contains the length allocated for the string. Can be NULL.
377	* @param fCanFree Whether *ppsz should be freed when we replace it.
378	*/
379	static void
380	kbuild_apply_defpath(struct variable pDefPath, char ppsz, unsigned int pcch, unsigned int *pcchAlloc, int fCanFree)
381	{
382	const char *pszIterator;
383	const char *pszInCur;
384	unsigned int cchInCur;
385	unsigned int cchMaxRelative = 0;
386	unsigned int cRelativePaths;
387
388	/*
389	* The first pass, count the relative paths.
390	*/
391	cRelativePaths = 0;
392	pszIterator = *ppsz;
393	while ((pszInCur = find_next_token(&pszIterator, &cchInCur)) != NULL)
394	{
395	/* is relative? */
396	#ifdef HAVE_DOS_PATHS
397	if (pszInCur[0] != '/' && pszInCur[0] != '\\' && (cchInCur < 2 \|\| pszInCur[1] != ':'))
398	#else
399	if (pszInCur[0] != '/')
400	#endif
401	{
402	cRelativePaths++;
403	if (cchInCur > cchMaxRelative)
404	cchMaxRelative = cchInCur;
405	}
406	}
407
408	/*
409	* The second pass construct the new string.
410	*/
411	if (cRelativePaths)
412	{
413	size_t const cchAbsPathBuf = MAX(GET_PATH_MAX, pDefPath->value_length + cchInCur + 1 + 16);
414	char pszAbsPathOut = (char )alloca(cchAbsPathBuf);
415	char pszAbsPathIn = (char )alloca(cchAbsPathBuf);
416	size_t cchAbsDefPath;
417	size_t cchOut;
418	char *pszOut;
419	char *pszOutCur;
420	const char pszInNextCopy = ppsz;
421
422	/* make defpath absolute and have a trailing slash first. */
423	if (abspath(pDefPath->value, pszAbsPathIn) == NULL)
424	memcpy(pszAbsPathIn, pDefPath->value, pDefPath->value_length);
425	cchAbsDefPath = strlen(pszAbsPathIn);
426	#ifdef HAVE_DOS_PATHS
427	if (pszAbsPathIn[cchAbsDefPath - 1] != '/' && pszAbsPathIn[cchAbsDefPath - 1] != '\\')
428	#else
429	if (pszAbsPathIn[cchAbsDefPath - 1] != '/')
430	#endif
431	pszAbsPathIn[cchAbsDefPath++] = '/';
432
433	cchOut = pcch + cRelativePaths cchAbsDefPath + 1;
434	pszOutCur = pszOut = xmalloc(cchOut);
435
436	cRelativePaths = 0;
437	pszIterator = *ppsz;
438	while ((pszInCur = find_next_token(&pszIterator, &cchInCur)))
439	{
440	/* is relative? */
441	#ifdef HAVE_DOS_PATHS
442	if (pszInCur[0] != '/' && pszInCur[0] != '\\' && (cchInCur < 2 \|\| pszInCur[1] != ':'))
443	#else
444	if (pszInCur[0] != '/')
445	#endif
446	{
447	const char *pszToCopy;
448	size_t cchToCopy;
449
450	/* Create the abspath input. */
451	memcpy(&pszAbsPathIn[cchAbsDefPath], pszInCur, cchInCur);
452	pszAbsPathIn[cchAbsDefPath + cchInCur] = '\0';
453
454	pszToCopy = abspath(pszAbsPathIn, pszAbsPathOut);
455	if (!pszToCopy)
456	pszToCopy = pszAbsPathIn;
457
458	/* copy leading input */
459	if (pszInCur != pszInNextCopy)
460	{
461	const size_t cchCopy = pszInCur - pszInNextCopy;
462	memcpy(pszOutCur, pszInNextCopy, cchCopy);
463	pszOutCur += cchCopy;
464	}
465	pszInNextCopy = pszInCur + cchInCur;
466
467	/* copy out the abspath. */
468	cchToCopy = strlen(pszToCopy);
469	assert(cchToCopy <= cchAbsDefPath + cchInCur);
470	memcpy(pszOutCur, pszToCopy, cchToCopy);
471	pszOutCur += cchToCopy;
472	}
473	/* else: Copy absolute paths as bulk when we hit then next relative one or the end. */
474	}
475
476	/* the final copy (includes the nil). */
477	cchInCur = ppsz + pcch - pszInNextCopy;
478	memcpy(pszOutCur, pszInNextCopy, cchInCur);
479	pszOutCur += cchInCur;
480	*pszOutCur = '\0';
481	assert((size_t)(pszOutCur - pszOut) < cchOut);
482
483	/* set return values */
484	if (fCanFree)
485	free(*ppsz);
486	*ppsz = pszOut;
487	*pcch = pszOutCur - pszOut;
488	if (pcchAlloc)
489	*pcchAlloc = cchOut;
490	}
491	}
492
493	/**
494	* Gets a variable that must exist.
495	* Will cause a fatal failure if the variable doesn't exist.
496	*
497	* @returns Pointer to the variable.
498	* @param pszName The variable name.
499	* @param cchName The name length.
500	*/
501	MY_INLINE struct variable *
502	kbuild_get_variable_n(const char *pszName, size_t cchName)
503	{
504	struct variable *pVar = lookup_variable(pszName, cchName);
505	if (!pVar)
506	fatal(NILF, _("variable `%.*s' isn't defined!"), (int)cchName, pszName);
507	if (pVar->recursive)
508	fatal(NILF, _("variable `%.*s' is defined as `recursive' instead of `simple'!"), (int)cchName, pszName);
509
510	MY_ASSERT_MSG(strlen(pVar->value) == pVar->value_length,
511	("%u != %u %.*s\n", pVar->value_length, (unsigned int)strlen(pVar->value), (int)cchName, pVar->name));
512	return pVar;
513	}
514
515
516	/**
517	* Gets a variable that must exist and can be recursive.
518	* Will cause a fatal failure if the variable doesn't exist.
519	*
520	* @returns Pointer to the variable.
521	* @param pszName The variable name.
522	*/
523	static struct variable *
524	kbuild_get_recursive_variable(const char *pszName)
525	{
526	struct variable *pVar = lookup_variable(pszName, strlen(pszName));
527	if (!pVar)
528	fatal(NILF, _("variable `%s' isn't defined!"), pszName);
529
530	MY_ASSERT_MSG(strlen(pVar->value) == pVar->value_length,
531	("%u != %u %s\n", pVar->value_length, (unsigned int)strlen(pVar->value), pVar->name));
532	return pVar;
533	}
534
535
536	/**
537	* Gets a variable that doesn't have to exit, but if it does can be recursive.
538	*
539	* @returns Pointer to the variable.
540	* NULL if not found.
541	* @param pszName The variable name. Doesn't need to be terminated.
542	* @param cchName The name length.
543	*/
544	static struct variable *
545	kbuild_query_recursive_variable_n(const char *pszName, size_t cchName)
546	{
547	struct variable *pVar = lookup_variable(pszName, cchName);
548	MY_ASSERT_MSG(!pVar \|\| strlen(pVar->value) == pVar->value_length,
549	("%u != %u %.*s\n", pVar->value_length, (unsigned int)strlen(pVar->value), (int)cchName, pVar->name));
550	return pVar;
551	}
552
553
554	/**
555	* Gets a variable that doesn't have to exit, but if it does can be recursive.
556	*
557	* @returns Pointer to the variable.
558	* NULL if not found.
559	* @param pszName The variable name.
560	*/
561	static struct variable *
562	kbuild_query_recursive_variable(const char *pszName)
563	{
564	return kbuild_query_recursive_variable_n(pszName, strlen(pszName));
565	}
566
567
568	/**
569	* Converts the specified variable into a 'simple' one.
570	* @returns pVar.
571	* @param pVar The variable.
572	*/
573	static struct variable *
574	kbuild_simplify_variable(struct variable *pVar)
575	{
576	if (memchr(pVar->value, '$', pVar->value_length))
577	{
578	unsigned int value_len;
579	char *pszExpanded = allocated_variable_expand_2(pVar->value, pVar->value_length, &value_len);
580	#ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
581	if (pVar->rdonly_val)
582	pVar->rdonly_val = 0;
583	else
584	#endif
585	free(pVar->value);
586	assert(pVar->origin != o_automatic);
587	pVar->value = pszExpanded;
588	pVar->value_length = value_len;
589	pVar->value_alloc_len = value_len + 1;
590	}
591	pVar->recursive = 0;
592	VARIABLE_CHANGED(pVar);
593	return pVar;
594	}
595
596
597	/**
598	* Looks up a variable.
599	* The value_length field is valid upon successful return.
600	*
601	* @returns Pointer to the variable. NULL if not found.
602	* @param pszName The variable name.
603	* @param cchName The name length.
604	*/
605	MY_INLINE struct variable *
606	kbuild_lookup_variable_n(const char *pszName, size_t cchName)
607	{
608	struct variable *pVar = lookup_variable(pszName, cchName);
609	if (pVar)
610	{
611	MY_ASSERT_MSG(strlen(pVar->value) == pVar->value_length,
612	("%u != %u %.*s\n", pVar->value_length, (unsigned int)strlen(pVar->value), (int)cchName, pVar->name));
613
614	/* Make sure the variable is simple, convert it if necessary. */
615	if (pVar->recursive)
616	kbuild_simplify_variable(pVar);
617	}
618	return pVar;
619	}
620
621
622	/**
623	* Looks up a variable.
624	* The value_length field is valid upon successful return.
625	*
626	* @returns Pointer to the variable. NULL if not found.
627	* @param pszName The variable name.
628	*/
629	MY_INLINE struct variable *
630	kbuild_lookup_variable(const char *pszName)
631	{
632	return kbuild_lookup_variable_n(pszName, strlen(pszName));
633	}
634
635
636	/**
637	* Looks up a variable and applies default a path to all relative paths.
638	* The value_length field is valid upon successful return.
639	*
640	* @returns Pointer to the variable. NULL if not found.
641	* @param pDefPath The default path.
642	* @param pszName The variable name.
643	* @param cchName The name length.
644	*/
645	MY_INLINE struct variable *
646	kbuild_lookup_variable_defpath_n(struct variable pDefPath, const char pszName, size_t cchName)
647	{
648	struct variable *pVar = kbuild_lookup_variable_n(pszName, cchName);
649	if (pVar && pDefPath)
650	{
651	assert(pVar->origin != o_automatic);
652	#ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
653	assert(!pVar->rdonly_val);
654	#endif
655	kbuild_apply_defpath(pDefPath, &pVar->value, &pVar->value_length, &pVar->value_alloc_len, 1);
656	}
657	return pVar;
658	}
659
660
661	/**
662	* Looks up a variable and applies default a path to all relative paths.
663	* The value_length field is valid upon successful return.
664	*
665	* @returns Pointer to the variable. NULL if not found.
666	* @param pDefPath The default path.
667	* @param pszName The variable name.
668	*/
669	MY_INLINE struct variable *
670	kbuild_lookup_variable_defpath(struct variable pDefPath, const char pszName)
671	{
672	struct variable *pVar = kbuild_lookup_variable(pszName);
673	if (pVar && pDefPath)
674	{
675	assert(pVar->origin != o_automatic);
676	#ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
677	assert(!pVar->rdonly_val);
678	#endif
679	kbuild_apply_defpath(pDefPath, &pVar->value, &pVar->value_length, &pVar->value_alloc_len, 1);
680	}
681	return pVar;
682	}
683
684
685	/**
686	* Gets the first defined property variable.
687	*/
688	static struct variable *
689	kbuild_first_prop(struct variable pTarget, struct variable pSource,
690	struct variable pTool, struct variable pType,
691	struct variable pBldTrg, struct variable pBldTrgArch,
692	const char *pszPropF1, char cchPropF1,
693	const char *pszPropF2, char cchPropF2,
694	const char *pszVarName)
695	{
696	struct variable *pVar;
697	size_t cchBuf;
698	char *pszBuf;
699	char psz, psz1, psz2, psz3, psz4, pszEnd;
700
701	/* calc and allocate a too big name buffer. */
702	cchBuf = cchPropF2 + 1
703	+ cchPropF1 + 1
704	+ pTarget->value_length + 1
705	+ pSource->value_length + 1
706	+ (pTool ? pTool->value_length + 1 : 0)
707	+ pType->value_length + 1
708	+ pBldTrg->value_length + 1
709	+ pBldTrgArch->value_length + 1;
710	pszBuf = xmalloc(cchBuf);
711
712	#define ADD_VAR(pVar) do { my_memcpy(psz, (pVar)->value, (pVar)->value_length); psz += (pVar)->value_length; } while (0)
713	#define ADD_STR(pszStr, cchStr) do { my_memcpy(psz, (pszStr), (cchStr)); psz += (cchStr); } while (0)
714	#define ADD_CSTR(pszStr) do { my_memcpy(psz, pszStr, sizeof(pszStr) - 1); psz += sizeof(pszStr) - 1; } while (0)
715	#define ADD_CH(ch) do { *psz++ = (ch); } while (0)
716
717	/*
718	* $(target)_$(source)_$(type)$(propf2).$(bld_trg).$(bld_trg_arch)
719	*/
720	psz = pszBuf;
721	ADD_VAR(pTarget);
722	ADD_CH('_');
723	ADD_VAR(pSource);
724	ADD_CH('_');
725	psz2 = psz;
726	ADD_VAR(pType);
727	ADD_STR(pszPropF2, cchPropF2);
728	psz3 = psz;
729	ADD_CH('.');
730	ADD_VAR(pBldTrg);
731	psz4 = psz;
732	ADD_CH('.');
733	ADD_VAR(pBldTrgArch);
734	pVar = kbuild_lookup_variable_n(pszBuf, psz - pszBuf);
735
736	/* $(target)_$(source)_$(type)$(propf2).$(bld_trg) */
737	if (!pVar)
738	pVar = kbuild_lookup_variable_n(pszBuf, psz4 - pszBuf);
739
740	/* $(target)_$(source)_$(type)$(propf2) */
741	if (!pVar)
742	pVar = kbuild_lookup_variable_n(pszBuf, psz3 - pszBuf);
743
744	/*
745	* $(target)_$(source)_$(propf2).$(bld_trg).$(bld_trg_arch)
746	*/
747	if (!pVar)
748	{
749	psz = psz2;
750	ADD_STR(pszPropF2, cchPropF2);
751	psz3 = psz;
752	ADD_CH('.');
753	ADD_VAR(pBldTrg);
754	psz4 = psz;
755	ADD_CH('.');
756	ADD_VAR(pBldTrgArch);
757	pVar = kbuild_lookup_variable_n(pszBuf, psz - pszBuf);
758
759	/* $(target)_$(source)_$(propf2).$(bld_trg) */
760	if (!pVar)
761	pVar = kbuild_lookup_variable_n(pszBuf, psz4 - pszBuf);
762
763	/* $(target)_$(source)_$(propf2) */
764	if (!pVar)
765	pVar = kbuild_lookup_variable_n(pszBuf, psz3 - pszBuf);
766	}
767
768
769	/*
770	* $(source)_$(type)$(propf2).$(bld_trg).$(bld_trg_arch)
771	*/
772	if (!pVar)
773	{
774	psz = pszBuf;
775	ADD_VAR(pSource);
776	ADD_CH('_');
777	psz2 = psz;
778	ADD_VAR(pType);
779	ADD_STR(pszPropF2, cchPropF2);
780	psz3 = psz;
781	ADD_CH('.');
782	ADD_VAR(pBldTrg);
783	psz4 = psz;
784	ADD_CH('.');
785	ADD_VAR(pBldTrgArch);
786	pVar = kbuild_lookup_variable_n(pszBuf, psz - pszBuf);
787
788	/* $(source)_$(type)$(propf2).$(bld_trg) */
789	if (!pVar)
790	pVar = kbuild_lookup_variable_n(pszBuf, psz4 - pszBuf);
791
792	/* $(source)_$(type)$(propf2) */
793	if (!pVar)
794	pVar = kbuild_lookup_variable_n(pszBuf, psz3 - pszBuf);
795
796	/*
797	* $(source)_$(propf2).$(bld_trg).$(bld_trg_arch)
798	*/
799	if (!pVar)
800	{
801	psz = psz2;
802	ADD_STR(pszPropF2, cchPropF2);
803	psz3 = psz;
804	ADD_CH('.');
805	ADD_VAR(pBldTrg);
806	psz4 = psz;
807	ADD_CH('.');
808	ADD_VAR(pBldTrgArch);
809	pVar = kbuild_lookup_variable_n(pszBuf, psz - pszBuf);
810
811	/* $(source)_$(propf2).$(bld_trg) */
812	if (!pVar)
813	pVar = kbuild_lookup_variable_n(pszBuf, psz4 - pszBuf);
814
815	/* $(source)_$(propf2) */
816	if (!pVar)
817	pVar = kbuild_lookup_variable_n(pszBuf, psz3 - pszBuf);
818	}
819	}
820
821	/*
822	* $(target)_$(type)$(propf2).$(bld_trg).$(bld_trg_arch)
823	*/
824	if (!pVar)
825	{
826	psz = pszBuf;
827	ADD_VAR(pTarget);
828	ADD_CH('_');
829	psz2 = psz;
830	ADD_VAR(pType);
831	ADD_STR(pszPropF2, cchPropF2);
832	psz3 = psz;
833	ADD_CH('.');
834	ADD_VAR(pBldTrg);
835	psz4 = psz;
836	ADD_CH('.');
837	ADD_VAR(pBldTrgArch);
838	pVar = kbuild_lookup_variable_n(pszBuf, psz - pszBuf);
839
840	/* $(target)_$(type)$(propf2).$(bld_trg) */
841	if (!pVar)
842	pVar = kbuild_lookup_variable_n(pszBuf, psz4 - pszBuf);
843
844	/* $(target)_$(type)$(propf2) */
845	if (!pVar)
846	pVar = kbuild_lookup_variable_n(pszBuf, psz3 - pszBuf);
847
848	/* $(target)_$(propf2).$(bld_trg).$(bld_trg_arch) */
849	if (!pVar)
850	{
851	psz = psz2;
852	ADD_STR(pszPropF2, cchPropF2);
853	psz3 = psz;
854	ADD_CH('.');
855	ADD_VAR(pBldTrg);
856	psz4 = psz;
857	ADD_CH('.');
858	ADD_VAR(pBldTrgArch);
859	pVar = kbuild_lookup_variable_n(pszBuf, psz - pszBuf);
860	}
861
862	/* $(target)_$(propf2).$(bld_trg) */
863	if (!pVar)
864	pVar = kbuild_lookup_variable_n(pszBuf, psz4 - pszBuf);
865
866	/* $(target)_$(propf2) */
867	if (!pVar)
868	pVar = kbuild_lookup_variable_n(pszBuf, psz3 - pszBuf);
869	}
870
871	/*
872	* TOOL_$(tool)_$(type)$(propf2).$(bld_trg).$(bld_trg_arch)
873	*/
874	if (!pVar && pTool)
875	{
876	psz = pszBuf;
877	ADD_CSTR("TOOL_");
878	ADD_VAR(pTool);
879	ADD_CH('_');
880	psz2 = psz;
881	ADD_VAR(pType);
882	ADD_STR(pszPropF2, cchPropF2);
883	psz3 = psz;
884	ADD_CH('.');
885	ADD_VAR(pBldTrg);
886	psz4 = psz;
887	ADD_CH('.');
888	ADD_VAR(pBldTrgArch);
889	pVar = kbuild_lookup_variable_n(pszBuf, psz - pszBuf);
890
891	/* TOOL_$(tool)_$(type)$(propf2).$(bld_trg) */
892	if (!pVar)
893	pVar = kbuild_lookup_variable_n(pszBuf, psz4 - pszBuf);
894
895	/* TOOL_$(tool)_$(type)$(propf2) */
896	if (!pVar)
897	pVar = kbuild_lookup_variable_n(pszBuf, psz3 - pszBuf);
898
899	/* TOOL_$(tool)_$(propf2).$(bld_trg).$(bld_trg_arch) */
900	if (!pVar)
901	{
902	psz = psz2;
903	ADD_STR(pszPropF2, cchPropF2);
904	psz3 = psz;
905	ADD_CH('.');
906	ADD_VAR(pBldTrg);
907	psz4 = psz;
908	ADD_CH('.');
909	ADD_VAR(pBldTrgArch);
910	pVar = kbuild_lookup_variable_n(pszBuf, psz - pszBuf);
911
912	/* TOOL_$(tool)_$(propf2).$(bld_trg) */
913	if (!pVar)
914	pVar = kbuild_lookup_variable_n(pszBuf, psz4 - pszBuf);
915
916	/* TOOL_$(tool)_$(propf2) */
917	if (!pVar)
918	pVar = kbuild_lookup_variable_n(pszBuf, psz3 - pszBuf);
919	}
920	}
921
922	/*
923	* $(type)$(propf1).$(bld_trg).$(bld_trg_arch)
924	*/
925	if (!pVar)
926	{
927	psz = pszBuf;
928	ADD_VAR(pType);
929	ADD_STR(pszPropF1, cchPropF1);
930	psz3 = psz;
931	ADD_CH('.');
932	ADD_VAR(pBldTrg);
933	psz4 = psz;
934	ADD_CH('.');
935	ADD_VAR(pBldTrgArch);
936	pVar = kbuild_lookup_variable_n(pszBuf, psz - pszBuf);
937
938	/* $(type)$(propf1).$(bld_trg) */
939	if (!pVar)
940	pVar = kbuild_lookup_variable_n(pszBuf, psz4 - pszBuf);
941
942	/* $(type)$(propf1) */
943	if (!pVar)
944	pVar = kbuild_lookup_variable_n(pszBuf, psz3 - pszBuf);
945
946	/*
947	* $(propf1).$(bld_trg).$(bld_trg_arch)
948	*/
949	if (!pVar)
950	{
951	psz1 = pszBuf + pType->value_length;
952	pVar = kbuild_lookup_variable_n(psz1, psz - psz1);
953
954	/* $(propf1).$(bld_trg) */
955	if (!pVar)
956	pVar = kbuild_lookup_variable_n(psz1, psz4 - psz1);
957
958	/* $(propf1) */
959	if (!pVar)
960	pVar = kbuild_lookup_variable_n(pszPropF1, cchPropF1);
961	}
962	}
963	free(pszBuf);
964	#undef ADD_VAR
965	#undef ADD_STR
966	#undef ADD_CSTR
967	#undef ADD_CH
968
969	if (pVar)
970	{
971	/* strip it */
972	psz = pVar->value;
973	pszEnd = psz + pVar->value_length;
974	while (isblank((unsigned char)*psz))
975	psz++;
976	while (pszEnd > psz && isblank((unsigned char)pszEnd[-1]))
977	pszEnd--;
978	if (pszEnd > psz)
979	{
980	char chSaved = *pszEnd;
981	*pszEnd = '\0';
982	pVar = define_variable_vl(pszVarName, strlen(pszVarName), psz, pszEnd - psz,
983	1 /* duplicate /, o_local, 0 / !recursive */);
984	*pszEnd = chSaved;
985	if (pVar)
986	return pVar;
987	}
988	}
989	return NULL;
990	}
991
992
993	/*
994	_SOURCE_TOOL = $(strip $(firstword \
995	$($(target)_$(source)_$(type)TOOL.$(bld_trg).$(bld_trg_arch)) \
996	$($(target)_$(source)_$(type)TOOL.$(bld_trg)) \
997	$($(target)_$(source)_$(type)TOOL) \
998	$($(target)_$(source)_TOOL.$(bld_trg).$(bld_trg_arch)) \
999	$($(target)_$(source)_TOOL.$(bld_trg)) \
1000	$($(target)_$(source)_TOOL) \
1001	$($(source)_$(type)TOOL.$(bld_trg).$(bld_trg_arch)) \
1002	$($(source)_$(type)TOOL.$(bld_trg)) \
1003	$($(source)_$(type)TOOL) \
1004	$($(source)_TOOL.$(bld_trg).$(bld_trg_arch)) \
1005	$($(source)_TOOL.$(bld_trg)) \
1006	$($(source)_TOOL) \
1007	$($(target)_$(type)TOOL.$(bld_trg).$(bld_trg_arch)) \
1008	$($(target)_$(type)TOOL.$(bld_trg)) \
1009	$($(target)_$(type)TOOL) \
1010	$($(target)_TOOL.$(bld_trg).$(bld_trg_arch)) \
1011	$($(target)_TOOL.$(bld_trg)) \
1012	$($(target)_TOOL) \
1013	$($(type)TOOL.$(bld_trg).$(bld_trg_arch)) \
1014	$($(type)TOOL.$(bld_trg)) \
1015	$($(type)TOOL) \
1016	$(TOOL.$(bld_trg).$(bld_trg_arch)) \
1017	$(TOOL.$(bld_trg)) \
1018	$(TOOL) ))
1019	*/
1020	static struct variable *
1021	kbuild_get_source_tool(struct variable pTarget, struct variable pSource, struct variable *pType,
1022	struct variable pBldTrg, struct variable pBldTrgArch, const char *pszVarName)
1023	{
1024	struct variable *pVar = kbuild_first_prop(pTarget, pSource, NULL, pType, pBldTrg, pBldTrgArch,
1025	"TOOL", sizeof("TOOL") - 1,
1026	"TOOL", sizeof("TOOL") - 1,
1027	pszVarName);
1028	if (!pVar)
1029	fatal(NILF, _("no tool for source `%s' in target `%s'!"), pSource->value, pTarget->value);
1030	return pVar;
1031	}
1032
1033
1034	/* Implements _SOURCE_TOOL. */
1035	char *
1036	func_kbuild_source_tool(char o, char argv, const char pszFuncName)
1037	{
1038	struct variable *pVar = kbuild_get_source_tool(kbuild_get_variable_n(ST("target")),
1039	kbuild_get_variable_n(ST("source")),
1040	kbuild_get_variable_n(ST("type")),
1041	kbuild_get_variable_n(ST("bld_trg")),
1042	kbuild_get_variable_n(ST("bld_trg_arch")),
1043	argv[0]);
1044	if (pVar)
1045	o = variable_buffer_output(o, pVar->value, pVar->value_length);
1046	(void)pszFuncName;
1047	return o;
1048
1049	}
1050
1051
1052	/* This has been extended a bit, it's now identical to _SOURCE_TOOL.
1053	$(firstword \
1054	$($(target)_$(source)_OBJSUFF.$(bld_trg).$(bld_trg_arch))\
1055	$($(target)_$(source)_OBJSUFF.$(bld_trg))\
1056	$($(target)_$(source)_OBJSUFF)\
1057	$($(source)_OBJSUFF.$(bld_trg).$(bld_trg_arch))\
1058	$($(source)_OBJSUFF.$(bld_trg))\
1059	$($(source)_OBJSUFF)\
1060	$($(target)_OBJSUFF.$(bld_trg).$(bld_trg_arch))\
1061	$($(target)_OBJSUFF.$(bld_trg))\
1062	$($(target)_OBJSUFF)\
1063	$(TOOL_$(tool)_$(type)OBJSUFF.$(bld_trg).$(bld_trg_arch))\
1064	$(TOOL_$(tool)_$(type)OBJSUFF.$(bld_trg))\
1065	$(TOOL_$(tool)_$(type)OBJSUFF)\
1066	$(SUFF_OBJ))
1067	*/
1068	static struct variable *
1069	kbuild_get_object_suffix(struct variable pTarget, struct variable pSource,
1070	struct variable pTool, struct variable pType,
1071	struct variable pBldTrg, struct variable pBldTrgArch, const char *pszVarName)
1072	{
1073	struct variable *pVar = kbuild_first_prop(pTarget, pSource, pTool, pType, pBldTrg, pBldTrgArch,
1074	"SUFF_OBJ", sizeof("SUFF_OBJ") - 1,
1075	"OBJSUFF", sizeof("OBJSUFF") - 1,
1076	pszVarName);
1077	if (!pVar)
1078	fatal(NILF, _("no OBJSUFF attribute or SUFF_OBJ default for source `%s' in target `%s'!"), pSource->value, pTarget->value);
1079	return pVar;
1080	}
1081
1082
1083	/* */
1084	char *
1085	func_kbuild_object_suffix(char o, char argv, const char pszFuncName)
1086	{
1087	struct variable *pVar = kbuild_get_object_suffix(kbuild_get_variable_n(ST("target")),
1088	kbuild_get_variable_n(ST("source")),
1089	kbuild_get_variable_n(ST("tool")),
1090	kbuild_get_variable_n(ST("type")),
1091	kbuild_get_variable_n(ST("bld_trg")),
1092	kbuild_get_variable_n(ST("bld_trg_arch")),
1093	argv[0]);
1094	if (pVar)
1095	o = variable_buffer_output(o, pVar->value, pVar->value_length);
1096	(void)pszFuncName;
1097	return o;
1098
1099	}
1100
1101
1102	/*
1103	## Figure out where to put object files.
1104	# @param $1 source file
1105	# @param $2 normalized main target
1106	# @remark There are two major hacks here:
1107	# 1. Source files in the output directory are translated into a gen/ subdir.
1108	# 2. Catch anyone specifying $(PATH_SUB_CURRENT)/sourcefile.c.
1109	_OBJECT_BASE = $(PATH_TARGET)/$(2)/$(call no-root-slash,$(call no-drive,$(basename \
1110	$(patsubst $(PATH_ROOT)/%,%,$(patsubst $(PATH_SUB_CURRENT)/%,%,$(patsubst $(PATH_TARGET)/$(2)/%,gen/%,$(1)))))))
1111	*/
1112	static struct variable *
1113	kbuild_get_object_base(struct variable pTarget, struct variable pSource, const char *pszVarName)
1114	{
1115	struct variable *pPathTarget = kbuild_get_variable_n(ST("PATH_TARGET"));
1116	struct variable *pPathRoot = kbuild_get_variable_n(ST("PATH_ROOT"));
1117	struct variable *pPathSubCur = kbuild_get_variable_n(ST("PATH_SUB_CURRENT"));
1118	const char *pszSrcPrefix = NULL;
1119	size_t cchSrcPrefix = 0;
1120	size_t cchSrc = 0;
1121	const char *pszSrcEnd;
1122	char *pszSrc;
1123	char *pszResult;
1124	char *psz;
1125	char *pszDot;
1126	size_t cch;
1127
1128	/*
1129	* Strip the source filename of any uncessary leading path and root specs.
1130	*/
1131	/* */
1132	if ( pSource->value_length > pPathTarget->value_length
1133	&& !strncmp(pSource->value, pPathTarget->value, pPathTarget->value_length))
1134	{
1135	pszSrc = pSource->value + pPathTarget->value_length;
1136	pszSrcPrefix = "gen/";
1137	cchSrcPrefix = sizeof("gen/") - 1;
1138	if ( *pszSrc == '/'
1139	&& !strncmp(pszSrc + 1, pTarget->value, pTarget->value_length)
1140	&& ( pszSrc[pTarget->value_length + 1] == '/'
1141	\|\| pszSrc[pTarget->value_length + 1] == '\0'))
1142	pszSrc += 1 + pTarget->value_length;
1143	}
1144	else if ( pSource->value_length > pPathRoot->value_length
1145	&& !strncmp(pSource->value, pPathRoot->value, pPathRoot->value_length))
1146	{
1147	pszSrc = pSource->value + pPathRoot->value_length;
1148	if ( *pszSrc == '/'
1149	&& !strncmp(pszSrc + 1, pPathSubCur->value, pPathSubCur->value_length)
1150	&& ( pszSrc[pPathSubCur->value_length + 1] == '/'
1151	\|\| pszSrc[pPathSubCur->value_length + 1] == '\0'))
1152	pszSrc += 1 + pPathSubCur->value_length;
1153	}
1154	else
1155	pszSrc = pSource->value;
1156
1157	/* skip root specification */
1158	#ifdef HAVE_DOS_PATHS
1159	if (isalpha(pszSrc[0]) && pszSrc[1] == ':')
1160	pszSrc += 2;
1161	#endif
1162	while (*pszSrc == '/'
1163	#ifdef HAVE_DOS_PATHS
1164	\|\| *pszSrc == '\\'
1165	#endif
1166	)
1167	pszSrc++;
1168
1169	/* drop the source extension. */
1170	pszSrcEnd = pSource->value + pSource->value_length;
1171	for (;;)
1172	{
1173	pszSrcEnd--;
1174	if ( pszSrcEnd <= pszSrc
1175	\|\| *pszSrcEnd == '/'
1176	#ifdef HAVE_DOS_PATHS
1177	\|\| *pszSrcEnd == '\\'
1178	\|\| *pszSrcEnd == ':'
1179	#endif
1180	)
1181	{
1182	pszSrcEnd = pSource->value + pSource->value_length;
1183	break;
1184	}
1185	if (*pszSrcEnd == '.')
1186	break;
1187	}
1188
1189	/*
1190	* Assemble the string on the heap and define the objbase variable
1191	* which we then return.
1192	*/
1193	cchSrc = pszSrcEnd - pszSrc;
1194	cch = pPathTarget->value_length
1195	+ 1 /* slash */
1196	+ pTarget->value_length
1197	+ 1 /* slash */
1198	+ cchSrcPrefix
1199	+ cchSrc
1200	+ 1;
1201	psz = pszResult = xmalloc(cch);
1202
1203	memcpy(psz, pPathTarget->value, pPathTarget->value_length); psz += pPathTarget->value_length;
1204	*psz++ = '/';
1205	memcpy(psz, pTarget->value, pTarget->value_length); psz += pTarget->value_length;
1206	*psz++ = '/';
1207	if (pszSrcPrefix)
1208	{
1209	memcpy(psz, pszSrcPrefix, cchSrcPrefix);
1210	psz += cchSrcPrefix;
1211	}
1212	pszDot = psz;
1213	memcpy(psz, pszSrc, cchSrc); psz += cchSrc;
1214	*psz = '\0';
1215
1216	/* convert '..' path elements in the source to 'dt'. */
1217	while ((pszDot = memchr(pszDot, '.', psz - pszDot)) != NULL)
1218	{
1219	if ( pszDot[1] == '.'
1220	&& ( pszDot == psz
1221	\|\| pszDot[-1] == '/'
1222	#ifdef HAVE_DOS_PATHS
1223	\|\| pszDot[-1] == '\\'
1224	\|\| pszDot[-1] == ':'
1225	#endif
1226	)
1227	&& ( !pszDot[2]
1228	\|\| pszDot[2] == '/'
1229	#ifdef HAVE_DOS_PATHS
1230	\|\| pszDot[2] == '\\'
1231	\|\| pszDot[2] == ':'
1232	#endif
1233	)
1234	)
1235	{
1236	*pszDot++ = 'd';
1237	*pszDot++ = 't';
1238	}
1239	else
1240	pszDot++;
1241	}
1242
1243	/*
1244	* Define the variable in the current set and return it.
1245	*/
1246	return define_variable_vl(pszVarName, strlen(pszVarName), pszResult, cch - 1,
1247	0 /* use pszResult /, o_local, 0 / !recursive */);
1248	}
1249
1250
1251	/* Implements _OBJECT_BASE. */
1252	char *
1253	func_kbuild_object_base(char o, char argv, const char pszFuncName)
1254	{
1255	struct variable *pVar = kbuild_get_object_base(kbuild_lookup_variable("target"),
1256	kbuild_lookup_variable("source"),
1257	argv[0]);
1258	if (pVar)
1259	o = variable_buffer_output(o, pVar->value, pVar->value_length);
1260	(void)pszFuncName;
1261	return o;
1262
1263	}
1264
1265
1266	struct kbuild_sdks
1267	{
1268	char *apsz[4];
1269	struct variable *pa;
1270	unsigned c;
1271	unsigned iGlobal;
1272	unsigned cGlobal;
1273	unsigned iTarget;
1274	unsigned cTarget;
1275	unsigned iSource;
1276	unsigned cSource;
1277	unsigned iTargetSource;
1278	unsigned cTargetSource;
1279	unsigned int cchMax;
1280	};
1281
1282
1283	/* Fills in the SDK struct (remember to free it). */
1284	static void
1285	kbuild_get_sdks(struct kbuild_sdks pSdks, struct variable pTarget, struct variable *pSource,
1286	struct variable pBldType, struct variable pBldTrg, struct variable *pBldTrgArch)
1287	{
1288	unsigned i;
1289	unsigned j;
1290	size_t cchTmp, cch;
1291	char *pszTmp;
1292	unsigned cchCur;
1293	char *pszCur;
1294	const char *pszIterator;
1295
1296	/** @todo rewrite this to avoid sprintf and allocated_varaible_expand_2. */
1297
1298	/* basic init. */
1299	pSdks->cchMax = 0;
1300	pSdks->pa = NULL;
1301	pSdks->c = 0;
1302	i = 0;
1303
1304	/* determin required tmp variable name space. */
1305	cchTmp = sizeof("$(__SDKS) $(__SDKS.) $(__SDKS.) $(__SDKS.) $(__SDKS..)")
1306	+ (pTarget->value_length + pSource->value_length) * 5
1307	+ pBldType->value_length
1308	+ pBldTrg->value_length
1309	+ pBldTrgArch->value_length
1310	+ pBldTrg->value_length + pBldTrgArch->value_length;
1311	pszTmp = alloca(cchTmp);
1312
1313	/* the global sdks. */
1314	pSdks->iGlobal = i;
1315	pSdks->cGlobal = 0;
1316	cch = sprintf(pszTmp, "$(SDKS) $(SDKS.%s) $(SDKS.%s) $(SDKS.%s) $(SDKS.%s.%s)",
1317	pBldType->value,
1318	pBldTrg->value,
1319	pBldTrgArch->value,
1320	pBldTrg->value, pBldTrgArch->value);
1321	pszIterator = pSdks->apsz[0] = allocated_variable_expand_2(pszTmp, cch, NULL);
1322	while ((pszCur = find_next_token(&pszIterator, &cchCur)) != 0)
1323	pSdks->cGlobal++;
1324	i += pSdks->cGlobal;
1325
1326	/* the target sdks.*/
1327	pSdks->iTarget = i;
1328	pSdks->cTarget = 0;
1329	cch = sprintf(pszTmp, "$(%s_SDKS) $(%s_SDKS.%s) $(%s_SDKS.%s) $(%s_SDKS.%s) $(%s_SDKS.%s.%s)",
1330	pTarget->value,
1331	pTarget->value, pBldType->value,
1332	pTarget->value, pBldTrg->value,
1333	pTarget->value, pBldTrgArch->value,
1334	pTarget->value, pBldTrg->value, pBldTrgArch->value);
1335	pszIterator = pSdks->apsz[1] = allocated_variable_expand_2(pszTmp, cch, NULL);
1336	while ((pszCur = find_next_token(&pszIterator, &cchCur)) != 0)
1337	pSdks->cTarget++;
1338	i += pSdks->cTarget;
1339
1340	/* the source sdks.*/
1341	pSdks->iSource = i;
1342	pSdks->cSource = 0;
1343	cch = sprintf(pszTmp, "$(%s_SDKS) $(%s_SDKS.%s) $(%s_SDKS.%s) $(%s_SDKS.%s) $(%s_SDKS.%s.%s)",
1344	pSource->value,
1345	pSource->value, pBldType->value,
1346	pSource->value, pBldTrg->value,
1347	pSource->value, pBldTrgArch->value,
1348	pSource->value, pBldTrg->value, pBldTrgArch->value);
1349	pszIterator = pSdks->apsz[2] = allocated_variable_expand_2(pszTmp, cch, NULL);
1350	while ((pszCur = find_next_token(&pszIterator, &cchCur)) != 0)
1351	pSdks->cSource++;
1352	i += pSdks->cSource;
1353
1354	/* the target + source sdks. */
1355	pSdks->iTargetSource = i;
1356	pSdks->cTargetSource = 0;
1357	cch = sprintf(pszTmp, "$(%s_%s_SDKS) $(%s_%s_SDKS.%s) $(%s_%s_SDKS.%s) $(%s_%s_SDKS.%s) $(%s_%s_SDKS.%s.%s)",
1358	pTarget->value, pSource->value,
1359	pTarget->value, pSource->value, pBldType->value,
1360	pTarget->value, pSource->value, pBldTrg->value,
1361	pTarget->value, pSource->value, pBldTrgArch->value,
1362	pTarget->value, pSource->value, pBldTrg->value, pBldTrgArch->value);
1363	assert(cch < cchTmp); (void)cch;
1364	pszIterator = pSdks->apsz[3] = allocated_variable_expand_2(pszTmp, cch, NULL);
1365	while ((pszCur = find_next_token(&pszIterator, &cchCur)) != 0)
1366	pSdks->cTargetSource++;
1367	i += pSdks->cTargetSource;
1368
1369	pSdks->c = i;
1370	if (!i)
1371	return;
1372
1373	/*
1374	* Allocate the variable array and create the variables.
1375	*/
1376	pSdks->pa = (struct variable )xmalloc(sizeof(pSdks->pa[0]) i);
1377	memset(pSdks->pa, 0, sizeof(pSdks->pa[0]) * i);
1378	for (i = j = 0; j < sizeof(pSdks->apsz) / sizeof(pSdks->apsz[0]); j++)
1379	{
1380	pszIterator = pSdks->apsz[j];
1381	while ((pszCur = find_next_token(&pszIterator, &cchCur)) != 0)
1382	{
1383	pSdks->pa[i].value = pszCur;
1384	pSdks->pa[i].value_length = cchCur;
1385	i++;
1386	}
1387	}
1388	assert(i == pSdks->c);
1389
1390	/* terminate them (find_next_token won't work if we terminate them in the previous loop). */
1391	while (i-- > 0)
1392	{
1393	pSdks->pa[i].value[pSdks->pa[i].value_length] = '\0';
1394
1395	/* calc the max variable length too. */
1396	if (pSdks->cchMax < (unsigned int)pSdks->pa[i].value_length)
1397	pSdks->cchMax = pSdks->pa[i].value_length;
1398	}
1399	}
1400
1401
1402	/* releases resources allocated in the kbuild_get_sdks. */
1403	static void
1404	kbuild_put_sdks(struct kbuild_sdks *pSdks)
1405	{
1406	unsigned j;
1407	for (j = 0; j < sizeof(pSdks->apsz) / sizeof(pSdks->apsz[0]); j++)
1408	free(pSdks->apsz[j]);
1409	free(pSdks->pa);
1410	}
1411
1412
1413	/* this kind of stuff:
1414
1415	defs := $(kb-src-exp defs)
1416	$(TOOL_$(tool)_DEFS)\
1417	$(TOOL_$(tool)_DEFS.$(bld_type))\
1418	$(TOOL_$(tool)_DEFS.$(bld_trg))\
1419	$(TOOL_$(tool)_DEFS.$(bld_trg_arch))\
1420	$(TOOL_$(tool)_DEFS.$(bld_trg).$(bld_trg_arch))\
1421	$(TOOL_$(tool)_DEFS.$(bld_trg_cpu))\
1422	$(TOOL_$(tool)_$(type)DEFS)\
1423	$(TOOL_$(tool)_$(type)DEFS.$(bld_type))\
1424	$(foreach sdk, $(SDKS.$(bld_trg)) \
1425	$(SDKS.$(bld_trg).$(bld_trg_arch)) \
1426	$(SDKS.$(bld_type)) \
1427	$(SDKS),\
1428	$(SDK_$(sdk)_DEFS)\
1429	$(SDK_$(sdk)_DEFS.$(bld_type))\
1430	$(SDK_$(sdk)_DEFS.$(bld_trg))\
1431	$(SDK_$(sdk)_DEFS.$(bld_trg_arch))\
1432	$(SDK_$(sdk)_DEFS.$(bld_trg).$(bld_trg_arch))\
1433	$(SDK_$(sdk)_DEFS.$(bld_trg_cpu))\
1434	$(SDK_$(sdk)_$(type)DEFS)\
1435	$(SDK_$(sdk)_$(type)DEFS.$(bld_type))\
1436	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg))\
1437	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg_arch))\
1438	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg).$(bld_trg_arch))\
1439	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg_cpu)))\
1440	$(DEFS)\
1441	$(DEFS.$(bld_type))\
1442	$(DEFS.$(bld_trg))\
1443	$(DEFS.$(bld_trg_arch))\
1444	$(DEFS.$(bld_trg).$(bld_trg_arch))\
1445	$(DEFS.$(bld_trg_cpu))\
1446	$($(type)DEFS)\
1447	$($(type)DEFS.$(bld_type))\
1448	$($(type)DEFS.$(bld_trg))\
1449	$($(type)DEFS.$(bld_trg_arch))\
1450	$($(type)DEFS.$(bld_trg).$(bld_trg_arch))\
1451	$($(type)DEFS.$(bld_trg_cpu))\
1452	$(foreach sdk, $($(target)_SDKS.$(bld_trg)) \
1453	$($(target)_SDKS.$(bld_trg).$(bld_trg_arch)) \
1454	$($(target)_SDKS.$(bld_type)) \
1455	$($(target)_SDKS),\
1456	$(SDK_$(sdk)_DEFS)\
1457	$(SDK_$(sdk)_DEFS.$(bld_type))\
1458	$(SDK_$(sdk)_DEFS.$(bld_trg))\
1459	$(SDK_$(sdk)_DEFS.$(bld_trg_arch))\
1460	$(SDK_$(sdk)_DEFS.$(bld_trg).$(bld_trg_arch))\
1461	$(SDK_$(sdk)_DEFS.$(bld_trg_cpu))\
1462	$(SDK_$(sdk)_$(type)DEFS)\
1463	$(SDK_$(sdk)_$(type)DEFS.$(bld_type))\
1464	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg))\
1465	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg_arch))\
1466	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg).$(bld_trg_arch))\
1467	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg_cpu)))\
1468	$($(target)_DEFS)\
1469	$($(target)_DEFS.$(bld_type))\
1470	$($(target)_DEFS.$(bld_trg))\
1471	$($(target)_DEFS.$(bld_trg_arch))\
1472	$($(target)_DEFS.$(bld_trg).$(bld_trg_arch))\
1473	$($(target)_DEFS.$(bld_trg_cpu))\
1474	$($(target)_$(type)DEFS)\
1475	$($(target)_$(type)DEFS.$(bld_type))\
1476	$($(target)_$(type)DEFS.$(bld_trg))\
1477	$($(target)_$(type)DEFS.$(bld_trg_arch))\
1478	$($(target)_$(type)DEFS.$(bld_trg).$(bld_trg_arch))\
1479	$($(target)_$(type)DEFS.$(bld_trg_cpu))\
1480	$(foreach sdk, $($(source)_SDKS.$(bld_trg)) \
1481	$($(source)_SDKS.$(bld_trg).$(bld_trg_arch)) \
1482	$($(source)_SDKS.$(bld_type)) \
1483	$($(source)_SDKS),\
1484	$(SDK_$(sdk)_DEFS)\
1485	$(SDK_$(sdk)_DEFS.$(bld_type))\
1486	$(SDK_$(sdk)_DEFS.$(bld_trg))\
1487	$(SDK_$(sdk)_DEFS.$(bld_trg_arch))\
1488	$(SDK_$(sdk)_DEFS.$(bld_trg).$(bld_trg_arch))\
1489	$(SDK_$(sdk)_DEFS.$(bld_trg_cpu))\
1490	$(SDK_$(sdk)_$(type)DEFS)\
1491	$(SDK_$(sdk)_$(type)DEFS.$(bld_type))\
1492	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg))\
1493	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg_arch))\
1494	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg).$(bld_trg_arch))\
1495	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg_cpu)))\
1496	$($(source)_DEFS)\
1497	$($(source)_DEFS.$(bld_type))\
1498	$($(source)_DEFS.$(bld_trg))\
1499	$($(source)_DEFS.$(bld_trg_arch))\
1500	$($(source)_DEFS.$(bld_trg).$(bld_trg_arch))\
1501	$($(source)_DEFS.$(bld_trg_cpu))\
1502	$($(source)_$(type)DEFS)\
1503	$($(source)_$(type)DEFS.$(bld_type))\
1504	$($(source)_$(type)DEFS.$(bld_trg))\
1505	$($(source)_$(type)DEFS.$(bld_trg_arch))\
1506	$($(source)_$(type)DEFS.$(bld_trg).$(bld_trg_arch))\
1507	$($(source)_$(type)DEFS.$(bld_trg_cpu))\
1508	$(foreach sdk, $($(target)_$(source)_SDKS.$(bld_trg)) \
1509	$($(target)_$(source)_SDKS.$(bld_trg).$(bld_trg_arch)) \
1510	$($(target)_$(source)_SDKS.$(bld_type)) \
1511	$($(target)_$(source)_SDKS),\
1512	$(SDK_$(sdk)_DEFS)\
1513	$(SDK_$(sdk)_DEFS.$(bld_type))\
1514	$(SDK_$(sdk)_DEFS.$(bld_trg))\
1515	$(SDK_$(sdk)_DEFS.$(bld_trg_arch))\
1516	$(SDK_$(sdk)_DEFS.$(bld_trg).$(bld_trg_arch))\
1517	$(SDK_$(sdk)_DEFS.$(bld_trg_cpu))\
1518	$(SDK_$(sdk)_$(type)DEFS)\
1519	$(SDK_$(sdk)_$(type)DEFS.$(bld_type))\
1520	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg))\
1521	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg_arch))\
1522	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg).$(bld_trg_arch))\
1523	$(SDK_$(sdk)_$(type)DEFS.$(bld_trg_cpu)))\
1524	$($(target)_$(source)_DEFS)\
1525	$($(target)_$(source)_DEFS.$(bld_type))\
1526	$($(target)_$(source)_DEFS.$(bld_trg))\
1527	$($(target)_$(source)_DEFS.$(bld_trg_arch))\
1528	$($(target)_$(source)_DEFS.$(bld_trg).$(bld_trg_arch))\
1529	$($(target)_$(source)_DEFS.$(bld_trg_cpu))\
1530	$($(target)_$(source)_$(type)DEFS)\
1531	$($(target)_$(source)_$(type)DEFS.$(bld_type))\
1532	$($(target)_$(source)_$(type)DEFS.$(bld_trg))\
1533	$($(target)_$(source)_$(type)DEFS.$(bld_trg_arch))\
1534	$($(target)_$(source)_$(type)DEFS.$(bld_trg).$(bld_trg_arch))\
1535	$($(target)_$(source)_$(type)DEFS.$(bld_trg_cpu))
1536	*/
1537	static struct variable *
1538	kbuild_collect_source_prop(struct variable pTarget, struct variable pSource,
1539	struct variable pTool, struct kbuild_sdks pSdks,
1540	struct variable pType, struct variable pBldType,
1541	struct variable pBldTrg, struct variable pBldTrgArch, struct variable *pBldTrgCpu,
1542	struct variable *pDefPath,
1543	const char *pszProp, size_t cchProp,
1544	const char *pszVarName, size_t cchVarName,
1545	int iDirection)
1546	{
1547	struct variable *pVar;
1548	unsigned iSdk, iSdkEnd;
1549	int cVars, iVar;
1550	size_t cchTotal, cchBuf;
1551	char pszResult, pszBuf, psz, psz2, *psz3;
1552	struct
1553	{
1554	struct variable *pVar;
1555	unsigned int cchExp;
1556	char *pszExp;
1557	} *paVars;
1558
1559	assert(iDirection == 1 \|\| iDirection == -1);
1560
1561	/*
1562	* Calc and allocate a too big name buffer.
1563	*/
1564	cchBuf = cchProp + 1
1565	+ pTarget->value_length + 1
1566	+ pSource->value_length + 1
1567	+ pSdks->cchMax + 1
1568	+ (pTool ? pTool->value_length + 1 : 0)
1569	+ pType->value_length + 1
1570	+ pBldTrg->value_length + 1
1571	+ pBldTrgArch->value_length + 1
1572	+ pBldTrgCpu->value_length + 1
1573	+ pBldType->value_length + 1;
1574	pszBuf = xmalloc(cchBuf);
1575
1576	/*
1577	* Get the variables.
1578	*
1579	* The compiler will get a heart attack when it sees this code ... ;-)
1580	*/
1581	cVars = 12 * (pSdks->c + 5);
1582	paVars = alloca(cVars * sizeof(paVars[0]));
1583
1584	iVar = 0;
1585	cchTotal = 0;
1586
1587	#define ADD_VAR(pVar) do { my_memcpy(psz, (pVar)->value, (pVar)->value_length); psz += (pVar)->value_length; } while (0)
1588	#define ADD_STR(pszStr, cchStr) do { my_memcpy(psz, (pszStr), (cchStr)); psz += (cchStr); } while (0)
1589	#define ADD_CSTR(pszStr) do { my_memcpy(psz, pszStr, sizeof(pszStr) - 1); psz += sizeof(pszStr) - 1; } while (0)
1590	#define ADD_CH(ch) do { *psz++ = (ch); } while (0)
1591	#define DO_VAR_LOOKUP() \
1592	do { \
1593	pVar = kbuild_lookup_variable_n(pszBuf, psz - pszBuf); \
1594	if (pVar) \
1595	{ \
1596	paVars[iVar].pVar = pVar; \
1597	if ( !pVar->recursive \
1598	\|\| IS_VARIABLE_RECURSIVE_WITHOUT_DOLLAR(pVar)) \
1599	{ \
1600	paVars[iVar].pszExp = pVar->value; \
1601	paVars[iVar].cchExp = pVar->value_length; \
1602	if (pDefPath && paVars[iVar].cchExp) \
1603	kbuild_apply_defpath(pDefPath, &paVars[iVar].pszExp, &paVars[iVar].cchExp, NULL, 0); \
1604	if (paVars[iVar].cchExp) \
1605	{ \
1606	cchTotal += paVars[iVar].cchExp + 1; \
1607	iVar++; \
1608	} \
1609	} \
1610	else \
1611	{ \
1612	paVars[iVar].pszExp = allocated_variable_expand_2(pVar->value, pVar->value_length, &paVars[iVar].cchExp); \
1613	if (pDefPath && paVars[iVar].cchExp) \
1614	kbuild_apply_defpath(pDefPath, &paVars[iVar].pszExp, &paVars[iVar].cchExp, NULL, 1); \
1615	if (paVars[iVar].cchExp) \
1616	{ \
1617	cchTotal += paVars[iVar].cchExp + 1; \
1618	iVar++; \
1619	} \
1620	else \
1621	free(paVars[iVar].pszExp); \
1622	} \
1623	} \
1624	} while (0)
1625	#define DO_SINGLE_PSZ3_VARIATION() \
1626	do { \
1627	DO_VAR_LOOKUP(); \
1628	\
1629	ADD_CH('.'); \
1630	psz3 = psz; \
1631	ADD_VAR(pBldType); \
1632	DO_VAR_LOOKUP(); \
1633	\
1634	psz = psz3; \
1635	ADD_VAR(pBldTrg); \
1636	DO_VAR_LOOKUP(); \
1637	\
1638	psz = psz3; \
1639	ADD_VAR(pBldTrgArch); \
1640	DO_VAR_LOOKUP(); \
1641	\
1642	psz = psz3; \
1643	ADD_VAR(pBldTrg); \
1644	ADD_CH('.'); \
1645	ADD_VAR(pBldTrgArch); \
1646	DO_VAR_LOOKUP(); \
1647	\
1648	psz = psz3; \
1649	ADD_VAR(pBldTrgCpu); \
1650	DO_VAR_LOOKUP(); \
1651	} while (0)
1652
1653	#define DO_DOUBLE_PSZ2_VARIATION() \
1654	do { \
1655	psz2 = psz; \
1656	ADD_STR(pszProp, cchProp); \
1657	DO_SINGLE_PSZ3_VARIATION(); \
1658	\
1659	/* add prop before type */ \
1660	psz = psz2; \
1661	ADD_VAR(pType); \
1662	ADD_STR(pszProp, cchProp); \
1663	DO_SINGLE_PSZ3_VARIATION(); \
1664	} while (0)
1665
1666	/* the tool (lowest priority). */
1667	psz = pszBuf;
1668	ADD_CSTR("TOOL_");
1669	ADD_VAR(pTool);
1670	ADD_CH('_');
1671	DO_DOUBLE_PSZ2_VARIATION();
1672
1673
1674	/* the global sdks. */
1675	iSdkEnd = iDirection == 1 ? pSdks->iGlobal + pSdks->cGlobal : pSdks->iGlobal - 1;
1676	for (iSdk = iDirection == 1 ? pSdks->iGlobal : pSdks->iGlobal + pSdks->cGlobal - 1;
1677	iSdk != iSdkEnd;
1678	iSdk += iDirection)
1679	{
1680	struct variable *pSdk = &pSdks->pa[iSdk];
1681	psz = pszBuf;
1682	ADD_CSTR("SDK_");
1683	ADD_VAR(pSdk);
1684	ADD_CH('_');
1685	DO_DOUBLE_PSZ2_VARIATION();
1686	}
1687
1688	/* the globals. */
1689	psz = pszBuf;
1690	DO_DOUBLE_PSZ2_VARIATION();
1691
1692
1693	/* the target sdks. */
1694	iSdkEnd = iDirection == 1 ? pSdks->iTarget + pSdks->cTarget : pSdks->iTarget - 1;
1695	for (iSdk = iDirection == 1 ? pSdks->iTarget : pSdks->iTarget + pSdks->cTarget - 1;
1696	iSdk != iSdkEnd;
1697	iSdk += iDirection)
1698	{
1699	struct variable *pSdk = &pSdks->pa[iSdk];
1700	psz = pszBuf;
1701	ADD_CSTR("SDK_");
1702	ADD_VAR(pSdk);
1703	ADD_CH('_');
1704	DO_DOUBLE_PSZ2_VARIATION();
1705	}
1706
1707	/* the target. */
1708	psz = pszBuf;
1709	ADD_VAR(pTarget);
1710	ADD_CH('_');
1711	DO_DOUBLE_PSZ2_VARIATION();
1712
1713	/* the source sdks. */
1714	iSdkEnd = iDirection == 1 ? pSdks->iSource + pSdks->cSource : pSdks->iSource - 1;
1715	for (iSdk = iDirection == 1 ? pSdks->iSource : pSdks->iSource + pSdks->cSource - 1;
1716	iSdk != iSdkEnd;
1717	iSdk += iDirection)
1718	{
1719	struct variable *pSdk = &pSdks->pa[iSdk];
1720	psz = pszBuf;
1721	ADD_CSTR("SDK_");
1722	ADD_VAR(pSdk);
1723	ADD_CH('_');
1724	DO_DOUBLE_PSZ2_VARIATION();
1725	}
1726
1727	/* the source. */
1728	psz = pszBuf;
1729	ADD_VAR(pSource);
1730	ADD_CH('_');
1731	DO_DOUBLE_PSZ2_VARIATION();
1732
1733	/* the target + source sdks. */
1734	iSdkEnd = iDirection == 1 ? pSdks->iTargetSource + pSdks->cTargetSource : pSdks->iTargetSource - 1;
1735	for (iSdk = iDirection == 1 ? pSdks->iTargetSource : pSdks->iTargetSource + pSdks->cTargetSource - 1;
1736	iSdk != iSdkEnd;
1737	iSdk += iDirection)
1738	{
1739	struct variable *pSdk = &pSdks->pa[iSdk];
1740	psz = pszBuf;
1741	ADD_CSTR("SDK_");
1742	ADD_VAR(pSdk);
1743	ADD_CH('_');
1744	DO_DOUBLE_PSZ2_VARIATION();
1745	}
1746
1747	/* the target + source. */
1748	psz = pszBuf;
1749	ADD_VAR(pTarget);
1750	ADD_CH('_');
1751	ADD_VAR(pSource);
1752	ADD_CH('_');
1753	DO_DOUBLE_PSZ2_VARIATION();
1754
1755	free(pszBuf);
1756
1757	assert(iVar <= cVars);
1758	cVars = iVar;
1759
1760	/*
1761	* Construct the result value.
1762	*/
1763	if (!cVars \|\| !cchTotal)
1764	pVar = define_variable_vl(pszVarName, cchVarName, "", 0,
1765	1 /* duplicate value / , o_local, 0 / !recursive */);
1766	else
1767	{
1768	psz = pszResult = xmalloc(cchTotal + 1);
1769	if (iDirection == 1)
1770	{
1771	for (iVar = 0; iVar < cVars; iVar++)
1772	{
1773	my_memcpy(psz, paVars[iVar].pszExp, paVars[iVar].cchExp);
1774	psz += paVars[iVar].cchExp;
1775	*psz++ = ' ';
1776	if (paVars[iVar].pszExp != paVars[iVar].pVar->value)
1777	free(paVars[iVar].pszExp);
1778	}
1779	}
1780	else
1781	{
1782	iVar = cVars;
1783	while (iVar-- > 0)
1784	{
1785	my_memcpy(psz, paVars[iVar].pszExp, paVars[iVar].cchExp);
1786	psz += paVars[iVar].cchExp;
1787	*psz++ = ' ';
1788	if (paVars[iVar].pszExp != paVars[iVar].pVar->value)
1789	free(paVars[iVar].pszExp);
1790	}
1791
1792	}
1793	assert(psz != pszResult);
1794	assert(cchTotal == (size_t)(psz - pszResult));
1795	psz[-1] = '\0';
1796	cchTotal--;
1797
1798	pVar = define_variable_vl(pszVarName, cchVarName, pszResult, cchTotal,
1799	0 /* take pszResult / , o_local, 0 / !recursive */);
1800	}
1801
1802	return pVar;
1803
1804	#undef ADD_VAR
1805	#undef ADD_STR
1806	#undef ADD_CSTR
1807	#undef ADD_CH
1808	#undef DO_VAR_LOOKUP
1809	#undef DO_DOUBLE_PSZ2_VARIATION
1810	#undef DO_SINGLE_PSZ3_VARIATION
1811	}
1812
1813
1814	/* get a source property. */
1815	char *
1816	func_kbuild_source_prop(char o, char argv, const char pszFuncName)
1817	{
1818	struct variable *pTarget = kbuild_get_variable_n(ST("target"));
1819	struct variable *pSource = kbuild_get_variable_n(ST("source"));
1820	struct variable *pDefPath = NULL;
1821	struct variable *pType = kbuild_get_variable_n(ST("type"));
1822	struct variable *pTool = kbuild_get_variable_n(ST("tool"));
1823	struct variable *pBldType = kbuild_get_variable_n(ST("bld_type"));
1824	struct variable *pBldTrg = kbuild_get_variable_n(ST("bld_trg"));
1825	struct variable *pBldTrgArch = kbuild_get_variable_n(ST("bld_trg_arch"));
1826	struct variable *pBldTrgCpu = kbuild_get_variable_n(ST("bld_trg_cpu"));
1827	struct variable *pVar;
1828	struct kbuild_sdks Sdks;
1829	int iDirection;
1830	if (!strcmp(argv[2], "left-to-right"))
1831	iDirection = 1;
1832	else if (!strcmp(argv[2], "right-to-left"))
1833	iDirection = -1;
1834	else
1835	fatal(NILF, _("incorrect direction argument `%s'!"), argv[2]);
1836	if (argv[3])
1837	{
1838	const char *psz = argv[3];
1839	while (isspace(*psz))
1840	psz++;
1841	if (*psz)
1842	pDefPath = kbuild_get_variable_n(ST("defpath"));
1843	}
1844
1845	kbuild_get_sdks(&Sdks, pTarget, pSource, pBldType, pBldTrg, pBldTrgArch);
1846
1847	pVar = kbuild_collect_source_prop(pTarget, pSource, pTool, &Sdks, pType,
1848	pBldType, pBldTrg, pBldTrgArch, pBldTrgCpu,
1849	pDefPath,
1850	argv[0], strlen(argv[0]),
1851	argv[1], strlen(argv[1]),
1852	iDirection);
1853	if (pVar)
1854	o = variable_buffer_output(o, pVar->value, pVar->value_length);
1855
1856	kbuild_put_sdks(&Sdks);
1857	(void)pszFuncName;
1858	return o;
1859	}
1860
1861
1862	/*
1863	dep := $(obj)$(SUFF_DEP)
1864	obj := $(outbase)$(objsuff)
1865	dirdep := $(call DIRDEP,$(dir $(outbase)))
1866	PATH_$(target)_$(source) := $(patsubst %/,%,$(dir $(outbase)))
1867	*/
1868	static struct variable *
1869	kbuild_set_object_name_and_dep_and_dirdep_and_PATH_target_source(struct variable pTarget, struct variable pSource,
1870	struct variable pOutBase, struct variable pObjSuff,
1871	const char pszVarName, struct variable *ppDep,
1872	struct variable **ppDirDep)
1873	{
1874	struct variable *pDepSuff = kbuild_get_variable_n(ST("SUFF_DEP"));
1875	struct variable *pObj;
1876	size_t cch = pOutBase->value_length + pObjSuff->value_length + pDepSuff->value_length + 1;
1877	char *pszResult = alloca(cch);
1878	char pszName, psz;
1879
1880	/*
1881	* dep.
1882	*/
1883	psz = pszResult;
1884	memcpy(psz, pOutBase->value, pOutBase->value_length); psz += pOutBase->value_length;
1885	memcpy(psz, pObjSuff->value, pObjSuff->value_length); psz += pObjSuff->value_length;
1886	memcpy(psz, pDepSuff->value, pDepSuff->value_length + 1);
1887	ppDep = define_variable_vl("dep", 3, pszResult, cch - 1, 1 /dup/, o_local, 0 / !recursive */);
1888
1889	/*
1890	* obj
1891	*/
1892	*psz = '\0';
1893	pObj = define_variable_vl(pszVarName, strlen(pszVarName), pszResult, psz - pszResult,
1894	1/* dup /, o_local, 0 / !recursive */);
1895
1896	/*
1897	* PATH_$(target)_$(source) - this is global!
1898	*/
1899	/* calc variable name. */
1900	cch = sizeof("PATH_")-1 + pTarget->value_length + sizeof("_")-1 + pSource->value_length;
1901	psz = pszName = alloca(cch + 1);
1902	memcpy(psz, "PATH_", sizeof("PATH_") - 1); psz += sizeof("PATH_") - 1;
1903	memcpy(psz, pTarget->value, pTarget->value_length); psz += pTarget->value_length;
1904	*psz++ = '_';
1905	memcpy(psz, pSource->value, pSource->value_length + 1);
1906
1907	/* strip off the filename. */
1908	psz = pszResult + pOutBase->value_length;
1909	for (;;)
1910	{
1911	psz--;
1912	if (psz <= pszResult)
1913	fatal(NULL, "whut!?! no path? result=`%s'", pszResult);
1914	#ifdef HAVE_DOS_PATHS
1915	if (*psz == ':')
1916	{
1917	psz++;
1918	break;
1919	}
1920	#endif
1921	if ( *psz == '/'
1922	#ifdef HAVE_DOS_PATHS
1923	\|\| *psz == '\\'
1924	#endif
1925	)
1926	{
1927	while ( psz - 1 > pszResult
1928	&& psz[-1] == '/'
1929	#ifdef HAVE_DOS_PATHS
1930	\|\| psz[-1] == '\\'
1931	#endif
1932	)
1933	psz--;
1934	#ifdef HAVE_DOS_PATHS
1935	if (psz == pszResult + 2 && pszResult[1] == ':')
1936	psz++;
1937	#endif
1938	break;
1939	}
1940	}
1941	*psz = '\0';
1942
1943	/* set global variable */
1944	define_variable_vl_global(pszName, cch, pszResult, psz - pszResult, 1/dup/, o_file, 0 /* !recursive */, NILF);
1945
1946	/*
1947	* dirdep
1948	*/
1949	if ( psz[-1] != '/'
1950	#ifdef HAVE_DOS_PATHS
1951	&& psz[-1] != '\\'
1952	&& psz[-1] != ':'
1953	#endif
1954	)
1955	{
1956	*psz++ = '/';
1957	*psz = '\0';
1958	}
1959	ppDirDep = define_variable_vl("dirdep", 6, pszResult, psz - pszResult, 1/dup/, o_local, 0 / !recursive */);
1960
1961	return pObj;
1962	}
1963
1964
1965	/* setup the base variables for def_target_source_c_cpp_asm_new:
1966
1967	X := $(kb-src-tool tool)
1968	x := $(kb-obj-base outbase)
1969	x := $(kb-obj-suff objsuff)
1970	obj := $(outbase)$(objsuff)
1971	PATH_$(target)_$(source) := $(patsubst %/,%,$(dir $(outbase)))
1972
1973	x := $(kb-src-prop DEFS,defs,left-to-right)
1974	x := $(kb-src-prop INCS,incs,right-to-left)
1975	x := $(kb-src-prop FLAGS,flags,right-to-left)
1976
1977	x := $(kb-src-prop DEPS,deps,left-to-right)
1978	dirdep := $(call DIRDEP,$(dir $(outbase)))
1979	dep := $(obj)$(SUFF_DEP)
1980	*/
1981	char *
1982	func_kbuild_source_one(char o, char argv, const char pszFuncName)
1983	{
1984	static int s_fNoCompileDepsDefined = -1;
1985	struct variable *pTarget = kbuild_get_variable_n(ST("target"));
1986	struct variable *pSource = kbuild_get_variable_n(ST("source"));
1987	struct variable *pDefPath = kbuild_get_variable_n(ST("defpath"));
1988	struct variable *pType = kbuild_get_variable_n(ST("type"));
1989	struct variable *pBldType = kbuild_get_variable_n(ST("bld_type"));
1990	struct variable *pBldTrg = kbuild_get_variable_n(ST("bld_trg"));
1991	struct variable *pBldTrgArch= kbuild_get_variable_n(ST("bld_trg_arch"));
1992	struct variable *pBldTrgCpu = kbuild_get_variable_n(ST("bld_trg_cpu"));
1993	struct variable *pTool = kbuild_get_source_tool(pTarget, pSource, pType, pBldTrg, pBldTrgArch, "tool");
1994	struct variable *pOutBase = kbuild_get_object_base(pTarget, pSource, "outbase");
1995	struct variable *pObjSuff = kbuild_get_object_suffix(pTarget, pSource, pTool, pType, pBldTrg, pBldTrgArch, "objsuff");
1996	struct variable pDefs, pIncs, pFlags, pDeps, pOrderDeps, pDirDep, pDep, pVar, pOutput, pOutputMaybe;
1997	struct variable *pObj = kbuild_set_object_name_and_dep_and_dirdep_and_PATH_target_source(pTarget, pSource, pOutBase, pObjSuff, "obj", &pDep, &pDirDep);
1998	int fInstallOldVars = 0;
1999	char pszDstVar, pszDst, pszSrcVar, pszSrc, pszVal, psz;
2000	char *pszSavedVarBuf;
2001	unsigned cchSavedVarBuf;
2002	size_t cch;
2003	struct kbuild_sdks Sdks;
2004	int iVer;
2005
2006	/*
2007	* argv[0] is the function version. Prior to r1792 (early 0.1.5) this
2008	* was undefined and footer.kmk always passed an empty string.
2009	*
2010	* Version 2, as implemented in r1797, will make use of the async
2011	* includedep queue feature. This means the files will be read by one or
2012	* more background threads, leaving the eval'ing to be done later on by
2013	* the main thread (in snap_deps).
2014	*/
2015	if (!argv[0][0])
2016	iVer = 0;
2017	else
2018	switch (argv[0][0] \| (argv[0][1] << 8))
2019	{
2020	case '2': iVer = 2; break;
2021	case '3': iVer = 3; break;
2022	case '4': iVer = 4; break;
2023	case '5': iVer = 5; break;
2024	case '6': iVer = 6; break;
2025	case '7': iVer = 7; break;
2026	case '8': iVer = 8; break;
2027	case '9': iVer = 9; break;
2028	case '0': iVer = 0; break;
2029	case '1': iVer = 1; break;
2030	default:
2031	iVer = 0;
2032	psz = argv[0];
2033	while (isblank((unsigned char)*psz))
2034	psz++;
2035	if (*psz)
2036	iVer = atoi(psz);
2037	break;
2038	}
2039
2040	/*
2041	* Gather properties.
2042	*/
2043	kbuild_get_sdks(&Sdks, pTarget, pSource, pBldType, pBldTrg, pBldTrgArch);
2044
2045	if (pDefPath && !pDefPath->value_length)
2046	pDefPath = NULL;
2047
2048
2049	pDefs = kbuild_collect_source_prop(pTarget, pSource, pTool, &Sdks, pType, pBldType, pBldTrg, pBldTrgArch, pBldTrgCpu, NULL,
2050	ST("DEFS"), ST("defs"), 1/* left-to-right */);
2051	pIncs = kbuild_collect_source_prop(pTarget, pSource, pTool, &Sdks, pType, pBldType, pBldTrg, pBldTrgArch, pBldTrgCpu, pDefPath,
2052	ST("INCS"), ST("incs"), -1/* right-to-left */);
2053	pFlags = kbuild_collect_source_prop(pTarget, pSource, pTool, &Sdks, pType, pBldType, pBldTrg, pBldTrgArch, pBldTrgCpu, NULL,
2054	ST("FLAGS"), ST("flags"), 1/* left-to-right */);
2055	pDeps = kbuild_collect_source_prop(pTarget, pSource, pTool, &Sdks, pType, pBldType, pBldTrg, pBldTrgArch, pBldTrgCpu, pDefPath,
2056	ST("DEPS"), ST("deps"), 1/* left-to-right */);
2057	pOrderDeps = kbuild_collect_source_prop(pTarget, pSource, pTool, &Sdks, pType, pBldType, pBldTrg, pBldTrgArch, pBldTrgCpu, pDefPath,
2058	ST("ORDERDEPS"), ST("orderdeps"), 1/* left-to-right */);
2059
2060	/*
2061	* If we've got a default path, we must expand the source now.
2062	* If we do this too early, "<source>_property = stuff" won't work becuase
2063	* our 'source' value isn't what the user expects.
2064	*/
2065	if (pDefPath)
2066	{
2067	/** @todo assert(pSource->origin != o_automatic); We're changing 'source'
2068	* from the foreach loop! */
2069	#ifdef CONFIG_WITH_RDONLY_VARIABLE_VALUE
2070	assert(!pSource->rdonly_val);
2071	#endif
2072	kbuild_apply_defpath(pDefPath, &pSource->value, &pSource->value_length, &pSource->value_alloc_len, 1 /* can free */);
2073	}
2074
2075	/*
2076	# dependencies
2077	ifndef NO_COMPILE_DEPS
2078	_DEPFILES_INCLUDED += $(dep)
2079	$(if $(wildcard $(dep)),$(eval include $(dep)))
2080	endif
2081	*/
2082	if (s_fNoCompileDepsDefined == -1)
2083	s_fNoCompileDepsDefined = kbuild_lookup_variable_n(ST("NO_COMPILE_DEPS")) != NULL;
2084	if (!s_fNoCompileDepsDefined)
2085	{
2086	pVar = kbuild_query_recursive_variable_n("_DEPFILES_INCLUDED", sizeof("_DEPFILES_INCLUDED") - 1);
2087	if (pVar)
2088	{
2089	if (pVar->recursive)
2090	pVar = kbuild_simplify_variable(pVar);
2091	append_string_to_variable(pVar, pDep->value, pDep->value_length, 1 /* append */);
2092	}
2093	else
2094	define_variable_vl_global("_DEPFILES_INCLUDED", sizeof("_DEPFILES_INCLUDED") - 1,
2095	pDep->value, pDep->value_length,
2096	1 /* duplicate_value */,
2097	o_file,
2098	0 /* recursive */,
2099	NULL /* flocp */);
2100
2101	eval_include_dep(pDep->value, NILF, iVer >= 2 ? incdep_queue : incdep_read_it);
2102	}
2103
2104	/*
2105	# call the tool
2106	$(target)_$(source)_CMDS_ := $(TOOL_$(tool)_COMPILE_$(type)_CMDS)
2107	$(target)_$(source)_OUTPUT_ := $(TOOL_$(tool)_COMPILE_$(type)_OUTPUT)
2108	$(target)_$(source)_OUTPUT_MAYBE_ := $(TOOL_$(tool)_COMPILE_$(type)_OUTPUT_MAYBE)
2109	$(target)_$(source)_DEPEND_ := $(TOOL_$(tool)_COMPILE_$(type)_DEPEND) $(deps) $(source)
2110	$(target)_$(source)_DEPORD_ := $(TOOL_$(tool)_COMPILE_$(type)_DEPORD) $(dirdep)
2111	*/
2112	/** @todo Make all these local variables, if someone needs the info later it
2113	* can be recalculated. (Ticket #80.) */
2114	cch = sizeof("TOOL_") + pTool->value_length + sizeof("_COMPILE_") + pType->value_length + sizeof("_OUTPUT_MAYBE");
2115	if (cch < pTarget->value_length + sizeof("$(_2_OBJS)"))
2116	cch = pTarget->value_length + sizeof("$(_2_OBJS)");
2117	psz = pszSrcVar = alloca(cch);
2118	memcpy(psz, "TOOL_", sizeof("TOOL_") - 1); psz += sizeof("TOOL_") - 1;
2119	memcpy(psz, pTool->value, pTool->value_length); psz += pTool->value_length;
2120	memcpy(psz, "_COMPILE_", sizeof("_COMPILE_") - 1); psz += sizeof("_COMPILE_") - 1;
2121	memcpy(psz, pType->value, pType->value_length); psz += pType->value_length;
2122	pszSrc = psz;
2123
2124	cch = pTarget->value_length + 1 + pSource->value_length + sizeof("_OUTPUT_MAYBE_");
2125	psz = pszDstVar = alloca(cch);
2126	memcpy(psz, pTarget->value, pTarget->value_length); psz += pTarget->value_length;
2127	*psz++ = '_';
2128	memcpy(psz, pSource->value, pSource->value_length); psz += pSource->value_length;
2129	pszDst = psz;
2130
2131	memcpy(pszSrc, "_CMDS", sizeof("_CMDS"));
2132	memcpy(pszDst, "_CMDS_", sizeof("_CMDS_"));
2133	pVar = kbuild_get_recursive_variable(pszSrcVar);
2134	do_variable_definition_2(NILF, pszDstVar, pVar->value, pVar->value_length,
2135	!pVar->recursive, 0, o_local, f_simple, 0 /* !target_var */);
2136	do_variable_definition_2(NILF, "kbsrc_cmds", pVar->value, pVar->value_length,
2137	!pVar->recursive, 0, o_local, f_simple, 0 /* !target_var */);
2138
2139	memcpy(pszSrc, "_OUTPUT", sizeof("_OUTPUT"));
2140	memcpy(pszDst, "_OUTPUT_", sizeof("_OUTPUT_"));
2141	pVar = kbuild_get_recursive_variable(pszSrcVar);
2142	pOutput = do_variable_definition_2(NILF, pszDstVar, pVar->value, pVar->value_length,
2143	!pVar->recursive, 0, o_local, f_simple, 0 /* !target_var */);
2144	pOutput = do_variable_definition_2(NILF, "kbsrc_output", pVar->value, pVar->value_length,
2145	!pVar->recursive, 0, o_local, f_simple, 0 /* !target_var */);
2146
2147	memcpy(pszSrc, "_OUTPUT_MAYBE", sizeof("_OUTPUT_MAYBE"));
2148	memcpy(pszDst, "_OUTPUT_MAYBE_", sizeof("_OUTPUT_MAYBE_"));
2149	pVar = kbuild_query_recursive_variable(pszSrcVar);
2150	if (pVar)
2151	{
2152	pOutputMaybe = do_variable_definition_2(NILF, pszDstVar, pVar->value, pVar->value_length,
2153	!pVar->recursive, 0, o_local, f_simple, 0 /* !target_var */);
2154	pOutputMaybe = do_variable_definition_2(NILF, "kbsrc_output_maybe", pVar->value, pVar->value_length,
2155	!pVar->recursive, 0, o_local, f_simple, 0 /* !target_var */);
2156	}
2157	else
2158	{
2159	pOutputMaybe = do_variable_definition_2(NILF, pszDstVar, "", 0, 1, 0, o_local, f_simple, 0 /* !target_var */);
2160	pOutputMaybe = do_variable_definition_2(NILF, "kbsrc_output_maybe", "", 0, 1, 0, o_local, f_simple, 0 /* !target_var */);
2161	}
2162
2163	memcpy(pszSrc, "_DEPEND", sizeof("_DEPEND"));
2164	memcpy(pszDst, "_DEPEND_", sizeof("_DEPEND_"));
2165	pVar = kbuild_get_recursive_variable(pszSrcVar);
2166	psz = pszVal = xmalloc(pVar->value_length + 1 + pDeps->value_length + 1 + pSource->value_length + 1);
2167	memcpy(psz, pVar->value, pVar->value_length); psz += pVar->value_length;
2168	*psz++ = ' ';
2169	memcpy(psz, pDeps->value, pDeps->value_length); psz += pDeps->value_length;
2170	*psz++ = ' ';
2171	memcpy(psz, pSource->value, pSource->value_length + 1);
2172	do_variable_definition_2(NILF, pszDstVar, pszVal, pVar->value_length + 1 + pDeps->value_length + 1 + pSource->value_length,
2173	!pVar->recursive && !pDeps->recursive && !pSource->recursive,
2174	NULL, o_local, f_simple, 0 /* !target_var */);
2175	do_variable_definition_2(NILF, "kbsrc_depend", pszVal, pVar->value_length + 1 + pDeps->value_length + 1 + pSource->value_length,
2176	!pVar->recursive && !pDeps->recursive && !pSource->recursive,
2177	pszVal, o_local, f_simple, 0 /* !target_var */);
2178
2179	memcpy(pszSrc, "_DEPORD", sizeof("_DEPORD"));
2180	memcpy(pszDst, "_DEPORD_", sizeof("_DEPORD_"));
2181	pVar = kbuild_get_recursive_variable(pszSrcVar);
2182	psz = pszVal = xmalloc(pVar->value_length + 1 + pDirDep->value_length + 1 + pOrderDeps->value_length + 1);
2183	memcpy(psz, pVar->value, pVar->value_length); psz += pVar->value_length;
2184	*psz++ = ' ';
2185	memcpy(psz, pDirDep->value, pDirDep->value_length); psz += pDirDep->value_length;
2186	*psz++ = ' ';
2187	memcpy(psz, pOrderDeps->value, pOrderDeps->value_length + 1);
2188	do_variable_definition_2(NILF, pszDstVar, pszVal,
2189	pVar->value_length + 1 + pDirDep->value_length + 1 + pOrderDeps->value_length,
2190	!pVar->recursive && !pDirDep->recursive && !pOrderDeps->recursive,
2191	NULL, o_local, f_simple, 0 /* !target_var */);
2192	do_variable_definition_2(NILF, "kbsrc_depord", pszVal,
2193	pVar->value_length + 1 + pDirDep->value_length + 1 + pOrderDeps->value_length,
2194	!pVar->recursive && !pDirDep->recursive && !pOrderDeps->recursive,
2195	pszVal, o_local, f_simple, 0 /* !target_var */);
2196
2197	/*
2198	_OUT_FILES += $($(target)_$(source)_OUTPUT_) $($(target)_$(source)_OUTPUT_MAYBE_)
2199	*/
2200	pVar = kbuild_get_variable_n(ST("_OUT_FILES"));
2201	append_string_to_variable(pVar, pOutput->value, pOutput->value_length, 1 /* append */);
2202	if (pOutputMaybe->value_length)
2203	append_string_to_variable(pVar, pOutputMaybe->value, pOutputMaybe->value_length, 1 /* append */);
2204
2205	/*
2206	$(target)_2_OBJS += $(obj)
2207	*/
2208	memcpy(pszDstVar + pTarget->value_length, "_2_OBJS", sizeof("_2_OBJS"));
2209	pVar = kbuild_query_recursive_variable_n(pszDstVar, pTarget->value_length + sizeof("_2_OBJS") - 1);
2210	fInstallOldVars \|= iVer <= 2 && (!pVar \|\| !pVar->value_length);
2211	if (pVar)
2212	{
2213	if (pVar->recursive)
2214	pVar = kbuild_simplify_variable(pVar);
2215	append_string_to_variable(pVar, pObj->value, pObj->value_length, 1 /* append */);
2216	}
2217	else
2218	define_variable_vl_global(pszDstVar, pTarget->value_length + sizeof("_2_OBJS") - 1,
2219	pObj->value, pObj->value_length,
2220	1 /* duplicate_value */,
2221	o_file,
2222	0 /* recursive */,
2223	NULL /* flocp */);
2224
2225	/*
2226	* Install legacy variables.
2227	*/
2228	if (fInstallOldVars)
2229	{
2230	/* $(target)_OBJS_ = $($(target)_2_OBJS)*/
2231	memcpy(pszDstVar + pTarget->value_length, "_OBJS_", sizeof("_OBJS_"));
2232
2233	pszSrcVar[0] = '$';
2234	pszSrcVar[1] = '(';
2235	memcpy(pszSrcVar + 2, pTarget->value, pTarget->value_length);
2236	psz = pszSrcVar + 2 + pTarget->value_length;
2237	memcpy(psz, "_2_OBJS)", sizeof("_2_OBJS)"));
2238
2239	define_variable_vl_global(pszDstVar, pTarget->value_length + sizeof("_OBJS_") - 1,
2240	pszSrcVar, pTarget->value_length + sizeof("$(_2_OBJS)") - 1,
2241	1 /* duplicate_value */,
2242	o_file,
2243	1 /* recursive */,
2244	NULL /* flocp */);
2245	}
2246
2247	/*
2248	$(eval $(def_target_source_rule))
2249	*/
2250	pVar = kbuild_get_recursive_variable("def_target_source_rule");
2251	pszVal = variable_expand_string_2 (o, pVar->value, pVar->value_length, &psz);
2252	assert(!((size_t)pszVal & 3));
2253
2254	install_variable_buffer(&pszSavedVarBuf, &cchSavedVarBuf);
2255	eval_buffer(pszVal, psz);
2256	restore_variable_buffer(pszSavedVarBuf, cchSavedVarBuf);
2257
2258	kbuild_put_sdks(&Sdks);
2259	(void)pszFuncName;
2260
2261	*pszVal = '\0';
2262	return pszVal;
2263	}
2264
2265	/*
2266
2267	## Inherit one template property in a non-accumulative manner.
2268	# @param $(prop) Property name
2269	# @param $(target) Target name
2270	# @todo fix the precedence order for some properties.
2271	define def_inherit_template_one
2272	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop)
2273	ifndef $(target)_$(prop)
2274	$(target)_$(prop) := $(TEMPLATE_$($(target)_TEMPLATE)_$(prop))
2275	endif
2276	endif
2277	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg)
2278	ifndef $(target)_$(prop).$(bld_trg)
2279	$(target)_$(prop).$(bld_trg) := $(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg))
2280	endif
2281	endif
2282	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg).$(bld_trg_arch)
2283	ifndef $(target)_$(prop).$(bld_trg).$(bld_trg_arch)
2284	$(target)_$(prop).$(bld_trg).$(bld_trg_arch) := $(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg).$(bld_trg_arch))
2285	endif
2286	endif
2287	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_arch)
2288	ifndef $(target)_$(prop).$(bld_trg_arch)
2289	$(target)_$(prop).$(bld_trg_arch) := $(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_arch))
2290	endif
2291	endif
2292	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_cpu)
2293	ifndef $(target)_$(prop).$(bld_trg_cpu)
2294	$(target)_$(prop).$(bld_trg_cpu) := $(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_cpu))
2295	endif
2296	endif
2297	endef
2298
2299	## Inherit one template property in a non-accumulative manner, deferred expansion.
2300	# @param 1: $(prop) Property name
2301	# @param 2: $(target) Target name
2302	# @todo fix the precedence order for some properties.
2303	# @remark this define relies on double evaluation
2304	define def_inherit_template_one_deferred
2305	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop)
2306	ifndef $(target)_$(prop)
2307	$(target)_$(prop) = $$(TEMPLATE_$($(target)_TEMPLATE)_$(prop))
2308	endif
2309	endif
2310	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg)
2311	ifndef $(target)_$(prop).$(bld_trg)
2312	$(target)_$(prop).$(bld_trg) = $$(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg))
2313	endif
2314	endif
2315	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg).$(bld_trg_arch)
2316	ifndef $(target)_$(prop).$(bld_trg).$(bld_trg_arch)
2317	$(target)_$(prop).$(bld_trg).$(bld_trg_arch) = $$(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg).$(bld_trg_arch))
2318	endif
2319	endif
2320	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_arch)
2321	ifndef $(target)_$(prop).$(bld_trg_arch)
2322	$(target)_$(prop).$(bld_trg_arch) = $$(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_arch))
2323	endif
2324	endif
2325	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_cpu)
2326	ifndef $(target)_$(prop).$(bld_trg_cpu)
2327	$(target)_$(prop).$(bld_trg_cpu) = $$(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_cpu))
2328	endif
2329	endif
2330	endef
2331
2332	## Inherit one acculumlative template property where the 'most significant' items are at the left end.
2333	# @param $(prop) Property name
2334	# @param $(target) Target name
2335	define def_inherit_template_one_accumulate_l
2336	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop)
2337	ifeq ($$(flavor $(target)_$(prop)),simple)
2338	$$(evalcall2 def_simple_2_recursive,$(target)_$(prop))
2339	endif
2340	$(target)_$(prop) += $$(TEMPLATE_$($(target)_TEMPLATE)_$(prop))
2341	endif
2342	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(KBUILD_TYPE)
2343	ifeq ($$(flavor $(target)_$(prop).$(KBUILD_TYPE)),simple)
2344	$$(evalcall2 def_simple_2_recursive,$(target)_$(prop).$(KBUILD_TYPE))
2345	endif
2346	$(target)_$(prop).$(KBUILD_TYPE) += $$(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(KBUILD_TYPE))
2347	endif
2348	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg)
2349	ifeq ($$(flavor $(target)_$(prop).$(bld_trg)),simple)
2350	$$(evalcall2 def_simple_2_recursive,$(target)_$(prop).$(bld_trg))
2351	endif
2352	$(target)_$(prop).$(bld_trg) += $$(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg))
2353	endif
2354	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg).$(bld_trg_arch)
2355	ifeq ($$(flavor $(target)_$(prop).$(bld_trg).$(bld_trg_arch)),simple)
2356	$$(evalcall2 def_simple_2_recursive,$(target)_$(prop).$(bld_trg).$(bld_trg_arch))
2357	endif
2358	$(target)_$(prop).$(bld_trg).$(bld_trg_arch) += $$(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg).$(bld_trg_arch))
2359	endif
2360	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_cpu)
2361	ifeq ($$(flavor $(target)_$(prop).$(bld_trg_cpu)),simple)
2362	$$(evalcall2 def_simple_2_recursive,$(target)_$(prop).$(bld_trg_cpu))
2363	endif
2364	$(target)_$(prop).$(bld_trg_cpu) += $$(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_cpu))
2365	endif
2366	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_arch)
2367	ifeq ($$(flavor $(target)_$(prop).$(bld_trg_arch)),simple)
2368	$$(evalcall2 def_simple_2_recursive,$(target)_$(prop).$(bld_trg_arch))
2369	endif
2370	$(target)_$(prop).$(bld_trg_arch) += $$(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_arch))
2371	endif
2372	endef
2373
2374	## Inherit one acculumlative template property where the 'most significant' items are at the right end.
2375	# @param $(prop) Property name
2376	# @param $(target) Target name
2377	define def_inherit_template_one_accumulate_r
2378	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop)
2379	ifeq ($$(flavor $(target)_$(prop)),simple)
2380	$$(evalcall2 def_simple_2_recursive,$(target)_$(prop))
2381	endif
2382	$(target)_$(prop) <=$$(TEMPLATE_$($(target)_TEMPLATE)_$(prop))
2383	endif
2384	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(KBUILD_TYPE)
2385	ifeq ($$(flavor $(target)_$(prop).$(KBUILD_TYPE)),simple)
2386	$$(evalcall2 def_simple_2_recursive,$(target)_$(prop).$(KBUILD_TYPE))
2387	endif
2388	$(target)_$(prop).$(KBUILD_TYPE) <=$$(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(KBUILD_TYPE))
2389	endif
2390	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg)
2391	ifeq ($$(flavor $(target)_$(prop).$(bld_trg)),simple)
2392	$$(evalcall2 def_simple_2_recursive,$(target)_$(prop).$(bld_trg))
2393	endif
2394	$(target)_$(prop).$(bld_trg) <=$$(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg))
2395	endif
2396	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg).$(bld_trg_arch)
2397	ifeq ($$(flavor $(target)_$(prop).$(bld_trg).$(bld_trg_arch)),simple)
2398	$$(evalcall2 def_simple_2_recursive,$(target)_$(prop).$(bld_trg).$(bld_trg_arch))
2399	endif
2400	$(target)_$(prop).$(bld_trg).$(bld_trg_arch) <=$$(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg).$(bld_trg_arch))
2401	endif
2402	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_cpu)
2403	ifeq ($$(flavor $(target)_$(prop).$(bld_trg_cpu)),simple)
2404	$$(evalcall2 def_simple_2_recursive,$(target)_$(prop).$(bld_trg_cpu))
2405	endif
2406	$(target)_$(prop).$(bld_trg_cpu) <=$$(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_cpu))
2407	endif
2408	ifdef TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_arch)
2409	ifeq ($$(flavor $(target)_$(prop).$(bld_trg_arch)),simple)
2410	$$(evalcall2 def_simple_2_recursive,$(target)_$(prop).$(bld_trg_arch))
2411	endif
2412	$(target)_$(prop).$(bld_trg_arch) <=$$(TEMPLATE_$($(target)_TEMPLATE)_$(prop).$(bld_trg_arch))
2413	endif
2414	endef
2415
2416
2417	## Inherit template properties for on target.
2418	# @param $(target) Target name.
2419	define def_inherit_template
2420	# sanity check.
2421	ifdef _$(target)_ALREADY_PROCESSED
2422	$(error kBuild: The target $(target) appears more than once in the target lists! Please correct the makefile(s))
2423	endif
2424	_$(target)_ALREADY_PROCESSED := 1
2425
2426	# Inherit any default template.
2427	ifdef TEMPLATE
2428	ifeq ($($(target)_TEMPLATE),)
2429	$(eval $(target)_TEMPLATE:=$(TEMPLATE))
2430	endif
2431	endif
2432	# Expand the template if specified.
2433	ifneq ($($(target)_TEMPLATE),)
2434	$(foreach prop,$(PROPS_SINGLE),$(evalval def_inherit_template_one))
2435	$(foreach prop,$(PROPS_DEFERRED),$(eval $(def_inherit_template_one_deferred))) # exploits the 2 evaluation, so no value!
2436	$(foreach prop,$(PROPS_ACCUMULATE_L),$(eval $(def_inherit_template_one_accumulate_l))) # += works fine without value
2437	$(foreach prop,$(PROPS_ACCUMULATE_R),$(eval $(def_inherit_template_one_accumulate_r))) # use <= (kmk addition)
2438	endif
2439	endef
2440
2441
2442	Invoked like this:
2443	$(kb-exp-tmpl 1,$(_ALL_TARGET_TARGETS),$(KBUILD_TARGET),$(KBUILD_TARGET_ARCH),$(KBUILD_TARGET_CPU),$(KBUILD_TYPE))
2444	*/
2445	char *
2446	func_kbuild_expand_template(char o, char argv, const char pszFuncName)
2447	{
2448	const char *pszVersion = argv[0];
2449	const char *pszBldTrg = argv[2];
2450	const char *pszBldTrgArch = argv[3];
2451	const char *pszBldTrgCpu = argv[4];
2452	const char *pszBldType = argv[5];
2453	size_t cchBldTrg = strlen(pszBldTrg);
2454	size_t cchBldTrgArch = strlen(pszBldTrgArch);
2455	size_t cchBldTrgCpu = strlen(pszBldTrgCpu);
2456	size_t cchBldType = strlen(pszBldType);
2457	size_t cchMaxBld = cchBldTrg + cchBldTrgArch + cchBldTrgCpu + cchBldType; /* too big, but so what. */
2458	struct kbet_key
2459	{
2460	unsigned int cch;
2461	char *psz;
2462	} aKeys[6];
2463	unsigned int const cKeys = 6;
2464	unsigned int iKey;
2465	struct variable *pDefTemplate;
2466	struct variable *pProps;
2467	struct kbet_prop
2468	{
2469	const char *pch;
2470	unsigned int cch;
2471	enum kbet_prop_enum { kPropSingle, kPropDeferred, kPropAccumulateL, kPropAccumulateR }
2472	enmType;
2473	} *paProps;
2474	unsigned int cProps;
2475	unsigned int iProp;
2476	size_t cchMaxProp;
2477	struct variable *pVarTrg;
2478	struct variable *pVarSrc;
2479	const char *pszIter;
2480	const char *pszTarget;
2481	unsigned int cchTarget;
2482	char *pszSrc = 0;
2483	char *pszSrcRef = 0;
2484	char *pszSrcBuf = 0;
2485	size_t cchSrcBuf = 0;
2486	char *pszTrg = 0;
2487	size_t cchTrg = 0;
2488
2489	/*
2490	* Validate input.
2491	*/
2492	if (pszVersion[0] != '1' \|\| pszVersion[1])
2493	fatal(NULL, "%s: Unsupported version `%s'", pszFuncName, pszVersion);
2494
2495	if (!cchBldTrg)
2496	fatal(NULL, "%s: missing bldtrg", pszFuncName);
2497
2498	if (!cchBldTrgArch)
2499	fatal(NULL, "%s: missing bld_trg_arch", pszFuncName);
2500
2501	if (!cchBldTrgCpu)
2502	fatal(NULL, "%s: missing bld_trg_cpu", pszFuncName);
2503
2504	if (!cchBldType)
2505	fatal(NULL, "%s: missing bld_type", pszFuncName);
2506
2507	/*
2508	* Prepare the keywords, prepending dots for quicker copying.
2509	* This allows for an inner loop when processing properties, saving code
2510	* at the expense of a few xmallocs.
2511	*/
2512	/* the first entry is empty. */
2513	aKeys[0].cch = 0;
2514	aKeys[0].psz = NULL;
2515
2516	/* .$(bld_type) */
2517	aKeys[1].cch = cchBldType + 1;
2518	aKeys[1].psz = xmalloc (aKeys[1].cch + 1);
2519	aKeys[1].psz[0] = '.';
2520	memcpy(aKeys[1].psz + 1, pszBldType, cchBldType + 1);
2521
2522	/* .$(bld_trg) */
2523	aKeys[2].cch = cchBldTrg + 1;
2524	aKeys[2].psz = xmalloc (aKeys[2].cch + 1);
2525	aKeys[2].psz[0] = '.';
2526	memcpy(aKeys[2].psz + 1, pszBldTrg, cchBldTrg + 1);
2527
2528	/* .$(bld_trg).$(bld_trg_arch) */
2529	aKeys[3].cch = cchBldTrg + 1 + cchBldTrgArch + 1;
2530	aKeys[3].psz = xmalloc (aKeys[3].cch + 1);
2531	aKeys[3].psz[0] = '.';
2532	memcpy(aKeys[3].psz + 1, pszBldTrg, cchBldTrg);
2533	aKeys[3].psz[1 + cchBldTrg] = '.';
2534	memcpy(aKeys[3].psz + 1 + cchBldTrg + 1, pszBldTrgArch, cchBldTrgArch + 1);
2535
2536	/* .$(bld_trg_cpu) */
2537	aKeys[4].cch = cchBldTrgCpu + 1;
2538	aKeys[4].psz = xmalloc (aKeys[4].cch + 1);
2539	aKeys[4].psz[0] = '.';
2540	memcpy(aKeys[4].psz + 1, pszBldTrgCpu, cchBldTrgCpu + 1);
2541
2542	/* .$(bld_trg_arch) */
2543	aKeys[5].cch = cchBldTrgArch + 1;
2544	aKeys[5].psz = xmalloc (aKeys[5].cch + 1);
2545	aKeys[5].psz[0] = '.';
2546	memcpy(aKeys[5].psz + 1, pszBldTrgArch, cchBldTrgArch + 1);
2547
2548
2549	/*
2550	* Prepare the properties, folding them into an array.
2551	* This way we won't have to reparse them for each an every target, though
2552	* it comes at the expense of one or more heap calls.
2553	*/
2554	#define PROP_ALLOC_INC 128
2555	iProp = 0;
2556	cProps = PROP_ALLOC_INC;
2557	paProps = xmalloc(sizeof(pProps) cProps);
2558
2559	pProps = kbuild_get_variable_n(ST("PROPS_SINGLE"));
2560	pszIter = pProps->value;
2561	while ((paProps[iProp].pch = find_next_token(&pszIter, &paProps[iProp].cch)))
2562	{
2563	paProps[iProp].enmType = kPropSingle;
2564	if (++iProp >= cProps)
2565	{
2566	cProps += PROP_ALLOC_INC;
2567	paProps = xrealloc(paProps, sizeof(paProps) cProps);
2568	}
2569
2570	}
2571
2572	pProps = kbuild_get_variable_n(ST("PROPS_DEFERRED"));
2573	pszIter = pProps->value;
2574	while ((paProps[iProp].pch = find_next_token(&pszIter, &paProps[iProp].cch)))
2575	{
2576	paProps[iProp].enmType = kPropDeferred;
2577	if (++iProp >= cProps)
2578	{
2579	cProps += PROP_ALLOC_INC;
2580	paProps = xrealloc(paProps, sizeof(paProps) cProps);
2581	}
2582	}
2583
2584	pProps = kbuild_get_variable_n(ST("PROPS_ACCUMULATE_L"));
2585	pszIter = pProps->value;
2586	while ((paProps[iProp].pch = find_next_token(&pszIter, &paProps[iProp].cch)))
2587	{
2588	paProps[iProp].enmType = kPropAccumulateL;
2589	if (++iProp >= cProps)
2590	{
2591	cProps += PROP_ALLOC_INC;
2592	paProps = xrealloc(paProps, sizeof(paProps) cProps);
2593	}
2594	}
2595
2596	pProps = kbuild_get_variable_n(ST("PROPS_ACCUMULATE_R"));
2597	pszIter = pProps->value;
2598	while ((paProps[iProp].pch = find_next_token(&pszIter, &paProps[iProp].cch)))
2599	{
2600	paProps[iProp].enmType = kPropAccumulateR;
2601	if (++iProp >= cProps)
2602	{
2603	cProps += PROP_ALLOC_INC;
2604	paProps = xrealloc(paProps, sizeof(paProps) cProps);
2605	}
2606	}
2607	#undef PROP_ALLOC_INC
2608	cProps = iProp;
2609
2610	/* find the max prop length. */
2611	cchMaxProp = paProps[0].cch;
2612	while (--iProp > 0)
2613	if (paProps[iProp].cch > cchMaxProp)
2614	cchMaxProp = paProps[iProp].cch;
2615
2616	/*
2617	* Query and prepare (strip) the default template
2618	* (given by the TEMPLATE variable).
2619	*/
2620	pDefTemplate = kbuild_lookup_variable_n(ST("TEMPLATE"));
2621	if (pDefTemplate)
2622	{
2623	if ( pDefTemplate->value_length
2624	&& ( isspace(pDefTemplate->value[0])
2625	\|\| isspace(pDefTemplate->value[pDefTemplate->value_length - 1])))
2626	{
2627	unsigned int off;
2628	if (pDefTemplate->rdonly_val)
2629	fatal(NULL, "%s: TEMPLATE is read-only", pszFuncName);
2630
2631	/* head */
2632	for (off = 0; isspace(pDefTemplate->value[off]); off++)
2633	/* nothing */;
2634	if (off)
2635	{
2636	pDefTemplate->value_length -= off;
2637	memmove(pDefTemplate->value, pDefTemplate->value + off, pDefTemplate->value_length + 1);
2638	}
2639
2640	/* tail */
2641	off = pDefTemplate->value_length;
2642	while (off > 0 && isspace(pDefTemplate->value[off - 1]))
2643	off--;
2644	pDefTemplate->value_length = off;
2645	pDefTemplate->value[off] = '\0';
2646
2647	VARIABLE_CHANGED(pDefTemplate);
2648	}
2649
2650	if (!pDefTemplate->value_length)
2651	pDefTemplate = NULL;
2652	}
2653
2654	/*
2655	* Iterate the target list.
2656	*/
2657	pszIter = argv[1];
2658	while ((pszTarget = find_next_token(&pszIter, &cchTarget)))
2659	{
2660	char pszTrgProp, pszSrcProp;
2661	char pszTrgKey, pszSrcKey;
2662	struct variable *pTmpl;
2663	const char *pszTmpl;
2664	size_t cchTmpl, cchMax;
2665
2666	/* resize the target buffer. */
2667	cchMax = cchTarget + cchMaxProp + cchMaxBld + 10;
2668	if (cchTrg < cchMax)
2669	{
2670	cchTrg = (cchMax + 31U) & ~(size_t)31;
2671	pszTrg = xrealloc(pszTrg, cchTrg);
2672	}
2673
2674	/*
2675	* Query the TEMPLATE property, if not found or zero-length fall back on the default.
2676	*/
2677	memcpy(pszTrg, pszTarget, cchTarget);
2678	pszTrgProp = pszTrg + cchTarget;
2679	memcpy(pszTrgProp, "_TEMPLATE", sizeof("_TEMPLATE"));
2680	pszTrgProp++; /* after '_'. */
2681
2682	/** @todo Change this to a recursive lookup with simplification below. That
2683	* will allow target_TEMPLATE = $(NO_SUCH_TEMPLATE) instead of having
2684	* to use target_TEMPLATE = DUMMY */
2685	pTmpl = kbuild_lookup_variable_n(pszTrg, cchTarget + sizeof("_TEMPLATE") - 1);
2686	if (!pTmpl \|\| !pTmpl->value_length)
2687	{
2688	if (!pDefTemplate)
2689	continue; /* no template */
2690	pszTmpl = pDefTemplate->value;
2691	cchTmpl = pDefTemplate->value_length;
2692	}
2693	else
2694	{
2695	pszTmpl = pTmpl->value;
2696	cchTmpl = pTmpl->value_length;
2697	while (isspace(*pszTmpl))
2698	cchTmpl--, pszTmpl++;
2699	if (!cchTmpl)
2700	continue; /* no template */
2701	}
2702
2703	/* resize the source buffer. */
2704	cchMax = sizeof("TEMPLATE_") + cchTmpl + cchMaxProp + cchMaxBld + 10 + sizeof(void *);
2705	if (cchSrcBuf < cchMax)
2706	{
2707	cchSrcBuf = (cchMax + 31U) & ~(size_t)31;
2708	pszSrcBuf = xrealloc(pszSrcBuf, cchSrcBuf);
2709	pszSrc = pszSrcBuf + sizeof(void ); assert(sizeof(void ) >= 2);
2710	pszSrcRef = pszSrc - 2;
2711	pszSrcRef[0] = '$';
2712	pszSrcRef[1] = '(';
2713	}
2714
2715	/* prepare the source buffer */
2716	memcpy(pszSrc, "TEMPLATE_", sizeof("TEMPLATE_") - 1);
2717	pszSrcProp = pszSrc + sizeof("TEMPLATE_") - 1;
2718	memcpy(pszSrcProp, pszTmpl, cchTmpl);
2719	pszSrcProp += cchTmpl;
2720	*pszSrcProp++ = '_';
2721
2722	/*
2723	* Process properties.
2724	* Note! The single and deferred are handled in the same way now.
2725	*/
2726	#define BY_REF_LIMIT 64 /(cchSrcVar 4 > 64 ? cchSrcVar * 4 : 64)*/
2727
2728	for (iProp = 0; iProp < cProps; iProp++)
2729	{
2730	memcpy(pszTrgProp, paProps[iProp].pch, paProps[iProp].cch);
2731	pszTrgKey = pszTrgProp + paProps[iProp].cch;
2732
2733	memcpy(pszSrcProp, paProps[iProp].pch, paProps[iProp].cch);
2734	pszSrcKey = pszSrcProp + paProps[iProp].cch;
2735
2736	for (iKey = 0; iKey < cKeys; iKey++)
2737	{
2738	char *pszTrgEnd;
2739	size_t cchSrcVar;
2740
2741	/* lookup source, skip ahead if it doesn't exist. */
2742	memcpy(pszSrcKey, aKeys[iKey].psz, aKeys[iKey].cch);
2743	cchSrcVar = pszSrcKey - pszSrc + aKeys[iKey].cch;
2744	pszSrc[cchSrcVar] = '\0';
2745	pVarSrc = kbuild_query_recursive_variable_n(pszSrc, cchSrcVar);
2746	if (!pVarSrc)
2747	continue;
2748
2749	/* lookup target, skip ahead if it exists. */
2750	memcpy(pszTrgKey, aKeys[iKey].psz, aKeys[iKey].cch);
2751	pszTrgEnd = pszTrgKey + aKeys[iKey].cch;
2752	*pszTrgEnd = '\0';
2753	pVarTrg = kbuild_query_recursive_variable_n(pszTrg, pszTrgEnd - pszTrg);
2754
2755	switch (paProps[iProp].enmType)
2756	{
2757	case kPropAccumulateL:
2758	case kPropAccumulateR:
2759	if (pVarTrg)
2760	{
2761	/* Append to existing variable. If the source is recursive,
2762	or we append by reference, we'll have to make sure the
2763	target is recusive as well. */
2764	if ( !pVarTrg->recursive
2765	&& ( pVarSrc->value_length >= BY_REF_LIMIT
2766	\|\| pVarSrc->recursive))
2767	pVarTrg->recursive = 1;
2768
2769	if (pVarSrc->value_length < BY_REF_LIMIT)
2770	append_string_to_variable(pVarTrg, pVarSrc->value, pVarSrc->value_length,
2771	paProps[iProp].enmType == kPropAccumulateL /* append */);
2772	else
2773	{
2774	pszSrc[cchSrcVar] = ')';
2775	pszSrc[cchSrcVar + 1] = '\0';
2776	append_string_to_variable(pVarTrg, pszSrcRef, 2 + cchSrcVar + 1,
2777	paProps[iProp].enmType == kPropAccumulateL /* append */);
2778	}
2779	break;
2780	}
2781	/* else: the target variable doesn't exist, create it. */
2782	/* fall thru */
2783
2784	case kPropSingle:
2785	case kPropDeferred:
2786	if (pVarTrg)
2787	continue; /* skip ahead if it already exists. */
2788
2789	/* copy the variable if its short, otherwise reference it. */
2790	if (pVarSrc->value_length < BY_REF_LIMIT)
2791	define_variable_vl_global(pszTrg, pszTrgEnd - pszTrg,
2792	pVarSrc->value, pVarSrc->value_length,
2793	1 /* duplicate_value */,
2794	o_file,
2795	pVarSrc->recursive,
2796	NULL /* flocp */);
2797	else
2798	{
2799	pszSrc[cchSrcVar] = ')';
2800	pszSrc[cchSrcVar + 1] = '\0';
2801	define_variable_vl_global(pszTrg, pszTrgEnd - pszTrg,
2802	pszSrcRef, 2 + cchSrcVar + 1,
2803	1 /* duplicate_value */,
2804	o_file,
2805	1 /* recursive */,
2806	NULL /* flocp */);
2807	}
2808	break;
2809
2810	}
2811
2812	} /* foreach key */
2813	} /* foreach prop */
2814	#undef BY_REF_LIMIT
2815	} /* foreach target */
2816
2817	/*
2818	* Cleanup.
2819	*/
2820	free(pszSrcBuf);
2821	free(pszTrg);
2822	free(paProps);
2823	for (iKey = 1; iKey < cKeys; iKey++)
2824	free(aKeys[iKey].psz);
2825
2826	return o;
2827	}
2828
2829	#endif /* KMK_HELPERS */
2830

Note: See TracBrowser for help on using the repository browser.

source: kBuild/trunk/src/kmk/kbuild.c@ 2837

Download in other formats: