/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* read.c
*
* This file contains the makefile reader.
*/
/*
* Included files
*/
#include <alloca.h> /* alloca() */
#include <errno.h> /* errno */
#include <fcntl.h> /* fcntl() */
#include <unistd.h> /* read(), unlink() */
#include <libintl.h>
/*
* typedefs & structs
*/
/*
* Static variables
*/
/*
* File table of contents
*/
static Source push_macro_value(register Source bp, register wchar_t *buffer, int size, register Source source);
extern void enter_target_groups_and_dependencies(Name_vector target, Name_vector depes, Cmd_line command, Separator separator, Boolean target_group_seen);
/*
* read_simple_file(makefile_name, chase_path, doname_it,
* complain, must_exist, report_file, lock_makefile)
*
* Make the makefile and setup to read it. Actually read it if it is stdio
*
* Return value:
* false if the read failed
*
* Parameters:
* makefile_name Name of the file to read
* chase_path Use the makefile path when opening file
* doname_it Call doname() to build the file first
* must_exist Generate fatal if file is missing
* report_file Report file when running -P
* lock_makefile Lock the makefile when reading
*
* Static variables used:
*
* Global variables used:
* do_not_exec_rule Is -n on?
* file_being_read Set to the name of the new file
* line_number The number of the current makefile line
* makefiles_used A list of all makefiles used, appended to
*/
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)
{
static short max_include_depth;
register int n;
char *path;
register int length;
register wchar_t *string_start;
register wchar_t *string_end;
if (max_include_depth++ >= 40) {
}
}
source->error_converting = false;
(wcb[0] != (int) hyphen_char)) {
(doname_it)) {
if (makefile_path == NULL) {
char *path;
add_dir_to_path(".",
-1);
// As regularly installed
// Tools build
add_dir_to_path("/usr/share/lib/make",
-1);
-1);
}
/* Try normalized filename */
4,
if (n == 0) {
get_vroot_path((char **) NULL,
&path,
(char **) NULL);
if ((path[0] == (int) period_char) &&
path += 2;
}
}
}
/*
* Commented out: retmem_mb(normalized_makefile_name->string_mb);
* We have to return this memory, but it seems to trigger a bug
* in dmake or in Sun C++ 5.7 compiler (it works ok if this code
* is compiled using Sun C++ 5.6).
*/
// retmem_mb(normalized_makefile_name->string_mb);
}
}
source->already_expanded = false;
/* Lock the file for read, but not when -n. */
if (lock_makefile &&
!do_not_exec_rule) {
(void) sprintf(make_state_lockfile,
"%s.lock",
(int *) &make_state_locked,
0);
if(!make_state_locked) {
printf("-- NO LOCKING for read\n");
make_state_lockfile = 0;
return failed;
}
}
if ((doname_it) &&
if (complain) {
gettext("%s: Couldn't make `%s'\n"),
getprogname(),
}
return failed;
}
//
// Before calling exists() make sure that we have the right timestamp
//
if (complain ||
if (must_exist) {
stat.stat_errno));
} else {
stat.stat_errno));
}
}
(void) unlink(make_state_lockfile);
make_state_locked = false;
}
return failed;
}
/*
* These values are the size and bytes of
* the MULTI-BYTE makefile.
*/
if (report_file) {
for (dpp = &makefiles_used;
}
0,
NULL,
if (must_exist) {
} else {
}
}
return failed;
}
if (makefile_type == reading_cpp_file) {
forget_after_parse = true;
}
} else {
/* Do we ever reach here? */
}
} else {
char *stdin_text_p;
char *stdin_text_end;
char *stdin_buffer_start;
char *stdin_buffer_end;
char *p_mb;
int num_mb_chars;
/*
* Memory to read standard in, then convert it
* to wide char strings.
*/
line_number = 0;
length)) > 0) {
length -= n;
stdin_text_p += n;
if (length == 0) {
stdin_text_p = p_mb +
length = 1024;
}
}
if (n < 0) {
}
/*
* Now, convert the sequence of multibyte chars into
* a sequence of corresponding wide character codes.
*/
source->bytes_left_in_file = 0;
source->already_expanded = false;
if ((int) num_wc_chars >= 0) {
}
(void) retmem_mb(stdin_text_p);
}
line_number = 1;
if (trace_reader) {
}
if (trace_reader) {
}
if(file_being_read) {
}
if (make_state_locked) {
/* Unlock .make.state. */
make_state_locked = false;
}
if (forget_after_parse) {
}
return succeeded;
}
/*
* parse_makefile(true_makefile_name, source)
*
* Strings are read from Sources.
* When macros are found, their values are represented by a
* Source that is pushed on a stack. At end of string
* (that is returned from GET_CHAR() as 0), the block is popped.
*
* Parameters:
* true_makefile_name The name of makefile we are parsing
* source The source block to read from
*
* Global variables used:
* do_not_exec_rule Is -n on?
* line_number The number of the current makefile line
* makefile_type What kind of makefile are we reading?
* empty_name The Name ""
*/
static void
{
/*
char mb_buffer[MB_LEN_MAX];
*/
register wchar_t *source_p;
register wchar_t *source_end;
register wchar_t *string_start;
wchar_t *string_end;
register int distance;
register int paren_count;
int brace_count;
int char_number;
int i;
int emptycount = 0;
/* Move some values from their struct to register declared locals */
CACHE_SOURCE(0);
/*
* Read whitespace on old line. Leave pointer on first char on
* next line.
*/
first_target = true;
/*
for (WCTOMB(mb_buffer, GET_CHAR());
1;
source_p++, WCTOMB(mb_buffer, GET_CHAR()))
switch (mb_buffer[0]) {
*/
case nul_char:
/* End of this string. Pop it and return to the previous one */
source_p--;
}
break;
case newline_char:
source_p++;
line_number++;
}
switch (GET_CHAR()) {
case nul_char:
}
/* Go back to the top of this loop */
goto start_new_line;
case newline_char:
case numbersign_char:
case dollar_char:
case space_char:
case tab_char:
/*
* Go back to the top of this loop since the
* new line does not start with a regular char.
*/
goto start_new_line;
default:
/* We found the first proper char on the new line */
goto start_new_line_no_skip;
}
case space_char:
if (char_number == 0)
case tab_char:
/* Whitespace. Just keep going in this loop */
break;
case numbersign_char:
/* Comment. Skip over it */
for (; 1; source_p++) {
switch (GET_CHAR()) {
case nul_char:
}
if (source->error_converting) {
// Illegal byte sequence - skip its first byte
source->inp_buf_ptr++;
}
source_p--;
break;
case backslash_char:
/* Comments can be continued */
}
if (source->error_converting) {
// Illegal byte sequence - skip its first byte
source->inp_buf_ptr++;
source_p--;
break;
}
}
if(*source_p == (int) newline_char) {
line_number++;
}
}
break;
case newline_char:
/*
* After we skip the comment we go to
* the end of line handler since end of
* line terminates comments.
*/
goto end_of_line;
}
}
case dollar_char:
/* Macro reference */
if (source->already_expanded) {
/*
* If we are reading from the expansion of a
* macro we already expanded everything enough.
*/
goto start_new_line_no_skip;
}
/*
* Expand the value and push the Source on the stack of
* things being read.
*/
source_p++;
{
source = push_macro_value(t,
sizeof buffer,
source);
}
CACHE_SOURCE(1);
break;
default:
/* We found the first proper char on the new line */
goto start_new_line_no_skip;
}
/*
* We found the first normal char (one that starts an identifier)
* on the newline.
*/
/* Inspect that first char to see if it maybe is special anyway */
switch (GET_CHAR()) {
case nul_char:
}
goto start_new_line_no_skip;
case newline_char:
/* Just in case */
goto start_new_line;
case exclam_char:
/* Evaluate the line before it is read */
macro_seen_in_string = false;
/* Stuff the line in a string so we can eval it. */
for (; 1; source_p++) {
switch (GET_CHAR()) {
case newline_char:
goto eoln_1;
case nul_char:
if (!macro_seen_in_string) {
macro_seen_in_string = true;
}
source_p - string_start);
source_p--;
break;
}
if (!macro_seen_in_string) {
}
source_p - string_start);
alloca((int) sizeof (Source_rec));
extrap->error_converting = false;
source_p++;
}
/* Eval the macro */
false);
if (name_string.free_after_use) {
}
/* And push the value */
CACHE_SOURCE(0);
goto line_evald;
}
}
default:
goto line_evald;
}
/* We now have a line we can start reading */
}
/* Check if this is an include command */
if ((makefile_type == reading_makefile) &&
!source->already_expanded) {
if (include_space[0] == (int) nul_char) {
}
source_p += 7;
wchar_t *name_start;
int name_length;
/*
* Yes, this is an include.
* Skip spaces to get to the filename.
*/
switch (GET_CHAR()) {
case nul_char:
}
break;
default:
source_p++;
break;
}
}
/* Find the end of the filename */
macro_seen_in_string = false;
switch (GET_CHAR()) {
case nul_char:
if (!macro_seen_in_string) {
}
source_p - string_start);
macro_seen_in_string = true;
}
break;
default:
source_p++;
break;
}
}
if (macro_seen_in_string) {
source_p - string_start);
} else {
}
/* Strip "./" from the head of the name */
if ((name_start[0] == (int) period_char) &&
name_start += 2;
name_length -= 2;
}
/* if include file name is surrounded by double quotes */
if ((name_start[0] == (int) doublequote_char) &&
name_start += 1;
name_length -= 2;
/* if name does not begin with a slash char */
if (name_start[0] != (int) slash_char) {
if ((name_start[0] == (int) period_char) &&
name_start += 2;
name_length -= 2;
}
}
}
}
/* Even when we run -n we want to create makefiles */
do_not_exec_rule = false;
if (makefile_name->dollar) {
wchar_t *p;
wchar_t *q;
false);
p++);
for (q = p;
q++);
makefile_name = GETNAME(p, q-p);
if (destination.free_after_use) {
}
}
source_p++;
/* Read the file */
true,
true,
true,
false,
true,
false) == failed) {
}
CACHE_SOURCE(0);
goto start_new_line;
} else {
source_p -= 7;
}
} else {
/* Check if the word include was split across 8K boundary. */
if (tmp_bytes_left_in_string < 8) {
tmp_maybe_include = false;
if (IS_WEQUALN(source_p,
tmp_maybe_include = true;
}
if (tmp_maybe_include) {
tmp_maybe_include = false;
goto line_evald;
}
}
}
}
/* Reset the status in preparation for the new line */
}
}
target_group_seen = false;
macro_value = NULL;
append = false;
current_names = ⌖
/* The state machine starts here */
while (1) switch (state) {
/****************************************************************
* Scan name state
*/
case scan_name_state:
/* Scan an identifier. We skip over chars until we find a break char */
/* First skip white space. */
case nul_char:
source_p--;
}
break;
case newline_char:
/* We found the end of the line. */
/* Do postprocessing or return error */
source_p++;
line_number++;
}
case backslash_char:
/* Continuation */
}
}
if (*source_p == (int) newline_char) {
line_number++;
}
} else {
source_p--;
}
break;
case tab_char:
case space_char:
/* Whitespace is skipped */
break;
case numbersign_char:
/* Comment. Skip over it */
for (; 1; source_p++) {
switch (GET_CHAR()) {
case nul_char:
}
if (source->error_converting) {
// Illegal byte sequence - skip its first byte
source->inp_buf_ptr++;
}
source_p--;
break;
case backslash_char:
}
if (source->error_converting) {
// Illegal byte sequence - skip its first byte
source->inp_buf_ptr++;
source_p--;
break;
}
}
if(*source_p == (int) newline_char) {
line_number++;
}
}
break;
case newline_char:
source_p++;
line_number++;
}
}
}
case dollar_char:
/* Macro reference. Expand and push value */
if (source->already_expanded) {
goto scan_name;
}
source_p++;
{
source = push_macro_value(t,
sizeof buffer,
source);
}
CACHE_SOURCE(1);
break;
default:
/* End of white space */
goto scan_name;
}
/* First proper identifier character */
paren_count = brace_count = 0;
macro_seen_in_string = false;
for (; 1; source_p++) {
switch (GET_CHAR()) {
case nul_char:
/* Save what we have seen so far of the identifier */
if (source_p != string_start) {
if (!macro_seen_in_string) {
}
source_p - string_start);
macro_seen_in_string = true;
}
/* Get more text to read */
source_p--;
}
break;
case newline_char:
if (paren_count > 0) {
}
if (brace_count > 0) {
}
source_p++;
/* Enter name */
source_p - 1,
first_target = false;
if (extra_names == NULL) {
alloca((int) sizeof (Name_vector_rec));
}
/* Do postprocessing or return error */
line_number++;
}
case backslash_char:
/* Check if this is a quoting backslash */
if (!macro_seen_in_string) {
macro_seen_in_string = true;
}
source_p - string_start);
}
}
if (*source_p == (int) newline_char) {
line_number++;
}
*source_p = (int) space_char;
goto resume_name_scan;
} else {
break;
}
break;
case numbersign_char:
if (paren_count + brace_count > 0) {
break;
}
case dollar_char:
if (source->already_expanded) {
break;
}
/* Save the identifier so far */
if (source_p != string_start) {
if (!macro_seen_in_string) {
}
source_p - string_start);
macro_seen_in_string = true;
}
/* Eval and push the macro */
source_p++;
{
Source t =
source = push_macro_value(t,
sizeof buffer,
source);
}
CACHE_SOURCE(1);
break;
case parenleft_char:
paren_count++;
break;
case parenright_char:
if (--paren_count < 0) {
}
break;
case braceleft_char:
brace_count++;
break;
case braceright_char:
if (--brace_count < 0) {
}
break;
case ampersand_char:
case greater_char:
case bar_char:
if (paren_count + brace_count == 0) {
source_p++;
}
/* Fall into */
case tab_char:
case space_char:
if (paren_count + brace_count > 0) {
break;
}
first_target = false;
if (extra_names == NULL) {
alloca((int) sizeof (Name_vector_rec));
}
goto enter_state;
case colon_char:
if (paren_count + brace_count > 0) {
break;
}
if (separator == conditional_seen) {
break;
}
/** POSIX **/
#if 0
if(posix) {
emptycount = 0;
}
#endif
/** END POSIX **/
/* End of the target list. We now start reading */
/* dependencies or a conditional assignment */
}
/* Enter the last target */
if ((string_start != source_p) ||
first_target = false;
if (extra_names == NULL) {
alloca((int)
sizeof (Name_vector_rec));
}
}
/* Check if it is ":" "::" or ":=" */
switch (*++source_p) {
case nul_char:
source_p--;
}
goto scan_colon_label;
case equal_char:
if(svr4) {
}
source_p++;
current_names = &depes;
case colon_char:
source_p++;
break;
default:
}
current_names = &depes;
case semicolon_char:
if (paren_count + brace_count > 0) {
break;
}
/* End of reading names. Start reading the rule */
}
/* Enter the last dependency */
if ((string_start != source_p) ||
first_target = false;
if (extra_names == NULL) {
alloca((int)
sizeof (Name_vector_rec));
}
}
source_p++;
/* Make sure to enter a rule even if the is */
/* no text here */
command->ignore_command_dependency = false;
command->ignore_error = false;
case plus_char:
/*
** following code drops the target separator plus char if it starts
** a line.
*/
if(first_target && !macro_seen_in_string &&
source_p == string_start) {
for (; 1; source_p++)
switch (GET_CHAR()) {
case nul_char:
if (source_p != string_start) {
if (!macro_seen_in_string) {
}
source_p - string_start);
macro_seen_in_string = true;
}
source_p--;
}
break;
case plus_char:
source_p++;
if (source_p != string_start) {
if (!macro_seen_in_string) {
}
source_p - string_start);
macro_seen_in_string = true;
}
}
}
*source_p == (int) space_char) {
macro_seen_in_string = false;
} else {
goto resume_name_scan;
}
break;
case tab_char:
case space_char:
break;
default:
goto resume_name_scan;
}
}
if (paren_count + brace_count > 0) {
break;
}
/* We found "+=" construct */
if (source_p != string_start) {
/* "+" is not a break char. */
/* Ignore it if it is part of an identifier */
source_p++;
goto resume_name_scan;
}
/* Make sure the "+" is followed by a "=" */
switch (*++source_p) {
case nul_char:
if (!macro_seen_in_string) {
}
source_p - string_start);
source_p--;
}
goto scan_append;
case equal_char:
if(!svr4) {
append = true;
} else {
}
break;
default:
/* The "+" just starts a regular name. */
/* Start reading that name */
goto resume_name_scan;
}
/* Fall into */
case equal_char:
if (paren_count + brace_count > 0) {
break;
}
/* We found macro assignment. */
/* Check if it is legal and if it is appending */
switch (separator) {
case none_seen:
break;
case conditional_seen:
break;
default:
/* Reader must special check for "MACRO:sh=" */
/* notation */
}
if (!macro_seen_in_string) {
}
);
(!svr4)) {
buffer);
append_char((int) colon_char,
¯o_name);
break;
(!svr4)) {
buffer);
append_char((int) colon_char,
¯o_name);
break;
}
if(svr4) {
}
else {
}
}
if (append) {
source_p--;
}
/* Enter the macro name */
if ((string_start != source_p) ||
first_target = false;
if (extra_names == NULL) {
alloca((int)
sizeof (Name_vector_rec));
}
}
if (append) {
source_p++;
}
macro_value = NULL;
source_p++;
distance = 0;
/* Skip whitespace to the start of the value */
macro_seen_in_string = false;
for (; 1; source_p++) {
switch (GET_CHAR()) {
case nul_char:
source_p--;
}
break;
case backslash_char:
}
}
if (*source_p != (int) newline_char) {
if (!macro_seen_in_string) {
true;
}
append_char((int)
&name_string);
&name_string);
goto macro_value_start;
} else {
line_number++;
}
}
break;
case newline_char:
case numbersign_char:
goto macro_value_end;
case tab_char:
case space_char:
break;
default:
goto macro_value_start;
}
}
/* Find the end of the value */
for (; 1; source_p++) {
if (distance != 0) {
}
switch (GET_CHAR()) {
case nul_char:
if (!macro_seen_in_string) {
macro_seen_in_string = true;
}
source_p - string_start);
source_p--;
}
break;
case backslash_char:
source_p++;
if (distance != 0) {
*source_p =
}
if (!macro_seen_in_string) {
true;
}
/* BID_1225561 */
source_p -
string_start - 1);
}
if (distance != 0) {
*source_p =
*(source_p +
distance);
}
if (*source_p == (int) newline_char) {
} else {
}
/****************/
}
if (*source_p == (int) newline_char) {
source_p--;
line_number++;
distance++;
*source_p = (int) space_char;
while ((*(source_p +
distance + 1) ==
(int) tab_char) ||
(*(source_p +
distance + 1) ==
(int) space_char)) {
distance++;
}
}
break;
case newline_char:
case numbersign_char:
goto macro_value_end;
}
}
/* Complete the value in the string */
if (!macro_seen_in_string) {
macro_seen_in_string = true;
}
source_p - string_start);
}
if (name_string.free_after_use) {
}
*source_p++ = (int) space_char;
}
}
}
/****************************************************************
* enter dependencies state
*/
case enter_dependencies_state:
/* Expects pointer on first non whitespace char after last dependency. (On */
/* next line.) We end up here after having read a "targets : dependencies" */
/* line. The state checks if there is a rule to read and if so dispatches */
/* to scan_command_state scan_command_state reads one rule line and the */
/* returns here */
/* First check if the first char on the next line is special */
switch (GET_CHAR()) {
case nul_char:
break;
}
goto enter_dependencies_label;
case exclam_char:
/* The line should be evaluate before it is read */
macro_seen_in_string = false;
for (; 1; source_p++) {
switch (GET_CHAR()) {
case newline_char:
goto eoln_2;
case nul_char:
if (!macro_seen_in_string) {
macro_seen_in_string = true;
}
source_p - string_start);
source_p--;
break;
}
if (!macro_seen_in_string) {
}
source_p - string_start);
alloca((int) sizeof (Source_rec));
extrap->error_converting = false;
false);
if (name_string.free_after_use) {
}
CACHE_SOURCE(0);
goto enter_dependencies_label;
}
}
case dollar_char:
if (source->already_expanded) {
break;
}
source_p++;
{
source = push_macro_value(t,
sizeof buffer,
source);
}
CACHE_SOURCE(0);
goto enter_dependencies_label;
case numbersign_char:
if (makefile_type != reading_makefile) {
source_p++;
}
for (; 1; source_p++) {
switch (GET_CHAR()) {
case nul_char:
}
if (source->error_converting) {
// Illegal byte sequence - skip its first byte
source->inp_buf_ptr++;
}
source_p--;
break;
case backslash_char:
}
if (source->error_converting) {
// Illegal byte sequence - skip its first byte
source->inp_buf_ptr++;
source_p--;
break;
}
}
if(*source_p == (int) newline_char) {
line_number++;
}
}
break;
case newline_char:
source_p++;
line_number++;
}
goto enter_dependencies_label;
}
}
case tab_char:
}
/* We read all the command lines for the target/dependency line. */
/* Enter the stuff */
goto start_new_line;
/****************************************************************
* scan command state
*/
case scan_command_state:
/* We need to read one rule line. Do that and return to */
/* the enter dependencies state */
macro_seen_in_string = false;
for (; 1; source_p++) {
switch (GET_CHAR()) {
case backslash_char:
if (!macro_seen_in_string) {
}
source_p - string_start);
macro_seen_in_string = true;
goto command_newline;
}
}
if (*source_p == (int) newline_char) {
line_number++;
}
goto command_newline;
}
}
source_p++;
}
} else {
goto command_newline;
}
}
}
if ((*source_p == (int) newline_char) ||
(*source_p == (int) backslash_char) ||
source_p--;
}
break;
case newline_char:
if ((string_start != source_p) ||
if (macro_seen_in_string) {
source_p - string_start);
} else {
}
while ((*string_start != (int) newline_char) &&
iswspace(*string_start)){
string_start++;
}
if ((string_end > string_start) ||
(makefile_type == reading_statefile)) {
if (command_tail == NULL) {
command =
} else {
command_tail->next =
}
command_tail->make_refd = false;
command_tail->ignore_command_dependency = false;
command_tail->assign = false;
command_tail->ignore_error = false;
command_tail->silent = false;
if (macro_seen_in_string &&
}
}
}
do {
line_number++;
}
}
}
} while (*source_p == (int) newline_char);
case nul_char:
if (!macro_seen_in_string) {
}
source_p - string_start);
macro_seen_in_string = true;
source_p--;
}
break;
}
}
/****************************************************************
* enter equal state
*/
case enter_equal_state:
}
goto start_new_line;
/****************************************************************
* enter conditional state
*/
case enter_conditional_state:
}
append);
}
}
goto start_new_line;
/****************************************************************
* Error states
*/
case illegal_bytes_state:
case illegal_eoln_state:
if (line_number > 1) {
line_number--;
fatal_reader(gettext("Unexpected end of line seen\n\t*** missing separator (did you mean TAB instead of 8 spaces?)"));
}
}
case exit_state:
return;
default:
}
}
/*
* push_macro_value(bp, buffer, size, source)
*
* Macro and function that evaluates one macro
* and makes the reader read from the value of it
*
* Return value:
* The source block to read the macro from
*
* Parameters:
* bp The new source block to fill in
* buffer Buffer to read from
* size size of the buffer
* source The old source block
*
* Global variables used:
*/
static Source
{
bp->inp_buf_ptr =
bp->error_converting = false;
/* 4209588: 'make' doesn't understand a macro with whitespaces in the head as target.
* strip whitespace from the begining of the macro value
*/
}
bp->already_expanded = true;
return bp;
}
/*
* enter_target_groups_and_dependencies(target, depes, command, separator,
* target_group_seen)
*
* Parameters:
* target Structure that shows the target(s) on the line
* we are currently parsing. This can looks like
* target1 .. targetN : dependencies
* commands
* or
* target1 + .. + targetN : dependencies
* commands
* depes Dependencies
* command Points to the command(s) to be executed for
* this target.
* separator : or :: or :=
* target_group_seen Set if we have target1 + .. + targetN
*
*
* After reading the command lines for a target, this routine
* is called to setup the dependencies and the commands for it.
* If the target is a % pattern or part of a target group, then
* the appropriate routines are called.
*/
void
enter_target_groups_and_dependencies(Name_vector target, Name_vector depes, Cmd_line command, Separator separator, Boolean target_group_seen)
{
int i;
if (target_group_seen) {
if(target_group_member == NULL) {
}
}
reset = false;
/* If we saw it in the makefile it must be
* a file */
/* Make sure that we use dependencies
* entered for makefiles */
/* If the target is special we delegate
* the processing */
!= no_special) {
command);
}
/* Check if this is a "a%b : x%y" type rule */
target->target_group[i],
if (target_group_seen) {
}
target->target_group[i],
} else {
if (target_group_seen) {
NULL;
}
target->target_group[i],
}
}
}
}
}