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