diff options
author | jtb <jtb> | 2003-07-12 11:39:52 +0000 |
---|---|---|
committer | jtb <jtb> | 2003-07-12 11:39:52 +0000 |
commit | 2eee37282a1c712de1da5c35a2a7bf23c8736d6f (patch) | |
tree | 1c84213f7b42333f057c9df0fd38860d5483eeeb | |
parent | ebc362acb01f0cff61ae99e0e11e25b08088fc74 (diff) | |
download | pkgsrc-2eee37282a1c712de1da5c35a2a7bf23c8736d6f.tar.gz |
Add the patches this time.
-rw-r--r-- | lang/gpc/patches/patch-ag | 161 | ||||
-rw-r--r-- | lang/gpc/patches/patch-ah | 361 | ||||
-rw-r--r-- | lang/gpc/patches/patch-ai | 420 |
3 files changed, 942 insertions, 0 deletions
diff --git a/lang/gpc/patches/patch-ag b/lang/gpc/patches/patch-ag new file mode 100644 index 00000000000..a3c82b1dea3 --- /dev/null +++ b/lang/gpc/patches/patch-ag @@ -0,0 +1,161 @@ +$NetBSD: patch-ag,v 1.1 2003/07/12 11:39:52 jtb Exp $ + +--- ../gcc-2.95.3/gcc/config/netbsd.h ++++ ../gcc-2.95.3/gcc/config/netbsd.h.orig +@@ -36,10 +36,13 @@ + + + /* Provide a CPP_SPEC appropriate for NetBSD. Current we just deal with +- the GCC option `-posix'. */ ++ the GCC option `-posix'. We also deal with -pthread, which is required ++ for the 2.95.3 STL to work. */ + + #undef CPP_SPEC +-#define CPP_SPEC "%(cpp_cpu) %{posix:-D_POSIX_SOURCE}" ++#define CPP_SPEC \ ++ "%(cpp_cpu) %{posix:-D_POSIX_SOURCE} \ ++ %{pthread:-D_REENTRANT -D_PTHREADS}" + + /* Provide an ASM_SPEC appropriate for NetBSD. Currently we only deal + with the options for generating PIC code. */ +@@ -54,7 +57,8 @@ + + #undef LIB_SPEC + #define LIB_SPEC \ +- "%{posix:%{!p:%{!pg:-lposix}}%{p:-lposix_p}%{pg:-lposix_p}} \ ++ "%{pthread:%{!p:%{!pg:-lpthread}}%{p:-lpthread_p}%{pg:-lpthread_p}} \ ++ %{posix:%{!p:%{!pg:-lposix}}%{p:-lposix_p}%{pg:-lposix_p}} \ + %{!shared:%{!symbolic:%{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}}" + + /* Provide a LIBGCC_SPEC appropriate for NetBSD. We also want to exclude +@@ -64,7 +68,7 @@ + #ifdef NETBSD_NATIVE + #define LIBGCC_SPEC "%{!symbolic:%{!shared:%{!p:%{!pg:-lgcc}}}%{shared:-lgcc_pic}%{p:-lgcc_p}%{pg:-lgcc_p}}" + #else +-#define LIBGCC_SPEC "%{!shared:%{!symbolic:-lgcc}}" ++#define LIBGCC_SPEC "%{!symbolic:%{!shared:-lgcc}%{shared:-lgcc_pic}}" + #endif + + /* #ifdef NETBSD_AOUT */ +@@ -147,6 +151,96 @@ + #define ASM_DECLARE_RESULT(FILE, RESULT) + #endif + ++/* NetBSD a.out support begins here. */ ++ ++#ifndef NETBSD_ELF ++ ++#undef DWARF_DEBUGGING_INFO /* XXX */ ++#undef DWARF2_DEBUGGING_INFO /* XXX */ ++ ++/* Write the extra assembler code needed to declare a function properly. ++ Some svr4 assemblers need to also have something extra said about the ++ function's return value. We allow for that here. */ ++ ++#undef ASM_DECLARE_FUNCTION_NAME ++#define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL) \ ++ do { \ ++ fprintf (FILE, "\t%s\t ", TYPE_ASM_OP); \ ++ assemble_name (FILE, NAME); \ ++ putc (',', FILE); \ ++ fprintf (FILE, TYPE_OPERAND_FMT, "function"); \ ++ putc ('\n', FILE); \ ++ ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL)); \ ++ ASM_OUTPUT_LABEL(FILE, NAME); \ ++ } while (0) ++ ++/* Write the extra assembler code needed to declare an object properly. */ ++ ++#undef ASM_DECLARE_OBJECT_NAME ++#define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL) \ ++ do { \ ++ fprintf (FILE, "\t%s\t ", TYPE_ASM_OP); \ ++ assemble_name (FILE, NAME); \ ++ putc (',', FILE); \ ++ fprintf (FILE, TYPE_OPERAND_FMT, "object"); \ ++ putc ('\n', FILE); \ ++ size_directive_output = 0; \ ++ if (!flag_inhibit_size_directive && DECL_SIZE (DECL)) \ ++ { \ ++ size_directive_output = 1; \ ++ fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \ ++ assemble_name (FILE, NAME); \ ++ fprintf (FILE, ",%d\n", int_size_in_bytes (TREE_TYPE (DECL))); \ ++ } \ ++ ASM_OUTPUT_LABEL(FILE, NAME); \ ++ } while (0) ++ ++/* Output the size directive for a decl in rest_of_decl_compilation ++ in the case where we did not do so before the initializer. ++ Once we find the error_mark_node, we know that the value of ++ size_directive_output was set ++ by ASM_DECLARE_OBJECT_NAME when it was run for the same decl. */ ++ ++#undef ASM_FINISH_DECLARE_OBJECT ++#define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END) \ ++do { \ ++ char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0); \ ++ if (!flag_inhibit_size_directive && DECL_SIZE (DECL) \ ++ && ! AT_END && TOP_LEVEL \ ++ && DECL_INITIAL (DECL) == error_mark_node \ ++ && !size_directive_output) \ ++ { \ ++ size_directive_output = 1; \ ++ fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \ ++ assemble_name (FILE, name); \ ++ fprintf (FILE, ",%d\n", int_size_in_bytes (TREE_TYPE (DECL))); \ ++ } \ ++ } while (0) ++ ++/* This is how to declare the size of a function. */ ++ ++#undef ASM_DECLARE_FUNCTION_SIZE ++#define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL) \ ++ do { \ ++ if (!flag_inhibit_size_directive) \ ++ { \ ++ char label[256]; \ ++ static int labelno; \ ++ labelno++; \ ++ ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno); \ ++ ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno); \ ++ fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \ ++ assemble_name (FILE, (FNAME)); \ ++ fprintf (FILE, ","); \ ++ assemble_name (FILE, label); \ ++ fprintf (FILE, "-"); \ ++ assemble_name (FILE, (FNAME)); \ ++ putc ('\n', FILE); \ ++ } \ ++ } while (0) ++ ++#endif ++ + /* NetBSD ELF support begins here. */ + + #ifdef NETBSD_ELF +@@ -167,6 +261,7 @@ + %{!pg: \ + %{p:gcrt0%O%s} \ + %{!p:crt0%O%s}}} \ ++ %:if-exists(crti%O%s) \ + %{!shared:crtbegin%O%s} %{shared:crtbeginS%O%s}" + + /* Provide an ENDFILE_SPEC appropriate for NetBSD ELF targets. Here we +@@ -175,13 +270,14 @@ + + #undef ENDFILE_SPEC + #define ENDFILE_SPEC \ +- "%{!shared:crtend%O%s} %{shared:crtendS%O%s}" ++ "%{!shared:crtend%O%s} %{shared:crtendS%O%s} \ ++ %:if-exists(crtn%O%s)" + + /* Provide a LINK_SPEC appropriate for a NetBSD ELF target. */ + + #undef LINK_SPEC + #define LINK_SPEC \ +- "%{assert*} \ ++ "%{assert*} %{R*} \ + %{shared:-shared} \ + %{!shared: \ + -dc -dp \ diff --git a/lang/gpc/patches/patch-ah b/lang/gpc/patches/patch-ah new file mode 100644 index 00000000000..88f7de61bb8 --- /dev/null +++ b/lang/gpc/patches/patch-ah @@ -0,0 +1,361 @@ +$NetBSD: patch-ah,v 1.1 2003/07/12 11:39:52 jtb Exp $ + +--- ../gcc-2.95.3/gcc/gcc.c.orig ++++ ../gcc-2.95.3/gcc/gcc.c +@@ -189,9 +189,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 *)); +@@ -216,6 +220,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)); + +@@ -231,6 +236,8 @@ + /* Number of extra output files that lang_specific_pre_link may generate. */ + extern int lang_specific_extra_outfiles; + ++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 +@@ -335,6 +342,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. +@@ -1162,6 +1175,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 +@@ -1404,6 +1435,15 @@ + + static const char *multilib_dir; + ++/* Allocate the argument vector. */ ++ ++static void ++alloc_args () ++{ ++ argbuf_length = 10; ++ argbuf = (char **) xmalloc (argbuf_length * sizeof (char *)); ++} ++ + /* Clear out the vector of arguments (after a command is executed). */ + + static void +@@ -2211,6 +2251,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) +@@ -3360,14 +3403,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 `|'. */ +@@ -3383,6 +3419,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 +@@ -4068,6 +4118,12 @@ + return -1; + break; + ++ case ':': ++ p = handle_spec_function (p); ++ if (p == 0) ++ return -1; ++ break; ++ + case '%': + obstack_1grow (&obstack, '%'); + break; +@@ -4222,7 +4278,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. */ +@@ -4674,8 +4896,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); + +@@ -5846,3 +6068,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; ++} diff --git a/lang/gpc/patches/patch-ai b/lang/gpc/patches/patch-ai new file mode 100644 index 00000000000..514d0653103 --- /dev/null +++ b/lang/gpc/patches/patch-ai @@ -0,0 +1,420 @@ +$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; ++} |