| blob | 0d47f5b2f642f78369fed0e893827c848c59a409 |
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 */
26 /*
27 * read.c
28 *
29 * This file contains the makefile reader.
30 */
32 /*
33 * Included files
34 */
38 #include <mk/defs.h>
44 #include <libintl.h>
47 /*
48 * typedefs & structs
49 */
51 /*
52 * Static variables
53 */
57 /*
58 * File table of contents
59 */
61 static Source push_macro_value(register Source bp, register wchar_t *buffer, int size, register Source source);
62 extern void enter_target_groups_and_dependencies(Name_vector target, Name_vector depes, Cmd_line command, Separator separator, Boolean target_group_seen);
65 /*
66 * read_simple_file(makefile_name, chase_path, doname_it,
67 * complain, must_exist, report_file, lock_makefile)
68 *
69 * Make the makefile and setup to read it. Actually read it if it is stdio
70 *
71 * Return value:
72 * false if the read failed
73 *
74 * Parameters:
75 * makefile_name Name of the file to read
76 * chase_path Use the makefile path when opening file
77 * doname_it Call doname() to build the file first
78 * complain Print message if doname/open fails
79 * must_exist Generate fatal if file is missing
80 * report_file Report file when running -P
81 * lock_makefile Lock the makefile when reading
82 *
83 * Static variables used:
84 *
85 * Global variables used:
86 * do_not_exec_rule Is -n on?
87 * file_being_read Set to the name of the new file
88 * line_number The number of the current makefile line
89 * makefiles_used A list of all makefiles used, appended to
90 */
93 Boolean
94 read_simple_file(register Name makefile_name, register Boolean chase_path, register Boolean doname_it, Boolean complain, Boolean must_exist, Boolean report_file, Boolean lock_makefile)
95 {
98 makefile_prop);
106 Dependency dp;
111 Makefile_type save_makefile_type;
112 Name normalized_makefile_name;
122 }
125 }
144 // As regularly installed
149 // Tools build
162 }
166 /* Try normalized filename */
174 chase_path ?
176 VROOT_DEFAULT);
184 }
187 FIND_LENGTH);
188 }
189 }
191 /*
192 * Commented out: retmem_mb(normalized_makefile_name->string_mb);
193 * We have to return this memory, but it seems to trigger a bug
194 * in dmake or in Sun C++ 5.7 compiler (it works ok if this code
195 * is compiled using Sun C++ 5.6).
196 */
197 // retmem_mb(normalized_makefile_name->string_mb);
198 }
200 }
204 /* Lock the file for read, but not when -n. */
213 make_state_lockfile,
221 }
222 }
233 }
234 max_include_depth--;
237 }
239 //
240 // Before calling exists() make sure that we have the right timestamp
241 //
257 }
258 }
259 max_include_depth--;
265 }
269 }
270 /*
271 * These values are the size and bytes of
272 * the MULTI-BYTE makefile.
273 */
289 }
291 O_RDONLY,
293 NULL,
294 VROOT_DEFAULT);
305 }
306 }
307 max_include_depth--;
309 }
318 }
323 /* Do we ever reach here? */
333 }
346 /*
347 * Memory to read standard in, then convert it
348 * to wide char strings.
349 */
350 stdin_buffer_start =
357 stdin_text_p,
364 stdin_buffer_start));
366 stdin_buffer_start,
368 stdin_buffer_start));
373 stdin_buffer_end =
376 }
377 }
381 }
386 /*
387 * Now, convert the sequence of multibyte chars into
388 * a sequence of corresponding wide character codes.
389 */
400 stdin_text_p,
401 num_mb_chars);
405 }
407 }
412 }
417 }
420 }
424 max_include_depth--;
426 /* Unlock .make.state. */
430 }
434 }
437 }
439 /*
440 * parse_makefile(true_makefile_name, source)
441 *
442 * Strings are read from Sources.
443 * When macros are found, their values are represented by a
444 * Source that is pushed on a stack. At end of string
445 * (that is returned from GET_CHAR() as 0), the block is popped.
446 *
447 * Parameters:
448 * true_makefile_name The name of makefile we are parsing
449 * source The source block to read from
450 *
451 * Global variables used:
452 * do_not_exec_rule Is -n on?
453 * line_number The number of the current makefile line
454 * makefile_type What kind of makefile are we reading?
455 * empty_name The Name ""
456 */
457 static void
459 {
460 /*
461 char mb_buffer[MB_LEN_MAX];
462 */
468 Boolean append;
469 String_rec name_string;
475 Cmd_line command;
476 Cmd_line command_tail;
477 Name macro_value;
479 Name_vector_rec target;
480 Name_vector_rec depes;
481 Name_vector_rec extra_name_vector;
482 Name_vector current_names;
484 Name_vector nvp;
485 Boolean target_group_seen;
492 Source extrap;
495 Name makefile_name;
506 Boolean first_target;
508 String_rec include_name;
512 /* Move some values from their struct to register declared locals */
515 start_new_line:
516 /*
517 * Read whitespace on old line. Leave pointer on first char on
518 * next line.
519 */
522 /*
523 for (WCTOMB(mb_buffer, GET_CHAR());
524 1;
525 source_p++, WCTOMB(mb_buffer, GET_CHAR()))
526 switch (mb_buffer[0]) {
527 */
530 /* End of this string. Pop it and return to the previous one */
532 source_p--;
535 }
538 end_of_line:
539 source_p++;
541 line_number++;
542 }
548 }
549 /* Go back to the top of this loop */
556 /*
557 * Go back to the top of this loop since the
558 * new line does not start with a regular char.
559 */
562 /* We found the first proper char on the new line */
564 }
569 /* Whitespace. Just keep going in this loop */
572 /* Comment. Skip over it */
579 }
581 // Illegal byte sequence - skip its first byte
583 }
584 source_p--;
587 /* Comments can be continued */
592 }
594 // Illegal byte sequence - skip its first byte
596 source_p--;
598 }
599 }
602 line_number++;
603 }
604 }
607 /*
608 * After we skip the comment we go to
609 * the end of line handler since end of
610 * line terminates comments.
611 */
613 }
614 }
616 /* Macro reference */
618 /*
619 * If we are reading from the expansion of a
620 * macro we already expanded everything enough.
621 */
623 }
624 /*
625 * Expand the value and push the Source on the stack of
626 * things being read.
627 */
628 source_p++;
630 {
633 buffer,
635 source);
636 }
640 /* We found the first proper char on the new line */
642 }
644 /*
645 * We found the first normal char (one that starts an identifier)
646 * on the newline.
647 */
648 start_new_line_no_skip:
649 /* Inspect that first char to see if it maybe is special anyway */
655 }
658 /* Just in case */
661 /* Evaluate the line before it is read */
664 /* Stuff the line in a string so we can eval it. */
675 }
681 source_p--;
683 }
684 eoln_1:
687 name_buffer);
688 }
700 source_p++;
701 }
702 /* Eval the macro */
704 FIND_LENGTH),
709 }
714 /* And push the value */
719 }
720 }
723 }
725 /* We now have a line we can start reading */
726 line_evald:
729 }
730 /* Check if this is an include command */
736 }
741 Makefile_type save_makefile_type;
745 /*
746 * Yes, this is an include.
747 * Skip spaces to get to the filename.
748 */
756 }
760 source_p++;
762 }
763 }
766 /* Find the end of the filename */
774 name_buffer);
775 }
784 }
788 source_p++;
790 }
791 }
803 }
805 /* Strip "./" from the head of the name */
810 }
811 /* if include file name is surrounded by double quotes */
817 /* if name does not begin with a slash char */
823 }
835 name_length);
839 }
840 }
841 }
843 /* Even when we run -n we want to create makefiles */
847 String_rec destination;
858 p++);
861 q++);
865 }
866 }
867 source_p++;
869 /* Read the file */
880 }
887 }
889 /* Check if the word include was split across 8K boundary. */
895 include_space,
896 tmp_bytes_left_in_string)) {
898 }
903 }
904 }
905 }
906 }
908 /* Reset the status in preparation for the new line */
911 }
914 }
924 /* The state machine starts here */
925 enter_state:
928 /****************************************************************
929 * Scan name state
930 */
932 /* Scan an identifier. We skip over chars until we find a break char */
933 /* First skip white space. */
937 source_p--;
940 }
943 /* We found the end of the line. */
944 /* Do postprocessing or return error */
945 source_p++;
947 line_number++;
948 }
951 /* Continuation */
956 }
957 }
960 line_number++;
961 }
963 source_p--;
964 }
968 /* Whitespace is skipped */
971 /* Comment. Skip over it */
978 }
980 // Illegal byte sequence - skip its first byte
982 }
983 source_p--;
990 }
992 // Illegal byte sequence - skip its first byte
994 source_p--;
996 }
997 }
1000 line_number++;
1001 }
1002 }
1005 source_p++;
1007 line_number++;
1008 }
1010 }
1011 }
1013 /* Macro reference. Expand and push value */
1016 }
1017 source_p++;
1019 {
1022 buffer,
1024 source);
1025 }
1029 /* End of white space */
1031 }
1033 /* First proper identifier character */
1034 scan_name:
1039 resume_name_scan:
1043 /* Save what we have seen so far of the identifier */
1047 name_buffer);
1048 }
1053 }
1054 /* Get more text to read */
1057 source_p--;
1060 }
1065 }
1068 }
1069 source_p++;
1070 /* Enter name */
1072 macro_seen_in_string,
1073 string_start,
1075 current_names,
1082 }
1083 /* Do postprocessing or return error */
1085 line_number++;
1086 }
1089 /* Check if this is a quoting backslash */
1092 name_buffer);
1094 }
1102 }
1103 }
1106 line_number++;
1107 }
1114 }
1119 }
1124 }
1125 /* Save the identifier so far */
1129 name_buffer);
1130 }
1135 }
1136 /* Eval and push the macro */
1137 source_p++;
1139 {
1140 Source t =
1143 buffer,
1145 source);
1146 }
1151 paren_count++;
1156 }
1159 brace_count++;
1164 }
1170 source_p++;
1171 }
1172 /* Fall into */
1177 }
1179 macro_seen_in_string,
1180 string_start,
1181 source_p,
1182 current_names,
1189 }
1194 }
1197 }
1198 /** POSIX **/
1199 #if 0
1202 }
1203 #endif
1204 /** END POSIX **/
1205 /* End of the target list. We now start reading */
1206 /* dependencies or a conditional assignment */
1209 }
1210 /* Enter the last target */
1212 macro_seen_in_string) {
1213 current_names =
1215 macro_seen_in_string,
1216 string_start,
1217 source_p,
1218 current_names,
1226 }
1227 }
1228 /* Check if it is ":" "::" or ":=" */
1229 scan_colon_label:
1233 source_p--;
1236 }
1241 }
1243 source_p++;
1248 source_p++;
1252 }
1259 }
1260 /* End of reading names. Start reading the rule */
1264 }
1265 /* Enter the last dependency */
1267 macro_seen_in_string) {
1268 current_names =
1270 macro_seen_in_string,
1271 string_start,
1272 source_p,
1273 current_names,
1281 }
1282 }
1283 source_p++;
1284 /* Make sure to enter a rule even if the is */
1285 /* no text here */
1297 /*
1298 ** following code drops the target separator plus char if it starts
1299 ** a line.
1300 */
1309 name_buffer);
1310 }
1315 }
1318 source_p--;
1321 }
1324 source_p++;
1329 name_buffer);
1330 }
1335 }
1340 }
1341 }
1348 }
1356 }
1357 }
1360 }
1361 /* We found "+=" construct */
1363 /* "+" is not a break char. */
1364 /* Ignore it if it is part of an identifier */
1365 source_p++;
1367 }
1368 /* Make sure the "+" is followed by a "=" */
1369 scan_append:
1374 name_buffer);
1375 }
1380 source_p--;
1384 }
1391 }
1394 /* The "+" just starts a regular name. */
1395 /* Start reading that name */
1397 }
1398 /* Fall into */
1402 }
1403 /* We found macro assignment. */
1404 /* Check if it is legal and if it is appending */
1414 /* Reader must special check for "MACRO:sh=" */
1415 /* notation */
1421 }
1425 name_buffer);
1426 }
1429 source_p - string_start
1430 );
1440 String_rec macro_name;
1444 buffer);
1447 FIND_LENGTH);
1452 FIND_LENGTH);
1455 FIND_LENGTH);
1467 String_rec macro_name;
1471 buffer);
1474 FIND_LENGTH);
1479 FIND_LENGTH);
1482 FIND_LENGTH);
1486 }
1489 }
1492 }
1493 }
1495 source_p--;
1496 }
1497 /* Enter the macro name */
1499 macro_seen_in_string) {
1500 current_names =
1502 macro_seen_in_string,
1503 string_start,
1504 source_p,
1505 current_names,
1513 }
1514 }
1516 source_p++;
1517 }
1519 source_p++;
1521 /* Skip whitespace to the start of the value */
1527 source_p--;
1530 }
1537 }
1538 }
1541 macro_seen_in_string =
1544 name_buffer);
1545 }
1547 backslash_char,
1555 line_number++;
1556 }
1557 }
1569 }
1570 }
1571 macro_value_start:
1572 /* Find the end of the value */
1576 }
1582 name_buffer);
1583 }
1589 source_p--;
1592 }
1595 source_p++;
1599 }
1602 macro_seen_in_string =
1605 name_buffer);
1606 }
1608 /* BID_1225561 */
1612 source_p -
1618 }
1622 distance);
1623 }
1628 }
1629 /****************/
1630 }
1632 source_p--;
1633 line_number++;
1634 distance++;
1642 distance++;
1643 }
1644 }
1649 }
1650 }
1651 macro_value_end:
1652 /* Complete the value in the string */
1656 name_buffer);
1657 }
1662 macro_value =
1664 FIND_LENGTH);
1665 }
1668 }
1671 }
1673 }
1674 }
1676 /****************************************************************
1677 * enter dependencies state
1678 */
1680 enter_dependencies_label:
1681 /* Expects pointer on first non whitespace char after last dependency. (On */
1682 /* next line.) We end up here after having read a "targets : dependencies" */
1683 /* line. The state checks if there is a rule to read and if so dispatches */
1684 /* to scan_command_state scan_command_state reads one rule line and the */
1685 /* returns here */
1687 /* First check if the first char on the next line is special */
1693 }
1696 /* The line should be evaluate before it is read */
1708 name_buffer);
1709 }
1715 source_p--;
1717 }
1718 eoln_2:
1721 name_buffer);
1722 }
1734 FIND_LENGTH),
1739 }
1748 }
1749 }
1753 }
1754 source_p++;
1756 {
1759 buffer,
1761 source);
1762 }
1767 source_p++;
1769 }
1776 }
1778 // Illegal byte sequence - skip its first byte
1780 }
1781 source_p--;
1788 }
1790 // Illegal byte sequence - skip its first byte
1792 source_p--;
1794 }
1795 }
1798 line_number++;
1799 }
1800 }
1803 source_p++;
1805 line_number++;
1806 }
1808 }
1809 }
1813 }
1815 /* We read all the command lines for the target/dependency line. */
1816 /* Enter the stuff */
1822 /****************************************************************
1823 * scan command state
1824 */
1826 /* We need to read one rule line. Do that and return to */
1827 /* the enter dependencies state */
1835 name_buffer);
1836 }
1846 }
1847 }
1852 line_number++;
1853 }
1859 }
1860 }
1862 source_p++;
1863 }
1870 }
1871 }
1872 }
1877 source_p--;
1878 }
1881 command_newline:
1883 macro_seen_in_string) {
1888 string_start =
1893 }
1896 string_start++;
1897 }
1901 command =
1902 command_tail =
1907 command_tail =
1909 }
1923 }
1924 }
1925 }
1928 line_number++;
1929 }
1935 }
1936 }
1943 name_buffer);
1944 }
1951 source_p--;
1954 }
1956 }
1957 }
1959 /****************************************************************
1960 * enter equal state
1961 */
1965 }
1969 /****************************************************************
1970 * enter conditional state
1971 */
1975 }
1980 macro_value,
1981 append);
1982 }
1983 }
1986 /****************************************************************
1987 * Error states
1988 */
1994 line_number--;
1995 fatal_reader(gettext("Unexpected end of line seen\n\t*** missing separator (did you mean TAB instead of 8 spaces?)"));
1996 }
1997 }
2005 }
2006 }
2008 /*
2009 * push_macro_value(bp, buffer, size, source)
2010 *
2011 * Macro and function that evaluates one macro
2012 * and makes the reader read from the value of it
2013 *
2014 * Return value:
2015 * The source block to read the macro from
2016 *
2017 * Parameters:
2018 * bp The new source block to fill in
2019 * buffer Buffer to read from
2020 * size size of the buffer
2021 * source The old source block
2022 *
2023 * Global variables used:
2024 */
2025 static Source
2026 push_macro_value(register Source bp, register wchar_t *buffer, int size, register Source source)
2027 {
2039 /* 4209588: 'make' doesn't understand a macro with whitespaces in the head as target.
2040 * strip whitespace from the begining of the macro value
2041 */
2044 }
2050 }
2052 /*
2053 * enter_target_groups_and_dependencies(target, depes, command, separator,
2054 * target_group_seen)
2055 *
2056 * Parameters:
2057 * target Structure that shows the target(s) on the line
2058 * we are currently parsing. This can looks like
2059 * target1 .. targetN : dependencies
2060 * commands
2061 * or
2062 * target1 + .. + targetN : dependencies
2063 * commands
2064 * depes Dependencies
2065 * command Points to the command(s) to be executed for
2066 * this target.
2067 * separator : or :: or :=
2068 * target_group_seen Set if we have target1 + .. + targetN
2069 *
2070 *
2071 * After reading the command lines for a target, this routine
2072 * is called to setup the dependencies and the commands for it.
2073 * If the target is a % pattern or part of a target group, then
2074 * the appropriate routines are called.
2075 */
2077 void
2078 enter_target_groups_and_dependencies(Name_vector target, Name_vector depes, Cmd_line command, Separator separator, Boolean target_group_seen)
2079 {
2082 Chain target_group_member;
2083 Percent percent_ptr;
2089 target_group_member =
2093 }
2094 }
2097 /* If we saw it in the makefile it must be
2098 * a file */
2100 /* Make sure that we use dependencies
2101 * entered for makefiles */
2104 /* If the target is special we delegate
2105 * the processing */
2109 depes,
2110 command);
2111 }
2112 /* Check if this is a "a%b : x%y" type rule */
2114 percent_ptr =
2120 percent_ptr;
2121 }
2124 enter_dependencies
2127 depes,
2128 command,
2129 separator);
2133 NULL;
2134 }
2136 enter_dependencies
2139 depes,
2140 command,
2141 separator);
2142 }
2143 }
2144 }
2145 }
2146 }