$NetBSD: patch-ai,v 1.1 2003/07/12 11:39:53 jtb Exp $ --- ../gcc-2.95.3/gcc/p/gpc.c.orig +++ ../gcc-2.95.3/gcc/p/gpc.c @@ -245,9 +245,13 @@ static void clear_failure_queue PROTO((void)); static int check_live_switch PROTO((int, int)); static const char *handle_braces PROTO((const char *)); +static const struct spec_function *lookup_spec_function PROTO((const char *)); +static const char *eval_spec_function PROTO((const char *, const char *)); +static const char *handle_spec_function PROTO((const char *)); static char *save_string PROTO((const char *, int)); extern int do_spec PROTO((const char *)); static int do_spec_1 PROTO((const char *, int, const char *)); +static int do_spec_2 PROTO((const char *)); static const char *find_file PROTO((const char *)); static int is_directory PROTO((const char *, const char *, int)); static void validate_switches PROTO((const char *)); @@ -280,6 +284,7 @@ static void process_command PROTO ((int, char **)); static int execute PROTO ((void)); static void unused_prefix_warnings PROTO ((struct path_prefix *)); +static void alloc_args PROTO ((void)); static void clear_args PROTO ((void)); static void fatal_error PROTO ((int)); @@ -290,6 +295,9 @@ extern char *xrealloc PROTO((void *, size_t)); #endif + +static const char *if_exists_spec_function PROTO ((int, const char **)); + /* Specs are strings containing lines, each of which (if not blank) is made up of a program name, and arguments separated by spaces. The program name must be exact and start from root, since no path @@ -373,6 +381,12 @@ %* substitute the variable part of a matched option. (See below.) Note that each comma in the substituted string is replaced by a single space. + %:function(args) + Call the named function FUNCTION, passing it ARGS. ARGS is + first processed as a nested spec string, then split into an + argument vector in the usual fashion. The function returns + a string which is processed as if it had appeared literally + as part of the current spec. %{S} substitutes the -S switch, if that switch was given to CC. If that switch was not specified, this substitutes nothing. Here S is a metasyntactic variable. @@ -1370,6 +1384,24 @@ static struct spec_list *specs = (struct spec_list *)0; +/* The mapping of a spec function name to the C function that + implements it. */ +struct spec_function +{ + const char *name; + const char *(*func) PROTO ((int, const char **)); +}; + +/* List of static spec functions. */ + +static const struct spec_function static_spec_functions[] = +{ + { "if-exists", if_exists_spec_function }, + { 0, 0 } +}; + +static int processing_spec_function; + /* Initialize the specs lookup routines. */ static void @@ -1598,6 +1630,15 @@ static char *multilib_dir; +/* Allocate the argument vector. */ + +static void +alloc_args () +{ + argbuf_length = 10; + argbuf = (char **) xmalloc (argbuf_length * sizeof (char *)); +} + #ifdef GPC /* Print a help screen and exit */ static void print_message_and_exit PROTO((void)); @@ -2482,6 +2523,9 @@ struct command *commands; /* each command buffer with above info. */ + if (processing_spec_function) + abort (); + /* Count # of piped commands. */ for (n_commands = 1, i = 0; i < argbuf_index; i++) if (strcmp (argbuf[i], "|") == 0) @@ -2665,6 +2709,11 @@ static int n_infiles; +/* This counts the number of libraries added by lang_specific_driver, so that + we can tell if there were any user supplied any files or libraries. */ + +static int added_libraries; + /* And a vector of corresponding output files is made up later. */ static const char **outfiles; @@ -2851,7 +2900,7 @@ strncpy (nstore, startp, endp-startp); if (endp == startp) strcpy (nstore, concat (".", dir_separator_str, NULL_PTR)); - else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR) + else if (!IS_DIR_SEPARATOR (endp[-1])) { nstore[endp-startp] = DIR_SEPARATOR; nstore[endp-startp+1] = 0; @@ -2882,7 +2931,7 @@ strncpy (nstore, startp, endp-startp); if (endp == startp) strcpy (nstore, concat (".", dir_separator_str, NULL_PTR)); - else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR) + else if (!IS_DIR_SEPARATOR (endp[-1])) { nstore[endp-startp] = DIR_SEPARATOR; nstore[endp-startp+1] = 0; @@ -2915,7 +2964,7 @@ strncpy (nstore, startp, endp-startp); if (endp == startp) strcpy (nstore, concat (".", dir_separator_str, NULL_PTR)); - else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR) + else if (!IS_DIR_SEPARATOR (endp[-1])) { nstore[endp-startp] = DIR_SEPARATOR; nstore[endp-startp+1] = 0; @@ -3518,14 +3567,7 @@ { int value; - clear_args (); - arg_going = 0; - delete_this_arg = 0; - this_is_output_file = 0; - this_is_library_file = 0; - input_from_pipe = 0; - - value = do_spec_1 (spec, 0, NULL_PTR); + value = do_spec_2 (spec); /* Force out any unfinished command. If -pipe, this forces out the last command if it ended in `|'. */ @@ -3541,6 +3583,20 @@ return value; } +static int +do_spec_2 (spec) + const char *spec; +{ + clear_args (); + arg_going = 0; + delete_this_arg = 0; + this_is_output_file = 0; + this_is_library_file = 0; + input_from_pipe = 0; + + return do_spec_1 (spec, 0, NULL_PTR); +} + /* Process the sub-spec SPEC as a portion of a larger spec. This is like processing a whole spec except that we do not initialize at the beginning and we do not supply a @@ -4258,6 +4314,12 @@ return -1; break; + case ':': + p = handle_spec_function (p); + if (p == 0) + return -1; + break; + case '%': obstack_1grow (&obstack, '%'); break; @@ -4414,7 +4476,173 @@ arg_going = 1; } - return 0; /* End of string */ + /* End of string. If we are processing a spec function, we need to + end any pending argument. */ + if (processing_spec_function && arg_going) + { + obstack_1grow (&obstack, 0); + string = obstack_finish (&obstack); + if (this_is_library_file) + string = find_file (string); + store_arg (string, delete_this_arg, this_is_output_file); + if (this_is_output_file) + outfiles[input_file_number] = string; + arg_going = 0; + } + + return 0; +} + +/* Look up a spec function. */ + +static const struct spec_function * +lookup_spec_function (name) + const char *name; +{ + static const struct spec_function * const spec_function_tables[] = + { + static_spec_functions, + }; + const struct spec_function *sf; + unsigned int i; + + for (i = 0; i < ARRAY_SIZE (spec_function_tables); i++) + { + for (sf = spec_function_tables[i]; sf->name != NULL; sf++) + if (strcmp (sf->name, name) == 0) + return sf; + } + + return NULL; +} + +/* Evaluate a spec function. */ + +static const char * +eval_spec_function (func, args) + const char *func, *args; +{ + const struct spec_function *sf; + const char *funcval; + + /* Saved spec processing context. */ + int save_argbuf_index; + int save_argbuf_length; + char **save_argbuf; + + int save_arg_going; + int save_delete_this_arg; + int save_this_is_output_file; + int save_this_is_library_file; + int save_input_from_pipe; + + + sf = lookup_spec_function (func); + if (sf == NULL) + fatal ("unknown spec function `%s'", func); + + /* Push the spec processing context. */ + save_argbuf_index = argbuf_index; + save_argbuf_length = argbuf_length; + save_argbuf = argbuf; + + save_arg_going = arg_going; + save_delete_this_arg = delete_this_arg; + save_this_is_output_file = this_is_output_file; + save_this_is_library_file = this_is_library_file; + save_input_from_pipe = input_from_pipe; + + /* Create a new spec processing context, and build the function + arguments. */ + + alloc_args (); + if (do_spec_2 (args) < 0) + fatal ("error in args to spec function `%s'", func); + + /* argbuf_index is an index for the next argument to be inserted, and + so contains the count of the args already inserted. */ + + funcval = (*sf->func) (argbuf_index, (const char **) argbuf); + + /* Pop the spec processing context. */ + argbuf_index = save_argbuf_index; + argbuf_length = save_argbuf_length; + free (argbuf); + argbuf = save_argbuf; + + arg_going = save_arg_going; + delete_this_arg = save_delete_this_arg; + this_is_output_file = save_this_is_output_file; + this_is_library_file = save_this_is_library_file; + input_from_pipe = save_input_from_pipe; + + return funcval; +} + +/* Handle a spec function call of the form: + + %:function(args) + + ARGS is processed as a spec in a separate context and split into an + argument vector in the normal fashion. The function returns a string + containing a spec which we then process in the caller's context, or + NULL if no processing is required. */ + +static const char * +handle_spec_function (p) + const char *p; +{ + char *func, *args; + const char *endp, *funcval; + int count; + + processing_spec_function++; + + /* Get the function name. */ + for (endp = p; *endp != '\0'; endp++) + { + if (*endp == '(') /* ) */ + break; + /* Only allow [A-Za-z0-9], -, and _ in function names. */ + if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_')) + fatal ("malformed spec function name"); + } + if (*endp != '(') /* ) */ + fatal ("no arguments for spec function"); + func = save_string (p, endp - p); + p = ++endp; + + /* Get the arguments. */ + for (count = 0; *endp != '\0'; endp++) + { + /* ( */ + if (*endp == ')') + { + if (count == 0) + break; + count--; + } + else if (*endp == '(') /* ) */ + count++; + } + /* ( */ + if (*endp != ')') + fatal ("malformed spec function arguments"); + args = save_string (p, endp - p); + p = ++endp; + + /* p now points to just past the end of the spec function expression. */ + + funcval = eval_spec_function (func, args); + if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0) + p = NULL; + + free (func); + free (args); + + processing_spec_function--; + + return p; } /* Return 0 if we call do_spec_1 and that returns -1. */ @@ -5146,7 +5374,8 @@ #endif /* GPC */ p = argv[0] + strlen (argv[0]); - while (p != argv[0] && p[-1] != '/' && p[-1] != DIR_SEPARATOR) --p; + while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1])) + --p; programname = p; #ifdef GPC @@ -5166,8 +5395,8 @@ signal (SIGPIPE, fatal_error); #endif - argbuf_length = 10; - argbuf = (char **) xmalloc (argbuf_length * sizeof (char *)); + /* Allocate the argument vector. */ + alloc_args (); obstack_init (&obstack); @@ -5469,7 +5698,7 @@ #endif } - if (n_infiles == 0) + if (n_infiles == added_libraries) fatal ("No input files"); /* Make a place to record the compiler output file names @@ -6380,3 +6609,25 @@ ++p; } } + +/* if-exists built-in spec function. + + Checks to see if the file specified by the absolute pathname in + ARGS exists. Returns that pathname if found. + + The usual use for this function is to check for a library file + (whose name has been expanded with %s). */ + +#define IS_ABSOLUTE_PATHNAME(cp) ((cp)[0] == '/') + +static const char * +if_exists_spec_function (argc, argv) + int argc; + const char **argv; +{ + /* Must have only one argument. */ + if (argc == 1 && IS_ABSOLUTE_PATHNAME (argv[0]) && ! access (argv[0], R_OK)) + return argv[0]; + + return NULL; +}