| blob | e179e7189ba4074fe55f4a6390a2de01d15b43c2 |
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 *
25 * Copyright 2016 RackTop Systems.
26 * Copyright (c) 2016 by Delphix. All rights reserved.
27 */
29 /*
30 * doname.c
31 *
32 * Figure out which targets are out of date and rebuild them
33 */
35 /*
36 * Included files
37 */
39 #include <fcntl.h>
40 #include <mk/defs.h>
44 #include <poll.h>
45 #include <libintl.h>
46 #include <signal.h>
47 #include <stropts.h>
48 #include <sys/errno.h>
49 #include <sys/stat.h>
50 #include <sys/types.h>
52 #include <sys/wait.h>
55 /*
56 * Defined macros
57 */
60 #define MAXRULES 100
62 // Sleep for .1 seconds between stat()'s
65 /*
66 * typedefs & structs
67 */
69 /*
70 * Static variables
71 */
78 /*
79 * File table of contents
80 */
81 extern Doname doname_check(register Name target, register Boolean do_get, register Boolean implicit, register Boolean automatic);
82 extern Doname doname(register Name target, register Boolean do_get, register Boolean implicit, register Boolean automatic);
83 static Boolean check_dependencies(Doname *result, Property line, Boolean do_get, Name target, Name true_target, Boolean doing_subtree, Chain *out_of_date_tail, Property old_locals, Boolean implicit, Property *command, Name less, Boolean rechecking_target, Boolean recheck_conditionals);
99 extern void reset_locals(register Name target, register Property old_locals, register Property conditional, register int index);
103 // From read2.cc
108 /*
109 * DONE.
110 *
111 * doname_check(target, do_get, implicit, automatic)
112 *
113 * Will call doname() and then inspect the return value
114 *
115 * Return value:
116 * Indication if the build failed or not
117 *
118 * Parameters:
119 * target The target to build
120 * do_get Passed thru to doname()
121 * implicit Passed thru to doname()
122 * automatic Are we building a hidden dependency?
123 *
124 * Global variables used:
125 * build_failed_seen Set if -k is on and error occurs
126 * continue_after_error Indicates that -k is on
127 * report_dependencies No error msg if -P is on
128 */
129 Doname
130 doname_check(register Name target, register Boolean do_get, register Boolean implicit, register Boolean automatic)
131 {
134 try_again:
146 }
151 /*
152 * If we can't figure out how to build an automatic
153 * (hidden) dependency, we just ignore it.
154 * We later declare the target to be out of date just in
155 * case something changed.
156 * Also, don't complain if just reporting the dependencies
157 * and not building anything.
158 */
162 }
167 }
174 }
177 }
178 }
181 void
183 {
185 Dependency dependency;
197 }
199 }
201 }
205 Name
207 {
208 Dyntarget p;
210 String_rec string;
229 }
230 }
231 pp++;
234 }
236 i++;
237 pp++;
244 }
245 }
247 }
248 }
249 }
251 }
253 /*
254 * DONE.
255 *
256 * doname(target, do_get, implicit)
257 *
258 * Chases all files the target depends on and builds any that
259 * are out of date. If the target is out of date it is then rebuilt.
260 *
261 * Return value:
262 * Indiates if build failed or nt
263 *
264 * Parameters:
265 * target Target to build
266 * do_get Run sccs get is nessecary
267 * implicit doname is trying to find an implicit rule
268 *
269 * Global variables used:
270 * assign_done True if command line assgnment has happened
271 * commands_done Preserved for the case that we need local value
272 * debug_level Should we trace make's actions?
273 * default_rule The rule for ".DEFAULT", used as last resort
274 * empty_name The Name "", used when looking for single sfx
275 * keep_state Indicates that .KEEP_STATE is on
276 * parallel True if building in parallel
277 * recursion_level Used for tracing
278 * report_dependencies make -P is on
279 */
280 Doname
281 doname(register Name target, register Boolean do_get, register Boolean implicit, register Boolean automatic)
282 {
285 Chain target_group;
295 Boolean saved_commands_done;
304 }
307 /*
308 * If this target is a member of target group and one of the
309 * other members of the group is running, mark this target
310 * as running.
311 */
318 recursion_level,
319 do_get,
320 implicit,
323 }
324 }
325 }
326 /*
327 * If the target is a constructed one for a "::" target,
328 * we need to consider that.
329 */
334 /* Make sure we have a valid time for :: targets */
335 Property time;
340 }
341 }
342 }
344 /*
345 * If the target has been processed, we don't need to do it again,
346 * unless it depends on conditional macros or a delayed assignment,
347 * or it has been done when KEEP_STATE is on.
348 */
354 }
355 }
357 /* A dynamic macro subtree is being built */
361 /*
362 * This target has been started before and therefore
363 * not all dependencies have to be built.
364 */
366 }
370 /*
371 } else if (parallel &&
372 keep_state &&
373 (target->conditional_cnt > 0)) {
374 if (!parallel_ok(target, false)) {
375 add_subtree(target, recursion_level, do_get, implicit);
376 target->state = build_running;
377 return build_running;
378 }
379 */
380 }
381 /*
382 * If KEEP_STATE is on, we have to rebuild the target if the
383 * building of it caused new automatic dependencies to be reported.
384 * This is where we restart the build.
385 */
388 }
389 recheck_target:
390 /* Init all local variables */
397 /*
398 * If this target has never been built before, mark all
399 * of the dependencies as never built.
400 */
405 }
406 }
407 /* Save the set of automatic depes defined for this target */
413 /*
414 * First run thru the dependency list to see how many
415 * autos there are.
416 */
421 auto_count++;
422 }
423 }
424 /* Create vector to hold the current autos */
425 automatics =
427 /* Copy them */
433 }
434 }
435 }
438 recursion_level,
441 }
442 recursion_level++;
443 /* Avoid infinite loops */
448 }
451 /* Activate conditional macros for the target */
455 }
460 }
462 /*
463 * after making the call to dynamic_dependecies unconditional we can handle
464 * target names that are same as file name. In this case $$@ in the
465 * dependencies did not mean anything. WIth this change it expands it
466 * as expected.
467 */
469 {
471 }
473 /*
474 * FIRST SECTION -- GO THROUGH DEPENDENCIES AND COLLECT EXPLICIT
475 * COMMANDS TO RUN
476 */
479 line,
480 do_get,
481 target,
482 true_target,
483 doing_subtree,
485 old_locals,
486 implicit,
488 less,
489 rechecking_target,
490 recheck_conditionals)) {
492 }
495 }
497 }
500 /*
501 * If the target is a :: type, do not try to find the rule for the target,
502 * all actions will be taken by separate branches.
503 * Else, we try to find an implicit rule using various methods,
504 * we quit as soon as one is found.
505 *
506 * [tolik, 12 Sep 2002] Do not try to find implicit rule for the target
507 * being rechecked - the target is being rechecked means that it already
508 * has explicit dependencies derived from an implicit rule found
509 * in previous step.
510 */
512 /* Look for percent matched rule */
516 target,
518 recheck_conditionals)) {
526 do_get,
527 implicit,
531 old_locals,
533 conditional_prop),
535 }
540 }
541 }
542 /* Look for double suffix rule */
544 Property member;
548 NULL)) {
553 recheck_conditionals)) {
561 do_get,
562 implicit,
566 old_locals,
568 conditional_prop),
570 }
573 /* ALWAYS bind $% for old style */
574 /* ar rules */
576 line =
578 line_prop);
579 }
583 }
587 recheck_conditionals)) {
595 do_get,
596 implicit,
600 old_locals,
602 prop,
603 conditional_prop),
605 }
607 }
608 }
609 }
610 /* Look for single suffix rule */
612 /* /tolik/
613 * I commented !implicit to fix bug 1247448: Suffix Rules failed when combine with Pattern Matching Rules.
614 * This caused problem with SVR4 tilde rules (infinite recursion). So I made some changes in "implicit.cc"
615 */
616 /* /tolik, 06.21.96/
617 * Regression! See BugId 1255360
618 * If more than one percent rules are defined for the same target then
619 * the behaviour of 'make' with my previous fix may be different from one
620 * of the 'old make'.
621 * The global variable second_pass (maybe it should be an argument to doname())
622 * is intended to avoid this regression. It is set in doname_check().
623 * First, 'make' will work as it worked before. Only when it is
624 * going to say "don't know how to make target" it sets second_pass to true and
625 * run 'doname' again but now trying to use Single Suffix Rules.
626 */
632 target,
633 empty_name,
635 recheck_conditionals)) {
643 do_get,
644 implicit,
648 old_locals,
650 conditional_prop),
652 }
654 }
655 }
656 /* Try to sccs get */
659 do_get) {
661 }
663 /* Use .DEFAULT rule if it is defined. */
667 default_rule &&
669 /* Make sure we have a line prop */
672 Boolean out_of_date;
679 }
684 recursion_level,
687 }
688 }
695 }
696 }
698 /* We say "target up to date" if no cmd were executed for the target */
701 }
706 {
708 {
710 }
712 {
714 }
715 }
718 r_command:
719 /* Run commands if any. */
725 }
729 true_target,
730 command,
732 auto_count,
733 automatics,
734 do_get,
735 implicit);
741 }
743 }
746 old_locals,
748 conditional_prop),
750 }
755 do_get,
756 implicit);
762 }
764 }
767 old_locals,
769 conditional_prop),
771 }
774 /* If all went OK set a nice timestamp */
777 }
779 }
781 /*
782 * If no command was found for the target, and it doesn't
783 * exist, and it is mentioned as a target in the makefile,
784 * we say it is extremely new and that it is OK.
785 */
789 }
791 }
792 /*
793 * Trying dynamic targets.
794 */
801 }
804 line,
805 do_get,
806 target,
807 true_target,
808 doing_subtree,
810 old_locals,
811 implicit,
813 less,
814 rechecking_target,
815 recheck_conditionals))
816 {
818 }
821 }
823 }
825 }
826 }
827 /*
828 * If the file exists, it is OK that we couldnt figure
829 * out how to build it.
830 */
835 }
836 }
838 /*
839 * Some of the following is duplicated in the function finish_doname.
840 * If anything is changed here, check to see if it needs to be
841 * changed there.
842 */
846 }
848 }
853 old_locals,
856 }
857 recursion_level--;
859 Property member;
861 /* Propagate the timestamp from the member file to the member*/
867 }
868 }
869 /*
870 * Check if we found any new auto dependencies when we
871 * built the target.
872 */
874 auto_count,
875 automatics)) {
877 (void) printf(gettext("%*sTarget `%s' acquired new dependencies from build, rechecking all dependencies\n"),
878 recursion_level,
881 }
885 }
889 }
892 }
894 /*
895 * DONE.
896 *
897 * check_dependencies(result, line, do_get,
898 * target, true_target, doing_subtree, out_of_date_tail,
899 * old_locals, implicit, command, less, rechecking_target)
900 *
901 * Return value:
902 * True returned if some dependencies left running
903 *
904 * Parameters:
905 * result Pointer to cell we update if build failed
906 * line We get the dependencies from here
907 * do_get Allow use of sccs get in recursive doname()
908 * target The target to chase dependencies for
909 * true_target The real one for :: and lib(member)
910 * doing_subtree True if building a conditional macro subtree
911 * out_of_date_tail Used to set the $? list
912 * old_locals Used for resetting the local macros
913 * implicit Called when scanning for implicit rules?
914 * command Place to stuff command
915 * less Set to $< value
916 *
917 * Global variables used:
918 * command_changed Set if we suspect .make.state needs rewrite
919 * debug_level Should we trace actions?
920 * force The Name " FORCE", compared against
921 * recursion_level Used for tracing
922 * rewrite_statefile Set if .make.state needs rewriting
923 * wait_name The Name ".WAIT", compared against
924 */
925 static Boolean
926 check_dependencies(Doname *result, Property line, Boolean do_get, Name target, Name true_target, Boolean doing_subtree, Chain *out_of_date_tail, Property old_locals, Boolean implicit, Property *command, Name less, Boolean rechecking_target, Boolean recheck_conditionals)
927 {
928 Boolean dependencies_running;
930 Doname dep_result;
936 }
940 /*
941 * Run thru all the dependencies and call doname() recursively
942 * on each of them.
943 */
951 /*
952 * We only bother with the autos when rechecking
953 */
955 }
958 /*
959 * The special target .WAIT means finish all of
960 * the prior dependencies before continuing.
961 */
964 }
967 /*
968 * If we can't execute the current dependency in
969 * parallel, hold off the dependency processing
970 * to preserve the order of the dependencies.
971 */
979 }
985 do_get,
988 }
990 /* should compare only secs, cause lib members does not have nsec time resolution */
992 this_dependency_changed =
993 dependency_changed =
995 }
998 this_dependency_changed =
999 dependency_changed =
1001 }
1002 }
1012 /*
1013 * If make can't figure out how to make a dependency, maybe the dependency
1014 * is out of date. In this case, we just declare the target out of date
1015 * and go on. If we really need the dependency, the make'ing of the target
1016 * will fail. This will only happen for automatic (hidden) dependencies.
1017 */
1020 }
1021 /*
1022 * Make sure the dependency is not saved
1023 * in the state file.
1024 */
1026 rewrite_statefile =
1027 command_changed =
1033 }
1035 }
1038 }
1042 }
1043 /*
1044 * Propagate new timestamp from "member" to
1045 * "lib.a(member)".
1046 */
1049 /* Collect the timestamp of the youngest dependency */
1054 /* Correction: do not consider nanosecs for members */
1057 }
1061 recursion_level,
1068 recursion_level,
1072 dependency_time));
1073 }
1074 }
1076 /* Build the $? list */
1082 /* Dina:
1083 * The next statement is commented
1084 * out as a fix for bug #1051032.
1085 * if dependency hasn't changed
1086 * then there's no need to invalidate
1087 * true_target. This statemnt causes
1088 * make to take much longer to process
1089 * an already-built archive. Soren
1090 * said it was a quick fix for some
1091 * problem he doesn't remember.
1092 true_target->stat.time = file_no_time;
1093 */
1095 }
1098 }
1099 Boolean out_of_date;
1106 }
1116 member_prop)->
1121 }
1127 recursion_level,
1133 recursion_level,
1137 }
1138 }
1139 }
1142 file_max_time;
1144 }
1145 }
1146 }
1151 old_locals,
1153 conditional_prop),
1155 }
1161 do_get,
1162 implicit,
1166 old_locals,
1168 conditional_prop),
1170 }
1172 }
1173 }
1174 /*
1175 * Collect the timestamp of the youngest double colon target
1176 * dependency.
1177 */
1182 Property tmp_line;
1189 }
1190 }
1191 }
1192 }
1195 }
1196 /*
1197 * After scanning all the dependencies, we check the rule
1198 * if we found one.
1199 */
1204 }
1206 /* Check if the target is out of date */
1207 Boolean out_of_date;
1214 }
1218 }
1219 }
1224 // set $< for explicit rule
1227 }
1229 // set $* for explicit rule
1230 Name target_body;
1232 Property member;
1236 Wstring targ_string;
1237 Wstring suf_string;
1241 NULL)) {
1243 }
1253 suffix_length)) {
1255 }
1259 );
1261 }
1263 // set result = build_ok so that implicit rules are not used.
1266 }
1267 }
1270 }
1271 }
1274 }
1276 /*
1277 * dynamic_dependencies(target)
1278 *
1279 * Checks if any dependency contains a macro ref
1280 * If so, it replaces the dependency with the expanded version.
1281 * Here, "$@" gets translated to target->string. That is
1282 * the current name on the left of the colon in the
1283 * makefile. Thus,
1284 * xyz: s.$@.c
1285 * translates into
1286 * xyz: s.xyz.c
1287 *
1288 * Also, "$(@F)" translates to the same thing without a preceeding
1289 * directory path (if one exists).
1290 * Note, to enter "$@" on a dependency line in a makefile
1291 * "$$@" must be typed. This is because make expands
1292 * macros in dependency lists upon reading them.
1293 * dynamic_dependencies() also expands file wildcards.
1294 * If there are any Shell meta characters in the name,
1295 * search the directory, and replace the dependency
1296 * with the set of files the pattern matches
1297 *
1298 * Parameters:
1299 * target Target to sanitize dependencies for
1300 *
1301 * Global variables used:
1302 * c_at The Name "@", used to set macro value
1303 * debug_level Should we trace actions?
1304 * dot The Name ".", used to read directory
1305 * recursion_level Used for tracing
1306 */
1307 void
1309 {
1312 Property line;
1315 String_rec string;
1319 Dependency new_depe;
1321 Dependency first_member;
1322 Name directory;
1323 Name lib;
1324 Name member;
1325 Property prop;
1331 }
1332 /* If the target is constructed from a "::" target we consider that */
1336 }
1337 /* Scan all dependencies and process the ones that contain "$" chars */
1343 }
1346 /* The make macro $@ is bound to the target name once per */
1347 /* invocation of dynamic_dependencies() */
1351 }
1352 /* Expand this dependency string */
1355 /* Scan the expanded string. It could contain whitespace */
1356 /* which mean it expands to several dependencies */
1359 start++;
1360 }
1361 /* Remove the cell (later) if the macro was empty */
1364 }
1366 /* azv 10/26/95 to fix bug BID_1170218 */
1370 }
1371 /* azv */
1374 /* We use the original dependency cell for the first */
1375 /* dependency from the expansion */
1377 /* We also have to deal with dependencies that expand to */
1378 /* lib.a(members) notation */
1386 start++;
1387 }
1389 }
1390 }
1392 /* First skip whitespace */
1398 }
1399 }
1400 /* Enter dependency from expansion */
1402 /* Create new dependency cell if */
1403 /* this is not the first dependency */
1404 /* picked from the expansion */
1413 }
1415 /* Internalize the dependency name */
1416 // tolik. Fix for bug 4110429: inconsistent expansion for macros that
1417 // include "//" and "/./"
1418 //dependency->name = GETNAME(start, p - start);
1423 recursion_level,
1427 }
1430 }
1433 /* If the expansion was of lib.a(members) format we now */
1434 /* enter the proper member cells */
1436 /* Scan the new dependencies and transform them from */
1437 /* "foo" to "lib.a(foo)" */
1439 /* Build "lib.a(foo)" name */
1447 FIND_LENGTH);
1450 /* Replace "foo" with "lib.a(foo)" */
1455 }
1458 recursion_level,
1461 string_mb,
1463 }
1465 /* Add member property to member */
1467 member_prop);
1473 }
1474 }
1475 }
1476 }
1477 Wstring wcb;
1478 /* Then scan all the dependencies again. This time we want to expand */
1479 /* shell file wildcards */
1486 }
1487 /* If dependency name string contains shell wildcards */
1488 /* replace the name with the expansion */
1493 /* lib(*) type pattern */
1513 }
1521 }
1522 /* The expansion is handled by the read_dir() routine*/
1527 }
1530 }
1531 }
1533 /* Then unbind $@ */
1535 }
1537 /*
1538 * DONE.
1539 *
1540 * run_command(line)
1541 *
1542 * Takes one Cmd_line and runs the commands from it.
1543 *
1544 * Return value:
1545 * Indicates if the command failed or not
1546 *
1547 * Parameters:
1548 * line The command line to run
1549 *
1550 * Global variables used:
1551 * commands_done Set if we do run command
1552 * current_line Set to the line we run a command from
1553 * current_target Set to the target we run a command for
1554 * file_number Used to form temp file name
1555 * keep_state Indicates that .KEEP_STATE is on
1556 * make_state The Name ".make.state", used to check timestamp
1557 * parallel True if currently building in parallel
1558 * parallel_process_cnt Count of parallel processes running
1559 * quest Indicates that make -q is on
1560 * rewrite_statefile Set if we do run a command
1561 * sunpro_dependencies The Name "SUNPRO_DEPENDENCIES", set value
1562 * temp_file_directory Used to form temp fie name
1563 * temp_file_name Set to the name of the temp file
1564 * touch Indicates that make -t is on
1565 */
1566 static Doname
1568 {
1578 }
1580 /*
1581 * Build the command if we know the target is out of date,
1582 * or if we want to check cmd consistency.
1583 */
1585 /* Hack for handling conditional macros in DMake. */
1588 }
1589 }
1590 /* Never mind */
1593 }
1594 /* If quest, then exit(1) because the target is out of date */
1598 }
1601 }
1602 /* We actually had to do something this time */
1604 /*
1605 * If this is an sccs command, we have to do some extra checking
1606 * and possibly complain. If the file can't be gotten because it's
1607 * checked out, we complain and behave as if the command was
1608 * executed eventhough we ignored the command.
1609 */
1617 }
1618 /*
1619 * If KEEP_STATE is on, we make sure we have the timestamp for
1620 * .make.state. If .make.state changes during the command run,
1621 * we reread .make.state after the command. We also setup the
1622 * environment variable that asks utilities to report dependencies.
1623 */
1625 keep_state &&
1633 }
1636 tmp_file_path,
1637 hostid,
1639 file_number++);
1641 Boolean fnd;
1649 }
1651 }
1656 sprodep_name,
1661 }
1663 /*
1664 * In case we are interrupted, we need to know what was going on.
1665 */
1667 /*
1668 * We also need to be able to save an empty command instead of the
1669 * interrupted one in .make.state.
1670 */
1673 /* Empty block!!! */
1678 }
1680 /*
1681 * If this is not a touch run, we need to execute the
1682 * proper command(s) for the target.
1683 */
1686 /*
1687 * We are building in parallel, but
1688 * this target must be built in serial.
1689 */
1690 /*
1691 * If nothing else is building,
1692 * do this one, else wait.
1693 */
1699 /*
1700 line->body.line.command_used = NULL;
1701 */
1704 }
1718 NULL;
1720 }
1721 }
1722 }
1725 }
1726 }
1730 }
1734 }
1736 /*
1737 * execute_serial(line)
1738 *
1739 * Runs thru the command line for the target and
1740 * executes the rules one by one.
1741 *
1742 * Return value:
1743 * The result of the command build
1744 *
1745 * Parameters:
1746 * line The command to execute
1747 *
1748 * Static variables used:
1749 *
1750 * Global variables used:
1751 * continue_after_error -k flag
1752 * do_not_exec_rule -n flag
1753 * report_dependencies -P flag
1754 * silent Don't echo commands before executing
1755 * temp_file_name Temp file for auto dependencies
1756 * vpath_defined If true, translate path for command
1757 */
1758 Doname
1760 {
1762 Boolean printed_serial;
1770 // We have to create a copy of the rules chain for processing because
1771 // the original one can be destroyed during .make.state file rereading.
1780 }
1782 }
1785 }
1789 }
1793 }
1794 /* Echo command line, maybe. */
1800 }
1802 /* Do assignment if command line prefixed with "=" */
1807 /* Execute command line. */
1812 /* ds 98.04.23 bug #4085164. make should always show error messages */
1814 /* BOOLEAN(rule->silent &&
1815 rule->ignore_error), */
1817 target);
1819 }
1822 }
1827 }
1832 }
1833 /*
1834 * Make sure a failing command is not
1835 * saved in .make.state.
1836 */
1841 }
1842 }
1843 }
1847 }
1851 }
1860 }
1861 }
1866 /*
1867 * Do not return memory allocated for SUNPRO_DEPENDENCIES
1868 * It will be returned in setvar_daemon() in macro.cc
1869 */
1870 // retmem_mb(val);
1872 }
1873 }
1876 }
1880 /*
1881 * vpath_translation(cmd)
1882 *
1883 * Translates one command line by
1884 * checking each word. If the word has an alias it is translated.
1885 *
1886 * Return value:
1887 * The translated command
1888 *
1889 * Parameters:
1890 * cmd Command to translate
1891 *
1892 * Global variables used:
1893 */
1894 Name
1896 {
1898 String_rec new_cmd;
1904 }
1913 }
1916 p++;
1917 }
1927 }
1928 }
1932 }
1934 }
1936 /*
1937 * check_state(temp_file_name)
1938 *
1939 * Reads and checks the state changed by the previously executed command.
1940 *
1941 * Parameters:
1942 * temp_file_name The auto dependency temp file
1943 *
1944 * Global variables used:
1945 */
1946 void
1948 {
1951 }
1953 /*
1954 * Then read the temp file that now might
1955 * contain dependency reports from utilities
1956 */
1959 /*
1960 * And reread .make.state if it
1961 * changed (the command ran recursive makes)
1962 */
1966 }
1967 }
1969 /*
1970 * read_dependency_file(filename)
1971 *
1972 * Read the temp file used for reporting dependencies to make
1973 *
1974 * Parameters:
1975 * filename The name of the file with the state info
1976 *
1977 * Global variables used:
1978 * makefile_type The type of makefile being read
1979 * read_trace_level Debug flag
1980 * temp_file_number The always increasing number for unique files
1981 * trace_reader Debug flag
1982 */
1983 static void
1985 {
1990 }
1997 }
1998 temp_file_number++;
2008 }
2009 }
2011 /*
2012 * check_read_state_file()
2013 *
2014 * Check if .make.state has changed
2015 * If it has we reread it
2016 *
2017 * Parameters:
2018 *
2019 * Global variables used:
2020 * make_state Make state file name
2021 * makefile_type Type of makefile being read
2022 * read_trace_level Debug flag
2023 * trace_reader Debug flag
2024 */
2025 static void
2027 {
2036 }
2039 /* Make sure we clear the old cached contents of .make.state */
2044 }
2047 }
2048 temp_file_number++;
2058 }
2060 /*
2061 * do_assign(line, target)
2062 *
2063 * Handles runtime assignments for command lines prefixed with "=".
2064 *
2065 * Parameters:
2066 * line The command that contains an assignment
2067 * target The Name of the target, used for error reports
2068 *
2069 * Global variables used:
2070 * assign_done Set to indicate doname needs to reprocess
2071 */
2072 static void
2074 {
2081 /*
2082 * If any runtime assignments are done, doname() must reprocess all
2083 * targets in the future since the macro values used to build the
2084 * command lines for the targets might have changed.
2085 */
2087 /* Skip white space. */
2089 string++;
2090 }
2092 /* Find "+=" or "=". */
2096 equal++;
2097 }
2098 /* Internalize macro name. */
2100 /* Skip over "+=" "=". */
2104 equal++;
2105 }
2113 equal++;
2115 }
2116 equal++;
2117 /* Skip over whitespace in front of value. */
2119 equal++;
2120 }
2121 /* Enter new macro value. */
2124 append);
2125 }
2127 /*
2128 * build_command_strings(target, line)
2129 *
2130 * Builds the command string to used when
2131 * building a target. If the string is different from the previous one
2132 * is_out_of_date is set.
2133 *
2134 * Parameters:
2135 * target Target to build commands for
2136 * line Where to stuff result
2137 *
2138 * Global variables used:
2139 * c_at The Name "@", used to set macro value
2140 * command_changed Set if command is different from old
2141 * debug_level Should we trace activities?
2142 * do_not_exec_rule Always echo when running -n
2143 * empty_name The Name "", used for empty rule
2144 * funny Semantics of characters
2145 * ignore_errors Used to init field for line
2146 * is_conditional Set to false befor evaling macro, checked
2147 * after expanding macros
2148 * keep_state Indicates that .KEEP_STATE is on
2149 * make_word_mentioned Set by macro eval, inits field for cmd
2150 * query The Name "?", used to set macro value
2151 * query_mentioned Set by macro eval, inits field for cmd
2152 * recursion_level Used for tracing
2153 * silent Used to init field for line
2154 */
2155 static void
2157 {
2158 String_rec command_line;
2164 Name new_command_line;
2167 Property member;
2171 Name tmp_name;
2180 }
2182 /* We have to check if a target depends on conditional macros */
2183 /* Targets that do must be reprocessed by doname() each time around */
2184 /* since the macro values used when building the target might have */
2185 /* changed */
2187 /* If we are building a lib.a(member) target $@ should be bound */
2188 /* to lib.a */
2192 }
2193 /* If we are building a "::" help target $@ should be bound to */
2194 /* the real target name */
2195 /* A lib.a(member) target is never :: */
2199 }
2200 /* Bind the magic macros that make supplies */
2206 }
2207 }
2215 }
2216 }
2224 }
2225 }
2233 }
2234 }
2237 /* $? is seldom used and it is expensive to build */
2238 /* so we store the list form and build the string on demand */
2249 }
2252 }
2256 chain_daemon,
2258 debug_level);
2260 /* build $^ */
2267 /* skip automatic dependencies */
2280 }
2287 }
2288 }
2292 }
2293 }
2294 }
2298 chain_daemon,
2300 debug_level);
2302 /* We have two command sequences we need to handle */
2303 /* The old one that we probably read from .make.state */
2304 /* and the new one we are building that will replace the old one */
2305 /* Even when KEEP_STATE is not on we build a new command sequence and store */
2306 /* it in the line prop. This command sequence is then executed by */
2307 /* run_command(). If KEEP_STATE is on it is also later written to */
2308 /* .make.state. The routine replaces the old command line by line with the */
2309 /* new one trying to reuse Cmd_lines */
2311 /* If there is no old command_used we have to start creating */
2312 /* Cmd_lines to keep the new cmd in */
2319 }
2320 /* Run thru the template for the new command and build the expanded */
2321 /* new command lines */
2325 /* If there is no old command_used Cmd_line we need to */
2326 /* create one and say that cmd consistency failed */
2332 }
2333 /* Prepare the Cmd_line for the processing */
2334 /* The command line prefixes "@-=?" are stripped and that */
2335 /* information is saved in the Cmd_line */
2340 /* Expand the macros in the command line */
2342 make_word_mentioned =
2343 query_mentioned =
2346 /* If the macro $(MAKE) is mentioned in the command */
2347 /* "make -n" runs actually execute the command */
2350 /* Strip the prefixes */
2355 start++) {
2372 }
2377 }
2379 }
2380 }
2381 /* If all command lines of the template are prefixed with "?"*/
2382 /* the VIRTUAL_ROOT is not used for cmd consistency checks */
2385 }
2386 /* Internalize the expanded and stripped command line */
2392 }
2393 /* Compare it with the old one for command consistency */
2402 (void) printf(gettext("%*sBuilding %s because new command \n\t%s\n%*sdifferent from old\n\t%s\n"),
2403 recursion_level,
2407 recursion_level,
2409 used->
2410 command_line->
2411 string_mb);
2413 (void) printf(gettext("%*sBuilding %s because new command \n\t%s\n%*sdifferent from empty old command\n"),
2414 recursion_level,
2418 recursion_level,
2420 }
2421 }
2424 }
2426 }
2429 }
2430 }
2431 /* Check if the old command is longer than the new for */
2432 /* command consistency */
2439 recursion_level,
2442 }
2445 }
2446 }
2447 /* Check if the new command is longer than the old command for */
2448 /* command consistency */
2451 keep_state) {
2454 recursion_level,
2457 }
2460 }
2461 /* Unbind the magic macros */
2469 }
2473 }
2479 }
2480 }
2482 /*
2483 * touch_command(line, target, result)
2484 *
2485 * If this is an "make -t" run we do this.
2486 * We touch all targets in the target group ("foo + fie:") if any.
2487 *
2488 * Return value:
2489 * Indicates if the command failed or not
2490 *
2491 * Parameters:
2492 * line The command line to update
2493 * target The target we are touching
2494 * result Initial value for the result we return
2495 *
2496 * Global variables used:
2497 * do_not_exec_rule Indicates that -n is on
2498 * silent Do not echo commands
2499 */
2500 static Doname
2502 {
2503 Name name;
2505 String_rec touch_string;
2507 Name touch_cmd;
2508 Cmd_line rule;
2512 /*
2513 * Build a touch command that can be passed
2514 * to dosys(). If KEEP_STATE is on, "make -t"
2515 * will save the proper command, not the
2516 * "touch" in .make.state.
2517 */
2524 vpath_alias_prop)->
2526 }
2529 FIND_LENGTH);
2531 FIND_LENGTH);
2534 }
2536 do_not_exec_rule &&
2539 }
2540 /* Run the touch command, or simulate it */
2547 name);
2550 }
2553 }
2558 }
2563 }
2564 }
2566 }
2568 /*
2569 * update_target(line, result)
2570 *
2571 * updates the status of a target after executing its commands.
2572 *
2573 * Parameters:
2574 * line The command line block to update
2575 * result Indicates that build is OK so can update
2576 *
2577 * Global variables used:
2578 * do_not_exec_rule Indicates that -n is on
2579 * touch Fake the new timestamp if we are just touching
2580 */
2581 void
2583 {
2584 Name target;
2585 Chain target_group;
2586 Property line2;
2587 timestruc_t old_stat_time;
2588 Property member;
2590 /*
2591 * [tolik] Additional fix for bug 1063790. It was fixed
2592 * for serial make long ago, but DMake dumps core when
2593 * target is a symlink and sccs file is newer then target.
2594 * In this case, finish_children() calls update_target()
2595 * with line==NULL.
2596 */
2598 /* XXX. Should we do anything here? */
2600 }
2606 touch ||
2611 /* If we are simulating execution we need to fake a */
2612 /* new timestamp for the target we didnt build */
2615 /*
2616 * If we really built the target we read the new
2617 * timestamp.
2618 * Fix for bug #1110906: if .c file is newer than
2619 * the corresponding .o file which is in an archive
2620 * file, make will compile the .c file but it won't
2621 * update the object in the .a file.
2622 */
2632 }
2633 }
2634 }
2635 /* If the target is part of a group we need to propagate the */
2636 /* result of the run to all members */
2642 line_prop);
2646 }
2647 }
2649 }
2651 /*
2652 * sccs_get(target, command)
2653 *
2654 * Figures out if it possible to sccs get a file
2655 * and builds the command to do it if it is.
2656 *
2657 * Return value:
2658 * Indicates if sccs get failed or not
2659 *
2660 * Parameters:
2661 * target Target to get
2662 * command Where to deposit command to use
2663 *
2664 * Global variables used:
2665 * debug_level Should we trace activities?
2666 * recursion_level Used for tracing
2667 * sccs_get_rule The rule to used for sccs getting
2668 */
2669 static Doname
2671 {
2674 String_rec string;
2677 timestruc_t sccs_time;
2681 /* For sccs, we need to chase symlinks. */
2684 fatal(gettext("Can't read symbolic link `%s': Number of symbolic links encountered during path name traversal exceeds 90."),
2686 }
2687 /* Read the value of the link. */
2689 link,
2691 NULL,
2692 VROOT_DEFAULT);
2696 }
2698 /* Use the value to build the proper filename. */
2705 }
2707 /* Replace the old name with the translated name. */
2712 }
2713 }
2715 /*
2716 * read_dir() also reads the ?/SCCS dir and saves information
2717 * about which files have SCSC/s. files.
2718 */
2721 }
2724 /* We dont know by now there is no SCCS/s.* */
2727 /*
2728 * If there is no SCCS/s.* but the plain file exists,
2729 * we say things are OK.
2730 */
2733 }
2734 /* If we cant find the plain file, we give up. */
2737 /*
2738 * Pay dirt. We now need to figure out if the plain file
2739 * is out of date relative to the SCCS/s.* file.
2740 */
2744 }
2749 /* only checking */
2752 }
2753 /*
2754 * We provide a command line for the target. The line is a
2755 * "sccs get" command from default.mk.
2756 */
2760 /*
2761 * And only if the plain file is out of date do we
2762 * request execution of the command.
2763 */
2767 recursion_level,
2770 }
2771 }
2784 }
2785 }
2786 }
2788 /*
2789 * Also make sure the rule is build with $* and $<
2790 * bound properly.
2791 */
2796 }
2798 }
2800 /*
2801 * read_directory_of_file(file)
2802 *
2803 * Reads the directory the specified file lives in.
2804 *
2805 * Parameters:
2806 * file The file we need to read dir for
2807 *
2808 * Global variables used:
2809 * dot The Name ".", used as the default dir
2810 */
2811 void
2813 {
2832 }
2834 /*
2835 * If the filename contains a "/" we have to extract the path
2836 * Else the path defaults to ".".
2837 */
2839 /*
2840 * Check some popular directories first to possibly
2841 * save time. Compare string length first to gain speed.
2842 */
2845 wcb,
2846 length)) {
2850 wcb,
2851 length)) {
2855 }
2856 }
2861 }
2863 /*
2864 * add_pattern_conditionals(target)
2865 *
2866 * Scan the list of conditionals defined for pattern targets and add any
2867 * that match this target to its list of conditionals.
2868 *
2869 * Parameters:
2870 * target The target we should add conditionals for
2871 *
2872 * Global variables used:
2873 * conditionals The list of pattern conditionals
2874 */
2875 static void
2877 {
2879 Property new_prop;
2881 Name_rec dummy;
2887 Wstring wcb1;
2896 /* Check for possible buffer under-read */
2899 }
2903 }
2904 }
2912 }
2913 }
2921 }
2924 }
2925 }
2927 /*
2928 * set_locals(target, old_locals)
2929 *
2930 * Sets any conditional macros for the target.
2931 * Each target carries a possibly empty set of conditional properties.
2932 *
2933 * Parameters:
2934 * target The target to set conditional macros for
2935 * old_locals Space to store old values in
2936 *
2937 * Global variables used:
2938 * debug_level Should we trace activity?
2939 * is_conditional We need to preserve this value
2940 * recursion_level Used for tracing
2941 */
2942 void
2944 {
2948 Chain cond_name;
2949 Chain cond_chain;
2953 }
2957 /* Scan the list of conditional properties and apply each one */
2961 i++) {
2962 /* Save the old value */
2968 recursion_level,
2970 }
2971 /* Set the conditional value. Macros are expanded when the */
2972 /* macro is refd as usual */
2978 }
2981 }
2982 /* Put this target on the front of the chain of conditional targets */
2988 }
2990 /*
2991 * reset_locals(target, old_locals, conditional, index)
2992 *
2993 * Removes any conditional macros for the target.
2994 *
2995 * Parameters:
2996 * target The target we are retoring values for
2997 * old_locals The values to restore
2998 * conditional The first conditional block for the target
2999 * index into the old_locals vector
3000 * Global variables used:
3001 * debug_level Should we trace activities?
3002 * recursion_level Used for tracing
3003 */
3004 void
3005 reset_locals(register Name target, register Property old_locals, register Property conditional, register int index)
3006 {
3008 Chain cond_chain;
3012 }
3014 /* Scan the list of conditional properties and restore the old value */
3015 /* to each one Reverse the order relative to when we assigned macros */
3020 /* Remove conditional target from chain */
3028 }
3029 }
3034 }
3038 recursion_level,
3041 string_mb,
3043 string_mb);
3046 recursion_level,
3049 string_mb);
3050 }
3051 }
3052 }
3054 /*
3055 * check_auto_dependencies(target, auto_count, automatics)
3056 *
3057 * Returns true if the target now has a dependency
3058 * it didn't previously have (saved on automatics).
3059 *
3060 * Return value:
3061 * true if new dependency found
3062 *
3063 * Parameters:
3064 * target Target we check
3065 * auto_count Number of old automatic vars
3066 * automatics Saved old automatics
3067 *
3068 * Global variables used:
3069 * keep_state Indicates that .KEEP_STATE is on
3070 */
3071 Boolean
3073 {
3076 Property line;
3077 Dependency dependency;
3082 }
3083 /* Go thru new list of automatic depes */
3087 /* And make sure that each one existed before we */
3088 /* built the target */
3092 n--) {
3094 /* If we can find it on the */
3095 /* saved list of autos we */
3096 /* are OK */
3098 }
3099 }
3100 /* But if we scan over the old list */
3101 /* of auto. without finding it it is */
3102 /* new and we must check it */
3104 }
3105 not_new:;
3106 }
3110 }
3111 }
3114 // Recursively delete each of the Chain struct on the chain.
3116 static void
3118 {
3124 }
3125 }
3127 Doname
3131 Property line;
3135 }
3136 /*
3137 * If the target is a constructed one for a "::" target,
3138 * we need to consider that.
3139 */
3143 }
3149 }
3152 }
3154 /* get line property for the target */
3157 /* first check for explicit rule */
3160 }
3161 /* try to find pattern rule */
3164 }
3166 /* try to find double suffix rule */
3174 }
3177 }
3178 }
3180 /* try to find suffix rule */
3183 }
3185 /* check for sccs */
3188 }
3190 /* try to find dyn target */
3195 }
3196 }
3198 /* check whether target was mentioned in makefile */
3202 }
3203 }
3205 /* result */
3207 }