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 2005 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * misc.cc
28 *
29 * This file contains various unclassified routines. Some main groups:
30 * getname
31 * Memory allocation
32 * String handling
33 * Property handling
34 * Error message handling
35 * Make internal state dumping
36 * main routine support
37 */
38
39 /*
40 * Included files
41 */
42 #include <errno.h>
43 #include <mk/defs.h>
44 #include <mksh/macro.h> /* SETVAR() */
45 #include <mksh/misc.h> /* enable_interrupt() */
46 #include <stdarg.h> /* va_list, va_start(), va_end() */
47 #include <vroot/report.h> /* SUNPRO_DEPENDENCIES */
48
49
50 #ifdef TEAMWARE_MAKE_CMN
51 #define MAXJOBS_ADJUST_RFE4694000
52
53 #ifdef MAXJOBS_ADJUST_RFE4694000
54 extern void job_adjust_fini();
55 #endif /* MAXJOBS_ADJUST_RFE4694000 */
56 #endif /* TEAMWARE_MAKE_CMN */
57
58
59 /*
60 * Defined macros
61 */
62
63 /*
64 * typedefs & structs
65 */
66
67 /*
68 * Static variables
69 */
70
71 /*
72 * File table of contents
73 */
74 static void print_rule(register Name target);
75 static void print_target_n_deps(register Name target);
76
77 /*****************************************
78 *
79 * getname
80 */
81
82 /*****************************************
83 *
84 * Memory allocation
85 */
86
87 /*
88 * free_chain()
89 *
90 * frees a chain of Name_vector's
91 *
92 * Parameters:
93 * ptr Pointer to the first element in the chain
94 * to be freed.
95 *
96 * Global variables used:
97 */
98 void
99 free_chain(Name_vector ptr)
100 {
101 if (ptr != NULL) {
102 if (ptr->next != NULL) {
103 free_chain(ptr->next);
104 }
105 free((char *) ptr);
106 }
107 }
108
109 /*****************************************
110 *
111 * String manipulation
112 */
113
114 /*****************************************
115 *
116 * Nameblock property handling
117 */
118
119 /*****************************************
120 *
121 * Error message handling
122 */
123
124 /*
125 * fatal(format, args...)
126 *
127 * Print a message and die
128 *
129 * Parameters:
130 * format printf type format string
131 * args Arguments to match the format
132 *
133 * Global variables used:
134 * fatal_in_progress Indicates if this is a recursive call
135 * parallel_process_cnt Do we need to wait for anything?
136 * report_pwd Should we report the current path?
137 */
138 /*VARARGS*/
139 void
140 fatal(const char *message, ...)
141 {
142 va_list args;
143
144 va_start(args, message);
145 (void) fflush(stdout);
146 (void) fprintf(stderr, catgets(catd, 1, 263, "make: Fatal error: "));
147 (void) vfprintf(stderr, message, args);
148 (void) fprintf(stderr, "\n");
149 va_end(args);
150 if (report_pwd) {
151 (void) fprintf(stderr,
152 catgets(catd, 1, 156, "Current working directory %s\n"),
153 get_current_path());
154 }
155 (void) fflush(stderr);
156 if (fatal_in_progress) {
157 exit_status = 1;
158 exit(1);
159 }
160 fatal_in_progress = true;
161 #ifdef TEAMWARE_MAKE_CMN
162 /* Let all parallel children finish */
163 if ((dmake_mode_type == parallel_mode) &&
164 (parallel_process_cnt > 0)) {
165 (void) fprintf(stderr,
166 catgets(catd, 1, 157, "Waiting for %d %s to finish\n"),
167 parallel_process_cnt,
168 parallel_process_cnt == 1 ?
169 catgets(catd, 1, 158, "job") : catgets(catd, 1, 159, "jobs"));
170 (void) fflush(stderr);
171 }
172
173 while (parallel_process_cnt > 0) {
174 await_parallel(true);
175 finish_children(false);
176 }
177 #endif
178
179 #if defined (TEAMWARE_MAKE_CMN) && defined (MAXJOBS_ADJUST_RFE4694000)
180 job_adjust_fini();
181 #endif
182
183 exit_status = 1;
184 exit(1);
185 }
186
187 /*
188 * warning(format, args...)
189 *
190 * Print a message and continue.
191 *
192 * Parameters:
193 * format printf type format string
194 * args Arguments to match the format
195 *
196 * Global variables used:
197 * report_pwd Should we report the current path?
198 */
199 /*VARARGS*/
200 void
201 warning(char * message, ...)
202 {
203 va_list args;
204
205 va_start(args, message);
206 (void) fflush(stdout);
207 (void) fprintf(stderr, catgets(catd, 1, 265, "make: Warning: "));
208 (void) vfprintf(stderr, message, args);
209 (void) fprintf(stderr, "\n");
210 va_end(args);
211 if (report_pwd) {
212 (void) fprintf(stderr,
213 catgets(catd, 1, 161, "Current working directory %s\n"),
214 get_current_path());
215 }
216 (void) fflush(stderr);
217 }
218
219 /*
220 * time_to_string(time)
221 *
222 * Take a numeric time value and produce
223 * a proper string representation.
224 *
225 * Return value:
226 * The string representation of the time
227 *
228 * Parameters:
229 * time The time we need to translate
230 *
231 * Global variables used:
232 */
233 char *
234 time_to_string(const timestruc_t &time)
235 {
236 struct tm *tm;
237 char buf[128];
238
239 if (time == file_doesnt_exist) {
240 return catgets(catd, 1, 163, "File does not exist");
241 }
242 if (time == file_max_time) {
243 return catgets(catd, 1, 164, "Younger than any file");
244 }
245 tm = localtime(&time.tv_sec);
246 strftime(buf, sizeof (buf), NOCATGETS("%c %Z"), tm);
247 buf[127] = (int) nul_char;
248 return strdup(buf);
249 }
250
251 /*
252 * get_current_path()
253 *
254 * Stuff current_path with the current path if it isnt there already.
255 *
256 * Parameters:
257 *
258 * Global variables used:
259 */
260 char *
261 get_current_path(void)
262 {
263 char pwd[(MAXPATHLEN * MB_LEN_MAX)];
264 static char *current_path;
265
266 if (current_path == NULL) {
267 getcwd(pwd, sizeof(pwd));
268 if (pwd[0] == (int) nul_char) {
269 pwd[0] = (int) slash_char;
270 pwd[1] = (int) nul_char;
271 }
272 current_path = strdup(pwd);
273 }
274 return current_path;
275 }
276
277 /*****************************************
278 *
279 * Make internal state dumping
280 *
281 * This is a set of routines for dumping the internal make state
282 * Used for the -p option
283 */
284
285 /*
286 * dump_make_state()
287 *
288 * Dump make's internal state to stdout
289 *
290 * Parameters:
291 *
292 * Global variables used:
293 * svr4 Was ".SVR4" seen in makefile?
294 * svr4_name The Name ".SVR4", printed
295 * posix Was ".POSIX" seen in makefile?
296 * posix_name The Name ".POSIX", printed
297 * default_rule Points to the .DEFAULT rule
298 * default_rule_name The Name ".DEFAULT", printed
299 * default_target_to_build The first target to print
300 * dot_keep_state The Name ".KEEP_STATE", printed
301 * dot_keep_state_file The Name ".KEEP_STATE_FILE", printed
302 * hashtab The make hash table for Name blocks
303 * ignore_errors Was ".IGNORE" seen in makefile?
304 * ignore_name The Name ".IGNORE", printed
305 * keep_state Was ".KEEP_STATE" seen in makefile?
306 * percent_list The list of % rules
307 * precious The Name ".PRECIOUS", printed
308 * sccs_get_name The Name ".SCCS_GET", printed
309 * sccs_get_posix_name The Name ".SCCS_GET_POSIX", printed
310 * get_name The Name ".GET", printed
311 * get_posix_name The Name ".GET_POSIX", printed
312 * sccs_get_rule Points to the ".SCCS_GET" rule
313 * silent Was ".SILENT" seen in makefile?
314 * silent_name The Name ".SILENT", printed
315 * suffixes The suffix list from ".SUFFIXES"
316 * suffixes_name The Name ".SUFFIX", printed
317 */
318 void
319 dump_make_state(void)
320 {
321 Name_set::iterator p, e;
322 register Property prop;
323 register Dependency dep;
324 register Cmd_line rule;
325 Percent percent, percent_depe;
326
327 /* Default target */
328 if (default_target_to_build != NULL) {
329 print_rule(default_target_to_build);
330 }
331 (void) printf("\n");
332
333 /* .POSIX */
334 if (posix) {
335 (void) printf("%s:\n", posix_name->string_mb);
336 }
337
338 /* .DEFAULT */
339 if (default_rule != NULL) {
340 (void) printf("%s:\n", default_rule_name->string_mb);
341 for (rule = default_rule; rule != NULL; rule = rule->next) {
342 (void) printf("\t%s\n", rule->command_line->string_mb);
343 }
344 }
345
346 /* .IGNORE */
347 if (ignore_errors) {
348 (void) printf("%s:\n", ignore_name->string_mb);
349 }
350
351 /* .KEEP_STATE: */
352 if (keep_state) {
353 (void) printf("%s:\n\n", dot_keep_state->string_mb);
354 }
355
356 /* .PRECIOUS */
357 (void) printf("%s:", precious->string_mb);
358 for (p = hashtab.begin(), e = hashtab.end(); p != e; p++) {
359 if ((p->stat.is_precious) || (all_precious)) {
360 (void) printf(" %s", p->string_mb);
361 }
362 }
363 (void) printf("\n");
364
365 /* .SCCS_GET */
366 if (sccs_get_rule != NULL) {
367 (void) printf("%s:\n", sccs_get_name->string_mb);
368 for (rule = sccs_get_rule; rule != NULL; rule = rule->next) {
369 (void) printf("\t%s\n", rule->command_line->string_mb);
370 }
371 }
372
373 /* .SILENT */
374 if (silent) {
375 (void) printf("%s:\n", silent_name->string_mb);
376 }
377
378 /* .SUFFIXES: */
379 (void) printf("%s:", suffixes_name->string_mb);
380 for (dep = suffixes; dep != NULL; dep = dep->next) {
381 (void) printf(" %s", dep->name->string_mb);
382 build_suffix_list(dep->name);
383 }
384 (void) printf("\n\n");
385
386 /* % rules */
387 for (percent = percent_list;
388 percent != NULL;
389 percent = percent->next) {
390 (void) printf("%s:",
391 percent->name->string_mb);
392
393 for (percent_depe = percent->dependencies;
394 percent_depe != NULL;
395 percent_depe = percent_depe->next) {
396 (void) printf(" %s", percent_depe->name->string_mb);
397 }
398
399 (void) printf("\n");
400
401 for (rule = percent->command_template;
402 rule != NULL;
403 rule = rule->next) {
404 (void) printf("\t%s\n", rule->command_line->string_mb);
405 }
406 }
407
408 /* Suffix rules */
409 for (p = hashtab.begin(), e = hashtab.end(); p != e; p++) {
410 Wstring wcb(p);
411 if (wcb.get_string()[0] == (int) period_char) {
412 print_rule(p);
413 }
414 }
415
416 /* Macro assignments */
417 for (p = hashtab.begin(), e = hashtab.end(); p != e; p++) {
418 if (((prop = get_prop(p->prop, macro_prop)) != NULL) &&
419 (prop->body.macro.value != NULL)) {
420 (void) printf("%s", p->string_mb);
421 print_value(prop->body.macro.value,
422 (Daemon) prop->body.macro.daemon);
423 }
424 }
425 (void) printf("\n");
426
427 /* Conditional macro assignments */
428 for (p = hashtab.begin(), e = hashtab.end(); p != e; p++) {
429 for (prop = get_prop(p->prop, conditional_prop);
430 prop != NULL;
431 prop = get_prop(prop->next, conditional_prop)) {
432 (void) printf("%s := %s",
433 p->string_mb,
434 prop->body.conditional.name->
435 string_mb);
436 if (prop->body.conditional.append) {
437 printf(" +");
438 }
439 else {
440 printf(" ");
441 }
442 print_value(prop->body.conditional.value,
443 no_daemon);
444 }
445 }
446 (void) printf("\n");
447
448 /* All other dependencies */
449 for (p = hashtab.begin(), e = hashtab.end(); p != e; p++) {
450 if (p->colons != no_colon) {
451 print_rule(p);
452 }
453 }
454 (void) printf("\n");
455 }
456
457 /*
458 * print_rule(target)
459 *
460 * Print the rule for one target
461 *
462 * Parameters:
463 * target Target we print rule for
464 *
465 * Global variables used:
466 */
467 static void
468 print_rule(register Name target)
469 {
470 register Cmd_line rule;
471 register Property line;
472 register Dependency dependency;
473
474 if (target->dependency_printed ||
475 ((line = get_prop(target->prop, line_prop)) == NULL) ||
476 ((line->body.line.command_template == NULL) &&
477 (line->body.line.dependencies == NULL))) {
478 return;
479 }
480 target->dependency_printed = true;
481
482 (void) printf("%s:", target->string_mb);
483
484 for (dependency = line->body.line.dependencies;
485 dependency != NULL;
486 dependency = dependency->next) {
487 (void) printf(" %s", dependency->name->string_mb);
488 }
489
490 (void) printf("\n");
491
492 for (rule = line->body.line.command_template;
493 rule != NULL;
494 rule = rule->next) {
495 (void) printf("\t%s\n", rule->command_line->string_mb);
496 }
497 }
498
499 void
500 dump_target_list(void)
501 {
502 Name_set::iterator p, e;
503 Wstring str;
504
505 for (p = hashtab.begin(), e = hashtab.end(); p != e; p++) {
506 str.init(p);
507 wchar_t * wcb = str.get_string();
508 if ((p->colons != no_colon) &&
509 ((wcb[0] != (int) period_char) ||
510 ((wcb[0] == (int) period_char) &&
511 (wschr(wcb, (int) slash_char))))) {
512 print_target_n_deps(p);
513 }
514 }
515 }
516
517 static void
518 print_target_n_deps(register Name target)
519 {
520 register Cmd_line rule;
521 register Property line;
522 register Dependency dependency;
523
524 if (target->dependency_printed) {
525 return;
526 }
527 target->dependency_printed = true;
528
529 (void) printf("%s\n", target->string_mb);
530
531 if ((line = get_prop(target->prop, line_prop)) == NULL) {
532 return;
533 }
534 for (dependency = line->body.line.dependencies;
535 dependency != NULL;
536 dependency = dependency->next) {
537 if (!dependency->automatic) {
538 print_target_n_deps(dependency->name);
539 }
540 }
541 }
542
543 /*****************************************
544 *
545 * main() support
546 */
547
548 /*
549 * load_cached_names()
550 *
551 * Load the vector of cached names
552 *
553 * Parameters:
554 *
555 * Global variables used:
556 * Many many pointers to Name blocks.
557 */
558 void
559 load_cached_names(void)
560 {
561 char *cp;
562 Name dollar;
563
564 /* Load the cached_names struct */
565 MBSTOWCS(wcs_buffer, NOCATGETS(".BUILT_LAST_MAKE_RUN"));
566 built_last_make_run = GETNAME(wcs_buffer, FIND_LENGTH);
567 MBSTOWCS(wcs_buffer, NOCATGETS("@"));
568 c_at = GETNAME(wcs_buffer, FIND_LENGTH);
569 MBSTOWCS(wcs_buffer, NOCATGETS(" *conditionals* "));
570 conditionals = GETNAME(wcs_buffer, FIND_LENGTH);
571 /*
572 * A version of make was released with NSE 1.0 that used
573 * VERSION-1.1 but this version is identical to VERSION-1.0.
574 * The version mismatch code makes a special case for this
575 * situation. If the version number is changed from 1.0
576 * it should go to 1.2.
577 */
578 MBSTOWCS(wcs_buffer, NOCATGETS("VERSION-1.0"));
579 current_make_version = GETNAME(wcs_buffer, FIND_LENGTH);
580 MBSTOWCS(wcs_buffer, NOCATGETS(".SVR4"));
581 svr4_name = GETNAME(wcs_buffer, FIND_LENGTH);
582 MBSTOWCS(wcs_buffer, NOCATGETS(".POSIX"));
583 posix_name = GETNAME(wcs_buffer, FIND_LENGTH);
584 MBSTOWCS(wcs_buffer, NOCATGETS(".DEFAULT"));
585 default_rule_name = GETNAME(wcs_buffer, FIND_LENGTH);
586 MBSTOWCS(wcs_buffer, NOCATGETS("$"));
587 dollar = GETNAME(wcs_buffer, FIND_LENGTH);
588 MBSTOWCS(wcs_buffer, NOCATGETS(".DONE"));
589 done = GETNAME(wcs_buffer, FIND_LENGTH);
590 MBSTOWCS(wcs_buffer, NOCATGETS("."));
591 dot = GETNAME(wcs_buffer, FIND_LENGTH);
592 MBSTOWCS(wcs_buffer, NOCATGETS(".KEEP_STATE"));
593 dot_keep_state = GETNAME(wcs_buffer, FIND_LENGTH);
594 MBSTOWCS(wcs_buffer, NOCATGETS(".KEEP_STATE_FILE"));
595 dot_keep_state_file = GETNAME(wcs_buffer, FIND_LENGTH);
596 MBSTOWCS(wcs_buffer, NOCATGETS(""));
597 empty_name = GETNAME(wcs_buffer, FIND_LENGTH);
598 MBSTOWCS(wcs_buffer, NOCATGETS(" FORCE"));
599 force = GETNAME(wcs_buffer, FIND_LENGTH);
600 MBSTOWCS(wcs_buffer, NOCATGETS("HOST_ARCH"));
601 host_arch = GETNAME(wcs_buffer, FIND_LENGTH);
602 MBSTOWCS(wcs_buffer, NOCATGETS("HOST_MACH"));
603 host_mach = GETNAME(wcs_buffer, FIND_LENGTH);
604 MBSTOWCS(wcs_buffer, NOCATGETS(".IGNORE"));
605 ignore_name = GETNAME(wcs_buffer, FIND_LENGTH);
606 MBSTOWCS(wcs_buffer, NOCATGETS(".INIT"));
607 init = GETNAME(wcs_buffer, FIND_LENGTH);
608 MBSTOWCS(wcs_buffer, NOCATGETS(".LOCAL"));
609 localhost_name = GETNAME(wcs_buffer, FIND_LENGTH);
610 MBSTOWCS(wcs_buffer, NOCATGETS(".make.state"));
611 make_state = GETNAME(wcs_buffer, FIND_LENGTH);
612 MBSTOWCS(wcs_buffer, NOCATGETS("MAKEFLAGS"));
613 makeflags = GETNAME(wcs_buffer, FIND_LENGTH);
614 MBSTOWCS(wcs_buffer, NOCATGETS(".MAKE_VERSION"));
615 make_version = GETNAME(wcs_buffer, FIND_LENGTH);
616 MBSTOWCS(wcs_buffer, NOCATGETS(".NO_PARALLEL"));
617 no_parallel_name = GETNAME(wcs_buffer, FIND_LENGTH);
618 MBSTOWCS(wcs_buffer, NOCATGETS(".NOT_AUTO"));
619 not_auto = GETNAME(wcs_buffer, FIND_LENGTH);
620 MBSTOWCS(wcs_buffer, NOCATGETS(".PARALLEL"));
621 parallel_name = GETNAME(wcs_buffer, FIND_LENGTH);
622 MBSTOWCS(wcs_buffer, NOCATGETS("PATH"));
623 path_name = GETNAME(wcs_buffer, FIND_LENGTH);
624 MBSTOWCS(wcs_buffer, NOCATGETS("+"));
625 plus = GETNAME(wcs_buffer, FIND_LENGTH);
626 MBSTOWCS(wcs_buffer, NOCATGETS(".PRECIOUS"));
627 precious = GETNAME(wcs_buffer, FIND_LENGTH);
628 MBSTOWCS(wcs_buffer, NOCATGETS("?"));
629 query = GETNAME(wcs_buffer, FIND_LENGTH);
630 MBSTOWCS(wcs_buffer, NOCATGETS("^"));
631 hat = GETNAME(wcs_buffer, FIND_LENGTH);
632 MBSTOWCS(wcs_buffer, NOCATGETS(".RECURSIVE"));
633 recursive_name = GETNAME(wcs_buffer, FIND_LENGTH);
634 MBSTOWCS(wcs_buffer, NOCATGETS(".SCCS_GET"));
635 sccs_get_name = GETNAME(wcs_buffer, FIND_LENGTH);
636 MBSTOWCS(wcs_buffer, NOCATGETS(".SCCS_GET_POSIX"));
637 sccs_get_posix_name = GETNAME(wcs_buffer, FIND_LENGTH);
638 MBSTOWCS(wcs_buffer, NOCATGETS(".GET"));
639 get_name = GETNAME(wcs_buffer, FIND_LENGTH);
640 MBSTOWCS(wcs_buffer, NOCATGETS(".GET_POSIX"));
641 get_posix_name = GETNAME(wcs_buffer, FIND_LENGTH);
642 MBSTOWCS(wcs_buffer, NOCATGETS("SHELL"));
643 shell_name = GETNAME(wcs_buffer, FIND_LENGTH);
644 MBSTOWCS(wcs_buffer, NOCATGETS(".SILENT"));
645 silent_name = GETNAME(wcs_buffer, FIND_LENGTH);
646 MBSTOWCS(wcs_buffer, NOCATGETS(".SUFFIXES"));
647 suffixes_name = GETNAME(wcs_buffer, FIND_LENGTH);
648 MBSTOWCS(wcs_buffer, SUNPRO_DEPENDENCIES);
649 sunpro_dependencies = GETNAME(wcs_buffer, FIND_LENGTH);
650 MBSTOWCS(wcs_buffer, NOCATGETS("TARGET_ARCH"));
651 target_arch = GETNAME(wcs_buffer, FIND_LENGTH);
652 MBSTOWCS(wcs_buffer, NOCATGETS("TARGET_MACH"));
653 target_mach = GETNAME(wcs_buffer, FIND_LENGTH);
654 MBSTOWCS(wcs_buffer, NOCATGETS("VIRTUAL_ROOT"));
655 virtual_root = GETNAME(wcs_buffer, FIND_LENGTH);
656 MBSTOWCS(wcs_buffer, NOCATGETS("VPATH"));
657 vpath_name = GETNAME(wcs_buffer, FIND_LENGTH);
658 MBSTOWCS(wcs_buffer, NOCATGETS(".WAIT"));
659 wait_name = GETNAME(wcs_buffer, FIND_LENGTH);
660
661 wait_name->state = build_ok;
662
663 /* Mark special targets so that the reader treats them properly */
664 svr4_name->special_reader = svr4_special;
665 posix_name->special_reader = posix_special;
666 built_last_make_run->special_reader = built_last_make_run_special;
667 default_rule_name->special_reader = default_special;
668 dot_keep_state->special_reader = keep_state_special;
669 dot_keep_state_file->special_reader = keep_state_file_special;
670 ignore_name->special_reader = ignore_special;
671 make_version->special_reader = make_version_special;
672 no_parallel_name->special_reader = no_parallel_special;
673 parallel_name->special_reader = parallel_special;
674 localhost_name->special_reader = localhost_special;
675 precious->special_reader = precious_special;
676 sccs_get_name->special_reader = sccs_get_special;
677 sccs_get_posix_name->special_reader = sccs_get_posix_special;
678 get_name->special_reader = get_special;
679 get_posix_name->special_reader = get_posix_special;
680 silent_name->special_reader = silent_special;
681 suffixes_name->special_reader = suffixes_special;
682
683 /* The value of $$ is $ */
684 (void) SETVAR(dollar, dollar, false);
685 dollar->dollar = false;
686
687 /* Set the value of $(SHELL) */
688 if (posix) {
689 MBSTOWCS(wcs_buffer, NOCATGETS("/usr/xpg4/bin/sh"));
690 } else {
691 MBSTOWCS(wcs_buffer, NOCATGETS("/bin/sh"));
692 }
693 (void) SETVAR(shell_name, GETNAME(wcs_buffer, FIND_LENGTH), false);
694
695 /*
696 * Use " FORCE" to simulate a FRC dependency for :: type
697 * targets with no dependencies.
698 */
699 (void) append_prop(force, line_prop);
700 force->stat.time = file_max_time;
701
702 /* Make sure VPATH is defined before current dir is read */
703 if ((cp = getenv(vpath_name->string_mb)) != NULL) {
704 MBSTOWCS(wcs_buffer, cp);
705 (void) SETVAR(vpath_name,
706 GETNAME(wcs_buffer, FIND_LENGTH),
707 false);
708 }
709
710 /* Check if there is NO PATH variable. If not we construct one. */
711 if (getenv(path_name->string_mb) == NULL) {
712 vroot_path = NULL;
713 add_dir_to_path(NOCATGETS("."), &vroot_path, -1);
714 add_dir_to_path(NOCATGETS("/bin"), &vroot_path, -1);
715 add_dir_to_path(NOCATGETS("/usr/bin"), &vroot_path, -1);
716 }
717 }
718
719 /*
720 * iterate on list of conditional macros in np, and place them in
721 * a String_rec starting with, and separated by the '$' character.
722 */
723 void
724 cond_macros_into_string(Name np, String_rec *buffer)
725 {
726 Macro_list macro_list;
727
728 /*
729 * Put the version number at the start of the string
730 */
731 MBSTOWCS(wcs_buffer, DEPINFO_FMT_VERSION);
732 append_string(wcs_buffer, buffer, FIND_LENGTH);
733 /*
734 * Add the rest of the conditional macros to the buffer
735 */
736 if (np->depends_on_conditional){
737 for (macro_list = np->conditional_macro_list;
738 macro_list != NULL; macro_list = macro_list->next){
739 append_string(macro_list->macro_name, buffer,
740 FIND_LENGTH);
741 append_char((int) equal_char, buffer);
742 append_string(macro_list->value, buffer, FIND_LENGTH);
743 append_char((int) dollar_char, buffer);
744 }
745 }
746 }
747 /*
748 * Copyright (c) 1987-1992 Sun Microsystems, Inc. All Rights Reserved.
749 * Sun considers its source code as an unpublished, proprietary
750 * trade secret, and it is available only under strict license
751 * provisions. This copyright notice is placed here only to protect
752 * Sun in the event the source is deemed a published work. Dissassembly,
753 * decompilation, or other means of reducing the object code to human
754 * readable form is prohibited by the license agreement under which
755 * this code is provided to the user or company in possession of this
756 * copy.
757 * RESTRICTED RIGHTS LEGEND: Use, duplication, or disclosure by the
758 * Government is subject to restrictions as set forth in subparagraph
759 * (c)(1)(ii) of the Rights in Technical Data and Computer Software
760 * clause at DFARS 52.227-7013 and in similar clauses in the FAR and
761 * NASA FAR Supplement.
762 *
763 * 1.3 91/09/30
764 */
765
766
767 /* Some includes are commented because of the includes at the beginning */
768 /* #include <signal.h> */
769 #include <sys/types.h>
770 #include <sys/stat.h>
771 #include <sys/param.h>
772 /* #include <string.h> */
773 #include <unistd.h>
774 #include <stdlib.h>
775 /* #include <stdio.h> */
776 /* #include <avo/find_dir.h> */
777 /* #ifndef TEAMWARE_MAKE_CMN
778 #include <avo/find_dir.h>
779 #endif */
780
781 /* Routines to find the base directory name from which the various components
782 * -executables, *crt* libraries etc will be accessed
783 */
784
785 /* This routine checks to see if a given filename is an executable or not.
786 Logically similar to the csh statement : if ( -x $i && ! -d $i )
787 */
788
789 static int
790 check_if_exec(char *file)
791 {
792 struct stat stb;
793 if (stat(file, &stb) < 0) {
794 return ( -1);
795 }
796 if (S_ISDIR(stb.st_mode)) {
797 return (-1);
798 }
799 if (!(stb.st_mode & S_IEXEC)) {
800 return ( -1);
801 }
802 return (0);
803 }
804
805 /* resolve - check for specified file in specified directory
806 * sets up dir, following symlinks.
807 * returns zero for success, or
808 * -1 for error (with errno set properly)
809 */
810 static int
811 resolve (const char *indir, /* search directory */
812 const char *cmd, /* search for name */
813 char *dir, /* directory buffer */
814 char **run) /* resultion name ptr ptr */
815 {
816 char *p;
817 int rv = -1;
818 int sll;
819 char symlink[MAXPATHLEN + 1];
820
821 do {
822 errno = ENAMETOOLONG;
823 if ((strlen (indir) + strlen (cmd) + 2) > (size_t) MAXPATHLEN)
824 break;
825
826 sprintf(dir, "%s/%s", indir, cmd);
827 if (check_if_exec(dir) != 0) /* check if dir is an executable */
828 {
829 break; /* Not an executable program */
830 }
831
832 /* follow symbolic links */
833 while ((sll = readlink (dir, symlink, MAXPATHLEN)) >= 0) {
834 symlink[sll] = 0;
835 if (*symlink == '/')
836 strcpy (dir, symlink);
837 else
838 sprintf (strrchr (dir, '/'), "/%s", symlink);
839 }
840 if (errno != EINVAL)
841 break;
842
843 p = strrchr (dir, '/');
844 *p++ = 0;
845 if (run) /* user wants resolution name */
846 *run = p;
847 rv = 0; /* complete, with success! */
848
849 } while (0);
850
851 return rv;
852 }
853
854 /*
855 *find_run_directory - find executable file in PATH
856 *
857 * PARAMETERS:
858 * cmd filename as typed by user (argv[0])
859 * cwd buffer from which is read the working directory
860 * if first character is '/' or into which is
861 * copied working directory name otherwise
862 * dir buffer into which is copied program's directory
863 * pgm where to return pointer to tail of cmd (may be NULL
864 * if not wanted)
865 * run where to return pointer to tail of final resolved
866 * name ( dir/run is the program) (may be NULL
867 * if not wanted)
868 * path user's path from environment
869 *
870 * Note: run and pgm will agree except when symbolic links have
871 * renamed files
872 *
873 * RETURNS:
874 * returns zero for success,
875 * -1 for error (with errno set properly).
876 *
877 * EXAMPLE:
878 * find_run_directory (argv[0], ".", &charray1, (char **) 0, (char **) 0,
879 * getenv(NOGETTEXT("PATH")));
880 */
881 extern int
882 find_run_directory (char *cmd,
883 char *cwd,
884 char *dir,
885 char **pgm,
886 char **run,
887 char *path)
888 {
889 int rv = 0;
890 char *f, *s;
891 int i;
892 char tmp_path[MAXPATHLEN];
893
894 if (!cmd || !*cmd || !cwd || !dir) {
895 errno = EINVAL; /* stupid arguments! */
896 return -1;
897 }
898
899 if (*cwd != '/')
900 if (!(getcwd (cwd, MAXPATHLEN)))
901 return -1; /* can not get working directory */
902
903 f = strrchr (cmd, '/');
904 if (pgm) /* user wants program name */
905 *pgm = f ? f + 1 : cmd;
906
907 /* get program directory */
908 rv = -1;
909 if (*cmd == '/') /* absname given */
910 rv = resolve ("", cmd + 1, dir, run);
911 else if (f) /* relname given */
912 rv = resolve (cwd, cmd, dir, run);
913 else { /* from searchpath */
914 if (!path || !*path) { /* if missing or null path */
915 tmp_path[0] = '.'; /* assume sanity */
916 tmp_path[1] = '\0';
917 } else {
918 strcpy(tmp_path, path);
919 }
920 f = tmp_path;
921 rv = -1;
922 errno = ENOENT; /* errno gets this if path empty */
923 while (*f && (rv < 0)) {
924 s = f;
925 while (*f && (*f != ':'))
926 ++f;
927 if (*f)
928 *f++ = 0;
929 if (*s == '/')
930 rv = resolve (s, cmd, dir, run);
931 else {
932 char abuf[MAXPATHLEN];
933
934 sprintf (abuf, "%s/%s", cwd, s);
935 rv = resolve (abuf, cmd, dir, run);
936 }
937 }
938 }
939
940 /* Remove any trailing /. */
941 i = strlen(dir);
942 if ( dir[i-2] == '/' && dir[i-1] == '.') {
943 dir[i-2] = '\0';
944 }
945
946 return rv;
947 }
948