Changeset 3138 for vendor/gnumake/current

vendor/gnumake/current/AUTHORS

-              r2596
+              r3138
       DJ Delorie <dj@delorie.com>
       Rob Tulloh <rob_tulloh@tivoli.com>
       Eli Zaretskii <eliz@is.elta.co.il>
+      Eli Zaretskii <eliz@gnu.org>
       Jonathan Grant <jg@jguk.org>
       Andreas Beuning <andreas.buening@nexgo.de>
       Earnie Boyd <earnie@uses.sf.net>
+      Troy Runkel <Troy.Runkel@mathworks.com>
 -----------------------------------
 …
   Janet Carson <janet_carson@tivoli.com>
   Howard Chu <hyc@highlandsun.com>
+  Ludovic CourtÃšs <ludo@gnu.org>
   Paul Eggert <eggert@twinsun.com>
+  Ramon Garcia Fernandez <ramon.garcia.f@gmail.com>
   Klaus Heinz <kamar@ease.rhein-main.de>
   Michael Joosten
 …
   Markus Mauhart <qwe123@chello.at>
   Greg McGary <greg@mcgary.org>
+  Thien-Thi Nguyen <ttn@gnuvola.org>
   Thomas Riedl <thomas.riedl@siemens.com>
   Han-Wen Nienhuys <hanwen@cs.uu.nl>
 …
   Carl Staelin (Princeton University)
   Ian Stewartson (Data Logic Limited)
+  Ramon Garcia Fernandez <ramon.garcia.f@gmail.com>
+  David A. Wheeler <dwheeler@dwheeler.com>
+  David Boyce <dsb@boyski.com>
+  Frank Heckenbach <f.heckenbach@fh-soft.de>
 With suggestions/comments/bug reports from a cast of ... well ...
 …
 -------------------------------------------------------------------------------
+Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1997-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.

vendor/gnumake/current/ChangeLog.1

-              r2596
+              r3138
         * load.c: Use the symbol KERNEL_FILE_NAME instead of KERNEL_FILE.
         * compatMakefile: Changed the comment for `LOAD_AVG' accordinly.
+        * compatMakefile: Changed the comment for `LOAD_AVG' accordingly.
 Thu Sep  7 16:46:26 1989  Roland McGrath  (mcgrath at paris.Berkeley.EDU)
 …
         `shell_function_completed'.  Block children before forking and
         unblock after `shell_function_pid' is set properly and
         `shell_functon_completed' is reset to 0.
+        `shell_function_completed' is reset to 0.
         * commands.c (child_handler): When the child of the `shell' function
 …
         * rule.c (pattern_search): If an existent (non-intermediate)
         dependendency was found via a terminal rule, set its
+        dependency was found via a terminal rule, set its
         `tried_implicit' flag, so it will never have implicit rule search done.
 …
         * dir.c: Re-indented the `struct dir' definition to be right.
         (dir_load): Cleaned up slighty.
+        (dir_load): Cleaned up slightly.
         (file_exists_p): Removed comment saying we could use `access', since
         that is a bad idea (except for setuid programs).  Cleaned up slightly.
 …
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009 Free
+Software Foundation, Inc.
+Copyright (C) 1988-2009 Free Software Foundation, Inc.
 This file is part of GNU Make.

vendor/gnumake/current/ChangeLog.2

-              r1989
+              r3138
         stores now the names of the variables only and reads their contents
         when they are accessed to reflect that these variables are really
         global (ie. they CAN change WHILE make runs !) This handling is
+        global (i.e., they CAN change WHILE make runs !) This handling is
         made in lookup_variable()
 …
 See ChangeLog.1, available in the CVS repository at:
         http://savannah.gnu.org/cvs/?group=make
+See ChangeLog.1, available in the Git repository at:
+        http://git.savannah.gnu.org/cgit/make.git/tree/
 for earlier changes.
+Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+, 2002, 2003, 2005, 2006, 2007 Free Software Foundation, Inc.
+Copyright (C) 1991-2007 Free Software Foundation, Inc.
 This file is part of GNU Make.

vendor/gnumake/current/ChangeLog.3

-              r3137
+              r3138
+-10-09  Paul Smith  <psmith@gnu.org>
+        Version 4.0 released.
+        * configure.ac: Updated for the release.
+        * NEWS: Updated for the release.
+        * maintMakefile (tag-release): New target to add a Git tag.
+        * read.c (eval): Typo fix.
+        * ChangeLog.1: Typo fixes.
+        * w32/subproc/sub_proc.c (process_cleanup): Typo fix.
+-10-07  Eli Zaretskii  <eliz@gnu.org>
+        * w32/compat/posixfcn.c (tmpfile): Move declaration of h before
+        the first executable statement.  Reported by Gisle Vanem
+        <gvanem@yahoo.no>.
+-10-05  Paul Smith  <psmith@gnu.org>
+        * makeint.h (MAP_USERFUNC): A new map type for function names.
+        * main.c (initialize_stopchar_map): Set up the function name map.
+        * gnumake.h (gmk_func_ptr): Define a type for function pointers.
+        (gmk_add_function): Convert the last argument to FLAGS.
+        (GMK_FUNC_*): Define flags for the function.  Change the default
+        behavior to "expand" since that's the most common one.
+        * function.c (function_table_entry): Use new function pointer type.
+        (lookup_function): Accept any valid function name character based
+        on the MAP_USERFUNC values.
+        (define_new_function): Use the new calling signature.  Verify that
+        registered functions have valid names.
+        * guile.c (guile_gmake_setup): Use new calling signatures.
+        * loadapi.c (gmk_add_function): Ditto.
+        * variable.h (define_new_function): Ditto.
+        * doc/make.texi (Loaded Object API): Make the registered function
+        API documentation more clear.
+-10-03  Eli Zaretskii  <eliz@gnu.org>
+        * function.c (abspath): Reset root_len to one for Cygwin only when
+        HAVE_DOS_PATHS is defined.  Suggested by Christopher Faylor.
+-10-02  Eli Zaretskii  <eliz@gnu.org>
+        * w32/compat/posixfcn.c (tmpfile): New function, a replacement for
+        the Windows libc version.
+        Fix $abspath on Cygwin when HAVE_DOS_PATHS is in effect.
+        * function.c (IS_ABSOLUTE) [__CYGWIN__]: Special definition for
+        Cygwin.
+        (abspath) [__CYGWIN__]: Reset root_len to 1 if the absolute file
+        name has the Posix /foo/bar form.
+        [HAVE_DOS_PATHS]: Use root_len instead of hard-coded 2.
+-10-01  Paul Smith  <psmith@gnu.org>
+        * configure.ac: Update version to 3.99.93.
+        * NEWS: Ditto.
+-09-30  Paul Smith  <psmith@gnu.org>
+        * guile.c: Portability fixes for Guile 1.8.
+-09-29  Paul Smith  <psmith@gnu.org>
+        * output.c (output_dump): Always write Enter/Leave messages to stdio.
+        (log_working_directory): This now always writes to stdio, so we
+        don't need the struct output parameter anymore.
+        (output_start): Show the working directory when output_sync is not
+        set or is recursive.
+        * main.c (main): Ensure the special "already shown Enter message"
+        token is removed from MAKE_RESTARTS before the user can see it.
+        * function.c (func_shell_base): If the output_context stderr
+        exists but is invalid, write to the real stderr.
+        Fixes suggested by Frank Heckenbach <f.heckenbach@fh-soft.de>.
+        * output.c: Guard unistd.h inclusion, add io.h.
+        * gnumake.h: Move GMK_EXPORT before the declarations.
+        * make_msvc_net2003.vcproj: Add missing files.
+        Changes for MSVC suggested by Gerte Hoogewerf <g.hoogewerf@gmail.com>
+        * function.c (func_shell_base) [EMX]: Fix EMX support for output-sync.
+        * job.c (child_execute_job) [EMX]: Ditto.
+        * job.h (child_execute_job) [EMX]: Ditto.
+        * w32/compat/posixfcn.c: Invert the test for NO_OUTPUT_SYNC.
+        * guile.c (GSUBR_TYPE): Pre-2.0 Guile doesn't provide a typedef
+        for gsubr pointers.  Create one.
+        (guile_define_module): Use it.
+        (internal_guile_eval): Force UTF-8 encoding for Guile strings.
+        * main.c (main): Clear GNUMAKEFLAGS after parsing, to avoid
+        proliferation of options.
+        * NEWS: Document it.
+        * doc/make.texi (Options/Recursion): Ditto.
+-09-23  Eli Zaretskii  <eliz@gnu.org>
+        * w32/compat/posixfcn.c: Fix the forgotten OUTPUT_SYNC conditional.
+        * job.h: Ditto, but in a comment.
+-09-22  Paul Smith  <psmith@gnu.org>
+        * configure.ac: Update version to 3.99.92.
+        * NEWS: Ditto.
+        * implicit.c (pattern_search): After second expansion be sure to
+        handle order-only markers inside the expansion properly.
+        Fixes Savannah bug #31155.
+        * guile.c (guile_define_module): Technically a void* cannot
+        contain a pointer-to-function and some compilers warn about this.
+        Cast the function pointers.
+        * load.c (load_object): Ditto.
+        * read.c (eval): If load_file() returns -1, don't add this to the
+        "to be rebuilt" list.
+        * doc/make.texi (load Directive): Document it.
+        * guile.c (guile_gmake_setup): Don't initialize Guile so early.
+        (func_guile): Lazily initialize Guile the first time the $(guile ..)
+        function is invoked.  Guile can steal file descriptors which
+        confuses our jobserver FD checking, so we don't want to initialize
+        it before we have to.
+        VMS port updates by Hartmut Becker <becker.ismaning@freenet.de>
+        * makefile.com: Add output to the filelist.
+        * output.c (va_copy): Add an implementation of this macro for VMS.
+        * commands.c: Ensure filedef.h is #included before dep.h.
+        * dir.c: Ditto.
+        * file.c: Ditto.
+        * guile.c: Ditto.
+        * main.c: Ditto.
+        * misc.c: Ditto.
+        * read.c: Ditto.
+        * rule.c: Ditto.
+        * variable.c: Ditto.
+        * readme.vms: Renamed to README.VMS and updates for this release.
+        * Makefile.am: Ditto.
+        * NEWS: Ditto.
+        * README.template: Ditto.
+        * Makefile.DOS.template: Ditto.
+-09-21  Paul Smith  <psmith@gnu.org>
+        * maintMakefile (check-alt-config): Create a target to test
+        alternative configurations.  Each one will build make with a
+        different configuration then run the test suite.
+        Invert the output-sync #define to NO_OUTPUT_SYNC
+        * configure.ac: Don't set OUTPUT_SYNC.
+        * makeint.h: Ditto.
+        * main.c: Use NO_OUTPUT_SYNC instead of OUTPUT_SYNC.
+        * output.c: Ditto.
+        * output.h: Ditto.
+        * job.h: Ditto.
+        * job.c: Ditto.
+        * config.ami.template: Set NO_OUTPUT_SYNC.
+        * config.h-vms.template: Ditto.
+        * config.h.W32.template: Ditto.
+        * configh.dos.template: Ditto.
+        Output generated while reading makefiles should be synced.
+        * main.c (make_sync): Define a context for syncing while reading
+        makefiles and other top-level operations.
+        (main): If we request syncing, enable it while we are parsing
+        options, reading makefiles, etc. to capture that output.  Just
+        before we start to run rules, dump the output if any.
+        (die): Dump any output we've been syncing before we die
+        * output.h (OUTPUT_SET): Disable output_context if not syncout.
+        Stderr generated from shell functions in recipes should be synced.
+        * job.h (FD_STDIN, FD_STDOUT, FD_STDERR): Create new macros to
+        avoid magic numbers.
+        (child_execute_job): Take a FD for stderr.
+        * job.c (child_execute_job): Handle STDERR FD's in addition to
+        stdin and stdout.
+        (start_job_command): Call child_execute_job() with the new STDERR
+        parameter.  Instead of performing the dup() here, send it to
+        child_execute_job() where it's already being done.
+        * function.c (func_shell_base): Pass the OUTPUT_CONTEXT stderr to
+        child_execute_job() if it's set, otherwise FD_STDERR.
+        * main.c (main): Pass FD_STDERR to child_execute_job().
+-09-19  Paul Smith  <psmith@gnu.org>
+        * main.c (main): Set MAKE_RESTARTS to negative before re-exec if
+        we've already generated an "Entering" message.  If we are started
+        and notice that MAKE_RESTARTS is negative, assume we already wrote
+        "Entering" and don't write it again.
+-09-18  Paul Smith  <psmith@gnu.org>
+        * main.c (main): Set starting_directory before we write any
+        errors.  Fixes Savannah bug #40043.
+-09-16  Eli Zaretskii  <eliz@gnu.org>
+        * output.c [WINDOWS32]: Include windows.h and sub_proc.h, to avoid
+        compiler warnings for CLOSE_ON_EXEC.
+-09-16  Paul Smith  <psmith@gnu.org>
+        * configure.ac: Update version to 3.99.91.
+        * NEWS: Ditto.
+-09-15  Paul Smith  <psmith@gnu.org>
+        * doc/make.texi (Error Messages): Add a bit more info to the
+        section on static pattern errors, since they're common.
+        Fixes Savannah bug #31326.
+        * read.c (eval_makefile): If the file open fails with an
+        unrecoverable error, stop now rather than trying to make it.
+        Fixes Savannah bug #27374.
+        * main.c (main): Perform the validation of the jobserver FDs
+        early, before we read makefiles, to ensure that something hasn't
+        opened and used those FDs for some other reason.
+        Fixes Savannah bug #39934.
+        * main.c (main): Don't set MAKEFLAGS in the environment when we
+        restart.  We have the original command line flags so keep the
+        original MAKEFLAGS settings as well.
+        Fixes Savannah bug #39203.
+-09-14  Paul Smith  <psmith@gnu.org>
+        * main.c (decode_debug_flags): Add support for the "n" flag to
+        disable all debugging.
+        * make.1: Document the "n" (none) flag.
+        * doc/make.texi (Options Summary): Ditto.
+        * NEWS: Ditto.
+        Fixes Savannah bug #35248.
+        * misc.c (close_stdout): Move to output.c.
+        * main.c (main): Move atexit call to output_init().
+        * makeint.h: Remove close_stdout() declaration.
+        * output.c (output_init): Add close_stdout at exit only if it's open.
+        Fixes Savannah bug #33134.  Suggested by David Boyce <dsb@boyski.com>.
+-09-14  Paul Smith  <psmith@gnu.org>
+        * misc.c (set_append_mode, open_tmpfd, open_tmpfile): Move to output.c.
+        * misc.h: Ditto.
+        * output.h: Ditto.
+        * main.c (main): Move stdio init into output.c:output_init().
+        Change open_tmpfile() to output_tmpfile().
+        * output.c: Rename open_*() to output_*().  set_append_mode() and
+        open_tmpfd() are static.
+        (_outputs, log_working_directory): Accept a struct output and
+        print to that rather than the global context.
+        (output_dump): In recurse mode print enter/leave once for the
+        whole makefile.
+        (output_init): Initialize this processes stdio as well as child's.
+        * vmsjobs.c: Reformat to be closer to convention.
+-09-12  Paul Smith  <psmith@gnu.org>
+        Rework output to handle synchronization and directory logging more
+        reliably.
+        * output.c: New file.  Implement lazy synchronization and
+        directory logging so that we manage them "just in time", and the
+        destination of the output is set via a global state variable.
+        * output.h: New file.
+        * function.c (func_shell_base): Ensure the output is set up before
+        running a shell command, in case it writes to stderr.
+        (func_error): Use outputs() to generate output.
+        * job.h (struct child): Add struct output to track the child's output.
+        * job.c: Use struct output in the child structure to track output.
+        (child_out, sync_init, assign_child_tempfiles, pump_from_tmp)
+        (acquire_semaphore, release_semaphore, sync_output): Move most of
+        the output_sync handling to output.c.
+        (child_error): Set output, then use simple message() and error()
+        not _s versions.
+        * main.c (log_working_directory): Moved to output.c
+        (trace_option, decode_trace_flags) Remove.  Remove support for
+        different trace modes; we don't use it anymore.
+        (die) Invoke output_close() before we exit.
+        * misc.c (message_s, error_s): Removed; no longer needed.
+        (message, error, fatal, perror_with_name, pfatal_with_name): Moved
+        to output.c.
+        * makeint.h: Remove message_s(), error_s(), and
+        log_working_directory().  Remove the TRACE_* macros.
+        * doc/make.texi: Enhance documentation for output sync, and remove
+        MODE assignment for --trace.
+        * make.1: Remove MODE assignment for --trace.
+        * Makefile.am: Add new files.
+        * NMakefile.template: Ditto.
+        * SMakefile.template: Ditto.
+        * build_w32.bat: Ditto.
+        * dosbuild.bat: Ditto.
+        * make.lnk: Ditto.
+        * make_nsvc_net2003.vcproj: Ditto.
+        * makefile.vms: Ditto.
+        * po/POTFILES.in: Ditto.
+-08-22  Petr Machata  <pmachata@redhat.com>
+        * function.c (func_shell_base): Get rid of any avoidable limit on
+        stack size for processes spawned via $(shell).
+-07-22  Paul Smith  <psmith@gnu.org>
+        * implicit.c (pattern_search): Use PARSE_SIMPLE_SEQ() even for
+        non-second expansion prerequisites, to handle globbing in patterns.
+        Fixes Savannah bug #39310.
+        * dep.h (PARSE_SIMPLE_SEQ): Macro for simple file sequence parsing.
+        * default.c (set_default_suffixes): Use it.
+        * file.c (split_prereqs): Ditto.
+        * main.c (main): Ditto.
+        * read.c (eval): Ditto.
+        * rule.c (install_pattern_rule): Ditto.
+        * file.c (split_prereqs): Use PARSEFS_NONE instead of 0.
+-07-21  Paul Smith  <psmith@gnu.org>
+        Cleanups detected by cppcheck.  Fixes Savannah bug #39158.
+        * arscan.c (ar_scan): Reduce the scope of local variables.
+        * dir.c (vms_hash): Ditto.
+        (find_directory): Ditto.
+        (file_impossible_p): Ditto.
+        * expand.c (variable_expand_string): Ditto.
+        * function.c (func_sort): Ditto.
+        (func_and): Ditto.
+        * job.c (reap_children): Ditto.
+        (exec_command): Ditto.
+        * main.c (main): Ditto.
+        * misc.c (collapse_continuations): Ditto.
+        * read.c (eval): Ditto.
+        (parse_file_seq): Ditto.
+        * vpath.c (gpath_search): Ditto.
+        (selective_vpath_search): Ditto.
+        * job.c (is_bourne_compatible_shell): Simplify for non-Windows systems.
+        * remake.c (f_mtime): Remove duplicate test.
+        * signame.c (strsignal): Fix bogus conditional.
+        * job.c (assign_child_tempfiles): Assign OUTFD to -1 for safety.
+        (start_job_command): Don't test output_sync and sync_cmd: redundant.
+        Changes suggested by Frank Heckenbach <f.heckenbach@fh-soft.de>.
+-07-14  Paul Smith  <psmith@gnu.org>
+        * filedef.h (update_status): Convert UPDATE_STATUS from a char to
+        an enumeration.  Some systems declare "char" to be "unsigned"
+        which broke the code (which expected to be able to use -1 as a
+        flag).  Using magic values was unpleasant, so rather than just
+        force "signed char" I reworked it to use an enum.
+        * dep.h (update_goal_chain): Return an update_status value not int.
+        * remake.c (touch_file): Ditto.
+        (update_goal_chain): Track the update_status enum.
+        * file.c (enter_file): Use new enumeration values with update_status.
+        (remove_intermediates): Ditto.
+        (print_file): Ditto.
+        * commands.c (execute_file_commands): Ditto.
+        * job.c (reap_children): Ditto.
+        (start_job_command): Ditto.
+        (start_waiting_job): Ditto.
+        * main.c (main): Ditto.
+        * remake.c (update_file): Ditto.
+        (complain): Ditto.
+        (update_file_1): Ditto.
+        (notice_finished_file): Ditto.
+        (remake_file): Ditto.
+        * vmsjobs.c (vmsHandleChildTerm): Ditto.
+-07-09  Paul Smith  <psmith@gnu.org>
+        * implicit.c (pattern_search): Keep a local copy of the number of
+        deps in deplist: the global max might change due to recursion.
+        Fixes a bug reported by Martin d'Anjou <martin.danjou14@gmail.com>.
+-06-28  Paul Smith  <psmith@gnu.org>
+        * misc.c (set_append_mode): Set the O_APPEND flag on a file descriptor.
+        (open_tmpfd): Set append mode on the temporary file descriptor.
+        * main.c (main): Set append mode on stdout and stderr.
+        * makeint.h (set_append_mode): Declare it.
+-06-22  Eli Zaretskii  <eliz@gnu.org>
+        * build_w32.bat (LinkGCC): Prevent a comment from being displayed
+        at build time.
+        * job.c (construct_command_argv_internal) [WINDOWS32]: Use
+        case-insensitive comparison with internal commands of non-Unix
+        shells.
+        * main.c (find_and_set_default_shell): Don't use file_exists_p or
+        dir_file_exists_p, as those call readdir, which can fail if PATH
+        includes directories with non-ASCII characters, and that would
+        cause Make to fail at startup with confusing diagnostics.  See
+        https://sourceforge.net/mailarchive/message.php?msg_id=30846737
+        for the details.
+-06-22  Paul Smith  <psmith@gnu.org>
+        Improve performance by using a character map to determine where we
+        want to stop searching strings, rather than discrete comparisons.
+        * read.c (find_char_unquote): Pass a stop map instead of various
+        flags and use that to check when to stop parsing the string.
+        (eval): Use the new find_char_unquote() calling signature.
+        (remove_comments): Ditto.
+        (unescape_char): Ditto.
+        (find_percent_cached): Ditto.
+        (parse_file_seq): Use a stop-map flag.
+        * main.c (stopchar_map): Character map definition.
+        (initialize_stopchar_map): Initialize the map definition.
+        (main): Invoke the map initialization function.
+        * misc.c (end_of_token_w32): Remove unused function.
+        * dir.c (dosify): Use STOP_SET to check for stop chars.
+        * main.c (main): Ditto.
+        * misc.c (end_of_token): Ditto.
+        * function.c (subst_expand): Ditto.
+        (func_notdir_suffix): Ditto.
+        (func_basename_dir): Ditto.
+        (abspath): Ditto.
+        * job.c (is_bourne_compatible_shell): Ditto.
+        * variable.c (parse_variable_definition): Ditto.
+        * read.c (eval): Ditto.
+        (conditional_line): Ditto.
+        (find_percent_cached): Ditto.
+        * dep.h (PARSE_FILE_SEQ): Update function declaration.
+        * default.c (set_default_suffixes): Update PARSE_FILE_SEQ() call.
+        * file.c (split_prereqs): Ditto.
+        * function.c (string_glob): Ditto.
+        * implicit.c (pattern_search): Ditto.
+        * rule.c (install_pattern_rule): Ditto.
+        * main.c (main): Ditto.
+-06-21  Paul Smith  <psmith@gnu.org>
+        * main.c (verify_flag): Global variable to determine whether to
+        verify the database or not.
+        (decode_debug_flags): If debug mode, enable verify_flag.
+        (main): If MAKE_MAINTAINER_MODE, enable verify_flag, otherwise not.
+        (die): Only verify the database if verify_flag is set.
+        * file.c (enter_file): Don't check caching unless verify_flag.
+        * makeint.h: Export verify_flag.
+-05-27  Paul Smith  <psmith@gnu.org>
+        * variable.c (define_automatic_variables): Create a new variable
+        MAKE_HOST.
+-05-27  Hartmut Becker  <becker.ismaning@freenet.de>
+        * function.c (func_shell_base) [VMS]: Support VMS.
+        * makefile.com [VMS]: Ditto.
+        * makefile.vms [VMS]: Ditto.
+        * makeint.h [VMS]: Ditto.
+        * vmsjobs.c [VMS]: Ditto.
+        * job.h: Define RECORD_SYNC_MUTEX() when OUTPUT_SYNC is not set.
+        * load.c (unload_file): Fix signature if MAKE_LOAD is not set.
+-05-26  Paul Smith  <psmith@gnu.org>
+        * remake.c (f_mtime): Ensure that archive file names are in the
+        string cache.  Fixes Savannah bug #38442.
+        * read.c (readline): To be safe, move the entire buffer if we
+        detect a CR.  Fixes Savannah bug #38945.
+        * job.c (new_job): Compare OUT to the beginning of the OUT
+        var/function, not IN.  Fixes Savannah bug #39035.
+-05-22  Paul Smith  <psmith@gnu.org>
+        * main.c (switches[]): Order switches so simple flags all come first.
+        (define_makeflags): Rework to make option passing more
+        reliable and the code less tricksy.  Ensure simple flags are kept
+        in the initial batch of flags.  Do not allow any flags with
+        options in that batch.  If there are only non-simple flags MAKEFLAGS
+        begins with ' '.
+        (print_data_base): Print the version.  Fixes part of Savannah #35336.
+        * read.c (eval_buffer): Initialize lineno.
+-05-18  Alexey Pavlov  <alexpux@gmail.com>  (tiny change)
+        * w32/Makefile.am (libw32_a_SOURCES): Add compat/posixfcn.c.
+        * configure.ac (OUTPUT_SYNC): Define for mingw32 target.
+        * job.c (construct_command_argv_internal) <sh_cmds_dos>
+        [WINDOWS32]: Add "move".  Fixes Savannah bug #30714.
+        * guile.c: Move inclusion of makeint.h before gnumake.h.  This
+        order must be observed when building Make, because gnumake.h must
+        be included with GMK_BUILDING_MAKE defined, which makeint.h
+        already does.  Otherwise, the linker will look for, and fail to
+        find, gmk_* functions in some external dynamic library.
+-05-17  Benno Schulenberg  <bensberg@justemail.net>
+        * main.c (decode_output_sync_flags): Fix output message.
+        * read.c (EXTRANEOUS): Ditto.
+        (record_files): Ditto.
+        * remake.c (update_file_1): Ditto.
+-05-17  Eli Zaretskii  <eliz@gnu.org>
+        * main.c (prepare_mutex_handle_string): Define conditioned on
+        OUTPUT_SYNC.
+        * build_w32.bat: Copy config.h.W32 to config.h regardless of
+        whether or not we are building from SCM.
+-05-17  Paul Smith  <psmith@gnu.org>
+        * configure.ac: Update version to 3.99.90.
+        * NEWS: Ditto.
+        * Source (*.[ch]): Remove TABs, use GNU coding styles.
+        * ALL: Update copyright.
+        * hash.c (CALLOC): Use xcalloc() to handle out of memory errors.
+        * makeint.h: Prototype new unload_file() function.
+        * load.c (unload_file): Create a function to unload a file.
+        (struct load_list): Type to remember loaded objects.
+        (loaded_syms): Global variable of remembered loaded objects so we
+        can unload them later.  We don't have to remove from the list
+        because the only time we unload is if we're about to re-exec.
+        (load_object): Remove unneeded extra DLP argument.
+        (load_file): Remove unneeded extra DLP argument.
+        * filedef.h (struct file): Remove the DLP pointer and add the
+        LOADED bit flag.  Saves 32/64 bytes per file, as this pointer is
+        almost never needed.
+        * read.c (eval): Set the new LOADED bit flag on the file.
+        * file.c (rehash_file): Merge the loaded bitfield.
+        * commands.c (execute_file_commands): Call unload_file() instead
+        of dlclose() directly.
+-05-14  Paul Smith  <psmith@gnu.org>
+        * doc/make.texi (Loaded Object API): Document the requirement for
+        the plugin_is_GPL_compatible symbol.
+        * load.c (load_object): Check for plugin_is_GPL_compatible symbol.
+-05-13  Paul Smith  <psmith@gnu.org>
+        * filedef.h (struct file): Add a builtin flag.
+        * file.c (enter_file): Unset the builtin flag.
+        (rehash_file): Ditto.
+        (print_file): Don't print builtin files if we've omitted them.
+        * default.c (undefine_default_variables): New function: go through
+        the default variables and undefine them.
+        (set_default_suffixes): Mark these suffix rules as builtin.
+        * makeint.h: Prototype.
+        * main.c (main): Handle addition of -r and -R to MAKEFLAGS in the
+        makefile.  Fixes Savannah bug #20501.
+        * main.c (define_makeflags): Assign o_env_override level to
+        MAKEFLAGS to ensure it's set even in the presence of -e.
+        Fixes Savannah bug #2216.
+        * makeint.h (TRACE_NONE, TRACE_RULE, TRACE_DIRECTORY): Define
+        constants for the trace mode.
+        * main.c: Add new --trace mode parsing.
+        (decode_trace_flags): New function.
+        (decode_switches): Call it.
+        (define_makeflags): Fix a bug with long-name options.
+        * misc.c (fatal): Remove special output-sync handling.
+        * make.1: Document new --trace mode flags.
+        * doc/make.texi (Options Summary): Ditto.
+-05-11  Eli Zaretskii  <eliz@gnu.org>
+        * job.c (child_out): Output the newline following the message
+        before fllush-ing the stream.  Avoids displaying the following
+        failure message, which goes to stderr, on the same line.
+-05-06  Eli Zaretskii  <eliz@gnu.org>
+        * gnumake.h (GMK_EXPORT) [_WIN32]: Move the dllexport declaration
+        here from makeint.h.
+        * makeint.h (GMK_BUILDING_MAKE) [WINDOWS32]: Define before
+        including gnumake.h.
+        * doc/make.texi (Loaded Object Example): Add a note about building
+        shared objects on MS-Windows.
+-05-05  Paul Smith  <psmith@gnu.org>
+        * makeint.h (OUTPUT_SYNC_LINE, OUTPUT_SYNC_RECURSE): Rename
+        output-sync options "job" to "line" and "make" to "recurse".
+        * main.c (decode_output_sync_flags): Ditto.
+        * job.c (reap_children): Ditto.
+        (start_job_command): Ditto.
+        * make.1: Ditto.
+        * doc/make.texi (Parallel Output): Ditto.
+        * job.c (child_out): Write newlines explicitly, and don't do
+        anything if the message is empty.
+        (sync_output): Put working dir messages around stdout AND stderr.
+        (start_job_command): Move the tmp file assignment earlier.  After
+        we do it, write the command line to the temp file to get the order
+        correct.
+        * misc.c (message): Remove special handling for output_sync.
+        (error): Ditto.
+-05-04  Paul Smith  <psmith@gnu.org>
+        * loadapi.c (gmk_alloc): New function.
+        * gnumake.h: Add gmk_alloc().  Clean GMK_EXPORT a bit to avoid MAIN.
+        * makeint.h (GMK_EXPORT): New handling, vs. MAIN.
+        * doc/make.texi (Loaded Object API): Add information on the memory
+        handling functions.
+        (Loaded Object Example): Create an example.
+        * job.c (pump_from_tmp): (Rename) Write to stdout/stderr using
+        FILE* rather than fd.  It's not a good idea to mix and match.
+-05-04  Eli Zaretskii  <eliz@gnu.org>
+        * makeint.h (ftruncate) [_MSC_VER]: Redirect to _chsize.
+        (_S_ISDIR): If not defined (MinGW64), define to S_ISDIR.
+-05-04  Paul Smith  <psmith@gnu.org>
+        * job.c (child_out): Handle EINTR and incomplete write scenarios.
+        (sync_init): New function: separate the initialization code.
+        (assign_child_tempfiles): Remove truncation from this function,
+        (sync_output): and add it here after output is generated.
+        (reap_children): Always call sync_output() in case output_sync was
+        reset after the child started, due to error.
+        (start_job_command): Create new sync_cmd variable.  Use new method
+        for initializing the handle.
+        If we're not syncing the output be sure any output we've saved is
+        dumped immediately before starting the child.
+-05-04  Eli Zaretskii  <eliz@gnu.org>
+        * job.c (start_job_command): Make the condition for creating a
+        temporary output file be identical to the Posix code branch.
+        Suggested by Frank Heckenbach <f.heckenbach@fh-soft.de>.
+-05-03  Eli Zaretskii  <eliz@gnu.org>
+        * w32/subproc/sub_proc.c: Include makeint.h.  Remove a private
+        incompatible prototype of xmalloc.
+        (batch_file_with_spaces): New function, detects Windows batch
+        files whose names include whitespace characters.
+        (process_begin): If exec_name is a batch file with whitespace
+        characters in its name, pass NULL as the first argument to
+        CreateProcess.  This avoids weird failures due to buggy quoting by
+        CreateProcess.  For the details, see the discussion starting at
+        http://lists.gnu.org/archive/html/make-w32/2013-04/msg00008.html.
+        * load.c (load_object, load_file): Accept an additional argument
+        DLP and return in it a pointer that can be used to unload the
+        dynamic object.
+        * read.c (eval): Call load_file with an additional argument, and
+        record the pointer returned there in the 'struct file' object of
+        dynamic objects in that object's 'struct file'.
+        * commands.c (execute_file_commands): Unload dynamic objects
+        before remaking them, to avoid failure to remake if the OS doesn't
+        allow overwriting objects that are in use.
+        * filedef.h (struct file): New member dlopen_ptr.
+        * gnumake.h (GMK_EXPORT): Define to dllexport/dllimport
+        decorations for Windows and to nothing on other platforms.
+        (gmk_eval, gmk_expand, gmk_add_function): Add GMK_EXPORT qualifier
+        to prototypes.
+        * makeint.h (MAIN): Define before including gnumake.h, to give
+        correct dllexport decorations to exported functions.
+        (load_file): Adjust prototype.
+        * loadapi.c: Don't include gnumake.h, since makeint.h already
+        includes it, and takes care of defining MAIN before doing so.
+        * build_w32.bat (LinkGCC): Produce an import library for functions
+        exported by Make for loadable dynamic objects.
+        * w32/compat/posixfcn.c (dlclose): New function.
+        * w32/include/dlfcn.h (dlclose): Add prototype.
+-05-01  Eli Zaretskii  <eliz@gnu.org>
+        * job.c (start_job_command) [WINDOWS32]: Make the same fix for
+        MS-Windows as the previous commit did for Posix platforms.
+        (construct_command_argv_internal): Don't treat a backslash as an
+        escape character before whitespace, if the shell is not a Posix
+        shell.   For the description of the problem, see
+        http://lists.gnu.org/archive/html/make-w32/2013-04/msg00014.html.
+-05-01  Paul Smith  <psmith@gnu.org>
+        * job.c (start_job_command): Don't redirect output for recursive
+        make jobs, unless we're in makefile synchronization mode.
+-04-30  Stefano Lattarini <stefano.lattarini@gmail.com>  (tiny change)
+        build: enable the 'silent-rules' automake options
+        * configure.ac (AM_INIT_AUTOMAKE): Here.  The future major Automake
+        version 2.0 (ETA about one, one and half year from now) will enable
+        it by default, so better prepare ourselves.
+-04-30  Stefano Lattarini <stefano.lattarini@gmail.com>  (tiny change)
+        build: require Autoconf >= 2.62 and Automake >= 1.11.1
+        Older versions of those tools should be considered fully obsolete.
+        Also, GNU make already requires Gettext >= 0.18.1, which has been
+        released six months after Automake 1.11.1 and two years after
+        Autoconf 2.62; so the new requirement shouldn't be problematic
+        for people already bootstrapping GNU make from the Git repository.
+        * configure.ac (AC_PREREQ): Require Autoconf 2.62 or later.
+        (AM_INIT_AUTOMAKE): Require Automake 1.11.1 or later (1.11 had
+        some serious bugs, and should not be used).
+-04-30  Stefano Lattarini <stefano.lattarini@gmail.com>  (tiny change)
+        build: get rid of 'HAVE_ANSI_COMPILER' C preprocessor conditional
+        GNU make already assume C89 or later throughout the codebase, and
+        that preprocessor conditional was no longer used anyway.
+        * configure.ac: Remove AC_DEFINE of HAVE_ANSI_COMPILER.
+        * config.ami.template: Remove #define of HAVE_ANSI_COMPILER.
+        * config.h-vms.template: Likewise.
+        * config.h.W32.template: Likewise.
+        * configh.dos.template: Likewise.
+-04-30  Stefano Lattarini <stefano.lattarini@gmail.com>  (tiny change)
+        cosmetics: fix few innocuous typos
+        Most of these were found using Lucas De Marchi's 'codespell' tool.
+        * ChangeLog: Fix minor typos.
+        * ChangeLog.2: Likewise.
+        * README.Amiga: Likewise.
+        * TODO.private: Likewise.
+        * function.c: Likewise.
+        * glob/glob.h: Likewise.
+        * job.c: Likewise.
+        * main.c: Likewise.
+        * readme.vms: Likewise.
+        * remake.c: Likewise.
+        * tests/ChangeLog: Likewise.
+        * tests/NEWS: Likewise.
+        * tests/README: Likewise.
+        * tests/scripts/variables/private: Likewise.
+        * vmsdir.h: Likewise.
+        * signame.c: Likewise.  While at it, improve line wrapping in the
+        touched comment.
+-04-29  Eli Zaretskii  <eliz@gnu.org>
+        * w32/include/dlfcn.h: New file.
+        * w32/compat/posixfcn.c: Include dlfcn.h.
+        (dlopen, dlerror, dlsym) [MAKE_LOAD]: New functions, in support of
+        dynamic loading.
+        * config.h.W32.template (MAKE_LOAD): Define.
+        * load.c (load_object) [HAVE_DOS_PATHS]: Support backslashes and
+        drive letters in file names of dynamic objects.
+        * job.c (construct_command_argv_internal) [WINDOWS32]: Return
+        right after generating new_argv for one_shell case.  This fixes
+        the Windows build for both Unixy shell and stock Windows shells.
+-04-28  Eli Zaretskii  <eliz@gnu.org>
+        * dir.c (local_stat) [WINDOWS32]: Use the wrapper on MS-Windows.
+        If the argument ends in "dir/.", make sure the parent dir exists
+        and is indeed a directory.  Fixes Savannah bug #37065.
+-04-28  Paul Smith  <psmith@gnu.org>
+        * makeint.h (message_s, error_s): Functions that print to strings
+        rather than directly to files.
+        * misc.c (message_s, error_s): Create them.
+        * job.c (child_error): Print error messages to the output sync
+        logs, if one exists, rather then directly to the terminal.
+        (reap_children): Move the per-line sync after child_error().
+        * configure.ac: Remove support for pre-ANSI variadic function calls.
+        * makeint.h: Ditto.
+        * misc.c: Ditto.
+        * config.ami.template: Ditto.
+        * config.h-vms.template: Ditto.
+        * config.h.W32.template: Ditto.
+        * configh.dos.template: Ditto.
+        Implement a "per-job" output synchronization option.
+        * main.c (decode_output_sync_flags): Recognize the new option.
+        * makeint.h (OUTPUT_SYNC_JOB): Add new values for "job"
+        * job.c (assign_child_tempfiles): In per-job mode, truncate the
+        temp file for re-use by the next job.
+        (sync_output): Don't close the temp files as we may still use them.
+        (free_child): Close the temp files here as we definitely don't
+        need them.
+        (new_job): In per-job output mode, sync_output() after each job.
+        * job.h (struct child): Avoid ifdefs.
+        * make.1: Add new options to the man page.
+        * doc/make.texi (Parallel Output): Break documentation on input
+        and output into separate sections for readability.  Document the
+        new "job" and "none" modes.
+-04-27  Paul Smith  <psmith@gnu.org>
+        * job.c (construct_command_argv_internal): Fix oneshell support
+        for non-POSIX-sh shells.
+        * load.c (load_object): Extract all POSIX-isms into a separate
+        function for portability.
+        (load_file): Check the .LOADED variable first and don't invoke
+        load_object() if it's already been loaded.
+-04-27  Eli Zaretskii  <eliz@gnu.org>
+        * read.c (record_files): Pay attention to .ONESHELL in MS-Windows.
+        * job.c (construct_command_argv_internal): Support .ONESHELL on
+        MS-Windows, when the shell is not a Unixy shell.
+-04-27  Eli Zaretskii  <eliz@gnu.org>
+        * job.c: Fix compilation error on GNU/Linux due to "label at end
+        of compound statement".
+-04-27  Frank Heckenbach <f.heckenbach@fh-soft.de>  (tiny change)
+        * job.c (sync_output): Don't discard the output if
+        acquire_semaphore fails; instead, dump the output unsynchronized.
+-04-27  Eli Zaretskii  <eliz@gnu.org>
+        Support --output-sync on MS-Windows.
+        * w32/compat/posixfcn.c: New file, with emulations of Posix
+        functions and Posix functionality for MS-Windows.
+        * w32/subproc/sub_proc.c: Include io.h.
+        (process_noinherit): New function, forces a file descriptor to not
+        be inherited by child processes.
+        (process_easy): Accept two additional arguments, and use them to
+        set up the standard output and standard error handles of the child
+        process.
+        * w32/include/sub_proc.h (process_easy): Adjust prototype.
+        (process_noinherit): Add prototype.
+        * read.c [WINDOWS32]: Include windows.h and sub_proc.h.
+        * makeint.h (LOCALEDIR) [WINDOWS32}: Define to NULL if not
+        defined.  This is needed because the MS-Windows build doesn't have
+        a canonical place for LOCALEDIR.
+        (WIN32_LEAN_AND_MEAN) [WINDOWS32]: Define, to avoid getting from
+        windows.h header too much stuff that could conflict with the code.
+        * main.c <sync_mutex>: New static variable.
+        <switches>: Add support for "--sync-mutex" switch.
+        (decode_output_sync_flags): Decode the --sync-mutex= switch.
+        (prepare_mutex_handle_string) [WINDOWS32]: New function.
+        (main): Add "output-sync" to .FEATURES.
+        * job.h (CLOSE_ON_EXEC) [WINDOWS32]: Define to call
+        process_noinherit.
+        (F_GETFD, F_SETLKW, F_WRLCK, F_UNLCK, struct flock) [WINDOWS32]:
+        New macros.
+        (RECORD_SYNC_MUTEX): New macro, a no-op for Posix platforms.
+        (sync_handle_t): New typedef.
+        * job.c <sync_handle>: Change type to sync_handle_t.
+        (FD_NOT_EMPTY): Seek to the file's end.  Suggested by Frank
+        Heckenbach <f.heckenbach@fh-soft.de>.
+        (pump_from_tmp_fd) [WINDOWS32]: Switch to_fd to binary mode for
+        the duration of this function, and then change back before
+        returning.
+        (start_job_command) [WINDOWS32]: Support output_sync mode on
+        MS-Windows.  Use a system-wide mutex instead of locking
+        stdout/stderr.  Call process_easy with two additional arguments:
+        child->outfd and child->errfd.
+        (exec_command) [WINDOWS32]: Pass two additional arguments, both
+        -1, to process_easy, to adjust for the changed function signature.
+        * function.c (windows32_openpipe) [WINDOWS32]: This function now
+        returns an int, which is -1 if it fails and zero otherwise.  It
+        also calls 'error' instead of 'fatal', to avoid exiting
+        prematurely.
+        (func_shell_base) [WINDOWS32]: Call perror_with_name if
+        windows32_openpipe fails, now that it always returns.  This avoids
+        a compiler warning that error_prefix is not used in the MS-Windows
+        build.
+        * config.h.W32.template (OUTPUT_SYNC): Define.
+        * build_w32.bat: Add w32/compat/posixfcn.c to compilation and
+        linking commands.
+-04-20  Stefano Lattarini <stefano.lattarini@gmail.com>  (tiny change)
+        * README.git: Our autoconf input file is 'configure.ac', not
+        'configure.in'.  Adjust accordingly.
+        * build_w32.bat: Likewise.
+        * config.h-vms.template: Likewise.
+        * Makefile.DOS.template: Likewise.
+-04-16  Paul Smith  <psmith@gnu.org>
+        * misc.c (open_tmpfd): Add a new function that returns a temporary
+        file by file descriptor.
+        (open_tmpfile): Move here from main.c.
+        * job.c (assign_child_tempfiles): Use the new open_tmpfd().
+-04-15  Paul Smith  <psmith@gnu.org>
+        * makeint.h (OUTPUT_SYNC_TARGET, OUTPUT_SYNC_MAKE): Rename.
+        * job.c (start_job_command): Use new constants.
+        * main.c: New -O argument format.
+        * doc/make.texi (Options Summary): Document the argument to -O.
+        * make.1: Ditto.
+        * main.c (define_makeflags): Don't add space between a single-char
+        option and its argument.
+-04-06  Paul Smith  <psmith@gnu.org>
+        * doc/make.texi (Implicit Variables): Clarify LDFLAGS vs. LDLIBS.
+        Fixes Savannah bug #37970.
+        * remake.c (check_dep): Reconsider files waiting on prerequisites,
+        as they may have finished.  Fixes Savannah bug #37703.
+-02-28  Paul Smith  <psmith@gnu.org>
+        * function.c (func_realpath): On Solaris (at least) realpath() can
+        fail due to EINTR, so loop it.  Fixes Savannah bug #38420.
+-02-25  Paul Smith  <psmith@gnu.org>
+        Add a proposed supported API for GNU make loaded objects.
+        * doc/make.texi (Loaded Object API): Document it.
+        * Makefile.am (make_SOURCES): Add new loadapi.c.
+        * dep.h: Remove eval_buffer(); moved to loadapi.c:gmk_eval().
+        * read.c (eval_buffer): Change eval_buffer() signature.
+        * main.c (main): Change eval_buffer() signature.
+        * variable.h (define_new_function): Change func_ptr signature.
+        * load.c (SYMBOL_EXTENSION): Change the extension.
+        * loadapi.c: Implement the new API.
+        * gnumake.h (gmk_eval): New function prototype.
+        (gmk_expand) Ditto.
+        (gmk_add_function) Ditto.
+        * gmk-default.scm (gmk-eval): Remove: now implemented in guile.c.
+        * guile.c (guile_expand_wrapper): Use gmk_expand()
+        (guile_eval_wrapper): Implement eval here to avoid double-expansion.
+        (guile_define_module): Define gmk-eval.
+        (func_guile): Use new func_ptr calling model.
+        (guile_gmake_setup): Use gmk_add_function() to declare $(guile ...)
+        * function.c (function_table_entry): Provide alternative func_ptr.
+        (func_eval): New signature for eval_buffer();
+        (function_table_init): New initialization for function_table_entry.
+        (expand_builtin_function): Support alternative invocation signature.
+        (define_new_function): Ditto.
+-01-20  Paul Smith  <psmith@gnu.org>
+        * gnumake.h: New file to contain externally-visible content.
+        * makeint.h: Include gnumake.h.  Move gmk_floc type to gnumake.h.
+        * Makefile.am (include_HEADERS): Install the gnumake.h header.
+        * makeint.h: Change struct floc to gmk_floc typedef.
+        * Many: Use the new typedef.
+        * make.h: Rename to makeint.h.
+        * Many: Use the new name makeint.h.
+-01-19  Paul Smith  <psmith@gnu.org>
+        * doc/make.texi (load Directive): Update to discuss location of
+        loaded object file.
+        (Remaking Loaded Objects): Document remaking of loaded objects.
+        * main.c (main): Rename READ_MAKEFILES to READ_FILES.
+        * read.c: Change READ_MAKEFILES to READ_FILES since it now
+        contains loaded object files as well.
+        (read_all_makefiles): Ditto.
+        (eval_makefile): Ditto.
+        (eval): Add any loaded file to the READ_FILES list, so that it
+        will be considered for re-build.
+        * load.c (load_file): Return the simple filename (no symbol) in
+        the LDNAME argument (now a const char **).
+        This filename should no longer have "./" prepended: modify the
+        function to always check the current directory if the name has no
+        "/", before using the normal methods.
+        * make.h: Change the load_file() prototype.
+        * README.git: Add a bit more documentation on Git workflow & rules.
+-01-13  Paul Smith  <psmith@gnu.org>
+        * main.c (main): Restore all make flags after re-exec is complete.
+        Fixes Savannah bug #38051.
+-01-12  Paul Smith  <psmith@gnu.org>
+        Convert CVS archive to Git.
+        * configure.in: Rename to configure.ac.
+        * README.cvs: Rename to README.git and rework for Git.
+        * maintMakefile: Use git clean for cleanup.
+        * ChangeLog: Use new Git repository URL.
+        * ChangeLog.2: Ditto.
+        * Makefile.am: Change documentation for Git
+        * Makefile.DOS.template: Ditto.
+        * README.template: Ditto.
+        * build_w32.bat: Ditto.
+        * prepare_w32.bat: Ditto.
+        * .cvsignore: Rename to .gitignore, and change to Git format.
+-12-08  Eli Zaretskii  <eliz@gnu.org>
+        * job.c (create_batch_file): Fix last change: always increment the
+        counter of batch files before trying to use it.
+-12-07  Eli Zaretskii  <eliz@gnu.org>
+        * job.c (construct_command_argv_internal): Remove " from
+        sh_chars_dos[].  Ignore an escaped backslash inside a string
+        quoted with "..".  This lifts the 4KB or 8KB command-line length
+        limitation imposed by the Windows shells when a command uses quoted
+        strings, because we now don't call the shell in that case.
+        * job.c (create_batch_file): Declare the counter of batch files
+        static, to avoid having 2 jobs using the same file name and
+        stepping on each other's toes.  When all 64K names are used up,
+        make one more loop looking for slots that became vacant.  This
+        avoids leaving behind temporary batch files in the temporary
+        directory, which happens frequently on a fast machine when using
+        parallel builds.
+        (reap_children): Add debug message for when removal of a temporary
+        batch file fails.
+-10-29  Paul Smith  <psmith@gnu.org>
+        New feature: "load" directive for dynamically-loaded objects.
+        * NEWS: Document new "load" directive.
+        * doc/make.texi (Extending make): New chapter on extensions to make.
+        * configure.in: Check for dlopen/dlsym/dlerror and -ldl.
+        * Makefile.am (make_SOURCES): Add new file load.c.
+        * make.h: Prototype for load_file().
+        * main.c (main): Add "load" to .FEATURES if it's available.
+        * read.c (eval): Parse "load" and "-load" directives.
+-09-29  Paul Smith  <psmith@gnu.org>
+        * configure.in: Require a new version of gettext (1.18.1).
+        Fixes Savannah bug #37307.
+-09-09  Paul Smith  <psmith@gnu.org>
+        * configure.in (bsd_signal): Define _GNU_SOURCE, a la make.h.
+        Fixes Savannah bug #32247.
+        * remake.c (update_file_1): Force intermediate files to be
+        considered, not pruned, if their non-intermediate parent needs to
+        be remade.  Fixes Savannah bug #30653.
+        * job.c (construct_command_argv_internal): Keep the command line
+        on the heap for very long lines.  Fixes Savannah bug #36451.
+        * function.c (func_realpath): BSD realpath(3) doesn't fail if the
+        file does not exist: use stat.  Fixes Savannah bug #35919.
+        * file.c (expand_deps): Duplicate the current variable buffer, not
+        the old pointer.  Fixes Savannah bug #36925.
+        * read.c (eval): If we detect an initial UTF-8 BOM, skip it.
+        Fixes Savannah bug #36529.
+        (record_target_var): Remove unused variable "fname".
+        (eval): Use the correct pointer when adding to the variable buffer.
+        Fixes Savannah bug #36106.
+-09-09  Eli Zaretskii  <eliz@gnu.org>
+        * read.c (unescape_char): Fix a thinko in the last change.
+-09-09  Paul Smith  <psmith@gnu.org>
+        * default.c (default_variables): Use a correct default LIBPPATERNS
+        for MacOS.  Fixes Savannah bug #37197.
+        * read.c (record_files): Reset the default macro values if .POSIX
+        is set.  Fixes Savannah bug #37069.
+        (parse_file_seq): Break out of an infinite loop if we're not
+        making progress when parsing archive references.
+-09-01  Eli Zaretskii  <eliz@gnu.org>
+        * README.W32.template: Update for job-server and Guile support.
+        * read.c (unescape_char): Advance 'p' after copying the unescaped
+        characters.  Otherwise the backslashes are incorrectly erased from
+        the original string.
+-03-05  Paul Smith  <psmith@gnu.org>
+        Update copyright notices to use year ranges, as allowed by
+        clarifications in the GNU Maintainer's Manual.
+-03-04  Paul Smith  <psmith@gnu.org>
+        * read.c (unescape_char): New function to remove escapes from a char.
+        (record_files): Call it on the dependency string to unescape ":".
+        Fixes Savannah bug #12126 and bug #16545.
+        * make.h (CSTRLEN): Determine the length of a constant string.
+        * main.c: Use the new macro.
+        * read.c: Ditto.
+        * variable.h: Ditto.
+        * function.c: Simplify checks for function alternatives.
+        * expand.c (variable_append): If the current set is local and the
+        next one is not a parent, then treat the next set as
+        local as well.  Fixes Savannah bug #35468.
+-03-03  Paul Smith  <psmith@gnu.org>
+        * acinclude.m4 (AC_STRUCT_ST_MTIM_NSEC): Add support for AIX 5.2+
+        nanosecond timestamps.  Fixes Savannah bug #32485.
+        Convert uses of `foo' for quoting to 'foo' to reflect changes in
+        the GNU Coding Standards.  Fixes Savannah bug #34530.
+        * job.c (construct_command_argv_internal): In oneshell we need to
+        break the SHELLFLAGS up for argv.  Fixes Savannah bug #35397.
+        * function.c (func_filter_filterout): Recompute the length of each
+        filter word in case it was compressed due to escape chars.  Don't
+        reset the string as it's freed.  Fixes Savannah bug #35410.
+        * misc.c (collapse_continuations): Only use POSIX-style
+        backslash/newline handling if the .POSIX target is set.
+        Addresses Savannah bug #16670 without backward-incompatibility.
+        * NEWS: Document behavior change.
+        * doc/make.texi (Splitting Lines): New section describing how to
+        use backslash/newline to split long lines.
+-02-26  Paul Smith  <psmith@gnu.org>
+        * implicit.c (pattern_search): Check the stem length to avoid
+        stack overflows in stem_str.  Fixes Savannah bug #35525.
+-02-03  Eli Zaretskii  <eliz@gnu.org>
+        * w32/subproc/sub_proc.c (proc_stdin_thread, proc_stdout_thread)
+        (proc_stderr_thread, process_pipe_io): Ifdef away unused
+        functions.
+        * w32/subproc/w32err.c (map_windows32_error_to_string) [_MSC_VER]:
+        Don't use TLS storage for szMessageBuffer.  Ifdef away special
+        code for handling Winsock error codes.  Make the function return a
+        `const char *'.  Suggested by Ozkan Sezer.  Fixes Savannah bug #34832.
+-01-29  Paul Smith  <psmith@gnu.org>
+        * gmk-default.scm (to-string-maybe): Variables map to empty strings.
+        In Guile 2.0, (define ...) results in a variable object so make
+        sure that maps to an empty string in make.
+        * variable.c (parse_variable_definition): New POSIX assignment ::=
+        Take a struct variable to return more information after parsing.
+        (assign_variable_definition): New parse_variable_definition() call.
+        * variable.h: New declaration of parse_variable_definition().
+        * read.c (do_define): New parse_variable_definition() call.
+        (parse_var_assignment): Ditto.
+        (get_next_mword): Parse ::= as a variable assignment.
+        * doc/make.texi (Flavors): Describe the new ::= syntax.
+        * NEWS: Mention the ::= operator.
+        * variable.h (struct variable): Rearrange elts to reduce struct size.
+        * function.c (func_file): Create a new function, $(file ...)
+        * doc/make.texi (File Function): Document the $(file ..) function.
+        * NEWS: Announce it.
+        * gmk-default.scm (to-string-maybe): Use a more portable way to
+        test for unprintable characters.
+        * configure.in [GUILE]: Guile 1.6 doesn't have pkg-config
+        * build_w32.bat: Ditto.
+-01-28  Eli Zaretskii  <eliz@gnu.org>
+        * config.h.W32.template: Update from config.h.in.
+        Support a Windows build with Guile.
+        * README.W32.template: Update with instructions for building with
+        Guile.
+        * build_w32.bat: Support building with Guile.
+        * make.h [HAVE_STDINT_H]: Include stdint.h.
+        * main.c (main, clean_jobserver): Move declarations of variables
+        not used in the WINDOWS32 build to the #else branch, to avoid
+        compiler warnings.
+        Fix failures on MS-Windows when Make's standard handles are invalid.
+        This can happen when Make is invoked from a GUI application.
+        * w32/subproc/sub_proc.c (process_init_fd): Don't dereference
+        pproc if it is a NULL pointer.
+        (process_begin, process_cleanup): Don't try to close pipe handles
+        whose value is INVALID_HANDLE_VALUE.
+        (process_easy): Initialize hIn, hOut, and hErr to
+        INVALID_HANDLE_VALUE.  If DuplicateHandle fails with
+        ERROR_INVALID_HANDLE, duplicate a handle for the null device
+        instead of STD_INPUT_HANDLE, STD_OUTPUT_HANDLE or
+        STD_ERROR_HANDLE.  Don't try to close pipe handles whose value is
+        INVALID_HANDLE_VALUE.
+        * function.c (windows32_openpipe): Initialize hIn and hErr to
+        INVALID_HANDLE_VALUE.  If DuplicateHandle fails with
+        ERROR_INVALID_HANDLE, duplicate a handle for the null device
+        instead of STD_INPUT_HANDLE or STD_ERROR_HANDLE.  Fix indentation.
+        Don't try to close handles whose value is INVALID_HANDLE_VALUE.
+-01-25  Eli Zaretskii  <eliz@gnu.org>
+        * function.c (define_new_function): Fix format strings in calls to
+        `fatal'.
+-01-17  Paul Smith  <psmith@gnu.org>
+        * guile.c (func_guile): Handle NULL returns from Guile.
+-01-16  Paul Smith  <psmith@gnu.org>
+        * make.h (PATH_SEPARATOR_CHAR): Allow resetting for crosscompiling
+        for Windows.  Patch by Chris Sutcliffe <ir0nh34d@gmail.com>
+        Fixes Savannah bug #34818.
+-01-15  Paul Smith  <psmith@gnu.org>
+        * variable.h: Prototype an interface for defining new make functions.
+        * function.c (define_new_function): Define it.
+        (func_guile): Remove the "guile" function.
+        (function_table_init): Ditto.
+        * guile.c (func_guile): Add the "guile" function here.
+        (setup_guile): Call define_new_function() to define it.
+        (guile_eval_string): Obsolete.
+        * all: Update copyright notices.
+-01-12  Paul Smith  <psmith@gnu.org>
+        Support GNU Guile as an embedded extension language for GNU make.
+        * NEWS: Note the new Guile capability.
+        * Makefile.am (EXTRA_DIST, make_SOURCES): Add new guile source files.
+        (AM_CFLAGS): Add Guile compiler flags.
+        (guile): Add a rule for converting default SCM into a C header.
+        * configure.in: Add support for --with-guile.
+        Also, convert the entire file to properly escaped autoconf m4, and
+        utilize newer features such as AS_IF() and AS_CASE().
+        * doc/make.texi (Guile Function): Document the GNU guile integration.
+        * make.h (guile_eval_string, guile_boot): Prototypes for Guile.
+        * main.c (main): Run guile_boot() to handle main().
+        (real_main): All the previous content of main() is here.
+        (real_main): Add "guile" to the .FEATURES variable.
+        * function.c (func_guile): Call Guile.
+        * guile.c: New file implementing GNU make integration with GNU Guile.
+        * gmk-default.scm: The integration of GNU make with Guile uses
+        Guile itself for much of the parsing and conversion of return
+        types, etc.  This implementation is embedded into GNU make.
+        * config.h-vms.template: Disable Guile support.
+        * config.h.W32.template: Ditto.
+        * configh.dos.template: Ditto.
+        * config.ami.template: Ditto.
+        * makefile.vms: Add new Guile files.
+        * Makefile.DOS.template: Ditto.
+        * Makefile.ami: Ditto.
+        * NMakefile.template: Ditto.
+        * SMakefile.template: Ditto.
+        * build_w32.bat: Ditto.
+        * dosbuild.bat: Ditto.
+        * make_msvc_net2001.vcproj: Ditto.
+-11-15  Paul Smith  <psmith@gnu.org>
+        * main.c (main): Use %ld when printing DWORD values.
+        * job.c (new_job): Ditto.
+        * w32/include/sub_proc.h: Use const.
+        * w32/subproc/sub_proc.c (open_jobserver_semaphore): Use const.
+        Fixes Savannah bug #34830.  Changes suggested by Ozkan Sezer.
+        * configure.in (MAKE_JOBSERVER): Enable jobserver on W32 systems.
+        * config.h.W32.template (MAKE_JOBSERVER): Ditto.
+-11-14  Paul Smith  <psmith@gnu.org>
+        * read.c (eval): parse_file_seq() might shorten the string due to
+        backslash removal.  Start parsing again at the colon.
+        Fixes Savannah bug #33399.
+-11-13  Paul Smith  <psmith@gnu.org>
+        * file.c (file_timestamp_cons): Match up data types to avoid warnings.
+        * filedef.h: Ditto.
+        * misc.c (concat): Ditto.
+        * read.c (eval): Assign value to avoid warnings.
+        * function.c (func_shell_base): Use fork() instead of vfork() to
+        avoid warnings.
+        * make.h (INTEGER_TYPE_SIGNED): Use <=0 to avoid warnings.
+        Fixes Savannah bug #34608.
+        * job.c (construct_command_argv): Remove _p.
+        (construct_command_argv_internal): Remove _ptr.
+        Fixes Savannah bug #32567.
+        * main.c (clean_jobserver): Don't write the free token to the pipe.
+        Change suggested by Tim Newsome <tnewsome@aristanetworks.com>
+        * acinclude.m4 (AC_STRUCT_ST_MTIM_NSEC): Add support for Darwin.
+        * filedef.h (FILE_TIMESTAMP_STAT_MODTIME): Ditto.
+        Patch provided by Troy Runkel <Troy.Runkel@mathworks.com>
+-10-11  Troy Runkel  <Troy.Runkel@mathworks.com>
+        * config.h.W32: Enable job server support for Windows.
+        * main.c [WINDOWS32]: Include sub_proc.h
+        (main): Create a named semaphore to implement the job server.
+        (clean_jobserver): Free the job server semaphore when make is finished.
+        * job.c [WINDOWS32]: Define WAIT_NOHANG
+        (reap_children): Support non-blocking wait for child processes.
+        (free_child): Release job server semaphore when child process finished.
+        (job_noop): Don't define function on Windows.
+        (set_child_handler_action_flags): Don't define function on Windows.
+        (new_job): Wait for job server semaphore or child process termination.
+        (exec_command): Pass new parameters to process_wait_for_any.
+        * w32/include/sub_proc.h [WINDOWS32]: New/updated EXTERN_DECL entries.
+        * w32/subproc/sub_proc.c [WINDOWS32]: Added job server implementation.
+        (open_jobserver_semaphore): Open existing job server semaphore by name.
+        (create_jobserver_semaphore): Create new job server named semaphore.
+        (free_jobserver_semaphore): Close existing job server semaphore.
+        (acquire_jobserver_semaphore): Decrement job server semaphore count.
+        (release_jobserver_semaphore): Increment job server semaphore count.
+        (has_jobserver_semaphore): Returns whether job server semaphore exists.
+        (get_jobserver_semaphore_name): Returns name of job server semaphore.
+        (wait_for_semaphore_or_child_process): Wait for either the job server
+        semaphore to become signalled or a child process to terminate.
+        (process_wait_for_any_private): Support for non-blocking wait for child.
+        (process_wait_for_any): Added support for non-blocking wait for child.
+        (process_file_io): Pass new parameters to process_wait_for_any_private.
+-09-18  Paul Smith  <psmith@gnu.org>
+        * main.c (main): If we're re-exec'ing and we're the master make,
+        then restore the job_slots value so it goes back into MAKEFLAGS
+        properly.  See Savannah bug #33873.
+        * remake.c (library_search): STD_DIRS is computed when other
+        static vars like buflen etc. are computed, so it must be static
+        as well.  See Savannah bug #32511.
+-09-16  Paul Smith  <psmith@gnu.org>
+        * maintMakefile (do-po-update): Apparently we have to avoid
+        certificate checks on the http://translationproject.org site now.
+-09-12  Paul Smith  <psmith@gnu.org>
+        * read.c (eval): Ensure exported variables are defined in the
+        global scope.  Fixes Savannah bug #32498.
+-09-11  Paul Smith  <psmith@gnu.org>
+        * Makefile.am (dist-hook): Remove w32/Makefile and .deps/ from the
+        dist file.  Fixes Savannah bug #31489.
+        * doc/make.texi (Complex Makefile): Add a hint about using
+        #!/usr/bin/make (for Savannah support request #106459)
+-09-02  Paul Smith  <psmith@gnu.org>
+        * remake.c (touch_file): If we have both -n and -t, -n takes
+        precedence.  Patch from Michael Witten <mfwitten@gmail.com>
+-08-29  Paul Smith  <psmith@gnu.org>
+        * expand.c (variable_expand_string): Always allocate a new buffer
+        for a string we're expanding.  The string we're working on can get
+        freed while we work on it (for example if it's the value of a
+        variable which modifies itself using an eval operation).
+        See Savannah patch #7534 for the original report by Lubomir Rintel.
+-06-12  Paul Smith  <psmith@gnu.org>
+        * read.c (parse_file_seq): Move the check for empty members out of
+        the loop so we can go to the next member properly.
+        Another fix for Savannah bug #30612.
+        * config.h-vms.template: Newer versions of VMS have strncasecmp()
+        Patch provided by: Hartmut Becker <becker.ismaning@freenet.de>
+-05-07  Paul Smith  <psmith@gnu.org>
+        * expand.c (variable_append): Add a LOCAL argument to track
+        whether this is the first invocation or not.  If it's not and
+        private_var is set, then skip this variable and try the next one.
+        Fixes Savannah bug #32872.
+        * read.c (parse_file_seq): Ensure existence checks use glob().
+-05-07  Eli Zaretskii  <eliz@gnu.org>
+        * job.c (construct_command_argv_internal): Don't assume shellflags
+        is always non-NULL.  Escape-protect characters special to the
+        shell when copying the value of SHELL into new_line.  Fixes
+        Savannah bug #23922.
+-05-02  Paul Smith  <psmith@gnu.org>
+        * doc/make.texi (Special Variables): Add documentation for the new
+        words in .FEATURES.  Fixes Savannah bug #32058.
+        (Flavor Function): Rewrite the section on the flavor function.
+        Fixes Savannah bug #31582.
+        * function.c (func_sort): Use the same algorithm to count the
+        number of words we will get after the split, as we use to split.
+        Based on a patch from Matthias Hopf.  Fixes Savannah bug #33125.
+        * make.h: Make global variable stack_limit extern.
+        Fixes Savannah bug #32753.
+-05-01  Paul Smith  <psmith@gnu.org>
+        * read.c (parse_file_seq): Don't try to invoke glob() unless there
+        are potential wildcard characters in the filename.  Performance
+        enhancement suggested by Michael Meeks <michael.meeks@novell.com>
+-04-29 Boris Kolpackov  <boris@codesynthesis.com>
+        * read.c (eval_makefile): Delay caching of the file name until after
+        all the expansions and searches.
+-04-17  David A. Wheeler  <dwheeler@dwheeler.com>
+        * doc/make.texi (Reading Makefiles): Document "!=".
+        (Setting): Ditto.
+        (Features): Ditto.
+        * variable.h (enum variable_flavor): New type "f_shell".
+        * variable.c (shell_result): Send a string to the shell and store
+        the output.
+        (do_variable_definition): Handle f_shell variables: expand the
+        value, then send it to the shell and store the result.
+        (parse_variable_definition): Parse "!=" shell assignments.
+        * read.c (get_next_mword): Treat "!=" as a varassign word.
+        * function.c (fold_newlines): If trim_newlines is set remove all
+        trailing newlines; otherwise remove only the last newline.
+        (func_shell_base): Move the guts of the shell function here.
+        (func_shell): Call func_shell_base().
+-02-21  Paul Smith  <psmith@gnu.org>
+        * strcache.c (various): Increase performance based on comments
+        from Ralf Wildenhues <Ralf.Wildenhues@gmx.de>.  Stop looking for
+        a buffer when we find the first one that fits, not the best fit.
+        If there is not enough free space in a buffer move it to a
+        separate list so we don't have to walk it again.
+        * make.h (NDEBUG): Turn off asserts unless maintainer mode is set.
+        (strcache_add_len, strcache_setbufsize): Use unsigned length/size.
+        * maintMakefile (AM_CPPFLAGS): Enable MAKE_MAINTAINER_MODE.
+        * remake.c (complain): Move translation lookups closer to use.
+-02-13  Paul Smith  <psmith@gnu.org>
+        * doc/make.texi: Clean up references to "static" variables and
+        semicolon errors.  Patch from Michael Witten <mfwitten@gmail.com>.
+-12-27  Paul Smith  <psmith@gnu.org>
+        * make.1: Update the header/footer info in the man page.
+-11-28  Paul Smith  <psmith@gnu.org>
+        * read.c (record_target_var): Don't reset v if it's the same as
+        the global version.  Fixes Savannah bug #31743.
+-11-06  Paul Smith  <psmith@gnu.org>
+        * variable.c (print_auto_variable): Print auto variables; ignore others.
+        (print_noauto_variable): Print non-auto variables; ignore others.
+        (print_variable_set): Allow the caller to select which type to print.
+        (print_target_variables): Show all the non-auto variables for a target.
+        * default.c (install_default_suffix_rules): Initialize recipe_prefix.
+        * rule.c (install_pattern_rule): Ditto.
+        * read.c (record_files): Pass in the current recipe prefix.  Remember
+        it in the struct command for these targets.
+        (eval): Remember the value of RECIPEPREFIX when we start parsing.
+        Do not remove recipe prefixes from the recipe here: we'll do it later.
+        * job.c (start_job_command): Remove recipe prefix characters early,
+        before we print the output or chop it up.
+        * file.c (print_file): If recipe_prefix is not standard, reset it
+        in -p output.  Assign target variables in -p output as well.
+        * commands.c (chop_commands): Max command lines is USHRT_MAX.
+        Set any_recurse as a bitfield.
+        * make.h (USHRT_MAX): Define if not set.
+-10-27  Paul Smith  <psmith@gnu.org>
+        * commands.h (struct commands): Rearrange to make better use of
+        memory.  Add new recipe_prefix value.
+-10-26  Paul Smith  <psmith@gnu.org>
+        * doc/make.texi (Setting): Document the treatment of
+        backslash-newline in variable values.
+        * misc.c (collapse_continuations): Do not collapse multiple
+        backslash-newlines into a single space.  Fixes Savannah bug #16670.
+-08-29  Paul Smith  <psmith@gnu.org>
+        * doc/make.texi (Implicit Variables): Document LDLIBS and LOADLIBES.
+        Fixes Savannah bug #30807.
+        (Instead of Execution): Mention that included makefiles are still
+        rebuilt even with -n.  Fixes Savannah bug #30762.
+        * configure.in: Bump to 3.82.90.
+        * make.h: Add trace_flag variable.
+        * main.c (switches): Add --trace option.
+        (trace_flag): Declare variable.
+        * job.c (start_job_command): Show recipe if trace_flag is set.
+        (new_job): Show trace messages if trace_flag is set.
+        * doc/make.texi (Options Summary): Document the new --trace option.
+        * make.1: Add --trace documentation.
+        * NEWS: Mention --trace.
+        * job.c (child_error): Show recipe filename/linenumber on error.
+        Also show "(ignored)" when appropriate even for signals/coredumps.
+        * NEWS: Mention file/linenumber change.
+        * main.c (main): Print version info when DB_BASIC is set.
+        * job.c (construct_command_argv_internal): If shellflags is not
+        set, choose an appropriate default value.  Fixes Savannah bug #30748.
+-08-27  Eli Zaretskii  <eliz@gnu.org>
+        * variable.c (define_automatic_variables) [__MSDOS__ || WINDOWS32]:
+        Remove trailing backslashes in $(@D), $(<D), etc., for consistency
+        with forward slashes.  Fixes Savannah bug #30795.
+-08-13  Paul Smith  <psmith@gnu.org>
+        * NEWS: Accidentally forgot to back out the sorted wildcard
+        enhancement in 3.82, so update NEWS.
+        Also add NEWS about the error check for explicit and pattern
+        targets in the same rule, added to 3.82.
+        * main.c (main): Add "oneshell" to $(.FEATURES) (forgot to add
+        this in 3.82!)
+        * read.c (parse_file_seq): Fix various errors parsing archives
+        with multiple objects in the parenthesis, as well as wildcards.
+        Fixes Savannah bug #30612.
+-08-10  Paul Smith  <psmith@gnu.org>
+        * main.c (main): Expand MAKEFLAGS before adding it to the
+        environment when re-exec'ing.  Fixes Savannah bug #30723.
+-08-07  Eli Zaretskii  <eliz@gnu.org>
+        * w32/subproc/build.bat: Make all 3 cl.exe compile command lines
+        use the same /I switches.  Fixes Savannah bug #30662.
+        * function.c (func_shell) [WINDOWS32]: Reset just_print_flag
+        around the call to construct_command_argv, so that a temporary
+        batch file _is_ created when needed for $(shell).
+        Fixes Savannah bug #16362.
+-08-07 Juan Manuel Guerrero  <juan.guerrero@gmx.de>
+        * configh.dos.template (HAVE_STRNCASECMP): Define.
 -07-28  Paul Smith  <psmith@gnu.org>
 …
 See ChangeLog.2, available in the CVS repository at:
         http://savannah.gnu.org/cvs/?group=make
+See ChangeLog.2, available in the Git repository at:
+        http://git.savannah.gnu.org/cgit/make.git/tree/
 for earlier changes.
+Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free
+Software Foundation, Inc.
+Copyright (C) 2000-2013 Free Software Foundation, Inc.
 This file is part of GNU Make.

vendor/gnumake/current/Makefile.DOS.template

-              r2596
+              r3138
 # Makefile.in generated automatically by automake 1.2 from Makefile.am
+#
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
+# 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+# Copyright (C) 1994-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 BUILT_SOURCES = README build.sh-in
 EXTRA_DIST =    $(BUILT_SOURCES) $(man_MANS) README.customs remote-cstms.c  make-stds.texi texinfo.tex SCOPTIONS SMakefile  Makefile.ami README.Amiga config.ami amiga.c amiga.h  NMakefile README.DOS configh.dos configure.bat makefile.com  README.W32 build_w32.bat config.h-W32 subproc.bat make.lnk  config.h-vms makefile.vms readme.vms vmsdir.h vmsfunctions.c  vmsify.c
+EXTRA_DIST =    $(BUILT_SOURCES) $(man_MANS) README.customs remote-cstms.c  make-stds.texi texinfo.tex SCOPTIONS SMakefile  Makefile.ami README.Amiga config.ami amiga.c amiga.h  NMakefile README.DOS configh.dos configure.bat makefile.com  README.W32 build_w32.bat config.h-W32 subproc.bat make.lnk  config.h-vms makefile.vms README.VMS vmsdir.h vmsfunctions.c  vmsify.c gmk-default.scm gmk-default.h
 SUBDIRS =       glob doc
 …
 NROFF = nroff
 DIST_COMMON =  README ABOUT-NLS AUTHORS COPYING ChangeLog INSTALL Makefile.am  Makefile.in NEWS acconfig.h aclocal.m4 alloca.c build.sh-in config.h-in  configure configure.in getloadavg.c
+DIST_COMMON =  README ABOUT-NLS AUTHORS COPYING ChangeLog INSTALL Makefile.am  Makefile.in NEWS acconfig.h aclocal.m4 alloca.c build.sh-in config.h-in  configure configure.ac getloadavg.c
 DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
 …
 dist-hook:
         (cd $(srcdir); \
          w32=`find w32 -follow \( -name CVS -prune \) -o -type f -print`; \
+         w32=`find w32 -follow \( -name .git -prune \) -o -type f -print`; \
          tar chf - $$w32) \
         | (cd $(distdir); tar xfBp -)

vendor/gnumake/current/Makefile.am

-              r2596
+              r3138
 # This is a -*-Makefile-*-, or close enough
+#
+# Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+# 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+# Copyright (C) 1997-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 # this program.  If not, see <http://www.gnu.org/licenses/>.
 AUTOMAKE_OPTIONS = 1.8 dist-bzip2 check-news
 ACLOCAL_AMFLAGS =  -I config
+AUTOMAKE_OPTIONS = dist-bzip2 silent-rules std-options
+ACLOCAL_AMFLAGS = -I config
 MAKE_HOST =     @MAKE_HOST@
 …
   W32INC =      -I $(top_srcdir)/w32/include
   W32LIB =      -Lw32 -lw32
+  ossrc =
+else
+  ossrc =       posixos.c
 endif
 …
 bin_PROGRAMS =  make
+include_HEADERS = gnumake.h
 if USE_CUSTOMS
 …
 endif
 make_SOURCES =  ar.c arscan.c commands.c default.c dir.c expand.c file.c \
+                function.c getopt.c getopt1.c implicit.c job.c main.c \
+                misc.c read.c remake.c $(remote) rule.c signame.c \
+                strcache.c variable.c version.c vpath.c hash.c
+                function.c getopt.c getopt1.c guile.c implicit.c job.c load.c \
+                loadapi.c main.c misc.c $(ossrc) output.c read.c remake.c \
+                rule.c signame.c strcache.c variable.c version.c vpath.c \
+                hash.c $(remote)
 EXTRA_make_SOURCES = vmsjobs.c remote-stub.c remote-cstms.c
+noinst_HEADERS = commands.h dep.h filedef.h job.h make.h rule.h variable.h \
+                debug.h getopt.h gettext.h hash.h
+make_LDADD =    @LIBOBJS@ @ALLOCA@ $(GLOBLIB) @GETLOADAVG_LIBS@ @LIBINTL@
+noinst_HEADERS = commands.h dep.h filedef.h job.h makeint.h rule.h variable.h \
+                debug.h getopt.h gettext.h hash.h output.h os.h
+make_LDADD =    @LIBOBJS@ @ALLOCA@ $(GLOBLIB) @GETLOADAVG_LIBS@ @LIBINTL@ \
+                $(GUILE_LIBS)
 # Only process if target is MS-Windows
 if WINDOWSENV
 …
 AM_CPPFLAGS =   $(GLOBINC)
+AM_CFLAGS =     $(GUILE_CFLAGS)
 # Only process if target is MS-Windows
 if WINDOWSENV
 …
 # Extra stuff to include in the distribution.
 EXTRA_DIST =    README build.sh.in $(man_MANS) \
+EXTRA_DIST =    ChangeLog README build.sh.in $(man_MANS) \
                 README.customs README.OS2 \
                 SCOPTIONS SMakefile \
 …
                 README.W32 NMakefile config.h.W32 build_w32.bat subproc.bat \
                 make_msvc_net2003.sln make_msvc_net2003.vcproj \
+                readme.vms makefile.vms makefile.com config.h-vms \
+                vmsdir.h vmsfunctions.c vmsify.c
+                README.VMS makefile.vms makefile.com config.h-vms \
+                vmsdir.h vmsfunctions.c vmsify.c vms_exit.c vms_progname.c \
+                vms_export_symbol.c vms_export_symbol_test.com \
+                gmk-default.scm gmk-default.h
 # This is built during configure, but behind configure's back
 …
 DISTCLEANFILES = build.sh
-# Forward targets
-html:
-        cd doc && $(MAKE) $(AM_MAKEFLAGS) $@
-.PHONY: html
 # --------------- Internationalization Section
 …
 # Whether or not make needs to be installed setgid.
 # The value should be either `true' or `false'.
 # On many systems, the getloadavg function (used to implement the `-l'
+# The value should be either 'true' or 'false'.
+# On many systems, the getloadavg function (used to implement the '-l'
 # switch) will not work unless make is installed setgid kmem.
+#
 …
            else \
              echo "$$app needs to be owned by group $(inst_group) and setgid;"; \
              echo "otherwise the \`-l' option will probably not work."; \
+             echo "otherwise the '-l' option will probably not work."; \
              echo "You may need special privileges to complete the installation"; \
              echo "of $$app."; \
 …
          else true; fi
+# --------------- Generate the Guile default module content
+guile.$(OBJEXT): gmk-default.h
+gmk-default.h: $(srcdir)/gmk-default.scm
+        (echo 'static const char *const GUILE_module_defn = " '\\ \
+          && sed -e 's/;.*//' -e '/^[ \t]*$$/d' -e 's/"/\\"/g' -e 's/$$/ \\/' \
+                 $(srcdir)/gmk-default.scm \
+          && echo '";') > $@
 # --------------- Local DIST Section
 …
 dist-hook:
         (cd $(srcdir); \
          sub=`find w32 tests -follow \( -name CVS -prune -o -name .cvsignore -o -name work -prune \) -o \( -name \*.orig -o -name \*.rej -o -name \*~ -prune \) -o -type f -print`; \
+         sub=`find w32 tests -follow \( -name .git -o -name .deps -o -name work -o -name .gitignore -o -name \*.orig -o -name \*.rej -o -name \*~ -o -name Makefile \) -prune -o -type f -print`; \
          tar chf - $$sub) \
         | (cd $(distdir); tar xfBp -)
 …
 MAKETESTFLAGS =
+check-regression:
+        @if test -f "$(srcdir)/tests/run_make_tests"; then \
+check-regression: tests/config-flags.pm
+        @if test -f '$(srcdir)/tests/run_make_tests'; then \
+          ulimit -n 128; \
           if $(PERL) -v >/dev/null 2>&1; then \
             case `cd $(srcdir); pwd` in `pwd`) : ;; \
+            case `cd '$(srcdir)'; pwd` in `pwd`) : ;; \
               *) test -d tests || mkdir tests; \
                  rm -f srctests; \
                  if ln -s "$(srcdir)/tests" srctests; then \
+                 if ln -s '$(srcdir)/tests' srctests; then \
                    for f in run_make_tests run_make_tests.pl test_driver.pl scripts; do \
                      rm -f tests/$$f; ln -s ../srctests/$$f tests; \
                    done; fi ;; \
             esac; \
             echo "cd tests && $(PERL) ./run_make_tests.pl -make ../make$(EXEEXT) $(MAKETESTFLAGS)"; \
             cd tests && $(PERL) ./run_make_tests.pl -make ../make$(EXEEXT) $(MAKETESTFLAGS); \
+            echo "cd tests && $(PERL) ./run_make_tests.pl -srcdir $(abs_srcdir) -make ../make$(EXEEXT) $(MAKETESTFLAGS)"; \
+            cd tests && $(PERL) ./run_make_tests.pl -srcdir '$(abs_srcdir)' -make '../make$(EXEEXT)' $(MAKETESTFLAGS); \
           else \
             echo "Can't find a working Perl ($(PERL)); the test suite requires Perl."; \
           fi; \
          else \
+        else \
           echo "Can't find the GNU Make test suite ($(srcdir)/tests)."; \
          fi
+        fi
 …
 # Tell automake that I haven't forgotten about this file and it will be
 # created before we build a distribution (see maintMakefile in the CVS
+# created before we build a distribution (see maintMakefile in the Git
 # distribution).

vendor/gnumake/current/Makefile.ami

-              r2596
+              r3138
 # -*-Makefile-*- for GNU make on Amiga
+#
+# NOTE: If you have no `make' program at all to process this makefile, run
+# `build.sh' instead.
+#
+# Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+# 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+# NOTE: If you have no 'make' program at all to process this makefile, run
+# 'build.sh' instead.
+#
+# Copyright (C) 1995-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 # Define these for your system as follows:
 #       -DNO_ARCHIVES           To disable `ar' archive support.
+#       -DNO_ARCHIVES           To disable 'ar' archive support.
 #       -DNO_FLOAT              To avoid using floating-point numbers.
 #       -DENUM_BITFIELDS        If the compiler isn't GCC but groks enum foo:2.
 …
 #                               so beware.
 # NeXT 1.0a uses an old version of GCC, which required -D__inline=inline.
 # See also `config.h'.
+# See also 'config.h'.
 defines =
 # Which flavor of remote job execution support to use.
 # The code is found in `remote-$(REMOTE).c'.
+# The code is found in 'remote-$(REMOTE).c'.
 REMOTE = stub
 …
 exec_prefix =
 # Directory to install `make' in.
+# Directory to install 'make' in.
 bindir = sc:c
 # Directory to find libraries in for `-lXXX'.
+# Directory to find libraries in for '-lXXX'.
 libdir = lib:
 # Directory to search by default for included makefiles.
 …
 # Number to put on the man page filename.
 manext = 1
 # Prefix to put on installed `make' binary file name.
+# Prefix to put on installed 'make' binary file name.
 binprefix =
 # Prefix to put on installed `make' man page file name.
+# Prefix to put on installed 'make' man page file name.
 manprefix = $(binprefix)
 # Whether or not make needs to be installed setgid.
 # The value should be either `true' or `false'.
 # On many systems, the getloadavg function (used to implement the `-l'
+# The value should be either 'true' or 'false'.
+# On many systems, the getloadavg function (used to implement the '-l'
 # switch) will not work unless make is installed setgid kmem.
 install_setgid = false
 …
 group = sys
 # Program to install `make'.
+# Program to install 'make'.
 INSTALL_PROGRAM = copy
 # Program to install the man page.
 …
 CTAGS = ctags -w
+objs = commands.o job.o dir.o file.o misc.o main.o read.o remake.o      \
+       rule.o implicit.o default.o variable.o expand.o function.o       \
+       vpath.o version.o ar.o arscan.o signame.o strcache.o hash.o      \
+       remote-$(REMOTE).o $(GETOPT) $(ALLOCA) $(extras)
+#guile = guile.o
+objs = commands.o job.o dir.o file.o misc.o main.o read.o remake.o   \
+       rule.o implicit.o default.o variable.o expand.o function.o    \
+       vpath.o version.o ar.o arscan.o signame.o strcache.o hash.o   \
+       remote-$(REMOTE).o $(GETOPT) $(ALLOCA) $(extras) $(guile)
 srcs = $(srcdir)commands.c $(srcdir)job.c $(srcdir)dir.c             \
        $(srcdir)file.c $(srcdir)getloadavg.c $(srcdir)misc.c         \
 …
        $(srcdir)variable.c $(srcdir)expand.c $(srcdir)function.c     \
        $(srcdir)vpath.c $(srcdir)version.c $(srcdir)hash.c           \
        $(srcdir)remote-$(REMOTE).c                                     \
        $(srcdir)ar.c $(srcdir)arscan.c $(srcdir)strcache.c              \
        $(srcdir)signame.c $(srcdir)signame.h $(GETOPT_SRC)            \
        $(srcdir)commands.h $(srcdir)dep.h $(srcdir)filedep.h            \
        $(srcdir)job.h $(srcdir)make.h $(srcdir)rule.h                \
+       $(srcdir)guile.c $(srcdir)remote-$(REMOTE).c                  \
+       $(srcdir)ar.c $(srcdir)arscan.c $(srcdir)strcache.c           \
+       $(srcdir)signame.c $(srcdir)signame.h $(GETOPT_SRC)           \
+       $(srcdir)commands.h $(srcdir)dep.h $(srcdir)filedep.h         \
+       $(srcdir)job.h $(srcdir)makeint.h $(srcdir)rule.h             \
        $(srcdir)variable.h $(ALLOCA_SRC) $(srcdir)config.h.in
 …
 info: make.info
 dvi: make.dvi
 # Some makes apparently use .PHONY as the default goal if it is before `all'.
+# Some makes apparently use .PHONY as the default goal if it is before 'all'.
 .PHONY: all check info dvi
 …
         cd glob; $(MAKE) libglob.a
 FORCE:
-tagsrcs = $(srcs) $(srcdir)remote-*.c
 .PHONY: install installdirs
 …
            else \
              echo "$@ needs to be owned by group $(group) and setgid;"; \
              echo "otherwise the \`-l' option will probably not work."; \
+             echo "otherwise the '-l' option will probably not work."; \
              echo "You may need special privileges to install $@."; \
            fi; \
 …
         done
 # Run install-info only if it exists.
 # Use `if' instead of just prepending `-' to the
+# Use 'if' instead of just prepending '-' to the
 # line so we notice real errors from install-info.
 # We use `$(SHELL) -c' because some shells do not
+# We use '$(SHELL) -c' because some shells do not
 # fail gracefully when there is an unknown command.
         if $(SHELL) -c 'install-info --version' >/dev/null 2>&1; then \
 …
 # The automatically generated dependencies below may omit config.h
 # because it is included with ``#include <config.h>'' rather than
 # ``#include "config.h"''.  So we add the explicit dependency to make sure.
+# because it is included with '#include <config.h>' rather than
+# '#include "config.h"'.  So we add the explicit dependency to make sure.
 $(objs): config.h
 …
 # Automatically generated dependencies.
 commands.o: commands.c make.h dep.h filedef.h variable.h job.h \
+commands.o: commands.c makeint.h dep.h filedef.h variable.h job.h \
  commands.h
 job.o: job.c make.h job.h filedef.h commands.h variable.h
 dir.o: dir.c make.h
 file.o: file.c make.h dep.h filedef.h job.h commands.h variable.h
 misc.o: misc.c make.h dep.h
 main.o: main.c make.h dep.h filedef.h variable.h job.h commands.h \
+job.o: job.c makeint.h job.h filedef.h commands.h variable.h
+dir.o: dir.c makeint.h
+file.o: file.c makeint.h dep.h filedef.h job.h commands.h variable.h
+misc.o: misc.c makeint.h dep.h
+main.o: main.c makeint.h dep.h filedef.h variable.h job.h commands.h \
  getopt.h
+read.o: read.c make.h dep.h filedef.h job.h commands.h variable.h \
+guile.o: guile.c makeint.h dep.h debug.h variable.h gmk-default.h
+read.o: read.c makeint.h dep.h filedef.h job.h commands.h variable.h \
  glob/glob.h
 remake.o: remake.c make.h filedef.h job.h commands.h dep.h
 rule.o: rule.c make.h dep.h filedef.h job.h commands.h variable.h \
+remake.o: remake.c makeint.h filedef.h job.h commands.h dep.h
+rule.o: rule.c makeint.h dep.h filedef.h job.h commands.h variable.h \
  rule.h
 implicit.o: implicit.c make.h rule.h dep.h filedef.h
 default.o: default.c make.h rule.h dep.h filedef.h job.h commands.h \
+implicit.o: implicit.c makeint.h rule.h dep.h filedef.h
+default.o: default.c makeint.h rule.h dep.h filedef.h job.h commands.h \
  variable.h
 variable.o: variable.c make.h dep.h filedef.h job.h commands.h \
+variable.o: variable.c makeint.h dep.h filedef.h job.h commands.h \
  variable.h
 expand.o: expand.c make.h filedef.h job.h commands.h variable.h
 function.o: function.c make.h filedef.h variable.h dep.h job.h \
+expand.o: expand.c makeint.h filedef.h job.h commands.h variable.h
+function.o: function.c makeint.h filedef.h variable.h dep.h job.h \
  commands.h amiga.h
 vpath.o: vpath.c make.h filedef.h variable.h
 strcache.o: strcache.c make.h hash.h
+vpath.o: vpath.c makeint.h filedef.h variable.h
+strcache.o: strcache.c makeint.h hash.h
 version.o: version.c
 ar.o: ar.c make.h filedef.h dep.h
 arscan.o: arscan.c make.h
+ar.o: ar.c makeint.h filedef.h dep.h
+arscan.o: arscan.c makeint.h
 signame.o: signame.c signame.h
 remote-stub.o: remote-stub.c make.h filedef.h job.h commands.h
+remote-stub.o: remote-stub.c makeint.h filedef.h job.h commands.h
 getopt.o: getopt.c
 getopt1.o : getopt1.c getopt.h
 getloadavg.o: getloadavg.c
 amiga.o: amiga.c make.h variable.h amiga.h
+amiga.o: amiga.c makeint.h variable.h amiga.h

vendor/gnumake/current/NEWS

-              r2596
+              r3138
 GNU make NEWS                                               -*-indented-text-*-
   History of user-visible changes.
 July 2010
+June 2016
 See the end of this file for copyrights and conditions.
 …
+Version 3.82
+Version 4.2.1 (10 Jun 2016)
+A complete list of bugs fixed in this version is available here:
+h
+ttp://sv.gnu.org/bugs/index.php?group=make&report_id=111&fix_release_id=107&set=custom
+This release is a bug-fix release.
+Version 4.2 (22 May 2016)
+A complete list of bugs fixed in this version is available here:
+http://sv.gnu.org/bugs/index.php?group=make&report_id=111&fix_release_id=106&set=custom
+* New variable: $(.SHELLSTATUS) is set to the exit status of the last != or
+  $(shell ...) function invoked in this instance of make.  This will be "0" if
+  successful or not "0" if not successful.  The variable value is unset if no
+  != or $(shell ...) function has been invoked.
+* The $(file ...) function can now read from a file with $(file <FILE).
+  The function is expanded to the contents of the file.  The contents are
+  expanded verbatim except that the final newline, if any, is stripped.
+* The makefile line numbers shown by GNU make now point directly to the
+  specific line in the recipe where the failure or warning occurred.
+  Sample changes suggested by Brian Vandenberg <phantall@gmail.com>
+* The interface to GNU make's "jobserver" is stable as documented in the
+  manual, for tools which may want to access it.
+  WARNING: Backward-incompatibility! The internal-only command line option
+  --jobserver-fds has been renamed for publishing, to --jobserver-auth.
+* The amount of parallelism can be determined by querying MAKEFLAGS, even when
+  the job server is enabled (previously MAKEFLAGS would always contain only
+  "-j", with no number, when job server was enabled).
+* VMS-specific changes:
+  * Perl test harness now works.
+  * Full support for converting Unix exit status codes to VMS exit status
+    codes.  BACKWARD INCOMPATIBILITY Notice: On a child failure the VMS exit
+    code is now the encoded Unix exit status that Make usually generates, not
+    the VMS exit status of the child.
+Version 4.1 (05 Oct 2014)
+A complete list of bugs fixed in this version is available here:
+http://sv.gnu.org/bugs/index.php?group=make&report_id=111&fix_release_id=105&set=custom
+* New variables: $(MAKE_TERMOUT) and $(MAKE_TERMERR) are set to non-empty
+  values if stdout or stderr, respectively, are believed to be writing to a
+  terminal.  These variables are exported by default.
+* Allow a no-text-argument form of the $(file ...) function.  Without a text
+  argument nothing is written to the file: it is simply opened in the
+  requested mode, then closed again.
+* Change the fatal error for mixed explicit and implicit rules, that was
+  introduced in GNU make 3.82, to a non-fatal error.  However, this syntax is
+  still deprecated and may return to being illegal in a future version of GNU
+  make.  Makefiles that rely on this syntax should be fixed.
+  See https://savannah.gnu.org/bugs/?33034
+* VMS-specific changes:
+  * Support for library files added, including support for using the GNV ar
+    utility.
+  * Partial support for properly encoding Unix exit status codes into VMS exit
+    status codes.
+    WARNING: Backward-incompatibility! These are different exit status codes
+    than Make exited with in the past.
+  * Macros to hold the current make command are set up to translate the
+    argv[0] string to a VMS format path name and prefix it with "MCR " so that
+    the macro has a space in it.
+    WARNING: Backward-incompatibility!  This may break complex makefiles that
+    do processing on those macros.  This is unlikely because so much in that
+    area was not and is still not currently working on VMS, it is unlikely to
+    find such a complex makefile, so this is more likely to impact
+    construction of a future makefile.
+  * A command file is always used to run the commands for a recipe.
+    WARNING: Backward-incompatibility!  Running the make self tests has
+    exposed that there are significant differences in behavior when running
+    with the command file mode.  It is unknown if this will be noticed by most
+    existing VMS makefiles.
+Version 4.0 (09 Oct 2013)
+A complete list of bugs fixed in this version is available here:
+http://sv.gnu.org/bugs/index.php?group=make&report_id=111&fix_release_id=101&set=custom
+* WARNING: Backward-incompatibility!
+  If .POSIX is specified, then make adheres to the POSIX backslash/newline
+  handling requirements, which introduces the following changes to the
+  standard backslash/newline handling in non-recipe lines:
+  * Any trailing space before the backslash is preserved
+  * Each backslash/newline (plus subsequent whitespace) is converted to a
+    single space
+* New feature: GNU Guile integration
+  This version of GNU make can be compiled with GNU Guile integration.
+  GNU Guile serves as an embedded extension language for make.
+  See the "Guile Function" section in the GNU Make manual for details.
+  Currently GNU Guile 1.8 and 2.0+ are supported.  In Guile 1.8 there is no
+  support for internationalized character sets.  In Guile 2.0+, scripts can be
+  encoded in UTF-8.
+* New command line option: --output-sync (-O) enables grouping of output by
+  target or by recursive make.  This is useful during parallel builds to avoid
+  mixing output from different jobs together giving hard-to-understand
+  results.  Original implementation by David Boyce <dsb@boyski.com>.
+  Reworked and enhanced by Frank Heckenbach <f.heckenbach@fh-soft.de>.
+  Windows support by Eli Zaretskii <eliz@gnu.org>.
+* New command line option: --trace enables tracing of targets.  When enabled
+  the recipe to be invoked is printed even if it would otherwise be suppressed
+  by .SILENT or a "@" prefix character.  Also before each recipe is run the
+  makefile name and linenumber where it was defined are shown as well as the
+  prerequisites that caused the target to be considered out of date.
+* New command line option argument: --debug now accepts a "n" (none) flag
+  which disables all debugging settings that are currently enabled.
+* New feature: The "job server" capability is now supported on Windows.
+  Implementation contributed by Troy Runkel <Troy.Runkel@mathworks.com>
+* New feature: The .ONESHELL capability is now supported on Windows.  Support
+  added by Eli Zaretskii <eliz@gnu.org>.
+* New feature: "!=" shell assignment operator as an alternative to the
+  $(shell ...) function.  Implemented for compatibility with BSD makefiles.
+  Note there are subtle differences between "!=" and $(shell ...).  See the
+  description in the GNU make manual.
+  WARNING: Backward-incompatibility!
+  Variables ending in "!" previously defined as "variable!= value" will now be
+  interpreted as shell assignment.  Change your assignment to add whitespace
+  between the "!" and "=": "variable! = value"
+* New feature: "::=" simple assignment operator as defined by POSIX in 2012.
+  This operator has identical functionality to ":=" in GNU make, but will be
+  portable to any implementation of make conforming to a sufficiently new
+  version of POSIX (see http://austingroupbugs.net/view.php?id=330).  It is
+  not necessary to define the .POSIX target to access this operator.
+* New feature: Loadable objects
+  This version of GNU make contains a "technology preview": the ability to
+  load dynamic objects into the make runtime.  These objects can be created by
+  the user and can add extended functionality, usable by makefiles.
+* New function: $(file ...) writes to a file.
+* New variable: $(GNUMAKEFLAGS) will be parsed for make flags, just like
+  MAKEFLAGS is.  It can be set in the environment or the makefile, containing
+  GNU make-specific flags to allow your makefile to be portable to other
+  versions of make.  Once this variable is parsed, GNU make will set it to the
+  empty string so that flags will not be duplicated on recursion.
+* New variable: `MAKE_HOST' gives the name of the host architecture
+  make was compiled for.  This is the same value you see after 'Built for'
+  when running 'make --version'.
+* Behavior of MAKEFLAGS and MFLAGS is more rigorously defined.  All simple
+  flags are grouped together in the first word of MAKEFLAGS.  No options that
+  accept arguments appear in the first word.  If no simple flags are present
+  MAKEFLAGS begins with a space.  Flags with both short and long versions
+  always use the short versions in MAKEFLAGS.  Flags are listed in
+  alphabetical order using ASCII ordering.  MFLAGS never begins with "- ".
+* Setting the -r and -R options in MAKEFLAGS inside a makefile now works as
+  expected, removing all built-in rules and variables, respectively.
+* If a recipe fails, the makefile name and linenumber of the recipe are shown.
+* A .RECIPEPREFIX setting is remembered per-recipe and variables expanded
+  in that recipe also use that recipe prefix setting.
+* In -p output, .RECIPEPREFIX settings are shown and all target-specific
+  variables are output as if in a makefile, instead of as comments.
+* On MS-Windows, recipes that use ".." quoting will no longer force
+  invocation of commands via temporary batch files and stock Windows
+  shells, they will be short-circuited and invoked directly.  (In
+  other words, " is no longer a special character for stock Windows
+  shells.)  This avoids hitting shell limits for command length when
+  quotes are used, but nothing else in the command requires the shell.
+  This change could potentially mean some minor incompatibilities in
+  behavior when the recipe uses quoted string on shell command lines.
+Version 3.82 (28 Jul 2010)
 A complete list of bugs fixed in this version is available here:
 …
 * Compiling GNU make now requires a conforming ISO C 1989 compiler and
   standard runtime library.
-* WARNING: Future backward-incompatibility!
-  Wildcards are not documented as returning sorted values, but up to and
-  including this release the results have been sorted and some makefiles are
-  apparently depending on that.  In the next release of GNU make, for
-  performance reasons, we may remove that sorting.  If your makefiles
-  require sorted results from wildcard expansions, use the $(sort ...)
-  function to request it explicitly.
 * WARNING: Backward-incompatibility!
 …
 * WARNING: Backward-incompatibility!
+  Wildcards were not documented as returning sorted values, but the results
+  have been sorted up until this release..  If your makefiles require sorted
+  results from wildcard expansions, use the $(sort ...)  function to request
+  it explicitly.
+* WARNING: Backward-incompatibility!
   As a result of parser enhancements, three backward-compatibility issues
   exist: first, a prerequisite containing an "=" cannot be escaped with a
 …
   multi-line variable assignment.
+Version 3.81
+* VMS-specific changes:
+  * Michael Gehre (at VISTEC-SEMI dot COM) supplied a fix for a problem with
+    timestamps of object modules in OLBs. The timestamps were not correctly
+    adjusted to GMT based time, if the local VMS time was using a daylight
+    saving algorithm and if daylight saving was switched off.
+  * John Eisenbraun (at HP dot COM) supplied fixes and and an enhancement to
+    append output redirection in action lines.
+  * Rework of ctrl+c and ctrl+y handling.
+  * Fix a problem with cached strings, which showed on case-insensitive file
+    systems.
+  * Build fixes for const-ified code in VMS specific sources.
+  * A note on appending the redirected output. With this change, a simple
+    mechanism is implemented to make ">>" work in action lines. In VMS
+    there is no simple feature like ">>" to have DCL command or program
+    output redirected and appended to a file. GNU make for VMS already
+    implements the redirection of output. If such a redirection is detected,
+    an ">" on the action line, GNU make creates a DCL command procedure to
+    execute the action and to redirect its output. Based on that, now ">>"
+    is also recognized and a similar but different command procedure is
+    created to implement the append. The main idea here is to create a
+    temporary file which collects the output and which is appended to the
+    wanted output file. Then the temporary file is deleted. This is all done
+    in the command procedure to keep changes in make small and simple. This
+    obviously has some limitations but it seems good enough compared with
+    the current ">" implementation. (And in my opinion, redirection is not
+    really what GNU make has to do.) With this approach, it may happen that
+    the temporary file is not yet appended and is left in SYS$SCRATCH.
+    The temporary file names look like "CMDxxxxx.". Any time the created
+    command procedure can not complete, this happens. Pressing Ctrl+Y to
+    abort make is one case. In case of Ctrl+Y the associated command
+    procedure is left in SYS$SCRATCH as well. Its name is CMDxxxxx.COM.
+  * Change in the Ctrl+Y handling. The CtrlY handler now uses $delprc to
+    delete all children. This way also actions with DCL commands will be
+    stopped. As before the CtrlY handler then sends SIGQUIT to itself,
+    which is handled in common code.
+  * Change in deleteing temporary command files. Temporary command files
+    are now deleted in the vms child termination handler. That deletes
+    them even if a Ctrl+C was pressed.
+  * The behavior of pressing Ctrl+C is not changed. It still has only an
+    effect, after the current action is terminated. If that doesn't happen
+    or takes too long, Ctrl+Y should be used instead.
+Version 3.81 (01 Apr 2006)
 * GNU make is ported to OS/2.
 …
   might have caused the target to rebuild.  Starting with the _next_
   release of GNU make, '$?' will contain all prerequisites that caused
   the target to be considered out of date.  See this Savannah bug:
   http://savannah.gnu.org/bugs/index.php?func=detailitem&item_id=16051
+  the target to be considered out of date.
+  See http://savannah.gnu.org/bugs/?16051
 * WARNING: Backward-incompatibility!
 …
 * On VMS there is now support for case-sensitive filesystems such as ODS5.
   See the readme.vms file for information.
+  See the README.VMS file for information.
 * Parallel builds (-jN) no longer require a working Bourne shell on
 …
 Version 3.80
+Version 3.80 (03 Oct 2002)
 * A new feature exists: order-only prerequisites.  These prerequisites
 …
 * Updated to autoconf 2.54 and automake 1.7.  Users should not be impacted.
+* VMS-specific changes:
+  * In default.c define variable ARCH as IA64 for VMS on Itanium systems.
+  * In makefile.vms avoid name collision for glob and globfree.
+  * This is the VMS port of GNU Make done by Hartmut.Becker@compaq.com.
+    It is based on the specific version 3.77k and on 3.78.1. 3.77k was done
+    by Klaus Kämpf <kkaempf@rmi.de>, the code was based on the VMS port of
+    GNU Make 3.60 by Mike Moretti.
+    It was ported on OpenVMS/Alpha V7.1, DECC V5.7-006. It was re-build and
+    tested on OpenVMS/Alpha V7.2, OpenVMS/VAX 7.1 and 5.5-2. Different
+    versions of DECC were used. VAXC was tried: it fails; but it doesn't
+    seem worth to get it working. There are still some PTRMISMATCH warnings
+    during the compile. Although perl is working on VMS the test scripts
+    don't work. The function $shell is still missing.
+    There is a known bug in some of the VMS CRTLs. It is in the shipped
+    versions of VMS V7.2 and V7.2-1 and in the currently (October 1999)
+    available ECOs for VMS V7.1 and newer versions. It is fixed in versions
+    shipped with newer VMS versions and all ECO kits after October 1999. It
+    only shows up during the daylight saving time period (DST): stat()
+    returns a modification time 1 hour ahead. This results in GNU make
+    warning messages. For a just created source you will see:
+     $ gmake x.exe
+     gmake.exe;1: *** Warning: File 'x.c' has modification time in the future
+     (940582863 > 940579269)
+     cc    /obj=x.obj x.c
+     link  x.obj    /exe=x.exe
+     gmake.exe;1: *** Warning:  Clock skew detected.  Your build may be
+     incomplete.
 A complete list of bugs fixed in this version is available here:
 …
 Version 3.79.1
+Version 3.79.1 (23 Jun 2000)
 * .SECONDARY with no prerequisites now prevents any target from being
 …
 Version 3.79
+Version 3.79 (04 Apr 2000)
 * GNU make optionally supports internationalization and locales via the
 …
 * Hartmut Becker provided many updates for the VMS port of GNU make.
+  See the readme.vms file for more details.
+Version 3.78
+  See the README.VMS file for more details.
+* VMS-specific changes:
+  * Fix a problem with automatically remaking makefiles. GNU make uses an
+    execve to restart itself after a successful remake of the makefile. On
+    UNIX systems execve replaces the running program with a new one and
+    resets all signal handling to the default. On VMS execve creates a child
+    process, signal and exit handlers of the parent are still active, and,
+    unfortunately, corrupt the exit code from the child. Fix in job.c:
+    ignore SIGCHLD.
+  * Added some switches to reflect latest features of DECC. Modifications in
+    makefile.vms.
+  * Set some definitions to reflect latest features of DECC. Modifications in
+    config.h-vms (which is copied to config.h).
+  * Added extern strcmpi declaration to avoid 'implicitly declared' messages.
+    Modification in make.h.
+  * Default rule for C++, conditionals for gcc (GCC_IS_NATIVE) or DEC/Digital/
+    Compaq c/c++ compilers. Modifications in default.c.
+  * Usage of opendir() and friends, suppress file version. Modifications in
+    dir.c.
+  * Added VMS specific code to handle ctrl+c and ctrl+y to abort make.
+    Modifications in job.c.
+  * Added support to have case sensitive targets and dependencies but to
+    still use case blind file names. This is especially useful for Java
+    makefiles on VMS:
+        .SUFFIXES :
+        .SUFFIXES : .class .java
+        .java.class :
+                javac "$<
+        HelloWorld.class :      HelloWorld.java
+  * A new macro WANT_CASE_SENSITIVE_TARGETS in config.h-vms was introduced.
+    It needs to be enabled to get this feature; default is disabled.  The
+    macro HAVE_CASE_INSENSITIVE_FS must not be touched: it is still enabled.
+    Modifications in file.c and config.h-vms.
+  * Bootstrap make to start building make is still makefile.com, but make
+    needs to be re-made with a make to make a correct version: ignore all
+    possible warnings, delete all objects, rename make.exe to a different
+    name and run it.
+  * Made some minor modifications to the bootstrap build makefile.com.
+Version 3.78 (22 Sep 1999)
 * Two new functions, $(error ...) and $(warning ...) are available.  The
 …
 Version 3.77
+Version 3.77 (28 Jul 1998)
 * Implement BSD make's "?=" variable assignment operator.  The variable
 …
   and to the DOS port from Eli Zaretski (see README.DOS).
+Version 3.76.1
+* VMS-specific changes:
+  * This is the VMS port of GNU Make.
+    It is based on the VMS port of GNU Make 3.60 by Mike Moretti.
+    This port was done by Klaus Kämpf <kkaempf@rmi.de>
+  * There is first-level support available from proGIS Software, Germany.
+    Visit their web-site at http://www.progis.de to get information
+    about other vms software and forthcoming updates to gnu make.
+  * /bin/sh style I/O redirection is supported. You can now write lines like
+        mcr sys$disk:[]program.exe < input.txt > output.txt &> error.txt
+  * Makefile variables are looked up in the current environment. You can set
+    symbols or logicals in DCL and evaluate them in the Makefile via
+    $(<name-of-symbol-or-logical>).  Variables defined in the Makefile
+    override VMS symbols/logicals !
+  * Functions for file names are working now. See the GNU Make manual for
+    $(dir ...)  and $(wildcard ...).  Unix-style and VMS-style names are
+    supported as arguments.
+  * The default rules are set up for GNU C. Building an executable from a
+    single source file is as easy as 'make file.exe'.
+  * The variable $(ARCH) is predefined as ALPHA or VAX resp. Makefiles for
+    different VMS systems can now be written by checking $(ARCH) as in
+      ifeq ($(ARCH),ALPHA)
+        $(ECHO) "On the Alpha"
+      else
+        $(ECHO) "On the VAX"
+      endif
+  * Command lines of excessive length are correctly broken and written to a
+    batch file in sys$scratch for later execution. There's no limit to the
+    lengths of commands (and no need for .opt files :-) any more.
+  * Empty commands are handled correctly and don't end in a new DCL process.
+Version 3.76.1 (19 Sep 1997)
 * Small (but serious) bug fix.  Quick rollout to get into the GNU source CD.
 Version 3.76
+Version 3.76 (16 Sep 1997)
 * GNU make now uses automake to control Makefile.in generation.  This
 …
   Delorie <dj@delorie.com>.
+* John W. Eaton has updated the VMS port to support libraries and VPATH.
+Version 3.75
+* VMS-specific changes:
+  * John W. Eaton has updated the VMS port to support libraries and VPATH.
+  * The cd command is supported if it's called as $(CD). This invokes
+    the 'builtin_cd' command which changes the directory.
+    Calling 'set def' doesn't do the trick, since a sub-shell is
+    spawned for this command, the directory is changed *in this sub-shell*
+    and the sub-shell ends.
+  * Libraries are not supported. They were in GNU Make 3.60 but somehow I
+    didn't care porting the code. If there is enough interest, I'll do it at
+    some later time.
+  * The variable $^ separates files with commas instead of spaces (It's the
+    natural thing to do for VMS).
+  * See defaults.c for VMS default suffixes and my definitions for default
+    rules and variables.
+  * The shell function is not implemented yet.
+  * Load average routines haven't been implemented for VMS yet.
+  * The default include directory for including other makefiles is
+    SYS$SYSROOT:[SYSLIB] (I don't remember why I didn't just use
+    SYS$LIBRARY: instead; maybe it wouldn't work that way).
+  * The default makefiles make looks for are: makefile.vms, gnumakefile,
+    makefile., and gnumakefile. .
+  * The stat() function and handling of time stamps in VMS is broken, so I
+    replaced it with a hack in vmsfunctions.c. I will provide a full rewrite
+    somewhere in the future. Be warned, the time resolution inside make is
+    less than what vms provides. This might be a problem on the faster Alphas.
+  * You can use a : in a filename only if you precede it with a backslash ('\').
+    E.g.- hobbes\:[bogas.files]
+  * Make ignores success, informational, or warning errors (-S-, -I-, or -W-).
+    But it will stop on -E- and -F- errors. (unless you do something
+    to override this in your makefile, or whatever).
+  * Remote stuff isn't implemented yet.
+  * Multiple line DCL commands, such as "if" statements, must be put inside
+    command files.  You can run a command file by using \@.
+Version 3.75 (27 Aug 1996)
 * The directory messages printed by `-w' and implicitly in sub-makes,
 …
   <rob_tulloh@tivoli.com>.
+Version 3.73
+* VMS-specific changes:
+  * Lots of default settings are adapted for VMS. See default.c.
+  * Long command lines are now converted to command files.
+  * Comma (',') as a separator is now allowed. See makefile.vms for an example.
+Version 3.73 (05 Apr 1995)
 * Converted to use Autoconf version 2, so `configure' has some new options.
 …
 Version 3.72
+Version 3.72 (04 Nov 1994)
 * DJ Delorie has ported Make to MS-DOS using the GO32 extender.
 …
 Version 3.71
+Version 3.71 (21 May 1994)
 * The automatic variables `$(@D)', `$(%D)', `$(*D)', `$(<D)', `$(?D)', and
 …
 Version 3.70
+Version 3.70 (03 Jan 1994)
 * It is no longer a fatal error to have a NUL character in a makefile.
 …
 Version 3.69
+Version 3.69 (07 Nov 1993)
 * Implicit rule search for archive member references is now done in the
 …
   cause a paradoxical situation in cases like:
         export variable = $(shell echo value)
+        export variable = $(shell echo value)
   When Make attempted to put this variable in the environment for a
 …
 Version 3.68
+Version 3.68 (28 Jul 1993)
 * You can list several archive member names inside parenthesis:
 …
 * A suffix rule `.X.a' now produces two pattern rules:
         (%.o): %.X      # Previous versions produced only this.
         %.a: %.X        # Now produces this as well, just like other suffixes.
+        (%.o): %.X      # Previous versions produced only this.
+        %.a: %.X        # Now produces this as well, just like other suffixes.
 * The new flag `--warn-undefined-variables' says to issue a warning message
 …
 Version 3.66
+Version 3.66 (21 May 1993)
 * `make --version' (or `make -v') now exits immediately after printing
 …
 Version 3.65
+Version 3.65 (09 May 1993)
 * Make now supports long-named members in `ar' archive files.
 Version 3.64
+Version 3.64 (21 Apr 1993)
 * Make now supports the `+=' syntax for a variable definition which appends
 …
 Version 3.63
+Version 3.63 (22 Jan 1993)
 * Make now uses a standard GNU `configure' script.  See the new file
 …
   Make runs.  Instead, only variables specified on the command line or in
   the environment are exported by default.  To export others, use:
         export VARIABLE
+        export VARIABLE
   or you can define variables with:
         export VARIABLE = VALUE
+        export VARIABLE = VALUE
   or:
         export VARIABLE := VALUE
+        export VARIABLE := VALUE
   You can use just:
         export
+        export
   or:
         .EXPORT_ALL_VARIABLES:
+        .EXPORT_ALL_VARIABLES:
   to get the old behavior.  See the node `Variables/Recursion' in the manual
   for a full description.
 …
 * A single `include' directive can now specify more than one makefile to
   include, like this:
         include file1 file2
+        include file1 file2
   You can also use shell file name patterns in an `include' directive:
         include *.mk
+        include *.mk
 * The default directories to search for included makefiles, and for
 …
 * Messages indicating failed recipe lines now contain the target name:
         make: *** [target] Error 1
+        make: *** [target] Error 1
 * The `-p' output format has been changed somewhat to look more like
 …
 -------------------------------------------------------------------------------
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.  This file is part of GNU Make.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
+This file is part of GNU Make.
 GNU Make is free software; you can redistribute it and/or modify it under the

vendor/gnumake/current/NMakefile.template

-              r2596
+              r3138
 # run 'build_w32.bat' instead.
+#
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+# 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+# Copyright (C) 1996-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 LDFLAGS_debug = w32\subproc\WinDebug\subproc.lib /NOLOGO /SUBSYSTEM:console\
         /INCREMENTAL:no /PDB:WinDebug/make.pdb /OUT:WinDebug/make.exe /DEBUG
+        /STACK:0x400000 /INCREMENTAL:no /PDB:WinDebug/make.pdb /OUT:WinDebug/make.exe /DEBUG
 LDFLAGS_release = w32\subproc\WinRel\subproc.lib /NOLOGO /SUBSYSTEM:console\
         /INCREMENTAL:no /OUT:WinRel/make.exe
+        /STACK:0x400000 /INCREMENTAL:no /OUT:WinRel/make.exe
 all: config.h subproc Release Debug
 …
 LIBS = kernel32.lib user32.lib advapi32.lib
+guile = $(OUTDIR)/guile.obj
 OBJS = \
         $(OUTDIR)/ar.obj \
 …
         $(OUTDIR)/implicit.obj \
         $(OUTDIR)/job.obj \
+        $(OUTDIR)/load.obj \
         $(OUTDIR)/main.obj \
         $(OUTDIR)/misc.obj \
+        $(OUTDIR)/output.obj \
         $(OUTDIR)/read.obj \
         $(OUTDIR)/remake.obj \
 …
         $(OUTDIR)/fnmatch.obj \
         $(OUTDIR)/dirent.obj \
+        $(OUTDIR)/pathstuff.obj
+        $(OUTDIR)/pathstuff.obj \
+        $(OUTDIR)/posixfcn.obj \
+        $(OUTDIR)/w32os.obj \
+        $(guile)
 $(OUTDIR)/make.exe: $(OUTDIR) $(OBJS)
 …
 $(OUTDIR)/dirent.obj : w32/compat/dirent.c
         $(CC) $(CFLAGS) /c $?
+$(OUTDIR)/posixfcn.obj : w32/compat/posixfcn.c
+        $(CC) $(CFLAGS) /c $?
 $(OUTDIR)/pathstuff.obj : w32/pathstuff.c
         $(CC) $(CFLAGS) /c $?
+$(OUTDIR)/w32os.obj : w32/w32os.c
+        $(CC) $(CFLAGS) /c $?

vendor/gnumake/current/README.Amiga

-              r2596
+              r3138
 - Allows to use Device-Names in targets:
         c:make : make.o
+        c:make : make.o
     is ok. To distinguish between device-names and target : or ::, MAKE
 …
 - Replaces @@ by a newline in any command line:
         if exists make @@\
             delete make.bak quiet @@\
             rename make make.bak @@\
         endif @@\
         $(CC) Link Make.o To make
+        if exists make @@\
+            delete make.bak quiet @@\
+            rename make make.bak @@\
+        endif @@\
+        $(CC) Link Make.o To make
     works. Note that the @@ must stand alone (ie. "make@@\" is illegal).
     Also be carefull that there is a space after the "\" (ie, at the
+    works. Note that the @@ must stand alone (i.e., "make@@\" is illegal).
+    Also be careful that there is a space after the "\" (i.e., at the
     beginning of the next line).
 - Can be made resident to save space and time
 …
     dummy.h : src/*.c
 tries to make dummy.h from "src/*.c" (ie. no wildcard-expansion takes
+tries to make dummy.h from "src/*.c" (i.e., no wildcard-expansion takes
 place). You have to use "$(wildcard src/*.c)" instead.
 …
 ----------------------
 To recompile, you need SAS/C 6.51. make itself is not neccessary, there
+To recompile, you need SAS/C 6.51. make itself is not necessary, there
 is an smakefile.
 . Copy config.ami to config.h
 . If you use make to compie, copy Makefile.ami to Makefile and
+. If you use make to compile, copy Makefile.ami to Makefile and
     glob/Makefile.ami to glob/Makefile. Copy make into the current
     directory.
 …
 INSTALLATION
 Copy make somewhere in your search path (eg. sc:c or sc:bin).
+Copy make somewhere in your search path (e.g., sc:c or sc:bin).
 If you plan to use recursive makes, install make resident:
 …
 -------------------------------------------------------------------------------
+Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1995-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.

vendor/gnumake/current/README.DOS.template

-              r2596
+              r3138
 . Supports both stock DOS COMMAND.COM and Unix-style shells
       (details in ``Notes'' below).
+      (details in 'Notes' below).
 . Supports DOS drive letters in dependencies and pattern rules.
 . Better support for DOS-style backslashes in pathnames (but see
       ``Notes'' below).
+      'Notes' below).
 . The $(shell) built-in can run arbitrary complex commands,
 …
       environment), or the DJGPP port of GNU Tar.
 . Invoke the `configure.bat' batch file.
+. Invoke the 'configure.bat' batch file.
       If you are building Make in-place, i.e. in the same directory
 …
       directory as an argument to the batch file, like this:
         c:\djgpp\gnu\make-%VERSION%\configure.bat c:/djgpp/gnu/make-%VERSION%
+        c:\djgpp\gnu\make-%VERSION%\configure.bat c:/djgpp/gnu/make-%VERSION%
       Note the forward slashes in the source path argument: you MUST
 …
 . If configure.bat doesn't find a working Make, it will suggest to
       use the `dosbuild.bat' batch file to build Make.  Either do as it
+      use the 'dosbuild.bat' batch file to build Make.  Either do as it
       suggests or install another Make program (a pre-compiled binary
       should be available from the usual DJGPP sites) and rerun
 …
       need to tell Make where the sources are, like this:
                 make srcdir=c:/djgpp/gnu/make-%VERSION%
+                make srcdir=c:/djgpp/gnu/make-%VERSION%
       (configure.bat will tell you this when it finishes).  You MUST
 …
 . After Make finishes, if you have a Unix-style shell installed,
       you can use the `install' target to install the package.  You
+      you can use the 'install' target to install the package.  You
       will also need GNU Fileutils and GNU Sed for this (they should
       be available from the DJGPP sites).
 …
       DESTDIR variable when invoking "make install", like this:
                 make install DESTDIR=c:/other/dir
+                make install DESTDIR=c:/other/dir
       This causes the make executable to be placed in c:/other/dir/bin,
 …
       and the docs manually.  Copy make.exe to a directory on your
       PATH, make.i* info files to your Info directory, and update the
       file `dir' in your Info directory by adding the following item
+      file 'dir' in your Info directory by adding the following item
       to the main menu:
         * Make: (make.info).           The GNU make utility.
       If you have the `install-info' program (from the GNU Texinfo
+        * Make: (make.info).           The GNU make utility.
+      If you have the 'install-info' program (from the GNU Texinfo
       package), it will do that for you if you invoke it like this:
         install-info --info-dir=c:/djgpp/info c:/djgpp/info/make.info
+        install-info --info-dir=c:/djgpp/info c:/djgpp/info/make.info
       (If your Info directory is other than C:\DJGPP\INFO, change this
       command accordingly.)
 . The `clean' targets also require Unix-style shell, and GNU Sed
       and `rm' programs (the latter from Fileutils).
+. The 'clean' targets also require Unix-style shell, and GNU Sed
+      and 'rm' programs (the latter from Fileutils).
 . To run the test suite, type "make check".  This requires a Unix
 …
       This port supports both DOS shells (the stock COMMAND.COM and its
 DOS/NDOS replacements), and Unix-style shells (tested with the
       venerable Stewartson's `ms_sh' 2.3 and the DJGPP port of `bash' by
+      venerable Stewartson's 'ms_sh' 2.3 and the DJGPP port of 'bash' by
       Daisuke Aoyama <jack@st.rim.or.jp>).
 …
       batch file or a command internal to the shell is invoked.  (Even
       when a command is an internal shell command, Make will first
       search the $PATH for it, so that if a Makefile calls `mkdir',
       you can install, say, a port of GNU `mkdir' and have it called
+      search the $PATH for it, so that if a Makefile calls 'mkdir',
+      you can install, say, a port of GNU 'mkdir' and have it called
       in that case.)
       The key to all this is the extended functionality of `spawn' and
       `system' functions from the DJGPP library; this port just calls
       `system' where it would invoke the shell on Unix.  The most
+      The key to all this is the extended functionality of 'spawn' and
+      'system' functions from the DJGPP library; this port just calls
+      'system' where it would invoke the shell on Unix.  The most
       important aspect of these functions is that they use a special
       mechanism to pass long (up to 16KB) command lines to DJGPP
       programs.  In addition, `system' emulates some internal
       commands, like `cd' (so that you can now use forward slashes
+      programs.  In addition, 'system' emulates some internal
+      commands, like 'cd' (so that you can now use forward slashes
       with it, and can also change the drive if the directory is on
       another drive).  Another aspect worth mentioning is that you can
 …
       The $(shell) built-in is implemented in this port by calling
       `popen'.  Since `popen' calls `system', the above considerations
+      'popen'.  Since 'popen' calls 'system', the above considerations
       are valid for $(shell) as well.  In particular, you can put
       arbitrary complex commands, including pipes and redirection,
 …
       Many Unix Makefiles include a line which sets the SHELL, for
       those versions of Make which don't have this as the default.
       Since many DOS systems don't have `sh' installed (in fact, most
       of them don't even have a `/bin' directory), this port takes
+      Since many DOS systems don't have 'sh' installed (in fact, most
+      of them don't even have a '/bin' directory), this port takes
       such directives with a grain of salt.  It will only honor such a
       directive if the basename of the shell name (like `sh' in the
+      directive if the basename of the shell name (like 'sh' in the
       above example) can indeed be found in the directory that is
       mentioned in the SHELL= line (`/bin' in the above example), or
+      mentioned in the SHELL= line ('/bin' in the above example), or
       in the current working directory, or anywhere on the $PATH (in
       that order).  If the basename doesn't include a filename
 …
       Makefiles to MSDOS and leave the line which sets the shell
       intact, so that people who do have Unixy shell could use it for
       targets which aren't converted to DOS (like `install' and
       `uninstall', for example).
+      targets which aren't converted to DOS (like 'install' and
+      'uninstall', for example).
 …
       letter-case issue.  Make is internally case-sensitive, but all
       file operations are case-insensitive on Windows 9x, so
       e.g. files `FAQ', `faq' and `Faq' all refer to the same file, as
+      e.g. files 'FAQ', 'faq' and 'Faq' all refer to the same file, as
       far as Windows is concerned.  The underlying DJGPP C library
       functions honor the letter-case of the filenames they get from
 …
       many Makefiles otherwise.  (The details of which filenames are
       converted to lower case are explained in the DJGPP libc docs,
       under the `_preserve_fncase' and `_lfn_gen_short_fname'
+      under the '_preserve_fncase' and '_lfn_gen_short_fname'
       functions, but as a thumb rule, any filename that is stored in
       upper case in the directory, is a valid DOS 8+3 filename and
 …
       There are a lot of places throughout the program sources which
       make implicit assumptions about the pathname syntax.  In
       particular, the directories are assumed to be separated by `/',
       and any pathname which doesn't begin with a `/' is assumed to be
+      particular, the directories are assumed to be separated by '/',
+      and any pathname which doesn't begin with a '/' is assumed to be
       relative to the current directory.  This port attempts to
       support DOS-style pathnames which might include the drive letter
 …
       are advised to stay away from backslashes whenever possible.  In
       particular, filename globbing won't work on pathnames with
       backslashes, because the GNU `glob' library doesn't support them
+      backslashes, because the GNU 'glob' library doesn't support them
       (backslash is special in filename wildcards, and I didn't want
       to break that).
 …
    group).  For other bugs, please follow the procedure explained in
    the "Bugs" chapter of the Info docs.  If you don't have an Info
    reader, look up that chapter in the `make.i1' file with any text
+   reader, look up that chapter in the 'make.i1' file with any text
    browser/editor.
    Enjoy,
                         Eli Zaretskii <eliz@is.elta.co.il>
+                        Eli Zaretskii <eliz@is.elta.co.il>
 -------------------------------------------------------------------------------
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.

vendor/gnumake/current/README.OS2.template

-              r2596
+              r3138
 _getcwd2() are NOT used).  The testsuite interpretes the whole output of
 make, especially statements like make[1]: Entering directory
 `C:/somewhere/make-3.79.1/tests' where the testsuite does not expect the
+'C:/somewhere/make-3.79.1/tests' where the testsuite does not expect the
 drive letter. This would be interpreted as an error even if there is
 none.
 …
 -------------------------------------------------------------------------------
+Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
+Foundation, Inc.
+Copyright (C) 2003-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.

vendor/gnumake/current/README.W32.template

-              r2596
+              r3138
+This version of GNU make has been tested on Microsoft Windows 2000/XP/2003.
+This version of GNU make has been tested on:
+  Microsoft Windows 2000/XP/2003/Vista/7/8/10
 It has also been used on Windows 95/98/NT, and on OS/2.
+It builds with the MinGW port of GCC (tested with GCC 3.4.2).
+It also builds with MSVC 2.x, 4.x, 5.x, 6.x, and 2003 as well as
+with .NET 7.x and .NET 2003.
+The Windows 32-bit port of GNU make is maintained jointly by various
+people.  It was originally made by Rob Tulloh.
+It builds with the MinGW port of GCC (tested with GCC 3.4.2, 4.8.1,
+and 4.9.3).
+It also builds with MSVC 2.x, 4.x, 5.x, 6.x, 2003, and 14 (2015) as
+well as with .NET 7.x and .NET 2003.
+As of version 4.0, a build with Guile is supported (tested with Guile
+.0.3).  To build with Guile, you will need, in addition to Guile
+itself, its dependency libraries and the pkg-config program.  The
+latter is used to figure out which compilation and link switches and
+libraries need to be mentioned on the compiler command lines to
+correctly link with Guile.  A Windows port of pkg-config can be found
+on ezwinports site:
+  http://sourceforge.net/projects/ezwinports/
+The libraries on which Guile depends can vary depending on your
+version and build of Guile.  At the very least, the Boehm's GC library
+will be needed, and typically also GNU MP, libffi, libunistring, and
+libtool's libltdl.  Whoever built the port of Guile you have should
+also provide you with these dependencies or a URL where to download
+them.  A precompiled 32-bit Windows build of Guile is available from
+the ezwinports site mentioned above.
+The Windows port of GNU make is maintained jointly by various people.
+It was originally made by Rob Tulloh.
+It is currently maintained by Eli Zaretskii.
 …
 ---------------------------------------------------------
+. At the Windows command prompt run:
+      if not exist NMakefile copy NMakefile.template NMakefile
+      if not exist config.h copy config.h.W32 config.h
+    Then edit config.h to your liking (especially the few shell-related
+. Edit config.h.W32 to your liking (especially the few shell-related
     defines near the end, or HAVE_CASE_INSENSITIVE_FS which corresponds
+    to './configure --enable-case-insensitive-file-system').
+    to './configure --enable-case-insensitive-file-system').  (We don't
+    recommend to define HAVE_CASE_INSENSITIVE_FS, but you may wish to
+    consider that if you have a lot of files whose names are in upper
+    case, while Makefile rules are written for lower-case versions.)
 …
     correct PATH and other environment variables for it, then execute ...
+        build_w32.bat gcc
+    This produces gnumake.exe in the current directory.
+        build_w32.bat gcc
+    This produces gnumake.exe in the GccRel directory.
+    If you want a version of GNU make built with debugging enabled,
+    add the --debug option.
+    The batch file will probe for Guile installation, and will build
+    gnumake.exe with Guile if it finds it.  If you have Guile
+    installed, but want to build Make without Guile support, type
+        build_w32.bat --without-guile gcc
 …
     menue entry from the cl-installation), then execute EITHER ...
+        build_w32.bat
+    (this produces WinDebug/gnumake.exe and WinRel/gnumake.exe)
+        build_w32.bat
+    This produces gnumake.exe in the WinRel directory.
+    If you want a version of GNU make built with debugging enabled,
+    add the --debug option.
     ... OR ...
         nmake /f NMakefile
+        nmake /f NMakefile
     (this produces WinDebug/make.exe and WinRel/make.exe).
+    The batch file will probe for Guile installation, and will build
+    gnumake.exe with Guile if it finds it.  If you have Guile
+    installed, but want to build Make without Guile support, type
+        build_w32.bat --without-guile
 -------------------
 …
 GNU make on Windows 32-bit platforms:
         This version of make is ported natively to Windows32 platforms
         (Windows NT 3.51, Windows NT 4.0, Windows 2000, Windows XP,
         Windows 95, and Windows 98). It does not rely on any 3rd party
         software or add-on packages for building. The only thing
         needed is a Windows compiler.  Two compilers supported
         officially are the MinGW port of GNU GCC, and the various
         versions of the Microsoft C compiler.
         Do not confuse this port of GNU make with other Windows32 projects
         which provide a GNU make binary. These are separate projects
         and are not connected to this port effort.
+        This version of make is ported natively to Windows32 platforms
+        (Windows NT 3.51, Windows NT 4.0, Windows 2000, Windows XP,
+        Windows 95, and Windows 98). It does not rely on any 3rd party
+        software or add-on packages for building. The only thing
+        needed is a Windows compiler.  Two compilers supported
+        officially are the MinGW port of GNU GCC, and the various
+        versions of the Microsoft C compiler.
+        Do not confuse this port of GNU make with other Windows32 projects
+        which provide a GNU make binary. These are separate projects
+        and are not connected to this port effort.
 GNU make and sh.exe:
         This port prefers if you have a working sh.exe somewhere on
         your system. If you don't have sh.exe, the port falls back to
         MSDOS mode for launching programs (via a batch file).  The
         MSDOS mode style execution has not been tested that carefully
         though (The author uses GNU bash as sh.exe).
         There are very few true ports of Bourne shell for NT right now.
         There is a version of GNU bash available from Cygnus "Cygwin"
         porting effort (http://www.cygwin.com/).
         Other possibilities are the MKS version of sh.exe, or building
+        This port prefers if you have a working sh.exe somewhere on
+        your system. If you don't have sh.exe, the port falls back to
+        MSDOS mode for launching programs (via a batch file).  The
+        MSDOS mode style execution has not been tested that carefully
+        though (The author uses GNU bash as sh.exe).
+        There are very few true ports of Bourne shell for NT right now.
+        There is a version of GNU bash available from Cygnus "Cygwin"
+        porting effort (http://www.cygwin.com/).
+        Other possibilities are the MKS version of sh.exe, or building
         your own with a package like NutCracker (DataFocus) or Portage
         (Consensys).  Also MinGW includes sh (http://mingw.org/).
 …
 GNU make and brain-dead shells (BATCH_MODE_ONLY_SHELL):
         Some versions of Bourne shell do not behave well when invoked
         as 'sh -c' from CreateProcess().  The main problem is they seem
         to have a hard time handling quoted strings correctly. This can
         be circumvented by writing commands to be executed to a batch
         file and then executing the command by calling 'sh file'.
         To work around this difficulty, this version of make supports
         a batch mode.  When BATCH_MODE_ONLY_SHELL is defined at compile
         time, make forces all command lines to be executed via script
         files instead of by command line.  In this mode you must have a
         working sh.exe in order to use parallel builds (-j).
         A native Windows32 system with no Bourne shell will also run
         in batch mode.  All command lines will be put into batch files
         and executed via $(COMSPEC) (%COMSPEC%).  However, parallel
         builds ARE supported with Windows shells (cmd.exe and
         command.com).  See the next section about some peculiarities
         of parallel builds on Windows.
+        Some versions of Bourne shell do not behave well when invoked
+        as 'sh -c' from CreateProcess().  The main problem is they seem
+        to have a hard time handling quoted strings correctly. This can
+        be circumvented by writing commands to be executed to a batch
+        file and then executing the command by calling 'sh file'.
+        To work around this difficulty, this version of make supports
+        a batch mode.  When BATCH_MODE_ONLY_SHELL is defined at compile
+        time, make forces all command lines to be executed via script
+        files instead of by command line.  In this mode you must have a
+        working sh.exe in order to use parallel builds (-j).
+        A native Windows32 system with no Bourne shell will also run
+        in batch mode.  All command lines will be put into batch files
+        and executed via $(COMSPEC) (%COMSPEC%).  However, parallel
+        builds ARE supported with Windows shells (cmd.exe and
+        command.com).  See the next section about some peculiarities
+        of parallel builds on Windows.
 Support for parallel builds
+        Parallel builds (-jN) are supported in this port, with 2
+        limitations:
+          - The number of concurrent processes has a hard limit of 64,
+            due to the way this port implements waiting for its
+            subprocesses;
+          - The job server method (available when Make runs on Posix
+            platforms) is not supported, which means you must pass an
+            explicit -jN switch to sub-Make's in a recursive Makefile.
+            If a sub-Make does not receive an explicit -jN switch, it
+            will default to -j1, i.e. no parallelism in sub-Make's.
+        Parallel builds (-jN) are supported in this port, with 1
+        limitation: The number of concurrent processes has a hard
+        limit of 64, due to the way this port implements waiting for
+        its subprocesses.
 GNU make and Cygnus GNU Windows32 tools:
         Good news! Make now has native support for Cygwin sh. To enable,
         define the HAVE_CYGWIN_SHELL in config.h and rebuild make
         from scratch. This version of make tested with B20.1 of Cygwin.
         Do not define BATCH_MODE_ONLY_SHELL if you use HAVE_CYGWIN_SHELL.
+        Good news! Make now has native support for Cygwin sh. To enable,
+        define the HAVE_CYGWIN_SHELL in config.h and rebuild make
+        from scratch. This version of make tested with B20.1 of Cygwin.
+        Do not define BATCH_MODE_ONLY_SHELL if you use HAVE_CYGWIN_SHELL.
 GNU make and the MKS shell:
         There is now semi-official support for the MKS shell. To turn this
         support on, define HAVE_MKS_SHELL in the config.h.W32 before you
         build make.  Do not define BATCH_MODE_ONLY_SHELL if you turn
         on HAVE_MKS_SHELL.
+        There is now semi-official support for the MKS shell. To turn this
+        support on, define HAVE_MKS_SHELL in the config.h.W32 before you
+        build make.  Do not define BATCH_MODE_ONLY_SHELL if you turn
+        on HAVE_MKS_SHELL.
 GNU make handling of drive letters in pathnames (PATH, vpath, VPATH):
         There is a caveat that should be noted with respect to handling
         single character pathnames on Windows systems.  When colon is
         used in PATH variables, make tries to be smart about knowing when
         you are using colon as a separator versus colon as a drive
         letter.  Unfortunately, something as simple as the string 'x:/'
         could be interpreted 2 ways: (x and /) or (x:/).
         Make chooses to interpret a letter plus colon (e.g. x:/) as a
         drive letter pathname.  If it is necessary to use single
         character directories in paths (VPATH, vpath, Path, PATH), the
         user must do one of two things:
          a. Use semicolon as the separator to disambiguate colon. For
             example use 'x;/' if you want to say 'x' and '/' are
             separate components.
          b. Qualify the directory name so that there is more than
             one character in the path(s) used. For example, none
             of these settings are ambiguous:
               ./x:./y
               /some/path/x:/some/path/y
               x:/some/path/x:x:/some/path/y
         Please note that you are free to mix colon and semi-colon in the
         specification of paths.  Make is able to figure out the intended
         result and convert the paths internally to the format needed
         when interacting with the operating system, providing the path
         is not within quotes, e.g. "x:/test/test.c".
         You are encouraged to use colon as the separator character.
         This should ease the pain of deciding how to handle various path
         problems which exist between platforms.  If colon is used on
         both Unix and Windows systems, then no ifdef'ing will be
         necessary in the makefile source.
+        There is a caveat that should be noted with respect to handling
+        single character pathnames on Windows systems.  When colon is
+        used in PATH variables, make tries to be smart about knowing when
+        you are using colon as a separator versus colon as a drive
+        letter.  Unfortunately, something as simple as the string 'x:/'
+        could be interpreted 2 ways: (x and /) or (x:/).
+        Make chooses to interpret a letter plus colon (e.g. x:/) as a
+        drive letter pathname.  If it is necessary to use single
+        character directories in paths (VPATH, vpath, Path, PATH), the
+        user must do one of two things:
+         a. Use semicolon as the separator to disambiguate colon. For
+            example use 'x;/' if you want to say 'x' and '/' are
+            separate components.
+         b. Qualify the directory name so that there is more than
+            one character in the path(s) used. For example, none
+            of these settings are ambiguous:
+              ./x:./y
+              /some/path/x:/some/path/y
+              x:/some/path/x:x:/some/path/y
+        Please note that you are free to mix colon and semi-colon in the
+        specification of paths.  Make is able to figure out the intended
+        result and convert the paths internally to the format needed
+        when interacting with the operating system, providing the path
+        is not within quotes, e.g. "x:/test/test.c".
+        You are encouraged to use colon as the separator character.
+        This should ease the pain of deciding how to handle various path
+        problems which exist between platforms.  If colon is used on
+        both Unix and Windows systems, then no ifdef'ing will be
+        necessary in the makefile source.
 GNU make test suite:
         I verified all functionality with a slightly modified version
         of make-test-%VERSION% (modifications to get test suite to run
         on Windows NT). All tests pass in an environment that includes
         sh.exe.  Tests were performed on both Windows NT and Windows 95.
+        I verified all functionality with a slightly modified version
+        of make-test-%VERSION% (modifications to get test suite to run
+        on Windows NT). All tests pass in an environment that includes
+        sh.exe.  Tests were performed on both Windows NT and Windows 95.
 Pathnames and white space:
         Unlike Unix, Windows 95/NT systems encourage pathnames which
         contain white space (e.g. C:\Program Files\). These sorts of
         pathnames are valid on Unix too, but are never encouraged.
         There is at least one place in make (VPATH/vpath handling) where
         paths containing white space will simply not work. There may be
         others too. I chose to not try and port make in such a way so
         that these sorts of paths could be handled. I offer these
         suggestions as workarounds:
 . Use 8.3 notation. i.e. "x:/long~1/", which is actually
                    "x:\longpathtest".  Type "dir /x" to view these filenames
                    within the cmd.exe shell.
 . Rename the directory so it does not contain white space.
         If you are unhappy with this choice, this is free software
         and you are free to take a crack at making this work. The code
         in w32/pathstuff.c and vpath.c would be the places to start.
+        Unlike Unix, Windows 95/NT systems encourage pathnames which
+        contain white space (e.g. C:\Program Files\). These sorts of
+        pathnames are valid on Unix too, but are never encouraged.
+        There is at least one place in make (VPATH/vpath handling) where
+        paths containing white space will simply not work. There may be
+        others too. I chose to not try and port make in such a way so
+        that these sorts of paths could be handled. I offer these
+        suggestions as workarounds:
+. Use 8.3 notation. i.e. "x:/long~1/", which is actually
+                   "x:\longpathtest".  Type "dir /x" to view these filenames
+                   within the cmd.exe shell.
+. Rename the directory so it does not contain white space.
+        If you are unhappy with this choice, this is free software
+        and you are free to take a crack at making this work. The code
+        in w32/pathstuff.c and vpath.c would be the places to start.
 Pathnames and Case insensitivity:
         Unlike Unix, Windows 95/NT systems are case insensitive but case
         preserving.  For example if you tell the file system to create a
         file named "Target", it will preserve the case.  Subsequent access to
         the file with other case permutations will succeed (i.e. opening a
         file named "target" or "TARGET" will open the file "Target").
         By default, GNU make retains its case sensitivity when comparing
         target names and existing files or directories.  It can be
         configured, however, into a case preserving and case insensitive
         mode by adding a define for HAVE_CASE_INSENSITIVE_FS to
         config.h.W32.
         For example, the following makefile will create a file named
         Target in the directory subdir which will subsequently be used
         to satisfy the dependency of SUBDIR/DepTarget on SubDir/TARGET.
         Without HAVE_CASE_INSENSITIVE_FS configured, the dependency link
         will not be made:
         subdir/Target:
                 touch $@
         SUBDIR/DepTarget: SubDir/TARGET
                 cp $^ $@
         Reliance on this behavior also eliminates the ability of GNU make
         to use case in comparison of matching rules.  For example, it is
         not possible to set up a C++ rule using %.C that is different
         than a C rule using %.c.  GNU make will consider these to be the
         same rule and will issue a warning.
+        Unlike Unix, Windows 95/NT systems are case insensitive but case
+        preserving.  For example if you tell the file system to create a
+        file named "Target", it will preserve the case.  Subsequent access to
+        the file with other case permutations will succeed (i.e. opening a
+        file named "target" or "TARGET" will open the file "Target").
+        By default, GNU make retains its case sensitivity when comparing
+        target names and existing files or directories.  It can be
+        configured, however, into a case preserving and case insensitive
+        mode by adding a define for HAVE_CASE_INSENSITIVE_FS to
+        config.h.W32.
+        For example, the following makefile will create a file named
+        Target in the directory subdir which will subsequently be used
+        to satisfy the dependency of SUBDIR/DepTarget on SubDir/TARGET.
+        Without HAVE_CASE_INSENSITIVE_FS configured, the dependency link
+        will not be made:
+        subdir/Target:
+                touch $@
+        SUBDIR/DepTarget: SubDir/TARGET
+                cp $^ $@
+        Reliance on this behavior also eliminates the ability of GNU make
+        to use case in comparison of matching rules.  For example, it is
+        not possible to set up a C++ rule using %.C that is different
+        than a C rule using %.c.  GNU make will consider these to be the
+        same rule and will issue a warning.
 SAMBA/NTFS/VFAT:
         I have not had any success building the debug version of this
         package using SAMBA as my file server. The reason seems to be
         related to the way VC++ 4.0 changes the case name of the pdb
         filename it is passed on the command line. It seems to change
         the name always to to lower case. I contend that the VC++
         compiler should not change the casename of files that are passed
         as arguments on the command line. I don't think this was a
         problem in MSVC 2.x, but I know it is a problem in MSVC 4.x.
         The package builds fine on VFAT and NTFS filesystems.
         Most all of the development I have done to date has been using
         NTFS and long file names. I have not done any considerable work
         under VFAT. VFAT users may wish to be aware that this port of
         make does respect case sensitivity.
+        I have not had any success building the debug version of this
+        package using SAMBA as my file server. The reason seems to be
+        related to the way VC++ 4.0 changes the case name of the pdb
+        filename it is passed on the command line. It seems to change
+        the name always to to lower case. I contend that the VC++
+        compiler should not change the casename of files that are passed
+        as arguments on the command line. I don't think this was a
+        problem in MSVC 2.x, but I know it is a problem in MSVC 4.x.
+        The package builds fine on VFAT and NTFS filesystems.
+        Most all of the development I have done to date has been using
+        NTFS and long file names. I have not done any considerable work
+        under VFAT. VFAT users may wish to be aware that this port of
+        make does respect case sensitivity.
 FAT:
         Version 3.76 added support for FAT filesystems. Make works
         around some difficulties with stat'ing of files and caching of
         filenames and directories internally.
+        Version 3.76 added support for FAT filesystems. Make works
+        around some difficulties with stat'ing of files and caching of
+        filenames and directories internally.
 Bug reports:
         Please submit bugs via the normal bug reporting mechanism which
         is described in the GNU make manual and the base README.
+        Please submit bugs via the normal bug reporting mechanism which
+        is described in the GNU make manual and the base README.
 -------------------------------------------------------------------------------
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.

vendor/gnumake/current/README.customs

-              r2596
+              r3138
 documentation.  You should also install the man pages (contrary to
 comments in the documentation, they weren't installed automatically for
 me; I had to cd to the ``pmake-2.1.33/doc'' directory and run ``pmake
 install'' there directly).
+me; I had to cd to the 'pmake-2.1.33/doc' directory and run 'pmake
+install' there directly).
 …
 Once you've installed Customs, you can build GNU make to use it.  When
 configuring GNU make, merely use the ``--with-customs=DIR'' option.
 Provide the directory containing the ``lib'' and ``include/customs''
+configuring GNU make, merely use the '--with-customs=DIR' option.
+Provide the directory containing the 'lib' and 'include/customs'
 subdirectories as DIR.  For example, if you installed the customs
 library in /usr/local/lib and the headers in /usr/local/include/customs,
 then you'd pass ``--with-customs=/usr/local'' as an option to configure.
+then you'd pass '--with-customs=/usr/local' as an option to configure.
 Run make (or use build.sh) normally to build GNU make as described in
 …
 -------------------------------------------------------------------------------
+Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+, 2010 Free Software Foundation, Inc.
+Copyright (C) 1998-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.

vendor/gnumake/current/README.template

-              r2596
+              r3138
 For general building and installation instructions, see the file INSTALL.
 If you need to build GNU Make and have no other `make' program to use,
 you can use the shell script `build.sh' instead.  To do this, first run
 `configure' as described in INSTALL.  Then, instead of typing `make' to
 build the program, type `sh build.sh'.  This should compile the program
+If you need to build GNU Make and have no other 'make' program to use,
+you can use the shell script 'build.sh' instead.  To do this, first run
+'configure' as described in INSTALL.  Then, instead of typing 'make' to
+build the program, type 'sh build.sh'.  This should compile the program
 in the current directory.  Then you will have a Make program that you can
 use for `./make install', or whatever else.
+use for './make install', or whatever else.
 Some systems' Make programs are broken and cannot process the Makefile for
 GNU Make.  If you get errors from your system's Make when building GNU
 Make, try using `build.sh' instead.
+Make, try using 'build.sh' instead.
 GNU Make is free software.  See the file COPYING for copying conditions.
+GNU Make is copyright by the Free Software Foundation.  Copyright notices
+condense sequential years into a range; e.g. "1987-1994" means all years
+from 1987 to 1994 inclusive.
 Downloading
 …
 You can send GNU make bug reports to <bug-make@gnu.org>.  Please see the
 section of the GNU make manual entitled `Problems and Bugs' for
+section of the GNU make manual entitled 'Problems and Bugs' for
 information on submitting useful and complete bug reports.
 …
   news:gnu.utils.bug
-  http://savannah.gnu.org/support/?group=make
+You may also find interesting patches to GNU Make available here:
+  http://savannah.gnu.org/patch/?group=make
+Note these patches are provided by our users as a service and we make no
+statements regarding their correctness.  Please contact the authors
+directly if you have a problem or suggestion for a patch available on
+this page.
+CVS Access
+Git Access
 ----------
 The GNU make source repository is available via anonymous CVS from the
 GNU Subversions CVS server; look here for details:
+The GNU make source repository is available via Git from the
+GNU Savannah Git server; look here for details:
   http://savannah.gnu.org/cvs/?group=make
+  http://savannah.gnu.org/git/?group=make
 Please note: you won't be able to build GNU make from CVS without
+Please note: you won't be able to build GNU make from Git without
 installing appropriate maintainer's tools, such as GNU m4, automake,
 autoconf, Perl, GNU make, and GCC.  See the README.cvs file for hints on
+autoconf, Perl, GNU make, and GCC.  See the README.git file for hints on
 how to build GNU make once these tools are available.  We make no
 guarantees about the contents or quality of the latest code in the CVS
+guarantees about the contents or quality of the latest code in the Git
 repository: it is not unheard of for code that is known to be broken to
 be checked in.  Use at your own risk.
 …
 It has been reported that the XLC 1.2 compiler on AIX 3.2 is buggy such
 that if you compile make with `cc -O' on AIX 3.2, it will not work
 correctly.  It is said that using `cc' without `-O' does work.
+that if you compile make with 'cc -O' on AIX 3.2, it will not work
+correctly.  It is said that using 'cc' without '-O' does work.
 The standard /bin/sh on SunOS 4.1.3_U1 and 4.1.4 is broken and cannot be
 …
 One area that is often a problem in configuration and porting is the code
 to check the system's current load average.  To make it easier to test and
 debug this code, you can do `make check-loadavg' to see if it works
 properly on your system.  (You must run `configure' beforehand, but you
+debug this code, you can do 'make check-loadavg' to see if it works
+properly on your system.  (You must run 'configure' beforehand, but you
 need not build Make itself to run this test.)
 …
 Please report any bugs that you find in this area.  If you run into
 difficulties, then as a workaround you should be able to disable LFS by
 adding the `--disable-largefile' option to the `configure' script.
+adding the '--disable-largefile' option to the 'configure' script.
 On systems that support micro- and nano-second timestamp values and
 …
     Customs distributed build environment from the Pmake distribution.
   - See readme.vms for details about GNU Make on OpenVMS.
+  - See README.VMS for details about GNU Make on OpenVMS.
   - See README.Amiga for details about GNU Make on AmigaDOS.
 …
 -------------------------------------------------------------------------------
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.

vendor/gnumake/current/SMakefile.template

-              r2596
+              r3138
 # run 'build.sh' instead.
+#
+# Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+# 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+# Copyright (C) 1995-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 # Ultrix 2.2 make doesn't expand the value of VPATH.
 VPATH = /make-%VERSION%/
 # This must repeat the value, because configure will remove `VPATH = .'.
+# This must repeat the value, because configure will remove 'VPATH = .'.
 srcdir = /make-%VERSION%/
 …
 # Define these for your system as follows:
 #       -DNO_ARCHIVES           To disable `ar' archive support.
+#       -DNO_ARCHIVES           To disable 'ar' archive support.
 #       -DNO_FLOAT              To avoid using floating-point numbers.
 #       -DENUM_BITFIELDS        If the compiler isn't GCC but groks enum foo:2.
 …
 #                               so beware.
 # NeXT 1.0a uses an old version of GCC, which required -D__inline=inline.
 # See also `config.h'.
+# See also 'config.h'.
 defines =
 # Which flavor of remote job execution support to use.
 # The code is found in `remote-$(REMOTE).c'.
+# The code is found in 'remote-$(REMOTE).c'.
 REMOTE = stub
 …
 exec_prefix =
 # Directory to install `make' in.
+# Directory to install 'make' in.
 bindir = sc:c
 # Directory to find libraries in for `-lXXX'.
+# Directory to find libraries in for '-lXXX'.
 libdir = lib:
 # Directory to search by default for included makefiles.
 …
 # Number to put on the man page filename.
 manext = 1
 # Prefix to put on installed `make' binary file name.
+# Prefix to put on installed 'make' binary file name.
 binprefix =
 # Prefix to put on installed `make' man page file name.
+# Prefix to put on installed 'make' man page file name.
 manprefix = $(binprefix)
 # Whether or not make needs to be installed setgid.
 # The value should be either `true' or `false'.
 # On many systems, the getloadavg function (used to implement the `-l'
+# The value should be either 'true' or 'false'.
+# On many systems, the getloadavg function (used to implement the '-l'
 # switch) will not work unless make is installed setgid kmem.
 install_setgid = false
 …
 group = sys
 # Program to install `make'.
+# Program to install 'make'.
 INSTALL_PROGRAM = copy
 # Program to install the man page.
 …
 CTAGS = ctags -w
+objs = commands.o job.o dir.o file.o misc.o main.o read.o remake.o      \
+       rule.o implicit.o default.o variable.o expand.o function.o       \
+       vpath.o version.o ar.o arscan.o signame.o strcache.o hash.o      \
+       remote-$(REMOTE).o $(GLOB) $(GETOPT) $(ALLOCA) $(extras)
+#guile = guile.o
+objs = commands.o job.o dir.o file.o misc.o main.o read.o remake.o   \
+       rule.o implicit.o default.o variable.o expand.o function.o    \
+       vpath.o version.o ar.o arscan.o signame.o strcache.o hash.o   \
+       output.o remote-$(REMOTE).o $(GLOB) $(GETOPT) $(ALLOCA)       \
+       $(extras) $(guile)
 srcs = $(srcdir)commands.c $(srcdir)job.c $(srcdir)dir.c             \
        $(srcdir)file.c $(srcdir)getloadavg.c $(srcdir)misc.c         \
 …
        $(srcdir)variable.c $(srcdir)expand.c $(srcdir)function.c     \
        $(srcdir)vpath.c $(srcdir)version.c $(srcdir)hash.c           \
        $(srcdir)remote-$(REMOTE).c                                     \
        $(srcdir)ar.c $(srcdir)arscan.c $(srcdir)strcache.c              \
        $(srcdir)signame.c $(srcdir)signame.h $(GETOPT_SRC)            \
+       $(srcdir)guile.c $(srcdir)remote-$(REMOTE).c                  \
+       $(srcdir)ar.c $(srcdir)arscan.c $(srcdir)strcache.c           \
+       $(srcdir)signame.c $(srcdir)signame.h $(GETOPT_SRC)           \
        $(srcdir)commands.h $(srcdir)dep.h $(srcdir)file.h            \
+       $(srcdir)job.h $(srcdir)make.h $(srcdir)rule.h                \
+       $(srcdir)job.h $(srcdir)makeint.h $(srcdir)rule.h             \
+       $(srcdir)output.c $(srcdir)output.h                           \
        $(srcdir)variable.h $(ALLOCA_SRC) $(srcdir)config.h.in
 …
 info: make.info
 dvi: make.dvi
 # Some makes apparently use .PHONY as the default goal if it is before `all'.
+# Some makes apparently use .PHONY as the default goal if it is before 'all'.
 .PHONY: all check info dvi

vendor/gnumake/current/TODO.private

-              r2596
+              r3138
 They are listed in no particular order!
 Also, I don't gaurantee that all of them will be ultimately deemed "good
+Also, I don't guarantee that all of them will be ultimately deemed "good
 ideas" and implemented.  These are just the ones that, at first blush,
 seem to have some merit (and that I can remember).
 …
     means this isn't 100% trivial, but it probably won't be hard.
-) Integration of Guile as an embedded scripting language.  This means:
-    allowing Guile functions to be declared in makefiles somehow, then
-    providing a syntax for invoking them.  At least one formulation of
-    that would have the function resolve to a string which would be
-    substituted in the makefile, kind of like $(shell ...) does now, but
-    using the embedded interpreter so there's no process forked of
-    course.  Obviously this is an optional add-on feature.
-    It could be more advanced than that, even, who knows?  Maybe make
-    could provide Guile functions that allow Guile scripts more direct
-    access to internal make structures, somehow.  This kind of thing
-    needs a lot of thought.
-    Also there's always the flip side: in some very fundamental ways
-    make isn't the best choice right now for a complex build tool.  It's
-    great for simple-to-medium tasks, but there are already other tools
-    available for the really tough situations.  Ask yourself,
-    realistically, how much work is worthwhile to add to make, given the
-    fundamentals you can't really overcome without significantly
-    affecting backward compatibility--and then why not use another tool
-    in the first place?
-    Something to think about.
 -------------------------------------------------------------------------------
+Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1997-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.

vendor/gnumake/current/acinclude.m4

-              r2596
+              r3138
 dnl
 dnl Automake will incorporate this into its generated aclocal.m4.
+dnl Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+dnl 2008, 2009, 2010 Free Software Foundation, Inc.
+dnl Copyright (C) 1998-2016 Free Software Foundation, Inc.
 dnl This file is part of GNU Make.
 dnl
 …
 dnl ---------------------------------------------------------------------------
 dnl From Paul Eggert <eggert@twinsun.com>
+dnl Update for Darwin by Troy Runkel <Troy.Runkel@mathworks.com>
+dnl Update for AIX by Olexiy Buyanskyy (Savannah bug 32485)
 AC_DEFUN([AC_STRUCT_ST_MTIM_NSEC],
  [AC_CACHE_CHECK([for nanoseconds field of struct stat.st_mtim],
+ [AC_CACHE_CHECK([for nanoseconds field of struct stat],
    ac_cv_struct_st_mtim_nsec,
    [ac_save_CPPFLAGS="$CPPFLAGS"
     ac_cv_struct_st_mtim_nsec=no
     # tv_nsec -- the usual case
     # _tv_nsec -- Solaris 2.6, if
+    # st_mtim.tv_nsec -- the usual case
+    # st_mtim._tv_nsec -- Solaris 2.6, if
     #   (defined _XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED == 1
     #    && !defined __EXTENSIONS__)
+    # st__tim.tv_nsec -- UnixWare 2.1.2
+    for ac_val in tv_nsec _tv_nsec st__tim.tv_nsec; do
+    # st_mtim.st__tim.tv_nsec -- UnixWare 2.1.2
+    # st_mtime_n -- AIX 5.2 and above
+    # st_mtimespec.tv_nsec -- Darwin (Mac OSX)
+    for ac_val in st_mtim.tv_nsec st_mtim._tv_nsec st_mtim.st__tim.tv_nsec st_mtime_n st_mtimespec.tv_nsec; do
       CPPFLAGS="$ac_save_CPPFLAGS -DST_MTIM_NSEC=$ac_val"
       AC_TRY_COMPILE([#include <sys/types.h>
 #include <sys/stat.h>
         ], [struct stat s; s.st_mtim.ST_MTIM_NSEC;],
+        ], [struct stat s; s.ST_MTIM_NSEC;],
         [ac_cv_struct_st_mtim_nsec=$ac_val; break])
     done

vendor/gnumake/current/alloca.c

r54	r3138
117	117	find_stack_direction (void)
118	118	{
119		static char addr = NULL; / Address of first `dummy', once known. */
	119	static char addr = NULL; / Address of first 'dummy', once known. */
120	120	auto char dummy; /* To get stack address. */
121	121

vendor/gnumake/current/amiga.c

-              r2596
+              r3138
 /* Running commands on Amiga
+Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1995-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include "variable.h"
 #include "amiga.h"
 …
 static const char Amiga_version[] = "$VER: Make 3.74.3 (12.05.96) \n"
                     "Amiga Port by A. Digulla (digulla@home.lake.de)";
+                    "Amiga Port by A. Digulla (digulla@home.lake.de)";
 int
 …
     for (aptr=argv; *aptr; aptr++)
+    {
         len += strlen (*aptr) + 4;
+        len += strlen (*aptr) + 4;
+    }
 …
     if (!buffer)
       fatal (NILF, "MyExecute: Cannot allocate space for calling a command");
+      O (fatal, NILF, "MyExecute: Cannot allocate space for calling a command\n");
     ptr = buffer;
 …
     for (aptr=argv; *aptr; aptr++)
+    {
         if (((*aptr)[0] == ';' && !(*aptr)[1]))
+        {
             *ptr ++ = '"';
             strcpy (ptr, *aptr);
             ptr += strlen (ptr);
             *ptr ++ = '"';
+        }
         else if ((*aptr)[0] == '@' && (*aptr)[1] == '@' && !(*aptr)[2])
+        {
             *ptr ++ = '\n';
             continue;
+        }
         else
+        {
             strcpy (ptr, *aptr);
             ptr += strlen (ptr);
+        }
         *ptr ++ = ' ';
         *ptr = 0;
+        if (((*aptr)[0] == ';' && !(*aptr)[1]))
+        {
+            *ptr ++ = '"';
+            strcpy (ptr, *aptr);
+            ptr += strlen (ptr);
+            *ptr ++ = '"';
+        }
+        else if ((*aptr)[0] == '@' && (*aptr)[1] == '@' && !(*aptr)[2])
+        {
+            *ptr ++ = '\n';
+            continue;
+        }
+        else
+        {
+            strcpy (ptr, *aptr);
+            ptr += strlen (ptr);
+        }
+        *ptr ++ = ' ';
+        *ptr = 0;
+    }
 …
     status = SystemTags (buffer,
         SYS_UserShell, TRUE,
         TAG_END);
+        SYS_UserShell, TRUE,
+        TAG_END);
     FreeMem (buffer, len);
     if (SetSignal(0L,0L) & SIGBREAKF_CTRL_C)
         status = 20;
+    if (SetSignal (0L,0L) & SIGBREAKF_CTRL_C)
+        status = 20;
     /* Warnings don't count */
     if (status == 5)
         status = 0;
+        status = 0;
     return status;
 …
 wildcard_expansion (char *wc, char *o)
+{
 #   define PATH_SIZE    1024
+#   define PATH_SIZE    1024
     struct AnchorPath * apath;
     if ( (apath = AllocMem (sizeof (struct AnchorPath) + PATH_SIZE,
             MEMF_CLEAR))
+        )
+            MEMF_CLEAR))
+        )
+    {
         apath->ap_Strlen = PATH_SIZE;
+        apath->ap_Strlen = PATH_SIZE;
         if (MatchFirst (wc, apath) == 0)
+        {
             do
+            {
                 o = variable_buffer_output (o, apath->ap_Buf,
                         strlen (apath->ap_Buf));
                 o = variable_buffer_output (o, " ",1);
             } while (MatchNext (apath) == 0);
+        }
+        if (MatchFirst (wc, apath) == 0)
+        {
+            do
+            {
+                o = variable_buffer_output (o, apath->ap_Buf,
+                        strlen (apath->ap_Buf));
+                o = variable_buffer_output (o, " ",1);
+            } while (MatchNext (apath) == 0);
+        }
         MatchEnd (apath);
         FreeMem (apath, sizeof (struct AnchorPath) + PATH_SIZE);
+        MatchEnd (apath);
+        FreeMem (apath, sizeof (struct AnchorPath) + PATH_SIZE);
+    }

vendor/gnumake/current/amiga.h

r2596	r3138
1	1	/* Definitions for amiga specific things
2		Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3		2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
	2	Copyright (C) 1995-2016 Free Software Foundation, Inc.
4	3	This file is part of GNU Make.
5	4

vendor/gnumake/current/ar.c

-              r2596
+              r3138
+/* Interface to `ar' archives for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+/* Interface to 'ar' archives for GNU Make.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
 #ifndef NO_ARCHIVES
+#include "makeint.h"
+#ifndef NO_ARCHIVES
 #include "filedef.h"
 …
 /* Return nonzero if NAME is an archive-member reference, zero if not.  An
    archive-member reference is a name like `lib(member)' where member is a
+   archive-member reference is a name like 'lib(member)' where member is a
    non-empty string.
    If a name like `lib((entry))' is used, a fatal error is signaled at
+   If a name like 'lib((entry))' is used, a fatal error is signaled at
    the attempt to use this unsupported feature.  */
 …
   if (p[1] == '(' && end[-1] == ')')
     fatal (NILF, _("attempt to use unsupported feature: `%s'"), name);
+    OS (fatal, NILF, _("attempt to use unsupported feature: '%s'"), name);
   return 1;
 …
   p = strchr (*arname_p, '(');
   *(p++) = '\0';
   p[strlen(p) - 1] = '\0';
+  p[strlen (p) - 1] = '\0';
   *memname_p = p;
+}
 …
 /* This function is called by `ar_scan' to find which member to look at.  */
+/* This function is called by 'ar_scan' to find which member to look at.  */
 /* ARGSUSED */
 static long int
 ar_member_date_1 (int desc UNUSED, const char *mem, int truncated,
                   long int hdrpos UNUSED, long int datapos UNUSED,
+                  long int hdrpos UNUSED, long int datapos UNUSED,
                   long int size UNUSED, long int date,
                   int uid UNUSED, int gid UNUSED, int mode UNUSED,
                   const void *name)
+                  int uid UNUSED, int gid UNUSED, unsigned int mode UNUSED,
+                  const void *name)
+{
   return ar_name_equal (name, mem, truncated) ? date : 0;
 …
 ar_touch (const char *name)
+{
   error (NILF, _("touch archive member is not available on VMS"));
+  O (error, NILF, _("touch archive member is not available on VMS"));
   return -1;
+}
 …
+    {
     case -1:
       error (NILF, _("touch: Archive `%s' does not exist"), arname);
+      OS (error, NILF, _("touch: Archive '%s' does not exist"), arname);
       break;
     case -2:
       error (NILF, _("touch: `%s' is not a valid archive"), arname);
+      OS (error, NILF, _("touch: '%s' is not a valid archive"), arname);
       break;
     case -3:
 …
       break;
     case 1:
       error (NILF,
              _("touch: Member `%s' does not exist in `%s'"), memname, arname);
+      OSS (error, NILF,
+           _("touch: Member '%s' does not exist in '%s'"), memname, arname);
       break;
     case 0:
 …
       break;
     default:
       error (NILF,
              _("touch: Bad return code from ar_member_touch on `%s'"), name);
+      OS (error, NILF,
+          _("touch: Bad return code from ar_member_touch on '%s'"), name);
+    }
 …
+/* State of an `ar_glob' run, passed to `ar_glob_match'.  */
+/* State of an 'ar_glob' run, passed to 'ar_glob_match'.  */
+/* On VMS, (object) modules in libraries do not have suffixes. That is, to
+   find a match for a pattern, the pattern must not have any suffix. So the
+   suffix of the pattern is saved and the pattern is stripped (ar_glob).
+   If there is a match and the match, which is a module name, is added to
+   the chain, the saved suffix is added back to construct a source filename
+   (ar_glob_match). */
 struct ar_glob_state
 …
     const char *arname;
     const char *pattern;
+#ifdef VMS
+    char *suffix;
+#endif
     unsigned int size;
     struct nameseq *chain;
 …
   };
 /* This function is called by `ar_scan' to match one archive
+/* This function is called by 'ar_scan' to match one archive
    element against the pattern in STATE.  */
 static long int
 ar_glob_match (int desc UNUSED, const char *mem, int truncated UNUSED,
                long int hdrpos UNUSED, long int datapos UNUSED,
+               long int hdrpos UNUSED, long int datapos UNUSED,
                long int size UNUSED, long int date UNUSED, int uid UNUSED,
                int gid UNUSED, int mode UNUSED, const void *arg)
+               int gid UNUSED, unsigned int mode UNUSED, const void *arg)
+{
   struct ar_glob_state *state = (struct ar_glob_state *)arg;
 …
       /* We have a match.  Add it to the chain.  */
       struct nameseq *new = xcalloc (state->size);
+      new->name = strcache_add (concat (4, state->arname, "(", mem, ")"));
+#ifdef VMS
+      if (state->suffix)
+        new->name = strcache_add(
+            concat(5, state->arname, "(", mem, state->suffix, ")"));
+      else
+#endif
+        new->name = strcache_add(concat(4, state->arname, "(", mem, ")"));
       new->next = state->chain;
       state->chain = new;
 …
    Metacharacters can be quoted with backslashes if QUOTE is nonzero.  */
 static int
 glob_pattern_p (const char *pattern, int quote)
+ar_glob_pattern_p (const char *pattern, int quote)
+{
   const char *p;
 …
       case '?':
       case '*':
         return 1;
+        return 1;
       case '\\':
         if (quote)
           ++p;
         break;
+        if (quote)
+          ++p;
+        break;
       case '[':
         opened = 1;
         break;
+        opened = 1;
+        break;
       case ']':
         if (opened)
           return 1;
         break;
+        if (opened)
+          return 1;
+        break;
+      }
 …
   const char **names;
   unsigned int i;
+  if (! glob_pattern_p (member_pattern, 1))
+#ifdef VMS
+  char *vms_member_pattern;
+#endif
+  if (! ar_glob_pattern_p (member_pattern, 1))
     return 0;
 …
   state.arname = arname;
   state.pattern = member_pattern;
+#ifdef VMS
+    {
+      /* In a copy of the pattern, find the suffix, save it and  remove it from
+         the pattern */
+      char *lastdot;
+      vms_member_pattern = xstrdup(member_pattern);
+      lastdot = strrchr(vms_member_pattern, '.');
+      state.suffix = lastdot;
+      if (lastdot)
+        {
+          state.suffix = xstrdup(lastdot);
+          *lastdot = 0;
+        }
+      state.pattern = vms_member_pattern;
+    }
+#endif
   state.size = size;
   state.chain = 0;
   state.n = 0;
   ar_scan (arname, ar_glob_match, &state);
+#ifdef VMS
+  /* Deallocate any duplicated string */
+  free(vms_member_pattern);
+  if (state.suffix)
+    {
+      free(state.suffix);
+    }
+#endif
   if (state.chain == 0)
 …
+}
 #endif  /* Not NO_ARCHIVES.  */
+#endif  /* Not NO_ARCHIVES.  */

vendor/gnumake/current/arscan.c

-              r2596
+              r3138
 /* Library function for scanning an archive file.
+Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1987-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
+#include "make.h"
+#include "makeint.h"
+#ifdef TEST
+/* Hack, the real error() routine eventually pulls in die from main.c */
+#define error(a, b, c, d)
+#endif
 #ifdef HAVE_FCNTL_H
 …
 #endif
 #ifndef NO_ARCHIVES
+#ifndef NO_ARCHIVES
 #ifdef VMS
 …
 #include <descrip.h>
 #include <ctype.h>
+#if __DECC
+#include <ssdef.h>
+#include <stsdef.h>
+#include <rmsdef.h>
+/* This symbol should be present in lbrdef.h. */
+#ifndef LBR$_HDRTRUNC
+#pragma extern_model save
+#pragma extern_model globalvalue
+extern unsigned int LBR$_HDRTRUNC;
+#pragma extern_model restore
+#endif
 #include <unixlib.h>
 #include <lbr$routines.h>
+#endif
+const char *
+vmsify (const char *name, int type);
+/* Time conversion from VMS to Unix
+   Conversion from local time (stored in library) to GMT (needed for gmake)
+   Note: The tm_gmtoff element is a VMS extension to the ANSI standard. */
+static time_t
+vms_time_to_unix(void *vms_time)
+{
+  struct tm *tmp;
+  time_t unix_time;
+  unix_time = decc$fix_time(vms_time);
+  tmp = localtime(&unix_time);
+  unix_time -= tmp->tm_gmtoff;
+  return unix_time;
+}
+/* VMS library routines need static variables for callback */
 static void *VMS_lib_idx;
+static char *VMS_saved_memname;
+static time_t VMS_member_date;
+static const void *VMS_saved_arg;
 static long int (*VMS_function) ();
+static long int VMS_function_ret;
+/* This is a callback procedure for lib$get_index */
 static int
 VMS_get_member_info (struct dsc$descriptor_s *module, unsigned long *rfa)
+VMS_get_member_info(struct dsc$descriptor_s *module, unsigned long *rfa)
+{
   int status, i;
+  long int fnval;
+  time_t val;
+  const int truncated = 0; /* Member name may be truncated */
+  time_t member_date; /* Member date */
+  char *filename;
+  unsigned int buffer_length; /* Actual buffer length */
+  /* Unused constants - Make does not actually use most of these */
+  const int file_desc = -1; /* archive file descriptor for reading the data */
+  const int header_position = 0; /* Header position */
+  const int data_position = 0; /* Data position in file */
+  const int data_size = 0; /* Data size */
+  const int uid = 0; /* member gid */
+  const int gid = 0; /* member gid */
+  const int mode = 0; /* member protection mode */
+  /* End of unused constants */
   static struct dsc$descriptor_s bufdesc =
     { 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL };
+  /* Only need the module definition */
   struct mhddef *mhd;
+  char filename[128];
+  bufdesc.dsc$a_pointer = filename;
+  bufdesc.dsc$w_length = sizeof (filename);
+  status = lbr$set_module (&VMS_lib_idx, rfa, &bufdesc,
+                           &bufdesc.dsc$w_length, 0);
+  if (! (status & 1))
+  /* If a previous callback is non-zero, just return that status */
+  if (VMS_function_ret)
+    {
+      error (NILF, _("lbr$set_module() failed to extract module info, status = %d"),
+             status);
+      lbr$close (&VMS_lib_idx);
+      return 0;
+      return SS$_NORMAL;
+    }
+  mhd = (struct mhddef *) filename;
+#ifdef __DECC
+  /* John Fowler <jfowler@nyx.net> writes this is needed in his environment,
+   * but that decc$fix_time() isn't documented to work this way.  Let me
+   * know if this causes problems in other VMS environments.
+   */
+  {
+    /* Modified by M. Gehre at 11-JAN-2008 because old formula is wrong:
+     * val = decc$fix_time (&mhd->mhd$l_datim) + timezone - daylight*3600;
+     * a) daylight specifies, if the timezone has daylight saving enabled, not
+     *    if it is active
+     * b) what we need is the information, if daylight saving was active, if
+     *    the library module was replaced. This information we get using the
+     *    localtime function
+     */
+    struct tm *tmp;
+    /* Conversion from VMS time to C time */
+    val = decc$fix_time (&mhd->mhd$l_datim);
+    /*
+     * Conversion from local time (stored in library) to GMT (needed for gmake)
+     * Note: The tm_gmtoff element is a VMS extension to the ANSI standard.
+     */
+    tmp = localtime (&val);
+    val -= tmp->tm_gmtoff;
+  }
+#endif
+  /* lbr_set_module returns more than just the module header. So allocate
+     a buffer which is big enough: the maximum LBR$C_MAXHDRSIZ. That's at
+     least bigger than the size of struct mhddef.
+     If the request is too small, a buffer truncated warning is issued so
+     it can be reissued with a larger buffer.
+     We do not care if the buffer is truncated, so that is still a success. */
+  mhd = xmalloc(LBR$C_MAXHDRSIZ);
+  bufdesc.dsc$a_pointer = (char *) mhd;
+  bufdesc.dsc$w_length = LBR$C_MAXHDRSIZ;
+  status = lbr$set_module(&VMS_lib_idx, rfa, &bufdesc, &buffer_length, 0);
+  if ((status != LBR$_HDRTRUNC) && !$VMS_STATUS_SUCCESS(status))
+    {
+      ON(error, NILF,
+          _("lbr$set_module() failed to extract module info, status = %d"),
+          status);
+      lbr$close(&VMS_lib_idx);
+      return status;
+    }
+#ifdef TEST
+  /* When testing this code, it is useful to know the length returned */
+  printf("Input length = %d, actual = %d\n",
+      bufdesc.dsc$w_length, buffer_length);
+#endif
+  /* Conversion from VMS time to C time.
+     VMS defectlet - mhddef is sub-optimal, for the time, it has a 32 bit
+     longword, mhd$l_datim, and a 32 bit fill instead of two longwords, or
+     equivalent. */
+  member_date = vms_time_to_unix(&mhd->mhd$l_datim);
+  free(mhd);
+  /* Here we have a problem.  The module name on VMS does not have
+     a file type, but the filename pattern in the "VMS_saved_arg"
+     may have one.
+     But only the method being called knows how to interpret the
+     filename pattern.
+     There are currently two different formats being used.
+     This means that we need a VMS specific code in those methods
+     to handle it. */
+  filename = xmalloc(module->dsc$w_length + 1);
+  /* TODO: We may need an option to preserve the case of the module
+     For now force the module name to lower case */
   for (i = 0; i < module->dsc$w_length; i++)
     filename[i] = _tolower ((unsigned char)module->dsc$a_pointer[i]);
+    filename[i] = _tolower((unsigned char )module->dsc$a_pointer[i]);
   filename[i] = '\0';
+  VMS_member_date = (time_t) -1;
+  fnval =
+    (*VMS_function) (-1, filename, 0, 0, 0, 0, val, 0, 0, 0,
+                     VMS_saved_memname);
+  if (fnval)
+    {
+      VMS_member_date = fnval;
+      return 0;
+    }
+  else
+    return 1;
+  VMS_function_ret = (*VMS_function)(file_desc, filename, truncated,
+      header_position, data_position, data_size, member_date, uid, gid, mode,
+      VMS_saved_arg);
+  free(filename);
+  return SS$_NORMAL;
+}
 /* Takes three arguments ARCHIVE, FUNCTION and ARG.
 …
 long int
 ar_scan (const char *archive, ar_member_func_t function, const void *arg)
+ar_scan (const char *archive, ar_member_func_t function, const void *varg)
+{
   char *p;
+  char *vms_archive;
   static struct dsc$descriptor_s libdesc =
     { 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL };
   unsigned long func = LBR$C_READ;
   unsigned long type = LBR$C_TYP_UNK;
   unsigned long index = 1;
+  const unsigned long func = LBR$C_READ;
+  const unsigned long type = LBR$C_TYP_UNK;
+  const unsigned long index = 1;
+  unsigned long lib_idx;
   int status;
+  status = lbr$ini_control (&VMS_lib_idx, &func, &type, 0);
+  if (! (status & 1))
+  VMS_saved_arg = varg;
+  /* Null archive string can show up in test and cause an access violation */
+  if (archive == NULL)
+    {
+      error (NILF, _("lbr$ini_control() failed with status = %d"), status);
+      /* Null filenames do not exist */
+      return -1;
+    }
+  /* archive path name must be in VMS format */
+  vms_archive = (char *) vmsify(archive, 0);
+  status = lbr$ini_control(&VMS_lib_idx, &func, &type, 0);
+  if (!$VMS_STATUS_SUCCESS(status))
+    {
+      ON(error, NILF, _("lbr$ini_control() failed with status = %d"), status);
       return -2;
+    }
+  /* there is no such descriptor with "const char *dsc$a_pointer" */
+  libdesc.dsc$a_pointer = (char *)archive;
+  libdesc.dsc$w_length = strlen (archive);
+  status = lbr$open (&VMS_lib_idx, &libdesc, 0, 0, 0, 0, 0);
+  if (! (status & 1))
+  libdesc.dsc$a_pointer = vms_archive;
+  libdesc.dsc$w_length = strlen(vms_archive);
+  status = lbr$open(&VMS_lib_idx, &libdesc, 0, NULL, 0, NULL, 0);
+  if (!$VMS_STATUS_SUCCESS(status))
+    {
+      error (NILF, _("unable to open library `%s' to lookup member `%s'"),
+             archive, (char *)arg);
+      return -1;
+      /* TODO: A library format failure could mean that this is a file
+         generated by the GNU AR utility and in that case, we need to
+         take the UNIX codepath.  This will also take a change to the
+         GNV AR wrapper program. */
+      switch (status)
+        {
+      case RMS$_FNF:
+        /* Archive does not exist */
+        return -1;
+      default:
+#ifndef TEST
+        OSN(error, NILF,
+            _("unable to open library '%s' to lookup member status %d"),
+            archive, status);
+#endif
+        /* For library format errors, specification says to return -2 */
+        return -2;
+        }
+    }
-  VMS_saved_memname = (char *)arg;
-  /* For comparison, delete .obj from arg name.  */
-  p = strrchr (VMS_saved_memname, '.');
-  if (p)
-    *p = '\0';
   VMS_function = function;
+  VMS_member_date = (time_t) -1;
+  lbr$get_index (&VMS_lib_idx, &index, VMS_get_member_info, 0);
+  /* Undo the damage.  */
+  if (p)
+    *p = '.';
+  lbr$close (&VMS_lib_idx);
+  return VMS_member_date > 0 ? VMS_member_date : 0;
+  /* Clear the return status, as we are supposed to stop calling the
+     callback function if it becomes non-zero, and this is a static
+     variable. */
+  VMS_function_ret = 0;
+  status = lbr$get_index(&VMS_lib_idx, &index, VMS_get_member_info, NULL, 0);
+  lbr$close(&VMS_lib_idx);
+  /* Unless a failure occurred in the lbr$ routines, return the
+     the status from the 'function' routine. */
+  if ($VMS_STATUS_SUCCESS(status))
+    {
+      return VMS_function_ret;
+    }
+  /* This must be something wrong with the library and an error
+     message should already have been printed. */
+  return -2;
+}
 …
 /* SCO Unix's compiler defines both of these.  */
 #ifdef  M_UNIX
 #undef  M_XENIX
+#ifdef  M_UNIX
+#undef  M_XENIX
 #endif
 …
 #if (!defined (PORTAR) || PORTAR == 0) && (!defined (PORT5AR) || PORT5AR == 0)
 #undef  PORTAR
+#undef  PORTAR
 #ifdef M_XENIX
 /* According to Jim Sievert <jas1@rsvl.unisys.com>, for SCO XENIX defining
 …
 #ifndef WINDOWS32
 # ifndef __BEOS__
+# if !defined (__ANDROID__) && !defined (__BEOS__)
 #  include <ar.h>
 # else
    /* BeOS 5 doesn't have <ar.h> but has archives in the same format
+   /* These platforms don't have <ar.h> but have archives in the same format
     * as many other Unices.  This was taken from GNU binutils for BeOS.
     */
 #  define ARMAG "!<arch>\n"     /* String that begins an archive file.  */
 #  define SARMAG 8              /* Size of that string.  */
 #  define ARFMAG "`\n"          /* String in ar_fmag at end of each header.  */
+#  define ARMAG "!<arch>\n"     /* String that begins an archive file.  */
+#  define SARMAG 8              /* Size of that string.  */
+#  define ARFMAG "`\n"          /* String in ar_fmag at end of each header.  */
 struct ar_hdr
+  {
     char ar_name[16];           /* Member file name, sometimes / terminated. */
     char ar_date[12];           /* File date, decimal seconds since Epoch.  */
     char ar_uid[6], ar_gid[6];  /* User and group IDs, in ASCII decimal.  */
     char ar_mode[8];            /* File mode, in ASCII octal.  */
     char ar_size[10];           /* File size, in ASCII decimal.  */
     char ar_fmag[2];            /* Always contains ARFMAG.  */
+    char ar_name[16];           /* Member file name, sometimes / terminated. */
+    char ar_date[12];           /* File date, decimal seconds since Epoch.  */
+    char ar_uid[6], ar_gid[6];  /* User and group IDs, in ASCII decimal.  */
+    char ar_mode[8];            /* File mode, in ASCII octal.  */
+    char ar_size[10];           /* File size, in ASCII decimal.  */
+    char ar_fmag[2];            /* Always contains ARFMAG.  */
   };
 # endif
 …
 /* Cray's <ar.h> apparently defines this.  */
 #ifndef AR_HDR_SIZE
 # define   AR_HDR_SIZE  (sizeof (struct ar_hdr))
+#ifndef AR_HDR_SIZE
+# define   AR_HDR_SIZE  (sizeof (struct ar_hdr))
 #endif
 …
 #ifdef AIAMAG
   FL_HDR fl_header;
 #ifdef AIAMAGBIG
+# ifdef AIAMAGBIG
   int big_archive = 0;
   FL_HDR_BIG fl_header_big;
+#endif
+#else
+  int long_name = 0;
+# endif
 #endif
   char *namemap = 0;
 …
+  {
     char buf[SARMAG];
+    register int nread = read (desc, buf, SARMAG);
+    int nread;
+    EINTRLOOP (nread, read (desc, buf, SARMAG));
     if (nread != SARMAG || memcmp (buf, ARMAG, SARMAG))
+      {
         (void) close (desc);
         return -2;
+        (void) close (desc);
+        return -2;
+      }
+  }
 …
 #ifdef AIAMAG
+  {
     register int nread = read (desc, &fl_header, FL_HSZ);
+    int nread;
+    EINTRLOOP (nread, read (desc, &fl_header, FL_HSZ));
     if (nread != FL_HSZ)
+      {
         (void) close (desc);
         return -2;
+        (void) close (desc);
+        return -2;
+      }
 #ifdef AIAMAGBIG
 …
     if (!memcmp (fl_header.fl_magic, AIAMAGBIG, SAIAMAG))
+      {
+        big_archive = 1;
+        /* seek back to beginning of archive */
+        if (lseek (desc, 0, 0) < 0)
+          {
+            (void) close (desc);
+            return -2;
+          }
+        /* re-read the header into the "big" structure */
+        nread = read (desc, &fl_header_big, FL_HSZ_BIG);
+        if (nread != FL_HSZ_BIG)
+          {
+            (void) close (desc);
+            return -2;
+          }
+        off_t o;
+        big_archive = 1;
+        /* seek back to beginning of archive */
+        EINTRLOOP (o, lseek (desc, 0, 0));
+        if (o < 0)
+          {
+            (void) close (desc);
+            return -2;
+          }
+        /* re-read the header into the "big" structure */
+        EINTRLOOP (nread, read (desc, &fl_header_big, FL_HSZ_BIG));
+        if (nread != FL_HSZ_BIG)
+          {
+            (void) close (desc);
+            return -2;
+          }
+      }
     else
 …
        /* Check to make sure this is a "normal" archive. */
       if (memcmp (fl_header.fl_magic, AIAMAG, SAIAMAG))
+        {
+        {
           (void) close (desc);
           return -2;
+        }
+        }
+  }
 #else
 …
     unsigned short int buf;
 #endif
+    register int nread = read(desc, &buf, sizeof (buf));
+    int nread;
+    EINTRLOOP (nread, read (desc, &buf, sizeof (buf)));
     if (nread != sizeof (buf) || buf != ARMAG)
+      {
         (void) close (desc);
         return -2;
+        (void) close (desc);
+        return -2;
+      }
+  }
 …
     if ( big_archive )
+      {
         sscanf (fl_header_big.fl_fstmoff, "%20ld", &member_offset);
         sscanf (fl_header_big.fl_lstmoff, "%20ld", &last_member_offset);
+        sscanf (fl_header_big.fl_fstmoff, "%20ld", &member_offset);
+        sscanf (fl_header_big.fl_lstmoff, "%20ld", &last_member_offset);
+      }
     else
 #endif
+      {
         sscanf (fl_header.fl_fstmoff, "%12ld", &member_offset);
         sscanf (fl_header.fl_lstmoff, "%12ld", &last_member_offset);
+        sscanf (fl_header.fl_fstmoff, "%12ld", &member_offset);
+        sscanf (fl_header.fl_lstmoff, "%12ld", &last_member_offset);
+      }
     if (member_offset == 0)
+      {
         /* Empty archive.  */
         close (desc);
         return 0;
+        /* Empty archive.  */
+        close (desc);
+        return 0;
+      }
 #else
 #ifndef M_XENIX
+#ifndef M_XENIX
     register long int member_offset = sizeof (int);
 #else   /* Xenix.  */
+#else   /* Xenix.  */
     register long int member_offset = sizeof (unsigned short int);
 #endif  /* Not Xenix.  */
+#endif  /* Not Xenix.  */
 #endif
 #endif
 …
     while (1)
+      {
         register int nread;
         struct ar_hdr member_header;
+        register int nread;
+        struct ar_hdr member_header;
 #ifdef AIAMAGBIG
         struct ar_hdr_big member_header_big;
+        struct ar_hdr_big member_header_big;
 #endif
 #ifdef AIAMAG
+        char name[256];
+        int name_len;
+        long int dateval;
+        int uidval, gidval;
+        long int data_offset;
+#else
+        char namebuf[sizeof member_header.ar_name + 1];
+        char *name;
+        int is_namemap;         /* Nonzero if this entry maps long names.  */
+#endif
+        long int eltsize;
+        int eltmode;
+        long int fnval;
+        if (lseek (desc, member_offset, 0) < 0)
+          {
+            (void) close (desc);
+            return -2;
+          }
+        char name[256];
+        int name_len;
+        long int dateval;
+        int uidval, gidval;
+        long int data_offset;
+#else
+        char namebuf[sizeof member_header.ar_name + 1];
+        char *name;
+        int is_namemap;         /* Nonzero if this entry maps long names.  */
+        int long_name = 0;
+#endif
+        long int eltsize;
+        unsigned int eltmode;
+        long int fnval;
+        off_t o;
+        EINTRLOOP (o, lseek (desc, member_offset, 0));
+        if (o < 0)
+          {
+            (void) close (desc);
+            return -2;
+          }
 #ifdef AIAMAG
 …
 #ifdef AIAMAGBIG
         if (big_archive)
+          {
             nread = read (desc, &member_header_big,
                           AR_MEMHDR_SZ(member_header_big) );
             if (nread != AR_MEMHDR_SZ(member_header_big))
+              {
                 (void) close (desc);
                 return -2;
+              }
             sscanf (member_header_big.ar_namlen, "%4d", &name_len);
             nread = read (desc, name, name_len);
             if (nread != name_len)
+              {
                 (void) close (desc);
                 return -2;
+              }
             name[name_len] = 0;
             sscanf (member_header_big.ar_date, "%12ld", &dateval);
             sscanf (member_header_big.ar_uid, "%12d", &uidval);
             sscanf (member_header_big.ar_gid, "%12d", &gidval);
             sscanf (member_header_big.ar_mode, "%12o", &eltmode);
             sscanf (member_header_big.ar_size, "%20ld", &eltsize);
             data_offset = (member_offset + AR_MEMHDR_SZ(member_header_big)
                            + name_len + 2);
+          }
         else
 #endif
+          {
             nread = read (desc, &member_header,
                           AR_MEMHDR_SZ(member_header) );
             if (nread != AR_MEMHDR_SZ(member_header))
+              {
                 (void) close (desc);
                 return -2;
+              }
             sscanf (member_header.ar_namlen, "%4d", &name_len);
             nread = read (desc, name, name_len);
             if (nread != name_len)
+              {
                 (void) close (desc);
                 return -2;
+              }
             name[name_len] = 0;
             sscanf (member_header.ar_date, "%12ld", &dateval);
             sscanf (member_header.ar_uid, "%12d", &uidval);
             sscanf (member_header.ar_gid, "%12d", &gidval);
             sscanf (member_header.ar_mode, "%12o", &eltmode);
             sscanf (member_header.ar_size, "%12ld", &eltsize);
             data_offset = (member_offset + AR_MEMHDR_SZ(member_header)
                            + name_len + 2);
+          }
         data_offset += data_offset % 2;
         fnval =
           (*function) (desc, name, 0,
                        member_offset, data_offset, eltsize,
                        dateval, uidval, gidval,
                        eltmode, arg);
 #else   /* Not AIAMAG.  */
         nread = read (desc, &member_header, AR_HDR_SIZE);
         if (nread == 0)
           /* No data left means end of file; that is OK.  */
           break;
         if (nread != AR_HDR_SIZE
+        if (big_archive)
+          {
+            EINTRLOOP (nread, read (desc, &member_header_big,
+                                    AR_MEMHDR_SZ(member_header_big)));
+            if (nread != AR_MEMHDR_SZ(member_header_big))
+              {
+                (void) close (desc);
+                return -2;
+              }
+            sscanf (member_header_big.ar_namlen, "%4d", &name_len);
+            EINTRLOOP (nread, read (desc, name, name_len));
+            if (nread != name_len)
+              {
+                (void) close (desc);
+                return -2;
+              }
+            name[name_len] = 0;
+            sscanf (member_header_big.ar_date, "%12ld", &dateval);
+            sscanf (member_header_big.ar_uid, "%12d", &uidval);
+            sscanf (member_header_big.ar_gid, "%12d", &gidval);
+            sscanf (member_header_big.ar_mode, "%12o", &eltmode);
+            sscanf (member_header_big.ar_size, "%20ld", &eltsize);
+            data_offset = (member_offset + AR_MEMHDR_SZ(member_header_big)
+                           + name_len + 2);
+          }
+        else
+#endif
+          {
+            EINTRLOOP (nread, read (desc, &member_header,
+                                    AR_MEMHDR_SZ(member_header)));
+            if (nread != AR_MEMHDR_SZ(member_header))
+              {
+                (void) close (desc);
+                return -2;
+              }
+            sscanf (member_header.ar_namlen, "%4d", &name_len);
+            EINTRLOOP (nread, read (desc, name, name_len));
+            if (nread != name_len)
+              {
+                (void) close (desc);
+                return -2;
+              }
+            name[name_len] = 0;
+            sscanf (member_header.ar_date, "%12ld", &dateval);
+            sscanf (member_header.ar_uid, "%12d", &uidval);
+            sscanf (member_header.ar_gid, "%12d", &gidval);
+            sscanf (member_header.ar_mode, "%12o", &eltmode);
+            sscanf (member_header.ar_size, "%12ld", &eltsize);
+            data_offset = (member_offset + AR_MEMHDR_SZ(member_header)
+                           + name_len + 2);
+          }
+        data_offset += data_offset % 2;
+        fnval =
+          (*function) (desc, name, 0,
+                       member_offset, data_offset, eltsize,
+                       dateval, uidval, gidval,
+                       eltmode, arg);
+#else   /* Not AIAMAG.  */
+        EINTRLOOP (nread, read (desc, &member_header, AR_HDR_SIZE));
+        if (nread == 0)
+          /* No data left means end of file; that is OK.  */
+          break;
+        if (nread != AR_HDR_SIZE
 #if defined(ARFMAG) || defined(ARFZMAG)
             || (
+            || (
 # ifdef ARFMAG
                 memcmp (member_header.ar_fmag, ARFMAG, 2)
 …
+               )
 #endif
+            )
+          {
             (void) close (desc);
             return -2;
+          }
         name = namebuf;
         memcpy (name, member_header.ar_name, sizeof member_header.ar_name);
+        {
           register char *p = name + sizeof member_header.ar_name;
           do
             *p = '\0';
           while (p > name && *--p == ' ');
+            )
+          {
+            (void) close (desc);
+            return -2;
+          }
+        name = namebuf;
+        memcpy (name, member_header.ar_name, sizeof member_header.ar_name);
+        {
+          register char *p = name + sizeof member_header.ar_name;
+          do
+            *p = '\0';
+          while (p > name && *--p == ' ');
 #ifndef AIAMAG
           /* If the member name is "//" or "ARFILENAMES/" this may be
              a list of file name mappings.  The maximum file name
              length supported by the standard archive format is 14
              characters.  This member will actually always be the
              first or second entry in the archive, but we don't check
              that.  */
           is_namemap = (!strcmp (name, "//")
                         || !strcmp (name, "ARFILENAMES/"));
 #endif  /* Not AIAMAG. */
           /* On some systems, there is a slash after each member name.  */
           if (*p == '/')
             *p = '\0';
+          /* If the member name is "//" or "ARFILENAMES/" this may be
+             a list of file name mappings.  The maximum file name
+             length supported by the standard archive format is 14
+             characters.  This member will actually always be the
+             first or second entry in the archive, but we don't check
+             that.  */
+          is_namemap = (!strcmp (name, "//")
+                        || !strcmp (name, "ARFILENAMES/"));
+#endif  /* Not AIAMAG. */
+          /* On some systems, there is a slash after each member name.  */
+          if (*p == '/')
+            *p = '\0';
 #ifndef AIAMAG
           /* If the member name starts with a space or a slash, this
              is an index into the file name mappings (used by GNU ar).
              Otherwise if the member name looks like #1/NUMBER the
              real member name appears in the element data (used by
 .4BSD).  */
           if (! is_namemap
               && (name[0] == ' ' || name[0] == '/')
               && namemap != 0)
+            {
               name = namemap + atoi (name + 1);
               long_name = 1;
+            }
           else if (name[0] == '#'
                    && name[1] == '1'
                    && name[2] == '/')
+            {
               int namesize = atoi (name + 3);
               name = alloca (namesize + 1);
               nread = read (desc, name, namesize);
               if (nread != namesize)
+                {
                   close (desc);
                   return -2;
+                }
               name[namesize] = '\0';
               long_name = 1;
+            }
+          /* If the member name starts with a space or a slash, this
+             is an index into the file name mappings (used by GNU ar).
+             Otherwise if the member name looks like #1/NUMBER the
+             real member name appears in the element data (used by
+.4BSD).  */
+          if (! is_namemap
+              && (name[0] == ' ' || name[0] == '/')
+              && namemap != 0)
+            {
+              name = namemap + atoi (name + 1);
+              long_name = 1;
+            }
+          else if (name[0] == '#'
+                   && name[1] == '1'
+                   && name[2] == '/')
+            {
+              int namesize = atoi (name + 3);
+              name = alloca (namesize + 1);
+              EINTRLOOP (nread, read (desc, name, namesize));
+              if (nread != namesize)
+                {
+                  close (desc);
+                  return -2;
+                }
+              name[namesize] = '\0';
+              long_name = 1;
+            }
 #endif /* Not AIAMAG. */
+        }
 #ifndef M_XENIX
         sscanf (TOCHAR (member_header.ar_mode), "%o", &eltmode);
         eltsize = atol (TOCHAR (member_header.ar_size));
 #else   /* Xenix.  */
         eltmode = (unsigned short int) member_header.ar_mode;
         eltsize = member_header.ar_size;
 #endif  /* Not Xenix.  */
         fnval =
           (*function) (desc, name, ! long_name, member_offset,
                        member_offset + AR_HDR_SIZE, eltsize,
 #ifndef M_XENIX
                        atol (TOCHAR (member_header.ar_date)),
                        atoi (TOCHAR (member_header.ar_uid)),
                        atoi (TOCHAR (member_header.ar_gid)),
 #else   /* Xenix.  */
                        member_header.ar_date,
                        member_header.ar_uid,
                        member_header.ar_gid,
 #endif  /* Not Xenix.  */
                        eltmode, arg);
+        }
+#ifndef M_XENIX
+        sscanf (TOCHAR (member_header.ar_mode), "%o", &eltmode);
+        eltsize = atol (TOCHAR (member_header.ar_size));
+#else   /* Xenix.  */
+        eltmode = (unsigned short int) member_header.ar_mode;
+        eltsize = member_header.ar_size;
+#endif  /* Not Xenix.  */
+        fnval =
+          (*function) (desc, name, ! long_name, member_offset,
+                       member_offset + AR_HDR_SIZE, eltsize,
+#ifndef M_XENIX
+                       atol (TOCHAR (member_header.ar_date)),
+                       atoi (TOCHAR (member_header.ar_uid)),
+                       atoi (TOCHAR (member_header.ar_gid)),
+#else   /* Xenix.  */
+                       member_header.ar_date,
+                       member_header.ar_uid,
+                       member_header.ar_gid,
+#endif  /* Not Xenix.  */
+                       eltmode, arg);
 #endif  /* AIAMAG.  */
         if (fnval)
+          {
             (void) close (desc);
             return fnval;
+          }
+        if (fnval)
+          {
+            (void) close (desc);
+            return fnval;
+          }
 #ifdef AIAMAG
         if (member_offset == last_member_offset)
           /* End of the chain.  */
           break;
+        if (member_offset == last_member_offset)
+          /* End of the chain.  */
+          break;
 #ifdef AIAMAGBIG
         if (big_archive)
+        if (big_archive)
          sscanf (member_header_big.ar_nxtmem, "%20ld", &member_offset);
         else
 #endif
           sscanf (member_header.ar_nxtmem, "%12ld", &member_offset);
         if (lseek (desc, member_offset, 0) != member_offset)
+          {
             (void) close (desc);
             return -2;
+          }
 #else
         /* If this member maps archive names, we must read it in.  The
            name map will always precede any members whose names must
            be mapped.  */
         if (is_namemap)
+          {
             char *clear;
             char *limit;
             namemap = alloca (eltsize);
             nread = read (desc, namemap, eltsize);
             if (nread != eltsize)
+              {
                 (void) close (desc);
                 return -2;
+              }
             /* The names are separated by newlines.  Some formats have
                a trailing slash.  Null terminate the strings for
                convenience.  */
             limit = namemap + eltsize;
             for (clear = namemap; clear < limit; clear++)
+              {
                 if (*clear == '\n')
+                  {
                     *clear = '\0';
                     if (clear[-1] == '/')
                       clear[-1] = '\0';
+                  }
+              }
             is_namemap = 0;
+          }
         member_offset += AR_HDR_SIZE + eltsize;
         if (member_offset % 2 != 0)
           member_offset++;
+        else
+#endif
+          sscanf (member_header.ar_nxtmem, "%12ld", &member_offset);
+        if (lseek (desc, member_offset, 0) != member_offset)
+          {
+            (void) close (desc);
+            return -2;
+          }
+#else
+        /* If this member maps archive names, we must read it in.  The
+           name map will always precede any members whose names must
+           be mapped.  */
+        if (is_namemap)
+          {
+            char *clear;
+            char *limit;
+            namemap = alloca (eltsize);
+            EINTRLOOP (nread, read (desc, namemap, eltsize));
+            if (nread != eltsize)
+              {
+                (void) close (desc);
+                return -2;
+              }
+            /* The names are separated by newlines.  Some formats have
+               a trailing slash.  Null terminate the strings for
+               convenience.  */
+            limit = namemap + eltsize;
+            for (clear = namemap; clear < limit; clear++)
+              {
+                if (*clear == '\n')
+                  {
+                    *clear = '\0';
+                    if (clear[-1] == '/')
+                      clear[-1] = '\0';
+                  }
+              }
+            is_namemap = 0;
+          }
+        member_offset += AR_HDR_SIZE + eltsize;
+        if (member_offset % 2 != 0)
+          member_offset++;
 #endif
+      }
 …
       struct ar_hdr hdr;
 #if !defined (__hpux) && !defined (cray)
       return strneq (name, mem, sizeof(hdr.ar_name) - 1);
 #else
       return strneq (name, mem, sizeof(hdr.ar_name) - 2);
+      return strneq (name, mem, sizeof (hdr.ar_name) - 1);
+#else
+      return strneq (name, mem, sizeof (hdr.ar_name) - 2);
 #endif /* !__hpux && !cray */
 #endif /* !AIAMAG */
+    }
+  return !strcmp (name, mem);
+#else
+  /* VMS members do not have suffixes, but the filenames usually
+     have.
+     Do we need to strip VMS disk/directory format paths?
+     Most VMS compilers etc. by default are case insensitive
+     but produce uppercase external names, incl. module names.
+     However the VMS librarian (ar) and the linker by default
+     are case sensitive: they take what they get, usually
+     uppercase names. So for the non-default settings of the
+     compilers etc. there is a need to have a case sensitive
+     mode. */
+  {
+    int len;
+    len = strlen(mem);
+    int match;
+    char *dot;
+    if ((dot=strrchr(name,'.')))
+      match = (len == dot - name) && !strncasecmp(name, mem, len);
+    else
+      match = !strcasecmp (name, mem);
+    return match;
+  }
 #endif /* !VMS */
-  return !strcmp (name, mem);
+}
 …
 static long int
 ar_member_pos (int desc UNUSED, const char *mem, int truncated,
                long int hdrpos, long int datapos UNUSED, long int size UNUSED,
+               long int hdrpos, long int datapos UNUSED, long int size UNUSED,
                long int date UNUSED, int uid UNUSED, int gid UNUSED,
                int mode UNUSED, const void *name)
+               unsigned int mode UNUSED, const void *name)
+{
   if (!ar_name_equal (name, mem, truncated))
 …
   int fd;
   struct ar_hdr ar_hdr;
+  int i;
+  off_t o;
+  int r;
   unsigned int ui;
   struct stat statbuf;
 …
     return 1;
   fd = open (arname, O_RDWR, 0666);
+  EINTRLOOP (fd, open (arname, O_RDWR, 0666));
   if (fd < 0)
     return -3;
   /* Read in this member's header */
+  if (lseek (fd, pos, 0) < 0)
+  EINTRLOOP (o, lseek (fd, pos, 0));
+  if (o < 0)
     goto lose;
+  if (AR_HDR_SIZE != read (fd, &ar_hdr, AR_HDR_SIZE))
+  EINTRLOOP (r, read (fd, &ar_hdr, AR_HDR_SIZE));
+  if (r != AR_HDR_SIZE)
     goto lose;
   /* Write back the header, thus touching the archive file.  */
+  if (lseek (fd, pos, 0) < 0)
+  EINTRLOOP (o, lseek (fd, pos, 0));
+  if (o < 0)
     goto lose;
+  if (AR_HDR_SIZE != write (fd, &ar_hdr, AR_HDR_SIZE))
+  EINTRLOOP (r, write (fd, &ar_hdr, AR_HDR_SIZE));
+  if (r != AR_HDR_SIZE)
     goto lose;
   /* The file's mtime is the time we we want.  */
   EINTRLOOP (i, fstat (fd, &statbuf));
   if (i < 0)
+  EINTRLOOP (r, fstat (fd, &statbuf));
+  if (r < 0)
     goto lose;
 #if defined(ARFMAG) || defined(ARFZMAG) || defined(AIAMAG) || defined(WINDOWS32)
 …
   for (ui = 0; ui < sizeof ar_hdr.ar_date; ui++)
     ar_hdr.ar_date[ui] = ' ';
   sprintf (TOCHAR (ar_hdr.ar_date), "%ld", (long int) statbuf.st_mtime);
+  sprintf (TOCHAR (ar_hdr.ar_date), "%lu", (long unsigned) statbuf.st_mtime);
 #ifdef AIAMAG
   ar_hdr.ar_date[strlen(ar_hdr.ar_date)] = ' ';
+  ar_hdr.ar_date[strlen (ar_hdr.ar_date)] = ' ';
 #endif
 #else
 …
 #endif
   /* Write back this member's header */
+  if (lseek (fd, pos, 0) < 0)
+  EINTRLOOP (o, lseek (fd, pos, 0));
+  if (o < 0)
     goto lose;
+  if (AR_HDR_SIZE != write (fd, &ar_hdr, AR_HDR_SIZE))
+  EINTRLOOP (r, write (fd, &ar_hdr, AR_HDR_SIZE));
+  if (r != AR_HDR_SIZE)
     goto lose;
   close (fd);
 …
  lose:
   i = errno;
+  r = errno;
   close (fd);
   errno = i;
+  errno = r;
   return -3;
+}
 …
 long int
 describe_member (int desc, const char *name, int truncated,
+                 long int hdrpos, long int datapos, long int size,
+                 long int date, int uid, int gid, int mode, const void *arg)
+                 long int hdrpos, long int datapos, long int size,
+                 long int date, int uid, int gid, unsigned int mode,
+                 const void *arg)
+{
   extern char *ctime ();
   printf (_("Member `%s'%s: %ld bytes at %ld (%ld).\n"),
           name, truncated ? _(" (name might be truncated)") : "",
           size, hdrpos, datapos);
+  printf (_("Member '%s'%s: %ld bytes at %ld (%ld).\n"),
+          name, truncated ? _(" (name might be truncated)") : "",
+          size, hdrpos, datapos);
   printf (_("  Date %s"), ctime (&date));
   printf (_("  uid = %d, gid = %d, mode = 0%o.\n"), uid, gid, mode);
 …
+}
 #endif  /* TEST.  */
 #endif  /* NO_ARCHIVES.  */
+#endif  /* TEST.  */
+#endif  /* NO_ARCHIVES.  */

vendor/gnumake/current/build.template

-              r2596
+              r3138
 #!/bin/sh
 # Shell script to build GNU Make in the absence of any `make' program.
+# Shell script to build GNU Make in the absence of any 'make' program.
 # @configure_input@
+# Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+# Copyright (C) 1993-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 srcdir='@srcdir@'
 CC='@CC@'
 CFLAGS='@CFLAGS@'
+CFLAGS='@CFLAGS@ @GUILE_CFLAGS@'
 CPPFLAGS='@CPPFLAGS@'
 LDFLAGS='@LDFLAGS@'
+LDFLAGS='@AM_LDFLAGS@ @LDFLAGS@'
 ALLOCA='@ALLOCA@'
 LOADLIBES='@LIBS@ @LIBINTL@'
+LOADLIBES='@LIBS@ @GUILE_LIBS@ @LIBINTL@'
 eval extras=\'@LIBOBJS@\'
 REMOTE='@REMOTE@'
 …
 # Common prefix for machine-dependent installed files.
 exec_prefix=`eval echo @exec_prefix@`
 # Directory to find libraries in for `-lXXX'.
+# Directory to find libraries in for '-lXXX'.
 libdir=${exec_prefix}/lib
 # Directory to search by default for included makefiles.
 …
 aliaspath=${localedir}${PATH_SEPARATOR}.
 defines="-DALIASPATH=\"${aliaspath}\" -DLOCALEDIR=\"${localedir}\" -DLIBDIR=\"${libdir}\" -DINCLUDEDIR=\"${includedir}\""' @DEFS@'
+defines="-DLOCALEDIR=\"${localedir}\" -DLIBDIR=\"${libdir}\" -DINCLUDEDIR=\"${includedir}\""' @DEFS@'
 # Exit as soon as any command fails.

vendor/gnumake/current/build_w32.bat

-              r2596
+              r3138
 @echo off
+rem Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+rem 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+rem Copyright (C) 1996-2016 Free Software Foundation, Inc.
 rem This file is part of GNU Make.
 rem
 …
 rem with this program.  If not, see <http://www.gnu.org/licenses/>.
+if exist config.h.W32 GoTo NotCVS
+sed -n "s/^AC_INIT(\[GNU make\],\[\([^]]\+\)\].*/s,%%VERSION%%,\1,g/p" configure.in > config.h.W32.sed
+echo s,%%PACKAGE%%,make,g >> config.h.W32.sed
+sed -f config.h.W32.sed config.h.W32.template > config.h.W32
+:NotCVS
+if not exist config.h copy config.h.W32 config.h
+cd w32\subproc
+echo "Creating the subproc library"
+%ComSpec% /c build.bat %1
+cd ..\..
+if exist link.dbg del link.dbg
+if exist link.rel del link.rel
+echo "Creating GNU Make for Windows 9X/NT/2K/XP"
+if "%1" == "gcc" GoTo GCCBuild
+set make=gnumake
+echo on
+if not exist .\WinDebug\nul mkdir .\WinDebug
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D TIVOLI /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c variable.c
+echo WinDebug\variable.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c rule.c
+echo WinDebug\rule.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c remote-stub.c
+echo WinDebug\remote-stub.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c commands.c
+echo WinDebug\commands.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c file.c
+echo WinDebug\file.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c getloadavg.c
+echo WinDebug\getloadavg.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c default.c
+echo WinDebug\default.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c signame.c
+echo WinDebug\signame.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c expand.c
+echo WinDebug\expand.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c dir.c
+echo WinDebug\dir.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c main.c
+echo WinDebug\main.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c getopt1.c
+echo WinDebug\getopt1.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c job.c
+echo WinDebug\job.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c read.c
+echo WinDebug\read.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c version.c
+echo WinDebug\version.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c getopt.c
+echo WinDebug\getopt.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c arscan.c
+echo WinDebug\arscan.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c hash.c
+echo WinDebug\hash.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c strcache.c
+echo WinDebug\strcache.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c remake.c
+echo WinDebug\remake.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c misc.c
+echo WinDebug\misc.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c ar.c
+echo WinDebug\ar.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c function.c
+echo WinDebug\function.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c vpath.c
+echo WinDebug\vpath.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c implicit.c
+echo WinDebug\implicit.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c  .\w32\compat\dirent.c
+echo WinDebug\dirent.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c  .\glob\glob.c
+echo WinDebug\glob.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c  .\glob\fnmatch.c
+echo WinDebug\fnmatch.obj >>link.dbg
+cl.exe /nologo /MT /W4 /GX /Zi /YX /Od /I . /I glob /I w32/include /D _DEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinDebug/ /Fp.\WinDebug/%make%.pch /Fo.\WinDebug/ /Fd.\WinDebug/%make%.pdb /c  .\w32\pathstuff.c
+echo WinDebug\pathstuff.obj >>link.dbg
+echo off
+echo "Linking WinDebug/%make%.exe"
+rem link.exe kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib w32\subproc\windebug\subproc.lib /NOLOGO /SUBSYSTEM:console /INCREMENTAL:yes /PDB:.\WinDebug/%make%.pdb /DEBUG /OUT:.\WinDebug/%make%.exe .\WinDebug/variable.obj  .\WinDebug/rule.obj  .\WinDebug/remote-stub.obj  .\WinDebug/commands.obj  .\WinDebug/file.obj  .\WinDebug/getloadavg.obj  .\WinDebug/default.obj  .\WinDebug/signame.obj  .\WinDebug/expand.obj  .\WinDebug/dir.obj  .\WinDebug/main.obj  .\WinDebug/getopt1.obj  .\WinDebug/job.obj  .\WinDebug/read.obj  .\WinDebug/version.obj  .\WinDebug/getopt.obj  .\WinDebug/arscan.obj  .\WinDebug/remake.obj  .\WinDebug/hash.obj  .\WinDebug/strcache.obj  .\WinDebug/misc.obj  .\WinDebug/ar.obj  .\WinDebug/function.obj  .\WinDebug/vpath.obj  .\WinDebug/implicit.obj  .\WinDebug/dirent.obj  .\WinDebug/glob.obj  .\WinDebug/fnmatch.obj  .\WinDebug/pathstuff.obj
+echo kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib w32\subproc\windebug\subproc.lib >>link.dbg
+link.exe /NOLOGO /SUBSYSTEM:console /INCREMENTAL:yes /PDB:.\WinDebug/%make%.pdb /DEBUG /OUT:.\WinDebug/%make%.exe @link.dbg
+if not exist .\WinDebug/%make%.exe echo "WinDebug build failed"
+if exist .\WinDebug/%make%.exe echo "WinDebug build succeeded!"
+if not exist .\WinRel\nul mkdir .\WinRel
+echo on
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /D TIVOLI /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c variable.c
+echo WinRel\variable.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c rule.c
+echo WinRel\rule.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c remote-stub.c
+echo WinRel\remote-stub.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c commands.c
+echo WinRel\commands.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c file.c
+echo WinRel\file.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c getloadavg.c
+echo WinRel\getloadavg.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c default.c
+echo WinRel\default.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c signame.c
+echo WinRel\signame.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c expand.c
+echo WinRel\expand.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c dir.c
+echo WinRel\dir.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c main.c
+echo WinRel\main.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c getopt1.c
+echo WinRel\getopt1.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c job.c
+echo WinRel\job.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c read.c
+echo WinRel\read.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c version.c
+echo WinRel\version.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c getopt.c
+echo WinRel\getopt.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c arscan.c
+echo WinRel\arscan.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c remake.c
+echo WinRel\remake.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c hash.c
+echo WinRel\hash.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c strcache.c
+echo WinRel\strcache.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c misc.c
+echo WinRel\misc.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c ar.c
+echo WinRel\ar.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c function.c
+echo WinRel\function.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c vpath.c
+echo WinRel\vpath.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c implicit.c
+echo WinRel\implicit.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c  .\w32\compat\dirent.c
+echo WinRel\dirent.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c  .\glob\glob.c
+echo WinRel\glob.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c  .\glob\fnmatch.c
+echo WinRel\fnmatch.obj >>link.rel
+cl.exe /nologo /MT /W4 /GX /YX /O2 /I . /I glob /I w32/include /D NDEBUG /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR.\WinRel/ /Fp.\WinRel/%make%.pch /Fo.\WinRel/ /c  .\w32\pathstuff.c
+echo WinRel\pathstuff.obj >>link.rel
+echo off
+echo "Linking WinRel/%make%.exe"
+rem link.exe kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib w32\subproc\winrel\subproc.lib /NOLOGO /SUBSYSTEM:console /INCREMENTAL:no /PDB:.\WinRel/%make%.pdb /OUT:.\WinRel/%make%.exe .\WinRel/variable.obj  .\WinRel/rule.obj  .\WinRel/remote-stub.obj  .\WinRel/commands.obj  .\WinRel/file.obj  .\WinRel/getloadavg.obj  .\WinRel/default.obj  .\WinRel/signame.obj  .\WinRel/expand.obj  .\WinRel/dir.obj  .\WinRel/main.obj  .\WinRel/getopt1.obj  .\WinRel/job.obj  .\WinRel/read.obj  .\WinRel/version.obj  .\WinRel/getopt.obj  .\WinRel/arscan.obj  .\WinRel/remake.obj  .\WinRel/misc.obj  .\WinRel/hash.obj  .\WinRel/strcache.obj  .\WinRel/ar.obj  .\WinRel/function.obj  .\WinRel/vpath.obj  .\WinRel/implicit.obj  .\WinRel/dirent.obj  .\WinRel/glob.obj  .\WinRel/fnmatch.obj  .\WinRel/pathstuff.obj
+echo kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib w32\subproc\winrel\subproc.lib >>link.rel
+link.exe /NOLOGO /SUBSYSTEM:console /INCREMENTAL:no /PDB:.\WinRel/%make%.pdb /OUT:.\WinRel/%make%.exe @link.rel
+if not exist .\WinRel/%make%.exe echo "WinRel build failed"
+if exist .\WinRel/%make%.exe echo "WinRel build succeeded!"
+set make=
+GoTo BuildEnd
+:GCCBuild
+echo on
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c variable.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c rule.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c remote-stub.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c commands.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c file.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c getloadavg.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c default.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c signame.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c expand.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c dir.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c main.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c getopt1.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c job.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c read.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c version.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c getopt.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c arscan.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c remake.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c hash.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c strcache.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c misc.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c ar.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c function.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c vpath.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c implicit.c
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c ./glob/glob.c -o glob.o
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c ./glob/fnmatch.c -o fnmatch.o
+gcc -mthreads -Wall -gdwarf-2 -g3 -O2 -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H -c ./w32/pathstuff.c -o pathstuff.o
+gcc -mthreads -gdwarf-2 -g3 -o gnumake.exe variable.o rule.o remote-stub.o commands.o file.o getloadavg.o default.o signame.o expand.o dir.o main.o getopt1.o job.o read.o version.o getopt.o arscan.o remake.o misc.o hash.o strcache.o ar.o function.o vpath.o implicit.o glob.o fnmatch.o pathstuff.o w32_misc.o sub_proc.o w32err.o -lkernel32 -luser32 -lgdi32 -lwinspool -lcomdlg32 -ladvapi32 -lshell32 -lole32 -loleaut32 -luuid -lodbc32 -lodbccp32
+:BuildEnd
+echo on
+call :Reset
+if "%1" == "-h" goto Usage
+if "%1" == "--help" goto Usage
+set MAKE=gnumake
+set GUILE=Y
+set COMPILER=msvc
+:ParseSW
+if "%1" == "--debug" goto SetDebug
+if "%1" == "--without-guile" goto NoGuile
+if "%1" == "gcc" goto SetCC
+if "%1" == "" goto DoneSW
+:SetDebug
+set DEBUG=Y
+shift
+goto ParseSW
+:NoGuile
+set GUILE=N
+echo Building without Guile
+shift
+goto ParseSW
+:SetCC
+set COMPILER=gcc
+echo Building with GCC
+shift
+goto ParseSW
+rem Build with Guile is supported only on NT and later versions
+:DoneSW
+echo.
+echo Creating GNU Make for Windows 9X/NT/2K/XP/Vista/7/8
+if "%DEBUG%" == "Y" echo Building without compiler optimizations
+if "%COMPILER%" == "gcc" goto GccBuild
+set OUTDIR=.\WinRel
+set "OPTS=/O2 /D NDEBUG"
+set LINKOPTS=
+if "%DEBUG%" == "Y" set OUTDIR=.\WinDebug
+if "%DEBUG%" == "Y" set "OPTS=/Zi /Od /D _DEBUG"
+if "%DEBUG%" == "Y" set LINKOPTS=/DEBUG
+call :Build
+goto Done
+:GccBuild
+set OUTDIR=.\GccRel
+set OPTS=-O2
+if "%DEBUG%" == "Y" set OPTS=-O0
+if "%DEBUG%" == "Y" set OUTDIR=.\GccDebug
+call :Build
+goto Done
+:Done
+call :Reset
+goto :EOF
+:Build
+:: Clean the directory if it exists
+if exist %OUTDIR%\nul rmdir /S /Q %OUTDIR%
+:: Recreate it
+mkdir %OUTDIR%
+mkdir %OUTDIR%\glob
+mkdir %OUTDIR%\w32
+mkdir %OUTDIR%\w32\compat
+mkdir %OUTDIR%\w32\subproc
+if "%GUILE%" == "Y" call :ChkGuile
+echo.
+echo Compiling %OUTDIR% version
+if exist config.h.W32.template call :ConfigSCM
+copy config.h.W32 %OUTDIR%\config.h
+call :Compile ar
+call :Compile arscan
+call :Compile commands
+call :Compile default
+call :Compile dir
+call :Compile expand
+call :Compile file
+call :Compile function
+call :Compile getloadavg
+call :Compile getopt
+call :Compile getopt1
+call :Compile glob\fnmatch
+call :Compile glob\glob
+call :Compile guile GUILE
+call :Compile hash
+call :Compile implicit
+call :Compile job
+call :Compile load
+call :Compile loadapi
+call :Compile main GUILE
+call :Compile misc
+call :Compile output
+call :Compile read
+call :Compile remake
+call :Compile remote-stub
+call :Compile rule
+call :Compile signame
+call :Compile strcache
+call :Compile variable
+call :Compile version
+call :Compile vpath
+call :Compile w32\compat\posixfcn
+call :Compile w32\pathstuff
+call :Compile w32\subproc\misc
+call :Compile w32\subproc\sub_proc
+call :Compile w32\subproc\w32err
+call :Compile w32\w32os
+if not "%COMPILER%" == "gcc" call :Compile w32\compat\dirent
+call :Link
+echo.
+if not exist %OUTDIR%\%MAKE%.exe echo %OUTDIR% build FAILED!
+if exist %OUTDIR%\%MAKE%.exe echo %OUTDIR% build succeeded.
+goto :EOF
+:Compile
+set EXTRAS=
+if "%2" == "GUILE" set "EXTRAS=%GUILECFLAGS%"
+if "%COMPILER%" == "gcc" goto GccCompile
+:: MSVC Compile
+echo on
+cl.exe /nologo /MT /W4 /EHsc %OPTS% /I %OUTDIR% /I . /I glob /I w32/include /D WINDOWS32 /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H /FR%OUTDIR% /Fp%OUTDIR%\%MAKE%.pch /Fo%OUTDIR%\%1.obj /Fd%OUTDIR%\%MAKE%.pdb %EXTRAS% /c %1.c
+@echo off
+echo %OUTDIR%\%1.obj >>%OUTDIR%\link.sc
+goto :EOF
+:GccCompile
+:: GCC Compile
+echo on
+gcc -mthreads -Wall -std=gnu99 -gdwarf-2 -g3 %OPTS% -I%OUTDIR% -I. -I./glob -I./w32/include -DWINDOWS32 -DHAVE_CONFIG_H %EXTRAS% -o %OUTDIR%\%1.o -c %1.c
+@echo off
+goto :EOF
+:Link
+echo Linking %OUTDIR%/%MAKE%.exe
+if "%COMPILER%" == "gcc" goto GccLink
+:: MSVC Link
+echo %GUILELIBS% kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib >>%OUTDIR%\link.sc
+echo on
+link.exe /NOLOGO /SUBSYSTEM:console /PDB:%OUTDIR%\%MAKE%.pdb %LINKOPTS% /OUT:%OUTDIR%\%MAKE%.exe @%OUTDIR%\link.sc
+@echo off
+goto :EOF
+:GccLink
+:: GCC Link
+echo on
+gcc -mthreads -gdwarf-2 -g3 -o %OUTDIR%\%MAKE%.exe %OUTDIR%\variable.o %OUTDIR%\rule.o %OUTDIR%\remote-stub.o %OUTDIR%\commands.o %OUTDIR%\file.o %OUTDIR%\getloadavg.o %OUTDIR%\default.o %OUTDIR%\signame.o %OUTDIR%\expand.o %OUTDIR%\dir.o %OUTDIR%\main.o %OUTDIR%\getopt1.o %OUTDIR%\guile.o %OUTDIR%\job.o %OUTDIR%\output.o %OUTDIR%\read.o %OUTDIR%\version.o %OUTDIR%\getopt.o %OUTDIR%\arscan.o %OUTDIR%\remake.o %OUTDIR%\misc.o %OUTDIR%\hash.o %OUTDIR%\strcache.o %OUTDIR%\ar.o %OUTDIR%\function.o %OUTDIR%\vpath.o %OUTDIR%\implicit.o %OUTDIR%\loadapi.o %OUTDIR%\load.o %OUTDIR%\glob\glob.o %OUTDIR%\glob\fnmatch.o %OUTDIR%\w32\pathstuff.o %OUTDIR%\w32\compat\posixfcn.o %OUTDIR%\w32\w32os.o %OUTDIR%\w32\subproc\misc.o %OUTDIR%\w32\subproc\sub_proc.o %OUTDIR%\w32\subproc\w32err.o %GUILELIBS% -lkernel32 -luser32 -lgdi32 -lwinspool -lcomdlg32 -ladvapi32 -lshell32 -lole32 -loleaut32 -luuid -lodbc32 -lodbccp32 -Wl,--out-implib=%OUTDIR%\libgnumake-1.dll.a
+@echo off
+goto :EOF
+:ConfigSCM
+echo Generating config from SCM templates
+sed -n "s/^AC_INIT(\[GNU make\],\[\([^]]\+\)\].*/s,%%VERSION%%,\1,g/p" configure.ac > %OUTDIR%\config.h.W32.sed
+echo s,%%PACKAGE%%,make,g >> %OUTDIR%\config.h.W32.sed
+sed -f %OUTDIR%\config.h.W32.sed config.h.W32.template > config.h.W32
+echo static const char *const GUILE_module_defn = ^" \> gmk-default.h
+sed -e "s/;.*//" -e "/^[ \t]*$/d" -e "s/\"/\\\\\"/g" -e "s/$/ \\\/" gmk-default.scm >> gmk-default.h
+echo ^";>> gmk-default.h
+goto :EOF
+:ChkGuile
+if not "%OS%" == "Windows_NT" goto NoGuile
+pkg-config --help > %OUTDIR%\guile.tmp 2> NUL
+if ERRORLEVEL 1 goto NoPkgCfg
+echo Checking for Guile 2.0
+if not "%COMPILER%" == "gcc" set PKGMSC=--msvc-syntax
+pkg-config --cflags --short-errors "guile-2.0" > %OUTDIR%\guile.tmp
+if not ERRORLEVEL 1 set /P GUILECFLAGS= < %OUTDIR%\guile.tmp
+pkg-config --libs --static --short-errors %PKGMSC% "guile-2.0" > %OUTDIR%\guile.tmp
+if not ERRORLEVEL 1 set /P GUILELIBS= < %OUTDIR%\guile.tmp
+if not "%GUILECFLAGS%" == "" goto GuileDone
+echo Checking for Guile 1.8
+pkg-config --cflags --short-errors "guile-1.8" > %OUTDIR%\guile.tmp
+if not ERRORLEVEL 1 set /P GUILECFLAGS= < %OUTDIR%\guile.tmp
+pkg-config --libs --static --short-errors %PKGMSC% "guile-1.8" > %OUTDIR%\guile.tmp
+if not ERRORLEVEL 1 set /P GUILELIBS= < %OUTDIR%\guile.tmp
+if not "%GUILECFLAGS%" == "" goto GuileDone
+echo No Guile found, building without Guile
+goto GuileDone
+:NoPkgCfg
+echo pkg-config not found, building without Guile
+:GuileDone
+if "%GUILECFLAGS%" == "" goto :EOF
+echo Guile found, building with Guile
+set "GUILECFLAGS=%GUILECFLAGS% -DHAVE_GUILE"
+goto :EOF
+:Usage
+echo Usage: %0 [options] [gcc]
+echo Options:
+echo.  --debug           For GCC only, make a debug build
+echo.                    (MSVC build always makes both debug and release)
+echo.  --without-guile   Do not compile Guile support even if found
+echo.  --help            Display these instructions and exit
+goto :EOF
+:Reset
+set COMPILER=
+set DEBUG=
+set GUILE=
+set GUILECFLAGS=
+set GUILELIBS=
+set LINKOPTS=
+set MAKE=
+set NOGUILE=
+set OPTS=
+set OUTDIR=
+set PKGMSC=
+goto :EOF

vendor/gnumake/current/commands.c

-              r2596
+              r3138
 /* Command processing for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
+#include "make.h"
+#include "makeint.h"
+#include "filedef.h"
 #include "dep.h"
-#include "filedef.h"
 #include "variable.h"
 #include "job.h"
 …
 #if VMS
 # define FILE_LIST_SEPARATOR ','
+# define FILE_LIST_SEPARATOR (vms_comma_separator ? ',' : ' ')
 #else
 # define FILE_LIST_SEPARATOR ' '
 #endif
+int remote_kill (int id, int sig);
+#ifndef HAVE_UNISTD_H
+#ifndef HAVE_UNISTD_H
 int getpid ();
 #endif
 …
   const char *at, *percent, *star, *less;
 #ifndef NO_ARCHIVES
   /* If the target is an archive member `lib(member)',
      then $@ is `lib' and $% is `member'.  */
+#ifndef NO_ARCHIVES
+  /* If the target is an archive member 'lib(member)',
+     then $@ is 'lib' and $% is 'member'.  */
   if (ar_name (file->name))
 …
+    }
   else
 #endif  /* NO_ARCHIVES.  */
+#endif  /* NO_ARCHIVES.  */
+    {
       at = file->name;
 …
+    {
       /* In Unix make, $* is set to the target name with
          any suffix in the .SUFFIXES list stripped off for
          explicit rules.  We store this in the `stem' member.  */
+         any suffix in the .SUFFIXES list stripped off for
+         explicit rules.  We store this in the 'stem' member.  */
       const char *name;
       unsigned int len;
 #ifndef NO_ARCHIVES
+#ifndef NO_ARCHIVES
       if (ar_name (file->name))
+        {
           name = strchr (file->name, '(') + 1;
           len = strlen (name) - 1;
+        }
+        {
+          name = strchr (file->name, '(') + 1;
+          len = strlen (name) - 1;
+        }
       else
 #endif
+        {
           name = file->name;
           len = strlen (name);
+        }
+        {
+          name = file->name;
+          len = strlen (name);
+        }
       for (d = enter_file (strcache_add (".SUFFIXES"))->deps; d ; d = d->next)
+        {
           unsigned int slen = strlen (dep_name (d));
           if (len > slen && strneq (dep_name (d), name + (len - slen), slen))
+            {
               file->stem = strcache_add_len (name, len - slen);
               break;
+            }
+        }
+        {
+          unsigned int slen = strlen (dep_name (d));
+          if (len > slen && strneq (dep_name (d), name + (len - slen), slen))
+            {
+              file->stem = strcache_add_len (name, len - slen);
+              break;
+            }
+        }
       if (d == 0)
         file->stem = "";
+        file->stem = "";
+    }
   star = file->stem;
 …
     less = at;
 #define DEFINE_VARIABLE(name, len, value) \
+#define DEFINE_VARIABLE(name, len, value) \
   (void) define_variable_for_file (name,len,value,o_automatic,0,file)
 …
     cp = plus_value;
     qmark_len = plus_len + 1;   /* Will be this or less.  */
+    qmark_len = plus_len + 1;   /* Will be this or less.  */
     for (d = file->deps; d != 0; d = d->next)
       if (! d->ignore_mtime && ! d->need_2nd_expansion)
 …
           const char *c = dep_name (d);
 #ifndef NO_ARCHIVES
+#ifndef NO_ARCHIVES
           if (ar_name (c))
+            {
 …
           *cp++ = FILE_LIST_SEPARATOR;
           if (! (d->changed || always_make_flag))
             qmark_len -= len + 1;       /* Don't space in $? for this one.  */
+            qmark_len -= len + 1;       /* Don't space in $? for this one.  */
+        }
 …
         c = dep_name (d);
 #ifndef NO_ARCHIVES
+#ifndef NO_ARCHIVES
         if (ar_name (c))
+          {
             c = strchr (c, '(') + 1;
             len = strlen (c) - 1;
+          }
         else
 #endif
           len = strlen (c);
+          {
+            c = strchr (c, '(') + 1;
+            len = strlen (c) - 1;
+          }
+        else
+#endif
+          len = strlen (c);
         if (d->ignore_mtime)
+          {
             memcpy (bp, c, len);
             bp += len;
             *bp++ = FILE_LIST_SEPARATOR;
+          }
         else
+            bp += len;
+            *bp++ = FILE_LIST_SEPARATOR;
+          }
+        else
+          {
             memcpy (cp, c, len);
 …
+  }
 #undef  DEFINE_VARIABLE
+#undef  DEFINE_VARIABLE
+}
 /* Chop CMDS up into individual command lines if necessary.
    Also set the `lines_flags' and `any_recurse' members.  */
+   Also set the 'lines_flags' and 'any_recurse' members.  */
 void
 …
      CMDS->any_recurse flag.  */
+  if (nlines > USHRT_MAX)
+    ON (fatal, &cmds->fileinfo, _("Recipe has too many lines (%ud)"), nlines);
   cmds->ncommand_lines = nlines;
   cmds->command_lines = lines;
 …
   for (idx = 0; idx < nlines; ++idx)
+    {
       int flags = 0;
+      unsigned char flags = 0;
       const char *p = lines[idx];
       while (isblank (*p) || *p == '-' || *p == '@' || *p == '+')
+      while (ISBLANK (*p) || *p == '-' || *p == '@' || *p == '+')
         switch (*(p++))
+          {
 …
       cmds->lines_flags[idx] = flags;
       cmds->any_recurse |= flags & COMMANDS_RECURSE;
+      cmds->any_recurse |= flags & COMMANDS_RECURSE ? 1 : 0;
+    }
+}
 …
   for (p = file->cmds->commands; *p != '\0'; ++p)
     if (!isspace ((unsigned char)*p) && *p != '-' && *p != '@')
+    if (!ISSPACE (*p) && *p != '-' && *p != '@' && *p != '+')
       break;
   if (*p == '\0')
 …
       /* If there are no commands, assume everything worked.  */
       set_command_state (file, cs_running);
       file->update_status = 0;
+      file->update_status = us_success;
       notice_finished_file (file);
       return;
 …
   set_file_variables (file);
+  /* If this is a loaded dynamic object, unload it before remaking.
+     Some systems don't support overwriting a loaded object.  */
+  if (file->loaded)
+    unload_file (file->name);
   /* Start the commands running.  */
 …
       if (susp_count != 0)
         fprintf (stderr, "SuspendThread: suspend count = %ld\n", susp_count);
+        fprintf (stderr, "SuspendThread: suspend count = %ld\n", susp_count);
       else if (susp_count == (DWORD)-1)
+        {
           DWORD ierr = GetLastError ();
           fprintf (stderr, "SuspendThread: error %ld: %s\n",
                    ierr, map_windows32_error_to_string (ierr));
+        }
+        {
+          DWORD ierr = GetLastError ();
+          fprintf (stderr, "SuspendThread: error %ld: %s\n",
+                   ierr, map_windows32_error_to_string (ierr));
+        }
+    }
 #endif
 …
       struct child *c;
       for (c = children; c != 0; c = c->next)
         if (!c->remote)
           (void) kill (c->pid, SIGTERM);
+        if (!c->remote)
+          (void) kill (c->pid, SIGTERM);
+    }
 …
       /* Remote children won't automatically get signals sent
          to the process group, so we must send them.  */
+         to the process group, so we must send them.  */
       for (c = children; c != 0; c = c->next)
         if (c->remote)
           (void) remote_kill (c->pid, sig);
+        if (c->remote)
+          (void) remote_kill (c->pid, sig);
       for (c = children; c != 0; c = c->next)
         delete_child_targets (c);
+        delete_child_targets (c);
       /* Clean up the children.  We don't just use the call below because
          we don't want to print the "Waiting for children" message.  */
+         we don't want to print the "Waiting for children" message.  */
       while (job_slots_used > 0)
         reap_children (1, 0);
+        reap_children (1, 0);
+    }
   else
 …
     /* We don't want to send ourselves SIGQUIT, because it will
        cause a core dump.  Just exit instead.  */
     exit (EXIT_FAILURE);
+    exit (MAKE_TROUBLE);
 #endif
 …
+    {
       time_t file_date = (file->last_mtime == NONEXISTENT_MTIME
                           ? (time_t) -1
                           : (time_t) FILE_TIMESTAMP_S (file->last_mtime));
+                          ? (time_t) -1
+                          : (time_t) FILE_TIMESTAMP_S (file->last_mtime));
       if (ar_member_date (file->name) != file_date)
+        {
+          if (on_behalf_of)
+            error (NILF, _("*** [%s] Archive member `%s' may be bogus; not deleted"),
+                   on_behalf_of, file->name);
+          else
+            error (NILF, _("*** Archive member `%s' may be bogus; not deleted"),
+                   file->name);
+        }
+        {
+          if (on_behalf_of)
+            OSS (error, NILF,
+                 _("*** [%s] Archive member '%s' may be bogus; not deleted"),
+                 on_behalf_of, file->name);
+          else
+            OS (error, NILF,
+                _("*** Archive member '%s' may be bogus; not deleted"),
+                file->name);
+        }
       return;
+    }
 …
+    {
       if (on_behalf_of)
+        error (NILF, _("*** [%s] Deleting file `%s'"), on_behalf_of, file->name);
+        OSS (error, NILF,
+             _("*** [%s] Deleting file '%s'"), on_behalf_of, file->name);
       else
         error (NILF, _("*** Deleting file `%s'"), file->name);
+        OS (error, NILF, _("*** Deleting file '%s'"), file->name);
       if (unlink (file->name) < 0
           && errno != ENOENT)   /* It disappeared; so what.  */
         perror_with_name ("unlink: ", file->name);
+          && errno != ENOENT)   /* It disappeared; so what.  */
+        perror_with_name ("unlink: ", file->name);
+    }
+}
 …
   delete_target (child->file, NULL);
   /* Also remove any non-precious targets listed in the `also_make' member.  */
+  /* Also remove any non-precious targets listed in the 'also_make' member.  */
   for (d = child->file->also_make; d != 0; d = d->next)
     delete_target (d->file, child->file->name);
 …
     puts (_(" (built-in):"));
   else
     printf (_(" (from `%s', line %lu):\n"),
+    printf (_(" (from '%s', line %lu):\n"),
             cmds->fileinfo.filenm, cmds->fileinfo.lineno);
 …
+    {
       const char *end;
+      end = strchr (s, '\n');
+      if (end == 0)
+        end = s + strlen (s);
+      int bs;
+      /* Print one full logical recipe line: find a non-escaped newline.  */
+      for (end = s, bs = 0; *end != '\0'; ++end)
+        {
+          if (*end == '\n' && !bs)
+            break;
+          bs = *end == '\\' ? !bs : 0;
+        }
       printf ("%c%.*s\n", cmd_prefix, (int) (end - s), s);

vendor/gnumake/current/commands.h

-              r2596
+              r3138
 /* Definition of data structures describing shell commands for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 struct commands
+  {
+    struct floc fileinfo;       /* Where commands were defined.  */
+    char *commands;             /* Commands text.  */
+    unsigned int ncommand_lines;/* Number of command lines.  */
+    char **command_lines;       /* Commands chopped up into lines.  */
+    char *lines_flags;          /* One set of flag bits for each line.  */
+    int any_recurse;            /* Nonzero if any `lines_recurse' elt has */
+                                /* the COMMANDS_RECURSE bit set.  */
+    floc fileinfo;              /* Where commands were defined.  */
+    char *commands;             /* Commands text.  */
+    char **command_lines;       /* Commands chopped up into lines.  */
+    unsigned char *lines_flags; /* One set of flag bits for each line.  */
+    unsigned short ncommand_lines;/* Number of command lines.  */
+    char recipe_prefix;         /* Recipe prefix for this command set.  */
+    unsigned int any_recurse:1; /* Nonzero if any 'lines_flags' elt has */
+                                /* the COMMANDS_RECURSE bit set.  */
   };
 /* Bits in `lines_flags'.  */
 #define COMMANDS_RECURSE        1 /* Recurses: + or $(MAKE).  */
 #define COMMANDS_SILENT         2 /* Silent: @.  */
 #define COMMANDS_NOERROR        4 /* No errors: -.  */
+/* Bits in 'lines_flags'.  */
+#define COMMANDS_RECURSE        1 /* Recurses: + or $(MAKE).  */
+#define COMMANDS_SILENT         2 /* Silent: @.  */
+#define COMMANDS_NOERROR        4 /* No errors: -.  */
+RETSIGTYPE fatal_error_signal (int sig);
 void execute_file_commands (struct file *file);
 void print_commands (const struct commands *cmds);

vendor/gnumake/current/config.ami.template

-              r2596
+              r3138
 /* config.h -- hand-massaged for Amiga                                  -*-C-*-
+Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1995-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 /* Define if on AIX 3.
    System headers sometimes define this.
    We just want to avoid a redefinition error message.  */
+   We just want to avoid a redefinition error message.  */
 #ifndef _ALL_SOURCE
 /* #undef _ALL_SOURCE */
 …
 /* #undef DGUX */
 /* Define if the `getloadavg' function needs to be run setuid or setgid.  */
+/* Define if the 'getloadavg' function needs to be run setuid or setgid.  */
 /* #undef GETLOADAVG_PRIVILEGED */
 /* Define to `unsigned long' or `unsigned long long'
+/* Define to 'unsigned long' or 'unsigned long long'
    if <inttypes.h> doesn't define.  */
 #define uintmax_t unsigned long
 /* Define to `int' if <sys/types.h> doesn't define.  */
+/* Define to 'int' if <sys/types.h> doesn't define.  */
 #define gid_t int
 …
 /* #undef HAVE_ALLOCA_H */
-/* Define if you don't have vprintf but do have _doprnt.  */
-/* #undef HAVE_DOPRNT */
 /* Define if your system has a working fnmatch function.  */
 /* #undef HAVE_FNMATCH */
 /* Define if your system has its own `getloadavg' function.  */
+/* Define if your system has its own 'getloadavg' function.  */
 /* #undef HAVE_GETLOADAVG */
 …
 /* #undef HAVE_GETMNTENT */
+/* Define if the `long double' type works.  */
+/* Embed GNU Guile support */
+/* #undef HAVE_GUILE */
+/* Define if the 'long double' type works.  */
 /* #undef HAVE_LONG_DOUBLE */
 /* Define if you support file names longer than 14 characters.  */
+/* Define if you support file names longer than 14 characters.  */
 #define HAVE_LONG_FILE_NAMES 1
 /* Define if you have a working `mmap' system call.  */
+/* Define if you have a working 'mmap' system call.  */
 /* #undef HAVE_MMAP */
 …
 /* #undef HAVE_ST_BLOCKS */
 /* Define if you have the strcoll function and it is properly defined.  */
+/* Define if you have the strcoll function and it is properly defined.  */
 #define HAVE_STRCOLL 1
 …
 #define HAVE_STRFTIME 1
 /* Define if you have <sys/wait.h> that is POSIX.1 compatible.  */
+/* Define if you have <sys/wait.h> that is POSIX.1 compatible.  */
 /* #undef HAVE_SYS_WAIT_H */
 …
 /* #undef HAVE_UTIME_NULL */
-/* Define if you have <vfork.h>.  */
-/* #undef HAVE_VFORK_H */
-/* Define if you have the vprintf function.  */
-#define HAVE_VPRINTF 1
 /* Define if you have the wait3 system call.  */
 /* #undef HAVE_WAIT3 */
 /* Define if on MINIX.  */
+/* Define if on MINIX.  */
 /* #undef _MINIX */
 …
 /* #undef NO_MINUS_C_MINUS_O */
 /* Define to `int' if <sys/types.h> doesn't define.  */
+/* Define to 'int' if <sys/types.h> doesn't define.  */
 #define pid_t int
 …
    direction of stack growth for your system; otherwise it will be
    automatically deduced at run-time.
         STACK_DIRECTION > 0 => grows toward higher addresses
         STACK_DIRECTION < 0 => grows toward lower addresses
         STACK_DIRECTION = 0 => direction of growth unknown
+        STACK_DIRECTION > 0 => grows toward higher addresses
+        STACK_DIRECTION < 0 => grows toward lower addresses
+        STACK_DIRECTION = 0 => direction of growth unknown
  */
 #define STACK_DIRECTION -1
 /* Define if the `S_IS*' macros in <sys/stat.h> do not work properly.  */
+/* Define if the 'S_IS*' macros in <sys/stat.h> do not work properly.  */
 /* #undef STAT_MACROS_BROKEN */
+/* Define if your compiler conforms to the ANSI C standard. */
+#define HAVE_ANSI_COMPILER 1
+/* Define if you have the ANSI C header files.  */
+/* Define if you have the ANSI C header files.  */
 #define STDC_HEADERS
 …
 /* #undef SVR4 */
 /* Define if `sys_siglist' is declared by <signal.h>.  */
+/* Define if 'sys_siglist' is declared by <signal.h>.  */
 /* #undef SYS_SIGLIST_DECLARED */
 /* Define to `int' if <sys/types.h> doesn't define.  */
+/* Define to 'int' if <sys/types.h> doesn't define.  */
 #define uid_t int
 …
 /* #undef UMAX4_3 */
-/* Define vfork as fork if vfork does not work.  */
-/* #undef vfork */
 /* Name of this package (needed by automake) */
 #define PACKAGE "%PACKAGE%"
 …
 #define VERSION "%VERSION%"
 /* Define to the name of the SCCS `get' command.  */
+/* Define to the name of the SCCS 'get' command.  */
 #define SCCS_GET "get"
 /* Define this if the SCCS `get' command understands the `-G<file>' option.  */
+/* Define this if the SCCS 'get' command understands the '-G<file>' option.  */
 /* #undef SCCS_GET_MINUS_G */
 …
 /* #undef ST_MTIM_NSEC */
 /* Define this if the C library defines the variable `sys_siglist'.  */
+/* Define this if the C library defines the variable 'sys_siglist'.  */
 /* #undef HAVE_SYS_SIGLIST */
 /* Define this if the C library defines the variable `_sys_siglist'.  */
+/* Define this if the C library defines the variable '_sys_siglist'.  */
 /* #undef HAVE__SYS_SIGLIST */
 /* Define this if you have the `union wait' type in <sys/wait.h>.  */
+/* Define this if you have the 'union wait' type in <sys/wait.h>.  */
 /* #undef HAVE_UNION_WAIT */
 …
 /* #undef HAVE_SETEUID */
 /* Define if you have the setlinebuf function.  */
+/* Define if you have the setlinebuf function.  */
 /* #undef HAVE_SETLINEBUF */
 …
 /* #undef HAVE_SETREUID */
 /* Define if you have the sigsetmask function.  */
+/* Define if you have the sigsetmask function.  */
 /* #undef HAVE_SIGSETMASK */
 …
 /* #undef HAVE_NDIR_H */
-/* Define to 1 if you have the <stdarg.h> header file. */
-#define HAVE_STDARG_H 1
 /* Define if you have the <stdlib.h> header file.  */
 /* #undef HAVE_STDLIB_H */
 …
 /* #undef HAVE_LIBKSTAT */
+/* Define to 1 if you have the `isatty' function. */
+/* #undef HAVE_ISATTY */
+/* Define to 1 if you have the `ttyname' function. */
+/* #undef HAVE_TTYNAME */
 /* Define if you have the sun library (-lsun).  */
 /* #undef HAVE_LIBSUN */
+/* Output sync sypport */
+#define NO_OUTPUT_SYNC
 /* Define for Case Insensitve behavior */
 #define HAVE_CASE_INSENSITIVE_FS

vendor/gnumake/current/config.h-vms.template

-              r2596
+              r3138
 /* config.h-vms. Generated by hand by Klaus Kämpf <kkaempf@rmi.de>      -*-C-*-
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 /* config.h.  Generated automatically by configure.  */
+/* config.h.in.  Generated automatically from configure.in by autoheader.  */
+/* config.h.in.  Generated automatically from configure.ac by autoheader.  */
+/* Pull in types.h here to get __CRTL_VER defined for old versions of the
+   compiler which don't define it. */
+#ifdef __DECC
+# include <types.h>
+#endif
 /* Define to 1 if on AIX 3.
 …
 /* #undef HAVE_GETTEXT */
+/* Embed GNU Guile support */
+/* #undef HAVE_GUILE */
 /* Define to 1 if your locale.h file contains LC_MESSAGES.  */
 /* #undef HAVE_LC_MESSAGES */
 …
 /* #undef DGUX */
 /* Define to 1 if the `getloadavg' function needs to be run setuid or setgid.  */
+/* Define to 1 if the 'getloadavg' function needs to be run setuid or setgid.  */
 /* #undef GETLOADAVG_PRIVILEGED */
 /* Define to `unsigned long' or `unsigned long long'
+/* Define to 'unsigned long' or 'unsigned long long'
    if <inttypes.h> doesn't define.  */
 #define uintmax_t unsigned long
 /* Define to `int' if <sys/types.h> doesn't define.  */
+/* Define to 'int' if <sys/types.h> doesn't define.  */
 /* #undef gid_t */
 …
 /* #undef HAVE_ALLOCA_H */
-/* Define to 1 if you don't have vprintf but do have _doprnt.  */
-/* #undef HAVE_DOPRNT */
 /* Define to 1 if you have the fdopen function.  */
 #define HAVE_FDOPEN 1
 …
 /* #undef HAVE_FNMATCH */
 /* Define to 1 if your system has its own `getloadavg' function.  */
+/* Define to 1 if your system has its own 'getloadavg' function.  */
 /* #undef HAVE_GETLOADAVG */
 …
 /* #undef HAVE_GETMNTENT */
 /* Define to 1 if the `long double' type works.  */
+/* Define to 1 if the 'long double' type works.  */
 /* #undef HAVE_LONG_DOUBLE */
 …
 #define HAVE_LONG_FILE_NAMES 1
 /* Define to 1 if you have a working `mmap' system call.  */
+/* Define to 1 if you have a working 'mmap' system call.  */
 /* #undef HAVE_MMAP */
 …
 /* #undef HAVE_STRCOLL */
+/* Define to 1 if you have the strncasecmp' function. */
+#if __CRTL_VER >= 70000000
+#define HAVE_STRNCASECMP 1
+#endif
 /* Define to 1 if your struct stat has st_rdev.  */
 /* #undef HAVE_ST_RDEV */
 …
 /* #undef HAVE_UTIME_NULL */
-/* Define to 1 if you have <vfork.h>.  */
-/* #undef HAVE_VFORK_H */
-/* Define to 1 if you have the vprintf function.  */
-#define HAVE_VPRINTF 1
 /* Define to 1 if you have the wait3 system call.  */
 /* #undef HAVE_WAIT3 */
 …
 /* #undef NO_MINUS_C_MINUS_O */
 /* Define to `int' if <sys/types.h> doesn't define.  */
+/* Define to 'int' if <sys/types.h> doesn't define.  */
 /* I assume types.h is available for all 5.0 cc/cxx compilers */
 #if __DECC_VER < 50090000
 …
    direction of stack growth for your system; otherwise it will be
    automatically deduced at run-time.
         STACK_DIRECTION > 0 => grows toward higher addresses
         STACK_DIRECTION < 0 => grows toward lower addresses
         STACK_DIRECTION = 0 => direction of growth unknown
+        STACK_DIRECTION > 0 => grows toward higher addresses
+        STACK_DIRECTION < 0 => grows toward lower addresses
+        STACK_DIRECTION = 0 => direction of growth unknown
  */
 /* #undef STACK_DIRECTION */
 /* Define to 1 if the `S_IS*' macros in <sys/stat.h> do not work properly.  */
+/* Define to 1 if the 'S_IS*' macros in <sys/stat.h> do not work properly.  */
 /* #undef STAT_MACROS_BROKEN */
 …
 /* #undef SVR4 */
 /* Define to 1 if `sys_siglist' is declared by <signal.h>.  */
+/* Define to 1 if 'sys_siglist' is declared by <signal.h>.  */
 /* #undef SYS_SIGLIST_DECLARED */
 /* Define to `int' if <sys/types.h> doesn't define.  */
+/* Define to 'int' if <sys/types.h> doesn't define.  */
 #if __DECC_VER < 50090000
 #define uid_t int
 …
 /* #undef UMAX4_3 */
-/* Define vfork as fork if vfork does not work.  */
-/* #undef vfork */
 /* Name of this package (needed by automake) */
 #define PACKAGE "%PACKAGE%"
 …
 #define VERSION "%VERSION%"
 /* Define to the name of the SCCS `get' command.  */
+/* Define to the name of the SCCS 'get' command.  */
 /* #undef SCCS_GET */
 /* Define this if the SCCS `get' command understands the `-G<file>' option.  */
+/* Define this if the SCCS 'get' command understands the '-G<file>' option.  */
 /* #undef SCCS_GET_MINUS_G */
 …
 /* #undef ST_MTIM_NSEC */
 /* Define to 1 if the C library defines the variable `sys_siglist'.  */
+/* Define to 1 if the C library defines the variable 'sys_siglist'.  */
 /* #undefine HAVE_SYS_SIGLIST */
 /* Define to 1 if the C library defines the variable `_sys_siglist'.  */
+/* Define to 1 if the C library defines the variable '_sys_siglist'.  */
 /* #undef HAVE__SYS_SIGLIST */
 /* Define to 1 if you have the `union wait' type in <sys/wait.h>.  */
+/* Define to 1 if you have the 'union wait' type in <sys/wait.h>.  */
 /* #undef HAVE_UNION_WAIT */
 …
 /* Define to 1 if you have the gethostname function.  */
 /* #undef HAVE_GETHOSTNAME */
-/* Define to 1 if you have the getloadavg function.  */
-/* #undef HAVE_GETLOADAVG */
 /* Define to 1 if you have the memmove function.  */
 …
 /* #undef HAVE_NDIR_H */
-/* Define to 1 if your compiler conforms to the ANSI C standard. */
-#define HAVE_ANSI_COMPILER 1
-/* Define to 1 if you have the <stdarg.h> header file. */
-#define HAVE_STDARG_H 1
 /* Define to 1 if you have the <stdlib.h> header file.  */
 #define HAVE_STDLIB_H 1
 …
 /* Define to 1 if you have the sun library (-lsun).  */
 /* #undef HAVE_LIBSUN */
+/* Define to 1 if you have the `isatty' function. */
+/* #undef HAVE_ISATTY */
+/* Define to 1 if you have the `ttyname' function. */
+/* #undef HAVE_TTYNAME */
 /* Use high resolution file timestamps if nonzero. */
 …
 /* #undef _DIRENT_HAVE_D_NAMLEN */
+/* On older systems without 7.0 backport of CRTL the first one is defined */
+#ifdef __CRTL_VER
+# if __CRTL_VER < 70000000
+#  define HAVE_VMSDIR_H 1
+# endif
+#else
+# if __VMS_VER < 70000000
+#  define HAVE_VMSDIR_H 1
+# endif
+/* On older systems without 7.0 backport of CRTL use non-VMS code for opendir() etc. */
+#if __CRTL_VER < 70000000
+# define HAVE_VMSDIR_H 1
 #endif
 …
 /* Define if using alloca.c.  */
 /* #undef C_ALLOCA */
+/* maybe this should be placed into make.h */
+#if     defined(__VAX) && defined(__DECC)
+#define alloca(n)       __ALLOCA(n)
+#endif
+/* maybe this should be placed into makeint.h */
+#if     defined(__VAX) && defined(__DECC)
+#define alloca(n)       __ALLOCA(n)
+#endif
+/* Output sync sypport */
+#define NO_OUTPUT_SYNC
+/* Define to 1 to write even short single-line actions into a VMS/DCL command
+   file; this also enables exporting make environment variables into the
+   (sub-)process, which executes the action.
+   The usual make rules apply whether a shell variable - here a DCL symbol or
+   VMS logical [see CRTL getenv()] - is added to the make environment and
+   is exported. */
+#define USE_DCL_COM_FILE 1
 /* Build host information. */

vendor/gnumake/current/config.h.W32.template

-              r2596
+              r3138
 /* config.h.W32 -- hand-massaged config.h file for Windows builds       -*-C-*-
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 #endif
 /* Define to 1 if the `closedir' function returns void instead of `int'. */
+/* Define to 1 if the 'closedir' function returns void instead of 'int'. */
 /* #undef CLOSEDIR_VOID */
 /* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
    systems. This function is required for `alloca.c' support on those systems.
+/* Define to one of '_getb67', 'GETB67', 'getb67' for Cray-2 and Cray-YMP
+   systems. This function is required for 'alloca.c' support on those systems.
    */
 /* #undef CRAY_STACKSEG_END */
 /* Define to 1 if using `alloca.c'. */
+/* Define to 1 if using 'alloca.c'. */
 /* #undef C_ALLOCA */
 /* Define to 1 if using `getloadavg.c'. */
+/*#define C_GETLOADAVG 1*/
+/* Define to 1 if using 'getloadavg.c'. */
+#define C_GETLOADAVG 1
 /* Define to 1 for DGUX with <sys/dg_sys_info.h>. */
 …
 #define FILE_TIMESTAMP_HI_RES 0
 /* Define to 1 if the `getloadavg' function needs to be run setuid or setgid.
+/* Define to 1 if the 'getloadavg' function needs to be run setuid or setgid.
    */
 /* #undef GETLOADAVG_PRIVILEGED */
 /* Define to 1 if you have `alloca', as a function or macro. */
+/* Define to 1 if you have 'alloca', as a function or macro. */
 #define HAVE_ALLOCA 1
 …
 /* #undef HAVE_ALLOCA_H */
+/* Define if your compiler conforms to the ANSI C standard. */
+#define HAVE_ANSI_COMPILER 1
+/* Define to 1 if you have the `bsd_signal' function. */
+/* #undef HAVE_BSD_SIGNAL */
+/* Define to 1 if you have the 'atexit' function. */
+#define HAVE_ATEXIT 1
 /* Use case insensitive file names */
 /* #undef HAVE_CASE_INSENSITIVE_FS */
 /* Define if you have the clock_gettime function. */
+/* Define to 1 if you have the clock_gettime function. */
 /* #undef HAVE_CLOCK_GETTIME */
+/* Embed GNU Guile support.  Windows build sets this on the
+   compilation command line.  */
+/* #undef HAVE_GUILE */
 /* Define if the GNU dcgettext() function is already present or preinstalled.
    */
 /* #undef HAVE_DCGETTEXT */
+/* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
+/* Define to 1 if you have the declaration of 'bsd_signal', and to 0 if you
+   don't. */
+#define HAVE_DECL_BSD_SIGNAL 0
+/* Define to 1 if you have the declaration of 'sys_siglist', and to 0 if you
+   don't. */
+#define HAVE_DECL_SYS_SIGLIST 0
+/* Define to 1 if you have the declaration of '_sys_siglist', and to 0 if you
+   don't. */
+#define HAVE_DECL__SYS_SIGLIST 0
+/* Define to 1 if you have the declaration of '__sys_siglist', and to 0 if you
+   don't. */
+#define HAVE_DECL___SYS_SIGLIST 0
+/* Define to 1 if you have the <dirent.h> header file, and it defines 'DIR'.
    */
 #define HAVE_DIRENT_H 1
 …
 #endif
-/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */
-/* #undef HAVE_DOPRNT */
 /* Use platform specific coding */
 #define HAVE_DOS_PATHS 1
 /* Define to 1 if you have the `dup2' function. */
+/* Define to 1 if you have the 'dup2' function. */
 #define HAVE_DUP2 1
 …
 #define HAVE_FCNTL_H 1
+/* Define to 1 if you have the `fdopen' function. */
+/*#define HAVE_FDOPEN 1*/
+/* Define to 1 if you have the `fork' function. */
+/* #undef HAVE_FORK */
+/* Define to 1 if you have the `getcwd' function.  */
+/* Define to 1 if you have the 'fdopen' function. */
+#ifdef __MINGW32__
+#define HAVE_FDOPEN 1
+#endif
+/* Define to 1 if you have the 'fileno' function. */
+#define HAVE_FILENO 1
+/* Define to 1 if you have the 'getcwd' function.  */
 #define HAVE_GETCWD 1
 /* Define to 1 if you have the `getgroups' function. */
+/* Define to 1 if you have the 'getgroups' function. */
 /* #undef HAVE_GETGROUPS */
 /* Define to 1 if you have the `gethostbyname' function. */
+/* Define to 1 if you have the 'gethostbyname' function. */
 /* #undef HAVE_GETHOSTBYNAME */
 /* Define to 1 if you have the `gethostname' function. */
+/* Define to 1 if you have the 'gethostname' function. */
 /* #undef HAVE_GETHOSTNAME */
 /* Define to 1 if you have the `getloadavg' function. */
+/* Define to 1 if you have the 'getloadavg' function. */
 /* #undef HAVE_GETLOADAVG */
 /* Define to 1 if you have the `getrlimit' function. */
+/* Define to 1 if you have the 'getrlimit' function. */
 /* #undef HAVE_GETRLIMIT */
 …
 /* #undef HAVE_GETTEXT */
+/* Define if you have a standard gettimeofday function */
+/* #undef HAVE_GETTIMEOFDAY */
+/* Define to 1 if you have a standard gettimeofday function */
+#ifdef __MINGW32__
+#define HAVE_GETTIMEOFDAY 1
+#endif
 /* Define if you have the iconv() function. */
 …
 /* Define to 1 if you have the <inttypes.h> header file. */
+/*#define HAVE_INTTYPES_H 1*/
+/* Define to 1 if you have the `dgc' library (-ldgc). */
+#ifdef __MINGW32__
+#define HAVE_INTTYPES_H 1
+#endif
+/* Define to 1 if you have the 'dgc' library (-ldgc). */
 /* #undef HAVE_LIBDGC */
 /* Define to 1 if you have the `kstat' library (-lkstat). */
+/* Define to 1 if you have the 'kstat' library (-lkstat). */
 /* #undef HAVE_LIBKSTAT */
 …
 /*#define HAVE_LOCALE_H 1*/
+/* Define to 1 if you have the 'lstat' function. */
+/* #undef HAVE_LSTAT */
 /* Define to 1 if you have the <mach/mach.h> header file. */
 /* #undef HAVE_MACH_MACH_H */
-/* Define to 1 if you have the `memmove' function. */
-#define HAVE_MEMMOVE 1
 /* Define to 1 if you have the <memory.h> header file. */
 #define HAVE_MEMORY_H 1
 /* Define to 1 if you have the `mkstemp' function. */
+/* Define to 1 if you have the 'mkstemp' function. */
 /* #undef HAVE_MKSTEMP */
 /* Define to 1 if you have the `mktemp' function. */
+/* Define to 1 if you have the 'mktemp' function. */
 #define HAVE_MKTEMP 1
 /* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
+/* Define to 1 if you have the <ndir.h> header file, and it defines 'DIR'. */
 /* #undef HAVE_NDIR_H */
 …
 /* #undef HAVE_NLIST_H */
 /* Define to 1 if you have the `pipe' function. */
+/* Define to 1 if you have the 'pipe' function. */
 /* #undef HAVE_PIPE */
 /* Define to 1 if you have the `pstat_getdynamic' function. */
+/* Define to 1 if you have the 'pstat_getdynamic' function. */
 /* #undef HAVE_PSTAT_GETDYNAMIC */
+/* Define to 1 if you have the `realpath' function. */
+/* Define to 1 if you have the 'readlink' function. */
+/* #undef HAVE_READLINK */
+/* Define to 1 if you have the 'realpath' function. */
 /* #undef HAVE_REALPATH */
 /* Define if <signal.h> defines the SA_RESTART constant. */
+/* Define to 1 if <signal.h> defines the SA_RESTART constant. */
 /* #undef HAVE_SA_RESTART */
 /* Define to 1 if you have the `setegid' function. */
+/* Define to 1 if you have the 'setegid' function. */
 /* #undef HAVE_SETEGID */
 /* Define to 1 if you have the `seteuid' function. */
+/* Define to 1 if you have the 'seteuid' function. */
 /* #undef HAVE_SETEUID */
 /* Define to 1 if you have the `setlinebuf' function. */
+/* Define to 1 if you have the 'setlinebuf' function. */
 /* #undef HAVE_SETLINEBUF */
 /* Define to 1 if you have the `setlocale' function. */
+/* Define to 1 if you have the 'setlocale' function. */
 /*#define HAVE_SETLOCALE 1*/
 /* Define to 1 if you have the `setregid' function. */
+/* Define to 1 if you have the 'setregid' function. */
 /* #undef HAVE_SETREGID */
 /* Define to 1 if you have the `setreuid' function. */
+/* Define to 1 if you have the 'setreuid' function. */
 /* #undef HAVE_SETREUID */
 /* Define to 1 if you have the `setrlimit' function. */
+/* Define to 1 if you have the 'setrlimit' function. */
 /* #undef HAVE_SETRLIMIT */
 /* Define to 1 if you have the `setvbuf' function. */
+/*#define HAVE_SETVBUF 1 */
 /* Define to 1 if you have the `sigaction' function. */
+/* Define to 1 if you have the 'setvbuf' function. */
+#define HAVE_SETVBUF 1
+/* Define to 1 if you have the 'sigaction' function. */
 /* #undef HAVE_SIGACTION */
 /* Define to 1 if you have the `sigsetmask' function. */
+/* Define to 1 if you have the 'sigsetmask' function. */
 /* #undef HAVE_SIGSETMASK */
 /* Define to 1 if you have the `socket' function. */
+/* Define to 1 if you have the 'socket' function. */
 /* #undef HAVE_SOCKET */
-/* Define to 1 if you have the <stdarg.h> header file. */
-#define HAVE_STDARG_H 1
 /* Define to 1 if you have the <stdint.h> header file. */
+/*#define HAVE_STDINT_H 1*/
+#ifdef __MINGW32__
+#define HAVE_STDINT_H 1
+#endif
 /* Define to 1 if you have the <stdlib.h> header file. */
 #define HAVE_STDLIB_H 1
+/* Define to 1 if you have the `strcasecmp' function. */
+/* #undef HAVE_STRCASECMP */
+/* Define to 1 if you have the `strcmpi' function. */
+/* #undef HAVE_STRCMPI */
+/* Define to 1 if you have the `stricmp' function. */
+/* Define to 1 if you have the 'strcasecmp' function. */
+#ifdef __MINGW32__
+#define HAVE_STRCASECMP 1
+#endif
+/* Define to 1 if you have the 'strcmpi' function. */
+#define HAVE_STRCMPI 1
+/* Define to 1 if you have the 'strcoll' function and it is properly defined.
+   */
+#define HAVE_STRCOLL 1
+/* Define to 1 if you have the 'strdup' function. */
+#define HAVE_STRDUP 1
+/* Define to 1 if you have the 'strerror' function. */
+#define HAVE_STRERROR 1
+/* Define to 1 if you have the 'stricmp' function. */
 #define HAVE_STRICMP 1
-/* Define to 1 if you have the `strncasecmp' function. */
-/* #undef HAVE_STRNCASECMP */
-/* Define to 1 if you have the `strncmpi' function. */
-/* #undef HAVE_STRNCMPI */
-/* Define to 1 if you have the `strnicmp' function. */
-#define HAVE_STRNICMP 1
-/* Define to 1 if you have the `strchr' function. */
-#define HAVE_STRCHR 1
-/* Define to 1 if you have the `strcoll' function and it is properly defined.
-   */
-#define HAVE_STRCOLL 1
-/* Define to 1 if you have the `strdup' function. */
-/* #define HAVE_STRDUP 1*/
-/* Define to 1 if you have the `strerror' function. */
-#define HAVE_STRERROR 1
 /* Define to 1 if you have the <strings.h> header file. */
 …
 #define HAVE_STRING_H 1
+/* Define to 1 if you have the `strsignal' function. */
+/* Define to 1 if you have the 'strncasecmp' function. */
+#ifdef __MINGW32__
+#define HAVE_STRNCASECMP 1
+#endif
+/* Define to 1 if you have the 'strncmpi' function. */
+/* #undef HAVE_STRNCMPI */
+/* Define to 1 if you have the 'strndup' function. */
+/* #undef HAVE_STRNDUP */
+/* Define to 1 if you have the 'strnicmp' function. */
+#ifdef __MINGW32__
+#define HAVE_STRNICMP 1
+#endif
+/* Define to 1 if you have the 'strsignal' function. */
 /* #undef HAVE_STRSIGNAL */
+/* Define to 1 if `n_un.n_name' is member of `struct nlist'. */
+/* Define to 1 if you have the `isatty' function. */
+#define HAVE_ISATTY 1
+/* Define to 1 if you have the `ttyname' function. */
+#define HAVE_TTYNAME 1
+char *ttyname (int);
+/* Define to 1 if 'n_un.n_name' is a member of 'struct nlist'. */
 /* #undef HAVE_STRUCT_NLIST_N_UN_N_NAME */
 /* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
+/* Define to 1 if you have the <sys/dir.h> header file, and it defines 'DIR'.
    */
 /* #undef HAVE_SYS_DIR_H */
 /* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
+/* Define to 1 if you have the <sys/ndir.h> header file, and it defines 'DIR'.
    */
 /* #undef HAVE_SYS_NDIR_H */
 /* Define to 1 if you have the <sys/param.h> header file. */
+/* #define HAVE_SYS_PARAM_H 1 */
+#ifdef __MINGW32__
+#define HAVE_SYS_PARAM_H 1
+#endif
 /* Define to 1 if you have the <sys/resource.h> header file. */
 …
 /* Define to 1 if you have the <sys/stat.h> header file. */
+/* #define HAVE_SYS_STAT_H 1 */
+#define HAVE_SYS_STAT_H 1
 /* Define to 1 if you have the <sys/timeb.h> header file. */
+/*#define HAVE_SYS_TIMEB_H 1*/
+#define HAVE_SYS_TIMEB_H 1
 /* Define to 1 if you have the <sys/time.h> header file. */
+/*#define HAVE_SYS_TIME_H 1*/
+#ifdef __MINGW32__
+#define HAVE_SYS_TIME_H 1
+#endif
 /* Define to 1 if you have the <sys/types.h> header file. */
+/*#define HAVE_SYS_TYPES_H 1*/
+#define HAVE_SYS_TYPES_H 1
 /* Define to 1 if you have the <sys/wait.h> header file. */
 /* #undef HAVE_SYS_WAIT_H */
 /* Define this if you have the \`union wait' type in <sys/wait.h>. */
+/* Define to 1 if you have the \'union wait' type in <sys/wait.h>. */
 /* #undef HAVE_UNION_WAIT */
 /* Define to 1 if you have the <unistd.h> header file. */
+/* #define HAVE_UNISTD_H 1*/
+/* Define to 1 if you have the <varargs.h> header file. */
+/* #undef HAVE_VARARGS_H */
+/* Define to 1 if you have the `vfork' function. */
+/* #undef HAVE_VFORK */
+/* Define to 1 if you have the <vfork.h> header file. */
+/* #undef HAVE_VFORK_H */
+/* Define to 1 if you have the `vprintf' function. */
+#define HAVE_VPRINTF 1
+/* Define to 1 if you have the `wait3' function. */
+#ifdef __MINGW32__
+#define HAVE_UNISTD_H 1
+#endif
+/* Define to 1 if you have the 'wait3' function. */
 /* #undef HAVE_WAIT3 */
 /* Define to 1 if you have the `waitpid' function. */
+/* Define to 1 if you have the 'waitpid' function. */
 /* #undef HAVE_WAITPID */
-/* Define to 1 if `fork' works. */
-/* #undef HAVE_WORKING_FORK */
-/* Define to 1 if `vfork' works. */
-/* #undef HAVE_WORKING_VFORK */
 /* Build host information. */
 #define MAKE_HOST "Windows32"
+/* Define this to enable job server support in GNU make. */
+/* #undef MAKE_JOBSERVER */
+/* Define to 1 if your `struct nlist' has an `n_un' member. Obsolete, depend
+   on `HAVE_STRUCT_NLIST_N_UN_N_NAME */
+/* Define to 1 to enable job server support in GNU make. */
+#define MAKE_JOBSERVER 1
+/* Define to 1 to enable 'load' support in GNU make. */
+#define MAKE_LOAD 1
+/* Define to 1 to enable symbolic link timestamp checking. */
+/* #undef MAKE_SYMLINKS */
+/* Define to 1 if your 'struct nlist' has an 'n_un' member. Obsolete, depend
+   on 'HAVE_STRUCT_NLIST_N_UN_N_NAME */
 /* #undef NLIST_NAME_UNION */
 /* Define if struct nlist.n_name is a pointer rather than an array. */
+/* Define to 1 if struct nlist.n_name is a pointer rather than an array. */
 /* #undef NLIST_STRUCT */
 …
 #define PACKAGE "%PACKAGE%"
+/* Define to 1 if the C compiler supports function prototypes. */
+#define PROTOTYPES 1
+/* Define as the return type of signal handlers (`int' or `void'). */
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "bug-make@gnu.org"
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "GNU make"
+/* Define to the home page for this package. */
+#define PACKAGE_URL "http://www.gnu.org/software/make/"
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "%VERSION%"
+/* Define to the character that separates directories in PATH. */
+#define PATH_SEPARATOR_CHAR ';'
+/* Define as the return type of signal handlers ('int' or 'void'). */
 #define RETSIGTYPE void
 …
 /* #undef SCCS_GET_MINUS_G */
 /* Define to 1 if the `setvbuf' function takes the buffering type as its
+/* Define to 1 if the 'setvbuf' function takes the buffering type as its
    second argument and the buffer pointer as the third, as on System V before
    release 3. */
 …
 /* If using the C implementation of alloca, define if you know the
    direction of stack growth for your system; otherwise it will be
    automatically deduced at run-time.
         STACK_DIRECTION > 0 => grows toward higher addresses
         STACK_DIRECTION < 0 => grows toward lower addresses
         STACK_DIRECTION = 0 => direction of growth unknown */
+   automatically deduced at run time.
+        STACK_DIRECTION > 0 => grows toward higher addresses
+        STACK_DIRECTION < 0 => grows toward lower addresses
+        STACK_DIRECTION = 0 => direction of growth unknown */
 /* #undef STACK_DIRECTION */
 /* Define to 1 if the `S_IS*' macros in <sys/stat.h> do not work properly. */
+/* Define to 1 if the 'S_IS*' macros in <sys/stat.h> do not work properly. */
 /* #undef STAT_MACROS_BROKEN */
 …
 /* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
+/* #define TIME_WITH_SYS_TIME 1 */
+#ifdef __MINGW32__
+#define TIME_WITH_SYS_TIME 1
+#endif
 /* Define to 1 for Encore UMAX. */
 …
 /* #undef _POSIX_1_SOURCE */
+/* Define to 1 if you need to in order for `stat' and other things to work. */
+#define _POSIX_SOURCE 1
+/* Define like PROTOTYPES; this can be used by system headers. */
+/*#define __PROTOTYPES 1*/
+/* Define to empty if `const' does not conform to ANSI C. */
+/* Define to 1 if you need to in order for 'stat' and other things to work. */
+/* #undef _POSIX_SOURCE */
+/* Define to empty if 'const' does not conform to ANSI C. */
 /* #undef const */
 #include <sys/types.h>
 /* Define to `int' if <sys/types.h> doesn't define. */
+/* Define to 'int' if <sys/types.h> doesn't define. */
 #define gid_t int
 /* Define to `int' if <sys/types.h> does not define. */
+/* Define to 'int' if <sys/types.h> does not define. */
 /* GCC 4.x reportedly defines pid_t.  */
 #ifndef _PID_T_
 …
 #endif
 /* Define to `int' if <sys/types.h> doesn't define. */
+/* Define to 'int' if <sys/types.h> doesn't define. */
 #define uid_t int
 /* Define uintmax_t if not defined in <stdint.h> or <inttypes.h>. */
+#if !HAVE_STDINT_H && !HAVE_INTTYPES_H
 #define uintmax_t unsigned long
+/* Define as `fork' if `vfork' does not work. */
+/*#define vfork fork*/
+/* Define to `unsigned long' or `unsigned long long'
+   if <inttypes.h> doesn't define.  */
+#define uintmax_t unsigned long
+/* Define if you support file names longer than 14 characters.  */
+#define HAVE_LONG_FILE_NAMES 1
+/* Define if your struct stat has st_rdev.  */
+#undef HAVE_ST_RDEV
+#define HAVE_ST_RDEV 1
+/* Define if you have the strftime function.  */
+#undef HAVE_STRFTIME
+#define HAVE_STRFTIME 1
+#endif
 /* Define if you have <sys/wait.h> that is POSIX.1 compatible.  */
 /* #undef HAVE_SYS_WAIT_H */
-/* Define if your struct tm has tm_zone.  */
-/* #undef HAVE_TM_ZONE */
-/* Define if you don't have tm_zone but do have the external array
-   tzname.  */
-#undef HAVE_TZNAME
-#define HAVE_TZNAME 1
-/* Define if utime(file, NULL) sets file's timestamp to the present.  */
-#undef HAVE_UTIME_NULL
-#define HAVE_UTIME_NULL 1
 /* Define to the installation directory for locales.  */

vendor/gnumake/current/config/.gitignore

Property svn:eol-style set to LF

-              r3137
+              r3138
+*.m4
+config.*
+mkinstalldirs
+texinfo.tex
+mdate-sh
+ar-lib
 compile
+config.guess
+config.rpath
+config.sub
 depcomp
 install-sh
+mdate-sh
 missing
+Makefile Makefile.in
+texinfo.tex
+*.m4
+!dospaths.m4

vendor/gnumake/current/config/ChangeLog.1

-              r3137
+              r3138
+-01-15  Paul Smith  <psmith@gnu.org>
+        * dospaths.m4: Use AC_LANG_PROGRAM to encapsulate the test code.
+        Fixes Savannah bug #35256.  Patch from Sebastian Pipping.
 -03-09  Paul Smith  <psmith@gnu.org>
 …
+Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software
+Foundation, Inc.
+Copyright (C) 2002-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.

vendor/gnumake/current/config/Makefile.am

-              r2596
+              r3138
 # -*-Makefile-*-, or close enough
+# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free
+# Software Foundation, Inc.
+# Copyright (C) 2002-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 # this program.  If not, see <http://www.gnu.org/licenses/>.
+EXTRA_DIST =    codeset.m4 gettext.m4 glibc21.m4 iconv.m4 isc-posix.m4 nls.m4 \
+                intdiv0.m4 inttypes-pri.m4 inttypes.m4 inttypes_h.m4 \
+                isc-posix.m4 lcmessage.m4 lib-ld.m4 lib-link.m4 lib-prefix.m4 \
+                progtest.m4 stdint_h.m4 uintmax_t.m4 ulonglong.m4 longlong.m4 \
+                dospaths.m4 po.m4 signed.m4 longdouble.m4 wchar_t.m4 \
+                wint_t.m4 intmax.m4 printf-posix.m4 xsize.m4 size_max.m4
+# Autoconf / automake know how to handle this directory.

vendor/gnumake/current/config/dospaths.m4

-              r2596
+              r3138
 # By Paul Smith <psmith@gnu.org>.  Based on dos.m4 by Jim Meyering.
+#
+# Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+# Copyright (C) 1993-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 # this program.  If not, see <http://www.gnu.org/licenses/>.
+AC_DEFUN([pds_AC_DOS_PATHS],
+  [
+    AC_CACHE_CHECK([whether system uses MSDOS-style paths], [ac_cv_dos_paths],
+      [
+        AC_COMPILE_IFELSE([
+AC_DEFUN([pds_AC_DOS_PATHS], [
+  AC_CACHE_CHECK([whether system uses MSDOS-style paths], [ac_cv_dos_paths], [
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
 #if !defined _WIN32 && !defined __WIN32__ && !defined __MSDOS__ && !defined __EMX__ && !defined __MSYS__ && !defined __CYGWIN__
 neither MSDOS nor Windows nor OS2
 #endif
 ],
+]])],
         [ac_cv_dos_paths=yes],
+        [ac_cv_dos_paths=no])
+      ])
+        [ac_cv_dos_paths=no])])
+    if test x"$ac_cv_dos_paths" = xyes; then
+      AC_DEFINE_UNQUOTED([HAVE_DOS_PATHS], 1,
+                         [Define if the system uses DOS-style pathnames.])
+    fi
+  ])
+  AS_IF([test x"$ac_cv_dos_paths" = xyes],
+  [ AC_DEFINE_UNQUOTED([HAVE_DOS_PATHS], 1,
+                       [Define if the system uses DOS-style pathnames.])])
+])

vendor/gnumake/current/configh.dos.template

-              r2596
+              r3138
 /* configh.dos -- hand-massaged config.h file for MS-DOS builds         -*-C-*-
+Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
+, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1994-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 #if __DJGPP__ > 2 || __DJGPP_MINOR__ > 1
 /* Define to 1 if `sys_siglist' is declared by <signal.h> or <unistd.h>. */
+/* Define to 1 if 'sys_siglist' is declared by <signal.h> or <unistd.h>. */
 # define SYS_SIGLIST_DECLARED 1
 /* Define to 1 if the C library defines the variable `_sys_siglist'.  */
+/* Define to 1 if the C library defines the variable '_sys_siglist'.  */
 # define HAVE_DECL_SYS_SIGLIST 1
 …
 #define FILE_TIMESTAMP_HI_RES 0
 /* Define to 1 if you have `alloca', as a function or macro. */
+/* Define to 1 if you have 'alloca', as a function or macro. */
 #define HAVE_ALLOCA 1
 …
 #define HAVE_FDOPEN 1
 /* Define to 1 if you have the `getgroups' function. */
+/* Define to 1 if you have the 'getgroups' function. */
 #define HAVE_GETGROUPS 1
 …
 #define HAVE_MKSTEMP 1
 /* Define to 1 if you have the `mktemp' function. */
+/* Define to 1 if you have the 'mktemp' function. */
 #define HAVE_MKTEMP 1
 /* Define to 1 if you have the `setlinebuf' function. */
+/* Define to 1 if you have the 'setlinebuf' function. */
 #define HAVE_SETLINEBUF 1
 /* Define to 1 if you have the `setvbuf' function. */
+/* Define to 1 if you have the 'setvbuf' function. */
 #define HAVE_SETVBUF 1
 #define SCCS_GET "get"
 /* Define to `unsigned long' or `unsigned long long'
+/* Define to 'unsigned long' or 'unsigned long long'
    if <inttypes.h> doesn't define.  */
 #define uintmax_t unsigned long long
 …
 #define HAVE_SELECT 1
-/* Define to 1 if your compiler conforms to the ANSI C standard. */
-#define HAVE_ANSI_COMPILER 1
-/* Define to 1 if you have the <stdarg.h> header file. */
-#define HAVE_STDARG_H 1
-/* Define to 1 if you have the vprintf library function.  */
-#undef HAVE_VPRINTF
-#define HAVE_VPRINTF 1
 /* Define to 1 if you have the stricmp function.  */
 #define HAVE_STRICMP 1
+/* Define to 1 if you have the 'strncasecmp' function. */
+#define HAVE_STRNCASECMP 1
 /* Name of the package */
 …
 #define PACKAGE_VERSION "%VERSION%"
 /* Define to 1 if the C compiler supports function prototypes. */
 #define PROTOTYPES 1
+/* Output sync sypport */
+#define NO_OUTPUT_SYNC
 /* Version number of package */

vendor/gnumake/current/configure.bat

r2596	r3138
1	1	@echo off
2		rem Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3		rem 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
	2	rem Copyright (C) 1994-2016 Free Software Foundation, Inc.
4	3	rem This file is part of GNU Make.
5	4	rem

vendor/gnumake/current/debug.h

r2596	r3138
1	1	/* Debugging macros and interface.
2		Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3		2009, 2010 Free Software Foundation, Inc.
	2	Copyright (C) 1999-2016 Free Software Foundation, Inc.
4	3	This file is part of GNU Make.
5	4

vendor/gnumake/current/default.c

-              r2596
+              r3138
 /* Data base of default implicit rules for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
+#include "make.h"
+#include "makeint.h"
+#include <assert.h>
 #include "filedef.h"
 #include "variable.h"
 …
 /* This is the default list of suffixes for suffix rules.
    `.s' must come last, so that a `.o' file will be made from
    a `.c' or `.p' or ... file rather than from a .s file.  */
+   '.s' must come last, so that a '.o' file will be made from
+   a '.c' or '.p' or ... file rather than from a .s file.  */
 static char default_suffixes[]
 #ifdef VMS
+  = ".exe .olb .ln .obj .c .cxx .cc .pas .p .for .f .r .y .l .mar \
+.s .ss .i .ii .mod .sym .def .h .info .dvi .tex .texinfo .texi .txinfo \
+.w .ch .cweb .web .com .sh .elc .el";
+  /* VMS should include all UNIX/POSIX + some VMS extensions */
+  = ".out .exe .a .olb .hlb .tlb .mlb .ln .o .obj .c .cxx .cc .cpp .pas .p \
+.for .f .r .y .l .ym .yl .mar .s .ss .i .ii .mod .sym .def .h .info .dvi \
+.tex .texinfo .texi .txinfo .mem .hlp .brn .rnh .rno .rnt .rnx .w .ch .cweb \
+.web .com .sh .elc .el";
 #elif defined(__EMX__)
   = ".out .a .ln .o .c .cc .C .cpp .p .f .F .m .r .y .l .ym .yl .s .S \
 …
 static struct pspec default_pattern_rules[] =
+  {
+#ifdef VMS
     { "(%)", "%",
+        "$(AR) $(ARFLAGS) $@ $<" },
+        "@if f$$search(\"$@\") .eqs. \"\" then $(LIBRARY)/CREATE/"
+         "$(or "
+          "$(patsubst %,TEXT,$(filter %.tlb %.TLB,$@)),"
+          "$(patsubst %,HELP,$(filter %.hlb %.HLB,$@)),"
+          "$(patsubst %,MACRO,$(filter %.mlb %.MLB,$@)),"
+          "$(and "
+           "$(patsubst %,SHARE,$(filter %.olb %.OLB,$@)),"
+           "$(patsubst %,SHARE,$(filter %.exe %.EXE,$<))),"
+          "OBJECT)"
+         " $@\n"
+        "$(AR) $(ARFLAGS) $@ $<" },
+#else
+    { "(%)", "%",
+        "$(AR) $(ARFLAGS) $@ $<" },
+#endif
     /* The X.out rules are only in BSD's default set because
        BSD Make has no null-suffix rules, so `foo.out' and
        `foo' are the same thing.  */
+       BSD Make has no null-suffix rules, so 'foo.out' and
+       'foo' are the same thing.  */
 #ifdef VMS
     { "%.exe", "%",
+        "copy $< $@" },
+#else
+        "$(CP) $< $@" },
+#endif
     { "%.out", "%",
         "@rm -f $@ \n cp $< $@" },
+#endif
+        "@rm -f $@ \n cp $< $@" },
     /* Syntax is "ctangle foo.w foo.ch foo.c".  */
     { "%.c", "%.w %.ch",
         "$(CTANGLE) $^ $@" },
+        "$(CTANGLE) $^ $@" },
     { "%.tex", "%.w %.ch",
         "$(CWEAVE) $^ $@" },
+        "$(CWEAVE) $^ $@" },
     { 0, 0, 0 }
 …
+  {
 #ifdef VMS
     /* RCS.  */
     { "%", "%$$5lv", /* Multinet style */
         "if f$$search($@) .nes. \"\" then +$(CHECKOUT,v)" },
+        "if f$$search(\"$@\") .nes. \"\" then +$(CHECKOUT,v)" },
     { "%", "[.$$rcs]%$$5lv", /* Multinet style */
         "if f$$search($@) .nes. \"\" then +$(CHECKOUT,v)" },
+        "if f$$search(\"$@\") .nes. \"\" then +$(CHECKOUT,v)" },
     { "%", "%_v", /* Normal style */
         "if f$$search($@) .nes. \"\" then +$(CHECKOUT,v)" },
+        "if f$$search(\"$@\") .nes. \"\" then +$(CHECKOUT,v)" },
     { "%", "[.rcs]%_v", /* Normal style */
         "if f$$search($@) .nes. \"\" then +$(CHECKOUT,v)" },
+        "if f$$search(\"$@\") .nes. \"\" then +$(CHECKOUT,v)" },
     /* SCCS.  */
+        /* ain't no SCCS on vms */
+        /* ain't no SCCS on vms */
 #else
     /* RCS.  */
     { "%", "%,v",
         "$(CHECKOUT,v)" },
+        "$(CHECKOUT,v)" },
     { "%", "RCS/%,v",
         "$(CHECKOUT,v)" },
+        "$(CHECKOUT,v)" },
     { "%", "RCS/%",
         "$(CHECKOUT,v)" },
+        "$(CHECKOUT,v)" },
     /* SCCS.  */
     { "%", "s.%",
         "$(GET) $(GFLAGS) $(SCCS_OUTPUT_OPTION) $<" },
+        "$(GET) $(GFLAGS) $(SCCS_OUTPUT_OPTION) $<" },
     { "%", "SCCS/s.%",
         "$(GET) $(GFLAGS) $(SCCS_OUTPUT_OPTION) $<" },
+        "$(GET) $(GFLAGS) $(SCCS_OUTPUT_OPTION) $<" },
 #endif /* !VMS */
     { 0, 0, 0 }
   };
 static char *default_suffix_rules[] =
+static const char *default_suffix_rules[] =
+  {
 #ifdef VMS
+    ".o",
+    "$(LINK.obj) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".obj",
+    "$(LINK.obj) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".s",
+    "$(LINK.s) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".S",
+    "$(LINK.S) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".c",
+    "$(LINK.c) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".cc",
+    "$(LINK.cc) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".C",
+    "$(LINK.C) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".cpp",
+    "$(LINK.cpp) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".f",
+    "$(LINK.f) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".m",
+    "$(LINK.m) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".p",
+    "$(LINK.p) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".F",
+    "$(LINK.F) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".r",
+    "$(LINK.r) $^ $(LOADLIBES) $(LDLIBS) -o $@",
+    ".mod",
+    "$(COMPILE.mod) -o $@ -e $@ $^",
+    ".def.sym",
+    "$(COMPILE.def) -o $@ $<",
+    ".sh",
+    "copy $< >$@",
     ".obj.exe",
     "$(LINK.obj) $^ $(LOADLIBES) $(LDLIBS) $(CRT0) /exe=$@",
     ".mar.exe",
     "$(COMPILE.mar) $^ \n $(LINK.obj) $(subst .mar,.obj,$^) $(LOADLIBES) $(LDLIBS) $(CRT0) /exe=$@",
+    ".s.o",
+    "$(COMPILE.s) -o $@ $<",
     ".s.exe",
     "$(COMPILE.s) $^ \n $(LINK.obj) $(subst .s,.obj,$^) $(LOADLIBES) $(LDLIBS) $(CRT0) /exe=$@",
 …
     ".c.obj",
     "$(COMPILE.c) /obj=$@ $<",
+    ".c.o",
+    "$(COMPILE.c) /obj=$@ $<",
     ".cc.ii",
     "$(COMPILE.cc)/prep /list=$@ $<",
 …
     ".cc.obj",
     "$(COMPILE.cc) /obj=$@ $<",
+    ".cc.o",
+    "$(COMPILE.cc) /obj=$@ $<",
     ".cxx.obj",
+    "$(COMPILE.cxx) /obj=$@ $<",
+    ".cxx.o",
     "$(COMPILE.cxx) /obj=$@ $<",
     ".for.obj",
     "$(COMPILE.for) /obj=$@ $<",
+    ".for.o",
+    "$(COMPILE.for) /obj=$@ $<",
     ".pas.obj",
+    "$(COMPILE.pas) /obj=$@ $<",
+    ".pas.o",
     "$(COMPILE.pas) /obj=$@ $<",
 …
     ".tex.dvi",
     "$(TEX) $<",
+    ".cpp.o",
+    "$(COMPILE.cpp) $(OUTPUT_OPTION) $<",
+    ".f.o",
+    "$(COMPILE.f) $(OUTPUT_OPTION) $<",
+    ".m.o",
+    "$(COMPILE.m) $(OUTPUT_OPTION) $<",
+    ".p.o",
+    "$(COMPILE.p) $(OUTPUT_OPTION) $<",
+    ".r.o",
+    "$(COMPILE.r) $(OUTPUT_OPTION) $<",
+    ".mod.o",
+    "$(COMPILE.mod) -o $@ $<",
+    ".c.ln",
+    "$(LINT.c) -C$* $<",
+    ".y.ln",
+    "$(YACC.y) $< \n rename y_tab.c $@",
+    ".l.ln",
+    "@$(RM) $*.c\n $(LEX.l) $< > $*.c\n$(LINT.c) -i $*.c -o $@\n $(RM) $*.c",
 #else /* ! VMS */
 …
     ".w.c",
     "$(CTANGLE) $< - $@",       /* The `-' says there is no `.ch' file.  */
+    "$(CTANGLE) $< - $@",       /* The '-' says there is no '.ch' file.  */
     ".web.p",
 …
     ".w.tex",
     "$(CWEAVE) $< - $@",        /* The `-' says there is no `.ch' file.  */
+    "$(CWEAVE) $< - $@",        /* The '-' says there is no '.ch' file.  */
     ".web.tex",
 …
     "ARCH", "VAX",
 #endif
+    "AR", "library/obj",
+    "AR", "library",
+    "LIBRARY", "library",
     "ARFLAGS", "/replace",
     "AS", "macro",
 …
 #endif
     "CD", "builtin_cd",
+    "MAKE", "make",
+    "ECHO", "write sys$$output \"",
+    "ECHO", "builtin_echo",
 #ifdef GCC_IS_NATIVE
     "C++", "gcc/plus",
 …
     "C++", "cxx",
     "CXX", "cxx",
+#ifndef __ia64
     "CXXLD", "cxxlink",
+    "CXXLINK", "cxxlink",
+#else
+    /* CXXLINK is not used on VMS/IA64 */
+    "CXXLD", "link",
+    "CXXLINK", "link",
+#endif
 #endif
     "CO", "co",
 …
 #endif
+    "LINK.o", "$(LD) $(LDFLAGS)",
     "LINK.obj", "$(LD) $(LDFLAGS)",
 #ifndef GCC_IS_NATIVE
 …
 #endif
     "COMPILE.c", "$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH)",
+    "LINK.c", "$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH)",
+    "COMPILE.m", "$(OBJC) $(OBJCFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c",
+    "LINK.m", "$(OBJC) $(OBJCFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
     "COMPILE.cc", "$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH)",
+    "COMPILE.C", "$(COMPILE.cc)",
+    "COMPILE.cpp", "$(COMPILE.cc)",
+    "LINK.C", "$(LINK.cc)",
+    "LINK.cpp", "$(LINK.cc)",
     "YACC.y", "$(YACC) $(YFLAGS)",
     "LEX.l", "$(LEX) $(LFLAGS)",
+    "YACC.m", "$(YACC) $(YFLAGS)",
+    "LEX.m", "$(LEX) $(LFLAGS) -t",
     "COMPILE.for", "$(FC) $(FFLAGS) $(TARGET_ARCH)",
+    "COMPILE.f", "$(FC) $(FFLAGS) $(TARGET_ARCH) -c",
+    "LINK.f", "$(FC) $(FFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
+    "COMPILE.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c",
+    "LINK.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
+    "COMPILE.r", "$(FC) $(FFLAGS) $(RFLAGS) $(TARGET_ARCH) -c",
+    "LINK.r", "$(FC) $(FFLAGS) $(RFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
     "COMPILE.pas", "$(PC) $(PFLAGS) $(CPPFLAGS) $(TARGET_ARCH)",
+    "COMPILE.def", "$(M2C) $(M2FLAGS) $(DEFFLAGS) $(TARGET_ARCH)",
+    "COMPILE.mod", "$(M2C) $(M2FLAGS) $(MODFLAGS) $(TARGET_ARCH)",
+    "COMPILE.p", "$(PC) $(PFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c",
+    "LINK.p", "$(PC) $(PFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
     "COMPILE.mar", "$(MACRO) $(MACROFLAGS)",
     "COMPILE.s", "$(AS) $(ASFLAGS) $(TARGET_MACH)",
+    "LINK.S", "$(CC) $(ASFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_MACH)",
+    "COMPILE.S", "$(CC) $(ASFLAGS) $(CPPFLAGS) $(TARGET_MACH) -c",
+    "PREPROCESS.S", "$(CC) -E $(CPPFLAGS)",
+    "PREPROCESS.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -F",
+    "PREPROCESS.r", "$(FC) $(FFLAGS) $(RFLAGS) $(TARGET_ARCH) -F",
     "LINT.c", "$(LINT) $(LINTFLAGS) $(CPPFLAGS) $(TARGET_ARCH)",
     "MV", "rename/new_version",
     "CP", "copy",
+    ".LIBPATTERNS", "%.olb lib%.a",
 #else /* !VMS */
 …
     "CC", "gcc",
 # ifdef __MSDOS__
     "CXX", "gpp",       /* g++ is an invalid name on MSDOS */
+    "CXX", "gpp",       /* g++ is an invalid name on MSDOS */
 # else
     "CXX", "gcc",
 …
     "CPP", "$(CC) -E",
 #ifdef  CRAY
+#ifdef  CRAY
     "CF77PPFLAGS", "-P",
     "CF77PP", "/lib/cpp",
 …
     "CF", "cf77",
     "FC", "$(CF)",
 #else   /* Not CRAY.  */
 #ifdef  _IBMR2
+#else   /* Not CRAY.  */
+#ifdef  _IBMR2
     "FC", "xlf",
 #else
 #ifdef  __convex__
+#ifdef  __convex__
     "FC", "fc",
 #else
 …
     "F77", "$(FC)",
     "F77FLAGS", "$(FFLAGS)",
 #endif  /* Cray.  */
+#endif  /* Cray.  */
     "GET", SCCS_GET,
     "LD", "ld",
 …
     "LINT", "lint",
     "M2C", "m2c",
 #ifdef  pyr
+#ifdef  pyr
     "PC", "pascal",
 #else
 #ifdef  CRAY
+#ifdef  CRAY
     "PC", "PASCAL",
     "SEGLDR", "segldr",
 #else
     "PC", "pc",
 #endif  /* CRAY.  */
 #endif  /* pyr.  */
+#endif  /* CRAY.  */
+#endif  /* pyr.  */
 #ifdef GCC_IS_NATIVE
     "YACC", "bison -y",
 #else
     "YACC", "yacc",     /* Or "bison -y"  */
+    "YACC", "yacc",     /* Or "bison -y"  */
 #endif
     "MAKEINFO", "makeinfo",
 …
     "LINK.m", "$(OBJC) $(OBJCFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
     "COMPILE.cc", "$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c",
+#ifndef HAVE_CASE_INSENSITIVE_FS
+    /* On case-insensitive filesystems, treat *.C files as *.c files,
+       to avoid erroneously compiling C sources as C++, which will
+       probably fail.  */
     "COMPILE.C", "$(COMPILE.cc)",
+#else
+    "COMPILE.C", "$(COMPILE.c)",
+#endif
     "COMPILE.cpp", "$(COMPILE.cc)",
     "LINK.cc", "$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
+#ifndef HAVE_CASE_INSENSITIVE_FS
     "LINK.C", "$(LINK.cc)",
+#else
+    "LINK.C", "$(LINK.c)",
+#endif
     "LINK.cpp", "$(LINK.cc)",
     "YACC.y", "$(YACC) $(YFLAGS)",
 …
     "LINT.c", "$(LINT) $(LINTFLAGS) $(CPPFLAGS) $(TARGET_ARCH)",
 #ifndef NO_MINUS_C_MINUS_O
+#ifndef NO_MINUS_C_MINUS_O
     "OUTPUT_OPTION", "-o $@",
 #endif
 #ifdef  SCCS_GET_MINUS_G
+#ifdef  SCCS_GET_MINUS_G
     "SCCS_OUTPUT_OPTION", "-G$@",
 #endif
 #ifdef _AMIGA
+#if defined(_AMIGA)
     ".LIBPATTERNS", "%.lib",
+#else
+#ifdef __MSDOS__
+#elif defined(__MSDOS__)
     ".LIBPATTERNS", "lib%.a $(DJDIR)/lib/lib%.a",
+#elif defined(__APPLE__)
+    ".LIBPATTERNS", "lib%.dylib lib%.a",
+#elif defined(__CYGWIN__) || defined(WINDOWS32)
+    ".LIBPATTERNS", "lib%.dll.a %.dll.a lib%.a %.lib lib%.dll %.dll",
 #else
     ".LIBPATTERNS", "lib%.so lib%.a",
 #endif
-#endif
 #endif /* !VMS */
+    /* Make this assignment to avoid undefined variable warnings.  */
+    "GNUMAKEFLAGS", "",
 , 0
   };
 …
+{
   suffix_file = enter_file (strcache_add (".SUFFIXES"));
+  suffix_file->builtin = 1;
   if (no_builtin_rules_flag)
 …
   else
+    {
+      char *p = default_suffixes;
+      suffix_file->deps = enter_prereqs(PARSE_FILE_SEQ (&p, struct dep, '\0',
+                                                        NULL, 0),
+                                        NULL);
+      struct dep *d;
+      const char *p = default_suffixes;
+      suffix_file->deps = enter_prereqs (PARSE_SIMPLE_SEQ ((char **)&p, struct dep),
+                                         NULL);
+      for (d = suffix_file->deps; d; d = d->next)
+        d->file->builtin = 1;
       define_variable_cname ("SUFFIXES", default_suffixes, o_default, 0);
+    }
 …
 install_default_suffix_rules (void)
+{
   char **s;
+  const char **s;
   if (no_builtin_rules_flag)
 …
+    {
       struct file *f = enter_file (strcache_add (s[0]));
       /* Don't clobber cmds given in a makefile if there were any.  */
       if (f->cmds == 0)
+        {
           f->cmds = xmalloc (sizeof (struct commands));
           f->cmds->fileinfo.filenm = 0;
           f->cmds->commands = s[1];
           f->cmds->command_lines = 0;
+        }
+      /* This function should run before any makefile is parsed.  */
+      assert (f->cmds == 0);
+      f->cmds = xmalloc (sizeof (struct commands));
+      f->cmds->fileinfo.filenm = 0;
+      f->cmds->commands = xstrdup (s[1]);
+      f->cmds->command_lines = 0;
+      f->cmds->recipe_prefix = RECIPEPREFIX_DEFAULT;
+      f->builtin = 1;
+    }
+}
 …
     define_variable (s[0], strlen (s[0]), s[1], o_default, 1);
+}
+void
+undefine_default_variables (void)
+{
+  const char **s;
+  for (s = default_variables; *s != 0; s += 2)
+    undefine_variable_global (s[0], strlen (s[0]), o_default);
+}

vendor/gnumake/current/dep.h

-              r2596
+              r3138
 /* Definitions of dependency data structures for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
-/* Flag bits for the second argument to `read_makefile'.
-   These flags are saved in the `changed' field of each
-   `struct dep' in the chain returned by `read_all_makefiles'.  */
+#define RM_NO_DEFAULT_GOAL      (1 << 0) /* Do not set default goal.  */
+#define RM_INCLUDED             (1 << 1) /* Search makefile search path.  */
+#define RM_DONTCARE             (1 << 2) /* No error if it doesn't exist.  */
+#define RM_NO_TILDE             (1 << 3) /* Don't expand ~ in file name.  */
+#define RM_NOFLAG               0
+/* Structure used in chains of names, for parsing and globbing.  */
+#define NAMESEQ(_t)     \
+    _t *next;           \
+    const char *name
+struct nameseq
+  {
+    NAMESEQ (struct nameseq);
+  };
+/* Flag bits for the second argument to 'read_makefile'.
+   These flags are saved in the 'flags' field of each
+   'struct goaldep' in the chain returned by 'read_all_makefiles'.  */
+#define RM_NO_DEFAULT_GOAL      (1 << 0) /* Do not set default goal.  */
+#define RM_INCLUDED             (1 << 1) /* Search makefile search path.  */
+#define RM_DONTCARE             (1 << 2) /* No error if it doesn't exist.  */
+#define RM_NO_TILDE             (1 << 3) /* Don't expand ~ in file name.  */
+#define RM_NOFLAG               0
 /* Structure representing one dependency of a file.
+   Each struct file's `deps' points to a chain of these,
+   chained through the `next'. `stem' is the stem for this
+   dep line of static pattern rule or NULL.
+   Each struct file's 'deps' points to a chain of these, through 'next'.
+   'stem' is the stem for this dep line of static pattern rule or NULL.  */
+   Note that the first two words of this match a struct nameseq.  */
+#define DEP(_t)                                 \
+    NAMESEQ (_t);                               \
+    struct file *file;                          \
+    const char *stem;                           \
+    unsigned short flags : 8;                   \
+    unsigned short changed : 1;                 \
+    unsigned short ignore_mtime : 1;            \
+    unsigned short staticpattern : 1;           \
+    unsigned short need_2nd_expansion : 1
 struct dep
+  {
+    struct dep *next;
+    const char *name;
+    const char *stem;
+    struct file *file;
+    unsigned int changed : 8;
+    unsigned int ignore_mtime : 1;
+    unsigned int staticpattern : 1;
+    unsigned int need_2nd_expansion : 1;
+    unsigned int dontcare : 1;
+    DEP (struct dep);
   };
+/* Structure representing one goal.
+   The goals to be built constitute a chain of these, chained through 'next'.
+   'stem' is not used, but it's simpler to include and ignore it.  */
+/* Structure used in chains of names, for parsing and globbing.  */
+struct nameseq
+struct goaldep
+  {
+    struct nameseq *next;
+    const char *name;
+    DEP (struct goaldep);
+    unsigned short error;
+    floc floc;
   };
+/* Options for parsing lists of filenames.  */
 #define PARSEFS_NONE    (0x0000)
 #define PARSEFS_NOSTRIP (0x0001)
 #define PARSEFS_NOAR    (0x0002)
 #define PARSEFS_NOGLOB  (0x0004)
 #define PARSEFS_EXISTS  (0x0008)
 #define PARSEFS_NOCACHE (0x0010)
+#define PARSEFS_NONE    0x0000
+#define PARSEFS_NOSTRIP 0x0001
+#define PARSEFS_NOAR    0x0002
+#define PARSEFS_NOGLOB  0x0004
+#define PARSEFS_EXISTS  0x0008
+#define PARSEFS_NOCACHE 0x0010
 #define PARSE_FILE_SEQ(_s,_t,_c,_p,_f) \
             (_t *)parse_file_seq ((_s),sizeof (_t),(_c),(_p),(_f))
+#define PARSE_SIMPLE_SEQ(_s,_t) \
+            (_t *)parse_file_seq ((_s),sizeof (_t),MAP_NUL,NULL,PARSEFS_NONE)
 #ifdef VMS
 …
 #else
 void *parse_file_seq (char **stringp, unsigned int size,
                       int stopchar, const char *prefix, int flags);
+                      int stopmap, const char *prefix, int flags);
 #endif
 …
 #endif
 #define dep_name(d)     ((d)->name == 0 ? (d)->file->name : (d)->name)
+#define dep_name(d)        ((d)->name ? (d)->name : (d)->file->name)
+#define alloc_dep()     (xcalloc (sizeof (struct dep)))
+#define free_ns(_n)     free (_n)
+#define free_dep(_d)    free_ns (_d)
+#define alloc_seq_elt(_t)   xcalloc (sizeof (_t))
+void free_ns_chain (struct nameseq *n);
+#if defined(MAKE_MAINTAINER_MODE) && defined(__GNUC__)
+/* Use inline to get real type-checking.  */
+#define SI static inline
+SI struct nameseq *alloc_ns()      { return alloc_seq_elt (struct nameseq); }
+SI struct dep *alloc_dep()         { return alloc_seq_elt (struct dep); }
+SI struct goaldep *alloc_goaldep() { return alloc_seq_elt (struct goaldep); }
+SI void free_ns(struct nameseq *n)      { free (n); }
+SI void free_dep(struct dep *d)         { free_ns ((struct nameseq *)d); }
+SI void free_goaldep(struct goaldep *g) { free_dep ((struct dep *)g); }
+SI void free_dep_chain(struct dep *d)      { free_ns_chain((struct nameseq *)d); }
+SI void free_goal_chain(struct goaldep *g) { free_dep_chain((struct dep *)g); }
+#else
+# define alloc_ns()          alloc_seq_elt (struct nameseq)
+# define alloc_dep()         alloc_seq_elt (struct dep)
+# define alloc_goaldep()     alloc_seq_elt (struct goaldep)
+# define free_ns(_n)         free (_n)
+# define free_dep(_d)        free_ns (_d)
+# define free_goaldep(_g)    free_dep (_g)
+# define free_dep_chain(_d)  free_ns_chain ((struct nameseq *)(_d))
+# define free_goal_chain(_g) free_ns_chain ((struct nameseq *)(_g))
+#endif
 struct dep *copy_dep_chain (const struct dep *d);
+void free_dep_chain (struct dep *d);
+void free_ns_chain (struct nameseq *n);
+struct dep *read_all_makefiles (const char **makefiles);
+void eval_buffer (char *buffer);
+int update_goal_chain (struct dep *goals);
+struct goaldep *read_all_makefiles (const char **makefiles);
+void eval_buffer (char *buffer, const floc *floc);
+enum update_status update_goal_chain (struct goaldep *goals);

vendor/gnumake/current/dir.c

-              r2596
+              r3138
 /* Directory hashing for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include "hash.h"
+#ifdef  HAVE_DIRENT_H
+#include "filedef.h"
+#include "dep.h"
+#ifdef  HAVE_DIRENT_H
 # include <dirent.h>
 # define NAMLEN(dirent) strlen((dirent)->d_name)
 …
   /* First, transform the name part.  */
   for (i = 0; *filename != '\0' && i < 8 && *filename != '.'; ++i)
+  for (i = 0; i < 8 && ! STOP_SET (*filename, MAP_DOT|MAP_NUL); ++i)
     *df++ = tolower ((unsigned char)*filename++);
   /* Now skip to the next dot.  */
   while (*filename != '\0' && *filename != '.')
+  while (! STOP_SET (*filename, MAP_DOT|MAP_NUL))
     ++filename;
   if (*filename != '\0')
+    {
       *df++ = *filename++;
       for (i = 0; *filename != '\0' && i < 3 && *filename != '.'; ++i)
         *df++ = tolower ((unsigned char)*filename++);
+      for (i = 0; i < 3 && ! STOP_SET (*filename, MAP_DOT|MAP_NUL); ++i)
+        *df++ = tolower ((unsigned char)*filename++);
+    }
   /* Look for more dots.  */
   while (*filename != '\0' && *filename != '.')
+  while (! STOP_SET (*filename, MAP_DOT|MAP_NUL))
     ++filename;
   if (*filename == '.')
 …
 #ifdef VMS
+static char *
+downcase_inplace(char *filename)
+{
+  char *name;
+  name = filename;
+  while (*name != '\0')
+    {
+      *name = tolower ((unsigned char)*name);
+      ++name;
+    }
+  return filename;
+}
+#ifndef _USE_STD_STAT
+/* VMS 8.2 fixed the VMS stat output to have unique st_dev and st_ino
+   when _USE_STD_STAT is used on the compile line.
+   Prior to _USE_STD_STAT support, the st_dev is a pointer to thread
+   static memory containing the device of the last filename looked up.
+   Todo: find out if the ino_t still needs to be faked on a directory.
+ */
+/* Define this if the older VMS_INO_T is needed */
+#define VMS_INO_T 1
 static int
 vms_hash (const char *name)
+{
   int h = 0;
-  int g;
   while (*name)
+    {
       unsigned char uc = *name;
+      int g;
 #ifdef HAVE_CASE_INSENSITIVE_FS
       h = (h << 4) + (isupper (uc) ? tolower (uc) : uc);
 …
       g = h & 0xf0000000;
       if (g)
+        {
           h = h ^ (g >> 24);
           h = h ^ g;
+        }
+        {
+          h = h ^ (g >> 24);
+          h = h ^ g;
+        }
+    }
   return h;
 …
     return -1;
   closedir (dir);
   s = strchr (name, ':');       /* find device */
+  s = strchr (name, ':');       /* find device */
   if (s)
+    {
 …
   return 0;
+}
+# define stat(__path, __sbuf) vmsstat_dir (__path, __sbuf)
+#endif /* _USE_STD_STAT */
 #endif /* VMS */
 …
 /* Hash table of directories.  */
 #ifndef DIRECTORY_BUCKETS
+#ifndef DIRECTORY_BUCKETS
 #define DIRECTORY_BUCKETS 199
 #endif
 …
 struct directory_contents
+  {
     dev_t dev;                  /* Device and inode numbers of this dir.  */
+    dev_t dev;                  /* Device and inode numbers of this dir.  */
 #ifdef WINDOWS32
     /* Inode means nothing on WINDOWS32. Even file key information is
 …
      * unreliable. I'm open to suggestion on a better way to emulate inode.  */
     char *path_key;
     int   ctime;
     int   mtime;        /* controls check for stale directory cache */
     int   fs_flags;     /* FS_FAT, FS_NTFS, ... */
+    time_t ctime;
+    time_t mtime;        /* controls check for stale directory cache */
+    int fs_flags;     /* FS_FAT, FS_NTFS, ... */
 # define FS_FAT      0x1
 # define FS_NTFS     0x2
 # define FS_UNKNOWN  0x4
 #else
 # ifdef VMS
+# ifdef VMS_INO_T
     ino_t ino[3];
 # else
 …
 # endif
 #endif /* WINDOWS32 */
     struct hash_table dirfiles; /* Files in this directory.  */
     DIR *dirstream;             /* Stream reading this directory.  */
+    struct hash_table dirfiles; /* Files in this directory.  */
+    DIR *dirstream;             /* Stream reading this directory.  */
   };
 …
   hash ^= ((unsigned int) key->dev << 4) ^ (unsigned int) key->ctime;
 #else
 # ifdef VMS
+# ifdef VMS_INO_T
   hash = (((unsigned int) key->dev << 4)
           ^ ((unsigned int) key->ino[0]
              + (unsigned int) key->ino[1]
              + (unsigned int) key->ino[2]));
+          ^ ((unsigned int) key->ino[0]
+             + (unsigned int) key->ino[1]
+             + (unsigned int) key->ino[2]));
 # else
   hash = ((unsigned int) key->dev << 4) ^ (unsigned int) key->ino;
 …
   hash ^= ((unsigned int) key->dev << 4) ^ (unsigned int) ~key->ctime;
 #else
 # ifdef VMS
+# ifdef VMS_INO_T
   hash = (((unsigned int) key->dev << 4)
           ^ ~((unsigned int) key->ino[0]
               + (unsigned int) key->ino[1]
               + (unsigned int) key->ino[2]));
+          ^ ~((unsigned int) key->ino[0]
+              + (unsigned int) key->ino[1]
+              + (unsigned int) key->ino[2]));
 # else
   hash = ((unsigned int) key->dev << 4) ^ (unsigned int) ~key->ino;
 …
     return result;
 #else
 # ifdef VMS
+# ifdef VMS_INO_T
   result = MAKECMP(x->ino[0], y->ino[0]);
   if (result)
 …
 struct directory
+  {
     const char *name;                   /* Name of the directory.  */
+    const char *name;                   /* Name of the directory.  */
     /* The directory's contents.  This data may be shared by several
        entries in the hash table, which refer to the same directory
        (identified uniquely by `dev' and `ino') under different names.  */
+       (identified uniquely by 'dev' and 'ino') under different names.  */
     struct directory_contents *contents;
   };
 …
+{
   return_ISTRING_COMPARE (((const struct directory *) x)->name,
                           ((const struct directory *) y)->name);
+                          ((const struct directory *) y)->name);
+}
 …
 struct dirfile
+  {
     const char *name;           /* Name of the file.  */
     short length;
     short impossible;           /* This file is impossible.  */
+    const char *name;           /* Name of the file.  */
+    size_t length;
+    short impossible;           /* This file is impossible.  */
   };
 …
+}
 #ifndef DIRFILE_BUCKETS
+#ifndef DIRFILE_BUCKETS
 #define DIRFILE_BUCKETS 107
 #endif
 …
 static struct directory *find_directory (const char *name);
 /* Find the directory named NAME and return its `struct directory'.  */
+/* Find the directory named NAME and return its 'struct directory'.  */
 static struct directory *
 find_directory (const char *name)
+{
-  const char *p;
   struct directory *dir;
   struct directory **dir_slot;
   struct directory dir_key;
-  int r;
-#ifdef WINDOWS32
-  char* w32_path;
-  char  fs_label[BUFSIZ];
-  char  fs_type[BUFSIZ];
-  unsigned long  fs_serno;
-  unsigned long  fs_flags;
-  unsigned long  fs_len;
-#endif
-#ifdef VMS
-  if ((*name == '.') && (*(name+1) == 0))
-    name = "[]";
-  else
-    name = vmsify (name,1);
-#endif
   dir_key.name = name;
 …
   if (HASH_VACANT (dir))
+    {
+      /* The directory was not found.  Create a new entry for it.  */
+      const char *p = name + strlen (name);
       struct stat st;
+      /* The directory was not found.  Create a new entry for it.  */
+      p = name + strlen (name);
+      int r;
       dir = xmalloc (sizeof (struct directory));
 #if defined(HAVE_CASE_INSENSITIVE_FS) && defined(VMS)
+      dir->name = strcache_add_len (downcase(name), p - name);
+      /* Todo: Why is this only needed on VMS? */
+      {
+        char *lname = downcase_inplace (xstrdup (name));
+        dir->name = strcache_add_len (lname, p - name);
+        free (lname);
+      }
 #else
       dir->name = strcache_add_len (name, p - name);
 …
       hash_insert_at (&directories, dir, dir_slot);
       /* The directory is not in the name hash table.
+         Find its device and inode numbers, and look it up by them.  */
+#ifdef VMS
+      r = vmsstat_dir (name, &st);
+#elif defined(WINDOWS32)
+         Find its device and inode numbers, and look it up by them.  */
+#if defined(WINDOWS32)
+      {
         char tem[MAXPATHLEN], *tstart, *tend;
 …
       if (r < 0)
+        {
         /* Couldn't stat the directory.  Mark this by
            setting the `contents' member to a nil pointer.  */
           dir->contents = 0;
+        }
+        /* Couldn't stat the directory.  Mark this by
+           setting the 'contents' member to a nil pointer.  */
+          dir->contents = 0;
+        }
       else
+        {
+          /* Search the contents hash table; device and inode are the key.  */
+          struct directory_contents *dc;
+          struct directory_contents **dc_slot;
+          struct directory_contents dc_key;
+          dc_key.dev = st.st_dev;
+#ifdef WINDOWS32
+          dc_key.path_key = w32_path = w32ify (name, 1);
+          dc_key.ctime = st.st_ctime;
+#else
+# ifdef VMS
+          dc_key.ino[0] = st.st_ino[0];
+          dc_key.ino[1] = st.st_ino[1];
+          dc_key.ino[2] = st.st_ino[2];
+        {
+          /* Search the contents hash table; device and inode are the key.  */
+#ifdef WINDOWS32
+          char *w32_path;
+#endif
+          struct directory_contents *dc;
+          struct directory_contents **dc_slot;
+          struct directory_contents dc_key;
+          dc_key.dev = st.st_dev;
+#ifdef WINDOWS32
+          dc_key.path_key = w32_path = w32ify (name, 1);
+          dc_key.ctime = st.st_ctime;
+#else
+# ifdef VMS_INO_T
+          dc_key.ino[0] = st.st_ino[0];
+          dc_key.ino[1] = st.st_ino[1];
+          dc_key.ino[2] = st.st_ino[2];
 # else
           dc_key.ino = st.st_ino;
+          dc_key.ino = st.st_ino;
 # endif
 #endif
+          dc_slot = (struct directory_contents **) hash_find_slot (&directory_contents, &dc_key);
+          dc = *dc_slot;
+          if (HASH_VACANT (dc))
+            {
+              /* Nope; this really is a directory we haven't seen before.  */
+              dc = (struct directory_contents *)
+                xmalloc (sizeof (struct directory_contents));
+              /* Enter it in the contents hash table.  */
+              dc->dev = st.st_dev;
+          dc_slot = (struct directory_contents **) hash_find_slot (&directory_contents, &dc_key);
+          dc = *dc_slot;
+          if (HASH_VACANT (dc))
+            {
+              /* Nope; this really is a directory we haven't seen before.  */
+#ifdef WINDOWS32
+              char  fs_label[BUFSIZ];
+              char  fs_type[BUFSIZ];
+              unsigned long  fs_serno;
+              unsigned long  fs_flags;
+              unsigned long  fs_len;
+#endif
+              dc = (struct directory_contents *)
+                xmalloc (sizeof (struct directory_contents));
+              /* Enter it in the contents hash table.  */
+              dc->dev = st.st_dev;
 #ifdef WINDOWS32
               dc->path_key = xstrdup (w32_path);
               dc->ctime = st.st_ctime;
+              dc->ctime = st.st_ctime;
               dc->mtime = st.st_mtime;
+              /*
+               * NTFS is the only WINDOWS32 filesystem that bumps mtime
+               * on a directory when files are added/deleted from
+               * a directory.
+               */
+              /* NTFS is the only WINDOWS32 filesystem that bumps mtime on a
+                 directory when files are added/deleted from a directory.  */
               w32_path[3] = '\0';
+              if (GetVolumeInformation(w32_path,
+                     fs_label, sizeof (fs_label),
+                     &fs_serno, &fs_len,
+                     &fs_flags, fs_type, sizeof (fs_type)) == FALSE)
+              if (GetVolumeInformation (w32_path, fs_label, sizeof (fs_label),
+                                        &fs_serno, &fs_len, &fs_flags, fs_type,
+                                        sizeof (fs_type)) == FALSE)
                 dc->fs_flags = FS_UNKNOWN;
               else if (!strcmp(fs_type, "FAT"))
+              else if (!strcmp (fs_type, "FAT"))
                 dc->fs_flags = FS_FAT;
               else if (!strcmp(fs_type, "NTFS"))
+              else if (!strcmp (fs_type, "NTFS"))
                 dc->fs_flags = FS_NTFS;
               else
                 dc->fs_flags = FS_UNKNOWN;
 #else
 # ifdef VMS
               dc->ino[0] = st.st_ino[0];
               dc->ino[1] = st.st_ino[1];
               dc->ino[2] = st.st_ino[2];
+# ifdef VMS_INO_T
+              dc->ino[0] = st.st_ino[0];
+              dc->ino[1] = st.st_ino[1];
+              dc->ino[2] = st.st_ino[2];
 # else
               dc->ino = st.st_ino;
+              dc->ino = st.st_ino;
 # endif
 #endif /* WINDOWS32 */
               hash_insert_at (&directory_contents, dc, dc_slot);
               ENULLLOOP (dc->dirstream, opendir (name));
               if (dc->dirstream == 0)
+              hash_insert_at (&directory_contents, dc, dc_slot);
+              ENULLLOOP (dc->dirstream, opendir (name));
+              if (dc->dirstream == 0)
                 /* Couldn't open the directory.  Mark this by setting the
                    `files' member to a nil pointer.  */
+                   'files' member to a nil pointer.  */
                 dc->dirfiles.ht_vec = 0;
               else
+                {
                   hash_init (&dc->dirfiles, DIRFILE_BUCKETS,
                              dirfile_hash_1, dirfile_hash_2, dirfile_hash_cmp);
                   /* Keep track of how many directories are open.  */
                   ++open_directories;
                   if (open_directories == MAX_OPEN_DIRECTORIES)
                     /* We have too many directories open already.
                        Read the entire directory and then close it.  */
                     dir_contents_file_exists_p (dc, 0);
+                }
+            }
           /* Point the name-hashed entry for DIR at its contents data.  */
           dir->contents = dc;
+        }
+              else
+                {
+                  hash_init (&dc->dirfiles, DIRFILE_BUCKETS,
+                             dirfile_hash_1, dirfile_hash_2, dirfile_hash_cmp);
+                  /* Keep track of how many directories are open.  */
+                  ++open_directories;
+                  if (open_directories == MAX_OPEN_DIRECTORIES)
+                    /* We have too many directories open already.
+                       Read the entire directory and then close it.  */
+                    dir_contents_file_exists_p (dc, 0);
+                }
+            }
+          /* Point the name-hashed entry for DIR at its contents data.  */
+          dir->contents = dc;
+        }
+    }
 …
                             const char *filename)
+{
-  unsigned int hash;
   struct dirfile *df;
   struct dirent *d;
 …
     _fnlwr (filename); /* lower case for FAT drives */
 #endif
-#ifdef VMS
-  filename = vmsify (filename,0);
-#endif
-  hash = 0;
   if (filename != 0)
+    {
 …
       if (*filename == '\0')
+        {
           /* Checking if the directory exists.  */
           return 1;
+        }
+        {
+          /* Checking if the directory exists.  */
+          return 1;
+        }
       dirfile_key.name = filename;
       dirfile_key.length = strlen (filename);
 …
        */
       if (dir->path_key)
+        {
+        {
           if ((dir->fs_flags & FS_FAT) != 0)
+            {
               dir->mtime = time ((time_t *) 0);
               rehash = 1;
+            }
           else if (stat (dir->path_key, &st) == 0 && st.st_mtime > dir->mtime)
+            {
               /* reset date stamp to show most recent re-process.  */
               dir->mtime = st.st_mtime;
               rehash = 1;
+            }
+            {
+              dir->mtime = time ((time_t *) 0);
+              rehash = 1;
+            }
+          else if (stat (dir->path_key, &st) == 0 && st.st_mtime > dir->mtime)
+            {
+              /* reset date stamp to show most recent re-process.  */
+              dir->mtime = st.st_mtime;
+              rehash = 1;
+            }
           /* If it has been already read in, all done.  */
           if (!rehash)
             return 0;
+          if (!rehash)
+            return 0;
           /* make sure directory can still be opened; if not return.  */
 …
           if (!dir->dirstream)
             return 0;
+        }
+        }
       else
 #endif
         /* The directory has been all read in.  */
         return 0;
+        /* The directory has been all read in.  */
+        return 0;
+    }
 …
+        {
           if (errno)
             fatal (NILF, "INTERNAL: readdir: %s\n", strerror (errno));
+            pfatal_with_name ("INTERNAL: readdir");
           break;
+        }
 #if defined(VMS) && defined(HAVE_DIRENT_H)
+      /* In VMS we get file versions too, which have to be stripped off */
+      /* In VMS we get file versions too, which have to be stripped off.
+         Some versions of VMS return versions on Unix files even when
+         the feature option to strip them is set.  */
+      {
         char *p = strrchr (d->d_name, ';');
 …
 #endif
       if (!REAL_DIR_ENTRY (d))
         continue;
+        continue;
       len = NAMLEN (d);
 …
       if (! rehash || HASH_VACANT (*dirfile_slot))
 #endif
+        {
           df = xmalloc (sizeof (struct dirfile));
+        {
+          df = xmalloc (sizeof (struct dirfile));
 #if defined(HAVE_CASE_INSENSITIVE_FS) && defined(VMS)
+          df->name = strcache_add_len (downcase(d->d_name), len);
+#else
+          df->name = strcache_add_len (d->d_name, len);
+#endif
+          df->length = len;
+          df->impossible = 0;
+          hash_insert_at (&dir->dirfiles, df, dirfile_slot);
+        }
+          /* TODO: Why is this only needed on VMS? */
+          df->name = strcache_add_len (downcase_inplace (d->d_name), len);
+#else
+          df->name = strcache_add_len (d->d_name, len);
+#endif
+          df->length = len;
+          df->impossible = 0;
+          hash_insert_at (&dir->dirfiles, df, dirfile_slot);
+        }
       /* Check if the name matches the one we're searching for.  */
       if (filename != 0 && patheq (d->d_name, filename))
 …
 dir_file_exists_p (const char *dirname, const char *filename)
+{
+#ifdef VMS
+  if ((filename != NULL) && (dirname != NULL))
+    {
+      int want_vmsify;
+      want_vmsify = (strpbrk (dirname, ":<[") != NULL);
+      if (want_vmsify)
+        filename = vmsify (filename, 0);
+    }
+#endif
   return dir_contents_file_exists_p (find_directory (dirname)->contents,
                                      filename);
+                                     filename);
+}
 …
   const char *slash;
 #ifndef NO_ARCHIVES
+#ifndef NO_ARCHIVES
   if (ar_name (name))
     return ar_member_date (name) != (time_t) -1;
 #endif
+  dirend = strrchr (name, '/');
 #ifdef VMS
-  dirend = strrchr (name, ']');
   if (dirend == 0)
+    dirend = strrchr (name, ':');
+    {
+      dirend = strrchr (name, ']');
+      dirend == NULL ? dirend : dirend++;
+    }
   if (dirend == 0)
+    return dir_file_exists_p ("[]", name);
+#else /* !VMS */
+  dirend = strrchr (name, '/');
+    {
+      dirend = strrchr (name, '>');
+      dirend == NULL ? dirend : dirend++;
+    }
+  if (dirend == 0)
+    {
+      dirend = strrchr (name, ':');
+      dirend == NULL ? dirend : dirend++;
+    }
+#endif /* VMS */
 #ifdef HAVE_DOS_PATHS
   /* Forward and backslashes might be mixed.  We need the rightmost one.  */
+  {
     const char *bslash = strrchr(name, '\\');
+    const char *bslash = strrchr (name, '\\');
     if (!dirend || bslash > dirend)
       dirend = bslash;
 …
 #ifndef _AMIGA
     return dir_file_exists_p (".", name);
 #else /* !VMS && !AMIGA */
+#else /* !AMIGA */
     return dir_file_exists_p ("", name);
 #endif /* AMIGA */
-#endif /* VMS */
   slash = dirend;
 …
   /* d:/ and d: are *very* different...  */
       if (dirend < name + 3 && name[1] == ':' &&
           (*dirend == '/' || *dirend == '\\' || *dirend == ':'))
         dirend++;
+          (*dirend == '/' || *dirend == '\\' || *dirend == ':'))
+        dirend++;
 #endif
       p = alloca (dirend - name + 1);
 …
       dirname = p;
+    }
+  return dir_file_exists_p (dirname, slash + 1);
+}
+/* Mark FILENAME as `impossible' for `file_impossible_p'.
+#ifdef VMS
+  if (*slash == '/')
+    slash++;
+#else
+  slash++;
+#endif
+  return dir_file_exists_p (dirname, slash);
+}
+/* Mark FILENAME as 'impossible' for 'file_impossible_p'.
    This means an attempt has been made to search for FILENAME
    as an intermediate file, and it has failed.  */
 …
   struct dirfile *new;
+  dirend = strrchr (p, '/');
 #ifdef VMS
+  dirend = strrchr (p, ']');
+  if (dirend == 0)
+    dirend = strrchr (p, ':');
+  dirend++;
+  if (dirend == (char *)1)
+    dir = find_directory ("[]");
+#else
+  dirend = strrchr (p, '/');
+# ifdef HAVE_DOS_PATHS
+  if (dirend == NULL)
+    {
+      dirend = strrchr (p, ']');
+      dirend == NULL ? dirend : dirend++;
+    }
+  if (dirend == NULL)
+    {
+      dirend = strrchr (p, '>');
+      dirend == NULL ? dirend : dirend++;
+    }
+  if (dirend == NULL)
+    {
+      dirend = strrchr (p, ':');
+      dirend == NULL ? dirend : dirend++;
+    }
+#endif
+#ifdef HAVE_DOS_PATHS
   /* Forward and backslashes might be mixed.  We need the rightmost one.  */
+  {
     const char *bslash = strrchr(p, '\\');
+    const char *bslash = strrchr (p, '\\');
     if (!dirend || bslash > dirend)
       dirend = bslash;
 …
       dirend = p + 1;
+  }
 # endif /* HAVE_DOS_PATHS */
+#endif /* HAVE_DOS_PATHS */
   if (dirend == 0)
 # ifdef _AMIGA
+#ifdef _AMIGA
     dir = find_directory ("");
 # else /* !VMS && !AMIGA */
+#else /* !AMIGA */
     dir = find_directory (".");
+# endif /* AMIGA */
+#endif /* VMS */
+#endif /* AMIGA */
   else
+    {
 …
       const char *slash = dirend;
       if (dirend == p)
         dirname = "/";
+        dirname = "/";
       else
+        {
+        {
           char *cp;
 #ifdef HAVE_DOS_PATHS
           /* d:/ and d: are *very* different...  */
           if (dirend < p + 3 && p[1] == ':' &&
               (*dirend == '/' || *dirend == '\\' || *dirend == ':'))
             dirend++;
 #endif
           cp = alloca (dirend - p + 1);
           memcpy (cp, p, dirend - p);
           cp[dirend - p] = '\0';
+          /* d:/ and d: are *very* different...  */
+          if (dirend < p + 3 && p[1] == ':' &&
+              (*dirend == '/' || *dirend == '\\' || *dirend == ':'))
+            dirend++;
+#endif
+          cp = alloca (dirend - p + 1);
+          memcpy (cp, p, dirend - p);
+          cp[dirend - p] = '\0';
           dirname = cp;
+        }
+        }
       dir = find_directory (dirname);
+#ifdef VMS
+      if (*slash == '/')
+        filename = p = slash + 1;
+      else
+        filename = p = slash;
+#else
       filename = p = slash + 1;
+#endif
+    }
 …
+    {
       hash_init (&dir->contents->dirfiles, DIRFILE_BUCKETS,
                  dirfile_hash_1, dirfile_hash_2, dirfile_hash_cmp);
+                 dirfile_hash_1, dirfile_hash_2, dirfile_hash_cmp);
+    }
 …
   new->length = strlen (filename);
 #if defined(HAVE_CASE_INSENSITIVE_FS) && defined(VMS)
+  new->name = strcache_add_len (downcase(filename), new->length);
+  /* todo: Why is this only needed on VMS? */
+  new->name = strcache_add_len (downcase (filename), new->length);
 #else
   new->name = strcache_add_len (filename, new->length);
 …
+{
   const char *dirend;
-  const char *p = filename;
   struct directory_contents *dir;
   struct dirfile *dirfile;
   struct dirfile dirfile_key;
 #ifdef VMS
+  dirend = strrchr (filename, ']');
+  if (dirend == 0)
+    dir = find_directory ("[]")->contents;
+#else
+  int want_vmsify = 0;
+#endif
   dirend = strrchr (filename, '/');
+#ifdef VMS
+  if (dirend == NULL)
+    {
+      want_vmsify = (strpbrk (filename, "]>:^") != NULL);
+      dirend = strrchr (filename, ']');
+    }
+  if (dirend == NULL && want_vmsify)
+    dirend = strrchr (filename, '>');
+  if (dirend == NULL && want_vmsify)
+    dirend = strrchr (filename, ':');
+#endif
 #ifdef HAVE_DOS_PATHS
   /* Forward and backslashes might be mixed.  We need the rightmost one.  */
+  {
     const char *bslash = strrchr(filename, '\\');
+    const char *bslash = strrchr (filename, '\\');
     if (!dirend || bslash > dirend)
       dirend = bslash;
 …
 #ifdef _AMIGA
     dir = find_directory ("")->contents;
 #else /* !VMS && !AMIGA */
+#else /* !AMIGA */
     dir = find_directory (".")->contents;
 #endif /* AMIGA */
-#endif /* VMS */
   else
+    {
 …
       const char *slash = dirend;
       if (dirend == filename)
         dirname = "/";
+        dirname = "/";
       else
+        {
+        {
           char *cp;
 #ifdef HAVE_DOS_PATHS
           /* d:/ and d: are *very* different...  */
           if (dirend < filename + 3 && filename[1] == ':' &&
               (*dirend == '/' || *dirend == '\\' || *dirend == ':'))
             dirend++;
 #endif
           cp = alloca (dirend - filename + 1);
           memcpy (cp, p, dirend - p);
           cp[dirend - p] = '\0';
+          /* d:/ and d: are *very* different...  */
+          if (dirend < filename + 3 && filename[1] == ':' &&
+              (*dirend == '/' || *dirend == '\\' || *dirend == ':'))
+            dirend++;
+#endif
+          cp = alloca (dirend - filename + 1);
+          memcpy (cp, filename, dirend - filename);
+          cp[dirend - filename] = '\0';
           dirname = cp;
+        }
+        }
       dir = find_directory (dirname)->contents;
+      p = filename = slash + 1;
+#ifdef VMS
+      if (*slash == '/')
+        filename = slash + 1;
+      else
+        filename = slash;
+#else
+      filename = slash + 1;
+#endif
+    }
 …
 #ifdef __MSDOS__
   filename = dosify (p);
+  filename = dosify (filename);
 #endif
 #ifdef HAVE_CASE_INSENSITIVE_FS
   filename = downcase (p);
+  filename = downcase (filename);
 #endif
 #ifdef VMS
+  filename = vmsify (p, 1);
+  if (want_vmsify)
+    filename = vmsify (filename, 1);
 #endif
 …
       struct directory *dir = *dir_slot;
       if (! HASH_VACANT (dir))
+        {
+          if (dir->contents == 0)
+            printf (_("# %s: could not be stat'd.\n"), dir->name);
+          else if (dir->contents->dirfiles.ht_vec == 0)
+            {
+#ifdef WINDOWS32
+              printf (_("# %s (key %s, mtime %d): could not be opened.\n"),
+                      dir->name, dir->contents->path_key,dir->contents->mtime);
+        {
+          if (dir->contents == 0)
+            printf (_("# %s: could not be stat'd.\n"), dir->name);
+          else if (dir->contents->dirfiles.ht_vec == 0)
+            {
+#ifdef WINDOWS32
+              printf (_("# %s (key %s, mtime %I64u): could not be opened.\n"),
+                      dir->name, dir->contents->path_key,
+                      (unsigned long long)dir->contents->mtime);
 #else  /* WINDOWS32 */
 #ifdef VMS
               printf (_("# %s (device %d, inode [%d,%d,%d]): could not be opened.\n"),
                       dir->name, dir->contents->dev,
                       dir->contents->ino[0], dir->contents->ino[1],
                       dir->contents->ino[2]);
 #else
               printf (_("# %s (device %ld, inode %ld): could not be opened.\n"),
                       dir->name, (long int) dir->contents->dev,
                       (long int) dir->contents->ino);
+#ifdef VMS_INO_T
+              printf (_("# %s (device %d, inode [%d,%d,%d]): could not be opened.\n"),
+                      dir->name, dir->contents->dev,
+                      dir->contents->ino[0], dir->contents->ino[1],
+                      dir->contents->ino[2]);
+#else
+              printf (_("# %s (device %ld, inode %ld): could not be opened.\n"),
+                      dir->name, (long int) dir->contents->dev,
+                      (long int) dir->contents->ino);
 #endif
 #endif /* WINDOWS32 */
+            }
+          else
+            {
+              unsigned int f = 0;
+              unsigned int im = 0;
+              struct dirfile **files_slot;
+              struct dirfile **files_end;
+              files_slot = (struct dirfile **) dir->contents->dirfiles.ht_vec;
+              files_end = files_slot + dir->contents->dirfiles.ht_size;
+              for ( ; files_slot < files_end; files_slot++)
+                {
+                  struct dirfile *df = *files_slot;
+                  if (! HASH_VACANT (df))
+                    {
+                      if (df->impossible)
+                        ++im;
+                      else
+                        ++f;
+                    }
+                }
+#ifdef WINDOWS32
+              printf (_("# %s (key %s, mtime %d): "),
+                      dir->name, dir->contents->path_key, dir->contents->mtime);
+            }
+          else
+            {
+              unsigned int f = 0;
+              unsigned int im = 0;
+              struct dirfile **files_slot;
+              struct dirfile **files_end;
+              files_slot = (struct dirfile **) dir->contents->dirfiles.ht_vec;
+              files_end = files_slot + dir->contents->dirfiles.ht_size;
+              for ( ; files_slot < files_end; files_slot++)
+                {
+                  struct dirfile *df = *files_slot;
+                  if (! HASH_VACANT (df))
+                    {
+                      if (df->impossible)
+                        ++im;
+                      else
+                        ++f;
+                    }
+                }
+#ifdef WINDOWS32
+              printf (_("# %s (key %s, mtime %I64u): "),
+                      dir->name, dir->contents->path_key,
+                      (unsigned long long)dir->contents->mtime);
 #else  /* WINDOWS32 */
 #ifdef VMS
               printf (_("# %s (device %d, inode [%d,%d,%d]): "),
                       dir->name, dir->contents->dev,
                       dir->contents->ino[0], dir->contents->ino[1],
                       dir->contents->ino[2]);
 #else
               printf (_("# %s (device %ld, inode %ld): "),
                       dir->name,
                       (long)dir->contents->dev, (long)dir->contents->ino);
+#ifdef VMS_INO_T
+              printf (_("# %s (device %d, inode [%d,%d,%d]): "),
+                      dir->name, dir->contents->dev,
+                      dir->contents->ino[0], dir->contents->ino[1],
+                      dir->contents->ino[2]);
+#else
+              printf (_("# %s (device %ld, inode %ld): "),
+                      dir->name,
+                      (long)dir->contents->dev, (long)dir->contents->ino);
 #endif
 #endif /* WINDOWS32 */
               if (f == 0)
                 fputs (_("No"), stdout);
               else
                 printf ("%u", f);
               fputs (_(" files, "), stdout);
               if (im == 0)
                 fputs (_("no"), stdout);
               else
                 printf ("%u", im);
               fputs (_(" impossibilities"), stdout);
               if (dir->contents->dirstream == 0)
                 puts (".");
               else
                 puts (_(" so far."));
               files += f;
               impossible += im;
+            }
+        }
+              if (f == 0)
+                fputs (_("No"), stdout);
+              else
+                printf ("%u", f);
+              fputs (_(" files, "), stdout);
+              if (im == 0)
+                fputs (_("no"), stdout);
+              else
+                printf ("%u", im);
+              fputs (_(" impossibilities"), stdout);
+              if (dir->contents->dirstream == 0)
+                puts (".");
+              else
+                puts (_(" so far."));
+              files += f;
+              impossible += im;
+            }
+        }
+    }
 …
 /* Hooks for globbing.  */
-#include <glob.h>
 /* Structure describing state of iterating through a directory hash table.  */
 …
       struct dirfile *df = *ds->dirfile_slot++;
       if (! HASH_VACANT (df) && !df->impossible)
+        {
           /* The glob interface wants a `struct dirent', so mock one up.  */
           struct dirent *d;
           unsigned int len = df->length + 1;
+        {
+          /* The glob interface wants a 'struct dirent', so mock one up.  */
+          struct dirent *d;
+          unsigned int len = df->length + 1;
           unsigned int sz = sizeof (*d) - sizeof (d->d_name) + len;
           if (sz > bufsz)
+            {
               bufsz *= 2;
               if (sz > bufsz)
                 bufsz = sz;
               buf = xrealloc (buf, bufsz);
+            }
           d = (struct dirent *) buf;
+          if (sz > bufsz)
+            {
+              bufsz *= 2;
+              if (sz > bufsz)
+                bufsz = sz;
+              buf = xrealloc (buf, bufsz);
+            }
+          d = (struct dirent *) buf;
 #ifdef __MINGW32__
 # if __MINGW32_MAJOR_VERSION < 3 || (__MINGW32_MAJOR_VERSION == 3 && \
                                      __MINGW32_MINOR_VERSION == 0)
           d->d_name = xmalloc(len);
+                                     __MINGW32_MINOR_VERSION == 0)
+          d->d_name = xmalloc (len);
 # endif
 #endif
           FAKE_DIR_ENTRY (d);
+          FAKE_DIR_ENTRY (d);
 #ifdef _DIRENT_HAVE_D_NAMLEN
           d->d_namlen = len - 1;
+          d->d_namlen = len - 1;
 #endif
 #ifdef _DIRENT_HAVE_D_TYPE
           d->d_type = DT_UNKNOWN;
 #endif
           memcpy (d->d_name, df->name, len);
           return d;
+        }
+          d->d_type = DT_UNKNOWN;
+#endif
+          memcpy (d->d_name, df->name, len);
+          return d;
+        }
+    }
   return 0;
+}
-static void
-ansi_free (void *p)
+{
-  if (p)
-    free(p);
+}
 …
  * macro for stat64().  If stat is a macro, make a local wrapper function to
  * invoke it.
+ *
+ * On MS-Windows, stat() "succeeds" for foo/bar/. where foo/bar is a
+ * regular file; fix that here.
  */
 #ifndef stat
+#if !defined(stat) && !defined(WINDOWS32) || defined(VMS)
 # ifndef VMS
+#  ifndef HAVE_SYS_STAT_H
 int stat (const char *path, struct stat *sbuf);
+#  endif
+# else
+    /* We are done with the fake stat.  Go back to the real stat */
+#   ifdef stat
+#     undef stat
+#   endif
 # endif
 # define local_stat stat
 …
+{
   int e;
+#ifdef WINDOWS32
+  size_t plen = strlen (path);
+  /* Make sure the parent of "." exists and is a directory, not a
+     file.  This is because 'stat' on Windows normalizes the argument
+     foo/. => foo without checking first that foo is a directory.  */
+  if (plen > 1 && path[plen - 1] == '.'
+      && (path[plen - 2] == '/' || path[plen - 2] == '\\'))
+    {
+      char parent[MAXPATHLEN];
+      strncpy (parent, path, plen - 2);
+      parent[plen - 2] = '\0';
+      if (stat (parent, buf) < 0 || !_S_ISDIR (buf->st_mode))
+        return -1;
+    }
+#endif
   EINTRLOOP (e, stat (path, buf));
 …
   gl->gl_opendir = open_dirstream;
   gl->gl_readdir = read_dirstream;
   gl->gl_closedir = ansi_free;
+  gl->gl_closedir = free;
   gl->gl_stat = local_stat;
   /* We don't bother setting gl_lstat, since glob never calls it.
 …
+{
   hash_init (&directories, DIRECTORY_BUCKETS,
              directory_hash_1, directory_hash_2, directory_hash_cmp);
+             directory_hash_1, directory_hash_2, directory_hash_cmp);
   hash_init (&directory_contents, DIRECTORY_BUCKETS,
              directory_contents_hash_1, directory_contents_hash_2,
+             directory_contents_hash_1, directory_contents_hash_2,
              directory_contents_hash_cmp);
+}

vendor/gnumake/current/doc/Makefile.am

-              r2596
+              r3138
 # -*-Makefile-*-, or close enough
+# Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+# 2010 Free Software Foundation, Inc.
+# Copyright (C) 2000-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 CLEANFILES = make*.html
-## ----------------------------- ##
-## Other documentation formats.  ##
-## ----------------------------- ##
-html: make_1.html
-make_1.html: $(info_TEXINFOS) $(make_TEXINFOS)
-        $(TEXI2HTML) $(TEXI2HTML_FLAGS) $(srcdir)/make.texi
-.PHONY: html

vendor/gnumake/current/doc/make.texi

-              r2596
+              r3138
 @include version.texi
+@set EDITION 0.71
+@set RCSID $Id: make.texi,v 1.66 2010/07/19 07:10:54 psmith Exp $
+@set EDITION 0.74
 @settitle GNU @code{make}
 …
 Copyright @copyright{} 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
 , 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007,
+, 2009, 2010 Free Software Foundation, Inc.
+, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Free Software
+Foundation, Inc.
 @quotation
 Permission is granted to copy, distribute and/or modify this document
 under the terms of the GNU Free Documentation License, Version 1.2 or
+under the terms of the GNU Free Documentation License, Version 1.3 or
 any later version published by the Free Software Foundation; with no
 Invariant Sections, with the Front-Cover Texts being ``A GNU Manual,''
 …
                                   based on their file names.
 * Archives::                    How @code{make} can update library archives.
+* Extending make::              Using extensions to @code{make}.
+* Integrating make::            Integrating @code{make} with other tools.
 * Features::                    Features GNU @code{make} has over other @code{make}s.
 * Missing::                     What GNU @code{make} lacks from other @code{make}s.
 …
                                   but nontrivial, makefile.
 * GNU Free Documentation License::  License for copying this manual
 * Concept Index::               Index of Concepts
 * Name Index::                  Index of Functions, Variables, & Directives
+* GNU Free Documentation License::  License for copying this manual.
+* Concept Index::               Index of Concepts.
+* Name Index::                  Index of Functions, Variables, & Directives.
 @detailmenu
 …
 Overview of @code{make}
 * Preparing::                   Preparing and running make
 * Reading::                     On reading this text
 * Bugs::                        Problems and bugs
+* Preparing::                   Preparing and running @code{make}.
+* Reading::                     On reading this text.
+* Bugs::                        Problems and bugs.
 An Introduction to Makefiles
 * Rule Introduction::           What a rule looks like.
 * Simple Makefile::             A simple makefile
 * How Make Works::              How @code{make} processes this makefile
 * Variables Simplify::          Variables make makefiles simpler
 * make Deduces::                Letting @code{make} deduce the recipe
 * Combine By Prerequisite::     Another style of makefile
 * Cleanup::                     Rules for cleaning the directory
+* Simple Makefile::             A simple makefile.
+* How Make Works::              How @code{make} processes this makefile.
+* Variables Simplify::          Variables make makefiles simpler.
+* make Deduces::                Letting @code{make} deduce the recipes.
+* Combine By Prerequisite::     Another style of makefile.
+* Cleanup::                     Rules for cleaning the directory.
 Writing Makefiles
 …
 * Reading Makefiles::           How makefiles are parsed.
 * Secondary Expansion::         How and when secondary expansion is performed.
+What Makefiles Contain
+* Splitting Lines::             Splitting long lines in makefiles
 Writing Rules
 …
 Using Wildcard Characters in File Names
 * Wildcard Examples::           Several examples
+* Wildcard Examples::           Several examples.
 * Wildcard Pitfall::            Problems to avoid.
 * Wildcard Function::           How to cause wildcard expansion where
 …
 Recipe Syntax
 * Splitting Lines::             Breaking long recipe lines for readability.
+* Splitting Recipe Lines::      Breaking long recipe lines for readability.
 * Variables in Recipes::        Using @code{make} variables in recipes.
 Recipe Execution
+* One Shell::                   One shell for all lines in a recipe.
 * Choosing the Shell::          How @code{make} chooses the shell used
                                   to run recipes.
+Parallel Execution
+* Parallel Output::             Handling output during parallel execution
+* Parallel Input::              Handling input during parallel execution
 Recursive Use of @code{make}
 …
 * Multi-Line::                  An alternate way to set a variable
                                   to a multi-line string.
+* Undefine Directive::          How to undefine a variable so that it appears
+                                  as if it was never set.
 * Environment::                 Variable values can come from the environment.
 * Target-specific::             Variable values can be defined on a per-target
 …
 * Conditional Functions::       Functions that implement conditions.
 * Foreach Function::            Repeat some text with controlled variation.
+* File Function::               Write text to a file.
 * Call Function::               Expand a user-defined function.
 * Value Function::              Return the un-expanded value of a variable.
 …
 * Origin Function::             Find where a variable got its value.
 * Flavor Function::             Find out the flavor of a variable.
+* Make Control Functions::      Functions that control how make runs.
 * Shell Function::              Substitute the output of a shell command.
 * Make Control Functions::      Functions that control how make runs.
+* Guile Function::              Use GNU Guile embedded scripting language.
 How to Run @code{make}
 …
 * Using Implicit::              How to use an existing implicit rule
                                   to get the recipe for updating a file.
 * Catalogue of Rules::          A list of built-in implicit rules.
+                                  to get the recipes for updating a file.
+* Catalogue of Rules::          A list of built-in rules.
 * Implicit Variables::          How to change what predefined rules do.
 * Chained Rules::               How to use a chain of implicit rules.
 …
 * Archive Symbols::             How to update archive symbol directories.
+Extending GNU @code{make}
+* Guile Integration::           Using Guile as an embedded scripting language.
+* Loading Objects::             Loading dynamic objects as extensions.
+GNU Guile Integration
+* Guile Types::                 Converting Guile types to @code{make} strings.
+* Guile Interface::             Invoking @code{make} functions from Guile.
+* Guile Example::               Example using Guile in @code{make}.
+Loading Dynamic Objects
+* load Directive::              Loading dynamic objects as extensions.
+* Remaking Loaded Objects::     How loaded objects get remade.
+* Loaded Object API::           Programmatic interface for loaded objects.
+* Loaded Object Example::       Example of a loaded object
+Integrating GNU @code{make}
+* Job Slots::                   Share job slots with GNU @code{make}.
+* Terminal Output::             Control output to terminals.
+Sharing Job Slots with GNU @code{make}
+* POSIX Jobserver::             Using the jobserver on POSIX systems.
+* Windows Jobserver::           Using the jobserver on Windows systems.
 @end detailmenu
 @end menu
 …
 @menu
 * Preparing::                   Preparing and Running Make
 * Reading::                     On Reading this Text
 * Bugs::                        Problems and Bugs
+* Preparing::                   Preparing and running @code{make}.
+* Reading::                     On reading this text.
+* Bugs::                        Problems and bugs.
 @end menu
 …
 @menu
 * Rule Introduction::           What a rule looks like.
 * Simple Makefile::             A Simple Makefile
 * How Make Works::              How @code{make} Processes This Makefile
 * Variables Simplify::          Variables Make Makefiles Simpler
 * make Deduces::                Letting @code{make} Deduce the Recipes
 * Combine By Prerequisite::     Another Style of Makefile
 * Cleanup::                     Rules for Cleaning the Directory
+* Simple Makefile::             A simple makefile.
+* How Make Works::              How @code{make} processes this makefile.
+* Variables Simplify::          Variables make makefiles simpler.
+* make Deduces::                Letting @code{make} deduce the recipes.
+* Combine By Prerequisite::     Another style of makefile.
+* Cleanup::                     Rules for cleaning the directory.
 @end menu
 …
 @noindent
+We split each long line into two lines using backslash-newline; this is
+like using one long line, but is easier to read.
+We split each long line into two lines using backslash/newline; this is
+like using one long line, but is easier to read.  @xref{Splitting Lines,
+, Splitting Long Lines}.
 @cindex continuation lines
 @cindex @code{\} (backslash), for continuation lines
 …
 @end itemize
+@menu
+* Splitting Lines::             Splitting long lines in makefiles
+@end menu
+@node Splitting Lines,  , Makefile Contents, Makefile Contents
+@subsection Splitting Long Lines
+@cindex splitting long lines
+@cindex long lines, splitting
+@cindex backslash (@code{\}), to quote newlines
+Makefiles use a ``line-based'' syntax in which the newline character
+is special and marks the end of a statement.  GNU @code{make} has no
+limit on the length of a statement line, up to the amount of memory in
+your computer.
+However, it is difficult to read lines which are too long to display
+without wrapping or scrolling.  So, you can format your makefiles for
+readability by adding newlines into the middle of a statement: you do
+this by escaping the internal newlines with a backslash (@code{\})
+character.  Where we need to make a distinction we will refer to
+``physical lines'' as a single line ending with a newline (regardless
+of whether it is escaped) and a ``logical line'' being a complete
+statement including all escaped newlines up to the first non-escaped
+newline.
+The way in which backslash/newline combinations are handled depends on
+whether the statement is a recipe line or a non-recipe line.  Handling
+of backslash/newline in a recipe line is discussed later
+(@pxref{Splitting Recipe Lines}).
+Outside of recipe lines, backslash/newlines are converted into a
+single space character.  Once that is done, all whitespace around the
+backslash/newline is condensed into a single space: this includes all
+whitespace preceding the backslash, all whitespace at the beginning of
+the line after the backslash/newline, and any consecutive
+backslash/newline combinations.
+If the @code{.POSIX} special target is defined then backslash/newline
+handling is modified slightly to conform to POSIX.2: first, whitespace
+preceding a backslash is not removed and second, consecutive
+backslash/newlines are not condensed.
 @node Makefile Names, Include, Makefile Contents, Makefiles
 @section What Name to Give Your Makefile
 …
 @node Remaking Makefiles, Overriding Makefiles, MAKEFILES Variable, Makefiles
 @section How Makefiles Are Remade
 @cindex updating makefiles
 @cindex remaking makefiles
 …
 you want to keep @code{make} from performing an implicit rule search
 on them, perhaps for efficiency reasons, you can use any normal method
 of preventing implicit rule lookup to do so.  For example, you can
+of preventing implicit rule look-up to do so.  For example, you can
 write an explicit rule with the makefile as the target, and an empty
 recipe (@pxref{Empty Recipes, ,Using Empty Recipes}).
 …
 another makefile.  You can often use the @samp{include} directive to
 include one in the other, and add more targets or variable definitions.
 However, it is illegal for two makefiles to give different recipes for
+However, it is invalid for two makefiles to give different recipes for
 the same target.  But there is another way.
 …
 @cindex ?=, expansion
 @cindex +=, expansion
+@cindex !=, expansion
 @cindex define, expansion
 …
 @var{immediate} ?= @var{deferred}
 @var{immediate} := @var{immediate}
+@var{immediate} ::= @var{immediate}
 @var{immediate} += @var{deferred} or @var{immediate}
+@var{immediate} != @var{immediate}
 define @var{immediate}
 …
 endef
+define @var{immediate} ::=
+  @var{immediate}
+endef
 define @var{immediate} +=
   @var{deferred} or @var{immediate}
 endef
+define @var{immediate} !=
+  @var{immediate}
+endef
 @end example
 For the append operator, @samp{+=}, the right-hand side is considered
 immediate if the variable was previously set as a simple variable
+(@samp{:=}), and deferred otherwise.
+(@samp{:=} or @samp{::=}), and deferred otherwise.
+For the shell assignment operator, @samp{!=}, the right-hand side is
+evaluated immediately and handed to the shell.  The result is stored in the
+variable named on the left, and that variable becomes a simple variable
+(and will thus be re-evaluated on each reference).
 @subheading Conditional Directives
 …
 @example
 @var{immediate} : @var{immediate} ; @var{deferred}
         @var{deferred}
+        @var{deferred}
 @end example
 …
 without being recognized as a variable reference.  Now during the
 secondary expansion the first word is expanded again but since it
 contains no variable or function references it remains the static
 value @file{onefile}, while the second word is now a normal reference
+to the variable @var{TWOVAR}, which is expanded to the value
+@file{twofile}.  The final result is that there are two prerequisites,
 @file{onefile} and @file{twofile}.
+contains no variable or function references it remains the value
+@file{onefile}, while the second word is now a normal reference to the
+variable @var{TWOVAR}, which is expanded to the value @file{twofile}.
+The final result is that there are two prerequisites, @file{onefile}
+and @file{twofile}.
 Obviously, this is not a very interesting case since the same result
 …
 Search, ,Implicit Rule Search Algorithm}, is appended (after
 expansion) to all the patterns in the prerequisites list.  As an
 example:
+example:@refill
 @example
 …
 %.o: $$(addsuffix /%.c,foo bar) foo.h
+@end example
+The prerequisite list after the secondary expansion and directory
+prefix reconstruction will be @file{/tmp/foo/foo.c /tmp/var/bar/foo.c
+foo.h}.  If you are not interested in this reconstruction, you can use
+@code{$$*} instead of @code{%} in the prerequisites list.
+        @@echo $^
+@end example
+The prerequisite list printed, after the secondary expansion and
+directory prefix reconstruction, will be @file{/tmp/foo/foo.c
+/tmp/bar/foo.c foo.h}.  If you are not interested in this
+reconstruction, you can use @code{$$*} instead of @code{%} in the
+prerequisites list.
 @node Rules, Recipes, Makefiles, Top
 …
 * Directory Search::            Searching other directories for source files.
 * Phony Targets::               Using a target that is not a real file's name.
 * Force Targets::               You can use a target without recipes
+* Force Targets::               You can use a target without a recipe
                                   or prerequisites to mark other targets
                                   as phony.
 …
 @menu
 * Wildcard Examples::           Several examples
+* Wildcard Examples::           Several examples.
 * Wildcard Pitfall::            Problems to avoid.
 * Wildcard Function::           How to cause wildcard expansion where
 …
                                   for a specified class of names.
 * Search Algorithm::            When and how search paths are applied.
 * Recipes/Search::             How to write recipes that work together
+* Recipes/Search::              How to write recipes that work together
                                   with search paths.
 * Implicit/Search::             How search paths affect implicit rules.
 …
 @samp{-l@var{name}} is seen, @code{make} will replace the percent in
 each pattern in the list with @var{name} and perform the above directory
 searches using each library filename.
+searches using each library file name.
 The default value for @code{.LIBPATTERNS} is @samp{lib%.so lib%.a},
 …
 @findex .PHONY
+The phony target will cease to work if anything ever does create a file
+named @file{clean} in this directory.  Since it has no prerequisites, the
+file @file{clean} would inevitably be considered up to date, and its
+recipe would not be executed.  To avoid this problem, you can explicitly
+declare the target to be phony, using the special target @code{.PHONY}
+In this example, the @file{clean} target will not work properly if a
+file named @file{clean} is ever created in this directory.  Since it
+has no prerequisites, @file{clean} would always be considered up to
+date and its recipe would not be executed.  To avoid this problem you
+can explicitly declare the target to be phony by making it a
+prerequisite of the special target @code{.PHONY}
 (@pxref{Special Targets, ,Special Built-in Target Names}) as follows:
-@example
-.PHONY : clean
-@end example
-@noindent
-Once this is done, @samp{make clean} will run the recipe regardless of
-whether there is a file named @file{clean}.
-Since it knows that phony targets do not name actual files that could be
-remade from other files, @code{make} skips the implicit rule search for
-phony targets (@pxref{Implicit Rules}).  This is why declaring a target
-phony is good for performance, even if you are not worried about the
-actual file existing.
-Thus, you first write the line that states that @code{clean} is a
-phony target, then you write the rule, like this:
 @example
 …
 @end example
+Another example of the usefulness of phony targets is in conjunction
+with recursive invocations of @code{make} (for more information, see
+@ref{Recursion, ,Recursive Use of @code{make}}).  In this case the
+makefile will often contain a variable which lists a number of
+subdirectories to be built.  One way to handle this is with one rule
+whose recipe is a shell loop over the subdirectories, like this:
+@noindent
+Once this is done, @samp{make clean} will run the recipe regardless of
+whether there is a file named @file{clean}.
+Phony targets are also useful in conjunction with recursive
+invocations of @code{make} (@pxref{Recursion, ,Recursive Use of @code{make}}).
+In this situation the makefile will often contain a variable which
+lists a number of sub-directories to be built.  A simplistic way to
+handle this is to define one rule with a recipe that loops over the
+sub-directories, like this:
 @example
 …
 There are problems with this method, however.  First, any error
 detected in a submake is ignored by this rule, so it will continue
+detected in a sub-make is ignored by this rule, so it will continue
 to build the rest of the directories even when one fails.  This can be
 overcome by adding shell commands to note the error and exit, but then
 …
 one rule.
 By declaring the subdirectories as phony targets (you must do this as
 the subdirectory obviously always exists; otherwise it won't be built)
 you can remove these problems:
+By declaring the sub-directories as @code{.PHONY} targets (you must do
+this as the sub-directory obviously always exists; otherwise it won't
+be built) you can remove these problems:
 @example
 …
 @end example
 Here we've also declared that the @file{foo} subdirectory cannot be
 built until after the @file{baz} subdirectory is complete; this kind of
+Here we've also declared that the @file{foo} sub-directory cannot be
+built until after the @file{baz} sub-directory is complete; this kind of
 relationship declaration is particularly important when attempting
 parallel builds.
+The implicit rule search (@pxref{Implicit Rules}) is skipped for
+@code{.PHONY} targets.  This is why declaring a target as
+@code{.PHONY} is good for performance, even if you are not worried
+about the actual file existing.
 A phony target should not be a prerequisite of a real target file; if it
 …
 is up to date.  Unfortunately, some hosts do not provide a way to set a
 high resolution file time stamp, so commands like @samp{cp -p} that
 explicitly set a file's time stamp must discard its subsecond part.
+explicitly set a file's time stamp must discard its sub-second part.
 If a file is created by such a command, you should list it as a
 prerequisite of @code{.LOW_RESOLUTION_TIME} so that @command{make}
 …
 @end example
 Since @samp{cp -p} discards the subsecond part of @file{src}'s time
+Since @samp{cp -p} discards the sub-second part of @file{src}'s time
 stamp, @file{dst} is typically slightly older than @file{src} even when
 it is up to date.  The @code{.LOW_RESOLUTION_TIME} line causes
 …
 for each target that does not.  If you have a list of files, only some of
 which will match the pattern, you can use the @code{filter} function to
 remove nonmatching file names (@pxref{Text Functions, ,Functions for String Substitution and Analysis}):
+remove non-matching file names (@pxref{Text Functions, ,Functions for String Substitution and Analysis}):
 @example
 …
 The compiler will do it for you.
+Note that such a prerequisite constitutes mentioning @file{main.o} in a
+makefile, so it can never be considered an intermediate file by implicit
+rule search.  This means that @code{make} won't ever remove the file
+after using it; @pxref{Chained Rules, ,Chains of Implicit Rules}.
+Note that such a rule constitutes mentioning @file{main.o} in a
+makefile, so it can never be considered an intermediate file by
+implicit rule search.  This means that @code{make} won't ever remove
+the file after using it; @pxref{Chained Rules, ,Chains of Implicit
+Rules}.
 @cindex @code{make depend}
 …
 of @samp{-M}.  This omits prerequisites on system header files.
 @xref{Preprocessor Options, , Options Controlling the Preprocessor,
 gcc.info, Using GNU CC}, for details.
+gcc, Using GNU CC}, for details.
 @cindex @code{sed} (shell command)
 …
 @menu
 * Splitting Lines::             Breaking long recipe lines for readability.
+* Splitting Recipe Lines::      Breaking long recipe lines for readability.
 * Variables in Recipes::        Using @code{make} variables in recipes.
 @end menu
 @node Splitting Lines, Variables in Recipes, Recipe Syntax, Recipe Syntax
+@node Splitting Recipe Lines, Variables in Recipes, Recipe Syntax, Recipe Syntax
 @subsection Splitting Recipe Lines
 @cindex recipes, splitting
 …
 However, in contrast to how they are treated in other places in a
+makefile, backslash-newline pairs are @emph{not} removed from the
+recipe.  Both the backslash and the newline characters are preserved
+and passed to the shell.  How the backslash-newline is interpreted
+depends on your shell.  If the first character of the next line after
+the backslash-newline is the recipe prefix character (a tab by
+default; @pxref{Special Variables}), then that character (and only
+that character) is removed.  Whitespace is never added to the recipe.
+makefile (@pxref{Splitting Lines, , Splitting Long Lines}),
+backslash/newline pairs are @emph{not} removed from the recipe.  Both
+the backslash and the newline characters are preserved and passed to
+the shell.  How the backslash/newline is interpreted depends on your
+shell.  If the first character of the next line after the
+backslash/newline is the recipe prefix character (a tab by default;
+@pxref{Special Variables}), then that character (and only that
+character) is removed.  Whitespace is never added to the recipe.
 For example, the recipe for the all target in this makefile:
 …
 Sometimes you want to split a long line inside of single quotes, but
 you don't want the backslash-newline to appear in the quoted content.
+you don't want the backslash/newline to appear in the quoted content.
 This is often the case when passing scripts to languages such as Perl,
 where extraneous backslashes inside the script can change its meaning
 …
 @code{make} variable then use the variable in the recipe.  In this
 situation the newline quoting rules for makefiles will be used, and
 the backslash-newline will be removed.  If we rewrite our example
+the backslash/newline will be removed.  If we rewrite our example
 above using this method:
 …
 uses it.
 @node Variables in Recipes,  , Splitting Lines, Recipe Syntax
+@node Variables in Recipes,  , Splitting Recipe Lines, Recipe Syntax
 @subsection Using Variables in Recipes
 @cindex variable references in recipes
 …
 When it is time to execute recipes to update a target, they are
 executed by invoking a new subshell for each line of the recipe,
+executed by invoking a new sub-shell for each line of the recipe,
 unless the @code{.ONESHELL} special target is in effect
 (@pxref{One Shell, ,Using One Shell})  (In practice, @code{make} may
 …
 @menu
 * One Shell::                   One shell for all lines in a recipe
+* One Shell::                   One shell for all lines in a recipe.
 * Choosing the Shell::          How @code{make} chooses the shell used
                                   to run recipes.
 …
 slots is one, which means serial execution (one thing at a time).
+One unpleasant consequence of running several recipes simultaneously is
+that output generated by the recipes appears whenever each recipe
+sends it, so messages from different recipes may be interspersed.
+Another problem is that two processes cannot both take input from the
+same device; so to make sure that only one recipe tries to take input
+from the terminal at once, @code{make} will invalidate the standard
+input streams of all but one running recipe.  This means that
+attempting to read from standard input will usually be a fatal error (a
+@samp{Broken pipe} signal) for most child processes if there are
+several.
+@cindex broken pipe
+@cindex standard input
+It is unpredictable which recipe will have a valid standard input stream
+(which will come from the terminal, or wherever you redirect the standard
+input of @code{make}).  The first recipe run will always get it first, and
+the first recipe started after that one finishes will get it next, and so
+on.
+We will change how this aspect of @code{make} works if we find a better
+alternative.  In the mean time, you should not rely on any recipe using
+standard input at all if you are using the parallel execution feature; but
+if you are not using this feature, then standard input works normally in
+all recipes.
+Finally, handling recursive @code{make} invocations raises issues.  For
+more information on this, see
+@ref{Options/Recursion, ,Communicating Options to a Sub-@code{make}}.
+Handling recursive @code{make} invocations raises issues for parallel
+execution.  For more information on this, see @ref{Options/Recursion,
+,Communicating Options to a Sub-@code{make}}.
 If a recipe fails (is killed by a signal or exits with a nonzero
+status), and errors are not ignored for that recipe
+(@pxref{Errors, ,Errors in Recipes}),
+the remaining recipe lines to remake the same target will not be run.
+If a recipe fails and the @samp{-k} or @samp{--keep-going}
+option was not given
+(@pxref{Options Summary, ,Summary of Options}),
+@code{make} aborts execution.  If make
+status), and errors are not ignored for that recipe (@pxref{Errors,
+,Errors in Recipes}), the remaining recipe lines to remake the same
+target will not be run.  If a recipe fails and the @samp{-k} or
+@samp{--keep-going} option was not given (@pxref{Options Summary,
+,Summary of Options}), @code{make} aborts execution.  If make
 terminates for any reason (including a signal) with child processes
 running, it waits for them to finish before actually exiting.@refill
 …
 By default, there is no load limit.
+@menu
+* Parallel Output::             Handling output during parallel execution
+* Parallel Input::              Handling input during parallel execution
+@end menu
+@node Parallel Output, Parallel Input, Parallel, Parallel
+@subsection Output During Parallel Execution
+@cindex output during parallel execution
+@cindex parallel execution, output during
+When running several recipes in parallel the output from each
+recipe appears as soon as it is generated, with the result that
+messages from different recipes may be interspersed, sometimes even
+appearing on the same line.  This can make reading the output very
+difficult.
+@cindex @code{--output-sync}
+@cindex @code{-O}
+To avoid this you can use the @samp{--output-sync} (@samp{-O}) option.
+This option instructs @code{make} to save the output from the commands
+it invokes and print it all once the commands are completed.
+Additionally, if there are multiple recursive @code{make} invocations
+running in parallel, they will communicate so that only one of them is
+generating output at a time.
+If working directory printing is enabled (@pxref{-w Option, ,The
+@samp{--print-directory} Option}), the enter/leave messages are
+printed around each output grouping.  If you prefer not to see these
+messages add the @samp{--no-print-directory} option to @code{MAKEFLAGS}.
+There are four levels of granularity when synchronizing output,
+specified by giving an argument to the option (e.g.,  @samp{-Oline} or
+@samp{--output-sync=recurse}).
+@table @code
+@item none
+This is the default: all output is sent directly as it is generated and
+no synchronization is performed.
+@item line
+Output from each individual line of the recipe is grouped and printed
+as soon as that line is complete.  If a recipe consists of multiple
+lines, they may be interspersed with lines from other recipes.
+@item target
+Output from the entire recipe for each target is grouped and printed
+once the target is complete.  This is the default if the
+@code{--output-sync} or @code{-O} option is given with no argument.
+@item recurse
+Output from each recursive invocation of @code{make} is grouped and
+printed once the recursive invocation is complete.
+@end table
+Regardless of the mode chosen, the total build time will be the same.
+The only difference is in how the output appears.
+The @samp{target} and @samp{recurse} modes both collect the output of
+the entire recipe of a target and display it uninterrupted when the
+recipe completes.  The difference between them is in how recipes that
+contain recursive invocations of @code{make} are treated
+(@pxref{Recursion, ,Recursive Use of @code{make}}).  For all recipes
+which have no recursive lines, the @samp{target} and @samp{recurse}
+modes behave identically.
+If the @samp{recurse} mode is chosen, recipes that contain recursive
+@code{make} invocations are treated the same as other targets: the
+output from the recipe, including the output from the recursive
+@code{make}, is saved and printed after the entire recipe is complete.
+This ensures output from all the targets built by a given recursive
+@code{make} instance are grouped together, which may make the output
+easier to understand.  However it also leads to long periods of time
+during the build where no output is seen, followed by large bursts of
+output.  If you are not watching the build as it proceeds, but instead
+viewing a log of the build after the fact, this may be the best option
+for you.
+If you are watching the output, the long gaps of quiet during the
+build can be frustrating.  The @samp{target} output synchronization
+mode detects when @code{make} is going to be invoked recursively,
+using the standard methods, and it will not synchronize the output of
+those lines.  The recursive @code{make} will perform the
+synchronization for its targets and the output from each will be
+displayed immediately when it completes.  Be aware that output from
+recursive lines of the recipe are not synchronized (for example if
+the recursive line prints a message before running @code{make}, that
+message will not be synchronized).
+The @samp{line} mode can be useful for front-ends that are watching
+the output of @code{make} to track when recipes are started and
+completed.
+Some programs invoked by @code{make} may behave differently if they
+determine they're writing output to a terminal versus a file (often
+described as ``interactive'' vs. ``non-interactive'' modes).  For
+example, many programs that can display colorized output will not do
+so if they determine they are not writing to a terminal.  If your
+makefile invokes a program like this then using the output
+synchronization options will cause the program to believe it's running
+in ``non-interactive'' mode even though the output will ultimately go
+to the terminal.
+@node Parallel Input,  , Parallel Output, Parallel
+@subsection Input During Parallel Execution
+@cindex input during parallel execution
+@cindex parallel execution, input during
+@cindex standard input
+Two processes cannot both take input from the same device at the same
+time.  To make sure that only one recipe tries to take input from the
+terminal at once, @code{make} will invalidate the standard input
+streams of all but one running recipe.  If another recipe attempts to
+read from standard input it will usually incur a fatal error (a
+@samp{Broken pipe} signal).
+@cindex broken pipe
+It is unpredictable which recipe will have a valid standard input stream
+(which will come from the terminal, or wherever you redirect the standard
+input of @code{make}).  The first recipe run will always get it first, and
+the first recipe started after that one finishes will get it next, and so
+on.
+We will change how this aspect of @code{make} works if we find a better
+alternative.  In the mean time, you should not rely on any recipe using
+standard input at all if you are using the parallel execution feature; but
+if you are not using this feature, then standard input works normally in
+all recipes.
 @node Errors, Interrupts, Parallel, Recipes
 …
 makefile.  This technique is useful when you want separate makefiles for
 various subsystems that compose a larger system.  For example, suppose you
 have a subdirectory @file{subdir} which has its own makefile, and you would
+have a sub-directory @file{subdir} which has its own makefile, and you would
 like the containing directory's makefile to run @code{make} on the
 subdirectory.  You can do it by writing this:
+sub-directory.  You can do it by writing this:
 @example
 …
 Variable values of the top-level @code{make} can be passed to the
 sub-@code{make} through the environment by explicit request.  These
 variables are defined in the sub-@code{make} as defaults, but do not
+override what is specified in the makefile used by the sub-@code{make}
+makefile unless you use the @samp{-e} switch (@pxref{Options Summary,
 ,Summary of Options}).@refill
+variables are defined in the sub-@code{make} as defaults, but they do
+not override variables defined in the makefile used by
+the sub-@code{make} unless you use the @samp{-e} switch (@pxref{Options
+Summary, ,Summary of Options}).@refill
 To pass down, or @dfn{export}, a variable, @code{make} adds the
 …
 If your operating system doesn't support the above communication, then
+@samp{-j 1} is always put into @code{MAKEFLAGS} instead of the value you
 specified.  This is because if the @w{@samp{-j}} option were passed down
 to sub-@code{make}s, you would get many more jobs running in parallel
+no @samp{-j} is added to @code{MAKEFLAGS}, so that sub-@code{make}s
+run in non-parallel mode.  If the @w{@samp{-j}} option were passed down
+to sub-@code{make}s you would get many more jobs running in parallel
 than you asked for.  If you give @samp{-j} with no numeric argument,
 meaning to run as many jobs as possible in parallel, this is passed
 …
 see the error message @samp{Arg list too long}, this may be the problem.
 @findex .POSIX
 @cindex POSIX.2
+@cindex POSIX
 (For strict compliance with POSIX.2, changing @code{MAKEOVERRIDES} does
 not affect @code{MAKEFLAGS} if the special target @samp{.POSIX} appears
 …
 put in one of these variables, could have disastrous consequences and would
 certainly have at least surprising and probably annoying effects.@refill
+If you'd like to run other implementations of @code{make} in addition
+to GNU @code{make}, and hence do not want to add GNU
+@code{make}-specific flags to the @code{MAKEFLAGS} variable, you can
+add them to the @code{GNUMAKEFLAGS} variable instead.  This variable
+is parsed just before @code{MAKEFLAGS}, in the same way as
+@code{MAKEFLAGS}.  When @code{make} constructs @code{MAKEFLAGS} to
+pass to a recursive @code{make} it will include all flags, even those
+taken from @code{GNUMAKEFLAGS}.  As a result, after parsing
+@code{GNUMAKEFLAGS} GNU @code{make} sets this variable to the empty
+string to avoid duplicating flags during recursion.
+It's best to use @code{GNUMAKEFLAGS} only with flags which won't
+materially change the behavior of your makefiles.  If your makefiles
+require GNU make anyway then simply use @code{MAKEFLAGS}.  Flags such
+as @samp{--no-print-directory} or @samp{--output-sync} may be
+appropriate for @code{GNUMAKEFLAGS}.
 @node -w Option,  , Options/Recursion, Recursion
 …
 In recipe execution, each line of a canned sequence is treated just as
 if the line appeared on its own in the rule, preceded by a tab.  In
 particular, @code{make} invokes a separate subshell for each line.  You
+particular, @code{make} invokes a separate sub-shell for each line.  You
 can use the special prefix characters that affect command lines
 (@samp{@@}, @samp{-}, and @samp{+}) on each line of a canned sequence.
 …
 @findex .DEFAULT@r{, and empty recipes}
+You may be wondering why you would want to define a recipe that
+does nothing.  The only reason this is useful is to prevent a target
+from getting implicit recipes (from implicit rules or the
+@code{.DEFAULT} special target; @pxref{Implicit Rules} and
+@pxref{Last Resort, ,Defining Last-Resort Default Rules}).@refill
+@c !!! another reason is for canonical stamp files:
+@ignore
+@example
+foo: stamp-foo ;
+stamp-foo: foo.in
+        create foo frm foo.in
+        touch $@
+@end example
+@end ignore
+You may be inclined to define empty recipes for targets that are
+not actual files, but only exist so that their prerequisites can be
+You may be wondering why you would want to define a recipe that does
+nothing.  One reason this is useful is to prevent a target from
+getting implicit recipes (from implicit rules or the @code{.DEFAULT}
+special target; @pxref{Implicit Rules} and @pxref{Last Resort,
+,Defining Last-Resort Default Rules}).@refill
+Empty recipes can also be used to avoid errors for targets that will
+be created as a side-effect of another recipe: if the target does not
+exist the empty recipe ensures that @code{make} won't complain that it
+doesn't know how to build the target, and @code{make} will assume the
+target is out of date.
+You may be inclined to define empty recipes for targets that are not
+actual files, but only exist so that their prerequisites can be
 remade.  However, this is not the best way to do that, because the
+prerequisites may not be remade properly if the target file actually does exist.
+@xref{Phony Targets, ,Phony Targets}, for a better way to do this.
+prerequisites may not be remade properly if the target file actually
+does exist.  @xref{Phony Targets, ,Phony Targets}, for a better way to
+do this.
 @node Using Variables, Conditionals, Recipes, Top
 …
 write output in, or anything else you can imagine.
+A variable name may be any sequence of characters not containing @samp{:},
+@samp{#}, @samp{=}, or leading or trailing whitespace.  However,
+variable names containing characters other than letters, numbers, and
+underscores should be avoided, as they may be given special meanings in the
+future, and with some shells they cannot be passed through the environment to a
+sub-@code{make}
+(@pxref{Variables/Recursion, ,Communicating Variables to a Sub-@code{make}}).
+A variable name may be any sequence of characters not containing
+@samp{:}, @samp{#}, @samp{=}, or whitespace.  However, variable names
+containing characters other than letters, numbers, and underscores
+should be considered carefully, as in some shells they cannot be
+passed through the environment to a sub-@code{make}
+(@pxref{Variables/Recursion, ,Communicating Variables to a
+Sub-@code{make}}).  Variable names beginning with @samp{.} and an
+uppercase letter may be given special meaning in future versions of
+@code{make}.
 Variable names are case-sensitive.  The names @samp{foo}, @samp{FOO},
 …
 expands to @samp{$(ugh)} which finally expands to @samp{Huh?}.@refill
 This flavor of variable is the only sort supported by other versions of
+@code{make}.  It has its advantages and its disadvantages.  An advantage
 (most would say) is that:
+This flavor of variable is the only sort supported by most other
+versions of @code{make}.  It has its advantages and its disadvantages.
+An advantage (most would say) is that:
 @example
 …
 @cindex variables, simply expanded
 @cindex :=
+@cindex ::=
 @dfn{Simply expanded variables} are defined by lines using @samp{:=}
+(@pxref{Setting, ,Setting Variables}).
+or @samp{::=} (@pxref{Setting, ,Setting Variables}).  Both forms are
+equivalent in GNU @code{make}; however only the @samp{::=} form is
+described by the POSIX standard (support for @samp{::=} was added to
+the POSIX standard in 2012, so older versions of @code{make} won't
+accept this form either).
 The value of a simply expanded variable is scanned
 once and for all, expanding any references to other variables and
 …
 References to recursively-expanded variables within a variable name are
 reexpanded in the usual fashion.  For example:
+re-expanded in the usual fashion.  For example:
 @example
 …
 @cindex =
 @cindex :=
+@cindex ::=
 @cindex ?=
+@cindex !=
 To set a variable from the makefile, write a line starting with the
+variable name followed by @samp{=} or @samp{:=}.  Whatever follows the
+@samp{=} or @samp{:=} on the line becomes the value.  For example,
+variable name followed by @samp{=}, @samp{:=}, or @samp{::=}.  Whatever
+follows the @samp{=}, @samp{:=}, or @samp{::=} on the line becomes the
+value.  For example,
 @example
 …
 name and immediately after the @samp{=} is ignored.
+Variables defined with @samp{=} are @dfn{recursively expanded} variables.
+Variables defined with @samp{:=} are @dfn{simply expanded} variables; these
+definitions can contain variable references which will be expanded before
+the definition is made.  @xref{Flavors, ,The Two Flavors of Variables}.
+Variables defined with @samp{=} are @dfn{recursively expanded}
+variables.  Variables defined with @samp{:=} or @samp{::=} are
+@dfn{simply expanded} variables; these definitions can contain
+variable references which will be expanded before the definition is
+made.  @xref{Flavors, ,The Two Flavors of Variables}.
 The variable name may contain function and variable references, which
 …
 There is no limit on the length of the value of a variable except the
+amount of swapping space on the computer.  When a variable definition is
+long, it is a good idea to break it into several lines by inserting
+backslash-newline at convenient places in the definition.  This will not
+affect the functioning of @code{make}, but it will make the makefile easier
+to read.
+amount of memory on the computer.  You can split the value of a
+variable into multiple physical lines for readability
+(@pxref{Splitting Lines, ,Splitting Long Lines}).
 Most variable names are considered to have the empty string as a value if
 …
 @end example
+The shell assignment operator @samp{!=} can be used to execute a
+shell script and set a variable to its output.  This operator first
+evaluates the right-hand side, then passes that result to the shell
+for execution.  If the result of the execution ends in a newline, that
+one newline is removed; all other newlines are replaced by spaces.
+The resulting string is then placed into the named
+recursively-expanded variable.  For example:
+@example
+hash != printf '\043'
+file_list != find . -name '*.c'
+@end example
+If the result of the execution could produce a @code{$}, and you don't
+intend what follows that to be interpreted as a make variable or
+function reference, then you must replace every @code{$} with
+@code{$$} as part of the execution.  Alternatively, you can set a
+simply expanded variable to the result of running a program using the
+@code{shell} function call.  @xref{Shell Function, , The @code{shell}
+Function}.  For example:
+@example
+hash := $(shell printf '\043')
+var := $(shell find . -name "*.c")
+@end example
+As with the @code{shell} function, the exit status of the just-invoked
+shell script is stored in the @code{.SHELLSTATUS} variable.
 @node Appending, Override Directive, Setting, Using Variables
 @section Appending More Text to Variables
 …
 When you add to a variable's value with @samp{+=}, @code{make} acts
 essentially as if you had included the extra text in the initial
 definition of the variable.  If you defined it first with @samp{:=},
+making it a simply-expanded variable, @samp{+=} adds to that
+simply-expanded definition, and expands the new text before appending it
+to the old value just as @samp{:=} does
+(see @ref{Setting, ,Setting Variables}, for a full explanation of @samp{:=}).
 In fact,
+definition of the variable.  If you defined it first with @samp{:=} or
+@samp{::=}, making it a simply-expanded variable, @samp{+=} adds to
+that simply-expanded definition, and expands the new text before
+appending it to the old value just as @samp{:=} does (see
+@ref{Setting, ,Setting Variables}, for a full explanation of
+@samp{:=} or @samp{::=}).  In fact,
 @example
 …
 The first line defines the @code{CFLAGS} variable with a reference to another
 variable, @code{includes}.  (@code{CFLAGS} is used by the rules for C
 compilation; @pxref{Catalogue of Rules, ,Catalogue of Implicit Rules}.)
+compilation; @pxref{Catalogue of Rules, ,Catalogue of Built-In Rules}.)
 Using @samp{=} for the definition makes @code{CFLAGS} a recursively-expanded
 variable, meaning @w{@samp{$(includes) -O}} is @emph{not} expanded when
 …
 since two commands separated by semicolon behave much like two separate
 shell commands.  However, note that using two separate lines means
 @code{make} will invoke the shell twice, running an independent subshell
+@code{make} will invoke the shell twice, running an independent sub-shell
 for each line.  @xref{Execution, ,Recipe Execution}.
 …
 The @var{variable-assignment} can be any valid form of assignment;
 recursive (@samp{=}), static (@samp{:=}), appending (@samp{+=}), or
+conditional (@samp{?=}).  All variables that appear within the
+@var{variable-assignment} are evaluated within the context of the
+target: thus, any previously-defined target-specific variable values
+will be in effect.  Note that this variable is actually distinct from
+any ``global'' value: the two variables do not have to have the same
 flavor (recursive vs.@: static).
+recursive (@samp{=}), simple (@samp{:=} or @samp{::=}), appending
+(@samp{+=}), or conditional (@samp{?=}).  All variables that appear
+within the @var{variable-assignment} are evaluated within the context
+of the target: thus, any previously-defined target-specific variable
+values will be in effect.  Note that this variable is actually
+distinct from any ``global'' value: the two variables do not have to
+have the same flavor (recursive vs.@: simple).
 Target-specific variables have the same priority as any other makefile
 …
 Due to the @code{private} modifier, @code{a.o} and @code{b.o} will not
 inherit the @code{EXTRA_CFLAGS} variable assignment from the
 @code{progs} target.
+@code{prog} target.
 @node Special Variables,  , Suppressing Inheritance, Using Variables
 …
 Note that assigning more than one target name to @code{.DEFAULT_GOAL} is
 illegal and will result in an error.
+invalid and will result in an error.
 @vindex MAKE_RESTARTS @r{(number of times @code{make} has restarted)}
 …
 this is not the same as recursion (counted by the @code{MAKELEVEL}
 variable).  You should not set, modify, or export this variable.
+@vindex MAKE_TERMOUT @r{(whether stdout is a terminal)}
+@vindex MAKE_TERMERR @r{(whether stderr is a terminal)}
+@item MAKE_TERMOUT
+@itemx MAKE_TERMERR
+When @code{make} starts it will check whether stdout and stderr will
+show their output on a terminal.  If so, it will set
+@code{MAKE_TERMOUT} and @code{MAKE_TERMERR}, respectively, to the name
+of the terminal device (or @code{true} if this cannot be determined).
+If set these variables will be marked for export.  These variables
+will not be changed by @code{make} and they will not be modified if
+already set.
+These values can be used (particularly in combination with output
+synchronization (@pxref{Parallel Output, ,Output During Parallel
+Execution}) to determine whether @code{make} itself is writing to a
+terminal; they can be tested to decide whether to force recipe
+commands to generate colorized output for example.
+If you invoke a sub-@code{make} and redirect its stdout or stderr it
+is your responsibility to reset or unexport these variables as well,
+if your makefiles rely on them.
 @vindex .RECIPEPREFIX @r{(change the recipe prefix character)}
 …
 @item .FEATURES
 Expands to a list of special features supported by this version of
 @code{make}.  Possible values include:
+@code{make}.  Possible values include, but are not limited to:
 @table @samp
 @item archives
 Supports @code{ar} (archive) files using special filename syntax.
+Supports @code{ar} (archive) files using special file name syntax.
 @xref{Archives, ,Using @code{make} to Update Archive Files}.
 …
 ,Parallel Execution}.
+@item second-expansion
+Supports secondary expansion of prerequisite lists.
+@item oneshell
+Supports the @code{.ONESHELL} special target.  @xref{One Shell, ,Using
+One Shell}.
 @item order-only
 …
 of Prerequisites}.
+@item second-expansion
+Supports secondary expansion of prerequisite lists.
+@item shortest-stem
+Uses the ``shortest stem'' method of choosing which pattern, of
+multiple applicable options, will be used.  @xref{Pattern Match, ,How
+Patterns Match}.
 @item target-specific
 Supports target-specific and pattern-specific variable assignments.
 @xref{Target-specific, ,Target-specific Variable Values}.
+@item undefine
+Supports the @code{undefine} directive.  @xref{Undefine Directive}.
+@item guile
+Has GNU Guile available as an embedded extension language.
+@xref{Guile Integration, ,GNU Guile Integration}.
+@item load
+Supports dynamically loadable objects for creating custom extensions.
+@xref{Loading Objects, ,Loading Dynamic Objects}.
 @end table
 …
 @example
 @var{conditional-directive}
+@var{conditional-directive-one}
 @var{text-if-one-is-true}
 else @var{conditional-directive}
 @var{text-if-true}
+else @var{conditional-directive-two}
+@var{text-if-two-is-true}
 else
 @var{text-if-false}
+@var{text-if-one-and-two-are-false}
 endif
 @end example
 …
 @item ifdef @var{variable-name}
 The @code{ifdef} form takes the @emph{name} of a variable as its
 argument, not a reference to a variable.  The value of that variable
+has a non-empty value, the @var{text-if-true} is effective; otherwise,
+the @var{text-if-false}, if any, is effective.  Variables that have
+never been defined have an empty value.  The text @var{variable-name}
+is expanded, so it could be a variable or function that expands
 to the name of a variable.  For example:
+argument, not a reference to a variable.  If the value of that
+variable has a non-empty value, the @var{text-if-true} is effective;
+otherwise, the @var{text-if-false}, if any, is effective.  Variables
+that have never been defined have an empty value.  The text
+@var{variable-name} is expanded, so it could be a variable or function
+that expands to the name of a variable.  For example:
 @example
 …
 * Conditional Functions::       Functions that implement conditions.
 * Foreach Function::            Repeat some text with controlled variation.
+* File Function::               Write text to a file.
 * Call Function::               Expand a user-defined function.
 * Value Function::              Return the un-expanded value of a variable.
 …
 * Origin Function::             Find where a variable got its value.
 * Flavor Function::             Find out the flavor of a variable.
+* Make Control Functions::      Functions that control how make runs.
 * Shell Function::              Substitute the output of a shell command.
 * Make Control Functions::      Functions that control how make runs.
+* Guile Function::              Use GNU Guile embedded scripting language.
 @end menu
 …
 @cindex functions, syntax of
+A function call resembles a variable reference.  It looks like this:
+A function call resembles a variable reference.  It can appear
+anywhere a variable reference can appear, and it is expanded using the
+same rules as variable references.  A function call looks like this:
 @example
 …
 Here @var{function} is a function name; one of a short list of names
 that are part of @code{make}.  You can also essentially create your own
 functions by using the @code{call} builtin function.
+functions by using the @code{call} built-in function.
 The @var{arguments} are the arguments of the function.  They are
 …
 @end table
 @node Foreach Function, Call Function, Conditional Functions, Functions
+@node Foreach Function, File Function, Conditional Functions, Functions
 @section The @code{foreach} Function
 @findex foreach
 …
 Here we use the variable @code{find_files} this way.  We use plain @samp{=}
 to define a recursively-expanding variable, so that its value contains an
 actual function call to be reexpanded under the control of @code{foreach};
+actual function call to be re-expanded under the control of @code{foreach};
 a simply-expanded variable would not do, since @code{wildcard} would be
 called only once at the time of defining @code{find_files}.
 …
 @smallexample
 files := $(foreach Esta escrito en espanol!,b c ch,$(find_files))
+files := $(foreach Esta-escrito-en-espanol!,b c ch,$(find_files))
 @end smallexample
 @noindent
 might be useful if the value of @code{find_files} references the variable
 whose name is @samp{Esta escrito en espanol!} (es un nombre bastante largo,
+whose name is @samp{Esta-escrito-en-espanol!} (es un nombre bastante largo,
 no?), but it is more likely to be a mistake.
+@node Call Function, Value Function, Foreach Function, Functions
+@node File Function, Call Function, Foreach Function, Functions
+@section The @code{file} Function
+@findex file
+@cindex writing to a file
+@cindex file, writing to
+@cindex reading from a file
+@cindex file, reading from
+The @code{file} function allows the makefile to write to or read from
+a file.  Two modes of writing are supported: overwrite, where the text
+is written to the beginning of the file and any existing content is
+lost, and append, where the text is written to the end of the file,
+preserving the existing content.  In both cases the file is created if
+it does not exist.  It is a fatal error if the file cannot be opened
+for writing, or if the write operation fails.  The @code{file}
+function expands to the empty string when writing to a file.
+When reading from a file, the @code{file} function expands to the
+verbatim contents of the file, except that the final newline (if there
+is one) will be stripped.  Attempting to read from a non-existent file
+expands to the empty string.
+The syntax of the @code{file} function is:
+@example
+$(file @var{op} @var{filename}[,@var{text}])
+@end example
+When the @code{file} function is evaluated all its arguments are
+expanded first, then the file indicated by @var{filename} will be
+opened in the mode described by @var{op}.
+The operator @var{op} can be @code{>} to indicate the file will be
+overwritten with new content, @code{>>} to indicate the current
+contents of the file will be appended to, or @code{<} to indicate the
+contents of the file will be read in.  The @var{filename} specifies
+the file to be written to or read from.  There may optionally be
+whitespace between the operator and the file name.
+When reading files, it is an error to provide a @var{text} value.
+When writing files, @var{text} will be written to the file.  If
+@var{text} does not already end in a newline a final newline will be
+written (even if @var{text} is the empty string).  If the @var{text}
+argument is not given at all, nothing will be written.
+For example, the @code{file} function can be useful if your build
+system has a limited command line size and your recipe runs a command
+that can accept arguments from a file as well.  Many commands use the
+convention that an argument prefixed with an @code{@@} specifies a
+file containing more arguments.  Then you might write your recipe in
+this way:
+@example
+@group
+program: $(OBJECTS)
+        $(file >$@@.in,$^)
+        $(CMD) $(CMDFLAGS) @@$@@.in
+        @@rm $@@.in
+@end group
+@end example
+If the command required each argument to be on a separate line of the
+input file, you might write your recipe like this:
+@example
+@group
+program: $(OBJECTS)
+        $(file >$@@.in) $(foreach O,$^,$(file >>$@@.in,$O))
+        $(CMD) $(CMDFLAGS) @@$@@.in
+        @@rm $@@.in
+@end group
+@end example
+@node Call Function, Value Function, File Function, Functions
 @section The @code{call} Function
 @findex call
 …
 constant.)
 If @var{variable} is the name of a builtin function, the builtin function
+If @var{variable} is the name of a built-in function, the built-in function
 is always invoked (even if a @code{make} variable by that name also
 exists).
 …
 The @code{call} function expands the @var{param} arguments before
 assigning them to temporary variables.  This means that @var{variable}
 values containing references to builtin functions that have special
+values containing references to built-in functions that have special
 expansion rules, like @code{foreach} or @code{if}, may not work as you
 expect.
 …
 @end example
 Note that @var{variable} is the @emph{name} of a variable; not a
+Note that @var{variable} is the @emph{name} of a variable, not a
 @emph{reference} to that variable.  Therefore you would not normally
 use a @samp{$} or parentheses when writing it.  (You can, however, use
 …
 @end example
 Note that @var{variable} is the @emph{name} of a variable to inquire about;
+Note that @var{variable} is the @emph{name} of a variable to inquire about,
 not a @emph{reference} to that variable.  Therefore you would not normally
 use a @samp{$} or parentheses when writing it.  (You can, however, use a
 …
 @xref{Text Functions, , Functions for String Substitution and Analysis}.
 @node Flavor Function, Shell Function, Origin Function, Functions
+@node Flavor Function, Make Control Functions, Origin Function, Functions
 @section The @code{flavor} Function
 @findex flavor
 …
 @cindex flavor of variable
+The @code{flavor} function is unlike most other functions (and like
+@code{origin} function) in that it does not operate on the values of
+variables; it tells you something @emph{about} a variable.
+Specifically, it tells you the flavor of a variable (@pxref{Flavors,
+,The Two Flavors of Variables}).
+The @code{flavor} function, like the @code{origin} function, does not
+operate on the values of variables but rather it tells you something
+@emph{about} a variable.  Specifically, it tells you the flavor of a
+variable (@pxref{Flavors, ,The Two Flavors of Variables}).
 The syntax of the @code{flavor} function is:
 …
 @end example
 Note that @var{variable} is the @emph{name} of a variable to inquire about;
+Note that @var{variable} is the @emph{name} of a variable to inquire about,
 not a @emph{reference} to that variable.  Therefore you would not normally
 use a @samp{$} or parentheses when writing it.  (You can, however, use a
 …
 @end table
+@node Shell Function, Make Control Functions, Flavor Function, Functions
+@section The @code{shell} Function
+@findex shell
+@cindex command expansion
+@cindex backquotes
+@cindex shell command, function for
+The @code{shell} function is unlike any other function other than the
+@code{wildcard} function
+(@pxref{Wildcard Function, ,The Function @code{wildcard}}) in that it
+communicates with the world outside of @code{make}.
+The @code{shell} function performs the same function that backquotes
+(@samp{`}) perform in most shells: it does @dfn{command expansion}.
+This means that it takes as an argument a shell command and evaluates
+to the output of the command.  The only processing @code{make} does on
+the result is to convert each newline (or carriage-return / newline
+pair) to a single space.  If there is a trailing (carriage-return
+and) newline it will simply be removed.@refill
+The commands run by calls to the @code{shell} function are run when the
+function calls are expanded (@pxref{Reading Makefiles, , How
+@code{make} Reads a Makefile}).  Because this function involves
+spawning a new shell, you should carefully consider the performance
+implications of using the @code{shell} function within recursively
+expanded variables vs.@: simply expanded variables (@pxref{Flavors, ,The
+Two Flavors of Variables}).
+Here are some examples of the use of the @code{shell} function:
+@example
+contents := $(shell cat foo)
+@end example
+@noindent
+sets @code{contents} to the contents of the file @file{foo}, with a space
+(rather than a newline) separating each line.
+@example
+files := $(shell echo *.c)
+@end example
+@noindent
+sets @code{files} to the expansion of @samp{*.c}.  Unless @code{make} is
+using a very strange shell, this has the same result as
+@w{@samp{$(wildcard *.c)}} (as long as at least one @samp{.c} file
+exists).@refill
+@node Make Control Functions,  , Shell Function, Functions
+@node Make Control Functions, Shell Function, Flavor Function, Functions
 @section Functions That Control Make
 @cindex functions, for controlling make
 …
 result of the expansion of this function is the empty string.
 @end table
+@node Shell Function, Guile Function, Make Control Functions, Functions
+@section The @code{shell} Function
+@findex shell
+@cindex command expansion
+@cindex backquotes
+@cindex shell command, function for
+The @code{shell} function is unlike any other function other than the
+@code{wildcard} function
+(@pxref{Wildcard Function, ,The Function @code{wildcard}}) in that it
+communicates with the world outside of @code{make}.
+The @code{shell} function performs the same function that backquotes
+(@samp{`}) perform in most shells: it does @dfn{command expansion}.
+This means that it takes as an argument a shell command and evaluates
+to the output of the command.  The only processing @code{make} does on
+the result is to convert each newline (or carriage-return / newline
+pair) to a single space.  If there is a trailing (carriage-return
+and) newline it will simply be removed.@refill
+The commands run by calls to the @code{shell} function are run when the
+function calls are expanded (@pxref{Reading Makefiles, , How
+@code{make} Reads a Makefile}).  Because this function involves
+spawning a new shell, you should carefully consider the performance
+implications of using the @code{shell} function within recursively
+expanded variables vs.@: simply expanded variables (@pxref{Flavors, ,The
+Two Flavors of Variables}).
+@vindex .SHELLSTATUS
+After the @code{shell} function or @samp{!=} assignment operator is
+used, its exit status is placed in the @code{.SHELLSTATUS} variable.
+Here are some examples of the use of the @code{shell} function:
+@example
+contents := $(shell cat foo)
+@end example
+@noindent
+sets @code{contents} to the contents of the file @file{foo}, with a space
+(rather than a newline) separating each line.
+@example
+files := $(shell echo *.c)
+@end example
+@noindent
+sets @code{files} to the expansion of @samp{*.c}.  Unless @code{make} is
+using a very strange shell, this has the same result as
+@w{@samp{$(wildcard *.c)}} (as long as at least one @samp{.c} file
+exists).@refill
+@node Guile Function,  , Shell Function, Functions
+@section The @code{guile} Function
+@findex guile
+@cindex Guile
+If GNU @code{make} is built with support for GNU Guile as an embedded
+extension language then the @code{guile} function will be available.
+The @code{guile} function takes one argument which is first expanded
+by @code{make} in the normal fashion, then passed to the GNU Guile
+evaluator.  The result of the evaluator is converted into a string and
+used as the expansion of the @code{guile} function in the makefile.
+See @ref{Guile Integration, ,GNU Guile Integration} for details on
+writing extensions to @code{make} in Guile.
+You can determine whether GNU Guile support is available by checking
+the @code{.FEATURES} variable for the word @var{guile}.
 @node Running, Implicit Rules, Functions, Top
 …
 @cindex @code{-n}
+``No-op''.  The activity is to print what recipe would be used to make
+the targets up to date, but not actually execute it.  Some recipes are
+still executed, even with this flag (@pxref{MAKE Variable, ,How the @code{MAKE} Variable Works}).
+``No-op''.  Causes @code{make} to print the recipes that are needed to
+make the targets up to date, but not actually execute them.  Note that
+some recipes are still executed, even with this flag (@pxref{MAKE
+Variable, ,How the @code{MAKE} Variable Works}).  Also any recipes
+needed to update included makefiles are still executed
+(@pxref{Remaking Makefiles, ,How Makefiles Are Remade}).
 @item -t
 …
 @cindex @code{-t}
+``Touch''.  The activity is to mark the targets as up to date without
+actually changing them.  In other words, @code{make} pretends to compile
+the targets but does not really change their contents.
+``Touch''.  Marks targets as up to date without actually changing
+them.  In other words, @code{make} pretends to update the targets but
+does not really change their contents; instead only their modified
+times are updated.
 @item -q
 …
 @cindex question mode
 ``Question''.  The activity is to find out silently whether the targets
+are up to date already; but execute no recipe in either case.  In other
 words, neither compilation nor output will occur.
+``Question''.  Silently check whether the targets are up to date, but
+do not execute recipes; the exit code shows whether any updates are
+needed.
 @item -W @var{file}
 …
 define either a recursively-expanded variable or a simply-expanded
 variable.  The examples shown above make a recursively-expanded
 variable; to make a simply-expanded variable, write @samp{:=} instead
+of @samp{=}.  But, unless you want to include a variable reference or
+function call in the @emph{value} that you specify, it makes no
 difference which kind of variable you create.
+variable; to make a simply-expanded variable, write @samp{:=} or
+@samp{::=} instead of @samp{=}.  But, unless you want to include a
+variable reference or function call in the @emph{value} that you
+specify, it makes no difference which kind of variable you create.
 There is one way that the makefile can change a variable that you have
 …
 @item j (@i{jobs})
 Prints messages giving details on the invocation of specific subcommands.
+Prints messages giving details on the invocation of specific sub-commands.
 @item m (@i{makefile})
 …
 too.  Note that the @samp{all} option does enable this option.  This
 option also enables @samp{basic} messages.
+@item n (@i{none})
+Disable all debugging currently enabled.  If additional debugging
+flags are encountered after this they will still take effect.
 @end table
 …
 are ignored.  @xref{Avoiding Compilation, ,Avoiding Recompilation of
 Some Files}.@refill
+@item -O[@var{type}]
+@cindex @code{-O}
+@itemx --output-sync[=@var{type}]
+@cindex @code{--output-sync}
+@cindex output during parallel execution
+@cindex parallel execution, output during
+Ensure that the complete output from each recipe is printed in one
+uninterrupted sequence.  This option is only useful when using the
+@code{--jobs} option to run multiple recipes simultaneously
+(@pxref{Parallel, ,Parallel Execution})  Without this option output
+will be displayed as it is generated by the recipes.@refill
+With no type or the type @samp{target}, output from the entire recipe
+of each target is grouped together.  With the type @samp{line}, output
+from each line in the recipe is grouped together.  With the type
+@samp{recurse}, the output from an entire recursive make is grouped
+together.  With the type @samp{none}, no output synchronization is
+performed.  @xref{Parallel Output, ,Output During Parallel Execution}.
 @item -p
 …
 to remake any files, use @w{@samp{make -qp}}.  To print the data base
 of predefined rules and variables, use @w{@samp{make -p -f /dev/null}}.
 The data base output contains filename and linenumber information for
+The data base output contains file name and line number information for
 recipe and variable definitions, so it can be a useful debugging tool
 in complex environments.
 …
 @code{make}.  @xref{Instead of Execution, ,Instead of Executing Recipes}.
+@item --trace
+@cindex @code{--trace}
+Show tracing information for @code{make} execution.  Prints the entire
+recipe to be executed, even for recipes that are normally silent (due
+to @code{.SILENT} or @samp{@@}).  Also prints the makefile name and
+line number where the recipe was defined, and information on why the
+target is being rebuilt.
 @item -v
 @cindex @code{-v}
 …
 see @ref{-w Option, ,The @samp{--print-directory} Option}.)
 @itemx --no-print-directory
+@item --no-print-directory
 @cindex @code{--no-print-directory}
 Disable printing of the working directory under @code{-w}.
 …
 * Using Implicit::              How to use an existing implicit rule
                                   to get the recipes for updating a file.
 * Catalogue of Rules::          A list of built-in implicit rules.
+* Catalogue of Rules::          A list of built-in rules.
 * Implicit Variables::          How to change what predefined rules do.
 * Chained Rules::               How to use a chain of implicit rules.
 * Pattern Rules::               How to define new implicit rules.
 * Last Resort::                 How to define recipes for rules which
+* Last Resort::                 How to define a recipe for rules which
                                   cannot find any.
 * Suffix Rules::                The old-fashioned style of implicit rule.
 …
 want @code{make} to use, and you know it will choose that one because you
 know which possible prerequisite files are supposed to exist.
 @xref{Catalogue of Rules, ,Catalogue of Implicit Rules},
+@xref{Catalogue of Rules, ,Catalogue of Built-In Rules},
 for a catalogue of all the predefined implicit rules.
 …
 rule to make an object file from a C source file is used instead,
 because it appears before the Pascal rule in the list of predefined
 implicit rules (@pxref{Catalogue of Rules, , Catalogue of Implicit
+implicit rules (@pxref{Catalogue of Rules, , Catalogue of Built-In
 Rules}).
 …
 @node Catalogue of Rules, Implicit Variables, Using Implicit, Implicit Rules
 @section Catalogue of Implicit Rules
+@section Catalogue of Built-In Rules
 @cindex implicit rule, predefined
 @cindex rule, implicit, predefined
 …
 Here is a table of some of the more common variables used as names of
 programs in built-in rules:
-makefiles.
 @table @code
 …
 @vindex LDFLAGS
 Extra flags to give to compilers when they are supposed to invoke the linker,
+@samp{ld}.
+@samp{ld}, such as @code{-L}.  Libraries (@code{-lfoo}) should be
+added to the @code{LDLIBS} variable instead.
+@item LDLIBS
+@vindex LDLIBS
+@vindex LOADLIBES
+Library flags or names given to compilers when they are supposed to
+invoke the linker, @samp{ld}.  @code{LOADLIBES} is a deprecated (but
+still supported) alternative to @code{LDLIBS}.  Non-library linker
+flags, such as @code{-L}, should go in the @code{LDFLAGS} variable.
 @item LFLAGS
 …
 * Pattern Examples::            Examples of pattern rules.
 * Automatic Variables::         How to use automatic variables in the
                                   recipes of implicit rules.
+                                  recipe of implicit rules.
 * Pattern Match::               How patterns match.
 * Match-Anything Rules::        Precautions you should take prior to
 …
 @noindent
 defines a rule that can make any file @file{@var{x}} whatsoever from a
 corresponding file @file{@var{x},v} in the subdirectory @file{RCS}.  Since
+corresponding file @file{@var{x},v} in the sub-directory @file{RCS}.  Since
 the target is @samp{%}, this rule will apply to any file whatever, provided
 the appropriate prerequisite file exists.  The double colon makes the rule
 …
 If you do not mark the match-anything rule as terminal, then it is
 nonterminal.  A nonterminal match-anything rule cannot apply to a file name
+non-terminal.  A non-terminal match-anything rule cannot apply to a file name
 that indicates a specific type of data.  A file name indicates a specific
 type of data if some non-match-anything implicit rule target matches it.
 …
 rule is actually applicable (which happens only if there is a file
 @file{foo.y}), the fact that its target matches is enough to prevent
 consideration of any nonterminal match-anything rules for the file
+consideration of any non-terminal match-anything rules for the file
 @file{foo.c}.  Thus, @code{make} will not even consider trying to make
 @file{foo.c} as an executable file from @file{foo.c.o}, @file{foo.c.c},
 @file{foo.c.p}, etc.@refill
 The motivation for this constraint is that nonterminal match-anything
+The motivation for this constraint is that non-terminal match-anything
 rules are used for making files containing specific types of data (such as
 executable files) and a file name with a recognized suffix indicates some
 …
 Special built-in dummy pattern rules are provided solely to recognize
 certain file names so that nonterminal match-anything rules will not be
+certain file names so that non-terminal match-anything rules will not be
 considered.  These dummy rules have no prerequisites and no recipes, and
 they are ignored for all other purposes.  For example, the built-in
 …
 @item
 If any rule in that list is @emph{not} a match-anything rule, then
 remove all nonterminal match-anything rules from the list.
+remove all non-terminal match-anything rules from the list.
 @item
 …
 prerequisites.  @xref{Automatic Variables}.
 @node Archives, Features, Implicit Rules, Top
+@node Archives, Extending make, Implicit Rules, Top
 @chapter Using @code{make} to Update Archive Files
 @cindex archive
 @dfn{Archive files} are files containing named subfiles called
+@dfn{Archive files} are files containing named sub-files called
 @dfn{members}; they are maintained with the program @code{ar} and their
 main use is as subroutine libraries for linking.
 …
 @w{%.@var{x}}} and @samp{@w{%.a}: @w{%.@var{x}}}.@refill
+@node Features, Missing, Archives, Top
+@node Extending make, Integrating make, Archives, Top
+@chapter Extending GNU @code{make}
+@cindex make extensions
+GNU @code{make} provides many advanced capabilities, including many
+useful functions.  However, it does not contain a complete programming
+language and so it has limitations.  Sometimes these limitations can be
+overcome through use of the @code{shell} function to invoke a separate
+program, although this can be inefficient.
+In cases where the built-in capabilities of GNU @code{make} are
+insufficient to your requirements there are two options for extending
+@code{make}.  On systems where it's provided, you can utilize GNU
+Guile as an embedded scripting language (@pxref{Guile Integration,,GNU
+Guile Integration}).  On systems which support dynamically loadable
+objects, you can write your own extension in any language (which can
+be compiled into such an object) and load it to provide extended
+capabilities (@pxref{load Directive, ,The @code{load} Directive}).
+@menu
+* Guile Integration::           Using Guile as an embedded scripting language.
+* Loading Objects::             Loading dynamic objects as extensions.
+@end menu
+@node Guile Integration, Loading Objects, Extending make, Extending make
+@section GNU Guile Integration
+@cindex Guile
+@cindex extensions, Guile
+GNU @code{make} may be built with support for GNU Guile as an embedded
+extension language.  Guile implements the Scheme language.  A review
+of GNU Guile and the Scheme language and its features is beyond the
+scope of this manual: see the documentation for GNU Guile and Scheme.
+You can determine if @code{make} contains support for Guile by
+examining the @code{.FEATURES} variable; it will contain the word
+@var{guile} if Guile support is available.
+The Guile integration provides one new @code{make} function: @code{guile}.
+The @code{guile} function takes one argument which is first expanded
+by @code{make} in the normal fashion, then passed to the GNU Guile
+evaluator.  The result of the evaluator is converted into a string and
+used as the expansion of the @code{guile} function in the makefile.
+In addition, GNU @code{make} exposes Guile procedures for use in Guile
+scripts.
+@menu
+* Guile Types::                 Converting Guile types to @code{make} strings.
+* Guile Interface::             Invoking @code{make} functions from Guile.
+* Guile Example::               Example using Guile in @code{make}.
+@end menu
+@node Guile Types, Guile Interface, Guile Integration, Guile Integration
+@subsection Conversion of Guile Types
+@cindex convert guile types
+@cindex guile, conversion of types
+@cindex types, conversion of
+There is only one ``data type'' in @code{make}: a string.  GNU Guile,
+on the other hand, provides a rich variety of different data types.
+An important aspect of the interface between @code{make} and GNU Guile
+is the conversion of Guile data types into @code{make} strings.
+This conversion is relevant in two places: when a makefile invokes the
+@code{guile} function to evaluate a Guile expression, the result of
+that evaluation must be converted into a make string so it can be
+further evaluated by @code{make}.  And secondly, when a Guile script
+invokes one of the procedures exported by @code{make} the argument
+provided to the procedure must be converted into a string.
+The conversion of Guile types into @code{make} strings is as below:
+@table @code
+@item #f
+False is converted into the empty string: in @code{make} conditionals
+the empty string is considered false.
+@item #t
+True is converted to the string @samp{#t}: in @code{make} conditionals
+any non-empty string is considered true.
+@item symbol
+@item number
+A symbol or number is converted into the string representation of that
+symbol or number.
+@item character
+A printable character is converted to the same character.
+@item string
+A string containing only printable characters is converted to the same
+string.
+@item list
+A list is converted recursively according to the above rules.  This
+implies that any structured list will be flattened (that is, a result
+of @samp{'(a b (c d) e)} will be converted to the @code{make} string
+@samp{a b c d e}).
+@item other
+Any other Guile type results in an error.  In future versions of
+@code{make}, other Guile types may be converted.
+@end table
+The translation of @samp{#f} (to the empty string) and @samp{#t} (to
+the non-empty string @samp{#t}) is designed to allow you to use Guile
+boolean results directly as @code{make} boolean conditions.  For
+example:
+@example
+$(if $(guile (access? "myfile" R_OK)),$(info myfile exists))
+@end example
+As a consequence of these conversion rules you must consider the
+result of your Guile script, as that result will be converted into a
+string and parsed by @code{make}.  If there is no natural result for
+the script (that is, the script exists solely for its side-effects),
+you should add @samp{#f} as the final expression in order to avoid
+syntax errors in your makefile.
+@node Guile Interface, Guile Example, Guile Types, Guile Integration
+@subsection Interfaces from Guile to @code{make}
+@cindex make interface to guile
+@cindex make procedures in guile
+In addition to the @code{guile} function available in makefiles,
+@code{make} exposes some procedures for use in your Guile scripts.  At
+startup @code{make} creates a new Guile module, @code{gnu make}, and
+exports these procedures as public interfaces from that module:
+@table @code
+@item gmk-expand
+@findex gmk-expand
+This procedure takes a single argument which is converted into a
+string.  The string is expanded by @code{make} using normal
+@code{make} expansion rules.  The result of the expansion is converted
+into a Guile string and provided as the result of the procedure.
+@item gmk-eval
+@findex gmk-eval
+This procedure takes a single argument which is converted into a
+string.  The string is evaluated by @code{make} as if it were a
+makefile.  This is the same capability available via the @code{eval}
+function (@pxref{Eval Function}).  The result of the @code{gmk-eval}
+procedure is always the empty string.
+Note that @code{gmk-eval} is not quite the same as using
+@code{gmk-expand} with the @code{eval} function: in the latter case
+the evaluated string will be expanded @emph{twice}; first by
+@code{gmk-expand}, then again by the @code{eval} function.
+@end table
+@node Guile Example,  , Guile Interface, Guile Integration
+@subsection Example Using Guile in @code{make}
+@cindex Guile example
+@cindex example using Guile
+Here is a very simple example using GNU Guile to manage writing to a
+file.  These Guile procedures simply open a file, allow writing to the
+file (one string per line), and close the file.  Note that because we
+cannot store complex values such as Guile ports in @code{make}
+variables, we'll keep the port as a global variable in the Guile
+interpreter.
+You can create Guile functions easily using @code{define}/@code{endef}
+to create a Guile script, then use the @code{guile} function to
+internalize it:
+@example
+@group
+define GUILEIO
+;; A simple Guile IO library for GNU make
+(define MKPORT #f)
+(define (mkopen name mode)
+  (set! MKPORT (open-file name mode))
+  #f)
+(define (mkwrite s)
+  (display s MKPORT)
+  (newline MKPORT)
+  #f)
+(define (mkclose)
+  (close-port MKPORT)
+  #f)
+#f
+endef
+# Internalize the Guile IO functions
+$(guile $(GUILEIO))
+@end group
+@end example
+If you have a significant amount of Guile support code, you might
+consider keeping it in a different file (e.g., @file{guileio.scm}) and
+then loading it in your makefile using the @code{guile} function:
+@example
+$(guile (load "guileio.scm"))
+@end example
+An advantage to this method is that when editing @file{guileio.scm},
+your editor will understand that this file contains Scheme syntax
+rather than makefile syntax.
+Now you can use these Guile functions to create files.  Suppose you
+need to operate on a very large list, which cannot fit on the command
+line, but the utility you're using accepts the list as input as well:
+@example
+@group
+prog: $(PREREQS)
+        @@$(guile (mkopen "tmp.out" "w")) \
+         $(foreach X,$^,$(guile (mkwrite "$(X)"))) \
+         $(guile (mkclose))
+        $(LINK) < tmp.out
+@end group
+@end example
+A more comprehensive suite of file manipulation procedures is possible
+of course.  You could, for example, maintain multiple output files at
+the same time by choosing a symbol for each one and using it as the
+key to a hash table, where the value is a port, then returning the
+symbol to be stored in a @code{make} variable.
+@node Loading Objects,  , Guile Integration, Extending make
+@section Loading Dynamic Objects
+@cindex loaded objects
+@cindex objects, loaded
+@cindex extensions, loading
+@cartouche
+@quotation Warning
+The @code{load} directive and extension capability is considered a
+``technology preview'' in this release of GNU make.  We encourage you
+to experiment with this feature and we appreciate any feedback on it.
+However we cannot guarantee to maintain backward-compatibility in the
+next release.  Consider using GNU Guile instead for extending GNU make
+(@pxref{Guile Function, ,The @code{guile} Function}).
+@end quotation
+@end cartouche
+Many operating systems provide a facility for dynamically loading
+compiled objects.  If your system provides this facility, GNU
+@code{make} can make use of it to load dynamic objects at runtime,
+providing new capabilities which may then be invoked by your makefile.
+The @code{load} directive is used to load a dynamic object.  Once the
+object is loaded, a ``setup'' function will be invoked to allow the
+object to initialize itself and register new facilities with GNU
+@code{make}.  A dynamic object might include new @code{make} functions,
+for example, and the ``setup'' function would register them with GNU
+@code{make}'s function handling system.
+@menu
+* load Directive::              Loading dynamic objects as extensions.
+* Remaking Loaded Objects::     How loaded objects get remade.
+* Loaded Object API::           Programmatic interface for loaded objects.
+* Loaded Object Example::       Example of a loaded object
+@end menu
+@node load Directive, Remaking Loaded Objects, Loading Objects, Loading Objects
+@subsection The @code{load} Directive
+@cindex load directive
+@cindex extensions, load directive
+Objects are loaded into GNU @code{make} by placing the @code{load}
+directive into your makefile.  The syntax of the @code{load} directive
+is as follows:
+@findex load
+@example
+load @var{object-file} @dots{}
+@end example
+or:
+@example
+load @var{object-file}(@var{symbol-name}) @dots{}
+@end example
+The file @var{object-file} is dynamically loaded by GNU @code{make}.
+If @var{object-file} does not include a directory path then it is
+first looked for in the current directory.  If it is not found there,
+or a directory path is included, then system-specific paths will be
+searched.  If the load fails for any reason, @code{make} will print a
+message and exit.
+If the load succeeds @code{make} will invoke an initializing function.
+If @var{symbol-name} is provided, it will be used as the name of the
+initializing function.
+If no @var{symbol-name} is provided, the initializing function name is
+created by taking the base file name of @var{object-file}, up to the
+first character which is not a valid symbol name character
+(alphanumerics and underscores are valid symbol name characters).  To
+this prefix will be appended the suffix @code{_gmk_setup}.
+More than one object file may be loaded with a single @code{load}
+directive, and both forms of @code{load} arguments may be used in the
+same directive.
+The initializing function will be provided the file name and line
+number of the invocation of the @code{load} operation.  It should
+return a value of type @code{int}, which must be @code{0} on failure
+and non-@code{0} on success.  If the return value is @code{-1}, then
+GNU make will @emph{not} attempt to rebuild the object file
+(@pxref{Remaking Loaded Objects, ,How Loaded Objects Are Remade}).
+For example:
+@example
+load ../mk_funcs.so
+@end example
+will load the dynamic object @file{../mk_funcs.so}.  After the object
+is loaded, @code{make} will invoke the function (assumed to be defined
+by the shared object) @code{mk_funcs_gmk_setup}.
+On the other hand:
+@example
+load ../mk_funcs.so(init_mk_func)
+@end example
+will load the dynamic object @file{../mk_funcs.so}.  After the object
+is loaded, @code{make} will invoke the function @code{init_mk_func}.
+Regardless of how many times an object file appears in a @code{load}
+directive, it will only be loaded (and its setup function will only
+be invoked) once.
+@vindex .LOADED
+After an object has been successfully loaded, its file name is
+appended to the @code{.LOADED} variable.
+@findex -load
+If you would prefer that failure to load a dynamic object not be
+reported as an error, you can use the @code{-load} directive instead
+of @code{load}.  GNU @code{make} will not fail and no message will be
+generated if an object fails to load.  The failed object is not added
+to the @code{.LOADED} variable, which can then be consulted to
+determine if the load was successful.
+@node Remaking Loaded Objects, Loaded Object API, load Directive, Loading Objects
+@subsection How Loaded Objects Are Remade
+@cindex updating loaded objects
+@cindex remaking loaded objects
+@cindex loaded objects, remaking of
+Loaded objects undergo the same re-make procedure as makefiles
+(@pxref{Remaking Makefiles, ,How Makefiles Are Remade}).  If any
+loaded object is recreated, then @code{make} will start from scratch
+and re-read all the makefiles, and reload the object files again.  It
+is not necessary for the loaded object to do anything special to
+support this.@refill
+It's up to the makefile author to provide the rules needed for
+rebuilding the loaded object.
+@node Loaded Object API, Loaded Object Example, Remaking Loaded Objects, Loading Objects
+@subsection Loaded Object Interface
+@cindex loaded object API
+@cindex interface for loaded objects
+@cartouche
+@quotation Warning
+For this feature to be useful your extensions will need to invoke
+various functions internal to GNU @code{make}.  The programming
+interfaces provided in this release should not be considered stable:
+functions may be added, removed, or change calling signatures or
+implementations in future versions of GNU @code{make}.
+@end quotation
+@end cartouche
+To be useful, loaded objects must be able to interact with GNU
+@code{make}.  This interaction includes both interfaces the loaded
+object provides to makefiles and also interfaces @code{make} provides
+to the loaded object to manipulate @code{make}'s operation.
+The interface between loaded objects and @code{make} is defined by the
+@file{gnumake.h} C header file.  All loaded objects written in C
+should include this header file.  Any loaded object not written in C
+will need to implement the interface defined in this header file.
+Typically, a loaded object will register one or more new GNU
+@code{make} functions using the @code{gmk_add_function} routine from
+within its setup function.  The implementations of these @code{make}
+functions may make use of the @code{gmk_expand} and @code{gmk_eval}
+routines to perform their tasks, then optionally return a string as
+the result of the function expansion.
+@subsubheading Loaded Object Licensing
+@cindex loaded object licensing
+@cindex plugin_is_GPL_compatible
+Every dynamic extension should define the global symbol
+@code{plugin_is_GPL_compatible} to assert that it has been licensed
+under a GPL-compatible license.  If this symbol does not exist,
+@code{make} emits a fatal error and exits when it tries to load your
+extension.
+The declared type of the symbol should be @code{int}. It does not need
+to be in any allocated section, though.  The code merely asserts that
+the symbol exists in the global scope. Something like this is enough:
+@example
+int plugin_is_GPL_compatible;
+@end example
+@subsubheading Data Structures
+@table @code
+@item gmk_floc
+This structure represents a filename/location pair.  It is provided
+when defining items, so GNU @code{make} can inform the user later
+where the definition occurred if necessary.
+@end table
+@subsubheading Registering Functions
+@findex gmk_add_function
+There is currently one way for makefiles to invoke operations provided
+by the loaded object: through the @code{make} function call
+interface.  A loaded object can register one or more new functions
+which may then be invoked from within the makefile in the same way as
+any other function.
+Use @code{gmk_add_function} to create a new @code{make} function.  Its
+arguments are as follows:
+@table @code
+@item name
+The function name.  This is what the makefile should use to invoke the
+function.  The name must be between 1 and 255 characters long and it
+may only contain alphanumeric, period (@samp{.}), dash (@samp{-}), and
+underscore (@samp{_}) characters.  It may not begin with a period.
+@item func_ptr
+A pointer to a function that @code{make} will invoke when it expands
+the function in a makefile.  This function must be defined by the
+loaded object.
+@item min_args
+The minimum number of arguments the function will accept.  Must be
+between 0 and 255.  GNU @code{make} will check this and fail before
+invoking @code{func_ptr} if the function was invoked with too few
+arguments.
+@item max_args
+The maximum number of arguments the function will accept.  Must be
+between 0 and 255.  GNU @code{make} will check this and fail before
+invoking @code{func_ptr} if the function was invoked with too few
+arguments.  If the value is 0, then any number of arguments is
+accepted.  If the value is greater than 0, then it must be greater
+than or equal to @code{min_args}.
+@item flags
+Flags that specify how this function will operate; the desired flags
+should be OR'd together.  If the @code{GMK_FUNC_NOEXPAND} flag is
+given then the function arguments will not be expanded before the
+function is called; otherwise they will be expanded first.
+@end table
+@subsubheading Registered Function Interface
+@findex gmk_func_ptr
+A function registered with @code{make} must match the
+@code{gmk_func_ptr} type.  It will be invoked with three parameters:
+@code{name} (the name of the function), @code{argc} (the number of
+arguments to the function), and @code{argv} (an array of pointers to
+arguments to the function).  The last pointer (that is,
+@code{argv[argc]}) will be null (@code{0}).
+The return value of the function is the result of expanding the
+function.  If the function expands to nothing the return value may be
+null.  Otherwise, it must be a pointer to a string created with
+@code{gmk_alloc}.  Once the function returns, @code{make} owns this
+string and will free it when appropriate; it cannot be accessed by the
+loaded object.
+@subsubheading GNU @code{make} Facilities
+There are some facilities exported by GNU @code{make} for use by
+loaded objects.  Typically these would be run from within the
+setup function and/or the functions registered via
+@code{gmk_add_function}, to retrieve or modify the data @code{make}
+works with.
+@table @code
+@item gmk_expand
+@findex gmk_expand
+This function takes a string and expands it using @code{make}
+expansion rules.  The result of the expansion is returned in a
+nil-terminated string buffer.  The caller is responsible for calling
+@code{gmk_free} with a pointer to the returned buffer when done.
+@item gmk_eval
+@findex gmk_eval
+This function takes a buffer and evaluates it as a segment of makefile
+syntax.  This function can be used to define new variables, new rules,
+etc.  It is equivalent to using the @code{eval} @code{make} function.
+@end table
+Note that there is a difference between @code{gmk_eval} and calling
+@code{gmk_expand} with a string using the @code{eval} function: in
+the latter case the string will be expanded @emph{twice}; once by
+@code{gmk_expand} and then again by the @code{eval} function.  Using
+@code{gmk_eval} the buffer is only expanded once, at most (as it's
+read by the @code{make} parser).
+@subsubheading Memory Management
+Some systems allow for different memory management schemes.  Thus you
+should never pass memory that you've allocated directly to any
+@code{make} function, nor should you attempt to directly free any
+memory returned to you by any @code{make} function.  Instead, use the
+@code{gmk_alloc} and @code{gmk_free} functions.
+In particular, the string returned to @code{make} by a function
+registered using @code{gmk_add_function} @emph{must} be allocated
+using @code{gmk_alloc}, and the string returned from the @code{make}
+@code{gmk_expand} function @emph{must} be freed (when no longer
+needed) using @code{gmk_free}.
+@table @code
+@item gmk_alloc
+@findex gmk_alloc
+Return a pointer to a newly-allocated buffer.  This function will
+always return a valid pointer; if not enough memory is available
+@code{make} will exit.
+@item gmk_free
+@findex gmk_free
+Free a buffer returned to you by @code{make}.  Once the
+@code{gmk_free} function returns the string will no longer be valid.
+@end table
+@node Loaded Object Example,  , Loaded Object API, Loading Objects
+@subsection Example Loaded Object
+@cindex loaded object example
+@cindex example of loaded objects
+Let's suppose we wanted to write a new GNU @code{make} function that
+would create a temporary file and return its name.  We would like our
+function to take a prefix as an argument.  First we can write the
+function in a file @file{mk_temp.c}:
+@example
+@group
+#include <stdlib.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <gnumake.h>
+int plugin_is_GPL_compatible;
+char *
+gen_tmpfile(const char *nm, int argc, char **argv)
+@{
+  int fd;
+  /* Compute the size of the filename and allocate space for it.  */
+  int len = strlen (argv[0]) + 6 + 1;
+  char *buf = gmk_alloc (len);
+  strcpy (buf, argv[0]);
+  strcat (buf, "XXXXXX");
+  fd = mkstemp(buf);
+  if (fd >= 0)
+    @{
+      /* Don't leak the file descriptor.  */
+      close (fd);
+      return buf;
+    @}
+  /* Failure.  */
+  fprintf (stderr, "mkstemp(%s) failed: %s\n", buf, strerror (errno));
+  gmk_free (buf);
+  return NULL;
+@}
+int
+mk_temp_gmk_setup ()
+@{
+  /* Register the function with make name "mk-temp".  */
+  gmk_add_function ("mk-temp", gen_tmpfile, 1, 1, 1);
+  return 1;
+@}
+@end group
+@end example
+Next, we will write a makefile that can build this shared object, load
+it, and use it:
+@example
+@group
+all:
+        @@echo Temporary file: $(mk-temp tmpfile.)
+load mk_temp.so
+mk_temp.so: mk_temp.c
+        $(CC) -shared -fPIC -o $@ $<
+@end group
+@end example
+On MS-Windows, due to peculiarities of how shared objects are
+produced, the compiler needs to scan the @dfn{import library} produced
+when building @code{make}, typically called
+@file{libgnumake-@var{version}.dll.a}, where @var{version} is the
+version of the load object API.  So the recipe to produce a shared
+object will look on Windows like this (assuming the API version is 1):
+@example
+@group
+mk_temp.dll: mk_temp.c
+        $(CC) -shared -o $@ $< -lgnumake-1
+@end group
+@end example
+Now when you run @code{make} you'll see something like:
+@example
+$ make
+cc -shared -fPIC -o mk_temp.so mk_temp.c
+Temporary filename: tmpfile.A7JEwd
+@end example
+@node Integrating make, Features, Extending make, Top
+@chapter Integrating GNU @code{make}
+@cindex make integration
+GNU @code{make} is often one component in a larger system of tools,
+including integrated development environments, compiler toolchains,
+and others.  The role of @code{make} is to start commands and
+determine whether they succeeded or not: no special integration is
+needed to accomplish that.  However, sometimes it is convenient to
+bind @code{make} more tightly with other parts of the system, both
+higher-level (tools that invoke @code{make}) and lower-level (tools
+that @code{make} invokes).
+@menu
+* Job Slots::                   Share job slots with GNU @code{make}.
+* Terminal Output::             Control output to terminals.
+@end menu
+@node Job Slots, Terminal Output, Integrating make, Integrating make
+@section Sharing Job Slots with GNU @code{make}
+@cindex job slots, sharing
+@cindex tools, sharing job slots
+GNU @code{make} has the ability to run multiple recipes in parallel
+(@pxref{Parallel, ,Parallel Execution}) and to cap the total number of
+parallel jobs even across recursive invocations of @code{make}
+(@pxref{Options/Recursion, ,Communicating Options to a
+Sub-@code{make}}).  Tools that @code{make} invokes which are also able
+to run multiple operations in parallel, either using multiple threads
+or multiple processes, can be enhanced to participate in GNU
+@code{make}'s job management facility to ensure that the total number
+of active threads/processes running on the system does not exceed the
+maximum number of slots provided to GNU @code{make}. @refill
+@cindex jobserver
+GNU @code{make} uses a method called the ``jobserver'' to control the
+number of active jobs across recursive invocations.  The actual
+implementation of the jobserver varies across different operating
+systems, but some fundamental aspects are always true.
+First, only command lines that @code{make} understands to be recursive
+invocations of @code{make} (@pxref{MAKE Variable, ,How the @code{MAKE}
+Variable Works}) will have access to the jobserver.  When writing
+makefiles you must be sure to mark the command as recursive (most
+commonly by prefixing the command line with the @code{+} indicator
+(@pxref{Recursion, ,Recursive Use of @code{make}}).
+Second, @code{make} will provide information necessary for accessing
+the jobserver through the environment to its children, in the
+@code{MAKEFLAGS} environment variable.  Tools which want to
+participate in the jobserver protocol will need to parse this
+environment variable, as described in subsequent sections.
+Third, every command @code{make} starts has one implicit job slot
+reserved for it before it starts.  Any tool which wants to participate
+in the jobserver protocol should assume it can always run one job
+without having to contact the jobserver at all.
+Finally, it's critical that tools that participate in the jobserver
+protocol return the exact number of slots they obtained from the
+jobserver back to the jobserver before they exit, even under error
+conditions.  Remember that the implicit job slot should @strong{not}
+be returned to the jobserver!  Returning too few slots means that
+those slots will be lost for the rest of the build process; returning
+too many slots means that extra slots will be available.  The
+top-level @code{make} command will print an error message at the end
+of the build if it detects an incorrect number of slots available in
+the jobserver.
+As an example, suppose you are implementing a linker which provides
+for multithreaded operation.  You would like to enhance the linker so
+that if it is invoked by GNU @code{make} it can participate in the
+jobserver protocol to control how many threads are used during link.
+First you will need to modify the linker to determine if the
+@code{MAKEFLAGS} environment variable is set.  Next you will need to
+parse the value of that variable to determine if the jobserver is
+available, and how to access it.  If it is available then you can
+access it to obtain job slots controlling how much parallelism your
+tool can use.  Once done your tool must return those job slots back to
+the jobserver.
+@menu
+* POSIX Jobserver::             Using the jobserver on POSIX systems.
+* Windows Jobserver::           Using the jobserver on Windows systems.
+@end menu
+@node POSIX Jobserver, Windows Jobserver, Job Slots, Job Slots
+@subsection POSIX Jobserver Interaction
+@cindex jobserver on POSIX
+On POSIX systems the jobserver is implemented as a simple UNIX pipe.
+The pipe will be pre-loaded with one single-character token for each
+available job.  To obtain an extra slot you must read a single
+character from the jobserver pipe; to release a slot you must write a
+single character back into the jobserver pipe.
+To access the pipe you must parse the @code{MAKEFLAGS} variable and
+look for the argument string @code{--jobserver-auth=R,W} where
+@samp{R} and @samp{W} are non-negative integers representing file
+descriptors: @samp{R} is the read file descriptor and @samp{W} is the
+write file descriptor.
+It's important that when you release the job slot, you write back the
+same character you read from the pipe for that slot.  Don't assume
+that all tokens are the same character; different characters may have
+different meanings to GNU @code{make}.  The order is not important,
+since @code{make} has no idea in what order jobs will complete anyway.
+There are various error conditions you must consider to ensure your
+implementation is robust:
+@itemize @bullet
+@item
+Usually you will have a command-line argument controlling the parallel
+operation of your tool.  Consider whether your tool should detect
+situations where both the jobserver and the command-line argument are
+specified, and how it should react.
+@item
+If your tool determines that the @code{--jobserver-auth} option is
+available in @code{MAKEFLAGS} but that the file descriptors specified
+are closed, this means that the calling @code{make} process did not
+think that your tool was a recursive @code{make} invocation (e.g., the
+command line was not prefixed with a @code{+} character).  You should
+notify your users of this situation.
+@item
+Your tool should also examine the first word of the @code{MAKEFLAGS}
+variable and look for the character @code{n}.  If this character is
+present then @code{make} was invoked with the @samp{-n} option and
+your tool should stop without performing any operations.
+@item
+Your tool should be sure to write back the tokens it read, even under
+error conditions.  This includes not only errors in your tool but also
+outside influences such as interrupts (@code{SIGINT}), etc.  You may
+want to install signal handlers to manage this write-back.
+@end itemize
+@node Windows Jobserver,  , POSIX Jobserver, Job Slots
+@subsection Windows Jobserver Interaction
+@cindex jobserver on Windows
+On Windows systems the jobserver is implemented as a named semaphore.
+The semaphore will be set with an initial count equal to the number of
+available slots; to obtain a slot you must wait on the semaphore (with
+or without a timeout).  To release a slot, release the semaphore.
+To access the semaphore you must parse the @code{MAKEFLAGS} variable and
+look for the argument string @code{--jobserver-auth=NAME} where
+@samp{NAME} is the name of the named semaphore.  Use this name with
+@code{OpenSemaphore} to create a handle to the semaphore.
+There are various error conditions you must consider to ensure your
+implementation is robust:
+@itemize @bullet
+@item
+Usually you will have a command-line argument controlling the parallel
+operation of your tool.  Consider whether your tool should detect
+situations where both the jobserver and the command-line argument are
+specified, and how it should react.
+@item
+Your tool should be sure to release the semaphore for the tokens it
+read, even under error conditions.  This includes not only errors in
+your tool but also outside influences such as interrupts
+(@code{SIGINT}), etc.  You may want to install signal handlers to
+manage this write-back.
+@end itemize
+@node Terminal Output,  , Job Slots, Integrating make
+@section Synchronized Terminal Output
+@cindex parallel output to terminal
+@cindex terminal, output to
+Normally GNU @code{make} will invoke all commands with access to the
+same standard and error outputs that @code{make} itself was started
+with.  A number of tools will detect whether the output is a terminal
+or not-a-terminal, and use this information to change the output
+style.  For example if the output goes to a terminal the tool may add
+control characters that set color, or even change the location of the
+cursor.  If the output is not going to a terminal then these special
+control characters are not emitted so that they don't corrupt log
+files, etc.
+The @code{--output-sync} (@pxref{Parallel Output, ,Output During
+Parallel Output}) option will defeat the terminal detection.  When
+output synchronization is enabled GNU @code{make} arranges for all
+command output to be written to a file, so that its output can be
+written as a block without interference from other commands.  This
+means that all tools invoked by @code{make} will believe that their
+output is not going to be displayed on a terminal, even when it will
+be (because @code{make} will display it there after the command is
+completed).
+In order to facilitate tools which would like to determine whether or
+not their output will be displayed on a terminal, GNU @code{make} will
+set the @code{MAKE_TERMOUT} and @code{MAKE_TERMERR} environment
+variables before invoking any commands.  Tools which would like to
+determine whether standard or error output (respectively) will be
+displayed on a terminal can check these environment variables to
+determine if they exist and contain a non-empty value.  If so the tool
+can assume that the output will (eventually) be displayed on a
+terminal.  If the variables are not set or have an empty value, then
+the tool should fall back to its normal methods of detecting whether
+output is going to a terminal or not.
+The content of the variables can be parsed to determine the type of
+terminal which will be used to display the output.
+Similarly, environments which invoke @code{make} and would like to
+capture the output and eventually display it on a terminal (or some
+display which can interpret terminal control characters) can set these
+variables before invoking @code{make}.  GNU @code{make} will not
+modify these environment variables if they already exist when it
+starts.
+@node Features, Missing, Integrating make, Top
 @chapter Features of GNU @code{make}
 @cindex features of GNU @code{make}
 …
 @item
 The arrangement of lines and backslash-newline combinations in
+The arrangement of lines and backslash/newline combinations in
 recipes is retained when the recipes are printed, so they appear as
 they do in the makefile, except for the stripping of initial
 …
 @item
+A number of different build tools that support parallelism also
+support collecting output and displaying as a single block.
+@xref{Parallel Output, ,Output During Parallel Execution}.
+@item
 Modified variable references using pattern substitution come from
 SunOS 4.  @xref{Reference, ,Basics of Variable References}.
 …
 @code{-include} directive.)  The same feature appears with the name
 @code{sinclude} in SGI @code{make} and perhaps others.
+@item
+The @code{!=} shell assignment operator exists in many BSD of
+@code{make} and is purposefully implemented here to behave identically
+to those implementations.
+@item
+Various build management tools are implemented using scripting
+languages such as Perl or Python and thus provide a natural embedded
+scripting language, similar to GNU @code{make}'s integration of GNU
+Guile.
 @end itemize
 …
 @item
 Various new built-in implicit rules.
 @xref{Catalogue of Rules, ,Catalogue of Implicit Rules}.
+@xref{Catalogue of Rules, ,Catalogue of Built-In Rules}.
 @item
+The built-in variable @samp{MAKE_VERSION} gives the version number of
+@code{make}.
+@vindex MAKE_VERSION
+Load dynamic objects which can modify the behavior of @code{make}.
+@xref{Loading Objects, ,Loading Dynamic Objects}.
 @end itemize
 …
 This feature was not put into GNU @code{make} because of the
 nonmodularity of putting knowledge into @code{make} of the internal
+non-modularity of putting knowledge into @code{make} of the internal
 format of archive file symbol tables.
 @xref{Archive Symbols, ,Updating Archive Symbol Directories}.
 …
 This appendix summarizes the directives, text manipulation functions,
 and special variables which GNU @code{make} understands.
 @xref{Special Targets}, @ref{Catalogue of Rules, ,Catalogue of Implicit Rules},
+@xref{Special Targets}, @ref{Catalogue of Rules, ,Catalogue of Built-In Rules},
 and @ref{Options Summary, ,Summary of Options},
 for other summaries.
 …
 @itemx define @var{variable} =
 @itemx define @var{variable} :=
+@itemx define @var{variable} ::=
 @itemx define @var{variable} +=
 @itemx define @var{variable} ?=
 …
 @xref{Eval Function, ,The @code{eval} Function}.
+@item $(file @var{op} @var{filename},@var{text})
+Expand the arguments, then open the file @var{filename} using mode
+@var{op} and write @var{text} to that file.@*
+@xref{File Function, ,The @code{file} Function}.
 @item $(value @var{var})
 Evaluates to the contents of the variable @var{var}, with no expansion
 …
 @code{MAKE} Variable Works}.
+@item MAKE_VERSION
+The built-in variable @samp{MAKE_VERSION} expands to the version
+number of the GNU @code{make} program.
+@vindex MAKE_VERSION
+@item MAKE_HOST
+The built-in variable @samp{MAKE_HOST} expands to a string
+representing the host that GNU @code{make} was built to run on.
+@vindex MAKE_HOST
 @item MAKELEVEL
 …
 through the environment from its parent.
+@item GNUMAKEFLAGS
+Other flags parsed by @code{make}.  You can set this in the environment or
+a makefile to set @code{make} command-line flags.  GNU @code{make}
+never sets this variable itself.  This variable is only needed if
+you'd like to set GNU @code{make}-specific flags in a POSIX-compliant
+makefile.  This variable will be seen by GNU @code{make} and ignored
+by other @code{make} implementations.  It's not needed if you only use
+GNU @code{make}; just use @code{MAKEFLAGS} directly.
+@xref{Options/Recursion, ,Communicating Options to a Sub-@code{make}}.
 @item MAKECMDGOALS
 …
 @item CURDIR
 Set to the pathname of the current working directory (after all
+@code{-C} options are processed, if any).  Setting this variable has no
 effect on the operation of @code{make}.@*
+Set to the absolute pathname of the current working directory (after
+all @code{-C} options are processed, if any).  Setting this variable
+has no effect on the operation of @code{make}.@*
 @xref{Recursion, ,Recursive Use of @code{make}}.
 …
 Error messages are all either prefixed with the name of the program
 (usually @samp{make}), or, if the error is found in a makefile, the name
 of the file and linenumber containing the problem.
+of the file and line number containing the problem.
 In the table below, these common prefixes are left off.
 …
 signal of some type).  @xref{Errors, ,Errors in Recipes}.
 If no @code{***} is attached to the message, then the subprocess failed
+If no @code{***} is attached to the message, then the sub-process failed
 but the rule in the makefile was prefixed with the @code{-} special
 character, so @code{make} ignored the error.
 …
 If you want that file to be built, you will need to add a rule to your
 makefile describing how that target can be built.  Other possible
 sources of this problem are typos in the makefile (if that filename is
+sources of this problem are typos in the makefile (if that file name is
 wrong) or a corrupted source tree (if that file is not supposed to be
 built, but rather only a prerequisite).
 …
 This means you've defined a normal (recursive) @code{make} variable
 @var{xxx} that, when it's expanded, will refer to itself (@var{xxx}).
 This is not allowed; either use simply-expanded variables (@code{:=}) or
+use the append operator (@code{+=}).  @xref{Using Variables, ,How to Use
 Variables}.
+This is not allowed; either use simply-expanded variables (@samp{:=}
+or @samp{::=}) or use the append operator (@samp{+=}).  @xref{Using
+Variables, ,How to Use Variables}.
 @item Unterminated variable reference.  Stop.
 …
 @itemx target pattern contains no `%'.  Stop.
 @itemx mixed implicit and static pattern rules.  Stop.
+These are generated for malformed static pattern rules.  The first means
+there's no pattern in the target section of the rule; the second means
+there are multiple patterns in the target section; the third means
+the target doesn't contain a pattern character (@code{%}); and the
+fourth means that all three parts of the static pattern rule contain
+pattern characters (@code{%})--only the first two parts should.
+These are generated for malformed static pattern rules.  The first
+means there's no pattern in the target section of the rule; the second
+means there are multiple patterns in the target section; the third
+means the target doesn't contain a pattern character (@code{%}); and
+the fourth means that all three parts of the static pattern rule
+contain pattern characters (@code{%})--only the first two parts
+should.  If you see these errors and you aren't trying to create a
+static pattern rule, check the value of any variables in your target
+and prerequisite lists to be sure they do not contain colons.
 @xref{Static Usage, ,Syntax of Static Pattern Rules}.
 …
 Here is the makefile for the GNU @code{tar} program.  This is a
+moderately complex makefile.
+moderately complex makefile.  The first line uses a @code{#!} setting
+to allow the makefile to be executed directly.
 Because it is the first target, the default goal is @samp{all}.  An
 …
 @example
 @group
+#!/usr/bin/make -f
 # Generated automatically from Makefile.in by configure.
 # Un*x Makefile for GNU tar program.

vendor/gnumake/current/dosbuild.bat

-              r2596
+              r3138
 @echo off
+rem Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+rem 2008, 2009, 2010 Free Software Foundation, Inc.
+rem Copyright (C) 1998-2016 Free Software Foundation, Inc.
 rem This file is part of GNU Make.
 rem
 …
 @echo on
 gcc  -c -I. -I./glob -DHAVE_CONFIG_H -O2 -g commands.c -o commands.o
+gcc  -c -I. -I./glob -DHAVE_CONFIG_H -O2 -g output.c -o output.o
 gcc  -c -I. -I./glob -DHAVE_CONFIG_H -O2 -g job.c -o job.o
 gcc  -c -I. -I./glob -DHAVE_CONFIG_H -O2 -g dir.c -o dir.o
 …
 cd ..
 echo commands.o > respf.$$$
 for %%f in (job dir file misc main read remake rule implicit default variable) do echo %%f.o >> respf.$$$
+for %%f in (job output dir file misc main read remake rule implicit default variable) do echo %%f.o >> respf.$$$
 for %%f in (expand function vpath hash strcache version ar arscan signame remote-stub getopt getopt1) do echo %%f.o >> respf.$$$
 echo glob/libglob.a >> respf.$$$
+rem gcc  -c -I. -I./glob -DHAVE_CONFIG_H -O2 -g guile.c -o guile.o
+rem echo guile.o >> respf.$$$
 @echo Linking...
 @echo on

vendor/gnumake/current/expand.c

-              r2596
+              r3138
 /* Variable expansion functions for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include <assert.h>
 …
 /* Initially, any errors reported when expanding strings will be reported
    against the file where the error appears.  */
 const struct floc **expanding_var = &reading_file;
+const floc **expanding_var = &reading_file;
 /* The next two describe the variable output buffer.
 …
       unsigned int offset = ptr - variable_buffer;
       variable_buffer_length = (newlen + 100 > 2 * variable_buffer_length
                                 ? newlen + 100
                                 : 2 * variable_buffer_length);
+                                ? newlen + 100
+                                : 2 * variable_buffer_length);
       variable_buffer = xrealloc (variable_buffer, variable_buffer_length);
       ptr = variable_buffer + offset;
 …
+{
   char *value;
   const struct floc *this_var;
   const struct floc **saved_varp;
+  const floc *this_var;
+  const floc **saved_varp;
   struct variable_set_list *save = 0;
   int set_reading = 0;
 …
       if (!v->exp_count)
         /* Expanding V causes infinite recursion.  Lose.  */
         fatal (*expanding_var,
                _("Recursive variable `%s' references itself (eventually)"),
                v->name);
+        OS (fatal, *expanding_var,
+            _("Recursive variable '%s' references itself (eventually)"),
+            v->name);
       --v->exp_count;
+    }
 …
    a null byte is found.
    Write the results to LINE, which must point into `variable_buffer'.  If
+   Write the results to LINE, which must point into 'variable_buffer'.  If
    LINE is NULL, start at the beginning of the buffer.
    Return a pointer to LINE, or to the beginning of the buffer if LINE is
 …
   struct variable *v;
   const char *p, *p1;
   char *abuf = NULL;
+  char *save;
   char *o;
   unsigned int line_offset;
   if (!line)
     line = initialize_variable_output();
+    line = initialize_variable_output ();
   o = line;
   line_offset = line - variable_buffer;
 …
+    }
+  /* If we want a subset of the string, allocate a temporary buffer for it.
+     Most of the functions we use here don't work with length limits.  */
+  if (length > 0 && string[length] != '\0')
+    {
+      abuf = xmalloc(length+1);
+      memcpy(abuf, string, length);
+      abuf[length] = '\0';
+      string = abuf;
+    }
+  p = string;
+  /* We need a copy of STRING: due to eval, it's possible that it will get
+     freed as we process it (it might be the value of a variable that's reset
+     for example).  Also having a nil-terminated string is handy.  */
+  save = length < 0 ? xstrdup (string) : xstrndup (string, length);
+  p = save;
   while (1)
 …
       /* Copy all following uninteresting chars all at once to the
          variable output buffer, and skip them.  Uninteresting chars end
          at the next $ or the end of the input.  */
+         at the next $ or the end of the input.  */
       p1 = strchr (p, '$');
 …
       if (p1 == 0)
         break;
+        break;
       p = p1 + 1;
 …
       switch (*p)
+        {
+        case '$':
+          /* $$ seen means output one $ to the variable output buffer.  */
+          o = variable_buffer_output (o, p, 1);
+          break;
+        case '(':
+        case '{':
+          /* $(...) or ${...} is the general case of substitution.  */
+          {
+            char openparen = *p;
+            char closeparen = (openparen == '(') ? ')' : '}';
+        {
+        case '$':
+        case '\0':
+          /* $$ or $ at the end of the string means output one $ to the
+             variable output buffer.  */
+          o = variable_buffer_output (o, p1, 1);
+          break;
+        case '(':
+        case '{':
+          /* $(...) or ${...} is the general case of substitution.  */
+          {
+            char openparen = *p;
+            char closeparen = (openparen == '(') ? ')' : '}';
             const char *begp;
             const char *beg = p + 1;
             char *op;
+            const char *beg = p + 1;
+            char *op;
             char *abeg = NULL;
             const char *end, *colon;
             op = o;
             begp = p;
             if (handle_function (&op, &begp))
+              {
                 o = op;
                 p = begp;
                 break;
+              }
             /* Is there a variable reference inside the parens or braces?
                If so, expand it before expanding the entire reference.  */
             end = strchr (beg, closeparen);
             if (end == 0)
+            const char *end, *colon;
+            op = o;
+            begp = p;
+            if (handle_function (&op, &begp))
+              {
+                o = op;
+                p = begp;
+                break;
+              }
+            /* Is there a variable reference inside the parens or braces?
+               If so, expand it before expanding the entire reference.  */
+            end = strchr (beg, closeparen);
+            if (end == 0)
               /* Unterminated variable reference.  */
               fatal (*expanding_var, _("unterminated variable reference"));
             p1 = lindex (beg, end, '$');
             if (p1 != 0)
+              {
                 /* BEG now points past the opening paren or brace.
                    Count parens or braces until it is matched.  */
                 int count = 0;
                 for (p = beg; *p != '\0'; ++p)
+                  {
                     if (*p == openparen)
                       ++count;
                     else if (*p == closeparen && --count < 0)
                       break;
+                  }
                 /* If COUNT is >= 0, there were unmatched opening parens
                    or braces, so we go to the simple case of a variable name
                    such as `$($(a)'.  */
                 if (count < 0)
+                  {
                     abeg = expand_argument (beg, p); /* Expand the name.  */
                     beg = abeg;
                     end = strchr (beg, '\0');
+                  }
+              }
             else
               /* Advance P to the end of this reference.  After we are
+              O (fatal, *expanding_var, _("unterminated variable reference"));
+            p1 = lindex (beg, end, '$');
+            if (p1 != 0)
+              {
+                /* BEG now points past the opening paren or brace.
+                   Count parens or braces until it is matched.  */
+                int count = 0;
+                for (p = beg; *p != '\0'; ++p)
+                  {
+                    if (*p == openparen)
+                      ++count;
+                    else if (*p == closeparen && --count < 0)
+                      break;
+                  }
+                /* If COUNT is >= 0, there were unmatched opening parens
+                   or braces, so we go to the simple case of a variable name
+                   such as '$($(a)'.  */
+                if (count < 0)
+                  {
+                    abeg = expand_argument (beg, p); /* Expand the name.  */
+                    beg = abeg;
+                    end = strchr (beg, '\0');
+                  }
+              }
+            else
+              /* Advance P to the end of this reference.  After we are
                  finished expanding this one, P will be incremented to
                  continue the scan.  */
+              p = end;
+            /* This is not a reference to a built-in function and
+               any variable references inside are now expanded.
+               Is the resultant text a substitution reference?  */
+            colon = lindex (beg, end, ':');
+            if (colon)
+              {
+                /* This looks like a substitution reference: $(FOO:A=B).  */
+                const char *subst_beg, *subst_end, *replace_beg, *replace_end;
+                subst_beg = colon + 1;
+                subst_end = lindex (subst_beg, end, '=');
+                if (subst_end == 0)
+                  /* There is no = in sight.  Punt on the substitution
+                     reference and treat this as a variable name containing
+                     a colon, in the code below.  */
+                  colon = 0;
+                else
+                  {
+                    replace_beg = subst_end + 1;
+                    replace_end = end;
+                    /* Extract the variable name before the colon
+                       and look up that variable.  */
+                    v = lookup_variable (beg, colon - beg);
+                    if (v == 0)
+                      warn_undefined (beg, colon - beg);
+              p = end;
+            /* This is not a reference to a built-in function and
+               any variable references inside are now expanded.
+               Is the resultant text a substitution reference?  */
+            colon = lindex (beg, end, ':');
+            if (colon)
+              {
+                /* This looks like a substitution reference: $(FOO:A=B).  */
+                const char *subst_beg = colon + 1;
+                const char *subst_end = lindex (subst_beg, end, '=');
+                if (subst_end == 0)
+                  /* There is no = in sight.  Punt on the substitution
+                     reference and treat this as a variable name containing
+                     a colon, in the code below.  */
+                  colon = 0;
+                else
+                  {
+                    const char *replace_beg = subst_end + 1;
+                    const char *replace_end = end;
+                    /* Extract the variable name before the colon
+                       and look up that variable.  */
+                    v = lookup_variable (beg, colon - beg);
+                    if (v == 0)
+                      warn_undefined (beg, colon - beg);
                     /* If the variable is not empty, perform the
                        substitution.  */
                     if (v != 0 && *v->value != '\0')
+                      {
                         char *pattern, *replace, *ppercent, *rpercent;
                         char *value = (v->recursive
+                    if (v != 0 && *v->value != '\0')
+                      {
+                        char *pattern, *replace, *ppercent, *rpercent;
+                        char *value = (v->recursive
                                        ? recursively_expand (v)
                                        : v->value);
+                                       : v->value);
                         /* Copy the pattern and the replacement.  Add in an
 …
                         /* Look for %.  Set the percent pointers properly
                            based on whether we find one or not.  */
                         ppercent = find_percent (pattern);
                         if (ppercent)
+                        ppercent = find_percent (pattern);
+                        if (ppercent)
+                          {
                             ++ppercent;
 …
                               ++rpercent;
+                          }
                         else
+                        else
+                          {
                             ppercent = pattern;
 …
                                                  ppercent, rpercent);
+                        if (v->recursive)
+                          free (value);
+                      }
+                  }
+              }
+            if (colon == 0)
+              /* This is an ordinary variable reference.
+                 Look up the value of the variable.  */
+                o = reference_variable (o, beg, end - beg);
+          if (abeg)
+            free (abeg);
+          }
+          break;
+        case '\0':
+          break;
+        default:
+          if (isblank ((unsigned char)p[-1]))
+            break;
+          /* A $ followed by a random char is a variable reference:
+             $a is equivalent to $(a).  */
+                        if (v->recursive)
+                          free (value);
+                      }
+                  }
+              }
+            if (colon == 0)
+              /* This is an ordinary variable reference.
+                 Look up the value of the variable.  */
+                o = reference_variable (o, beg, end - beg);
+            free (abeg);
+          }
+          break;
+        default:
+          if (ISSPACE (p[-1]))
+            break;
+          /* A $ followed by a random char is a variable reference:
+             $a is equivalent to $(a).  */
           o = reference_variable (o, p, 1);
           break;
+        }
+          break;
+        }
       if (*p == '\0')
         break;
+        break;
       ++p;
+    }
+  if (abuf)
+    free (abuf);
+  free (save);
   variable_buffer_output (o, "", 1);
 …
 /* Scan LINE for variable references and expansion-function calls.
    Build in `variable_buffer' the result of expanding the references and calls.
+   Build in 'variable_buffer' the result of expanding the references and calls.
    Return the address of the resulting string, which is null-terminated
    and is valid only until the next time this function is called.  */
 …
 variable_expand (const char *line)
+{
   return variable_expand_string(NULL, line, (long)-1);
+  return variable_expand_string (NULL, line, (long)-1);
+}
 …
    The text starting at STR and ending at END is variable-expanded
    into a null-terminated string that is returned as the value.
    This is done without clobbering `variable_buffer' or the current
+   This is done without clobbering 'variable_buffer' or the current
    variable-expansion that is in progress.  */
 …
   if (str == end)
     return xstrdup("");
+    return xstrdup ("");
   if (!end || *end == '\0')
 …
   r = allocated_variable_expand (tmp);
+  if (alloc)
+    free (alloc);
+  free (alloc);
   return r;
 …
   char *result;
   struct variable_set_list *savev;
   const struct floc *savef;
+  const floc *savef;
   if (file == 0)
 …
 static char *
 variable_append (const char *name, unsigned int length,
                  const struct variable_set_list *set)
+                 const struct variable_set_list *set, int local)
+{
   const struct variable *v;
   char *buf = 0;
+  /* If this set is local and the next is not a parent, then next is local.  */
+  int nextlocal = local && set->next_is_parent == 0;
   /* If there's nothing left to check, return the empty buffer.  */
 …
   v = lookup_variable_in_set (name, length, set->set);
   /* If there isn't one, look to see if there's one in a set above us.  */
   if (!v)
     return variable_append (name, length, set->next);
+  /* If there isn't one, or this one is private, try the set above us.  */
+  if (!v || (!local && v->private_var))
+    return variable_append (name, length, set->next, nextlocal);
   /* If this variable type is append, first get any upper values.
      If not, initialize the buffer.  */
   if (v->append)
     buf = variable_append (name, length, set->next);
+    buf = variable_append (name, length, set->next, nextlocal);
   else
     buf = initialize_variable_output ();
 …
   variable_buffer = 0;
+  val = variable_append (v->name, strlen (v->name), current_variable_set_list);
+  val = variable_append (v->name, strlen (v->name),
+                         current_variable_set_list, 1);
   variable_buffer_output (val, "", 1);
   val = variable_buffer;

vendor/gnumake/current/file.c

-              r2596
+              r3138
 /* Target file management for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include <assert.h>
+#include "filedef.h"
 #include "dep.h"
-#include "filedef.h"
 #include "job.h"
 #include "commands.h"
 …
+{
   return_ISTRING_COMPARE (((struct file const *) x)->hname,
+                          ((struct file const *) y)->hname);
+}
+#ifndef FILE_BUCKETS
+#define FILE_BUCKETS    1007
+#endif
+                          ((struct file const *) y)->hname);
+}
 static struct hash_table files;
 …
   struct file *f;
   struct file file_key;
+#if defined(VMS) && !defined(WANT_CASE_SENSITIVE_TARGETS)
+#ifdef VMS
+  int want_vmsify;
+#ifndef WANT_CASE_SENSITIVE_TARGETS
   char *lname;
+#endif
 #endif
 …
      on the command line.  */
 #ifdef VMS
+   want_vmsify = (strpbrk (name, "]>:^") != NULL);
 # ifndef WANT_CASE_SENSITIVE_TARGETS
   if (*name != '.')
 …
   while (name[0] == '[' && name[1] == ']' && name[2] != '\0')
       name += 2;
+  while (name[0] == '<' && name[1] == '>' && name[2] != '\0')
+      name += 2;
 #endif
   while (name[0] == '.'
 #ifdef HAVE_DOS_PATHS
          && (name[1] == '/' || name[1] == '\\')
+         && (name[1] == '/' || name[1] == '\\')
 #else
          && name[1] == '/'
+         && name[1] == '/'
 #endif
          && name[2] != '\0')
+         && name[2] != '\0')
+    {
       name += 2;
       while (*name == '/'
 #ifdef HAVE_DOS_PATHS
              || *name == '\\'
+             || *name == '\\'
 #endif
+             )
         /* Skip following slashes: ".//foo" is "foo", not "/foo".  */
         ++name;
+             )
+        /* Skip following slashes: ".//foo" is "foo", not "/foo".  */
+        ++name;
+    }
   if (*name == '\0')
+    /* It was all slashes after a dot.  */
+    {
+      /* It was all slashes after a dot.  */
+#if defined(_AMIGA)
+      name = "";
+#else
+      name = "./";
+#endif
 #if defined(VMS)
+    name = "[]";
+#elif defined(_AMIGA)
+    name = "";
+#else
+    name = "./";
+      /* TODO - This section is probably not needed. */
+      if (want_vmsify)
+        name = "[]";
 #endif
+    }
   file_key.hname = name;
   f = hash_find_item (&files, &file_key);
 …
   assert (*name != '\0');
   assert (strcache_iscached (name));
+  assert (! verify_flag || strcache_iscached (name));
 #if defined(VMS) && !defined(WANT_CASE_SENSITIVE_TARGETS)
 …
   f = *file_slot;
   if (! HASH_VACANT (f) && !f->double_colon)
+    return f;
+    {
+      f->builtin = 0;
+      return f;
+    }
   new = xcalloc (sizeof (struct file));
   new->name = new->hname = name;
   new->update_status = -1;
+  new->update_status = us_none;
   if (HASH_VACANT (f))
 …
 /* Rehash FILE to NAME.  This is not as simple as resetting
    the `hname' member, since it must be put in a new hash bucket,
+   the 'hname' member, since it must be put in a new hash bucket,
    and possibly merged with an existing file called NAME.  */
 …
   /* If it's already that name, we're done.  */
+  from_file->builtin = 0;
   file_key.hname = to_hname;
   if (! file_hash_cmp (from_file, &file_key))
 …
       else if (from_file->cmds != to_file->cmds)
+        {
+          size_t l = strlen (from_file->name);
           /* We have two sets of commands.  We will go with the
              one given in the rule explicitly mentioning this name,
 …
           if (to_file->cmds->fileinfo.filenm != 0)
             error (&from_file->cmds->fileinfo,
+                   _("Recipe was specified for file `%s' at %s:%lu,"),
+                   l + strlen (to_file->cmds->fileinfo.filenm) + INTSTR_LENGTH,
+                   _("Recipe was specified for file '%s' at %s:%lu,"),
                    from_file->name, to_file->cmds->fileinfo.filenm,
                    to_file->cmds->fileinfo.lineno);
           else
             error (&from_file->cmds->fileinfo,
                    _("Recipe for file `%s' was found by implicit rule search,"),
+            error (&from_file->cmds->fileinfo, l,
+                   _("Recipe for file '%s' was found by implicit rule search,"),
                    from_file->name);
+          error (&from_file->cmds->fileinfo,
+                 _("but `%s' is now considered the same file as `%s'."),
+          l += strlen (to_hname);
+          error (&from_file->cmds->fileinfo, l,
+                 _("but '%s' is now considered the same file as '%s'."),
                  from_file->name, to_hname);
           error (&from_file->cmds->fileinfo,
                  _("Recipe for `%s' will be ignored in favor of the one for `%s'."),
+          error (&from_file->cmds->fileinfo, l,
+                 _("Recipe for '%s' will be ignored in favor of the one for '%s'."),
                  to_hname, from_file->name);
+        }
 …
   if (to_file->double_colon && from_file->is_target && !from_file->double_colon)
     fatal (NILF, _("can't rename single-colon `%s' to double-colon `%s'"),
            from_file->name, to_hname);
+    OSS (fatal, NILF, _("can't rename single-colon '%s' to double-colon '%s'"),
+         from_file->name, to_hname);
   if (!to_file->double_colon  && from_file->double_colon)
+    {
       if (to_file->is_target)
+        fatal (NILF, _("can't rename double-colon `%s' to single-colon `%s'"),
+               from_file->name, to_hname);
+        OSS (fatal, NILF,
+             _("can't rename double-colon '%s' to single-colon '%s'"),
+             from_file->name, to_hname);
       else
         to_file->double_colon = from_file->double_colon;
 …
   MERGE (cmd_target);
   MERGE (phony);
+  MERGE (loaded);
   MERGE (ignore_vpath);
 #undef MERGE
+  to_file->builtin = 0;
   from_file->renamed = to_file;
+}
 /* Rename FILE to NAME.  This is not as simple as resetting
    the `name' member, since it must be put in a new hash bucket,
+   the 'name' member, since it must be put in a new hash bucket,
    and possibly merged with an existing file called NAME.  */
 …
     if (! HASH_VACANT (*file_slot))
+      {
         struct file *f = *file_slot;
+        struct file *f = *file_slot;
         /* Is this file eligible for automatic deletion?
            Yes, IFF: it's marked intermediate, it's not secondary, it wasn't
            given on the command line, and it's either a -include makefile or
            it's not precious.  */
+        if (f->intermediate && (f->dontcare || !f->precious)
+            && !f->secondary && !f->cmd_target)
+          {
+            int status;
+            if (f->update_status == -1)
+              /* If nothing would have created this file yet,
+                 don't print an "rm" command for it.  */
+              continue;
+            if (just_print_flag)
+              status = 0;
+            else
+              {
+                status = unlink (f->name);
+                if (status < 0 && errno == ENOENT)
+                  continue;
+              }
+            if (!f->dontcare)
+              {
+                if (sig)
+                  error (NILF, _("*** Deleting intermediate file `%s'"), f->name);
+                else
+                  {
+                    if (! doneany)
+                      DB (DB_BASIC, (_("Removing intermediate files...\n")));
+                    if (!silent_flag)
+                      {
+                        if (! doneany)
+                          {
+                            fputs ("rm ", stdout);
+                            doneany = 1;
+                          }
+                        else
+                          putchar (' ');
+                        fputs (f->name, stdout);
+                        fflush (stdout);
+                      }
+                  }
+                if (status < 0)
+                  perror_with_name ("unlink: ", f->name);
+              }
+          }
+        if (f->intermediate && (f->dontcare || !f->precious)
+            && !f->secondary && !f->cmd_target)
+          {
+            int status;
+            if (f->update_status == us_none)
+              /* If nothing would have created this file yet,
+                 don't print an "rm" command for it.  */
+              continue;
+            if (just_print_flag)
+              status = 0;
+            else
+              {
+                status = unlink (f->name);
+                if (status < 0 && errno == ENOENT)
+                  continue;
+              }
+            if (!f->dontcare)
+              {
+                if (sig)
+                  OS (error, NILF,
+                      _("*** Deleting intermediate file '%s'"), f->name);
+                else
+                  {
+                    if (! doneany)
+                      DB (DB_BASIC, (_("Removing intermediate files...\n")));
+                    if (!silent_flag)
+                      {
+                        if (! doneany)
+                          {
+                            fputs ("rm ", stdout);
+                            doneany = 1;
+                          }
+                        else
+                          putchar (' ');
+                        fputs (f->name, stdout);
+                        fflush (stdout);
+                      }
+                  }
+                if (status < 0)
+                  perror_with_name ("unlink: ", f->name);
+              }
+          }
+      }
 …
 split_prereqs (char *p)
+{
+  struct dep *new = PARSE_FILE_SEQ (&p, struct dep, '|', NULL, 0);
+  struct dep *new = PARSE_FILE_SEQ (&p, struct dep, MAP_PIPE, NULL,
+                                    PARSEFS_NONE);
   if (*p)
 …
       ++p;
       ood = PARSE_FILE_SEQ (&p, struct dep, '\0', NULL, 0);
+      ood = PARSE_SIMPLE_SEQ (&p, struct dep);
       if (! new)
 …
       if (d->staticpattern)
+        {
+          char *o;
+          d->name = o = variable_expand ("");
+          char *o = variable_expand ("");
           o = subst_expand (o, name, "%", "$*", 1, 2, 0);
           *o = '\0';
           free (name);
           d->name = name = xstrdup (d->name);
+          d->name = name = xstrdup (variable_buffer);
           d->staticpattern = 0;
+        }
 …
+}
 /* For each dependency of each file, make the `struct dep' point
    at the appropriate `struct file' (which may have to be created).
+/* For each dependency of each file, make the 'struct dep' point
+   at the appropriate 'struct file' (which may have to be created).
    Also mark the files depended on by .PRECIOUS, .PHONY, .SILENT,
 …
     for (d = f->deps; d != 0; d = d->next)
       for (f2 = d->file; f2 != 0; f2 = f2->prev)
         f2->precious = 1;
+        f2->precious = 1;
   for (f = lookup_file (".LOW_RESOLUTION_TIME"); f != 0; f = f->prev)
     for (d = f->deps; d != 0; d = d->next)
       for (f2 = d->file; f2 != 0; f2 = f2->prev)
         f2->low_resolution_time = 1;
+        f2->low_resolution_time = 1;
   for (f = lookup_file (".PHONY"); f != 0; f = f->prev)
     for (d = f->deps; d != 0; d = d->next)
       for (f2 = d->file; f2 != 0; f2 = f2->prev)
+        {
           /* Mark this file as phony nonexistent target.  */
           f2->phony = 1;
+        {
+          /* Mark this file as phony nonexistent target.  */
+          f2->phony = 1;
           f2->is_target = 1;
           f2->last_mtime = NONEXISTENT_MTIME;
           f2->mtime_before_update = NONEXISTENT_MTIME;
+        }
+          f2->last_mtime = NONEXISTENT_MTIME;
+          f2->mtime_before_update = NONEXISTENT_MTIME;
+        }
   for (f = lookup_file (".INTERMEDIATE"); f != 0; f = f->prev)
 …
+    {
       if (f->deps == 0)
         ignore_errors_flag = 1;
+        ignore_errors_flag = 1;
       else
         for (d = f->deps; d != 0; d = d->next)
           for (f2 = d->file; f2 != 0; f2 = f2->prev)
             f2->command_flags |= COMMANDS_NOERROR;
+        for (d = f->deps; d != 0; d = d->next)
+          for (f2 = d->file; f2 != 0; f2 = f2->prev)
+            f2->command_flags |= COMMANDS_NOERROR;
+    }
 …
+    {
       if (f->deps == 0)
         silent_flag = 1;
+        silent_flag = 1;
       else
         for (d = f->deps; d != 0; d = d->next)
           for (f2 = d->file; f2 != 0; f2 = f2->prev)
             f2->command_flags |= COMMANDS_SILENT;
+        for (d = f->deps; d != 0; d = d->next)
+          for (f2 = d->file; f2 != 0; f2 = f2->prev)
+            f2->command_flags |= COMMANDS_SILENT;
+    }
 …
 /* Set the `command_state' member of FILE and all its `also_make's.  */
+/* Set the 'command_state' member of FILE and all its 'also_make's.  */
 void
 …
 FILE_TIMESTAMP
 file_timestamp_cons (const char *fname, time_t s, int ns)
+file_timestamp_cons (const char *fname, time_t stamp, long int ns)
+{
   int offset = ORDINARY_MTIME_MIN + (FILE_TIMESTAMP_HI_RES ? ns : 0);
+  FILE_TIMESTAMP s = stamp;
   FILE_TIMESTAMP product = (FILE_TIMESTAMP) s << FILE_TIMESTAMP_LO_BITS;
   FILE_TIMESTAMP ts = product + offset;
   if (! (s <= FILE_TIMESTAMP_S (ORDINARY_MTIME_MAX)
          && product <= ts && ts <= ORDINARY_MTIME_MAX))
+         && product <= ts && ts <= ORDINARY_MTIME_MAX))
+    {
       char buf[FILE_TIMESTAMP_PRINT_LEN_BOUND + 1];
+      const char *f = fname ? fname : _("Current time");
       ts = s <= OLD_MTIME ? ORDINARY_MTIME_MIN : ORDINARY_MTIME_MAX;
       file_timestamp_sprintf (buf, ts);
       error (NILF, _("%s: Timestamp out of range; substituting %s"),
              fname ? fname : _("Current time"), buf);
+      OSS (error, NILF,
+           _("%s: Timestamp out of range; substituting %s"), f, buf);
+    }
 …
     if (clock_gettime (CLOCK_REALTIME, &timespec) == 0)
+      {
         r = 1;
         s = timespec.tv_sec;
         ns = timespec.tv_nsec;
         goto got_time;
+        r = 1;
+        s = timespec.tv_sec;
+        ns = timespec.tv_nsec;
+        goto got_time;
+      }
+  }
 …
     if (gettimeofday (&timeval, 0) == 0)
+      {
         r = 1000;
         s = timeval.tv_sec;
         ns = timeval.tv_usec * 1000;
         goto got_time;
+        r = 1000;
+        s = timeval.tv_sec;
+        ns = timeval.tv_usec * 1000;
+        goto got_time;
+      }
+  }
 …
   if (tm)
     sprintf (p, "%04d-%02d-%02d %02d:%02d:%02d",
              tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
              tm->tm_hour, tm->tm_min, tm->tm_sec);
+             tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
+             tm->tm_hour, tm->tm_min, tm->tm_sec);
   else if (t < 0)
     sprintf (p, "%ld", (long) t);
 …
   const struct file *f = item;
+  /* If we're not using builtin targets, don't show them.
+     Ideally we'd be able to delete them altogether but currently there's no
+     facility to ever delete a file once it's been added.  */
+  if (no_builtin_rules_flag && f->builtin)
+    return;
   putchar ('\n');
+  if (f->cmds && f->cmds->recipe_prefix != cmd_prefix)
+    {
+      fputs (".RECIPEPREFIX = ", stdout);
+      cmd_prefix = f->cmds->recipe_prefix;
+      if (cmd_prefix != RECIPEPREFIX_DEFAULT)
+        putchar (cmd_prefix);
+      putchar ('\n');
+    }
+  if (f->variables != 0)
+    print_target_variables (f);
   if (!f->is_target)
     puts (_("# Not a target:"));
 …
   if (f->dontcare)
     puts (_("#  A default, MAKEFILES, or -include/sinclude makefile."));
+  if (f->builtin)
+    puts (_("#  Builtin rule"));
   puts (f->tried_implicit
         ? _("#  Implicit rule search has been done.")
         : _("#  Implicit rule search has not been done."));
   if (f->stem != 0)
     printf (_("#  Implicit/static pattern stem: `%s'\n"), f->stem);
+    printf (_("#  Implicit/static pattern stem: '%s'\n"), f->stem);
   if (f->intermediate)
     puts (_("#  File is an intermediate prerequisite."));
 …
       fputs (_("#  Also makes:"), stdout);
       for (d = f->also_make; d != 0; d = d->next)
         printf (" %s", dep_name (d));
+        printf (" %s", dep_name (d));
       putchar ('\n');
+    }
 …
     case cs_finished:
       switch (f->update_status)
+        {
+        case -1:
+          break;
+        case 0:
+          puts (_("#  Successfully updated."));
+          break;
+        case 1:
+          assert (question_flag);
+          puts (_("#  Needs to be updated (-q is set)."));
+          break;
+        case 2:
+          puts (_("#  Failed to be updated."));
+          break;
+        default:
+          puts (_("#  Invalid value in `update_status' member!"));
+          fflush (stdout);
+          fflush (stderr);
+          abort ();
+        }
+        {
+        case us_none:
+          break;
+        case us_success:
+          puts (_("#  Successfully updated."));
+          break;
+        case us_question:
+          assert (question_flag);
+          puts (_("#  Needs to be updated (-q is set)."));
+          break;
+        case us_failed:
+          puts (_("#  Failed to be updated."));
+          break;
+        }
       break;
     default:
       puts (_("#  Invalid value in `command_state' member!"));
+      puts (_("#  Invalid value in 'command_state' member!"));
       fflush (stdout);
       fflush (stderr);
 …
 #define VERIFY_CACHED(_p,_n) \
+    do{\
+        if (_p->_n && _p->_n[0] && !strcache_iscached (_p->_n)) \
+          error (NULL, "%s: Field '%s' not cached: %s\n", _p->name, # _n, _p->_n); \
+    do{                                                                       \
+        if (_p->_n && _p->_n[0] && !strcache_iscached (_p->_n))               \
+          error (NULL, strlen (_p->name) + CSTRLEN (# _n) + strlen (_p->_n),  \
+                 _("%s: Field '%s' not cached: %s"), _p->name, # _n, _p->_n); \
     }while(0)

vendor/gnumake/current/filedef.h

-              r2596
+              r3138
 /* Definition of target file data structures for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 /* Structure that represents the info on one file
    that the makefile says how to make.
    All of these are chained together through `next'.  */
+   All of these are chained together through 'next'.  */
 #include "hash.h"
 …
     const char *hname;          /* Hashed filename */
     const char *vpath;          /* VPATH/vpath pathname */
+    struct dep *deps;           /* all dependencies, including duplicates */
+    struct commands *cmds;      /* Commands to execute for this target.  */
+    int command_flags;          /* Flags OR'd in for cmds; see commands.h.  */
+    const char *stem;           /* Implicit stem, if an implicit
+    struct dep *deps;           /* all dependencies, including duplicates */
+    struct commands *cmds;      /* Commands to execute for this target.  */
+    const char *stem;           /* Implicit stem, if an implicit
                                    rule has been used */
+    struct dep *also_make;      /* Targets that are made by making this.  */
+    FILE_TIMESTAMP last_mtime;  /* File's modtime, if already known.  */
+    FILE_TIMESTAMP mtime_before_update; /* File's modtime before any updating
+                                           has been performed.  */
+    struct file *prev;          /* Previous entry for same file name;
+                                   used when there are multiple double-colon
+                                   entries for the same file.  */
+    struct dep *also_make;      /* Targets that are made by making this.  */
+    struct file *prev;          /* Previous entry for same file name;
+                                   used when there are multiple double-colon
+                                   entries for the same file.  */
     struct file *last;          /* Last entry for the same file name.  */
     /* File that this file was renamed to.  After any time that a
        file could be renamed, call `check_renamed' (below).  */
+       file could be renamed, call 'check_renamed' (below).  */
     struct file *renamed;
 …
     struct file *double_colon;
+    short int update_status;    /* Status of the last attempt to update,
+                                   or -1 if none has been made.  */
+    enum cmd_state              /* State of the commands.  */
+      {         /* Note: It is important that cs_not_started be zero.  */
+        cs_not_started,         /* Not yet started.  */
+        cs_deps_running,        /* Dep commands running.  */
+        cs_running,             /* Commands running.  */
+        cs_finished             /* Commands finished.  */
+    FILE_TIMESTAMP last_mtime;  /* File's modtime, if already known.  */
+    FILE_TIMESTAMP mtime_before_update; /* File's modtime before any updating
+                                           has been performed.  */
+    unsigned int considered;    /* equal to 'considered' if file has been
+                                   considered on current scan of goal chain */
+    int command_flags;          /* Flags OR'd in for cmds; see commands.h.  */
+    enum update_status          /* Status of the last attempt to update.  */
+      {
+        us_success = 0,         /* Successfully updated.  Must be 0!  */
+        us_none,                /* No attempt to update has been made.  */
+        us_question,            /* Needs to be updated (-q is is set).  */
+        us_failed               /* Update failed.  */
+      } update_status ENUM_BITFIELD (2);
+    enum cmd_state              /* State of the commands.  */
+      {
+        cs_not_started = 0,     /* Not yet started.  Must be 0!  */
+        cs_deps_running,        /* Dep commands running.  */
+        cs_running,             /* Commands running.  */
+        cs_finished             /* Commands finished.  */
       } command_state ENUM_BITFIELD (2);
+    unsigned int precious:1;    /* Non-0 means don't delete file on quit */
+    unsigned int low_resolution_time:1; /* Nonzero if this file's time stamp
+                                           has only one-second resolution.  */
+    unsigned int builtin:1;     /* True if the file is a builtin rule. */
+    unsigned int precious:1;    /* Non-0 means don't delete file on quit */
+    unsigned int loaded:1;      /* True if the file is a loaded object. */
+    unsigned int low_resolution_time:1; /* Nonzero if this file's time stamp
+                                           has only one-second resolution.  */
     unsigned int tried_implicit:1; /* Nonzero if have searched
                                       for implicit rule for making
                                       this file; don't search again.  */
     unsigned int updating:1;    /* Nonzero while updating deps of this file */
     unsigned int updated:1;     /* Nonzero if this file has been remade.  */
     unsigned int is_target:1;   /* Nonzero if file is described as target.  */
     unsigned int cmd_target:1;  /* Nonzero if file was given on cmd line.  */
     unsigned int phony:1;       /* Nonzero if this is a phony file
                                    i.e., a prerequisite of .PHONY.  */
+                                      for implicit rule for making
+                                      this file; don't search again.  */
+    unsigned int updating:1;    /* Nonzero while updating deps of this file */
+    unsigned int updated:1;     /* Nonzero if this file has been remade.  */
+    unsigned int is_target:1;   /* Nonzero if file is described as target.  */
+    unsigned int cmd_target:1;  /* Nonzero if file was given on cmd line.  */
+    unsigned int phony:1;       /* Nonzero if this is a phony file
+                                   i.e., a prerequisite of .PHONY.  */
     unsigned int intermediate:1;/* Nonzero if this is an intermediate file.  */
     unsigned int secondary:1;   /* Nonzero means remove_intermediates should
                                    not delete it.  */
     unsigned int dontcare:1;    /* Nonzero if no complaint is to be made if
                                    this target cannot be remade.  */
+    unsigned int dontcare:1;    /* Nonzero if no complaint is to be made if
+                                   this target cannot be remade.  */
     unsigned int ignore_vpath:1;/* Nonzero if we threw out VPATH name.  */
     unsigned int pat_searched:1;/* Nonzero if we already searched for
                                    pattern-specific variables.  */
-    unsigned int considered:1;  /* equal to 'considered' if file has been
-                                   considered on current scan of goal chain */
     unsigned int no_diag:1;     /* True if the file failed to update and no
                                    diagnostics has been issued (dontcare). */
 …
 extern struct file *suffix_file, *default_file;
+extern struct file *default_file;
 …
 void notice_finished_file (struct file *file);
 void init_hash_files (void);
+void verify_file_data_base (void);
 char *build_target_list (char *old_list);
 void print_prereqs (const struct dep *deps);
 void print_file_data_base (void);
+int try_implicit_rule (struct file *file, unsigned int depth);
+int stemlen_compare (const void *v1, const void *v2);
 #if FILE_TIMESTAMP_HI_RES
 # define FILE_TIMESTAMP_STAT_MODTIME(fname, st) \
     file_timestamp_cons (fname, (st).st_mtime, (st).st_mtim.ST_MTIM_NSEC)
+    file_timestamp_cons (fname, (st).st_mtime, (st).ST_MTIM_NSEC)
 #else
 # define FILE_TIMESTAMP_STAT_MODTIME(fname, st) \
 …
 #define FILE_TIMESTAMP_S(ts) (((ts) - ORDINARY_MTIME_MIN) \
                               >> FILE_TIMESTAMP_LO_BITS)
+                              >> FILE_TIMESTAMP_LO_BITS)
 #define FILE_TIMESTAMP_NS(ts) ((int) (((ts) - ORDINARY_MTIME_MIN) \
                                       & ((1 << FILE_TIMESTAMP_LO_BITS) - 1)))
+                                      & ((1 << FILE_TIMESTAMP_LO_BITS) - 1)))
 /* Upper bound on length of string "YYYY-MM-DD HH:MM:SS.NNNNNNNNN"
    representing a file timestamp.  The upper bound is not necessarily 19,
+   representing a file timestamp.  The upper bound is not necessarily 29,
    since the year might be less than -999 or greater than 9999.
 …
    + 1 + 1 + 4 + 25)
 FILE_TIMESTAMP file_timestamp_cons (char const *, time_t, int);
+FILE_TIMESTAMP file_timestamp_cons (char const *, time_t, long int);
 FILE_TIMESTAMP file_timestamp_now (int *);
 void file_timestamp_sprintf (char *p, FILE_TIMESTAMP ts);
 …
 #define ORDINARY_MTIME_MIN (OLD_MTIME + 1)
 #define ORDINARY_MTIME_MAX ((FILE_TIMESTAMP_S (NEW_MTIME) \
                              << FILE_TIMESTAMP_LO_BITS) \
                             + ORDINARY_MTIME_MIN + FILE_TIMESTAMPS_PER_S - 1)
 /* Modtime value to use for `infinitely new'.  We used to get the current time
    from the system and use that whenever we wanted `new'.  But that causes
+                             << FILE_TIMESTAMP_LO_BITS) \
+                            + ORDINARY_MTIME_MIN + FILE_TIMESTAMPS_PER_S - 1)
+/* Modtime value to use for 'infinitely new'.  We used to get the current time
+   from the system and use that whenever we wanted 'new'.  But that causes
    trouble when the machine running make and the machine holding a file have
    different ideas about what time it is; and can also lose for `force'
+   different ideas about what time it is; and can also lose for 'force'
    targets, which need to be considered newer than anything that depends on
    them, even if said dependents' modtimes are in the future.  */

vendor/gnumake/current/function.c

-              r2596
+              r3138
 /* Builtin function expansion for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include "filedef.h"
 #include "variable.h"
 …
 struct function_table_entry
+  {
+    union {
+      char *(*func_ptr) (char *output, char **argv, const char *fname);
+      gmk_func_ptr alloc_func_ptr;
+    } fptr;
     const char *name;
     unsigned char len;
     unsigned char minimum_args;
     unsigned char maximum_args;
     char expand_args;
     char *(*func_ptr) (char *output, char **argv, const char *fname);
+    unsigned char expand_args:1;
+    unsigned char alloc_fn:1;
   };
 …
       o = variable_buffer_output (o, t, strlen (t));
       if (rlen > 0)
         o = variable_buffer_output (o, replace, rlen);
+        o = variable_buffer_output (o, replace, rlen);
       return o;
+    }
 …
+    {
       if (by_word && slen == 0)
         /* When matching by words, the empty string should match
            the end of each word, rather than the end of the whole text.  */
         p = end_of_token (next_token (t));
+        /* When matching by words, the empty string should match
+           the end of each word, rather than the end of the whole text.  */
+        p = end_of_token (next_token (t));
       else
+        {
           p = strstr (t, subst);
           if (p == 0)
+            {
               /* No more matches.  Output everything left on the end.  */
               o = variable_buffer_output (o, t, strlen (t));
               return o;
+            }
+        }
+        {
+          p = strstr (t, subst);
+          if (p == 0)
+            {
+              /* No more matches.  Output everything left on the end.  */
+              o = variable_buffer_output (o, t, strlen (t));
+              return o;
+            }
+        }
       /* Output everything before this occurrence of the string to replace.  */
       if (p > t)
         o = variable_buffer_output (o, t, p - t);
+        o = variable_buffer_output (o, t, p - t);
       /* If we're substituting only by fully matched words,
          or only at the ends of words, check that this case qualifies.  */
+         or only at the ends of words, check that this case qualifies.  */
       if (by_word
           && ((p > text && !isblank ((unsigned char)p[-1]))
               || (p[slen] != '\0' && !isblank ((unsigned char)p[slen]))))
         /* Struck out.  Output the rest of the string that is
            no longer to be replaced.  */
         o = variable_buffer_output (o, subst, slen);
+          && ((p > text && !ISSPACE (p[-1]))
+              || ! STOP_SET (p[slen], MAP_SPACE|MAP_NUL)))
+        /* Struck out.  Output the rest of the string that is
+           no longer to be replaced.  */
+        o = variable_buffer_output (o, subst, slen);
       else if (rlen > 0)
         /* Output the replacement string.  */
         o = variable_buffer_output (o, replace, rlen);
+        /* Output the replacement string.  */
+        o = variable_buffer_output (o, replace, rlen);
       /* Advance T past the string to be replaced.  */
 …
     /* With no % in the pattern, this is just a simple substitution.  */
     return subst_expand (o, text, pattern, replace,
                          strlen (pattern), strlen (replace), 1);
+                         strlen (pattern), strlen (replace), 1);
   /* Record the length of PATTERN before and after the %
 …
       /* Is it big enough to match?  */
       if (len < pattern_prepercent_len + pattern_postpercent_len)
         fail = 1;
+        fail = 1;
       /* Does the prefix match? */
       if (!fail && pattern_prepercent_len > 0
           && (*t != *pattern
               || t[pattern_prepercent_len - 1] != pattern_percent[-2]
               || !strneq (t + 1, pattern + 1, pattern_prepercent_len - 1)))
         fail = 1;
+          && (*t != *pattern
+              || t[pattern_prepercent_len - 1] != pattern_percent[-2]
+              || !strneq (t + 1, pattern + 1, pattern_prepercent_len - 1)))
+        fail = 1;
       /* Does the suffix match? */
       if (!fail && pattern_postpercent_len > 0
           && (t[len - 1] != pattern_percent[pattern_postpercent_len - 1]
               || t[len - pattern_postpercent_len] != *pattern_percent
               || !strneq (&t[len - pattern_postpercent_len],
                           pattern_percent, pattern_postpercent_len - 1)))
         fail = 1;
+          && (t[len - 1] != pattern_percent[pattern_postpercent_len - 1]
+              || t[len - pattern_postpercent_len] != *pattern_percent
+              || !strneq (&t[len - pattern_postpercent_len],
+                          pattern_percent, pattern_postpercent_len - 1)))
+        fail = 1;
       if (fail)
         /* It didn't match.  Output the string.  */
         o = variable_buffer_output (o, t, len);
+        /* It didn't match.  Output the string.  */
+        o = variable_buffer_output (o, t, len);
       else
+        {
           /* It matched.  Output the replacement.  */
           /* Output the part of the replacement before the %.  */
           o = variable_buffer_output (o, replace, replace_prepercent_len);
           if (replace_percent != 0)
+            {
               /* Output the part of the matched string that
                  matched the % in the pattern.  */
               o = variable_buffer_output (o, t + pattern_prepercent_len,
                                           len - (pattern_prepercent_len
                                                  + pattern_postpercent_len));
               /* Output the part of the replacement after the %.  */
               o = variable_buffer_output (o, replace_percent,
                                           replace_postpercent_len);
+            }
+        }
+        {
+          /* It matched.  Output the replacement.  */
+          /* Output the part of the replacement before the %.  */
+          o = variable_buffer_output (o, replace, replace_prepercent_len);
+          if (replace_percent != 0)
+            {
+              /* Output the part of the matched string that
+                 matched the % in the pattern.  */
+              o = variable_buffer_output (o, t + pattern_prepercent_len,
+                                          len - (pattern_prepercent_len
+                                                 + pattern_postpercent_len));
+              /* Output the part of the replacement after the %.  */
+              o = variable_buffer_output (o, replace_percent,
+                                          replace_postpercent_len);
+            }
+        }
       /* Output a space, but not if the replacement is "".  */
       if (fail || replace_prepercent_len > 0
           || (replace_percent != 0 && len + replace_postpercent_len > 0))
+        {
           o = variable_buffer_output (o, " ", 1);
           doneany = 1;
+        }
+          || (replace_percent != 0 && len + replace_postpercent_len > 0))
+        {
+          o = variable_buffer_output (o, " ", 1);
+          doneany = 1;
+        }
+    }
   if (doneany)
 …
 lookup_function (const char *s)
+{
+  struct function_table_entry function_table_entry_key;
   const char *e = s;
   while (*e && ( (*e >= 'a' && *e <= 'z') || *e == '-'))
+  while (STOP_SET (*e, MAP_USERFUNC))
     e++;
+  if (*e == '\0' || isblank ((unsigned char) *e))
+    {
+      struct function_table_entry function_table_entry_key;
+      function_table_entry_key.name = s;
+      function_table_entry_key.len = e - s;
+      return hash_find_item (&function_table, &function_table_entry_key);
+    }
+  return 0;
+  if (e == s || !STOP_SET(*e, MAP_NUL|MAP_SPACE))
+    return NULL;
+  function_table_entry_key.name = s;
+  function_table_entry_key.len = e - s;
+  return hash_find_item (&function_table, &function_table_entry_key);
+}
 …
       percent = find_percent (new_chars);
       if (percent == 0)
         return streq (new_chars, str);
+        return streq (new_chars, str);
       pattern = new_chars;
+    }
 …
     else if (*ptr == endparen)
+      {
         --count;
         if (count < 0)
           return NULL;
+        --count;
+        if (count < 0)
+          return NULL;
+      }
 …
   unsigned int idx;
   chain = PARSE_FILE_SEQ (&line, struct nameseq, '\0', NULL,
                           /* We do not want parse_file_seq to strip `./'s.
+  chain = PARSE_FILE_SEQ (&line, struct nameseq, MAP_NUL, NULL,
+                          /* We do not want parse_file_seq to strip './'s.
                              That would break examples like:
                              $(patsubst ./%.c,obj/%.o,$(wildcard ./?*.c)).  */
 …
       tp = find_next_token (&list1_iterator, &len1);
       if (tp != 0)
         o = variable_buffer_output (o, tp, len1);
+        o = variable_buffer_output (o, tp, len1);
       pp = find_next_token (&list2_iterator, &len2);
       if (pp != 0)
         o = variable_buffer_output (o, pp, len2);
+        o = variable_buffer_output (o, pp, len2);
       if (tp != 0 || pp != 0)
+        {
           o = variable_buffer_output (o, " ", 1);
           doneany = 1;
+        }
+        {
+          o = variable_buffer_output (o, " ", 1);
+          doneany = 1;
+        }
+    }
   while (tp != 0 || pp != 0);
 …
       default:
       case o_invalid:
         abort ();
         break;
+        abort ();
+        break;
       case o_default:
         o = variable_buffer_output (o, "default", 7);
         break;
+        o = variable_buffer_output (o, "default", 7);
+        break;
       case o_env:
         o = variable_buffer_output (o, "environment", 11);
         break;
+        o = variable_buffer_output (o, "environment", 11);
+        break;
       case o_file:
         o = variable_buffer_output (o, "file", 4);
         break;
+        o = variable_buffer_output (o, "file", 4);
+        break;
       case o_env_override:
         o = variable_buffer_output (o, "environment override", 20);
         break;
+        o = variable_buffer_output (o, "environment override", 20);
+        break;
       case o_command:
         o = variable_buffer_output (o, "command line", 12);
         break;
+        o = variable_buffer_output (o, "command line", 12);
+        break;
       case o_override:
         o = variable_buffer_output (o, "override", 8);
         break;
+        o = variable_buffer_output (o, "override", 8);
+        break;
       case o_automatic:
         o = variable_buffer_output (o, "automatic", 9);
         break;
+        o = variable_buffer_output (o, "automatic", 9);
+        break;
+      }
 …
+}
-#ifdef VMS
-# define IS_PATHSEP(c) ((c) == ']')
-#else
-# ifdef HAVE_DOS_PATHS
-#  define IS_PATHSEP(c) ((c) == '/' || (c) == '\\')
-# else
-#  define IS_PATHSEP(c) ((c) == '/')
-# endif
-#endif
 static char *
 …
   unsigned int len=0;
   int is_suffix = streq (funcname, "suffix");
+  int is_suffix = funcname[0] == 's';
   int is_notdir = !is_suffix;
+  int stop = MAP_DIRSEP | (is_suffix ? MAP_DOT : 0);
+#ifdef VMS
+  /* For VMS list_iterator points to a comma separated list. To use the common
+     [find_]next_token, create a local copy and replace the commas with
+     spaces. Obviously, there is a problem if there is a ',' in the VMS filename
+     (can only happen on ODS5), the same problem as with spaces in filenames,
+     which seems to be present in make on all platforms. */
+  char *vms_list_iterator = alloca(strlen(list_iterator) + 1);
+  int i;
+  for (i = 0; list_iterator[i]; i++)
+    if (list_iterator[i] == ',')
+      vms_list_iterator[i] = ' ';
+    else
+      vms_list_iterator[i] = list_iterator[i];
+  vms_list_iterator[i] = list_iterator[i];
+  while ((p2 = find_next_token((const char**) &vms_list_iterator, &len)) != 0)
+#else
   while ((p2 = find_next_token (&list_iterator, &len)) != 0)
+    {
+      const char *p = p2 + len;
+      while (p >= p2 && (!is_suffix || *p != '.'))
+        {
+          if (IS_PATHSEP (*p))
+            break;
+          --p;
+        }
+#endif
+    {
+      const char *p = p2 + len - 1;
+      while (p >= p2 && ! STOP_SET (*p, stop))
+        --p;
       if (p >= p2)
+        {
           if (is_notdir)
             ++p;
           else if (*p != '.')
             continue;
           o = variable_buffer_output (o, p, len - (p - p2));
+        }
+        {
+          if (is_notdir)
+            ++p;
+          else if (*p != '.')
+            continue;
+          o = variable_buffer_output (o, p, len - (p - p2));
+        }
 #ifdef HAVE_DOS_PATHS
       /* Handle the case of "d:foo/bar".  */
       else if (streq (funcname, "notdir") && p2[0] && p2[1] == ':')
+        {
           p = p2 + 2;
           o = variable_buffer_output (o, p, len - (p - p2));
+        }
+      else if (is_notdir && p2[0] && p2[1] == ':')
+        {
+          p = p2 + 2;
+          o = variable_buffer_output (o, p, len - (p - p2));
+        }
 #endif
       else if (is_notdir)
         o = variable_buffer_output (o, p2, len);
+        o = variable_buffer_output (o, p2, len);
       if (is_notdir || p >= p2)
+        {
+          o = variable_buffer_output (o, " ", 1);
+          doneany = 1;
+        }
+        {
+#ifdef VMS
+          if (vms_comma_separator)
+            o = variable_buffer_output (o, ",", 1);
+          else
+#endif
+          o = variable_buffer_output (o, " ", 1);
+          doneany = 1;
+        }
+    }
 …
   const char *p3 = argv[0];
   const char *p2;
+  int doneany=0;
+  unsigned int len=0;
+  int is_basename= streq (funcname, "basename");
+  int is_dir= !is_basename;
+  int doneany = 0;
+  unsigned int len = 0;
+  int is_basename = funcname[0] == 'b';
+  int is_dir = !is_basename;
+  int stop = MAP_DIRSEP | (is_basename ? MAP_DOT : 0) | MAP_NUL;
+#ifdef VMS
+  /* As in func_notdir_suffix ... */
+  char *vms_p3 = alloca (strlen(p3) + 1);
+  int i;
+  for (i = 0; p3[i]; i++)
+    if (p3[i] == ',')
+      vms_p3[i] = ' ';
+    else
+      vms_p3[i] = p3[i];
+  vms_p3[i] = p3[i];
+  while ((p2 = find_next_token((const char**) &vms_p3, &len)) != 0)
+#else
   while ((p2 = find_next_token (&p3, &len)) != 0)
+    {
+      const char *p = p2 + len;
+      while (p >= p2 && (!is_basename  || *p != '.'))
+        {
+          if (IS_PATHSEP (*p))
+            break;
+          --p;
+        }
+#endif
+    {
+      const char *p = p2 + len - 1;
+      while (p >= p2 && ! STOP_SET (*p, stop))
+        --p;
       if (p >= p2 && (is_dir))
 …
       else if (is_dir)
 #ifdef VMS
+        o = variable_buffer_output (o, "[]", 2);
+        {
+          extern int vms_report_unix_paths;
+          if (vms_report_unix_paths)
+            o = variable_buffer_output (o, "./", 2);
+          else
+            o = variable_buffer_output (o, "[]", 2);
+        }
 #else
 #ifndef _AMIGA
 …
         o = variable_buffer_output (o, p2, len);
+      o = variable_buffer_output (o, " ", 1);
+#ifdef VMS
+      if (vms_comma_separator)
+        o = variable_buffer_output (o, ",", 1);
+      else
+#endif
+        o = variable_buffer_output (o, " ", 1);
       doneany = 1;
+    }
 …
   int fixlen = strlen (argv[0]);
   const char *list_iterator = argv[1];
   int is_addprefix = streq (funcname, "addprefix");
+  int is_addprefix = funcname[3] == 'p';
   int is_addsuffix = !is_addprefix;
 …
+    {
       if (is_addprefix)
         o = variable_buffer_output (o, argv[0], fixlen);
+        o = variable_buffer_output (o, argv[0], fixlen);
       o = variable_buffer_output (o, p, len);
       if (is_addsuffix)
         o = variable_buffer_output (o, argv[0], fixlen);
+        o = variable_buffer_output (o, argv[0], fixlen);
       o = variable_buffer_output (o, " ", 1);
       doneany = 1;
 …
+{
   o = subst_expand (o, argv[2], argv[0], argv[1], strlen (argv[0]),
                     strlen (argv[1]), 0);
+                    strlen (argv[1]), 0);
   return o;
 …
   char buf[20];
   while (find_next_token (&word_iterator, (unsigned int *) 0) != 0)
+  while (find_next_token (&word_iterator, NULL) != 0)
     ++i;
 …
 strip_whitespace (const char **begpp, const char **endpp)
+{
   while (*begpp <= *endpp && isspace ((unsigned char)**begpp))
+  while (*begpp <= *endpp && ISSPACE (**begpp))
     (*begpp) ++;
   while (*endpp >= *begpp && isspace ((unsigned char)**endpp))
+  while (*endpp >= *begpp && ISSPACE (**endpp))
     (*endpp) --;
   return (char *)*begpp;
 …
   for (; s <= end; ++s)
     if (!ISDIGIT (*s))  /* ISDIGIT only evals its arg once: see make.h.  */
+    if (!ISDIGIT (*s))  /* ISDIGIT only evals its arg once: see makeint.h.  */
       break;
   if (s <= end || end - beg < 0)
     fatal (*expanding_var, "%s: '%s'", msg, beg);
+    OSS (fatal, *expanding_var, "%s: '%s'", msg, beg);
+}
 …
   /* Check the first argument.  */
   check_numeric (argv[0], _("non-numeric first argument to `word' function"));
+  check_numeric (argv[0], _("non-numeric first argument to 'word' function"));
   i = atoi (argv[0]);
   if (i == 0)
     fatal (*expanding_var,
            _("first argument to `word' function must be greater than 0"));
+    O (fatal, *expanding_var,
+       _("first argument to 'word' function must be greater than 0"));
   end_p = argv[1];
 …
   /* Check the arguments.  */
   check_numeric (argv[0],
                  _("non-numeric first argument to `wordlist' function"));
+                 _("non-numeric first argument to 'wordlist' function"));
   check_numeric (argv[1],
                  _("non-numeric second argument to `wordlist' function"));
+                 _("non-numeric second argument to 'wordlist' function"));
   start = atoi (argv[0]);
   if (start < 1)
     fatal (*expanding_var,
            "invalid first argument to `wordlist' function: `%d'", start);
+    ON (fatal, *expanding_var,
+        "invalid first argument to 'wordlist' function: '%d'", start);
   count = atoi (argv[1]) - start + 1;
 …
   struct variable *var;
+  /* Clean up the variable name by removing whitespace.  */
+  char *vp = next_token (varname);
+  end_of_token (vp)[0] = '\0';
   push_new_variable_scope ();
   var = define_variable (varname, strlen (varname), "", o_automatic, 0);
+  var = define_variable (vp, strlen (vp), "", o_automatic, 0);
   /* loop through LIST,  put the value in VAR and expand BODY */
 …
     return result;
   return_STRING_COMPARE (((struct a_word const *) x)->str,
                          ((struct a_word const *) y)->str);
+                         ((struct a_word const *) y)->str);
+}
 …
   char *percent;
   int length;
-  int save_c;
 };
 …
   struct hash_table a_word_table;
   int is_filter = streq (funcname, "filter");
+  int is_filter = funcname[CSTRLEN ("filter")] == '\0';
   const char *pat_iterator = argv[0];
   const char *word_iterator = argv[1];
 …
   unsigned int len;
+  /* Chop ARGV[0] up into patterns to match against the words.  */
+  /* Chop ARGV[0] up into patterns to match against the words.
+     We don't need to preserve it because our caller frees all the
+     argument memory anyway.  */
   pattail = &pathead;
 …
       if (*pat_iterator != '\0')
         ++pat_iterator;
+        ++pat_iterator;
       pat->str = p;
-      pat->length = len;
-      pat->save_c = p[len];
       p[len] = '\0';
       pat->percent = find_percent (p);
       if (pat->percent == 0)
+        literals++;
+        literals++;
+      /* find_percent() might shorten the string so LEN is wrong.  */
+      pat->length = strlen (pat->str);
+    }
   *pattail = 0;
 …
       if (*word_iterator != '\0')
         ++word_iterator;
+        ++word_iterator;
       p[len] = '\0';
 …
                  a_word_hash_cmp);
       for (wp = wordhead; wp != 0; wp = wp->next)
+        {
           struct a_word *owp = hash_insert (&a_word_table, wp);
           if (owp)
             wp->chain = owp;
+        }
+        {
+          struct a_word *owp = hash_insert (&a_word_table, wp);
+          if (owp)
+            wp->chain = owp;
+        }
+    }
 …
       /* Run each pattern through the words, killing words.  */
       for (pp = pathead; pp != 0; pp = pp->next)
+        {
           if (pp->percent)
             for (wp = wordhead; wp != 0; wp = wp->next)
               wp->matched |= pattern_matches (pp->str, pp->percent, wp->str);
           else if (hashing)
+            {
               struct a_word a_word_key;
               a_word_key.str = pp->str;
               a_word_key.length = pp->length;
               wp = hash_find_item (&a_word_table, &a_word_key);
               while (wp)
+                {
                   wp->matched |= 1;
                   wp = wp->chain;
+                }
+            }
           else
             for (wp = wordhead; wp != 0; wp = wp->next)
               wp->matched |= (wp->length == pp->length
                               && strneq (pp->str, wp->str, wp->length));
+        }
+        {
+          if (pp->percent)
+            for (wp = wordhead; wp != 0; wp = wp->next)
+              wp->matched |= pattern_matches (pp->str, pp->percent, wp->str);
+          else if (hashing)
+            {
+              struct a_word a_word_key;
+              a_word_key.str = pp->str;
+              a_word_key.length = pp->length;
+              wp = hash_find_item (&a_word_table, &a_word_key);
+              while (wp)
+                {
+                  wp->matched |= 1;
+                  wp = wp->chain;
+                }
+            }
+          else
+            for (wp = wordhead; wp != 0; wp = wp->next)
+              wp->matched |= (wp->length == pp->length
+                              && strneq (pp->str, wp->str, wp->length));
+        }
       /* Output the words that matched (or didn't, for filter-out).  */
       for (wp = wordhead; wp != 0; wp = wp->next)
         if (is_filter ? wp->matched : !wp->matched)
+          {
             o = variable_buffer_output (o, wp->str, strlen (wp->str));
             o = variable_buffer_output (o, " ", 1);
             doneany = 1;
+          }
+        if (is_filter ? wp->matched : !wp->matched)
+          {
+            o = variable_buffer_output (o, wp->str, strlen (wp->str));
+            o = variable_buffer_output (o, " ", 1);
+            doneany = 1;
+          }
       if (doneany)
+        /* Kill the last space.  */
+        --o;
+    }
+  for (pp = pathead; pp != 0; pp = pp->next)
+    pp->str[pp->length] = pp->save_c;
+        /* Kill the last space.  */
+        --o;
+    }
   if (hashing)
 …
       const char *word_start;
+      while (isspace ((unsigned char)*p))
+        ++p;
+      NEXT_TOKEN (p);
       word_start = p;
       for (i=0; *p != '\0' && !isspace ((unsigned char)*p); ++p, ++i)
         {}
+      for (i=0; *p != '\0' && !ISSPACE (*p); ++p, ++i)
+        {}
       if (!i)
         break;
+        break;
       o = variable_buffer_output (o, word_start, i);
       o = variable_buffer_output (o, " ", 1);
 …
   strcpy (p, *argvp);
+  switch (*funcname) {
+  switch (*funcname)
+    {
     case 'e':
       fatal (reading_file, "%s", msg);
+      OS (fatal, reading_file, "%s", msg);
     case 'w':
       error (reading_file, "%s", msg);
+      OS (error, reading_file, "%s", msg);
       break;
     case 'i':
       printf ("%s\n", msg);
       fflush(stdout);
+      outputs (0, msg);
+      outputs (0, "\n");
       break;
     default:
       fatal (*expanding_var, "Internal error: func_error: '%s'", funcname);
+  }
+      OS (fatal, *expanding_var, "Internal error: func_error: '%s'", funcname);
+    }
   /* The warning function expands to the empty string.  */
 …
   char *p;
   unsigned int len;
-  int i;
   /* Find the maximum number of words we'll have.  */
   t = argv[0];
+  wordi = 1;
+  while (*t != '\0')
+    {
+      char c = *(t++);
+      if (! isspace ((unsigned char)c))
+        continue;
+  wordi = 0;
+  while ((p = find_next_token (&t, NULL)) != 0)
+    {
+      ++t;
       ++wordi;
+      while (isspace ((unsigned char)*t))
+        ++t;
+    }
+  words = xmalloc (wordi * sizeof (char *));
+    }
+  words = xmalloc ((wordi == 0 ? 1 : wordi) * sizeof (char *));
   /* Now assign pointers to each string in the array.  */
 …
   if (wordi)
+    {
+      int i;
       /* Now sort the list of words.  */
       qsort (words, wordi, sizeof (char *), alpha_compare);
 …
+{
   char *expansion;
-  int result;
   while (1)
 …
       const char *begp = *argv;
       const char *endp = begp + strlen (*argv) - 1;
+      int result;
       /* An empty condition is always false.  */
 …
   install_variable_buffer (&buf, &len);
   eval_buffer (argv[0]);
+  eval_buffer (argv[0], NULL);
   restore_variable_buffer (buf, len);
 …
   /* Copy its value into the output buffer without expanding it.  */
   if (v)
     o = variable_buffer_output (o, v->value, strlen(v->value));
+    o = variable_buffer_output (o, v->value, strlen (v->value));
   return o;
 …
 /*
   \r  is replaced on UNIX as well. Is this desirable?
+  \r is replaced on UNIX as well. Is this desirable?
  */
 static void
 fold_newlines (char *buffer, unsigned int *length)
+fold_newlines (char *buffer, unsigned int *length, int trim_newlines)
+{
   char *dst = buffer;
   char *src = buffer;
   char *last_nonnl = buffer -1;
+  char *last_nonnl = buffer - 1;
   src[*length] = 0;
   for (; *src != '\0'; ++src)
+    {
       if (src[0] == '\r' && src[1] == '\n')
         continue;
+        continue;
       if (*src == '\n')
+        {
           *dst++ = ' ';
+        }
+        {
+          *dst++ = ' ';
+        }
       else
+        {
+          last_nonnl = dst;
+          *dst++ = *src;
+        }
+    }
+        {
+          last_nonnl = dst;
+          *dst++ = *src;
+        }
+    }
+  if (!trim_newlines && (last_nonnl < (dst - 2)))
+    last_nonnl = dst - 2;
   *(++last_nonnl) = '\0';
   *length = last_nonnl - buffer;
+}
+int shell_function_pid = 0, shell_function_completed;
+pid_t shell_function_pid = 0;
+static int shell_function_completed;
+void
+shell_completed (int exit_code, int exit_sig)
+{
+  char buf[256];
+  shell_function_pid = 0;
+  if (exit_sig == 0 && exit_code == 127)
+    shell_function_completed = -1;
+  else
+    shell_function_completed = 1;
+  sprintf (buf, "%d", exit_code);
+  define_variable_cname (".SHELLSTATUS", buf, o_override, 0);
+}
 #ifdef WINDOWS32
 …
+void
 windows32_openpipe (int *pipedes, pid_t *pid_p, char **command_argv, char **envp)
+int
+windows32_openpipe (int *pipedes, int errfd, pid_t *pid_p, char **command_argv, char **envp)
+{
   SECURITY_ATTRIBUTES saAttr;
   HANDLE hIn;
   HANDLE hErr;
+  HANDLE hIn = INVALID_HANDLE_VALUE;
+  HANDLE hErr = INVALID_HANDLE_VALUE;
   HANDLE hChildOutRd;
   HANDLE hChildOutWr;
+  HANDLE hProcess;
+  HANDLE hProcess, tmpIn, tmpErr;
+  DWORD e;
+  /* Set status for return.  */
+  pipedes[0] = pipedes[1] = -1;
+  *pid_p = (pid_t)-1;
   saAttr.nLength = sizeof (SECURITY_ATTRIBUTES);
 …
   saAttr.lpSecurityDescriptor = NULL;
+  if (DuplicateHandle (GetCurrentProcess(),
+                      GetStdHandle(STD_INPUT_HANDLE),
+                      GetCurrentProcess(),
+                      &hIn,
+,
+                      TRUE,
+                      DUPLICATE_SAME_ACCESS) == FALSE) {
+    fatal (NILF, _("windows32_openpipe(): DuplicateHandle(In) failed (e=%ld)\n"),
+           GetLastError());
+  }
+  if (DuplicateHandle(GetCurrentProcess(),
+                      GetStdHandle(STD_ERROR_HANDLE),
+                      GetCurrentProcess(),
+                      &hErr,
+,
+                      TRUE,
+                      DUPLICATE_SAME_ACCESS) == FALSE) {
+    fatal (NILF, _("windows32_open_pipe(): DuplicateHandle(Err) failed (e=%ld)\n"),
+           GetLastError());
+  }
+  if (!CreatePipe(&hChildOutRd, &hChildOutWr, &saAttr, 0))
+    fatal (NILF, _("CreatePipe() failed (e=%ld)\n"), GetLastError());
+  hProcess = process_init_fd(hIn, hChildOutWr, hErr);
+  /* Standard handles returned by GetStdHandle can be NULL or
+     INVALID_HANDLE_VALUE if the parent process closed them.  If that
+     happens, we open the null device and pass its handle to
+     process_begin below as the corresponding handle to inherit.  */
+  tmpIn = GetStdHandle (STD_INPUT_HANDLE);
+  if (DuplicateHandle (GetCurrentProcess (), tmpIn,
+                       GetCurrentProcess (), &hIn,
+, TRUE, DUPLICATE_SAME_ACCESS) == FALSE)
+    {
+      e = GetLastError ();
+      if (e == ERROR_INVALID_HANDLE)
+        {
+          tmpIn = CreateFile ("NUL", GENERIC_READ,
+                              FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+                              OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+          if (tmpIn != INVALID_HANDLE_VALUE
+              && DuplicateHandle (GetCurrentProcess (), tmpIn,
+                                  GetCurrentProcess (), &hIn,
+, TRUE, DUPLICATE_SAME_ACCESS) == FALSE)
+            CloseHandle (tmpIn);
+        }
+      if (hIn == INVALID_HANDLE_VALUE)
+        {
+          ON (error, NILF,
+              _("windows32_openpipe: DuplicateHandle(In) failed (e=%ld)\n"), e);
+          return -1;
+        }
+    }
+  tmpErr = (HANDLE)_get_osfhandle (errfd);
+  if (DuplicateHandle (GetCurrentProcess (), tmpErr,
+                       GetCurrentProcess (), &hErr,
+, TRUE, DUPLICATE_SAME_ACCESS) == FALSE)
+    {
+      e = GetLastError ();
+      if (e == ERROR_INVALID_HANDLE)
+        {
+          tmpErr = CreateFile ("NUL", GENERIC_WRITE,
+                               FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+                               OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+          if (tmpErr != INVALID_HANDLE_VALUE
+              && DuplicateHandle (GetCurrentProcess (), tmpErr,
+                                  GetCurrentProcess (), &hErr,
+, TRUE, DUPLICATE_SAME_ACCESS) == FALSE)
+            CloseHandle (tmpErr);
+        }
+      if (hErr == INVALID_HANDLE_VALUE)
+        {
+          ON (error, NILF,
+              _("windows32_openpipe: DuplicateHandle(Err) failed (e=%ld)\n"), e);
+          return -1;
+        }
+    }
+  if (! CreatePipe (&hChildOutRd, &hChildOutWr, &saAttr, 0))
+    {
+      ON (error, NILF, _("CreatePipe() failed (e=%ld)\n"), GetLastError());
+      return -1;
+    }
+  hProcess = process_init_fd (hIn, hChildOutWr, hErr);
   if (!hProcess)
+    fatal (NILF, _("windows32_openpipe(): process_init_fd() failed\n"));
+    {
+      O (error, NILF, _("windows32_openpipe(): process_init_fd() failed\n"));
+      return -1;
+    }
   /* make sure that CreateProcess() has Path it needs */
   sync_Path_environment();
   /* `sync_Path_environment' may realloc `environ', so take note of
+  sync_Path_environment ();
+  /* 'sync_Path_environment' may realloc 'environ', so take note of
      the new value.  */
   envp = environ;
+  if (!process_begin(hProcess, command_argv, envp, command_argv[0], NULL)) {
+    /* register process for wait */
+    process_register(hProcess);
+    /* set the pid for returning to caller */
+    *pid_p = (pid_t) hProcess;
+  /* set up to read data from child */
+  pipedes[0] = _open_osfhandle((intptr_t) hChildOutRd, O_RDONLY);
+  /* this will be closed almost right away */
+  pipedes[1] = _open_osfhandle((intptr_t) hChildOutWr, O_APPEND);
+  } else {
+    /* reap/cleanup the failed process */
+        process_cleanup(hProcess);
+    /* close handles which were duplicated, they weren't used */
+        CloseHandle(hIn);
+        CloseHandle(hErr);
+        /* close pipe handles, they won't be used */
+        CloseHandle(hChildOutRd);
+        CloseHandle(hChildOutWr);
+    /* set status for return */
+    pipedes[0] = pipedes[1] = -1;
+    *pid_p = (pid_t)-1;
+  }
+  if (! process_begin (hProcess, command_argv, envp, command_argv[0], NULL))
+    {
+      /* register process for wait */
+      process_register (hProcess);
+      /* set the pid for returning to caller */
+      *pid_p = (pid_t) hProcess;
+      /* set up to read data from child */
+      pipedes[0] = _open_osfhandle ((intptr_t) hChildOutRd, O_RDONLY);
+      /* this will be closed almost right away */
+      pipedes[1] = _open_osfhandle ((intptr_t) hChildOutWr, O_APPEND);
+      return 0;
+    }
+  else
+    {
+      /* reap/cleanup the failed process */
+      process_cleanup (hProcess);
+      /* close handles which were duplicated, they weren't used */
+      if (hIn != INVALID_HANDLE_VALUE)
+        CloseHandle (hIn);
+      if (hErr != INVALID_HANDLE_VALUE)
+        CloseHandle (hErr);
+      /* close pipe handles, they won't be used */
+      CloseHandle (hChildOutRd);
+      CloseHandle (hChildOutWr);
+      return -1;
+    }
+}
 #endif
 …
+{
   FILE *fpipe=0;
   /* MSDOS can't fork, but it has `popen'.  */
+  /* MSDOS can't fork, but it has 'popen'.  */
   struct variable *sh = lookup_variable ("SHELL", 5);
   int e;
 …
   /* Make sure not to bother processing an empty line.  */
+  while (isblank ((unsigned char)*text))
+    ++text;
+  NEXT_TOKEN (text);
   if (*text == '\0')
     return 0;
 …
       char buf[PATH_MAX + 7];
       /* This makes sure $SHELL value is used by $(shell), even
          though the target environment is not passed to it.  */
+         though the target environment is not passed to it.  */
       sprintf (buf, "SHELL=%s", sh->value);
       putenv (buf);
 …
       *pidp = -1;
       if (dos_status)
         errno = EINTR;
+        errno = EINTR;
       else if (errno == 0)
+        errno = ENOMEM;
+      shell_function_completed = -1;
+        errno = ENOMEM;
+      if (fpipe)
+        pclose (fpipe);
+      shell_completed (127, 0);
+    }
   else
 …
       *pidp = 42; /* Yes, the Meaning of Life, the Universe, and Everything! */
       errno = e;
-      shell_function_completed = 1;
+    }
   return fpipe;
 …
 /* VMS can't do $(shell ...)  */
+char *
+func_shell_base (char *o, char **argv, int trim_newlines)
+{
+  fprintf (stderr, "This platform does not support shell\n");
+  die (MAKE_TROUBLE);
+  return NULL;
+}
 #define func_shell 0
 #else
 #ifndef _AMIGA
 static char *
 func_shell (char *o, char **argv, const char *funcname UNUSED)
+char *
+func_shell_base (char *o, char **argv, int trim_newlines)
+{
   char *batch_filename = NULL;
+  int errfd;
 #ifdef __MSDOS__
   FILE *fpipe;
 …
 #ifndef __MSDOS__
+#ifdef WINDOWS32
+  /* Reset just_print_flag.  This is needed on Windows when batch files
+     are used to run the commands, because we normally refrain from
+     creating batch files under -n.  */
+  int j_p_f = just_print_flag;
+  just_print_flag = 0;
+#endif
   /* Construct the argument list.  */
   command_argv = construct_command_argv (argv[0], NULL, NULL, 0,
                                          &batch_filename);
   if (command_argv == 0)
+    return o;
+    {
+#ifdef WINDOWS32
+      just_print_flag = j_p_f;
 #endif
+  /* Using a target environment for `shell' loses in cases like:
+     export var = $(shell echo foobie)
+     because target_environment hits a loop trying to expand $(var)
+     to put it in the environment.  This is even more confusing when
+     var was not explicitly exported, but just appeared in the
+     calling environment.
+      return o;
+    }
+#endif /* !__MSDOS__ */
+  /* Using a target environment for 'shell' loses in cases like:
+       export var = $(shell echo foobie)
+       bad := $(var)
+     because target_environment hits a loop trying to expand $(var) to put it
+     in the environment.  This is even more confusing when 'var' was not
+     explicitly exported, but just appeared in the calling environment.
      See Savannah bug #10593.
   envp = target_environment (NILF);
+  envp = target_environment (NULL);
   */
 …
+    {
       char *p = alloca (strlen (reading_file->filenm)+11+4);
+      sprintf (p, "%s:%lu: ", reading_file->filenm, reading_file->lineno);
+      sprintf (p, "%s:%lu: ", reading_file->filenm,
+               reading_file->lineno + reading_file->offset);
       error_prefix = p;
+    }
   else
     error_prefix = "";
+  /* Set up the output in case the shell writes something.  */
+  output_start ();
+  errfd = (output_context && output_context->err >= 0
+           ? output_context->err : FD_STDERR);
 #if defined(__MSDOS__)
 …
       return o;
+    }
 #elif defined(WINDOWS32)
+  windows32_openpipe (pipedes, &pid, command_argv, envp);
+  windows32_openpipe (pipedes, errfd, &pid, command_argv, envp);
+  /* Restore the value of just_print_flag.  */
+  just_print_flag = j_p_f;
   if (pipedes[0] < 0)
+    {
       /* open of the pipe failed, mark as failed execution */
       shell_function_completed = -1;
+      /* Open of the pipe failed, mark as failed execution.  */
+      shell_completed (127, 0);
+      perror_with_name (error_prefix, "pipe");
       return o;
+    }
+  else
 #else
   if (pipe (pipedes) < 0)
 …
+    }
+# ifdef __EMX__
+  /* close some handles that are unnecessary for the child process */
+  /* Close handles that are unnecessary for the child process.  */
   CLOSE_ON_EXEC(pipedes[1]);
   CLOSE_ON_EXEC(pipedes[0]);
+  /* Never use fork()/exec() here! Use spawn() instead in exec_command() */
+  pid = child_execute_job (0, pipedes[1], command_argv, envp);
+  {
+    struct output out;
+    out.syncout = 1;
+    out.out = pipedes[1];
+    out.err = errfd;
+    pid = child_execute_job (&out, 1, command_argv, envp);
+  }
   if (pid < 0)
+    perror_with_name (error_prefix, "spawn");
+# else /* ! __EMX__ */
+  pid = vfork ();
+  if (pid < 0)
+    perror_with_name (error_prefix, "fork");
+  else if (pid == 0)
+    child_execute_job (0, pipedes[1], command_argv, envp);
+  else
+# endif
+    {
+      perror_with_name (error_prefix, "fork");
+      return o;
+    }
 #endif
+    {
       /* We are the parent.  */
       char *buffer;
       unsigned int maxlen, i;
       int cc;
       /* Record the PID for reap_children.  */
       shell_function_pid = pid;
+  {
+    char *buffer;
+    unsigned int maxlen, i;
+    int cc;
+    /* Record the PID for reap_children.  */
+    shell_function_pid = pid;
 #ifndef  __MSDOS__
       shell_function_completed = 0;
       /* Free the storage only the child needed.  */
       free (command_argv[0]);
       free (command_argv);
       /* Close the write side of the pipe.  We test for -1, since
          pipedes[1] is -1 on MS-Windows, and some versions of MS
          libraries barf when `close' is called with -1.  */
       if (pipedes[1] >= 0)
         close (pipedes[1]);
+    shell_function_completed = 0;
+    /* Free the storage only the child needed.  */
+    free (command_argv[0]);
+    free (command_argv);
+    /* Close the write side of the pipe.  We test for -1, since
+       pipedes[1] is -1 on MS-Windows, and some versions of MS
+       libraries barf when 'close' is called with -1.  */
+    if (pipedes[1] >= 0)
+      close (pipedes[1]);
 #endif
       /* Set up and read from the pipe.  */
       maxlen = 200;
       buffer = xmalloc (maxlen + 1);
       /* Read from the pipe until it gets EOF.  */
       for (i = 0; ; i += cc)
+        {
           if (i == maxlen)
+            {
               maxlen += 512;
               buffer = xrealloc (buffer, maxlen + 1);
+            }
           EINTRLOOP (cc, read (pipedes[0], &buffer[i], maxlen - i));
           if (cc <= 0)
             break;
+        }
       buffer[i] = '\0';
       /* Close the read side of the pipe.  */
+    /* Set up and read from the pipe.  */
+    maxlen = 200;
+    buffer = xmalloc (maxlen + 1);
+    /* Read from the pipe until it gets EOF.  */
+    for (i = 0; ; i += cc)
+      {
+        if (i == maxlen)
+          {
+            maxlen += 512;
+            buffer = xrealloc (buffer, maxlen + 1);
+          }
+        EINTRLOOP (cc, read (pipedes[0], &buffer[i], maxlen - i));
+        if (cc <= 0)
+          break;
+      }
+    buffer[i] = '\0';
+    /* Close the read side of the pipe.  */
 #ifdef  __MSDOS__
+      if (fpipe)
+        (void) pclose (fpipe);
+    if (fpipe)
+      {
+        int st = pclose (fpipe);
+        shell_completed (st, 0);
+      }
 #else
       (void) close (pipedes[0]);
+    (void) close (pipedes[0]);
 #endif
+      /* Loop until child_handler or reap_children()  sets
+         shell_function_completed to the status of our child shell.  */
+      while (shell_function_completed == 0)
+        reap_children (1, 0);
+      if (batch_filename) {
+        DB (DB_VERBOSE, (_("Cleaning up temporary batch file %s\n"),
+                       batch_filename));
+        remove (batch_filename);
+        free (batch_filename);
+    /* Loop until child_handler or reap_children()  sets
+       shell_function_completed to the status of our child shell.  */
+    while (shell_function_completed == 0)
+      reap_children (1, 0);
+    if (batch_filename)
+      {
+        DB (DB_VERBOSE, (_("Cleaning up temporary batch file %s\n"),
+                         batch_filename));
+        remove (batch_filename);
+        free (batch_filename);
+      }
       shell_function_pid = 0;
       /* The child_handler function will set shell_function_completed
+         to 1 when the child dies normally, or to -1 if it
          dies with status 127, which is most likely an exec fail.  */
       if (shell_function_completed == -1)
+        {
           /* This likely means that the execvp failed, so we should just
              write the error message in the pipe from the child.  */
           fputs (buffer, stderr);
           fflush (stderr);
+        }
       else
+        {
           /* The child finished normally.  Replace all newlines in its output
              with spaces, and put that in the variable output buffer.  */
           fold_newlines (buffer, &i);
           o = variable_buffer_output (o, buffer, i);
+        }
       free (buffer);
+    }
   return o;
+}
 #else   /* _AMIGA */
+    shell_function_pid = 0;
+    /* shell_completed() will set shell_function_completed to 1 when the
+       child dies normally, or to -1 if it dies with status 127, which is
+       most likely an exec fail.  */
+    if (shell_function_completed == -1)
+      {
+        /* This likely means that the execvp failed, so we should just
+           write the error message in the pipe from the child.  */
+        fputs (buffer, stderr);
+        fflush (stderr);
+      }
+    else
+      {
+        /* The child finished normally.  Replace all newlines in its output
+           with spaces, and put that in the variable output buffer.  */
+        fold_newlines (buffer, &i, trim_newlines);
+        o = variable_buffer_output (o, buffer, i);
+      }
+    free (buffer);
+  }
+  return o;
+}
+#else   /* _AMIGA */
 /* Do the Amiga version of func_shell.  */
 static char *
 func_shell (char *o, char **argv, const char *funcname)
+char *
+func_shell_base (char *o, char **argv, int trim_newlines)
+{
   /* Amiga can't fork nor spawn, but I can start a program with
 …
   /* Note the mktemp() is a security hole, but this only runs on Amiga.
      Ideally we would use main.c:open_tmpfile(), but this uses a special
+     Ideally we would use output_tmpfile(), but this uses a special
      Open(), not fopen(), and I'm not familiar enough with the code to mess
      with it.  */
 …
+    {
       if (i == maxlen)
+        {
           maxlen += 512;
           buffer = xrealloc (buffer, maxlen + 1);
+        }
+        {
+          maxlen += 512;
+          buffer = xrealloc (buffer, maxlen + 1);
+        }
       cc = Read (child_stdout, &buffer[i], maxlen - i);
       if (cc > 0)
         i += cc;
+        i += cc;
     } while (cc > 0);
   Close (child_stdout);
   fold_newlines (buffer, &i);
+  fold_newlines (buffer, &i, trim_newlines);
   o = variable_buffer_output (o, buffer, i);
   free (buffer);
 …
+}
 #endif  /* _AMIGA */
+static char *
+func_shell (char *o, char **argv, const char *funcname UNUSED)
+{
+  return func_shell_base (o, argv, 1);
+}
 #endif  /* !VMS */
 …
 /*
   equality. Return is string-boolean, ie, the empty string is false.
+  equality. Return is string-boolean, i.e., the empty string is false.
  */
 static char *
 func_eq (char *o, char **argv, char *funcname)
+func_eq (char *o, char **argv, char *funcname UNUSED)
+{
   int result = ! strcmp (argv[0], argv[1]);
 …
  */
 static char *
 func_not (char *o, char **argv, char *funcname)
+func_not (char *o, char **argv, char *funcname UNUSED)
+{
   const char *s = argv[0];
   int result = 0;
+  while (isspace ((unsigned char)*s))
+    s++;
+  NEXT_TOKEN (s);
   result = ! (*s);
   o = variable_buffer_output (o,  result ? "1" : "", result);
 …
 #ifdef HAVE_DOS_PATHS
+#define IS_ABSOLUTE(n) (n[0] && n[1] == ':')
+#define ROOT_LEN 3
+# ifdef __CYGWIN__
+#  define IS_ABSOLUTE(n) ((n[0] && n[1] == ':') || STOP_SET (n[0], MAP_DIRSEP))
+# else
+#  define IS_ABSOLUTE(n) (n[0] && n[1] == ':')
+# endif
+# define ROOT_LEN 3
 #else
 #define IS_ABSOLUTE(n) (n[0] == '/')
 …
 #endif
 /* Return the absolute name of file NAME which does not contain any `.',
    `..' components nor any repeated path separators ('/').   */
+/* Return the absolute name of file NAME which does not contain any '.',
+   '..' components nor any repeated path separators ('/').   */
 static char *
 …
       /* It is unlikely we would make it until here but just to make sure. */
       if (!starting_directory)
         return NULL;
+        return NULL;
       strcpy (apath, starting_directory);
 #ifdef HAVE_DOS_PATHS
       if (IS_PATHSEP(name[0]))
+        {
           if (IS_PATHSEP(name[1]))
+            {
               /* A UNC.  Don't prepend a drive letter.  */
               apath[0] = name[0];
               apath[1] = name[1];
               root_len = 2;
+            }
           /* We have /foo, an absolute file name except for the drive
              letter.  Assume the missing drive letter is the current
              drive, which we can get if we remove from starting_directory
              everything past the root directory.  */
           apath[root_len] = '\0';
+        }
+      if (STOP_SET (name[0], MAP_DIRSEP))
+        {
+          if (STOP_SET (name[1], MAP_DIRSEP))
+            {
+              /* A UNC.  Don't prepend a drive letter.  */
+              apath[0] = name[0];
+              apath[1] = name[1];
+              root_len = 2;
+            }
+          /* We have /foo, an absolute file name except for the drive
+             letter.  Assume the missing drive letter is the current
+             drive, which we can get if we remove from starting_directory
+             everything past the root directory.  */
+          apath[root_len] = '\0';
+        }
 #endif
 …
   else
+    {
+#if defined(__CYGWIN__) && defined(HAVE_DOS_PATHS)
+      if (STOP_SET (name[0], MAP_DIRSEP))
+        root_len = 1;
+#endif
       strncpy (apath, name, root_len);
       apath[root_len] = '\0';
 …
       name += root_len;
 #ifdef HAVE_DOS_PATHS
       if (!IS_PATHSEP(apath[2]))
+        {
           /* Convert d:foo into d:./foo and increase root_len.  */
           apath[2] = '.';
           apath[3] = '/';
           dest++;
           root_len++;
           /* strncpy above copied one character too many.  */
           name--;
+        }
+      if (! STOP_SET (apath[root_len - 1], MAP_DIRSEP))
+        {
+          /* Convert d:foo into d:./foo and increase root_len.  */
+          apath[2] = '.';
+          apath[3] = '/';
+          dest++;
+          root_len++;
+          /* strncpy above copied one character too many.  */
+          name--;
+        }
       else
         apath[2] = '/'; /* make sure it's a forward slash */
+        apath[root_len - 1] = '/'; /* make sure it's a forward slash */
 #endif
+    }
 …
       /* Skip sequence of multiple path-separators.  */
       while (IS_PATHSEP(*start))
         ++start;
+      while (STOP_SET (*start, MAP_DIRSEP))
+        ++start;
       /* Find end of path component.  */
       for (end = start; *end != '\0' && !IS_PATHSEP(*end); ++end)
+      for (end = start; ! STOP_SET (*end, MAP_DIRSEP|MAP_NUL); ++end)
+        ;
 …
       if (len == 0)
         break;
+        break;
       else if (len == 1 && start[0] == '.')
         /* nothing */;
+        /* nothing */;
       else if (len == 2 && start[0] == '.' && start[1] == '.')
+        {
+          /* Back up to previous component, ignore if at root already.  */
+          if (dest > apath + root_len)
+            for (--dest; !IS_PATHSEP(dest[-1]); --dest);
+        }
+        {
+          /* Back up to previous component, ignore if at root already.  */
+          if (dest > apath + root_len)
+            for (--dest; ! STOP_SET (dest[-1], MAP_DIRSEP); --dest)
+              ;
+        }
       else
+        {
           if (!IS_PATHSEP(dest[-1]))
+        {
+          if (! STOP_SET (dest[-1], MAP_DIRSEP))
             *dest++ = '/';
           if (dest + len >= apath_limit)
+          if (dest + len >= apath_limit)
             return NULL;
           dest = memcpy (dest, start, len);
+          dest = memcpy (dest, start, len);
           dest += len;
           *dest = '\0';
+        }
+          *dest = '\0';
+        }
+    }
   /* Unless it is root strip trailing separator.  */
   if (dest > apath + root_len && IS_PATHSEP(dest[-1]))
+  if (dest > apath + root_len && STOP_SET (dest[-1], MAP_DIRSEP))
     --dest;
 …
   int doneany = 0;
   unsigned int len = 0;
-#ifndef HAVE_REALPATH
-  struct stat st;
-#endif
-  PATH_VAR (in);
-  PATH_VAR (out);
   while ((path = find_next_token (&p, &len)) != 0)
 …
       if (len < GET_PATH_MAX)
+        {
+          char *rp;
+          struct stat st;
+          PATH_VAR (in);
+          PATH_VAR (out);
           strncpy (in, path, len);
           in[len] = '\0';
-          if (
 #ifdef HAVE_REALPATH
               realpath (in, out)
+          ENULLLOOP (rp, realpath (in, out));
 #else
               abspath (in, out) && stat (out, &st) == 0
+          rp = abspath (in, out);
 #endif
+             )
+          if (rp)
+            {
+              o = variable_buffer_output (o, out, strlen (out));
+              o = variable_buffer_output (o, " ", 1);
+              doneany = 1;
+              int r;
+              EINTRLOOP (r, stat (out, &st));
+              if (r == 0)
+                {
+                  o = variable_buffer_output (o, out, strlen (out));
+                  o = variable_buffer_output (o, " ", 1);
+                  doneany = 1;
+                }
+            }
+        }
 …
   if (doneany)
     --o;
+  return o;
+}
+static char *
+func_file (char *o, char **argv, const char *funcname UNUSED)
+{
+  char *fn = argv[0];
+  if (fn[0] == '>')
+    {
+      FILE *fp;
+      const char *mode = "w";
+      /* We are writing a file.  */
+      ++fn;
+      if (fn[0] == '>')
+        {
+          mode = "a";
+          ++fn;
+        }
+      NEXT_TOKEN (fn);
+      if (fn[0] == '\0')
+        O (fatal, *expanding_var, _("file: missing filename"));
+      ENULLLOOP (fp, fopen (fn, mode));
+      if (fp == NULL)
+        OSS (fatal, reading_file, _("open: %s: %s"), fn, strerror (errno));
+      if (argv[1])
+        {
+          int l = strlen (argv[1]);
+          int nl = l == 0 || argv[1][l-1] != '\n';
+          if (fputs (argv[1], fp) == EOF || (nl && fputc ('\n', fp) == EOF))
+            OSS (fatal, reading_file, _("write: %s: %s"), fn, strerror (errno));
+        }
+      if (fclose (fp))
+        OSS (fatal, reading_file, _("close: %s: %s"), fn, strerror (errno));
+    }
+  else if (fn[0] == '<')
+    {
+      char *preo = o;
+      FILE *fp;
+      ++fn;
+      NEXT_TOKEN (fn);
+      if (fn[0] == '\0')
+        O (fatal, *expanding_var, _("file: missing filename"));
+      if (argv[1])
+        O (fatal, *expanding_var, _("file: too many arguments"));
+      ENULLLOOP (fp, fopen (fn, "r"));
+      if (fp == NULL)
+        {
+          if (errno == ENOENT)
+            return o;
+          OSS (fatal, reading_file, _("open: %s: %s"), fn, strerror (errno));
+        }
+      while (1)
+        {
+          char buf[1024];
+          size_t l = fread (buf, 1, sizeof (buf), fp);
+          if (l > 0)
+            o = variable_buffer_output (o, buf, l);
+          if (ferror (fp))
+            if (errno != EINTR)
+              OSS (fatal, reading_file, _("read: %s: %s"), fn, strerror (errno));
+          if (feof (fp))
+            break;
+        }
+      if (fclose (fp))
+        OSS (fatal, reading_file, _("close: %s: %s"), fn, strerror (errno));
+      /* Remove trailing newline.  */
+      if (o > preo && o[-1] == '\n')
+        if (--o > preo && o[-1] == '\r')
+          --o;
+    }
+  else
+    OS (fatal, *expanding_var, _("file: invalid file operation: %s"), fn);
   return o;
 …
   int doneany = 0;
   unsigned int len = 0;
-  PATH_VAR (in);
-  PATH_VAR (out);
   while ((path = find_next_token (&p, &len)) != 0)
 …
       if (len < GET_PATH_MAX)
+        {
+          PATH_VAR (in);
+          PATH_VAR (out);
           strncpy (in, path, len);
           in[len] = '\0';
 …
 static char *func_call (char *o, char **argv, const char *funcname);
+#define FT_ENTRY(_name, _min, _max, _exp, _func) \
+  { { (_func) }, STRING_SIZE_TUPLE(_name), (_min), (_max), (_exp), 0 }
 static struct function_table_entry function_table_init[] =
+{
+ /* Name/size */                    /* MIN MAX EXP? Function */
+  { STRING_SIZE_TUPLE("abspath"),       0,  1,  1,  func_abspath},
+  { STRING_SIZE_TUPLE("addprefix"),     2,  2,  1,  func_addsuffix_addprefix},
+  { STRING_SIZE_TUPLE("addsuffix"),     2,  2,  1,  func_addsuffix_addprefix},
+  { STRING_SIZE_TUPLE("basename"),      0,  1,  1,  func_basename_dir},
+  { STRING_SIZE_TUPLE("dir"),           0,  1,  1,  func_basename_dir},
+  { STRING_SIZE_TUPLE("notdir"),        0,  1,  1,  func_notdir_suffix},
+  { STRING_SIZE_TUPLE("subst"),         3,  3,  1,  func_subst},
+  { STRING_SIZE_TUPLE("suffix"),        0,  1,  1,  func_notdir_suffix},
+  { STRING_SIZE_TUPLE("filter"),        2,  2,  1,  func_filter_filterout},
+  { STRING_SIZE_TUPLE("filter-out"),    2,  2,  1,  func_filter_filterout},
+  { STRING_SIZE_TUPLE("findstring"),    2,  2,  1,  func_findstring},
+  { STRING_SIZE_TUPLE("firstword"),     0,  1,  1,  func_firstword},
+  { STRING_SIZE_TUPLE("flavor"),        0,  1,  1,  func_flavor},
+  { STRING_SIZE_TUPLE("join"),          2,  2,  1,  func_join},
+  { STRING_SIZE_TUPLE("lastword"),      0,  1,  1,  func_lastword},
+  { STRING_SIZE_TUPLE("patsubst"),      3,  3,  1,  func_patsubst},
+  { STRING_SIZE_TUPLE("realpath"),      0,  1,  1,  func_realpath},
+  { STRING_SIZE_TUPLE("shell"),         0,  1,  1,  func_shell},
+  { STRING_SIZE_TUPLE("sort"),          0,  1,  1,  func_sort},
+  { STRING_SIZE_TUPLE("strip"),         0,  1,  1,  func_strip},
+  { STRING_SIZE_TUPLE("wildcard"),      0,  1,  1,  func_wildcard},
+  { STRING_SIZE_TUPLE("word"),          2,  2,  1,  func_word},
+  { STRING_SIZE_TUPLE("wordlist"),      3,  3,  1,  func_wordlist},
+  { STRING_SIZE_TUPLE("words"),         0,  1,  1,  func_words},
+  { STRING_SIZE_TUPLE("origin"),        0,  1,  1,  func_origin},
+  { STRING_SIZE_TUPLE("foreach"),       3,  3,  0,  func_foreach},
+  { STRING_SIZE_TUPLE("call"),          1,  0,  1,  func_call},
+  { STRING_SIZE_TUPLE("info"),          0,  1,  1,  func_error},
+  { STRING_SIZE_TUPLE("error"),         0,  1,  1,  func_error},
+  { STRING_SIZE_TUPLE("warning"),       0,  1,  1,  func_error},
+  { STRING_SIZE_TUPLE("if"),            2,  3,  0,  func_if},
+  { STRING_SIZE_TUPLE("or"),            1,  0,  0,  func_or},
+  { STRING_SIZE_TUPLE("and"),           1,  0,  0,  func_and},
+  { STRING_SIZE_TUPLE("value"),         0,  1,  1,  func_value},
+  { STRING_SIZE_TUPLE("eval"),          0,  1,  1,  func_eval},
+ /*         Name            MIN MAX EXP? Function */
+  FT_ENTRY ("abspath",       0,  1,  1,  func_abspath),
+  FT_ENTRY ("addprefix",     2,  2,  1,  func_addsuffix_addprefix),
+  FT_ENTRY ("addsuffix",     2,  2,  1,  func_addsuffix_addprefix),
+  FT_ENTRY ("basename",      0,  1,  1,  func_basename_dir),
+  FT_ENTRY ("dir",           0,  1,  1,  func_basename_dir),
+  FT_ENTRY ("notdir",        0,  1,  1,  func_notdir_suffix),
+  FT_ENTRY ("subst",         3,  3,  1,  func_subst),
+  FT_ENTRY ("suffix",        0,  1,  1,  func_notdir_suffix),
+  FT_ENTRY ("filter",        2,  2,  1,  func_filter_filterout),
+  FT_ENTRY ("filter-out",    2,  2,  1,  func_filter_filterout),
+  FT_ENTRY ("findstring",    2,  2,  1,  func_findstring),
+  FT_ENTRY ("firstword",     0,  1,  1,  func_firstword),
+  FT_ENTRY ("flavor",        0,  1,  1,  func_flavor),
+  FT_ENTRY ("join",          2,  2,  1,  func_join),
+  FT_ENTRY ("lastword",      0,  1,  1,  func_lastword),
+  FT_ENTRY ("patsubst",      3,  3,  1,  func_patsubst),
+  FT_ENTRY ("realpath",      0,  1,  1,  func_realpath),
+  FT_ENTRY ("shell",         0,  1,  1,  func_shell),
+  FT_ENTRY ("sort",          0,  1,  1,  func_sort),
+  FT_ENTRY ("strip",         0,  1,  1,  func_strip),
+  FT_ENTRY ("wildcard",      0,  1,  1,  func_wildcard),
+  FT_ENTRY ("word",          2,  2,  1,  func_word),
+  FT_ENTRY ("wordlist",      3,  3,  1,  func_wordlist),
+  FT_ENTRY ("words",         0,  1,  1,  func_words),
+  FT_ENTRY ("origin",        0,  1,  1,  func_origin),
+  FT_ENTRY ("foreach",       3,  3,  0,  func_foreach),
+  FT_ENTRY ("call",          1,  0,  1,  func_call),
+  FT_ENTRY ("info",          0,  1,  1,  func_error),
+  FT_ENTRY ("error",         0,  1,  1,  func_error),
+  FT_ENTRY ("warning",       0,  1,  1,  func_error),
+  FT_ENTRY ("if",            2,  3,  0,  func_if),
+  FT_ENTRY ("or",            1,  0,  0,  func_or),
+  FT_ENTRY ("and",           1,  0,  0,  func_and),
+  FT_ENTRY ("value",         0,  1,  1,  func_value),
+  FT_ENTRY ("eval",          0,  1,  1,  func_eval),
+  FT_ENTRY ("file",          1,  2,  1,  func_file),
 #ifdef EXPERIMENTAL
   { STRING_SIZE_TUPLE("eq"),            2,  2,  1,  func_eq},
   { STRING_SIZE_TUPLE("not"),           0,  1,  1,  func_not},
+  FT_ENTRY ("eq",            2,  2,  1,  func_eq),
+  FT_ENTRY ("not",           0,  1,  1,  func_not),
 #endif
 };
 …
                          const struct function_table_entry *entry_p)
+{
+  char *p;
   if (argc < (int)entry_p->minimum_args)
     fatal (*expanding_var,
            _("insufficient number of arguments (%d) to function `%s'"),
+    fatal (*expanding_var, strlen (entry_p->name),
+           _("insufficient number of arguments (%d) to function '%s'"),
            argc, entry_p->name);
   /* I suppose technically some function could do something with no
      arguments, but so far none do, so just test it for all functions here
+  /* I suppose technically some function could do something with no arguments,
+     but so far no internal ones do, so just test it for all functions here
      rather than in each one.  We can change it later if necessary.  */
   if (!argc)
+  if (!argc && !entry_p->alloc_fn)
     return o;
+  if (!entry_p->func_ptr)
+    fatal (*expanding_var,
+           _("unimplemented on this platform: function `%s'"), entry_p->name);
+  return entry_p->func_ptr (o, argv, entry_p->name);
+  if (!entry_p->fptr.func_ptr)
+    OS (fatal, *expanding_var,
+        _("unimplemented on this platform: function '%s'"), entry_p->name);
+  if (!entry_p->alloc_fn)
+    return entry_p->fptr.func_ptr (o, argv, entry_p->name);
+  /* This function allocates memory and returns it to us.
+     Write it to the variable buffer, then free it.  */
+  p = entry_p->fptr.alloc_func_ptr (entry_p->name, argc, argv);
+  if (p)
+    {
+      o = variable_buffer_output (o, p, strlen (p));
+      free (p);
+    }
+  return o;
+}
 …
      whitespace after the name).  */
+  beg = next_token (beg + entry_p->len);
+  beg += entry_p->len;
+  NEXT_TOKEN (beg);
   /* Find the end of the function invocation, counting nested use of
 …
   if (count >= 0)
     fatal (*expanding_var,
            _("unterminated call to function `%s': missing `%c'"),
            entry_p->name, closeparen);
+    fatal (*expanding_var, strlen (entry_p->name),
+           _("unterminated call to function '%s': missing '%c'"),
+           entry_p->name, closeparen);
   *stringp = end;
 …
     for (argvp=argv; *argvp != 0; ++argvp)
       free (*argvp);
   if (abeg)
+  else
     free (abeg);
 …
   static int max_args = 0;
   char *fname;
-  char *cp;
   char *body;
   int flen;
 …
   struct variable *v;
+  /* There is no way to define a variable with a space in the name, so strip
+     leading and trailing whitespace as a favor to the user.  */
+  fname = argv[0];
+  while (*fname != '\0' && isspace ((unsigned char)*fname))
+    ++fname;
+  cp = fname + strlen (fname) - 1;
+  while (cp > fname && isspace ((unsigned char)*cp))
+    --cp;
+  cp[1] = '\0';
+  /* Clean up the name of the variable to be invoked.  */
+  fname = next_token (argv[0]);
+  end_of_token (fname)[0] = '\0';
   /* Calling nothing is a no-op */
 …
 void
+define_new_function (const floc *flocp, const char *name,
+                     unsigned int min, unsigned int max, unsigned int flags,
+                     gmk_func_ptr func)
+{
+  const char *e = name;
+  struct function_table_entry *ent;
+  size_t len;
+  while (STOP_SET (*e, MAP_USERFUNC))
+    e++;
+  len = e - name;
+  if (len == 0)
+    O (fatal, flocp, _("Empty function name"));
+  if (*name == '.' || *e != '\0')
+    OS (fatal, flocp, _("Invalid function name: %s"), name);
+  if (len > 255)
+    OS (fatal, flocp, _("Function name too long: %s"), name);
+  if (min > 255)
+    ONS (fatal, flocp,
+         _("Invalid minimum argument count (%u) for function %s"), min, name);
+  if (max > 255 || (max && max < min))
+    ONS (fatal, flocp,
+         _("Invalid maximum argument count (%u) for function %s"), max, name);
+  ent = xmalloc (sizeof (struct function_table_entry));
+  ent->name = name;
+  ent->len = len;
+  ent->minimum_args = min;
+  ent->maximum_args = max;
+  ent->expand_args = ANY_SET(flags, GMK_FUNC_NOEXPAND) ? 0 : 1;
+  ent->alloc_fn = 1;
+  ent->fptr.alloc_func_ptr = func;
+  hash_insert (&function_table, ent);
+}
+void
 hash_init_function_table (void)
+{
   hash_init (&function_table, FUNCTION_TABLE_ENTRIES * 2,
              function_table_entry_hash_1, function_table_entry_hash_2,
              function_table_entry_hash_cmp);
+             function_table_entry_hash_1, function_table_entry_hash_2,
+             function_table_entry_hash_cmp);
   hash_load (&function_table, function_table_init,
              FUNCTION_TABLE_ENTRIES, sizeof (struct function_table_entry));
+}
+             FUNCTION_TABLE_ENTRIES, sizeof (struct function_table_entry));
+}

vendor/gnumake/current/getloadavg.c

-              r2596
+              r3138
 /* Get the system load averages.
+Copyright (C) 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
+, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1985-2016 Free Software Foundation, Inc.
 GNU Make is free software; you can redistribute it and/or modify it under the
 …
 /* Exclude all the code except the test program at the end
    if the system has its own `getloadavg' function.
    The declaration of `errno' is needed by the test program
+   if the system has its own 'getloadavg' function.
+   The declaration of 'errno' is needed by the test program
    as well as the function itself, so it comes first.  */
 …
   /* This call can return -1 for an error, but with good args
      it's not supposed to fail.  The first argument is for no
      apparent reason of type `long int *'.  */
+     apparent reason of type 'long int *'.  */
   dg_sys_info ((long int *) &load_info,
                DG_SYS_INFO_LOAD_INFO_TYPE,
 …
 #ifdef TEST
 #include "make.h"
+#include "makeint.h"
 int

vendor/gnumake/current/getopt.c

-              r2596
+              r3138
 before changing it!
+Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1987-2016 Free Software Foundation, Inc.
 NOTE: The canonical source of this file is maintained with the GNU C Library.
 …
 /* This version of `getopt' appears to the caller like standard Unix `getopt'
+/* This version of `getopt' appears to the caller like standard Unix 'getopt'
    but it behaves differently for the user, since it allows the user
    to intersperse the options with the other arguments.
 …
+        {
           if (opterr)
             fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
+            fprintf (stderr, _("%s: option '%s' is ambiguous\n"),
                      argv[0], argv[optind]);
           nextchar += strlen (nextchar);
 …
                     /* --option */
                     fprintf (stderr,
                      _("%s: option `--%s' doesn't allow an argument\n"),
+                     _("%s: option '--%s' doesn't allow an argument\n"),
                      argv[0], pfound->name);
                    else
                     /* +option or -option */
                     fprintf (stderr,
                      _("%s: option `%c%s' doesn't allow an argument\n"),
+                     _("%s: option '%c%s' doesn't allow an argument\n"),
                      argv[0], argv[optind - 1][0], pfound->name);
 …
                   if (opterr)
                     fprintf (stderr,
                            _("%s: option `%s' requires an argument\n"),
+                           _("%s: option '%s' requires an argument\n"),
                            argv[0], argv[optind - 1]);
                   nextchar += strlen (nextchar);
 …
               if (argv[optind][1] == '-')
                 /* --option */
                 fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
+                fprintf (stderr, _("%s: unrecognized option '--%s'\n"),
                          argv[0], nextchar);
               else
                 /* +option or -option */
                 fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
+                fprintf (stderr, _("%s: unrecognized option '%c%s'\n"),
                          argv[0], argv[optind][0], nextchar);
+            }
 …
+          {
             if (opterr)
               fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
+              fprintf (stderr, _("%s: option '-W %s' is ambiguous\n"),
                        argv[0], argv[optind]);
             nextchar += strlen (nextchar);
 …
                     if (opterr)
                       fprintf (stderr, _("\
 %s: option `-W %s' doesn't allow an argument\n"),
+%s: option '-W %s' doesn't allow an argument\n"),
                                argv[0], pfound->name);
 …
                     if (opterr)
                       fprintf (stderr,
                                _("%s: option `%s' requires an argument\n"),
+                               _("%s: option '%s' requires an argument\n"),
                                argv[0], argv[optind - 1]);
                     nextchar += strlen (nextchar);
 …
         case 'c':
           printf ("option c with value `%s'\n", optarg);
+          printf ("option c with value '%s'\n", optarg);
           break;

vendor/gnumake/current/getopt.h

-              r2596
+              r3138
 /* Declarations for getopt.
+Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free
+Software Foundation, Inc.
+Copyright (C) 1989-2016 Free Software Foundation, Inc.
 NOTE: The canonical source of this file is maintained with the GNU C Library.

vendor/gnumake/current/getopt1.c

-              r2596
+              r3138
 /* getopt_long and getopt_long_only entry points for GNU getopt.
+Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1987-1994, 1996-2016 Free Software Foundation, Inc.
 NOTE: The canonical source of this file is maintained with the GNU C Library.
 …
         case 'c':
           printf ("option c with value `%s'\n", optarg);
+          printf ("option c with value '%s'\n", optarg);
           break;
         case 'd':
           printf ("option d with value `%s'\n", optarg);
+          printf ("option d with value '%s'\n", optarg);
           break;

vendor/gnumake/current/gettext.h

r2596	r3138
1	1	/* Convenience header for conditional use of GNU <libintl.h>.
2		Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005,
3		2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
	2	Copyright (C) 1995-2016 Free Software Foundation, Inc.
4	3	This file is part of GNU Make.
5	4

vendor/gnumake/current/glob/ChangeLog

-              r2596
+              r3138
+-10-20  Paul Smith  <psmith@gnu.org>
+        * glob.c (glob): Cherry-pick a471e96a5352a5f0bde6d32dd36d33524811a2b1
+        from git://sourceware.org/git/glibc.git to fix SV 18123,
+        https://sourceware.org/bugzilla/show_bug.cgi?id=10278
 -09-28  Juan Manuel Guerrero  <juan.guerrero@gmx.de>

vendor/gnumake/current/glob/glob.c

-              r2596
+              r3138
       return -1;
+    }
+  /* POSIX requires all slashes to be matched.  This means that with
+     a trailing slash we must match only directories.  */
+  if (pattern[0] && pattern[strlen (pattern) - 1] == '/')
+    flags |= GLOB_ONLYDIR;
   if (flags & GLOB_BRACE)

vendor/gnumake/current/glob/glob.h

r1989	r3138
57	57	/* This is a guess. */
58	58	/*hb
59		* Conflicts with DECCs aready defined type __size_t.
	59	* Conflicts with DECCs already defined type __size_t.
60	60	* Defining an own type with a name beginning with '__' is no good.
61	61	* Anyway if DECC is used and __SIZE_T is defined then __size_t is

vendor/gnumake/current/hash.c

-              r2596
+              r3138
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include "hash.h"
 #define CALLOC(t, n) ((t *) calloc (sizeof (t), (n)))
+#define CALLOC(t, n) ((t *) xcalloc (sizeof (t) * (n)))
 #define MALLOC(t, n) ((t *) xmalloc (sizeof (t) * (n)))
 #define REALLOC(o, t, n) ((t *) xrealloc ((o), sizeof (t) * (n)))
 …
 /* Implement double hashing with open addressing.  The table size is
    always a power of two.  The secondary (`increment') hash function
+   always a power of two.  The secondary ('increment') hash function
    is forced to return an odd-value, in order to be relatively prime
    to the table size.  This guarantees that the increment can
 …
       fprintf (stderr, _("can't allocate %lu bytes for hash table: memory exhausted"),
                ht->ht_size * (unsigned long) sizeof (struct token *));
       exit (1);
+      exit (MAKE_TROUBLE);
+    }
 …
+}
 /* Load an array of items into `ht'.  */
+/* Load an array of items into 'ht'.  */
 void
 …
+}
 /* Returns the address of the table slot matching `key'.  If `key' is
+/* Returns the address of the table slot matching 'key'.  If 'key' is
    not found, return the address of an empty slot suitable for
    inserting `key'.  The caller is responsible for incrementing
+   inserting 'key'.  The caller is responsible for incrementing
    ht_fill on insertion.  */

vendor/gnumake/current/hash.h

-              r2596
+              r3138
 # undef __P
 # define __P(protos)    ()
 /* We can get away without defining `const' here only because in this file
    it is used only inside the prototype for `fnmatch', which is elided in
    non-ANSI C where `const' is problematical.  */
+/* We can get away without defining 'const' here only because in this file
+   it is used only inside the prototype for 'fnmatch', which is elided in
+   non-ANSI C where 'const' is problematical.  */
 #endif /* C++ or ANSI C.  */
 …
+{
   void **ht_vec;
+  hash_func_t ht_hash_1;        /* primary hash function */
+  hash_func_t ht_hash_2;        /* secondary hash function */
+  hash_cmp_func_t ht_compare;   /* comparison function */
   unsigned long ht_size;        /* total number of slots (power of 2) */
   unsigned long ht_capacity;    /* usable slots, limited by loading-factor */
 …
   unsigned long ht_lookups;     /* # of queries */
   unsigned int ht_rehashes;     /* # of times we've expanded table */
-  hash_func_t ht_hash_1;        /* primary hash function */
-  hash_func_t ht_hash_2;        /* secondary hash function */
-  hash_cmp_func_t ht_compare;   /* comparison function */
 };

vendor/gnumake/current/implicit.c

-              r2596
+              r3138
 /* Implicit rule searching for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include "filedef.h"
 #include "rule.h"
 …
 try_implicit_rule (struct file *file, unsigned int depth)
+{
   DBF (DB_IMPLICIT, _("Looking for an implicit rule for `%s'.\n"));
+  DBF (DB_IMPLICIT, _("Looking for an implicit rule for '%s'.\n"));
   /* The order of these searches was previously reversed.  My logic now is
 …
+    {
       DBF (DB_IMPLICIT,
            _("Looking for archive-member implicit rule for `%s'.\n"));
+           _("Looking for archive-member implicit rule for '%s'.\n"));
       if (pattern_search (file, 1, depth, 0))
         return 1;
 …
   /* Skip any leading whitespace.  */
+  while (isblank ((unsigned char)*p))
+    ++p;
+  NEXT_TOKEN (p);
   beg = p;
 …
   /* List of dependencies found recursively.  */
   struct patdeps *deplist
     = xmalloc (max_pattern_deps * sizeof (struct patdeps));
+  unsigned int max_deps = max_pattern_deps;
+  struct patdeps *deplist = xmalloc (max_deps * sizeof (struct patdeps));
   struct patdeps *pat = deplist;
-  /* All the prerequisites actually found for a rule, after expansion.  */
-  struct dep *deps;
   /* Names of possible dependencies are constructed in this buffer.  */
 …
   /* Nonzero if we have matched a pattern-rule target
      that is not just `%'.  */
+     that is not just '%'.  */
   int specific_rule_matched = 0;
-  struct dep dep_simple;
   unsigned int ri;  /* uninit checks OK */
 …
          but not counting any slash at the end.  (foo/bar/ counts as
          bar/ in directory foo/, not empty in directory foo/bar/.)  */
+      lastslash = strrchr (filename, '/');
 #ifdef VMS
+      lastslash = strrchr (filename, ']');
+      if (lastslash == 0)
+      if (lastslash == NULL)
+        lastslash = strrchr (filename, ']');
+      if (lastslash == NULL)
+        lastslash = strrchr (filename, '>');
+      if (lastslash == NULL)
         lastslash = strrchr (filename, ':');
+#else
+      lastslash = strrchr (filename, '/');
+#endif
 #ifdef HAVE_DOS_PATHS
       /* Handle backslashes (possibly mixed with forward slashes)
 …
+      }
 #endif
-#endif
       if (lastslash != 0 && lastslash[1] == '\0')
         lastslash = 0;
 …
           const char *target = rule->targets[ti];
           const char *suffix = rule->suffixes[ti];
           int check_lastslash;
+          char check_lastslash;
           /* Rules that can match any filename and are not terminal
 …
+            {
 #ifdef VMS
+              check_lastslash = (strchr (target, ']') == 0
+                                 && strchr (target, ':') == 0);
+              check_lastslash = strpbrk (target, "/]>:") == NULL;
 #else
               check_lastslash = strchr (target, '/') == 0;
+#endif
 #ifdef HAVE_DOS_PATHS
               /* Didn't find it yet: check for DOS-type directories.  */
 …
                   check_lastslash = !(b || (target[0] && target[1] == ':'));
+                }
-#endif
 #endif
+            }
 …
              that rule will be in TRYRULES more than once.  */
           tryrules[nrules].rule = rule;
           tryrules[nrules].matches = ti;
+          tryrules[nrules].matches = ti;
           tryrules[nrules].stemlen = stemlen + (check_lastslash ? pathlen : 0);
           tryrules[nrules].order = nrules;
           tryrules[nrules].checked_lastslash = check_lastslash;
+          tryrules[nrules].checked_lastslash = check_lastslash;
           ++nrules;
+        }
 …
+        {
           struct dep *dep;
           int check_lastslash;
+          char check_lastslash;
           unsigned int failed = 0;
           int file_variables_set = 0;
 …
+            }
+          DBS (DB_IMPLICIT, (_("Trying pattern rule with stem `%.*s'.\n"),
+          if (stemlen > GET_PATH_MAX)
+            {
+              DBS (DB_IMPLICIT, (_("Stem too long: '%.*s'.\n"),
+                                 (int) stemlen, stem));
+              continue;
+            }
+          DBS (DB_IMPLICIT, (_("Trying pattern rule with stem '%.*s'.\n"),
                              (int) stemlen, stem));
 …
               if (! dep->need_2nd_expansion)
+                {
-                  dep_simple = *dep;
-                  dep_simple.next = 0;
                   p = strchr (nptr, '%');
                   if (p == 0)
                     dep_simple.name = nptr;
+                    strcpy (depname, nptr);
                   else
+                    {
 …
                       o += stemlen;
                       strcpy (o, p + 1);
+                      dep_simple.name = strcache_add (depname);
+                    }
+                  dl = &dep_simple;
+                    }
+                  /* Parse the expanded string.  It might have wildcards.  */
+                  p = depname;
+                  dl = PARSE_SIMPLE_SEQ (&p, struct dep);
+                  for (d = dl; d != NULL; d = d->next)
+                    {
+                      ++deps_found;
+                      d->ignore_mtime = dep->ignore_mtime;
+                    }
                   /* We've used up this dep, so next time get a new one.  */
                   nptr = 0;
-                  ++deps_found;
+                }
 …
                   int add_dir = 0;
                   unsigned int len;
+                  struct dep **dptr;
                   nptr = get_next_word (nptr, &len);
 …
+                    }
+                  /* Set up for the next word.  */
+                  nptr += len;
                   /* Initialize and set file variables if we haven't already
                      done so. */
 …
                   /* Perform the 2nd expansion.  */
                   p = variable_expand_for_file (depname, file);
+                  /* Parse the expanded string. */
+                  dl = PARSE_FILE_SEQ (&p, struct dep, order_only ? '\0' : '|',
+                                       add_dir ? dir : NULL, 0);
+                  for (d = dl; d != NULL; d = d->next)
+                    {
+                      ++deps_found;
+                      if (order_only)
+                        d->ignore_mtime = 1;
+                    }
+                  /* Set up for the next word.  */
+                  nptr += len;
+                  dptr = &dl;
+                  /* Parse the results into a deps list.  */
+                  do
+                    {
+                      /* Parse the expanded string. */
+                      struct dep *dp = PARSE_FILE_SEQ (&p, struct dep,
+                                                       order_only ? MAP_NUL : MAP_PIPE,
+                                                       add_dir ? dir : NULL, PARSEFS_NONE);
+                      *dptr = dp;
+                      for (d = dp; d != NULL; d = d->next)
+                        {
+                          ++deps_found;
+                          if (order_only)
+                            d->ignore_mtime = 1;
+                          dptr = &d->next;
+                        }
+                      /* If we stopped due to an order-only token, note it.  */
+                      if (*p == '|')
+                        {
+                          order_only = 1;
+                          ++p;
+                        }
+                    }
+                  while (*p != '\0');
+                }
 …
 nd expansion), reset it and realloc the arrays.  */
               if (deps_found > max_pattern_deps)
+              if (deps_found > max_deps)
+                {
                   unsigned int l = pat - deplist;
+                  /* This might have changed due to recursion.  */
+                  max_pattern_deps = MAX(max_pattern_deps, deps_found);
+                  max_deps = max_pattern_deps;
                   deplist = xrealloc (deplist,
                                       deps_found * sizeof (struct patdeps));
+                                      max_deps * sizeof (struct patdeps));
                   pat = deplist + l;
-                  max_pattern_deps = deps_found;
+                }
 …
                       DBS (DB_IMPLICIT,
                            (is_rule
                             ? _("Rejecting impossible rule prerequisite `%s'.\n")
                             : _("Rejecting impossible implicit prerequisite `%s'.\n"),
+                            ? _("Rejecting impossible rule prerequisite '%s'.\n")
+                            : _("Rejecting impossible implicit prerequisite '%s'.\n"),
                             d->name));
                       tryrules[ri].rule = 0;
 …
                   DBS (DB_IMPLICIT,
                        (is_rule
                         ? _("Trying rule prerequisite `%s'.\n")
                         : _("Trying implicit prerequisite `%s'.\n"), d->name));
+                        ? _("Trying rule prerequisite '%s'.\n")
+                        : _("Trying implicit prerequisite '%s'.\n"), d->name));
                   /* If this prereq is also explicitly mentioned for FILE,
 …
+                      {
                         DBS (DB_IMPLICIT,
                              (_("Found prerequisite `%s' as VPATH `%s'\n"),
+                             (_("Found prerequisite '%s' as VPATH '%s'\n"),
                               d->name, vname));
                         (pat++)->name = d->name;
 …
+                    {
                       DBS (DB_IMPLICIT,
                            (_("Looking for a rule with intermediate file `%s'.\n"),
+                           (_("Looking for a rule with intermediate file '%s'.\n"),
                             d->name));
 …
                           int_file->name = d->name;
                           pat->file = int_file;
+                          int_file = 0;
                           (pat++)->name = d->name;
-                          int_file = 0;
                           continue;
+                        }
 …
               /* Free the ns chain.  */
+              if (dl != &dep_simple)
+                free_dep_chain (dl);
+              free_dep_chain (dl);
               if (failed)
 …
           file->stem = 0;
           /* This rule is no longer `in use' for recursive searches.  */
+          /* This rule is no longer 'in use' for recursive searches.  */
           rule->in_use = 0;
 …
             break;
+          /* This pattern rule does not apply. If some of its dependencies
+             succeeded, free the data structure describing them.  */
+          /* free_idep_chain (deps); */
+          deps = 0;
+          /* This pattern rule does not apply.  Keep looking.  */
+        }
 …
           /* We don't want to delete an intermediate file that happened
              to be a prerequisite of some (other) target. Mark it as
+             precious.  */
+             secondary.  We don't want it to be precious as that disables
+             DELETE_ON_ERROR etc.  */
           if (f != 0)
             f->precious = 1;
+            f->secondary = 1;
           else
             f = enter_file (imf->name);
 …
              the rule that found it was a terminal one, then we want to mark
              the found file so that it will not have implicit rule search done
              for it.  If we are not entering a `struct file' for it now, we
              indicate this with the `changed' flag.  */
+             for it.  If we are not entering a 'struct file' for it now, we
+             indicate this with the 'changed' flag.  */
           if (dep->file == 0)
             dep->changed = 1;
 …
   /* If this rule builds other targets, too, put the others into FILE's
      `also_make' member.  */
+     'also_make' member.  */
   if (rule->num > 1)

vendor/gnumake/current/job.c

-              r2596
+              r3138
 /* Job execution and handling for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include <assert.h>
 …
 #include "commands.h"
 #include "variable.h"
 #include "debug.h"
+#include "os.h"
 #include <string.h>
 …
 #include <windows.h>
 char *default_shell = "sh.exe";
+const char *default_shell = "sh.exe";
 int no_default_sh_exe = 1;
 int batch_mode_shell = 1;
 …
 #elif defined (_AMIGA)
 char default_shell[] = "";
+const char *default_shell = "";
 extern int MyExecute (char **);
 int batch_mode_shell = 0;
 …
    to search the $PATH for it (since MSDOS doesn't have standard
    directories we could trust).  */
 char *default_shell = "command.com";
+const char *default_shell = "command.com";
 int batch_mode_shell = 0;
 #elif defined (__EMX__)
 char *default_shell = "/bin/sh";
+const char *default_shell = "/bin/sh";
 int batch_mode_shell = 0;
 …
 # include <descrip.h>
+char default_shell[] = "";
+# include <stsdef.h>
+const char *default_shell = "";
 int batch_mode_shell = 0;
+#elif defined (__riscos__)
+char default_shell[] = "";
+int batch_mode_shell = 0;
+#define strsignal vms_strsignal
+char * vms_strsignal (int status);
+#ifndef C_FACILITY_NO
+# define C_FACILITY_NO 0x350000
+#endif
+#ifndef VMS_POSIX_EXIT_MASK
+# define VMS_POSIX_EXIT_MASK (C_FACILITY_NO | 0xA000)
+#endif
 #else
 char default_shell[] = "/bin/sh";
+const char *default_shell = "/bin/sh";
 int batch_mode_shell = 0;
 …
 # include "w32err.h"
 # include "pathstuff.h"
+# define WAIT_NOHANG 1
 #endif /* WINDOWS32 */
 …
 #ifdef HAVE_WAITPID
 # define WAIT_NOHANG(status)    waitpid (-1, (status), WNOHANG)
 #else   /* Don't have waitpid.  */
+# define WAIT_NOHANG(status)    waitpid (-1, (status), WNOHANG)
+#else   /* Don't have waitpid.  */
 # ifdef HAVE_WAIT3
 #  ifndef wait3
 extern int wait3 ();
 #  endif
 #  define WAIT_NOHANG(status)   wait3 ((status), WNOHANG, (struct rusage *) 0)
+#  define WAIT_NOHANG(status)   wait3 ((status), WNOHANG, (struct rusage *) 0)
 # endif /* Have wait3.  */
 #endif /* Have waitpid.  */
 …
 #endif
 #ifndef HAVE_UNION_WAIT
+#ifndef HAVE_UNION_WAIT
 # define WAIT_T int
 …
 # endif
 #else   /* Have `union wait'.  */
+#else   /* Have 'union wait'.  */
 # define WAIT_T union wait
 …
 # endif
 #endif  /* Don't have `union wait'.  */
+#endif  /* Don't have 'union wait'.  */
 #if !defined(HAVE_UNISTD_H) && !defined(WINDOWS32)
 …
+}
+#ifndef HAVE_GETLOADAVG
 int getloadavg (double loadavg[], int nelem);
+int start_remote_job (char **argv, char **envp, int stdin_fd, int *is_remote,
+                      int *id_ptr, int *used_stdin);
+int start_remote_job_p (int);
+int remote_status (int *exit_code_ptr, int *signal_ptr, int *coredump_ptr,
+                   int block);
+RETSIGTYPE child_handler (int);
+#endif
 static void free_child (struct child *);
 static void start_job_command (struct child *child);
 …
 unsigned int job_slots_used = 0;
 /* Nonzero if the `good' standard input is in use.  */
+/* Nonzero if the 'good' standard input is in use.  */
 static int good_stdin_used = 0;
 …
 unsigned int jobserver_tokens = 0;
 #ifdef WINDOWS32
 /*
  * The macro which references this function is defined in make.h.
+ * The macro which references this function is defined in makeint.h.
  */
 int
 w32_kill(pid_t pid, int sig)
+w32_kill (pid_t pid, int sig)
+{
   return ((process_kill((HANDLE)pid, sig) == TRUE) ? 0 : -1);
+  return ((process_kill ((HANDLE)pid, sig) == TRUE) ? 0 : -1);
+}
 …
   const char *error_string = NULL;
   char temp_path[MAXPATHLEN]; /* need to know its length */
   unsigned path_size = GetTempPath(sizeof temp_path, temp_path);
+  unsigned path_size = GetTempPath (sizeof temp_path, temp_path);
   int path_is_dot = 0;
+  unsigned uniq = 1;
+  /* The following variable is static so we won't try to reuse a name
+     that was generated a little while ago, because that file might
+     not be on disk yet, since we use FILE_ATTRIBUTE_TEMPORARY below,
+     which tells the OS it doesn't need to flush the cache to disk.
+     If the file is not yet on disk, we might think the name is
+     available, while it really isn't.  This happens in parallel
+     builds, where Make doesn't wait for one job to finish before it
+     launches the next one.  */
+  static unsigned uniq = 0;
+  static int second_loop = 0;
   const unsigned sizemax = strlen (base) + strlen (ext) + 10;
 …
+    }
+  ++uniq;
+  if (uniq >= 0x10000 && !second_loop)
+    {
+      /* If we already had 64K batch files in this
+         process, make a second loop through the numbers,
+         looking for free slots, i.e. files that were
+         deleted in the meantime.  */
+      second_loop = 1;
+      uniq = 1;
+    }
   while (path_size > 0 &&
          path_size + sizemax < sizeof temp_path &&
          uniq < 0x10000)
+         !(uniq >= 0x10000 && second_loop))
+    {
       unsigned size = sprintf (temp_path + path_size,
 …
       if (h == INVALID_HANDLE_VALUE)
+        {
           const DWORD er = GetLastError();
+          const DWORD er = GetLastError ();
           if (er == ERROR_FILE_EXISTS || er == ERROR_ALREADY_EXISTS)
+            ++uniq;
+            {
+              ++uniq;
+              if (uniq == 0x10000 && !second_loop)
+                {
+                  second_loop = 1;
+                  uniq = 1;
+                }
+            }
           /* the temporary path is not guaranteed to exist */
 …
   if (error_string == NULL)
     error_string = _("Cannot create a temporary file\n");
   fatal (NILF, error_string);
+  O (fatal, NILF, error_string);
   /* not reached */
 …
   i = 0;
+  while (known_os2shells[i] != NULL) {
+    if (strcasecmp (name, known_os2shells[i]) == 0)
+      return 0; /* not a unix shell */
+    i++;
+  }
+  while (known_os2shells[i] != NULL)
+    {
+      if (strcasecmp (name, known_os2shells[i]) == 0)
+        return 0; /* not a unix shell */
+      i++;
+    }
   /* in doubt assume a unix like shell */
 …
 is_bourne_compatible_shell (const char *path)
+{
   /* list of known unix (Bourne-like) shells */
   const char *unix_shells[] = {
+  /* List of known POSIX (or POSIX-ish) shells.  */
+  static const char *unix_shells[] = {
     "sh",
     "bash",
 …
     NULL
   };
   unsigned i, len;
+  const char **s;
   /* find the rightmost '/' or '\\' */
 …
     name = path;
+  if (*name == '/' || *name == '\\') name++;
+  if (*name == '/' || *name == '\\')
+    ++name;
   /* this should be able to deal with extensions on Windows-like systems */
   for (i = 0; unix_shells[i] != NULL; i++) {
     len = strlen(unix_shells[i]);
+  for (s = unix_shells; *s != NULL; ++s)
+    {
 #if defined(WINDOWS32) || defined(__MSDOS__)
+    if ((strncasecmp (name, unix_shells[i], len) == 0) &&
+      (strlen(name) >= len && (name[len] == '\0' || name[len] == '.')))
+      unsigned int len = strlen (*s);
+      if ((strlen (name) >= len && STOP_SET (name[len], MAP_DOT|MAP_NUL))
+          && strncasecmp (name, *s, len) == 0)
 #else
+    if ((strncmp (name, unix_shells[i], len) == 0) &&
+      (strlen(name) >= len && name[len] == '\0'))
+#endif
+        return 1; /* a known unix-style shell */
+  }
+      if (strcmp (name, *s) == 0)
+#endif
+        return 1; /* a known unix-style shell */
+    }
   /* if not on the list, assume it's not a Bourne-like shell */
 …
 static void
 child_error (const char *target_name,
+child_error (struct child *child,
              int exit_code, int exit_sig, int coredump, int ignored)
+{
+  const char *pre = "*** ";
+  const char *post = "";
+  const char *dump = "";
+  const struct file *f = child->file;
+  const floc *flocp = &f->cmds->fileinfo;
+  const char *nm;
+  size_t l;
   if (ignored && silent_flag)
     return;
+#ifdef VMS
+  if (!(exit_code & 1))
+      error (NILF,
+             (ignored ? _("*** [%s] Error 0x%x (ignored)")
+              : _("*** [%s] Error 0x%x")),
+             target_name, exit_code);
+#else
+  if (exit_sig && coredump)
+    dump = _(" (core dumped)");
+  if (ignored)
+    {
+      pre = "";
+      post = _(" (ignored)");
+    }
+  if (! flocp->filenm)
+    nm = _("<builtin>");
+  else
+    {
+      char *a = alloca (strlen (flocp->filenm) + 1 + 11 + 1);
+      sprintf (a, "%s:%lu", flocp->filenm, flocp->lineno + flocp->offset);
+      nm = a;
+    }
+  l = strlen (pre) + strlen (nm) + strlen (f->name) + strlen (post);
+  OUTPUT_SET (&child->output);
+  show_goal_error ();
   if (exit_sig == 0)
+    error (NILF, ignored ? _("[%s] Error %d (ignored)") :
+           _("*** [%s] Error %d"),
+           target_name, exit_code);
+    error (NILF, l + INTSTR_LENGTH,
+           _("%s[%s: %s] Error %d%s"), pre, nm, f->name, exit_code, post);
   else
+    error (NILF, "*** [%s] %s%s",
+           target_name, strsignal (exit_sig),
+           coredump ? _(" (core dumped)") : "");
+#endif /* VMS */
+    {
+      const char *s = strsignal (exit_sig);
+      error (NILF, l + strlen (s) + strlen (dump),
+             "%s[%s: %s] %s%s%s", pre, nm, f->name, s, dump, post);
+    }
+  OUTPUT_UNSET ();
+}
 …
 /* Handle a dead child.  This handler may or may not ever be installed.
+   If we're using the jobserver feature, we need it.  First, installing it
+   ensures the read will interrupt on SIGCHLD.  Second, we close the dup'd
+   read FD to ensure we don't enter another blocking read without reaping all
+   the dead children.  In this case we don't need the dead_children count.
+   If we're using the jobserver feature without pselect(), we need it.
+   First, installing it ensures the read will interrupt on SIGCHLD.  Second,
+   we close the dup'd read FD to ensure we don't enter another blocking read
+   without reaping all the dead children.  In this case we don't need the
+   dead_children count.
    If we don't have either waitpid or wait3, then make is unreliable, but we
 …
   ++dead_children;
+  if (job_rfd >= 0)
+    {
+      close (job_rfd);
+      job_rfd = -1;
+    }
+  jobserver_signal ();
 #ifdef __EMX__
 …
   signal (SIGCHLD, SIG_DFL);
 #endif
-  /* This causes problems if the SIGCHLD interrupts a printf().
-  DB (DB_JOBS, (_("Got a SIGCHLD; %u unreaped children.\n"), dead_children));
-  */
+}
 extern int shell_function_pid, shell_function_completed;
+extern pid_t shell_function_pid;
 /* Reap all dead children, storing the returned status and the new command
    state (`cs_finished') in the `file' member of the `struct child' for the
+   state ('cs_finished') in the 'file' member of the 'struct child' for the
    dead child, and removing the child from the chain.  In addition, if BLOCK
    nonzero, we block in this function until we've reaped at least one
 …
 #ifndef WINDOWS32
   WAIT_T status;
+#endif
   /* Initially, assume we have some.  */
   int reap_more = 1;
-#endif
 #ifdef WAIT_NOHANG
 …
          && (block || REAP_MORE))
+    {
       int remote = 0;
+      unsigned int remote = 0;
       pid_t pid;
       int exit_code, exit_sig, coredump;
       register struct child *lastc, *c;
+      struct child *lastc, *c;
       int child_failed;
       int any_remote, any_local;
 …
       if (err && block)
+        {
+        {
           static int printed = 0;
           /* We might block for a while, so let the user know why.
+          /* We might block for a while, so let the user know why.
              Only print this message once no matter how many jobs are left.  */
           fflush (stdout);
+          fflush (stdout);
           if (!printed)
             error (NILF, _("*** Waiting for unfinished jobs...."));
+            O (error, NILF, _("*** Waiting for unfinished jobs...."));
           printed = 1;
+        }
+        }
       /* We have one less dead child to reap.  As noted in
          child_handler() above, this count is completely unimportant for
          all modern, POSIX-y systems that support wait3() or waitpid().
          The rest of this comment below applies only to early, broken
          pre-POSIX systems.  We keep the count only because... it's there...
          The test and decrement are not atomic; if it is compiled into:
                 register = dead_children - 1;
                 dead_children = register;
          a SIGCHLD could come between the two instructions.
          child_handler increments dead_children.
          The second instruction here would lose that increment.  But the
          only effect of dead_children being wrong is that we might wait
          longer than necessary to reap a child, and lose some parallelism;
          and we might print the "Waiting for unfinished jobs" message above
          when not necessary.  */
+         child_handler() above, this count is completely unimportant for
+         all modern, POSIX-y systems that support wait3() or waitpid().
+         The rest of this comment below applies only to early, broken
+         pre-POSIX systems.  We keep the count only because... it's there...
+         The test and decrement are not atomic; if it is compiled into:
+                register = dead_children - 1;
+                dead_children = register;
+         a SIGCHLD could come between the two instructions.
+         child_handler increments dead_children.
+         The second instruction here would lose that increment.  But the
+         only effect of dead_children being wrong is that we might wait
+         longer than necessary to reap a child, and lose some parallelism;
+         and we might print the "Waiting for unfinished jobs" message above
+         when not necessary.  */
       if (dead_children > 0)
         --dead_children;
+        --dead_children;
       any_remote = 0;
       any_local = shell_function_pid != 0;
       for (c = children; c != 0; c = c->next)
+        {
           any_remote |= c->remote;
           any_local |= ! c->remote;
           DB (DB_JOBS, (_("Live child %p (%s) PID %s %s\n"),
+        {
+          any_remote |= c->remote;
+          any_local |= ! c->remote;
+          DB (DB_JOBS, (_("Live child %p (%s) PID %s %s\n"),
                         c, c->file->name, pid2str (c->pid),
                         c->remote ? _(" (remote)") : ""));
 #ifdef VMS
           break;
 #endif
+        }
+          break;
+#endif
+        }
       /* First, check for remote children.  */
       if (any_remote)
         pid = remote_status (&exit_code, &exit_sig, &coredump, 0);
+        pid = remote_status (&exit_code, &exit_sig, &coredump, 0);
       else
         pid = 0;
+        pid = 0;
       if (pid > 0)
         /* We got a remote child.  */
         remote = 1;
+        /* We got a remote child.  */
+        remote = 1;
       else if (pid < 0)
+        {
+        {
           /* A remote status command failed miserably.  Punt.  */
         remote_status_lose:
           pfatal_with_name ("remote_status");
+        }
+        remote_status_lose:
+          pfatal_with_name ("remote_status");
+        }
       else
+        {
           /* No remote children.  Check for local children.  */
+        {
+          /* No remote children.  Check for local children.  */
 #if !defined(__MSDOS__) && !defined(_AMIGA) && !defined(WINDOWS32)
           if (any_local)
+            {
+          if (any_local)
+            {
 #ifdef VMS
+              vmsWaitForChildren (&status);
+              pid = c->pid;
+              /* Todo: This needs more untangling multi-process support */
+              /* Just do single child process support now */
+              vmsWaitForChildren (&status);
+              pid = c->pid;
+              /* VMS failure status can not be fully translated */
+              status = $VMS_STATUS_SUCCESS (c->cstatus) ? 0 : (1 << 8);
+              /* A Posix failure can be exactly translated */
+              if ((c->cstatus & VMS_POSIX_EXIT_MASK) == VMS_POSIX_EXIT_MASK)
+                status = (c->cstatus >> 3 & 255) << 8;
 #else
 #ifdef WAIT_NOHANG
               if (!block)
                 pid = WAIT_NOHANG (&status);
               else
 #endif
                 EINTRLOOP(pid, wait (&status));
+              if (!block)
+                pid = WAIT_NOHANG (&status);
+              else
+#endif
+                EINTRLOOP (pid, wait (&status));
 #endif /* !VMS */
+            }
           else
             pid = 0;
           if (pid < 0)
+            {
+            }
+          else
+            pid = 0;
+          if (pid < 0)
+            {
               /* The wait*() failed miserably.  Punt.  */
               pfatal_with_name ("wait");
+            }
           else if (pid > 0)
+            {
               /* We got a child exit; chop the status word up.  */
               exit_code = WEXITSTATUS (status);
               exit_sig = WIFSIGNALED (status) ? WTERMSIG (status) : 0;
               coredump = WCOREDUMP (status);
+              pfatal_with_name ("wait");
+            }
+          else if (pid > 0)
+            {
+              /* We got a child exit; chop the status word up.  */
+              exit_code = WEXITSTATUS (status);
+              exit_sig = WIFSIGNALED (status) ? WTERMSIG (status) : 0;
+              coredump = WCOREDUMP (status);
               /* If we have started jobs in this second, remove one.  */
               if (job_counter)
                 --job_counter;
+            }
           else
+            {
               /* No local children are dead.  */
+            }
+          else
+            {
+              /* No local children are dead.  */
               reap_more = 0;
               if (!block || !any_remote)
+              if (!block || !any_remote)
                 break;
 …
               /* We got a remote child.  */
               remote = 1;
+            }
+            }
 #endif /* !__MSDOS__, !Amiga, !WINDOWS32.  */
 #ifdef __MSDOS__
           /* Life is very different on MSDOS.  */
           pid = dos_pid - 1;
           status = dos_status;
           exit_code = WEXITSTATUS (status);
           if (exit_code == 0xff)
             exit_code = -1;
           exit_sig = WIFSIGNALED (status) ? WTERMSIG (status) : 0;
           coredump = 0;
+          /* Life is very different on MSDOS.  */
+          pid = dos_pid - 1;
+          status = dos_status;
+          exit_code = WEXITSTATUS (status);
+          if (exit_code == 0xff)
+            exit_code = -1;
+          exit_sig = WIFSIGNALED (status) ? WTERMSIG (status) : 0;
+          coredump = 0;
 #endif /* __MSDOS__ */
 #ifdef _AMIGA
           /* Same on Amiga */
           pid = amiga_pid - 1;
           status = amiga_status;
           exit_code = amiga_status;
           exit_sig = 0;
           coredump = 0;
+          /* Same on Amiga */
+          pid = amiga_pid - 1;
+          status = amiga_status;
+          exit_code = amiga_status;
+          exit_sig = 0;
+          coredump = 0;
 #endif /* _AMIGA */
 #ifdef WINDOWS32
+          {
             HANDLE hPID;
-            int werr;
             HANDLE hcTID, hcPID;
+            DWORD dwWaitStatus = 0;
             exit_code = 0;
             exit_sig = 0;
 …
                     fprintf (stderr,
                              "Determine main thread ID (Error %ld: %s)\n",
                              e, map_windows32_error_to_string(e));
+                             e, map_windows32_error_to_string (e));
+                  }
                 else
 …
             /* wait for anything to finish */
             hPID = process_wait_for_any();
+            hPID = process_wait_for_any (block, &dwWaitStatus);
             if (hPID)
+              {
                 /* was an error found on this process? */
                 werr = process_last_err(hPID);
+                int werr = process_last_err (hPID);
                 /* get exit data */
                 exit_code = process_exit_code(hPID);
+                exit_code = process_exit_code (hPID);
                 if (werr)
                   fprintf(stderr, "make (e=%d): %s",
                           exit_code, map_windows32_error_to_string(exit_code));
+                  fprintf (stderr, "make (e=%d): %s", exit_code,
+                           map_windows32_error_to_string (exit_code));
                 /* signal */
                 exit_sig = process_signal(hPID);
+                exit_sig = process_signal (hPID);
                 /* cleanup process */
                 process_cleanup(hPID);
+                process_cleanup (hPID);
                 coredump = 0;
+              }
+            else if (dwWaitStatus == WAIT_FAILED)
+              {
+                /* The WaitForMultipleObjects() failed miserably.  Punt.  */
+                pfatal_with_name ("WaitForMultipleObjects");
+              }
+            else if (dwWaitStatus == WAIT_TIMEOUT)
+              {
+                /* No child processes are finished.  Give up waiting. */
+                reap_more = 0;
+                break;
+              }
             pid = (pid_t) hPID;
+          }
 #endif /* WINDOWS32 */
+        }
       /* Check if this is the child of the `shell' function.  */
+        }
+      /* Check if this is the child of the 'shell' function.  */
       if (!remote && pid == shell_function_pid)
+        {
+          /* It is.  Leave an indicator for the `shell' function.  */
+          if (exit_sig == 0 && exit_code == 127)
+            shell_function_completed = -1;
+          else
+            shell_function_completed = 1;
+          break;
+        }
+      child_failed = exit_sig != 0 || exit_code != 0;
+        {
+          shell_completed (exit_code, exit_sig);
+          break;
+        }
       /* Search for a child matching the deceased one.  */
       lastc = 0;
       for (c = children; c != 0; lastc = c, c = c->next)
         if (c->remote == remote && c->pid == pid)
           break;
+        if (c->pid == pid && c->remote == remote)
+          break;
       if (c == 0)
 …
         continue;
+      /* Determine the failure status: 0 for success, 1 for updating target in
+         question mode, 2 for anything else.  */
+      if (exit_sig == 0 && exit_code == 0)
+        child_failed = MAKE_SUCCESS;
+      else if (exit_sig == 0 && exit_code == 1 && question_flag && c->recursive)
+        child_failed = MAKE_TROUBLE;
+      else
+        child_failed = MAKE_FAILURE;
       DB (DB_JOBS, (child_failed
                     ? _("Reaping losing child %p PID %s %s\n")
 …
                     c, pid2str (c->pid), c->remote ? _(" (remote)") : ""));
+      if (c->sh_batch_file) {
+        DB (DB_JOBS, (_("Cleaning up temp batch file %s\n"),
+                      c->sh_batch_file));
+        /* just try and remove, don't care if this fails */
+        remove (c->sh_batch_file);
+        /* all done with memory */
+        free (c->sh_batch_file);
+        c->sh_batch_file = NULL;
+      }
+      if (c->sh_batch_file)
+        {
+          int rm_status;
+          DB (DB_JOBS, (_("Cleaning up temp batch file %s\n"),
+                        c->sh_batch_file));
+          errno = 0;
+          rm_status = remove (c->sh_batch_file);
+          if (rm_status)
+            DB (DB_JOBS, (_("Cleaning up temp batch file %s failed (%d)\n"),
+                          c->sh_batch_file, errno));
+          /* all done with memory */
+          free (c->sh_batch_file);
+          c->sh_batch_file = NULL;
+        }
       /* If this child had the good stdin, say it is now free.  */
 …
           static int delete_on_error = -1;
           if (!dontcare)
             child_error (c->file->name, exit_code, exit_sig, coredump, 0);
           c->file->update_status = 2;
+          if (!dontcare && child_failed == MAKE_FAILURE)
+            child_error (c, exit_code, exit_sig, coredump, 0);
+          c->file->update_status = child_failed == MAKE_FAILURE ? us_failed : us_question;
           if (delete_on_error == -1)
+            {
 …
+            {
               /* The commands failed, but we don't care.  */
+              child_error (c->file->name,
+                           exit_code, exit_sig, coredump, 1);
+              child_error (c, exit_code, exit_sig, coredump, 1);
               child_failed = 0;
+            }
 …
                      the target was not completely remade.  So we treat
                      this as if a command had failed.  */
                   c->file->update_status = 2;
+                  c->file->update_status = us_failed;
+                }
               else
+                {
+#ifndef NO_OUTPUT_SYNC
+                  /* If we're sync'ing per line, write the previous line's
+                     output before starting the next one.  */
+                  if (output_sync == OUTPUT_SYNC_LINE)
+                    output_dump (&c->output);
+#endif
                   /* Check again whether to start remotely.
                      Whether or not we want to changes over time.
 …
+                }
               if (c->file->update_status != 0)
+              if (c->file->update_status != us_success)
                 /* We failed to start the commands.  */
                 delete_child_targets (c);
 …
                without an unignored error.  Now the target has been
                successfully updated.  */
             c->file->update_status = 0;
+            c->file->update_status = us_success;
+        }
+      /* When we get here, all the commands for C->file are finished
+         (or aborted) and C->file->update_status contains 0 or 2.  But
+         C->file->command_state is still cs_running if all the commands
+      /* When we get here, all the commands for c->file are finished.  */
+#ifndef NO_OUTPUT_SYNC
+      /* Synchronize any remaining parallel output.  */
+      output_dump (&c->output);
+#endif
+      /* At this point c->file->update_status is success or failed.  But
+         c->file->command_state is still cs_running if all the commands
          ran; notice_finish_file looks for cs_running to tell it that
          it's interesting to check the file's modtime again now.  */
 …
           /* fatal_error_signal will die with the right signal.  */
           !handling_fatal_signal)
         die (2);
+        die (child_failed);
       /* Only block for one child.  */
 …
 free_child (struct child *child)
+{
+  output_close (&child->output);
   if (!jobserver_tokens)
     fatal (NILF, "INTERNAL: Freeing child %p (%s) but no tokens left!\n",
            child, child->file->name);
+    ONS (fatal, NILF, "INTERNAL: Freeing child %p (%s) but no tokens left!\n",
+         child, child->file->name);
   /* If we're using the jobserver and this child is not the only outstanding
      job, put a token back into the pipe for it.  */
+  if (job_fds[1] >= 0 && jobserver_tokens > 1)
+    {
+      char token = '+';
+      int r;
+      /* Write a job token back to the pipe.  */
+      EINTRLOOP (r, write (job_fds[1], &token, 1));
+      if (r != 1)
+        pfatal_with_name (_("write jobserver"));
+  if (jobserver_enabled () && jobserver_tokens > 1)
+    {
+      jobserver_release (1);
       DB (DB_JOBS, (_("Released token for child %p (%s).\n"),
                     child, child->file->name));
 …
       register unsigned int i;
       for (i = 0; i < child->file->cmds->ncommand_lines; ++i)
         free (child->command_lines[i]);
+        free (child->command_lines[i]);
       free (child->command_lines);
+    }
 …
       register char **ep = child->environment;
       while (*ep != 0)
         free (*ep++);
+        free (*ep++);
       free (child->environment);
+    }
 …
 #endif
-#ifdef MAKE_JOBSERVER
-RETSIGTYPE
-job_noop (int sig UNUSED)
+{
+}
-/* Set the child handler action flags to FLAGS.  */
-static void
-set_child_handler_action_flags (int set_handler, int set_alarm)
+{
-  struct sigaction sa;
-#ifdef __EMX__
-  /* The child handler must be turned off here.  */
-  signal (SIGCHLD, SIG_DFL);
-#endif
-  memset (&sa, '\0', sizeof sa);
-  sa.sa_handler = child_handler;
-  sa.sa_flags = set_handler ? 0 : SA_RESTART;
-#if defined SIGCHLD
-  sigaction (SIGCHLD, &sa, NULL);
-#endif
-#if defined SIGCLD && SIGCLD != SIGCHLD
-  sigaction (SIGCLD, &sa, NULL);
-#endif
-#if defined SIGALRM
-  if (set_alarm)
+    {
-      /* If we're about to enter the read(), set an alarm to wake up in a
-         second so we can check if the load has dropped and we can start more
-         work.  On the way out, turn off the alarm and set SIG_DFL.  */
-      alarm (set_handler ? 1 : 0);
-      sa.sa_handler = set_handler ? job_noop : SIG_DFL;
-      sa.sa_flags = 0;
-      sigaction (SIGALRM, &sa, NULL);
+    }
-#endif
+}
-#endif
 /* Start a job to run the commands specified in CHILD.
 …
    NOTE: On return fatal signals are blocked!  The caller is responsible
    for calling `unblock_sigs', once the new child is safely on the chain so
+   for calling 'unblock_sigs', once the new child is safely on the chain so
    it can be cleaned up in the event of a fatal signal.  */
 …
 start_job_command (struct child *child)
+{
+#if !defined(_AMIGA) && !defined(WINDOWS32)
+  static int bad_stdin = -1;
+#endif
+  int flags;
   char *p;
-  /* Must be volatile to silence bogus GCC warning about longjmp/vfork.  */
-  volatile int flags;
 #ifdef VMS
   char *argv;
 …
      the flags specified globally for this target.  */
   flags = (child->file->command_flags
            | child->file->cmds->lines_flags[child->command_line - 1]);
+           | child->file->cmds->lines_flags[child->command_line - 1]);
   p = child->command_ptr;
 …
+    {
       if (*p == '@')
         flags |= COMMANDS_SILENT;
+        flags |= COMMANDS_SILENT;
       else if (*p == '+')
         flags |= COMMANDS_RECURSE;
+        flags |= COMMANDS_RECURSE;
       else if (*p == '-')
+        child->noerror = 1;
+      else if (!isblank ((unsigned char)*p))
+        break;
+        child->noerror = 1;
+      /* Don't skip newlines.  */
+      else if (!ISBLANK (*p))
+        break;
       ++p;
+    }
+  child->recursive = ((flags & COMMANDS_RECURSE) != 0);
   /* Update the file's command flags with any new ones we found.  We only
 …
      order to really fix this, we'll have to keep a lines_flags for every
      actual line, after expansion.  */
+  child->file->cmds->lines_flags[child->command_line - 1]
+    |= flags & COMMANDS_RECURSE;
+  child->file->cmds->lines_flags[child->command_line - 1] |= flags & COMMANDS_RECURSE;
+  /* POSIX requires that a recipe prefix after a backslash-newline should
+     be ignored.  Remove it now so the output is correct.  */
+  {
+    char prefix = child->file->cmds->recipe_prefix;
+    char *p1, *p2;
+    p1 = p2 = p;
+    while (*p1 != '\0')
+      {
+        *(p2++) = *p1;
+        if (p1[0] == '\n' && p1[1] == prefix)
+          ++p1;
+        ++p1;
+      }
+    *p2 = *p1;
+  }
   /* Figure out an argument list from this command line.  */
+  {
     char *end = 0;
 #ifdef VMS
+    /* Skip any leading whitespace */
+    while (*p)
+      {
+        if (!ISSPACE (*p))
+          {
+            if (*p != '\\')
+              break;
+            if ((p[1] != '\n') && (p[1] != 'n') && (p[1] != 't'))
+              break;
+          }
+        p++;
+      }
     argv = p;
+    /* Although construct_command_argv contains some code for VMS, it was/is
+       not called/used.  Please note, for VMS argv is a string (not an array
+       of strings) which contains the complete command line, which for
+       multi-line variables still includes the newlines.  So detect newlines
+       and set 'end' (which is used for child->command_ptr) instead of
+       (re-)writing construct_command_argv */
+    if (!one_shell)
+      {
+        char *s = p;
+        int instring = 0;
+        while (*s)
+          {
+            if (*s == '"')
+              instring = !instring;
+            else if (*s == '\\' && !instring && *(s+1) != 0)
+              s++;
+            else if (*s == '\n' && !instring)
+              {
+                end = s;
+                break;
+              }
+            ++s;
+          }
+      }
 #else
     argv = construct_command_argv (p, &end, child->file,
                                    child->file->cmds->lines_flags[child->command_line - 1],
                                    &child->sh_batch_file);
+                                   child->file->cmds->lines_flags[child->command_line - 1],
+                                   &child->sh_batch_file);
 #endif
     if (end == NULL)
 …
     else
+      {
         *end++ = '\0';
         child->command_ptr = end;
+        *end++ = '\0';
+        child->command_ptr = end;
+      }
+  }
   /* If -q was given, say that updating `failed' if there was any text on the
      command line, or `succeeded' otherwise.  The exit status of 1 tells the
      user that -q is saying `something to do'; the exit status for a random
+  /* If -q was given, say that updating 'failed' if there was any text on the
+     command line, or 'succeeded' otherwise.  The exit status of 1 tells the
+     user that -q is saying 'something to do'; the exit status for a random
      error is 2.  */
   if (argv != 0 && question_flag && !(flags & COMMANDS_RECURSE))
 …
       free (argv);
 #endif
+      child->file->update_status = 1;
+      notice_finished_file (child->file);
+      return;
+#ifdef VMS
+      /* On VMS, argv[0] can be a null string here */
+      if (argv[0] != 0)
+        {
+#endif
+          child->file->update_status = us_question;
+          notice_finished_file (child->file);
+          return;
+#ifdef VMS
+        }
+#endif
+    }
 …
+    {
       /* Go on to the next command.  It might be the recursive one.
          We construct ARGV only to find the end of the command line.  */
+         We construct ARGV only to find the end of the command line.  */
 #ifndef VMS
       if (argv)
 …
       /* This line has no commands.  Go to the next.  */
       if (job_next_command (child))
         start_job_command (child);
+        start_job_command (child);
       else
+        {
           /* No more commands.  Make sure we're "running"; we might not be if
+        {
+          /* No more commands.  Make sure we're "running"; we might not be if
              (e.g.) all commands were skipped due to -n.  */
           set_command_state (child->file, cs_running);
+          child->file->update_status = 0;
+          notice_finished_file (child->file);
+        }
+          child->file->update_status = us_success;
+          notice_finished_file (child->file);
+        }
+      OUTPUT_UNSET();
       return;
+    }
+  /* Print out the command.  If silent, we call `message' with null so it
+     can log the working directory before the command's own error messages
+     appear.  */
+  message (0, (just_print_flag || (!(flags & COMMANDS_SILENT) && !silent_flag))
+           ? "%s" : (char *) 0, p);
+  /* Are we going to synchronize this command's output?  Do so if either we're
+     in SYNC_RECURSE mode or this command is not recursive.  We'll also check
+     output_sync separately below in case it changes due to error.  */
+  child->output.syncout = output_sync && (output_sync == OUTPUT_SYNC_RECURSE
+                                          || !(flags & COMMANDS_RECURSE));
+  OUTPUT_SET (&child->output);
+#ifndef NO_OUTPUT_SYNC
+  if (! child->output.syncout)
+    /* We don't want to sync this command: to avoid misordered
+       output ensure any already-synced content is written.  */
+    output_dump (&child->output);
+#endif
+  /* Print the command if appropriate.  */
+  if (just_print_flag || trace_flag
+      || (!(flags & COMMANDS_SILENT) && !silent_flag))
+    OS (message, 0, "%s", p);
   /* Tell update_goal_chain that a command has been started on behalf of
 …
   if (
 #if defined __MSDOS__ || defined (__EMX__)
       unixy_shell       /* the test is complicated and we already did it */
+      unixy_shell       /* the test is complicated and we already did it */
 #else
       (argv[0] && is_bourne_compatible_shell(argv[0]))
+      (argv[0] && is_bourne_compatible_shell (argv[0]))
 #endif
       && (argv[1] && argv[1][0] == '-'
         &&
             ((argv[1][1] == 'c' && argv[1][2] == '\0')
           ||
              (argv[1][1] == 'e' && argv[1][2] == 'c' && argv[1][3] == '\0')))
+        &&
+            ((argv[1][1] == 'c' && argv[1][2] == '\0')
+          ||
+             (argv[1][1] == 'e' && argv[1][2] == 'c' && argv[1][3] == '\0')))
       && (argv[2] && argv[2][0] == ':' && argv[2][1] == '\0')
       && argv[3] == NULL)
 …
+    }
+  /* We're sure we're going to invoke a command: set up the output.  */
+  output_start ();
   /* Flush the output streams so they won't have things written twice.  */
 …
   fflush (stderr);
+#ifndef VMS
+#if !defined(WINDOWS32) && !defined(_AMIGA) && !defined(__MSDOS__)
+  /* Set up a bad standard input that reads from a broken pipe.  */
+  if (bad_stdin == -1)
+    {
+      /* Make a file descriptor that is the read end of a broken pipe.
+         This will be used for some children's standard inputs.  */
+      int pd[2];
+      if (pipe (pd) == 0)
+        {
+          /* Close the write side.  */
+          (void) close (pd[1]);
+          /* Save the read side.  */
+          bad_stdin = pd[0];
+          /* Set the descriptor to close on exec, so it does not litter any
+             child's descriptor table.  When it is dup2'd onto descriptor 0,
+             that descriptor will not close on exec.  */
+          CLOSE_ON_EXEC (bad_stdin);
+        }
+    }
+#endif /* !WINDOWS32 && !_AMIGA && !__MSDOS__ */
+  /* Decide whether to give this child the `good' standard input
+     (one that points to the terminal or whatever), or the `bad' one
+  /* Decide whether to give this child the 'good' standard input
+     (one that points to the terminal or whatever), or the 'bad' one
      that points to the read side of a broken pipe.  */
 …
   if (child->good_stdin)
     good_stdin_used = 1;
-#endif /* !VMS */
   child->deleted = 0;
 …
       int is_remote, id, used_stdin;
       if (start_remote_job (argv, child->environment,
                             child->good_stdin ? 0 : bad_stdin,
                             &is_remote, &id, &used_stdin))
+                            child->good_stdin ? 0 : get_bad_stdin (),
+                            &is_remote, &id, &used_stdin))
         /* Don't give up; remote execution may fail for various reasons.  If
            so, simply run the job locally.  */
         goto run_local;
+        goto run_local;
       else
+        {
           if (child->good_stdin && !used_stdin)
+            {
               child->good_stdin = 0;
               good_stdin_used = 0;
+            }
           child->remote = is_remote;
           child->pid = id;
+        }
+        {
+          if (child->good_stdin && !used_stdin)
+            {
+              child->good_stdin = 0;
+              good_stdin_used = 0;
+            }
+          child->remote = is_remote;
+          child->pid = id;
+        }
+    }
   else
 …
 #ifdef VMS
+      if (!child_execute_job (argv, child)) {
+        /* Fork failed!  */
+        perror_with_name ("vfork", "");
+        goto error;
+      }
+      if (!child_execute_job (child, argv))
+        {
+          /* Fork failed!  */
+          perror_with_name ("fork", "");
+          goto error;
+        }
 #else
 …
       parent_environ = environ;
+# ifdef __EMX__
+      /* If we aren't running a recursive command and we have a jobserver
+         pipe, close it before exec'ing.  */
+      if (!(flags & COMMANDS_RECURSE) && job_fds[0] >= 0)
+        {
+          CLOSE_ON_EXEC (job_fds[0]);
+          CLOSE_ON_EXEC (job_fds[1]);
+        }
+      if (job_rfd >= 0)
+        CLOSE_ON_EXEC (job_rfd);
+      /* Never use fork()/exec() here! Use spawn() instead in exec_command() */
+      child->pid = child_execute_job (child->good_stdin ? 0 : bad_stdin, 1,
+                                      argv, child->environment);
+      jobserver_pre_child (flags & COMMANDS_RECURSE);
+      child->pid = child_execute_job (&child->output, child->good_stdin, argv, child->environment);
+      environ = parent_environ; /* Restore value child may have clobbered.  */
+      jobserver_post_child (flags & COMMANDS_RECURSE);
       if (child->pid < 0)
+        {
+          /* spawn failed!  */
+          unblock_sigs ();
+          perror_with_name ("spawn", "");
+          goto error;
+        }
+      /* undo CLOSE_ON_EXEC() after the child process has been started */
+      if (!(flags & COMMANDS_RECURSE) && job_fds[0] >= 0)
+        {
+          fcntl (job_fds[0], F_SETFD, 0);
+          fcntl (job_fds[1], F_SETFD, 0);
+        }
+      if (job_rfd >= 0)
+        fcntl (job_rfd, F_SETFD, 0);
+#else  /* !__EMX__ */
+      child->pid = vfork ();
+      environ = parent_environ; /* Restore value child may have clobbered.  */
+      if (child->pid == 0)
+        {
+          /* We are the child side.  */
+          unblock_sigs ();
+          /* If we aren't running a recursive command and we have a jobserver
+             pipe, close it before exec'ing.  */
+          if (!(flags & COMMANDS_RECURSE) && job_fds[0] >= 0)
+            {
+              close (job_fds[0]);
+              close (job_fds[1]);
+            }
+          if (job_rfd >= 0)
+            close (job_rfd);
+#ifdef SET_STACK_SIZE
+          /* Reset limits, if necessary.  */
+          if (stack_limit.rlim_cur)
+            setrlimit (RLIMIT_STACK, &stack_limit);
+#endif
+          child_execute_job (child->good_stdin ? 0 : bad_stdin, 1,
+                             argv, child->environment);
+        }
+      else if (child->pid < 0)
+        {
+          /* Fork failed!  */
+          unblock_sigs ();
+          perror_with_name ("vfork", "");
+          goto error;
+        }
+# endif  /* !__EMX__ */
+        {
+          /* Fork failed!  */
+          unblock_sigs ();
+          perror_with_name ("fork", "");
+          goto error;
+        }
 #endif /* !VMS */
+    }
 #else   /* __MSDOS__ or Amiga or WINDOWS32 */
+#else   /* __MSDOS__ or Amiga or WINDOWS32 */
 #ifdef __MSDOS__
+  {
 …
     dos_status = 0;
     /* We call `system' to do the job of the SHELL, since stock DOS
        shell is too dumb.  Our `system' knows how to handle long
+    /* We call 'system' to do the job of the SHELL, since stock DOS
+       shell is too dumb.  Our 'system' knows how to handle long
        command lines even if pipes/redirection is needed; it will only
        call COMMAND.COM when its internal commands are used.  */
     if (execute_by_shell)
+      {
         char *cmdline = argv[0];
         /* We don't have a way to pass environment to `system',
            so we need to save and restore ours, sigh...  */
         char **parent_environ = environ;
         environ = child->environment;
         /* If we have a *real* shell, tell `system' to call
            it to do everything for us.  */
         if (unixy_shell)
+          {
             /* A *real* shell on MSDOS may not support long
                command lines the DJGPP way, so we must use `system'.  */
             cmdline = argv[2];  /* get past "shell -c" */
+          }
         dos_command_running = 1;
         proc_return = system (cmdline);
         environ = parent_environ;
         execute_by_shell = 0;   /* for the next time */
+        char *cmdline = argv[0];
+        /* We don't have a way to pass environment to 'system',
+           so we need to save and restore ours, sigh...  */
+        char **parent_environ = environ;
+        environ = child->environment;
+        /* If we have a *real* shell, tell 'system' to call
+           it to do everything for us.  */
+        if (unixy_shell)
+          {
+            /* A *real* shell on MSDOS may not support long
+               command lines the DJGPP way, so we must use 'system'.  */
+            cmdline = argv[2];  /* get past "shell -c" */
+          }
+        dos_command_running = 1;
+        proc_return = system (cmdline);
+        environ = parent_environ;
+        execute_by_shell = 0;   /* for the next time */
+      }
     else
+      {
         dos_command_running = 1;
         proc_return = spawnvpe (P_WAIT, argv[0], argv, child->environment);
+        dos_command_running = 1;
+        proc_return = spawnvpe (P_WAIT, argv[0], argv, child->environment);
+      }
 …
      DeleteFile (amiga_bname);        /* Ignore errors.  */
+  }
 #endif  /* Amiga */
+#endif  /* Amiga */
 #ifdef WINDOWS32
+  {
       HANDLE hPID;
       char* arg0;
+      int outfd = FD_STDOUT;
+      int errfd = FD_STDERR;
       /* make UNC paths safe for CreateProcess -- backslash format */
 …
       /* make sure CreateProcess() has Path it needs */
+      sync_Path_environment();
+      hPID = process_easy(argv, child->environment);
+      sync_Path_environment ();
+#ifndef NO_OUTPUT_SYNC
+      /* Divert child output if output_sync in use.  */
+      if (child->output.syncout)
+        {
+          if (child->output.out >= 0)
+            outfd = child->output.out;
+          if (child->output.err >= 0)
+            errfd = child->output.err;
+        }
+#else
+      outfd = errfd = -1;
+#endif
+      hPID = process_easy (argv, child->environment, outfd, errfd);
       if (hPID != INVALID_HANDLE_VALUE)
         child->pid = (pid_t) hPID;
+      else {
+        int i;
+        unblock_sigs();
+        fprintf(stderr,
+                _("process_easy() failed to launch process (e=%ld)\n"),
+                process_last_err(hPID));
+        for (i = 0; argv[i]; i++)
+          fprintf(stderr, "%s ", argv[i]);
+        fprintf(stderr, _("\nCounted %d args in failed launch\n"), i);
+        goto error;
+      }
+      else
+        {
+          int i;
+          unblock_sigs ();
+          fprintf (stderr,
+                   _("process_easy() failed to launch process (e=%ld)\n"),
+                   process_last_err (hPID));
+          for (i = 0; argv[i]; i++)
+            fprintf (stderr, "%s ", argv[i]);
+          fprintf (stderr, _("\nCounted %d args in failed launch\n"), i);
+          goto error;
+        }
+  }
 #endif /* WINDOWS32 */
 #endif  /* __MSDOS__ or Amiga or WINDOWS32 */
+#endif  /* __MSDOS__ or Amiga or WINDOWS32 */
   /* Bump the number of jobs started in this second.  */
 …
 #endif
+  OUTPUT_UNSET();
   return;
  error:
   child->file->update_status = 2;
+  child->file->update_status = us_failed;
   notice_finished_file (child->file);
   return;
+  OUTPUT_UNSET();
+}
 /* Try to start a child running.
    Returns nonzero if the child was started (and maybe finished), or zero if
    the load was too high and the child was put on the `waiting_jobs' chain.  */
+   the load was too high and the child was put on the 'waiting_jobs' chain.  */
 static int
 …
       && ((job_slots_used > 0 && load_too_high ())
 #ifdef WINDOWS32
           || (process_used_slots () >= MAXIMUM_WAIT_OBJECTS)
 #endif
           ))
+          || (process_used_slots () >= MAXIMUM_WAIT_OBJECTS)
+#endif
+          ))
+    {
       /* Put this child on the chain of children waiting for the load average
 …
     case cs_not_started:
       /* All the command lines turned out to be empty.  */
       f->update_status = 0;
+      f->update_status = us_success;
       /* FALLTHROUGH */
 …
+}
 /* Create a `struct child' for FILE and start its commands running.  */
+/* Create a 'struct child' for FILE and start its commands running.  */
 void
 …
   chop_commands (cmds);
+  /* Start the command sequence, record it in a new
+     'struct child', and add that to the chain.  */
+  c = xcalloc (sizeof (struct child));
+  output_init (&c->output);
+  c->file = file;
+  c->sh_batch_file = NULL;
+  /* Cache dontcare flag because file->dontcare can be changed once we
+     return. Check dontcare inheritance mechanism for details.  */
+  c->dontcare = file->dontcare;
+  /* Start saving output in case the expansion uses $(info ...) etc.  */
+  OUTPUT_SET (&c->output);
   /* Expand the command lines and store the results in LINES.  */
   lines = xmalloc (cmds->ncommand_lines * sizeof (char *));
 …
+    {
       /* Collapse backslash-newline combinations that are inside variable
          or function references.  These are left alone by the parser so
          that they will appear in the echoing of commands (where they look
          nice); and collapsed by construct_command_argv when it tokenizes.
          But letting them survive inside function invocations loses because
          we don't want the functions to see them as part of the text.  */
+         or function references.  These are left alone by the parser so
+         that they will appear in the echoing of commands (where they look
+         nice); and collapsed by construct_command_argv when it tokenizes.
+         But letting them survive inside function invocations loses because
+         we don't want the functions to see them as part of the text.  */
       char *in, *out, *ref;
       /* IN points to where in the line we are scanning.
          OUT points to where in the line we are writing.
          When we collapse a backslash-newline combination,
          IN gets ahead of OUT.  */
+         OUT points to where in the line we are writing.
+         When we collapse a backslash-newline combination,
+         IN gets ahead of OUT.  */
       in = out = cmds->command_lines[i];
       while ((ref = strchr (in, '$')) != 0)
+        {
+          ++ref;                /* Move past the $.  */
+          if (out != in)
+            /* Copy the text between the end of the last chunk
+               we processed (where IN points) and the new chunk
+               we are about to process (where REF points).  */
+            memmove (out, in, ref - in);
+          /* Move both pointers past the boring stuff.  */
+          out += ref - in;
+          in = ref;
+          if (*ref == '(' || *ref == '{')
+            {
+              char openparen = *ref;
+              char closeparen = openparen == '(' ? ')' : '}';
+              int count;
+              char *p;
+              *out++ = *in++;   /* Copy OPENPAREN.  */
+              /* IN now points past the opening paren or brace.
+                 Count parens or braces until it is matched.  */
+              count = 0;
+              while (*in != '\0')
+                {
+                  if (*in == closeparen && --count < 0)
+                    break;
+                  else if (*in == '\\' && in[1] == '\n')
+                    {
+                      /* We have found a backslash-newline inside a
+                         variable or function reference.  Eat it and
+                         any following whitespace.  */
+                      int quoted = 0;
+                      for (p = in - 1; p > ref && *p == '\\'; --p)
+                        quoted = !quoted;
+                      if (quoted)
+                        /* There were two or more backslashes, so this is
+                           not really a continuation line.  We don't collapse
+                           the quoting backslashes here as is done in
+                           collapse_continuations, because the line will
+                           be collapsed again after expansion.  */
+                        *out++ = *in++;
+                      else
+                        {
+                          /* Skip the backslash, newline and
+                             any following whitespace.  */
+                          in = next_token (in + 2);
+                          /* Discard any preceding whitespace that has
+                             already been written to the output.  */
+                          while (out > ref
+                                 && isblank ((unsigned char)out[-1]))
+                            --out;
+                          /* Replace it all with a single space.  */
+                          *out++ = ' ';
+                        }
+                    }
+                  else
+                    {
+                      if (*in == openparen)
+                        ++count;
+                      *out++ = *in++;
+                    }
+                }
+            }
+        }
+        {
+          ++ref;                /* Move past the $.  */
+          if (out != in)
+            /* Copy the text between the end of the last chunk
+               we processed (where IN points) and the new chunk
+               we are about to process (where REF points).  */
+            memmove (out, in, ref - in);
+          /* Move both pointers past the boring stuff.  */
+          out += ref - in;
+          in = ref;
+          if (*ref == '(' || *ref == '{')
+            {
+              char openparen = *ref;
+              char closeparen = openparen == '(' ? ')' : '}';
+              char *outref;
+              int count;
+              char *p;
+              *out++ = *in++;   /* Copy OPENPAREN.  */
+              outref = out;
+              /* IN now points past the opening paren or brace.
+                 Count parens or braces until it is matched.  */
+              count = 0;
+              while (*in != '\0')
+                {
+                  if (*in == closeparen && --count < 0)
+                    break;
+                  else if (*in == '\\' && in[1] == '\n')
+                    {
+                      /* We have found a backslash-newline inside a
+                         variable or function reference.  Eat it and
+                         any following whitespace.  */
+                      int quoted = 0;
+                      for (p = in - 1; p > ref && *p == '\\'; --p)
+                        quoted = !quoted;
+                      if (quoted)
+                        /* There were two or more backslashes, so this is
+                           not really a continuation line.  We don't collapse
+                           the quoting backslashes here as is done in
+                           collapse_continuations, because the line will
+                           be collapsed again after expansion.  */
+                        *out++ = *in++;
+                      else
+                        {
+                          /* Skip the backslash, newline, and whitespace.  */
+                          in += 2;
+                          NEXT_TOKEN (in);
+                          /* Discard any preceding whitespace that has
+                             already been written to the output.  */
+                          while (out > outref && ISBLANK (out[-1]))
+                            --out;
+                          /* Replace it all with a single space.  */
+                          *out++ = ' ';
+                        }
+                    }
+                  else
+                    {
+                      if (*in == openparen)
+                        ++count;
+                      *out++ = *in++;
+                    }
+                }
+            }
+        }
       /* There are no more references in this line to worry about.
          Copy the remaining uninteresting text to the output.  */
+         Copy the remaining uninteresting text to the output.  */
       if (out != in)
         memmove (out, in, strlen (in) + 1);
+        memmove (out, in, strlen (in) + 1);
       /* Finally, expand the line.  */
+      cmds->fileinfo.offset = i;
       lines[i] = allocated_variable_expand_for_file (cmds->command_lines[i],
+                                                     file);
+    }
+  /* Start the command sequence, record it in a new
+     `struct child', and add that to the chain.  */
+  c = xcalloc (sizeof (struct child));
+  c->file = file;
+                                                     file);
+    }
+  cmds->fileinfo.offset = 0;
   c->command_lines = lines;
-  c->sh_batch_file = NULL;
-  /* Cache dontcare flag because file->dontcare can be changed once we
-     return. Check dontcare inheritance mechanism for details.  */
-  c->dontcare = file->dontcare;
   /* Fetch the first command line to be run.  */
 …
      this is where the old parallel job code waits, so...  */
   else if (job_fds[0] >= 0)
+  else if (jobserver_enabled ())
     while (1)
+      {
+        char token;
+        int got_token;
+        int saved_errno;
+        int got_token;
         DB (DB_JOBS, ("Need a job token; we %shave children\n",
 …
           break;
+        /* Read a token.  As long as there's no token available we'll block.
+           We enable interruptible system calls before the read(2) so that if
+           we get a SIGCHLD while we're waiting, we'll return with EINTR and
+           we can process the death(s) and return tokens to the free pool.
+           Once we return from the read, we immediately reinstate restartable
+           system calls.  This allows us to not worry about checking for
+           EINTR on all the other system calls in the program.
+           There is one other twist: there is a span between the time
+           reap_children() does its last check for dead children and the time
+           the read(2) call is entered, below, where if a child dies we won't
+           notice.  This is extremely serious as it could cause us to
+           deadlock, given the right set of events.
+           To avoid this, we do the following: before we reap_children(), we
+           dup(2) the read FD on the jobserver pipe.  The read(2) call below
+           uses that new FD.  In the signal handler, we close that FD.  That
+           way, if a child dies during the section mentioned above, the
+           read(2) will be invoked with an invalid FD and will return
+           immediately with EBADF.  */
+        /* Make sure we have a dup'd FD.  */
+        if (job_rfd < 0)
+          {
+            DB (DB_JOBS, ("Duplicate the job FD\n"));
+            job_rfd = dup (job_fds[0]);
+          }
+        /* Prepare for jobserver token acquisition.  */
+        jobserver_pre_acquire ();
         /* Reap anything that's currently waiting.  */
 …
         /* Kick off any jobs we have waiting for an opportunity that
            can run now (ie waiting for load). */
+           can run now (i.e., waiting for load). */
         start_waiting_jobs ();
+        /* If our "free" slot has become available, use it; we don't need an
+           actual token.  */
+        /* If our "free" slot is available, use it; we don't need a token.  */
         if (!jobserver_tokens)
           break;
 …
            waiting for a token. */
         if (!children)
+          fatal (NILF, "INTERNAL: no children as we go to sleep on read\n");
+        /* Set interruptible system calls, and read() for a job token.  */
+        set_child_handler_action_flags (1, waiting_jobs != NULL);
+        got_token = read (job_rfd, &token, 1);
+        saved_errno = errno;
+        set_child_handler_action_flags (0, waiting_jobs != NULL);
+          O (fatal, NILF, "INTERNAL: no children as we go to sleep on read\n");
+        /* Get a token.  */
+        got_token = jobserver_acquire (waiting_jobs != NULL);
         /* If we got one, we're done here.  */
         if (got_token == 1)
+        if (got_token == 1)
+          {
             DB (DB_JOBS, (_("Obtained token for child %p (%s).\n"),
 …
             break;
+          }
-        /* If the error _wasn't_ expected (EINTR or EBADF), punt.  Otherwise,
-           go back and reap_children(), and try again.  */
-        errno = saved_errno;
-        if (errno != EINTR && errno != EBADF)
-          pfatal_with_name (_("read jobs pipe"));
-        if (errno == EBADF)
-          DB (DB_JOBS, ("Read returned EBADF.\n"));
+      }
 #endif
   ++jobserver_tokens;
+  /* Trace the build.
+     Use message here so that changes to working directories are logged.  */
+  if (trace_flag)
+    {
+      char *newer = allocated_variable_expand_for_file ("$?", c->file);
+      const char *nm;
+      if (! cmds->fileinfo.filenm)
+        nm = _("<builtin>");
+      else
+        {
+          char *n = alloca (strlen (cmds->fileinfo.filenm) + 1 + 11 + 1);
+          sprintf (n, "%s:%lu", cmds->fileinfo.filenm, cmds->fileinfo.lineno);
+          nm = n;
+        }
+      if (newer[0] == '\0')
+        OSS (message, 0,
+             _("%s: target '%s' does not exist"), nm, c->file->name);
+      else
+        OSSS (message, 0,
+              _("%s: update target '%s' due to: %s"), nm, c->file->name, newer);
+      free (newer);
+    }
   /* The job is now primed.  Start it running.
      (This will notice if there is in fact no recipe.)  */
-  if (cmds->fileinfo.filenm)
-    DB (DB_BASIC, (_("Invoking recipe from %s:%lu to update target `%s'.\n"),
-                   cmds->fileinfo.filenm, cmds->fileinfo.lineno,
-                   c->file->name));
-  else
-    DB (DB_BASIC, (_("Invoking builtin recipe to update target `%s'.\n"),
-                   c->file->name));
   start_waiting_job (c);
   if (job_slots == 1 || not_parallel)
     /* Since there is only one job slot, make things run linearly.
        Wait for the child to die, setting the state to `cs_finished'.  */
+       Wait for the child to die, setting the state to 'cs_finished'.  */
     while (file->command_state == cs_running)
       reap_children (1, 0);
+  OUTPUT_UNSET ();
   return;
+}
 …
       /* There are no more lines in the expansion of this line.  */
       if (child->command_line == child->file->cmds->ncommand_lines)
+        {
+          /* There are no more lines to be expanded.  */
+          child->command_ptr = 0;
+          return 0;
+        }
+        {
+          /* There are no more lines to be expanded.  */
+          child->command_ptr = 0;
+          child->file->cmds->fileinfo.offset = 0;
+          return 0;
+        }
       else
+        /* Get the next line to run.  */
+        child->command_ptr = child->command_lines[child->command_line++];
+    }
+        /* Get the next line to run.  */
+        child->command_ptr = child->command_lines[child->command_line++];
+    }
+  child->file->cmds->fileinfo.offset = child->command_line - 1;
   return 1;
+}
 …
       /* Complain only once for the same error.  */
       if (lossage == -1 || errno != lossage)
+        {
           if (errno == 0)
             /* An errno value of zero means getloadavg is just unsupported.  */
             error (NILF,
                    _("cannot enforce load limits on this operating system"));
           else
             perror_with_name (_("cannot enforce load limit: "), "getloadavg");
+        }
+        {
+          if (errno == 0)
+            /* An errno value of zero means getloadavg is just unsupported.  */
+            O (error, NILF,
+               _("cannot enforce load limits on this operating system"));
+          else
+            perror_with_name (_("cannot enforce load limit: "), "getloadavg");
+        }
       lossage = errno;
       load = 0;
 …
       /* Try to start that job.  We break out of the loop as soon
          as start_waiting_job puts one back on the waiting list.  */
+         as start_waiting_job puts one back on the waiting list.  */
+    }
   while (start_waiting_job (job) && waiting_jobs != 0);
 …
 # if defined __EMX__
 int
 child_execute_job (int stdin_fd, int stdout_fd, char **argv, char **envp)
+child_execute_job (struct output *out, int good_stdin, char **argv, char **envp)
+{
   int pid;
+  /* stdin_fd == 0 means: nothing to do for stdin;
+     stdout_fd == 1 means: nothing to do for stdout */
+  int save_stdin = (stdin_fd != 0) ? dup (0) : 0;
+  int save_stdout = (stdout_fd != 1) ? dup (1): 1;
+  /* < 0 only if dup() failed */
+  if (save_stdin < 0)
+    fatal (NILF, _("no more file handles: could not duplicate stdin\n"));
+  if (save_stdout < 0)
+    fatal (NILF, _("no more file handles: could not duplicate stdout\n"));
+  /* Close unnecessary file handles for the child.  */
+  if (save_stdin != 0)
+    CLOSE_ON_EXEC (save_stdin);
+  if (save_stdout != 1)
+    CLOSE_ON_EXEC (save_stdout);
+  /* Connect the pipes to the child process.  */
+  if (stdin_fd != 0)
+    (void) dup2 (stdin_fd, 0);
+  if (stdout_fd != 1)
+    (void) dup2 (stdout_fd, 1);
+  /* stdin_fd and stdout_fd must be closed on exit because we are
+     still in the parent process */
+  if (stdin_fd != 0)
+    CLOSE_ON_EXEC (stdin_fd);
+  if (stdout_fd != 1)
+    CLOSE_ON_EXEC (stdout_fd);
+  int fdin = good_stdin ? FD_STDIN : get_bad_stdin ();
+  int fdout = FD_STDOUT;
+  int fderr = FD_STDERR;
+  int save_fdin = -1;
+  int save_fdout = -1;
+  int save_fderr = -1;
+  /* Divert child output if we want to capture output.  */
+  if (out && out->syncout)
+    {
+      if (out->out >= 0)
+        fdout = out->out;
+      if (out->err >= 0)
+        fderr = out->err;
+    }
+  /* For each FD which needs to be redirected first make a dup of the standard
+     FD to save and mark it close on exec so our child won't see it.  Then
+     dup2() the standard FD to the redirect FD, and also mark the redirect FD
+     as close on exec. */
+  if (fdin != FD_STDIN)
+    {
+      save_fdin = dup (FD_STDIN);
+      if (save_fdin < 0)
+        O (fatal, NILF, _("no more file handles: could not duplicate stdin\n"));
+      CLOSE_ON_EXEC (save_fdin);
+      dup2 (fdin, FD_STDIN);
+      CLOSE_ON_EXEC (fdin);
+    }
+  if (fdout != FD_STDOUT)
+    {
+      save_fdout = dup (FD_STDOUT);
+      if (save_fdout < 0)
+        O (fatal, NILF,
+           _("no more file handles: could not duplicate stdout\n"));
+      CLOSE_ON_EXEC (save_fdout);
+      dup2 (fdout, FD_STDOUT);
+      CLOSE_ON_EXEC (fdout);
+    }
+  if (fderr != FD_STDERR)
+    {
+      if (fderr != fdout)
+        {
+          save_fderr = dup (FD_STDERR);
+          if (save_fderr < 0)
+            O (fatal, NILF,
+               _("no more file handles: could not duplicate stderr\n"));
+          CLOSE_ON_EXEC (save_fderr);
+        }
+      dup2 (fderr, FD_STDERR);
+      CLOSE_ON_EXEC (fderr);
+    }
   /* Run the command.  */
   pid = exec_command (argv, envp);
   /* Restore stdout/stdin of the parent and close temporary FDs.  */
   if (stdin_fd != 0)
+    {
       if (dup2 (save_stdin, 0) != 0)
         fatal (NILF, _("Could not restore stdin\n"));
+  /* Restore stdout/stdin/stderr of the parent and close temporary FDs.  */
+  if (save_fdin >= 0)
+    {
+      if (dup2 (save_fdin, FD_STDIN) != FD_STDIN)
+        O (fatal, NILF, _("Could not restore stdin\n"));
       else
         close (save_stdin);
+    }
   if (stdout_fd != 1)
+    {
       if (dup2 (save_stdout, 1) != 1)
         fatal (NILF, _("Could not restore stdout\n"));
+        close (save_fdin);
+    }
+  if (save_fdout >= 0)
+    {
+      if (dup2 (save_fdout, FD_STDOUT) != FD_STDOUT)
+        O (fatal, NILF, _("Could not restore stdout\n"));
       else
+        close (save_stdout);
+        close (save_fdout);
+    }
+  if (save_fderr >= 0)
+    {
+      if (dup2 (save_fderr, FD_STDERR) != FD_STDERR)
+        O (fatal, NILF, _("Could not restore stderr\n"));
+      else
+        close (save_fderr);
+    }
 …
 #elif !defined (_AMIGA) && !defined (__MSDOS__) && !defined (VMS)
+/* UNIX:
+   Replace the current process with one executing the command in ARGV.
+   STDIN_FD and STDOUT_FD are used as the process's stdin and stdout; ENVP is
+   the environment of the new program.  This function does not return.  */
+void
+child_execute_job (int stdin_fd, int stdout_fd, char **argv, char **envp)
+/* POSIX:
+   Create a child process executing the command in ARGV.
+   ENVP is the environment of the new program.  Returns the PID or -1.  */
+int
+child_execute_job (struct output *out, int good_stdin, char **argv, char **envp)
+{
+  if (stdin_fd != 0)
+    (void) dup2 (stdin_fd, 0);
+  if (stdout_fd != 1)
+    (void) dup2 (stdout_fd, 1);
+  if (stdin_fd != 0)
+    (void) close (stdin_fd);
+  if (stdout_fd != 1)
+    (void) close (stdout_fd);
+  int r;
+  int pid;
+  int fdin = good_stdin ? FD_STDIN : get_bad_stdin ();
+  int fdout = FD_STDOUT;
+  int fderr = FD_STDERR;
+  /* Divert child output if we want to capture it.  */
+  if (out && out->syncout)
+    {
+      if (out->out >= 0)
+        fdout = out->out;
+      if (out->err >= 0)
+        fderr = out->err;
+    }
+  pid = vfork();
+  if (pid != 0)
+    return pid;
+  /* We are the child.  */
+  unblock_sigs ();
+#ifdef SET_STACK_SIZE
+  /* Reset limits, if necessary.  */
+  if (stack_limit.rlim_cur)
+    setrlimit (RLIMIT_STACK, &stack_limit);
+#endif
+  /* For any redirected FD, dup2() it to the standard FD.
+     They are all marked close-on-exec already.  */
+  if (fdin != FD_STDIN)
+    EINTRLOOP (r, dup2 (fdin, FD_STDIN));
+  if (fdout != FD_STDOUT)
+    EINTRLOOP (r, dup2 (fdout, FD_STDOUT));
+  if (fderr != FD_STDERR)
+    EINTRLOOP (r, dup2 (fderr, FD_STDERR));
   /* Run the command.  */
 …
   HANDLE hPID;
   HANDLE hWaitPID;
-  int err = 0;
   int exit_code = EXIT_FAILURE;
   /* make sure CreateProcess() has Path it needs */
   sync_Path_environment();
+  sync_Path_environment ();
   /* launch command */
   hPID = process_easy(argv, envp);
+  hPID = process_easy (argv, envp, -1, -1);
   /* make sure launch ok */
 …
+    {
       int i;
+      fprintf(stderr,
+              _("process_easy() failed to launch process (e=%ld)\n"),
+              process_last_err(hPID));
+      fprintf (stderr, _("process_easy() failed to launch process (e=%ld)\n"),
+               process_last_err (hPID));
       for (i = 0; argv[i]; i++)
           fprintf(stderr, "%s ", argv[i]);
       fprintf(stderr, _("\nCounted %d args in failed launch\n"), i);
       exit(EXIT_FAILURE);
+          fprintf (stderr, "%s ", argv[i]);
+      fprintf (stderr, _("\nCounted %d args in failed launch\n"), i);
+      exit (EXIT_FAILURE);
+    }
   /* wait and reap last child */
   hWaitPID = process_wait_for_any();
+  hWaitPID = process_wait_for_any (1, 0);
   while (hWaitPID)
+    {
       /* was an error found on this process? */
       err = process_last_err(hWaitPID);
+      int err = process_last_err (hWaitPID);
       /* get exit data */
       exit_code = process_exit_code(hWaitPID);
+      exit_code = process_exit_code (hWaitPID);
       if (err)
           fprintf(stderr, "make (e=%d, rc=%d): %s",
                   err, exit_code, map_windows32_error_to_string(err));
+          fprintf (stderr, "make (e=%d, rc=%d): %s",
+                   err, exit_code, map_windows32_error_to_string (err));
       /* cleanup process */
       process_cleanup(hWaitPID);
+      process_cleanup (hWaitPID);
       /* expect to find only last pid, warn about other pids reaped */
 …
           break;
       else
+        {
           char *pidstr = xstrdup (pid2str ((pid_t)hWaitPID));
           fprintf(stderr,
                   _("make reaped child pid %s, still waiting for pid %s\n"),
                   pidstr, pid2str ((pid_t)hPID));
           free (pidstr);
+        }
+        {
+          char *pidstr = xstrdup (pid2str ((pid_t)hWaitPID));
+          fprintf (stderr,
+                   _("make reaped child pid %s, still waiting for pid %s\n"),
+                   pidstr, pid2str ((pid_t)hPID));
+          free (pidstr);
+        }
+    }
   /* return child's exit code as our exit code */
   exit(exit_code);
+  exit (exit_code);
 #else  /* !WINDOWS32 */
 …
 # ifdef __EMX__
   /* Run the program.  */
   pid = spawnvpe (P_NOWAIT, argv[0], argv, envp);
   if (pid >= 0)
     return pid;
 …
 # else
   /* Run the program.  */
   environ = envp;
 …
+    {
     case ENOENT:
+      error (NILF, _("%s: Command not found"), argv[0]);
+      /* We are in the child: don't use the output buffer.
+         It's not right to run fprintf() here!  */
+      if (makelevel == 0)
+        fprintf (stderr, _("%s: %s: Command not found\n"), program, argv[0]);
+      else
+        fprintf (stderr, _("%s[%u]: %s: Command not found\n"),
+                 program, makelevel, argv[0]);
       break;
     case ENOEXEC:
+      {
+        /* The file is not executable.  Try it as a shell script.  */
+        extern char *getenv ();
+        char *shell;
+        char **new_argv;
+        int argc;
+        /* The file is not executable.  Try it as a shell script.  */
+        const char *shell;
+        char **new_argv;
+        int argc;
         int i=1;
 # ifdef __EMX__
         /* Do not use $SHELL from the environment */
         struct variable *p = lookup_variable ("SHELL", 5);
         if (p)
           shell = p->value;
+        struct variable *p = lookup_variable ("SHELL", 5);
+        if (p)
+          shell = p->value;
         else
           shell = 0;
 # else
         shell = getenv ("SHELL");
+        shell = getenv ("SHELL");
 # endif
         if (shell == 0)
           shell = default_shell;
         argc = 1;
         while (argv[argc] != 0)
           ++argc;
+        if (shell == 0)
+          shell = default_shell;
+        argc = 1;
+        while (argv[argc] != 0)
+          ++argc;
 # ifdef __EMX__
 …
 # endif
         new_argv = alloca ((1 + argc + 1) * sizeof (char *));
         new_argv[0] = shell;
+        new_argv = alloca ((1 + argc + 1) * sizeof (char *));
+        new_argv[0] = (char *)shell;
 # ifdef __EMX__
 …
         new_argv[i] = argv[0];
         while (argc > 0)
+          {
             new_argv[i + argc] = argv[argc];
             --argc;
+          }
+        while (argc > 0)
+          {
+            new_argv[i + argc] = argv[argc];
+            --argc;
+          }
 # ifdef __EMX__
         pid = spawnvpe (P_NOWAIT, shell, new_argv, envp);
         if (pid >= 0)
+        pid = spawnvpe (P_NOWAIT, shell, new_argv, envp);
+        if (pid >= 0)
           break;
 # else
         execvp (shell, new_argv);
+        execvp (shell, new_argv);
 # endif
         if (errno == ENOENT)
           error (NILF, _("%s: Shell program not found"), shell);
         else
           perror_with_name ("execvp: ", shell);
         break;
+        if (errno == ENOENT)
+          OS (error, NILF, _("%s: Shell program not found"), shell);
+        else
+          perror_with_name ("execvp: ", shell);
+        break;
+      }
 …
     case EINVAL:
       /* this nasty error was driving me nuts :-( */
       error (NILF, _("spawnvpe: environment space might be exhausted"));
+      O (error, NILF, _("spawnvpe: environment space might be exhausted"));
       /* FALLTHROUGH */
 # endif
 …
+}
 #else /* On Amiga */
+void exec_command (char **argv)
+void
+exec_command (char **argv)
+{
   MyExecute (argv);
 …
 /* Figure out the argument list necessary to run LINE as a command.  Try to
    avoid using a shell.  This routine handles only ' quoting, and " quoting
    when no backslash, $ or ` characters are seen in the quotes.  Starting
+   when no backslash, $ or ' characters are seen in the quotes.  Starting
    quotes may be escaped with a backslash.  If any of the characters in
    sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[]
+   sh_chars is seen, or any of the builtin commands listed in sh_cmds
    is the first word of a line, the shell is used.
 …
 static char **
 construct_command_argv_internal (char *line, char **restp, char *shell,
                                  char *shellflags, char *ifs, int flags,
                                  char **batch_filename_ptr)
+construct_command_argv_internal (char *line, char **restp, const char *shell,
+                                 const char *shellflags, const char *ifs,
+                                 int flags, char **batch_filename UNUSED)
+{
 #ifdef __MSDOS__
   /* MSDOS supports both the stock DOS shell and ports of Unixy shells.
      We call `system' for anything that requires ``slow'' processing,
+     We call 'system' for anything that requires ''slow'' processing,
      because DOS shells are too dumb.  When $SHELL points to a real
      (unix-style) shell, `system' just calls it to do everything.  When
      $SHELL points to a DOS shell, `system' does most of the work
+     (unix-style) shell, 'system' just calls it to do everything.  When
+     $SHELL points to a DOS shell, 'system' does most of the work
      internally, calling the shell only for its internal commands.
      However, it looks on the $PATH first, so you can e.g. have an
      external command named `mkdir'.
      Since we call `system', certain characters and commands below are
+     external command named 'mkdir'.
+     Since we call 'system', certain characters and commands below are
      actually not specific to COMMAND.COM, but to the DJGPP implementation
      of `system'.  In particular:
+     of 'system'.  In particular:
        The shell wildcard characters are in DOS_CHARS because they will
        not be expanded if we call the child via `spawnXX'.
        The `;' is in DOS_CHARS, because our `system' knows how to run
+       not be expanded if we call the child via 'spawnXX'.
+       The ';' is in DOS_CHARS, because our 'system' knows how to run
        multiple commands on a single line.
 …
        won't have to tell one from another and have one more set of
        commands and special characters.  */
+  static char sh_chars_dos[] = "*?[];|<>%^&()";
+  static char *sh_cmds_dos[] = { "break", "call", "cd", "chcp", "chdir", "cls",
+                                 "copy", "ctty", "date", "del", "dir", "echo",
+                                 "erase", "exit", "for", "goto", "if", "md",
+                                 "mkdir", "path", "pause", "prompt", "rd",
+                                 "rmdir", "rem", "ren", "rename", "set",
+                                 "shift", "time", "type", "ver", "verify",
+                                 "vol", ":", 0 };
+  static char sh_chars_sh[]  = "#;\"*?[]&|<>(){}$`^";
+  static char *sh_cmds_sh[]  = { "cd", "echo", "eval", "exec", "exit", "login",
+                                 "logout", "set", "umask", "wait", "while",
+                                 "for", "case", "if", ":", ".", "break",
+                                 "continue", "export", "read", "readonly",
+                                 "shift", "times", "trap", "switch", "unset",
+                                 "ulimit", 0 };
+  char *sh_chars;
+  char **sh_cmds;
+  static const char *sh_chars_dos = "*?[];|<>%^&()";
+  static const char *sh_cmds_dos[] =
+    { "break", "call", "cd", "chcp", "chdir", "cls", "copy", "ctty", "date",
+      "del", "dir", "echo", "erase", "exit", "for", "goto", "if", "md",
+      "mkdir", "path", "pause", "prompt", "rd", "rmdir", "rem", "ren",
+      "rename", "set", "shift", "time", "type", "ver", "verify", "vol", ":",
+};
+  static const char *sh_chars_sh = "#;\"*?[]&|<>(){}$`^";
+  static const char *sh_cmds_sh[] =
+    { "cd", "echo", "eval", "exec", "exit", "login", "logout", "set", "umask",
+      "wait", "while", "for", "case", "if", ":", ".", "break", "continue",
+      "export", "read", "readonly", "shift", "times", "trap", "switch",
+      "unset", "ulimit", 0 };
+  const char *sh_chars;
+  const char **sh_cmds;
 #elif defined (__EMX__)
+  static char sh_chars_dos[] = "*?[];|<>%^&()";
+  static char *sh_cmds_dos[] = { "break", "call", "cd", "chcp", "chdir", "cls",
+                                 "copy", "ctty", "date", "del", "dir", "echo",
+                                 "erase", "exit", "for", "goto", "if", "md",
+                                 "mkdir", "path", "pause", "prompt", "rd",
+                                 "rmdir", "rem", "ren", "rename", "set",
+                                 "shift", "time", "type", "ver", "verify",
+                                 "vol", ":", 0 };
+  static char sh_chars_os2[] = "*?[];|<>%^()\"'&";
+  static char *sh_cmds_os2[] = { "call", "cd", "chcp", "chdir", "cls", "copy",
+                             "date", "del", "detach", "dir", "echo",
+                             "endlocal", "erase", "exit", "for", "goto", "if",
+                             "keys", "md", "mkdir", "move", "path", "pause",
+                             "prompt", "rd", "rem", "ren", "rename", "rmdir",
+                             "set", "setlocal", "shift", "start", "time",
+                             "type", "ver", "verify", "vol", ":", 0 };
+  static char sh_chars_sh[]  = "#;\"*?[]&|<>(){}$`^~'";
+  static char *sh_cmds_sh[]  = { "echo", "cd", "eval", "exec", "exit", "login",
+                                 "logout", "set", "umask", "wait", "while",
+                                 "for", "case", "if", ":", ".", "break",
+                                 "continue", "export", "read", "readonly",
+                                 "shift", "times", "trap", "switch", "unset",
+};
+  char *sh_chars;
+  char **sh_cmds;
+  static const char *sh_chars_dos = "*?[];|<>%^&()";
+  static const char *sh_cmds_dos[] =
+    { "break", "call", "cd", "chcp", "chdir", "cls", "copy", "ctty", "date",
+      "del", "dir", "echo", "erase", "exit", "for", "goto", "if", "md",
+      "mkdir", "path", "pause", "prompt", "rd", "rmdir", "rem", "ren",
+      "rename", "set", "shift", "time", "type", "ver", "verify", "vol", ":",
+};
+  static const char *sh_chars_os2 = "*?[];|<>%^()\"'&";
+  static const char *sh_cmds_os2[] =
+    { "call", "cd", "chcp", "chdir", "cls", "copy", "date", "del", "detach",
+      "dir", "echo", "endlocal", "erase", "exit", "for", "goto", "if", "keys",
+      "md", "mkdir", "move", "path", "pause", "prompt", "rd", "rem", "ren",
+      "rename", "rmdir", "set", "setlocal", "shift", "start", "time", "type",
+      "ver", "verify", "vol", ":", 0 };
+  static const char *sh_chars_sh = "#;\"*?[]&|<>(){}$`^~'";
+  static const char *sh_cmds_sh[] =
+    { "echo", "cd", "eval", "exec", "exit", "login", "logout", "set", "umask",
+      "wait", "while", "for", "case", "if", ":", ".", "break", "continue",
+      "export", "read", "readonly", "shift", "times", "trap", "switch",
+      "unset", 0 };
+  const char *sh_chars;
+  const char **sh_cmds;
 #elif defined (_AMIGA)
   static char sh_chars[] = "#;\"|<>()?*$`";
   static char *sh_cmds[] = { "cd", "eval", "if", "delete", "echo", "copy",
                              "rename", "set", "setenv", "date", "makedir",
                              "skip", "else", "endif", "path", "prompt",
+                             "unset", "unsetenv", "version",
+};
+  static const char *sh_chars = "#;\"|<>()?*$`";
+  static const char *sh_cmds[] =
+    { "cd", "eval", "if", "delete", "echo", "copy", "rename", "set", "setenv",
+      "date", "makedir", "skip", "else", "endif", "path", "prompt", "unset",
+      "unsetenv", "version", 0 };
 #elif defined (WINDOWS32)
+  static char sh_chars_dos[] = "\"|&<>";
+  static char *sh_cmds_dos[] = { "assoc", "break", "call", "cd", "chcp",
+                                 "chdir", "cls", "color", "copy", "ctty",
+                                 "date", "del", "dir", "echo", "echo.",
+                                 "endlocal", "erase", "exit", "for", "ftype",
+                                 "goto", "if", "if", "md", "mkdir", "path",
+                                 "pause", "prompt", "rd", "rem", "ren",
+                                 "rename", "rmdir", "set", "setlocal",
+                                 "shift", "time", "title", "type", "ver",
+                                 "verify", "vol", ":", 0 };
+  static char sh_chars_sh[] = "#;\"*?[]&|<>(){}$`^";
+  static char *sh_cmds_sh[] = { "cd", "eval", "exec", "exit", "login",
+                             "logout", "set", "umask", "wait", "while", "for",
+                             "case", "if", ":", ".", "break", "continue",
+                             "export", "read", "readonly", "shift", "times",
+                             "trap", "switch", "test",
+  /* We used to have a double quote (") in sh_chars_dos[] below, but
+     that caused any command line with quoted file names be run
+     through a temporary batch file, which introduces command-line
+     limit of 4K charcaters imposed by cmd.exe.  Since CreateProcess
+     can handle quoted file names just fine, removing the quote lifts
+     the limit from a very frequent use case, because using quoted
+     file names is commonplace on MS-Windows.  */
+  static const char *sh_chars_dos = "|&<>";
+  static const char *sh_cmds_dos[] =
+    { "assoc", "break", "call", "cd", "chcp", "chdir", "cls", "color", "copy",
+      "ctty", "date", "del", "dir", "echo", "echo.", "endlocal", "erase",
+      "exit", "for", "ftype", "goto", "if", "if", "md", "mkdir", "move",
+      "path", "pause", "prompt", "rd", "rem", "ren", "rename", "rmdir",
+      "set", "setlocal", "shift", "time", "title", "type", "ver", "verify",
+      "vol", ":", 0 };
+  static const char *sh_chars_sh = "#;\"*?[]&|<>(){}$`^";
+  static const char *sh_cmds_sh[] =
+    { "cd", "eval", "exec", "exit", "login", "logout", "set", "umask", "wait",
+      "while", "for", "case", "if", ":", ".", "break", "continue", "export",
+      "read", "readonly", "shift", "times", "trap", "switch", "test",
 #ifdef BATCH_MODE_ONLY_SHELL
+                 "echo",
+#endif
+};
+  char*  sh_chars;
+  char** sh_cmds;
+      "echo",
+#endif
+};
+  const char *sh_chars;
+  const char **sh_cmds;
 #elif defined(__riscos__)
   static char sh_chars[] = "";
   static char *sh_cmds[] = { 0 };
+  static const char *sh_chars = "";
+  static const char *sh_cmds[] = { 0 };
 #else  /* must be UNIX-ish */
+  static char sh_chars[] = "#;\"*?[]&|<>(){}$`^~!";
+  static char *sh_cmds[] = { ".", ":", "break", "case", "cd", "continue",
+                             "eval", "exec", "exit", "export", "for", "if",
+                             "login", "logout", "read", "readonly", "set",
+                             "shift", "switch", "test", "times", "trap",
+                             "ulimit", "umask", "unset", "wait", "while", 0 };
+  static const char *sh_chars = "#;\"*?[]&|<>(){}$`^~!";
+  static const char *sh_cmds[] =
+    { ".", ":", "break", "case", "cd", "continue", "eval", "exec", "exit",
+      "export", "for", "if", "login", "logout", "read", "readonly", "set",
+      "shift", "switch", "test", "times", "trap", "ulimit", "umask", "unset",
+      "wait", "while", 0 };
 # ifdef HAVE_DOS_PATHS
   /* This is required if the MSYS/Cygwin ports (which do not define
      WINDOWS32) are compiled with HAVE_DOS_PATHS defined, which uses
+     sh_chars_sh[] directly (see below).  */
+  static char *sh_chars_sh = sh_chars;
+# endif  /* HAVE_DOS_PATHS */
+     sh_chars_sh directly (see below).  The value must be identical
+     to that of sh_chars immediately above.  */
+  static const char *sh_chars_sh =  "#;\"*?[]&|<>(){}$`^~!";
+# endif  /* HAVE_DOS_PATHS */
 #endif
   int i;
   char *p;
+#ifndef NDEBUG
+  char *end;
+#endif
   char *ap;
+  char *end;
+  const char *cap;
+  const char *cp;
   int instring, word_has_equals, seen_nonequals, last_argument_was_empty;
   char **new_argv = 0;
 …
   int slow_flag = 0;
+  if (!unixy_shell) {
+    sh_cmds = sh_cmds_dos;
+    sh_chars = sh_chars_dos;
+  } else {
+    sh_cmds = sh_cmds_sh;
+    sh_chars = sh_chars_sh;
+  }
+  if (!unixy_shell)
+    {
+      sh_cmds = sh_cmds_dos;
+      sh_chars = sh_chars_dos;
+    }
+  else
+    {
+      sh_cmds = sh_cmds_sh;
+      sh_chars = sh_chars_sh;
+    }
 #endif /* WINDOWS32 */
 …
     *restp = NULL;
   /* Make sure not to bother processing an empty line.  */
   while (isblank ((unsigned char)*line))
+  /* Make sure not to bother processing an empty line but stop at newline.  */
+  while (ISBLANK (*line))
     ++line;
   if (*line == '\0')
     return 0;
+  if (shellflags == 0)
+    shellflags = posix_pedantic ? "-ec" : "-c";
   /* See if it is safe to parse commands internally.  */
 …
     slow_flag = strcmp ((s1 ? s1 : ""), (s2 ? s2 : ""));
+    if (s1)
+      free (s1);
+    if (s2)
+      free (s2);
+    free (s1);
+    free (s2);
+  }
   if (slow_flag)
 …
       extern int _is_unixy_shell (const char *_path);
       DB (DB_BASIC, (_("$SHELL changed (was `%s', now `%s')\n"),
+      DB (DB_BASIC, (_("$SHELL changed (was '%s', now '%s')\n"),
                      default_shell, shell));
       unixy_shell = _is_unixy_shell (shell);
 …
 #endif /* not WINDOWS32 */
   if (ifs != 0)
     for (ap = ifs; *ap != '\0'; ++ap)
       if (*ap != ' ' && *ap != '\t' && *ap != '\n')
         goto slow;
   if (shellflags != 0)
+  if (ifs)
+    for (cap = ifs; *cap != '\0'; ++cap)
+      if (*cap != ' ' && *cap != '\t' && *cap != '\n')
+        goto slow;
+  if (shellflags)
     if (shellflags[0] != '-'
         || ((shellflags[1] != 'c' || shellflags[2] != '\0')
 …
   /* All the args can fit in a buffer as big as LINE is.   */
   ap = new_argv[0] = argstr = xmalloc (i);
+#ifndef NDEBUG
   end = ap + i;
+#endif
   /* I is how many complete arguments have been found.  */
 …
       if (instring)
+        {
           /* Inside a string, just copy any char except a closing quote
              or a backslash-newline combination.  */
           if (*p == instring)
+            {
               instring = 0;
               if (ap == new_argv[0] || *(ap-1) == '\0')
                 last_argument_was_empty = 1;
+            }
           else if (*p == '\\' && p[1] == '\n')
+        {
+          /* Inside a string, just copy any char except a closing quote
+             or a backslash-newline combination.  */
+          if (*p == instring)
+            {
+              instring = 0;
+              if (ap == new_argv[0] || *(ap-1) == '\0')
+                last_argument_was_empty = 1;
+            }
+          else if (*p == '\\' && p[1] == '\n')
+            {
               /* Backslash-newline is handled differently depending on what
                  kind of string we're in: inside single-quoted strings you
+                 keep them; in double-quoted strings they disappear.
+                 For DOS/Windows/OS2, if we don't have a POSIX shell,
+                 we keep the pre-POSIX behavior of removing the
+                 backslash-newline.  */
+                 keep them; in double-quoted strings they disappear.  For
+                 DOS/Windows/OS2, if we don't have a POSIX shell, we keep the
+                 pre-POSIX behavior of removing the backslash-newline.  */
               if (instring == '"'
 #if defined (__MSDOS__) || defined (__EMX__) || defined (WINDOWS32)
                   || !unixy_shell
 #endif
+                  )
+                  || !unixy_shell
+#endif
+                  )
                 ++p;
               else
 …
+                }
+            }
+          else if (*p == '\n' && restp != NULL)
+            {
+              /* End of the command line.  */
+              *restp = p;
+              goto end_of_line;
+            }
+          /* Backslash, $, and ` are special inside double quotes.
+             If we see any of those, punt.
+             But on MSDOS, if we use COMMAND.COM, double and single
+             quotes have the same effect.  */
+          else if (instring == '"' && strchr ("\\$`", *p) != 0 && unixy_shell)
+            goto slow;
+          else
+            *ap++ = *p;
+        }
+          else if (*p == '\n' && restp != NULL)
+            {
+              /* End of the command line.  */
+              *restp = p;
+              goto end_of_line;
+            }
+          /* Backslash, $, and ` are special inside double quotes.
+             If we see any of those, punt.
+             But on MSDOS, if we use COMMAND.COM, double and single
+             quotes have the same effect.  */
+          else if (instring == '"' && strchr ("\\$`", *p) != 0 && unixy_shell)
+            goto slow;
+#ifdef WINDOWS32
+          /* Quoted wildcard characters must be passed quoted to the
+             command, so give up the fast route.  */
+          else if (instring == '"' && strchr ("*?", *p) != 0 && !unixy_shell)
+            goto slow;
+          else if (instring == '"' && strncmp (p, "\\\"", 2) == 0)
+            *ap++ = *++p;
+#endif
+          else
+            *ap++ = *p;
+        }
       else if (strchr (sh_chars, *p) != 0)
         /* Not inside a string, but it's a special char.  */
         goto slow;
+        /* Not inside a string, but it's a special char.  */
+        goto slow;
       else if (one_shell && *p == '\n')
         /* In .ONESHELL mode \n is a separator like ; or && */
         goto slow;
+        /* In .ONESHELL mode \n is a separator like ; or && */
+        goto slow;
 #ifdef  __MSDOS__
       else if (*p == '.' && p[1] == '.' && p[2] == '.' && p[3] != '.')
         /* `...' is a wildcard in DJGPP.  */
         goto slow;
+        /* '...' is a wildcard in DJGPP.  */
+        goto slow;
 #endif
       else
         /* Not a special char.  */
         switch (*p)
+          {
           case '=':
             /* Equals is a special character in leading words before the
                first word with no equals sign in it.  This is not the case
                with sh -k, but we never get here when using nonstandard
                shell flags.  */
             if (! seen_nonequals && unixy_shell)
               goto slow;
             word_has_equals = 1;
             *ap++ = '=';
             break;
           case '\\':
             /* Backslash-newline has special case handling, ref POSIX.
+        /* Not a special char.  */
+        switch (*p)
+          {
+          case '=':
+            /* Equals is a special character in leading words before the
+               first word with no equals sign in it.  This is not the case
+               with sh -k, but we never get here when using nonstandard
+               shell flags.  */
+            if (! seen_nonequals && unixy_shell)
+              goto slow;
+            word_has_equals = 1;
+            *ap++ = '=';
+            break;
+          case '\\':
+            /* Backslash-newline has special case handling, ref POSIX.
                We're in the fastpath, so emulate what the shell would do.  */
             if (p[1] == '\n')
+              {
                 /* Throw out the backslash and newline.  */
+            if (p[1] == '\n')
+              {
+                /* Throw out the backslash and newline.  */
                 ++p;
                 /* If there's nothing in this argument yet, skip any
                    whitespace before the start of the next word.  */
+                /* At the beginning of the argument, skip any whitespace other
+                   than newline before the start of the next word.  */
                 if (ap == new_argv[i])
+                  p = next_token (p + 1) - 1;
+              }
+            else if (p[1] != '\0')
+                  while (ISBLANK (p[1]))
+                    ++p;
+              }
+#ifdef WINDOWS32
+            /* Backslash before whitespace is not special if our shell
+               is not Unixy.  */
+            else if (ISSPACE (p[1]) && !unixy_shell)
+              {
+                *ap++ = *p;
+                break;
+              }
+#endif
+            else if (p[1] != '\0')
+              {
 #ifdef HAVE_DOS_PATHS
 …
 #endif
                   if (p[1] != '\\' && p[1] != '\''
                       && !isspace ((unsigned char)p[1])
+                      && !ISSPACE (p[1])
                       && strchr (sh_chars_sh, p[1]) == 0)
                     /* back up one notch, to copy the backslash */
 …
                 *ap++ = *++p;
+              }
             break;
           case '\'':
           case '"':
             instring = *p;
             break;
           case '\n':
             if (restp != NULL)
+              {
                 /* End of the command line.  */
                 *restp = p;
                 goto end_of_line;
+              }
             else
               /* Newlines are not special.  */
               *ap++ = '\n';
             break;
           case ' ':
           case '\t':
             /* We have the end of an argument.
                Terminate the text of the argument.  */
             *ap++ = '\0';
             new_argv[++i] = ap;
             last_argument_was_empty = 0;
             /* Update SEEN_NONEQUALS, which tells us if every word
                heretofore has contained an `='.  */
             seen_nonequals |= ! word_has_equals;
             if (word_has_equals && ! seen_nonequals)
               /* An `=' in a word before the first
                  word without one is magical.  */
               goto slow;
             word_has_equals = 0; /* Prepare for the next word.  */
             /* If this argument is the command name,
                see if it is a built-in shell command.
                If so, have the shell handle it.  */
             if (i == 1)
+              {
                 register int j;
                 for (j = 0; sh_cmds[j] != 0; ++j)
+            break;
+          case '\'':
+          case '"':
+            instring = *p;
+            break;
+          case '\n':
+            if (restp != NULL)
+              {
+                /* End of the command line.  */
+                *restp = p;
+                goto end_of_line;
+              }
+            else
+              /* Newlines are not special.  */
+              *ap++ = '\n';
+            break;
+          case ' ':
+          case '\t':
+            /* We have the end of an argument.
+               Terminate the text of the argument.  */
+            *ap++ = '\0';
+            new_argv[++i] = ap;
+            last_argument_was_empty = 0;
+            /* Update SEEN_NONEQUALS, which tells us if every word
+               heretofore has contained an '='.  */
+            seen_nonequals |= ! word_has_equals;
+            if (word_has_equals && ! seen_nonequals)
+              /* An '=' in a word before the first
+                 word without one is magical.  */
+              goto slow;
+            word_has_equals = 0; /* Prepare for the next word.  */
+            /* If this argument is the command name,
+               see if it is a built-in shell command.
+               If so, have the shell handle it.  */
+            if (i == 1)
+              {
+                register int j;
+                for (j = 0; sh_cmds[j] != 0; ++j)
+                  {
                     if (streq (sh_cmds[j], new_argv[0]))
                       goto slow;
 # ifdef __EMX__
+#if defined(__EMX__) || defined(WINDOWS32)
                     /* Non-Unix shells are case insensitive.  */
                     if (!unixy_shell
                         && strcasecmp (sh_cmds[j], new_argv[0]) == 0)
                       goto slow;
 # endif
+#endif
+                  }
+              }
+            /* Ignore multiple whitespace chars.  */
+            p = next_token (p) - 1;
+            break;
+          default:
+            *ap++ = *p;
+            break;
+          }
+              }
+            /* Skip whitespace chars, but not newlines.  */
+            while (ISBLANK (p[1]))
+              ++p;
+            break;
+          default:
+            *ap++ = *p;
+            break;
+          }
+    }
  end_of_line:
 …
       register int j;
       for (j = 0; sh_cmds[j] != 0; ++j)
         if (streq (sh_cmds[j], new_argv[0]))
           goto slow;
+        if (streq (sh_cmds[j], new_argv[0]))
+          goto slow;
+    }
 …
 #ifdef __MSDOS__
   execute_by_shell = 1; /* actually, call `system' if shell isn't unixy */
+  execute_by_shell = 1; /* actually, call 'system' if shell isn't unixy */
 #endif
 …
+    {
       if (*ptr == '\\' && ptr[1] == '\n')
         ptr += 2;
+        ptr += 2;
       else if (*ptr == '@') /* Kludge: multiline commands */
+      {
         ptr += 2;
         *dptr++ = '\n';
+        ptr += 2;
+        *dptr++ = '\n';
+      }
       else
         *dptr++ = *ptr++;
+        *dptr++ = *ptr++;
+    }
     *dptr = 0;
 …
     new_argv[1] = 0;
+  }
 #else   /* Not Amiga  */
+#else   /* Not Amiga  */
 #ifdef WINDOWS32
   /*
 …
   /* Make sure not to bother processing an empty line.  */
+  while (isspace ((unsigned char)*line))
+    ++line;
+  NEXT_TOKEN (line);
   if (*line == '\0')
     return 0;
 …
        argument list.  */
+    char *new_line;
     unsigned int shell_len = strlen (shell);
     unsigned int line_len = strlen (line);
+    unsigned int sflags_len = strlen (shellflags);
+    unsigned int sflags_len = shellflags ? strlen (shellflags) : 0;
+#ifdef WINDOWS32
     char *command_ptr = NULL; /* used for batch_mode_shell mode */
+    char *new_line;
+#endif
 # ifdef __EMX__ /* is this necessary? */
     if (!unixy_shell)
+    if (!unixy_shell && shellflags)
       shellflags[0] = '/'; /* "/c" */
 # endif
     /* In .ONESHELL mode we are allowed to throw the entire current
         recipe string at a single shell and trust that the user
         has configured the shell and shell flags, and formatted
         the string, appropriately. */
+        recipe string at a single shell and trust that the user
+        has configured the shell and shell flags, and formatted
+        the string, appropriately. */
     if (one_shell)
+      {
         /* If the shell is Bourne compatible, we must remove and ignore
            interior special chars [@+-] because they're meaningless to
            the shell itself. If, however, we're in .ONESHELL mode and
            have changed SHELL to something non-standard, we should
            leave those alone because they could be part of the
            script. In this case we must also leave in place
            any leading [@+-] for the same reason.  */
         /* Remove and ignore interior prefix chars [@+-] because they're
              meaningless given a single shell. */
+        /* If the shell is Bourne compatible, we must remove and ignore
+           interior special chars [@+-] because they're meaningless to
+           the shell itself. If, however, we're in .ONESHELL mode and
+           have changed SHELL to something non-standard, we should
+           leave those alone because they could be part of the
+           script. In this case we must also leave in place
+           any leading [@+-] for the same reason.  */
+        /* Remove and ignore interior prefix chars [@+-] because they're
+             meaningless given a single shell. */
 #if defined __MSDOS__ || defined (__EMX__)
         if (unixy_shell)     /* the test is complicated and we already did it */
+        if (unixy_shell)     /* the test is complicated and we already did it */
 #else
+        if (is_bourne_compatible_shell(shell))
+        if (is_bourne_compatible_shell (shell)
+#ifdef WINDOWS32
+            /* If we didn't find any sh.exe, don't behave is if we did!  */
+            && !no_default_sh_exe
+#endif
+            )
 #endif
+          {
 …
                 int esc = 0;
                 /* This is the start of a new recipe line.
                    Skip whitespace and prefix characters.  */
                 while (isblank (*f) || *f == '-' || *f == '@' || *f == '+')
+                /* This is the start of a new recipe line.  Skip whitespace
+                   and prefix characters but not newlines.  */
+                while (ISBLANK (*f) || *f == '-' || *f == '@' || *f == '+')
                   ++f;
 …
             *t = '\0';
+          }
+        new_argv = xmalloc (4 * sizeof (char *));
+        new_argv[0] = xstrdup(shell);
+        new_argv[1] = xstrdup(shellflags);
+        new_argv[2] = line;
+        new_argv[3] = NULL;
+        return new_argv;
+#ifdef WINDOWS32
+        else    /* non-Posix shell (cmd.exe etc.) */
+          {
+            const char *f = line;
+            char *t = line;
+            char *tstart = t;
+            int temp_fd;
+            FILE* batch = NULL;
+            int id = GetCurrentProcessId ();
+            PATH_VAR(fbuf);
+            /* Generate a file name for the temporary batch file.  */
+            sprintf (fbuf, "make%d", id);
+            *batch_filename = create_batch_file (fbuf, 0, &temp_fd);
+            DB (DB_JOBS, (_("Creating temporary batch file %s\n"),
+                          *batch_filename));
+            /* Create a FILE object for the batch file, and write to it the
+               commands to be executed.  Put the batch file in TEXT mode.  */
+            _setmode (temp_fd, _O_TEXT);
+            batch = _fdopen (temp_fd, "wt");
+            fputs ("@echo off\n", batch);
+            DB (DB_JOBS, (_("Batch file contents:\n\t@echo off\n")));
+            /* Copy the recipe, removing and ignoring interior prefix chars
+               [@+-]: they're meaningless in .ONESHELL mode.  */
+            while (*f != '\0')
+              {
+                /* This is the start of a new recipe line.  Skip whitespace
+                   and prefix characters but not newlines.  */
+                while (ISBLANK (*f) || *f == '-' || *f == '@' || *f == '+')
+                  ++f;
+                /* Copy until we get to the next logical recipe line.  */
+                while (*f != '\0')
+                  {
+                    /* Remove the escaped newlines in the command, and the
+                       blanks that follow them.  Windows shells cannot handle
+                       escaped newlines.  */
+                    if (*f == '\\' && f[1] == '\n')
+                      {
+                        f += 2;
+                        while (ISBLANK (*f))
+                          ++f;
+                      }
+                    *(t++) = *(f++);
+                    /* On an unescaped newline, we're done with this
+                       line.  */
+                    if (f[-1] == '\n')
+                      break;
+                  }
+                /* Write another line into the batch file.  */
+                if (t > tstart)
+                  {
+                    char c = *t;
+                    *t = '\0';
+                    fputs (tstart, batch);
+                    DB (DB_JOBS, ("\t%s", tstart));
+                    tstart = t;
+                    *t = c;
+                  }
+              }
+            DB (DB_JOBS, ("\n"));
+            fclose (batch);
+            /* Create an argv list for the shell command line that
+               will run the batch file.  */
+            new_argv = xmalloc (2 * sizeof (char *));
+            new_argv[0] = xstrdup (*batch_filename);
+            new_argv[1] = NULL;
+            return new_argv;
+          }
+#endif /* WINDOWS32 */
+        /* Create an argv list for the shell command line.  */
+        {
+          int n = 0;
+          new_argv = xmalloc ((4 + sflags_len/2) * sizeof (char *));
+          new_argv[n++] = xstrdup (shell);
+          /* Chop up the shellflags (if any) and assign them.  */
+          if (! shellflags)
+            new_argv[n++] = xstrdup ("");
+          else
+            {
+              const char *s = shellflags;
+              char *t;
+              unsigned int len;
+              while ((t = find_next_token (&s, &len)) != 0)
+                new_argv[n++] = xstrndup (t, len);
+            }
+          /* Set the command to invoke.  */
+          new_argv[n++] = line;
+          new_argv[n++] = NULL;
+        }
+        return new_argv;
+      }
     new_line = alloca (shell_len + 1 + sflags_len + 1
                              + (line_len*2) + 1);
+    new_line = xmalloc ((shell_len*2) + 1 + sflags_len + 1
+                        + (line_len*2) + 1);
     ap = new_line;
+    memcpy (ap, shell, shell_len);
+    ap += shell_len;
+    /* Copy SHELL, escaping any characters special to the shell.  If
+       we don't escape them, construct_command_argv_internal will
+       recursively call itself ad nauseam, or until stack overflow,
+       whichever happens first.  */
+    for (cp = shell; *cp != '\0'; ++cp)
+      {
+        if (strchr (sh_chars, *cp) != 0)
+          *(ap++) = '\\';
+        *(ap++) = *cp;
+      }
     *(ap++) = ' ';
+    memcpy (ap, shellflags, sflags_len);
+    if (shellflags)
+      memcpy (ap, shellflags, sflags_len);
     ap += sflags_len;
     *(ap++) = ' ';
+#ifdef WINDOWS32
     command_ptr = ap;
+#endif
     for (p = line; *p != '\0'; ++p)
+      {
         if (restp != NULL && *p == '\n')
+          {
             *restp = p;
             break;
+          }
         else if (*p == '\\' && p[1] == '\n')
+          {
             /* POSIX says we keep the backslash-newline.  If we don't have a
+        if (restp != NULL && *p == '\n')
+          {
+            *restp = p;
+            break;
+          }
+        else if (*p == '\\' && p[1] == '\n')
+          {
+            /* POSIX says we keep the backslash-newline.  If we don't have a
                POSIX shell on DOS/Windows/OS2, mimic the pre-POSIX behavior
                and remove the backslash/newline.  */
 …
 # define PRESERVE_BSNL  1
 #endif
             if (PRESERVE_BSNL)
+              {
                 *(ap++) = '\\';
                 /* Only non-batch execution needs another backslash,
                    because it will be passed through a recursive
                    invocation of this function.  */
                 if (!batch_mode_shell)
                   *(ap++) = '\\';
                 *(ap++) = '\n';
+              }
             ++p;
             continue;
+          }
+            if (PRESERVE_BSNL)
+              {
+                *(ap++) = '\\';
+                /* Only non-batch execution needs another backslash,
+                   because it will be passed through a recursive
+                   invocation of this function.  */
+                if (!batch_mode_shell)
+                  *(ap++) = '\\';
+                *(ap++) = '\n';
+              }
+            ++p;
+            continue;
+          }
         /* DOS shells don't know about backslash-escaping.  */
         if (unixy_shell && !batch_mode_shell &&
+        if (unixy_shell && !batch_mode_shell &&
             (*p == '\\' || *p == '\'' || *p == '"'
              || isspace ((unsigned char)*p)
+             || ISSPACE (*p)
              || strchr (sh_chars, *p) != 0))
           *ap++ = '\\';
+          *ap++ = '\\';
 #ifdef __MSDOS__
         else if (unixy_shell && strneq (p, "...", 3))
+          {
             /* The case of `...' wildcard again.  */
+            /* The case of '...' wildcard again.  */
             strcpy (ap, "\\.\\.\\");
             ap += 5;
 …
+          }
 #endif
         *ap++ = *p;
+        *ap++ = *p;
+      }
     if (ap == new_line + shell_len + sflags_len + 2)
+      /* Line was empty.  */
+      return 0;
+      {
+        /* Line was empty.  */
+        free (new_line);
+        return 0;
+      }
     *ap = '\0';
 …
        command line (e.g. Cygnus GNUWIN32 sh.exe on WIN32 systems).  In these
        cases, run commands via a script file.  */
+    if (just_print_flag && !(flags & COMMANDS_RECURSE)) {
+      /* Need to allocate new_argv, although it's unused, because
+        start_job_command will want to free it and its 0'th element.  */
+      new_argv = xmalloc(2 * sizeof (char *));
+      new_argv[0] = xstrdup ("");
+      new_argv[1] = NULL;
+    } else if ((no_default_sh_exe || batch_mode_shell) && batch_filename_ptr) {
+      int temp_fd;
+      FILE* batch = NULL;
+      int id = GetCurrentProcessId();
+      PATH_VAR(fbuf);
+      /* create a file name */
+      sprintf(fbuf, "make%d", id);
+      *batch_filename_ptr = create_batch_file (fbuf, unixy_shell, &temp_fd);
+      DB (DB_JOBS, (_("Creating temporary batch file %s\n"),
+                    *batch_filename_ptr));
+      /* Create a FILE object for the batch file, and write to it the
+         commands to be executed.  Put the batch file in TEXT mode.  */
+      _setmode (temp_fd, _O_TEXT);
+      batch = _fdopen (temp_fd, "wt");
+      if (!unixy_shell)
+        fputs ("@echo off\n", batch);
+      fputs (command_ptr, batch);
+      fputc ('\n', batch);
+      fclose (batch);
+      DB (DB_JOBS, (_("Batch file contents:%s\n\t%s\n"),
+                    !unixy_shell ? "\n\t@echo off" : "", command_ptr));
+      /* create argv */
+      new_argv = xmalloc(3 * sizeof (char *));
+      if (unixy_shell) {
+        new_argv[0] = xstrdup (shell);
+        new_argv[1] = *batch_filename_ptr; /* only argv[0] gets freed later */
+      } else {
+        new_argv[0] = xstrdup (*batch_filename_ptr);
+    if (just_print_flag && !(flags & COMMANDS_RECURSE))
+      {
+        /* Need to allocate new_argv, although it's unused, because
+           start_job_command will want to free it and its 0'th element.  */
+        new_argv = xmalloc (2 * sizeof (char *));
+        new_argv[0] = xstrdup ("");
         new_argv[1] = NULL;
+      }
+      new_argv[2] = NULL;
+    } else
+    else if ((no_default_sh_exe || batch_mode_shell) && batch_filename)
+      {
+        int temp_fd;
+        FILE* batch = NULL;
+        int id = GetCurrentProcessId ();
+        PATH_VAR (fbuf);
+        /* create a file name */
+        sprintf (fbuf, "make%d", id);
+        *batch_filename = create_batch_file (fbuf, unixy_shell, &temp_fd);
+        DB (DB_JOBS, (_("Creating temporary batch file %s\n"),
+                      *batch_filename));
+        /* Create a FILE object for the batch file, and write to it the
+           commands to be executed.  Put the batch file in TEXT mode.  */
+        _setmode (temp_fd, _O_TEXT);
+        batch = _fdopen (temp_fd, "wt");
+        if (!unixy_shell)
+          fputs ("@echo off\n", batch);
+        fputs (command_ptr, batch);
+        fputc ('\n', batch);
+        fclose (batch);
+        DB (DB_JOBS, (_("Batch file contents:%s\n\t%s\n"),
+                      !unixy_shell ? "\n\t@echo off" : "", command_ptr));
+        /* create argv */
+        new_argv = xmalloc (3 * sizeof (char *));
+        if (unixy_shell)
+          {
+            new_argv[0] = xstrdup (shell);
+            new_argv[1] = *batch_filename; /* only argv[0] gets freed later */
+          }
+        else
+          {
+            new_argv[0] = xstrdup (*batch_filename);
+            new_argv[1] = NULL;
+          }
+        new_argv[2] = NULL;
+      }
+    else
 #endif /* WINDOWS32 */
     if (unixy_shell)
+      new_argv = construct_command_argv_internal (new_line, 0, 0, 0, 0, flags, 0);
+      new_argv = construct_command_argv_internal (new_line, 0, 0, 0, 0,
+                                                  flags, 0);
 #ifdef __EMX__
     else if (!unixy_shell)
+      {
         /* new_line is local, must not be freed therefore
+        /* new_line is local, must not be freed therefore
            We use line here instead of new_line because we run the shell
            manually.  */
 …
 #else
     else
+      fatal (NILF, _("%s (line %d) Bad shell context (!unixy && !batch_mode_shell)\n"),
+      fatal (NILF, CSTRLEN (__FILE__) + INTSTR_LENGTH,
+             _("%s (line %d) Bad shell context (!unixy && !batch_mode_shell)\n"),
             __FILE__, __LINE__);
 #endif
+    free (new_line);
+  }
 #endif  /* ! AMIGA */
+#endif  /* ! AMIGA */
   return new_argv;
 …
 /* Figure out the argument list necessary to run LINE as a command.  Try to
    avoid using a shell.  This routine handles only ' quoting, and " quoting
    when no backslash, $ or ` characters are seen in the quotes.  Starting
+   when no backslash, $ or ' characters are seen in the quotes.  Starting
    quotes may be escaped with a backslash.  If any of the characters in
    sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[]
+   sh_chars is seen, or any of the builtin commands listed in sh_cmds
    is the first word of a line, the shell is used.
 …
 char **
 construct_command_argv (char *line, char **restp, struct file *file,
                         int cmd_flags, char **batch_filename_ptr)
+                        int cmd_flags, char **batch_filename)
+{
   char *shell, *ifs, *shellflags;
 …
   for (;;)
+    {
+      while ((*cptr != 0)
+             && (isspace ((unsigned char)*cptr)))
+        cptr++;
+      while ((*cptr != 0) && (ISSPACE (*cptr)))
+        cptr++;
       if (*cptr == 0)
+        break;
+      while ((*cptr != 0)
+             && (!isspace((unsigned char)*cptr)))
+        cptr++;
+        break;
+      while ((*cptr != 0) && (!ISSPACE (*cptr)))
+        cptr++;
       argc++;
+    }
 …
   for (;;)
+    {
+      while ((*cptr != 0)
+             && (isspace ((unsigned char)*cptr)))
+        cptr++;
+      while ((*cptr != 0) && (ISSPACE (*cptr)))
+        cptr++;
       if (*cptr == 0)
         break;
+        break;
       DB (DB_JOBS, ("argv[%d] = [%s]\n", argc, cptr));
       argv[argc++] = cptr;
+      while ((*cptr != 0)
+             && (!isspace((unsigned char)*cptr)))
+        cptr++;
+      while ((*cptr != 0) && (!ISSPACE (*cptr)))
+        cptr++;
       if (*cptr != 0)
         *cptr++ = 0;
+        *cptr++ = 0;
+    }
 #else
 …
      * is not confused.
      */
+    if (shell) {
+      char *p = w32ify (shell, 0);
+      strcpy (shell, p);
+    }
+    if (shell)
+      {
+        char *p = w32ify (shell, 0);
+        strcpy (shell, p);
+      }
 #endif
 #ifdef __EMX__
 …
       static int init = 0;
       if (init == 0)
+        {
           unixroot = getenv ("UNIXROOT");
           /* unixroot must be NULL or not empty */
           if (unixroot && unixroot[0] == '\0') unixroot = NULL;
           init = 1;
+        }
+        {
+          unixroot = getenv ("UNIXROOT");
+          /* unixroot must be NULL or not empty */
+          if (unixroot && unixroot[0] == '\0') unixroot = NULL;
+          init = 1;
+        }
       /* if we have an unixroot drive and if shell is not default_shell
 …
          "$UNIXROOT/bin/sh" instead.  */
       if (unixroot && shell && strcmp (shell, last_shell) != 0
           && (shell[0] == '/' || shell[0] == '\\'))
+        {
           /* trying a new shell, check whether it exists */
           size_t size = strlen (shell);
           char *buf = xmalloc (size + 7);
           memcpy (buf, shell, size);
           memcpy (buf + size, ".exe", 5); /* including the trailing '\0' */
+          && (shell[0] == '/' || shell[0] == '\\'))
+        {
+          /* trying a new shell, check whether it exists */
+          size_t size = strlen (shell);
+          char *buf = xmalloc (size + 7);
+          memcpy (buf, shell, size);
+          memcpy (buf + size, ".exe", 5); /* including the trailing '\0' */
           if (access (shell, F_OK) != 0 && access (buf, F_OK) != 0)
+            {
               /* try the same for the unixroot drive */
               memmove (buf + 2, buf, size + 5);
               buf[0] = unixroot[0];
               buf[1] = unixroot[1];
               if (access (buf, F_OK) == 0)
                 /* we have found a shell! */
                 /* free(shell); */
                 shell = buf;
               else
                 free (buf);
+            }
           else
+            {
+              /* try the same for the unixroot drive */
+              memmove (buf + 2, buf, size + 5);
+              buf[0] = unixroot[0];
+              buf[1] = unixroot[1];
+              if (access (buf, F_OK) == 0)
+                /* we have found a shell! */
+                /* free(shell); */
+                shell = buf;
+              else
+                free (buf);
+            }
+          else
             free (buf);
+        }
+        }
+    }
 #endif /* __EMX__ */
 …
   argv = construct_command_argv_internal (line, restp, shell, shellflags, ifs,
                                           cmd_flags, batch_filename_ptr);
+                                          cmd_flags, batch_filename);
   free (shell);
 …
   (void) close (new);
   fd = dup (old);
+  EINTRLOOP (fd, dup (old));
   if (fd != new)
+    {

vendor/gnumake/current/job.h

-              r2596
+              r3138
 /* Definitions for managing subprocesses in GNU Make.
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
+Foundation, Inc.
+Copyright (C) 1992-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
+#ifndef SEEN_JOB_H
+#define SEEN_JOB_H
+#include "output.h"
 #ifdef HAVE_FCNTL_H
 …
 /* How to set close-on-exec for a file descriptor.  */
+#if !defined F_SETFD
+# define CLOSE_ON_EXEC(_d)
+#if !defined(F_SETFD) || !defined(F_GETFD)
+# ifdef WINDOWS32
+#  define CLOSE_ON_EXEC(_d)  process_noinherit(_d)
+# else
+#  define CLOSE_ON_EXEC(_d)
+# endif
 #else
 # ifndef FD_CLOEXEC
 …
 #endif
+#ifdef NO_OUTPUT_SYNC
+# define RECORD_SYNC_MUTEX(m) \
+    O (error, NILF,                                                    \
+       _("-O[TYPE] (--output-sync[=TYPE]) is not configured for this build."));
+#else
+# ifdef WINDOWS32
+/* For emulations in w32/compat/posixfcn.c.  */
+#  define F_GETFD 1
+#  define F_SETLKW 2
+/* Implementation note: None of the values of l_type below can be zero
+   -- they are compared with a static instance of the struct, so zero
+   means unknown/invalid, see w32/compat/posixfcn.c. */
+#  define F_WRLCK 1
+#  define F_UNLCK 2
+struct flock
+  {
+    short l_type;
+    short l_whence;
+    off_t l_start;
+    off_t l_len;
+    pid_t l_pid;
+  };
+/* This type is actually a HANDLE, but we want to avoid including
+   windows.h as much as possible.  */
+typedef intptr_t sync_handle_t;
+/* Public functions emulated/provided in posixfcn.c.  */
+int fcntl (intptr_t fd, int cmd, ...);
+intptr_t create_mutex (void);
+int same_stream (FILE *f1, FILE *f2);
+#  define RECORD_SYNC_MUTEX(m) record_sync_mutex(m)
+void record_sync_mutex (const char *str);
+void prepare_mutex_handle_string (intptr_t hdl);
+# else  /* !WINDOWS32 */
+typedef int sync_handle_t;      /* file descriptor */
+#  define RECORD_SYNC_MUTEX(m) (void)(m)
+# endif
+#endif  /* !NO_OUTPUT_SYNC */
 /* Structure describing a running or dead child process.  */
 struct child
+  {
     struct child *next;         /* Link in the chain.  */
+    struct child *next;         /* Link in the chain.  */
     struct file *file;          /* File being remade.  */
+    struct file *file;          /* File being remade.  */
+    char **environment;         /* Environment for commands.  */
+    char **environment;         /* Environment for commands.  */
+    char *sh_batch_file;        /* Script file for shell commands */
+    char **command_lines;       /* Array of variable-expanded cmd lines.  */
+    char *command_ptr;          /* Ptr into command_lines[command_line].  */
+    char **command_lines;       /* Array of variable-expanded cmd lines.  */
+    unsigned int command_line;  /* Index into above.  */
+    char *command_ptr;          /* Ptr into command_lines[command_line].  */
+#ifdef VMS
+    char *comname;              /* Temporary command file name */
+    int efn;                    /* Completion event flag number */
+    int cstatus;                /* Completion status */
+    int vms_launch_status;      /* non-zero if lib$spawn, etc failed */
+#endif
+    pid_t pid;                  /* Child process's ID number.  */
+#ifdef VMS
+    int efn;                    /* Completion event flag number */
+    int cstatus;                /* Completion status */
+    char *comname;              /* Temporary command file name */
+#endif
+    char *sh_batch_file;        /* Script file for shell commands */
+    unsigned int remote:1;      /* Nonzero if executing remotely.  */
+    unsigned int noerror:1;     /* Nonzero if commands contained a `-'.  */
+    unsigned int good_stdin:1;  /* Nonzero if this child has a good stdin.  */
+    unsigned int deleted:1;     /* Nonzero if targets have been deleted.  */
+    unsigned int dontcare:1;    /* Saved dontcare flag.  */
+    unsigned int  command_line; /* Index into command_lines.  */
+    struct output output;       /* Output for this child.  */
+    pid_t         pid;          /* Child process's ID number.  */
+    unsigned int  remote:1;     /* Nonzero if executing remotely.  */
+    unsigned int  noerror:1;    /* Nonzero if commands contained a '-'.  */
+    unsigned int  good_stdin:1; /* Nonzero if this child has a good stdin.  */
+    unsigned int  deleted:1;    /* Nonzero if targets have been deleted.  */
+    unsigned int  recursive:1;  /* Nonzero for recursive command ('+' etc.)  */
+    unsigned int  dontcare:1;   /* Saved dontcare flag.  */
   };
 extern struct child *children;
+/* A signal handler for SIGCHLD, if needed.  */
+RETSIGTYPE child_handler (int sig);
 int is_bourne_compatible_shell(const char *path);
 void new_job (struct file *file);
 …
 char **construct_command_argv (char *line, char **restp, struct file *file,
                                int cmd_flags, char** batch_file);
 #ifdef VMS
+int child_execute_job (char *argv, struct child *child);
+#elif defined(__EMX__)
+int child_execute_job (int stdin_fd, int stdout_fd, char **argv, char **envp);
+int child_execute_job (struct child *child, char *argv);
 #else
+void child_execute_job (int stdin_fd, int stdout_fd, char **argv, char **envp);
+# define FD_STDIN       (fileno (stdin))
+# define FD_STDOUT      (fileno (stdout))
+# define FD_STDERR      (fileno (stderr))
+int child_execute_job (struct output *out, int good_stdin, char **argv, char **envp);
 #endif
 #ifdef _AMIGA
 void exec_command (char **argv);
+void exec_command (char **argv) __attribute__ ((noreturn));
 #elif defined(__EMX__)
 int exec_command (char **argv, char **envp);
 #else
 void exec_command (char **argv, char **envp);
+void exec_command (char **argv, char **envp) __attribute__ ((noreturn));
 #endif
 …
 void unblock_sigs (void);
 #else
 #ifdef  HAVE_SIGSETMASK
+#ifdef  HAVE_SIGSETMASK
 extern int fatal_signal_mask;
 #define unblock_sigs()  sigsetmask (0)
+#define unblock_sigs()  sigsetmask (0)
 #else
 #define unblock_sigs()
+#define unblock_sigs()
 #endif
 #endif
 extern unsigned int jobserver_tokens;
-#endif /* SEEN_JOB_H */

vendor/gnumake/current/main.c

-              r2596
+              r3138
 /* Argument parsing and main program of GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
+#include "make.h"
+#include "makeint.h"
+#include "os.h"
+#include "filedef.h"
 #include "dep.h"
-#include "filedef.h"
 #include "variable.h"
 #include "job.h"
 …
 #endif
 #ifdef WINDOWS32
+#include <windows.h>
+#include <io.h>
+#include "pathstuff.h"
+# include <windows.h>
+# include <io.h>
+# include "pathstuff.h"
+# include "sub_proc.h"
+# include "w32err.h"
 #endif
 #ifdef __EMX__
 …
 int __stack = 20000; /* Make sure we have 20K of stack space */
 #endif
+void init_dir (void);
+void remote_setup (void);
+void remote_cleanup (void);
+RETSIGTYPE fatal_error_signal (int sig);
+void print_variable_data_base (void);
+void print_dir_data_base (void);
+void print_rule_data_base (void);
+void print_vpath_data_base (void);
+void verify_file_data_base (void);
+#ifdef VMS
+int vms_use_mcr_command = 0;
+int vms_always_use_cmd_file = 0;
+int vms_gnv_shell = 0;
+int vms_legacy_behavior = 0;
+int vms_comma_separator = 0;
+int vms_unix_simulation = 0;
+int vms_report_unix_paths = 0;
+/* Evaluates if a VMS environment option is set, only look at first character */
+static int
+get_vms_env_flag (const char *name, int default_value)
+{
+char * value;
+char x;
+  value = getenv (name);
+  if (value == NULL)
+    return default_value;
+  x = toupper (value[0]);
+  switch (x)
+    {
+    case '1':
+    case 'T':
+    case 'E':
+      return 1;
+      break;
+    case '0':
+    case 'F':
+    case 'D':
+      return 0;
+    }
+}
+#endif
 #if defined HAVE_WAITPID || defined HAVE_WAIT3
 …
 #endif
 #ifndef HAVE_UNISTD_H
+#ifndef HAVE_UNISTD_H
 int chdir ();
 #endif
 #ifndef STDC_HEADERS
 # ifndef sun                    /* Sun has an incorrect decl in a header.  */
+#ifndef STDC_HEADERS
+# ifndef sun                    /* Sun has an incorrect decl in a header.  */
 void exit (int) __attribute__ ((noreturn));
 # endif
 …
 static void print_data_base (void);
 static void print_version (void);
 static void decode_switches (int argc, char **argv, int env);
 static void decode_env_switches (char *envar, unsigned int len);
 static const char *define_makeflags (int all, int makefile);
+static void decode_switches (int argc, const char **argv, int env);
+static void decode_env_switches (const char *envar, unsigned int len);
+static struct variable *define_makeflags (int all, int makefile);
 static char *quote_for_env (char *out, const char *in);
 static void initialize_global_hash_tables (void);
 …
 struct command_switch
+  {
     int c;                      /* The switch character.  */
     enum                        /* Type of the value.  */
+    int c;                      /* The switch character.  */
+    enum                        /* Type of the value.  */
+      {
+        flag,                   /* Turn int flag on.  */
+        flag_off,               /* Turn int flag off.  */
+        string,                 /* One string per switch.  */
+        filename,               /* A string containing a file name.  */
+        positive_int,           /* A positive integer.  */
+        floating,               /* A floating-point number (double).  */
+        ignore                  /* Ignored.  */
+        flag,                   /* Turn int flag on.  */
+        flag_off,               /* Turn int flag off.  */
+        string,                 /* One string per invocation.  */
+        strlist,                /* One string per switch.  */
+        filename,               /* A string containing a file name.  */
+        positive_int,           /* A positive integer.  */
+        floating,               /* A floating-point number (double).  */
+        ignore                  /* Ignored.  */
       } type;
     void *value_ptr;    /* Pointer to the value-holding variable.  */
     unsigned int env:1;         /* Can come from MAKEFLAGS.  */
     unsigned int toenv:1;       /* Should be put in MAKEFLAGS.  */
     unsigned int no_makefile:1; /* Don't propagate when remaking makefiles.  */
     const void *noarg_value;    /* Pointer to value used if no arg given.  */
     const void *default_value;  /* Pointer to default value.  */
     char *long_name;            /* Long option name.  */
+    void *value_ptr;    /* Pointer to the value-holding variable.  */
+    unsigned int env:1;         /* Can come from MAKEFLAGS.  */
+    unsigned int toenv:1;       /* Should be put in MAKEFLAGS.  */
+    unsigned int no_makefile:1; /* Don't propagate when remaking makefiles.  */
+    const void *noarg_value;    /* Pointer to value used if no arg given.  */
+    const void *default_value;  /* Pointer to default value.  */
+    const char *long_name;      /* Long option name.  */
   };
 …
 /* The structure used to hold the list of strings given
    in command switches of a type that takes string arguments.  */
+   in command switches of a type that takes strlist arguments.  */
 struct stringlist
+  {
     const char **list;  /* Nil-terminated list of strings.  */
     unsigned int idx;   /* Index into above.  */
     unsigned int max;   /* Number of pointers allocated.  */
+    const char **list;  /* Nil-terminated list of strings.  */
+    unsigned int idx;   /* Index into above.  */
+    unsigned int max;   /* Number of pointers allocated.  */
   };
 /* The recognized command switches.  */
+/* Nonzero means do extra verification (that may slow things down).  */
+int verify_flag;
 /* Nonzero means do not print commands to be executed (-s).  */
 …
 /* Print debugging info (--debug).  */
 static struct stringlist *db_flags;
+static struct stringlist *db_flags = 0;
 static int debug_flag = 0;
 int db_level = 0;
 /* Output level (--verbosity).  */
 static struct stringlist *verbosity_flags;
+/* Synchronize output (--output-sync).  */
+char *output_sync_option = 0;
 #ifdef WINDOWS32
 …
+/* Number of job slots (commands that can be run at once).  */
+unsigned int job_slots = 1;
+unsigned int default_job_slots = 1;
+/* Number of job slots for parallelism.  */
+unsigned int job_slots;
+#define INVALID_JOB_SLOTS (-1)
 static unsigned int master_job_slots = 0;
+static int arg_job_slots = INVALID_JOB_SLOTS;
+static const int default_job_slots = INVALID_JOB_SLOTS;
 /* Value of job_slots that means no limit.  */
+static unsigned int inf_jobs = 0;
+/* File descriptors for the jobs pipe.  */
+static struct stringlist *jobserver_fds = 0;
+int job_fds[2] = { -1, -1 };
+int job_rfd = -1;
+static const int inf_jobs = 0;
+/* Authorization for the jobserver.  */
+static char *jobserver_auth = NULL;
+/* Handle for the mutex used on Windows to synchronize output of our
+   children under -O.  */
+char *sync_mutex = NULL;
 /* Maximum load average at which multiple jobs will be run.
 …
                               Consider FILE to be very old and don't remake it.\n"),
     N_("\
+  -O[TYPE], --output-sync[=TYPE]\n\
+                              Synchronize output of parallel jobs by TYPE.\n"),
+    N_("\
   -p, --print-data-base       Print make's internal database.\n"),
     N_("\
 …
   -t, --touch                 Touch targets instead of remaking them.\n"),
     N_("\
+  --trace                     Print tracing information.\n"),
+    N_("\
   -v, --version               Print the version number of make and exit.\n"),
     N_("\
 …
   };
+/* The table of command switches.  */
+/* The table of command switches.
+   Order matters here: this is the order MAKEFLAGS will be constructed.
+   So be sure all simple flags (single char, no argument) come first.  */
 static const struct command_switch switches[] =
 …
     { 'b', ignore, 0, 0, 0, 0, 0, 0, 0 },
     { 'B', flag, &always_make_set, 1, 1, 0, 0, 0, "always-make" },
-    { 'C', filename, &directories, 0, 0, 0, 0, 0, "directory" },
     { 'd', flag, &debug_flag, 1, 1, 0, 0, 0, 0 },
-    { CHAR_MAX+1, string, &db_flags, 1, 1, 0, "basic", 0, "debug" },
 #ifdef WINDOWS32
     { 'D', flag, &suspend_flag, 1, 1, 0, 0, 0, "suspend-for-debug" },
 #endif
     { 'e', flag, &env_overrides, 1, 1, 0, 0, 0, "environment-overrides", },
-    { 'f', filename, &makefiles, 0, 0, 0, 0, 0, "file" },
     { 'h', flag, &print_usage_flag, 0, 0, 0, 0, 0, "help" },
     { 'i', flag, &ignore_errors_flag, 1, 1, 0, 0, 0, "ignore-errors" },
-    { 'I', filename, &include_directories, 1, 1, 0, 0, 0,
-      "include-dir" },
-    { 'j', positive_int, &job_slots, 1, 1, 0, &inf_jobs, &default_job_slots,
-      "jobs" },
-    { CHAR_MAX+2, string, &jobserver_fds, 1, 1, 0, 0, 0, "jobserver-fds" },
     { 'k', flag, &keep_going_flag, 1, 1, 0, 0, &default_keep_going_flag,
       "keep-going" },
-#ifndef NO_FLOAT
-    { 'l', floating, &max_load_average, 1, 1, 0, &default_load_average,
-      &default_load_average, "load-average" },
-#else
-    { 'l', positive_int, &max_load_average, 1, 1, 0, &default_load_average,
-      &default_load_average, "load-average" },
-#endif
     { 'L', flag, &check_symlink_flag, 1, 1, 0, 0, 0, "check-symlink-times" },
     { 'm', ignore, 0, 0, 0, 0, 0, 0, 0 },
     { 'n', flag, &just_print_flag, 1, 1, 1, 0, 0, "just-print" },
-    { 'o', filename, &old_files, 0, 0, 0, 0, 0, "old-file" },
     { 'p', flag, &print_data_base_flag, 1, 1, 0, 0, 0, "print-data-base" },
     { 'q', flag, &question_flag, 1, 1, 1, 0, 0, "question" },
 …
     { 't', flag, &touch_flag, 1, 1, 1, 0, 0, "touch" },
     { 'v', flag, &print_version_flag, 1, 1, 0, 0, 0, "version" },
-    { CHAR_MAX+3, string, &verbosity_flags, 1, 1, 0, 0, 0,
-      "verbosity" },
     { 'w', flag, &print_directory_flag, 1, 1, 0, 0, 0, "print-directory" },
+    /* These options take arguments.  */
+    { 'C', filename, &directories, 0, 0, 0, 0, 0, "directory" },
+    { 'f', filename, &makefiles, 0, 0, 0, 0, 0, "file" },
+    { 'I', filename, &include_directories, 1, 1, 0, 0, 0,
+      "include-dir" },
+    { 'j', positive_int, &arg_job_slots, 1, 1, 0, &inf_jobs, &default_job_slots,
+      "jobs" },
+#ifndef NO_FLOAT
+    { 'l', floating, &max_load_average, 1, 1, 0, &default_load_average,
+      &default_load_average, "load-average" },
+#else
+    { 'l', positive_int, &max_load_average, 1, 1, 0, &default_load_average,
+      &default_load_average, "load-average" },
+#endif
+    { 'o', filename, &old_files, 0, 0, 0, 0, 0, "old-file" },
+    { 'O', string, &output_sync_option, 1, 1, 0, "target", 0, "output-sync" },
+    { 'W', filename, &new_files, 0, 0, 0, 0, 0, "what-if" },
+    /* These are long-style options.  */
+    { CHAR_MAX+1, strlist, &db_flags, 1, 1, 0, "basic", 0, "debug" },
+    { CHAR_MAX+2, string, &jobserver_auth, 1, 1, 0, 0, 0, "jobserver-auth" },
+    { CHAR_MAX+3, flag, &trace_flag, 1, 1, 0, 0, 0, "trace" },
     { CHAR_MAX+4, flag, &inhibit_print_directory_flag, 1, 1, 0, 0, 0,
       "no-print-directory" },
-    { 'W', filename, &new_files, 0, 0, 0, 0, 0, "what-if" },
     { CHAR_MAX+5, flag, &warn_undefined_variables_flag, 1, 1, 0, 0, 0,
       "warn-undefined-variables" },
+    { CHAR_MAX+6, string, &eval_strings, 1, 0, 0, 0, 0, "eval" },
+    { CHAR_MAX+6, strlist, &eval_strings, 1, 0, 0, 0, 0, "eval" },
+    { CHAR_MAX+7, string, &sync_mutex, 1, 1, 0, 0, 0, "sync-mutex" },
     { 0, 0, 0, 0, 0, 0, 0, 0, 0 }
   };
 …
 static struct option long_option_aliases[] =
+  {
     { "quiet",          no_argument,            0, 's' },
     { "stop",           no_argument,            0, 'S' },
     { "new-file",       required_argument,      0, 'W' },
     { "assume-new",     required_argument,      0, 'W' },
     { "assume-old",     required_argument,      0, 'o' },
     { "max-load",       optional_argument,      0, 'l' },
     { "dry-run",        no_argument,            0, 'n' },
     { "recon",          no_argument,            0, 'n' },
     { "makefile",       required_argument,      0, 'f' },
+    { "quiet",          no_argument,            0, 's' },
+    { "stop",           no_argument,            0, 'S' },
+    { "new-file",       required_argument,      0, 'W' },
+    { "assume-new",     required_argument,      0, 'W' },
+    { "assume-old",     required_argument,      0, 'o' },
+    { "max-load",       optional_argument,      0, 'l' },
+    { "dry-run",        no_argument,            0, 'n' },
+    { "recon",          no_argument,            0, 'n' },
+    { "makefile",       required_argument,      0, 'f' },
   };
 /* List of goal targets.  */
 static struct dep *goals, *lastgoal;
+static struct goaldep *goals, *lastgoal;
 /* List of variables which were defined on the command line
 …
 /* The name we were invoked with.  */
+#ifdef WINDOWS32
+/* On MS-Windows, we chop off the .exe suffix in 'main', so this
+   cannot be 'const'.  */
 char *program;
+#else
+const char *program;
+#endif
 /* Our current directory before processing any -C options.  */
 …
 struct file *default_file;
 /* Nonzero if we have seen the magic `.POSIX' target.
+/* Nonzero if we have seen the magic '.POSIX' target.
    This turns on pedantic compliance with POSIX.2.  */
 …
 int one_shell;
+/* Nonzero if we have seen the `.NOTPARALLEL' target.
+/* One of OUTPUT_SYNC_* if the "--output-sync" option was given.  This
+   attempts to synchronize the output of parallel jobs such that the results
+   of each job stay together.  */
+int output_sync = OUTPUT_SYNC_NONE;
+/* Nonzero if the "--trace" option was given.  */
+int trace_flag = 0;
+/* Nonzero if we have seen the '.NOTPARALLEL' target.
    This turns off parallel builds for this invocation of make.  */
 …
 int clock_skew_detected;
+/* Map of possible stop characters for searching strings.  */
+#ifndef UCHAR_MAX
+# define UCHAR_MAX 255
+#endif
+unsigned short stopchar_map[UCHAR_MAX + 1] = {0};
+/* If output-sync is enabled we'll collect all the output generated due to
+   options, while reading makefiles, etc.  */
+struct output make_sync;
 /* Mask of signals that are being caught with fatal_error_signal.  */
 #ifdef  POSIX
+#ifdef POSIX
 sigset_t fatal_signal_set;
 #else
 # ifdef HAVE_SIGSETMASK
+# ifdef HAVE_SIGSETMASK
 int fatal_signal_mask;
 # endif
 …
+}
+/* This character map locate stop chars when parsing GNU makefiles.
+   Each element is true if we should stop parsing on that character.  */
+static void
+initialize_stopchar_map (void)
+{
+  int i;
+  stopchar_map[(int)'\0'] = MAP_NUL;
+  stopchar_map[(int)'#'] = MAP_COMMENT;
+  stopchar_map[(int)';'] = MAP_SEMI;
+  stopchar_map[(int)'='] = MAP_EQUALS;
+  stopchar_map[(int)':'] = MAP_COLON;
+  stopchar_map[(int)'%'] = MAP_PERCENT;
+  stopchar_map[(int)'|'] = MAP_PIPE;
+  stopchar_map[(int)'.'] = MAP_DOT | MAP_USERFUNC;
+  stopchar_map[(int)','] = MAP_COMMA;
+  stopchar_map[(int)'$'] = MAP_VARIABLE;
+  stopchar_map[(int)'-'] = MAP_USERFUNC;
+  stopchar_map[(int)'_'] = MAP_USERFUNC;
+  stopchar_map[(int)' '] = MAP_BLANK;
+  stopchar_map[(int)'\t'] = MAP_BLANK;
+  stopchar_map[(int)'/'] = MAP_DIRSEP;
+#if defined(VMS)
+  stopchar_map[(int)':'] |= MAP_DIRSEP;
+  stopchar_map[(int)']'] |= MAP_DIRSEP;
+  stopchar_map[(int)'>'] |= MAP_DIRSEP;
+#elif defined(HAVE_DOS_PATHS)
+  stopchar_map[(int)'\\'] |= MAP_DIRSEP;
+#endif
+  for (i = 1; i <= UCHAR_MAX; ++i)
+    {
+      if (isspace (i) && NONE_SET (stopchar_map[i], MAP_BLANK))
+        /* Don't mark blank characters as newline characters.  */
+        stopchar_map[i] |= MAP_NEWLINE;
+      else if (isalnum (i))
+        stopchar_map[i] |= MAP_USERFUNC;
+    }
+}
 static const char *
 expand_command_line_file (char *name)
+expand_command_line_file (const char *name)
+{
   const char *cp;
 …
   if (name[0] == '\0')
     fatal (NILF, _("empty string invalid as file name"));
+    O (fatal, NILF, _("empty string invalid as file name"));
   if (name[0] == '~')
+    {
       expanded = tilde_expand (name);
       if (expanded != 0)
         name = expanded;
+      if (expanded && expanded[0] != '\0')
+        name = expanded;
+    }
 …
      for names read from makefiles.  It is here for names passed
      on the command line.  */
   while (name[0] == '.' && name[1] == '/' && name[2] != '\0')
+  while (name[0] == '.' && name[1] == '/')
+    {
       name += 2;
+      while (*name == '/')
+        /* Skip following slashes: ".//foo" is "foo", not "/foo".  */
+        ++name;
+    }
+  if (*name == '\0')
+    {
+      /* It was all slashes!  Move back to the dot and truncate
+         it after the first slash, so it becomes just "./".  */
+      do
+        --name;
+      while (name[0] != '.');
+      name[2] = '\0';
+      while (name[0] == '/')
+        /* Skip following slashes: ".//foo" is "foo", not "/foo".  */
+        ++name;
+    }
+  if (name[0] == '\0')
+    {
+      /* Nothing else but one or more "./", maybe plus slashes!  */
+      name = "./";
+    }
   cp = strcache_add (name);
+  if (expanded)
+    free (expanded);
+  free (expanded);
   return cp;
 …
     db_level = DB_ALL;
+  if (!db_flags)
+    return;
+  for (pp=db_flags->list; *pp; ++pp)
+    {
+      const char *p = *pp;
+      while (1)
+        {
+          switch (tolower (p[0]))
+            {
+            case 'a':
+              db_level |= DB_ALL;
+  if (db_flags)
+    for (pp=db_flags->list; *pp; ++pp)
+      {
+        const char *p = *pp;
+        while (1)
+          {
+            switch (tolower (p[0]))
+              {
+              case 'a':
+                db_level |= DB_ALL;
+                break;
+              case 'b':
+                db_level |= DB_BASIC;
+                break;
+              case 'i':
+                db_level |= DB_BASIC | DB_IMPLICIT;
+                break;
+              case 'j':
+                db_level |= DB_JOBS;
+                break;
+              case 'm':
+                db_level |= DB_BASIC | DB_MAKEFILES;
+                break;
+              case 'n':
+                db_level = 0;
+                break;
+              case 'v':
+                db_level |= DB_BASIC | DB_VERBOSE;
+                break;
+              default:
+                OS (fatal, NILF,
+                    _("unknown debug level specification '%s'"), p);
+              }
+            while (*(++p) != '\0')
+              if (*p == ',' || *p == ' ')
+                {
+                  ++p;
+                  break;
+                }
+            if (*p == '\0')
               break;
+            case 'b':
+              db_level |= DB_BASIC;
+              break;
+            case 'i':
+              db_level |= DB_BASIC | DB_IMPLICIT;
+              break;
+            case 'j':
+              db_level |= DB_JOBS;
+              break;
+            case 'm':
+              db_level |= DB_BASIC | DB_MAKEFILES;
+              break;
+            case 'v':
+              db_level |= DB_BASIC | DB_VERBOSE;
+              break;
+            default:
+              fatal (NILF, _("unknown debug level specification `%s'"), p);
+            }
+          while (*(++p) != '\0')
+            if (*p == ',' || *p == ' ')
+              break;
+          if (*p == '\0')
+            break;
+          ++p;
+        }
+    }
+          }
+      }
+  if (db_level)
+    verify_flag = 1;
+  if (! db_level)
+    debug_flag = 0;
+}
+static void
+decode_output_sync_flags (void)
+{
+#ifdef NO_OUTPUT_SYNC
+  output_sync = OUTPUT_SYNC_NONE;
+#else
+  if (output_sync_option)
+    {
+      if (streq (output_sync_option, "none"))
+        output_sync = OUTPUT_SYNC_NONE;
+      else if (streq (output_sync_option, "line"))
+        output_sync = OUTPUT_SYNC_LINE;
+      else if (streq (output_sync_option, "target"))
+        output_sync = OUTPUT_SYNC_TARGET;
+      else if (streq (output_sync_option, "recurse"))
+        output_sync = OUTPUT_SYNC_RECURSE;
+      else
+        OS (fatal, NILF,
+            _("unknown output-sync type '%s'"), output_sync_option);
+    }
+  if (sync_mutex)
+    RECORD_SYNC_MUTEX (sync_mutex);
+#endif
+}
 #ifdef WINDOWS32
+#ifndef NO_OUTPUT_SYNC
+/* This is called from start_job_command when it detects that
+   output_sync option is in effect.  The handle to the synchronization
+   mutex is passed, as a string, to sub-makes via the --sync-mutex
+   command-line argument.  */
+void
+prepare_mutex_handle_string (sync_handle_t handle)
+{
+  if (!sync_mutex)
+    {
+      /* Prepare the mutex handle string for our children.  */
+      /* 2 hex digits per byte + 2 characters for "0x" + null.  */
+      sync_mutex = xmalloc ((2 * sizeof (sync_handle_t)) + 2 + 1);
+      sprintf (sync_mutex, "0x%Ix", handle);
+      define_makeflags (1, 0);
+    }
+}
+#endif  /* NO_OUTPUT_SYNC */
 /*
  * HANDLE runtime exceptions by avoiding a requestor on the GUI. Capture
 …
  */
 LONG WINAPI
 handle_runtime_exceptions( struct _EXCEPTION_POINTERS *exinfo )
+handle_runtime_exceptions (struct _EXCEPTION_POINTERS *exinfo)
+{
   PEXCEPTION_RECORD exrec = exinfo->ExceptionRecord;
   LPSTR cmdline = GetCommandLine();
   LPSTR prg = strtok(cmdline, " ");
+  LPSTR cmdline = GetCommandLine ();
+  LPSTR prg = strtok (cmdline, " ");
   CHAR errmsg[1024];
 #ifdef USE_EVENT_LOG
 …
   if (! ISDB (DB_VERBOSE))
+    {
       sprintf(errmsg,
               _("%s: Interrupt/Exception caught (code = 0x%lx, addr = 0x%p)\n"),
               prg, exrec->ExceptionCode, exrec->ExceptionAddress);
       fprintf(stderr, errmsg);
       exit(255);
+    }
   sprintf(errmsg,
           _("\nUnhandled exception filter called from program %s\nExceptionCode = %lx\nExceptionFlags = %lx\nExceptionAddress = 0x%p\n"),
           prg, exrec->ExceptionCode, exrec->ExceptionFlags,
           exrec->ExceptionAddress);
+      sprintf (errmsg,
+               _("%s: Interrupt/Exception caught (code = 0x%lx, addr = 0x%p)\n"),
+               prg, exrec->ExceptionCode, exrec->ExceptionAddress);
+      fprintf (stderr, errmsg);
+      exit (255);
+    }
+  sprintf (errmsg,
+           _("\nUnhandled exception filter called from program %s\nExceptionCode = %lx\nExceptionFlags = %lx\nExceptionAddress = 0x%p\n"),
+           prg, exrec->ExceptionCode, exrec->ExceptionFlags,
+           exrec->ExceptionAddress);
   if (exrec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION
       && exrec->NumberParameters >= 2)
     sprintf(&errmsg[strlen(errmsg)],
             (exrec->ExceptionInformation[0]
              ? _("Access violation: write operation at address 0x%p\n")
              : _("Access violation: read operation at address 0x%p\n")),
             (PVOID)exrec->ExceptionInformation[1]);
+    sprintf (&errmsg[strlen(errmsg)],
+             (exrec->ExceptionInformation[0]
+              ? _("Access violation: write operation at address 0x%p\n")
+              : _("Access violation: read operation at address 0x%p\n")),
+             (PVOID)exrec->ExceptionInformation[1]);
   /* turn this on if we want to put stuff in the event log too */
 #ifdef USE_EVENT_LOG
   hEventSource = RegisterEventSource(NULL, "GNU Make");
+  hEventSource = RegisterEventSource (NULL, "GNU Make");
   lpszStrings[0] = errmsg;
   if (hEventSource != NULL)
+    {
       ReportEvent(hEventSource,         /* handle of event source */
                   EVENTLOG_ERROR_TYPE,  /* event type */
 ,                    /* event category */
 ,                    /* event ID */
                   NULL,                 /* current user's SID */
 ,                    /* strings in lpszStrings */
 ,                    /* no bytes of raw data */
                   lpszStrings,          /* array of error strings */
                   NULL);                /* no raw data */
       (VOID) DeregisterEventSource(hEventSource);
+      ReportEvent (hEventSource,         /* handle of event source */
+                   EVENTLOG_ERROR_TYPE,  /* event type */
+,                    /* event category */
+,                    /* event ID */
+                   NULL,                 /* current user's SID */
+,                    /* strings in lpszStrings */
+,                    /* no bytes of raw data */
+                   lpszStrings,          /* array of error strings */
+                   NULL);                /* no raw data */
+      (VOID) DeregisterEventSource (hEventSource);
+    }
 #endif
   /* Write the error to stderr too */
   fprintf(stderr, errmsg);
+  fprintf (stderr, errmsg);
 #ifdef DEBUG
   return EXCEPTION_CONTINUE_SEARCH;
 #else
   exit(255);
+  exit (255);
   return (255); /* not reached */
 #endif
 …
  * On WIN32 systems we don't have the luxury of a /bin directory that
  * is mapped globally to every drive mounted to the system. Since make could
  * be invoked from any drive, and we don't want to propogate /bin/sh
+ * be invoked from any drive, and we don't want to propagate /bin/sh
  * to every single drive. Allow ourselves a chance to search for
  * a value for default shell here (if the default path does not exist).
 …
   int sh_found = 0;
   char *atoken = 0;
   char *search_token;
   char *tokend;
+  const char *search_token;
+  const char *tokend;
   PATH_VAR(sh_path);
   extern char *default_shell;
+  extern const char *default_shell;
   if (!token)
     search_token = default_shell;
   else
     atoken = search_token = xstrdup (token);
+    search_token = atoken = xstrdup (token);
   /* If the user explicitly requests the DOS cmd shell, obey that request.
 …
            || (tokend - 4 > search_token
                && (tokend[-5] == '/' || tokend[-5] == '\\')))
+          && !strcasecmp (tokend - 4, "cmd.exe"))) {
+    batch_mode_shell = 1;
+    unixy_shell = 0;
+    sprintf (sh_path, "%s", search_token);
+    default_shell = xstrdup (w32ify (sh_path, 0));
+    DB (DB_VERBOSE, (_("find_and_set_shell() setting default_shell = %s\n"),
+                     default_shell));
+    sh_found = 1;
+  } else if (!no_default_sh_exe &&
+             (token == NULL || !strcmp (search_token, default_shell))) {
+    /* no new information, path already set or known */
+    sh_found = 1;
+  } else if (file_exists_p (search_token)) {
+    /* search token path was found */
+    sprintf (sh_path, "%s", search_token);
+    default_shell = xstrdup (w32ify (sh_path, 0));
+    DB (DB_VERBOSE, (_("find_and_set_shell() setting default_shell = %s\n"),
+                     default_shell));
+    sh_found = 1;
+  } else {
+    char *p;
+    struct variable *v = lookup_variable (STRING_SIZE_TUPLE ("PATH"));
+    /* Search Path for shell */
+    if (v && v->value) {
+      char *ep;
+      p  = v->value;
+      ep = strchr (p, PATH_SEPARATOR_CHAR);
+      while (ep && *ep) {
+        *ep = '\0';
+        if (dir_file_exists_p (p, search_token)) {
+          sprintf (sh_path, "%s/%s", p, search_token);
+          default_shell = xstrdup (w32ify (sh_path, 0));
+          sh_found = 1;
+          *ep = PATH_SEPARATOR_CHAR;
+          /* terminate loop */
+          p += strlen (p);
+        } else {
+          *ep = PATH_SEPARATOR_CHAR;
+           p = ++ep;
+          && !strcasecmp (tokend - 4, "cmd.exe")))
+    {
+      batch_mode_shell = 1;
+      unixy_shell = 0;
+      sprintf (sh_path, "%s", search_token);
+      default_shell = xstrdup (w32ify (sh_path, 0));
+      DB (DB_VERBOSE, (_("find_and_set_shell() setting default_shell = %s\n"),
+                       default_shell));
+      sh_found = 1;
+    }
+  else if (!no_default_sh_exe
+           && (token == NULL || !strcmp (search_token, default_shell)))
+    {
+      /* no new information, path already set or known */
+      sh_found = 1;
+    }
+  else if (_access (search_token, 0) == 0)
+    {
+      /* search token path was found */
+      sprintf (sh_path, "%s", search_token);
+      default_shell = xstrdup (w32ify (sh_path, 0));
+      DB (DB_VERBOSE, (_("find_and_set_shell() setting default_shell = %s\n"),
+                       default_shell));
+      sh_found = 1;
+    }
+  else
+    {
+      char *p;
+      struct variable *v = lookup_variable (STRING_SIZE_TUPLE ("PATH"));
+      /* Search Path for shell */
+      if (v && v->value)
+        {
+          char *ep;
+          p  = v->value;
+          ep = strchr (p, PATH_SEPARATOR_CHAR);
+          while (ep && *ep)
+            {
+              *ep = '\0';
+              sprintf (sh_path, "%s/%s", p, search_token);
+              if (_access (sh_path, 0) == 0)
+                {
+                  default_shell = xstrdup (w32ify (sh_path, 0));
+                  sh_found = 1;
+                  *ep = PATH_SEPARATOR_CHAR;
+                  /* terminate loop */
+                  p += strlen (p);
+                }
+              else
+                {
+                  *ep = PATH_SEPARATOR_CHAR;
+                  p = ++ep;
+                }
+              ep = strchr (p, PATH_SEPARATOR_CHAR);
+            }
+          /* be sure to check last element of Path */
+          if (p && *p)
+            {
+              sprintf (sh_path, "%s/%s", p, search_token);
+              if (_access (sh_path, 0) == 0)
+                {
+                  default_shell = xstrdup (w32ify (sh_path, 0));
+                  sh_found = 1;
+                }
+            }
+          if (sh_found)
+            DB (DB_VERBOSE,
+                (_("find_and_set_shell() path search set default_shell = %s\n"),
+                 default_shell));
+        }
+        ep = strchr (p, PATH_SEPARATOR_CHAR);
+      }
+      /* be sure to check last element of Path */
+      if (p && *p && dir_file_exists_p (p, search_token)) {
+          sprintf (sh_path, "%s/%s", p, search_token);
+          default_shell = xstrdup (w32ify (sh_path, 0));
+          sh_found = 1;
+      }
+      if (sh_found)
+        DB (DB_VERBOSE,
+            (_("find_and_set_shell() path search set default_shell = %s\n"),
+             default_shell));
+    }
+  }
+    }
   /* naive test */
+  if (!unixy_shell && sh_found &&
+      (strstr (default_shell, "sh") || strstr (default_shell, "SH"))) {
+    unixy_shell = 1;
+    batch_mode_shell = 0;
+  }
+  if (!unixy_shell && sh_found
+      && (strstr (default_shell, "sh") || strstr (default_shell, "SH")))
+    {
+      unixy_shell = 1;
+      batch_mode_shell = 0;
+    }
 #ifdef BATCH_MODE_ONLY_SHELL
 …
 #endif
+  if (atoken)
+    free (atoken);
+  free (atoken);
   return (sh_found);
 …
 #endif  /* __MSDOS__ */
+char *mktemp (char *template);
+int mkstemp (char *template);
+FILE *
+open_tmpfile(char **name, const char *template)
+static void
+reset_jobserver (void)
+{
+#ifdef HAVE_FDOPEN
+  int fd;
+#endif
+#if defined HAVE_MKSTEMP || defined HAVE_MKTEMP
+# define TEMPLATE_LEN   strlen (template)
+#else
+# define TEMPLATE_LEN   L_tmpnam
+#endif
+  *name = xmalloc (TEMPLATE_LEN + 1);
+  strcpy (*name, template);
+#if defined HAVE_MKSTEMP && defined HAVE_FDOPEN
+  /* It's safest to use mkstemp(), if we can.  */
+  fd = mkstemp (*name);
+  if (fd == -1)
+    return 0;
+  return fdopen (fd, "w");
+#else
+# ifdef HAVE_MKTEMP
+  (void) mktemp (*name);
+# else
+  (void) tmpnam (*name);
+# endif
+# ifdef HAVE_FDOPEN
+  /* Can't use mkstemp(), but guard against a race condition.  */
+  fd = open (*name, O_CREAT|O_EXCL|O_WRONLY, 0600);
+  if (fd == -1)
+    return 0;
+  return fdopen (fd, "w");
+# else
+  /* Not secure, but what can we do?  */
+  return fopen (*name, "w");
+# endif
+#endif
+  jobserver_clear ();
+  free (jobserver_auth);
+  jobserver_auth = NULL;
+}
 #ifdef _AMIGA
 …
   static char *stdin_nm = 0;
   int makefile_status = MAKE_SUCCESS;
   struct dep *read_makefiles;
+  struct goaldep *read_files;
   PATH_VAR (current_directory);
   unsigned int restarts = 0;
+  unsigned int syncing = 0;
+  int argv_slots;
 #ifdef WINDOWS32
   char *unix_path = NULL;
   char *windows32_path = NULL;
   SetUnhandledExceptionFilter(handle_runtime_exceptions);
+  const char *unix_path = NULL;
+  const char *windows32_path = NULL;
+  SetUnhandledExceptionFilter (handle_runtime_exceptions);
   /* start off assuming we have no shell */
 …
   no_default_sh_exe = 1;
 #endif
+  output_init (&make_sync);
+  initialize_stopchar_map();
 #ifdef SET_STACK_SIZE
 …
 #endif
-#ifdef HAVE_ATEXIT
-  atexit (close_stdout);
-#endif
   /* Needed for OS/2 */
+  initialize_main(&argc, &argv);
+  reading_file = 0;
+  initialize_main (&argc, &argv);
+#ifdef MAKE_MAINTAINER_MODE
+  /* In maintainer mode we always enable verification.  */
+  verify_flag = 1;
+#endif
 #if defined (__MSDOS__) && !defined (_POSIX_SOURCE)
   /* Request the most powerful version of `system', to
+  /* Request the most powerful version of 'system', to
      make up for the dumb default shell.  */
   __system_flags = (__system_redirect
                     | __system_use_shell
                     | __system_allow_multiple_cmds
                     | __system_allow_long_cmds
                     | __system_handle_null_commands
                     | __system_emulate_chdir);
+                    | __system_use_shell
+                    | __system_allow_multiple_cmds
+                    | __system_allow_long_cmds
+                    | __system_handle_null_commands
+                    | __system_emulate_chdir);
 #endif
 …
   (void)textdomain (PACKAGE);
 #ifdef  POSIX
+#ifdef  POSIX
   sigemptyset (&fatal_signal_set);
 #define ADD_SIG(sig)    sigaddset (&fatal_signal_set, sig)
+#define ADD_SIG(sig)    sigaddset (&fatal_signal_set, sig)
 #else
 #ifdef  HAVE_SIGSETMASK
+#ifdef  HAVE_SIGSETMASK
   fatal_signal_mask = 0;
 #define ADD_SIG(sig)    fatal_signal_mask |= sigmask (sig)
+#define ADD_SIG(sig)    fatal_signal_mask |= sigmask (sig)
 #else
 #define ADD_SIG(sig)    (void)sig      /* Needed to avoid warnings in MSVC.  */
 #endif
 #endif
 #define FATAL_SIG(sig)                                                        \
   if (bsd_signal (sig, fatal_error_signal) == SIG_IGN)                        \
     bsd_signal (sig, SIG_IGN);                                                \
   else                                                                        \
+#define ADD_SIG(sig)    (void)sig
+#endif
+#endif
+#define FATAL_SIG(sig)                                                        \
+  if (bsd_signal (sig, fatal_error_signal) == SIG_IGN)                        \
+    bsd_signal (sig, SIG_IGN);                                                \
+  else                                                                        \
     ADD_SIG (sig);
 …
 #endif
 #ifdef  SIGDANGER
+#ifdef  SIGDANGER
   FATAL_SIG (SIGDANGER);
 #endif
 …
 #endif
 #undef  FATAL_SIG
+#undef  FATAL_SIG
   /* Do not ignore the child-death signal.  This must be done before
 …
 #endif
+  /* Make sure stdout is line-buffered.  */
+#ifdef HAVE_SETVBUF
+# ifdef SETVBUF_REVERSED
+  setvbuf (stdout, _IOLBF, xmalloc (BUFSIZ), BUFSIZ);
+# else  /* setvbuf not reversed.  */
+  /* Some buggy systems lose if we pass 0 instead of allocating ourselves.  */
+  setvbuf (stdout, 0, _IOLBF, BUFSIZ);
+# endif /* setvbuf reversed.  */
+#elif HAVE_SETLINEBUF
+  setlinebuf (stdout);
+#endif  /* setlinebuf missing.  */
+  output_init (NULL);
   /* Figure out where this program lives.  */
   if (argv[0] == 0)
     argv[0] = "";
+    argv[0] = (char *)"";
   if (argv[0][0] == '\0')
     program = "make";
   else
+    {
-#ifdef VMS
-      program = strrchr (argv[0], ']');
-#else
       program = strrchr (argv[0], '/');
-#endif
 #if defined(__MSDOS__) || defined(__EMX__)
       if (program == 0)
         program = strrchr (argv[0], '\\');
+        program = strrchr (argv[0], '\\');
       else
+        {
           /* Some weird environments might pass us argv[0] with
              both kinds of slashes; we must find the rightmost.  */
           char *p = strrchr (argv[0], '\\');
           if (p && p > program)
             program = p;
+        }
+        {
+          /* Some weird environments might pass us argv[0] with
+             both kinds of slashes; we must find the rightmost.  */
+          char *p = strrchr (argv[0], '\\');
+          if (p && p > program)
+            program = p;
+        }
       if (program == 0 && argv[0][1] == ':')
         program = argv[0] + 1;
+        program = argv[0] + 1;
 #endif
 #ifdef WINDOWS32
 …
+        {
           /* Extract program from full path */
-          int argv0_len;
           program = strrchr (argv[0], '\\');
           if (program)
+            {
               argv0_len = strlen(program);
+              int argv0_len = strlen (program);
               if (argv0_len > 4 && streq (&program[argv0_len - 4], ".exe"))
                 /* Remove .exe extension */
 …
+        }
 #endif
+#ifdef VMS
+      set_program_name (argv[0]);
+      program = program_name;
+      {
+        const char *shell;
+        char pwdbuf[256];
+        char *pwd;
+        shell = getenv ("SHELL");
+        if (shell != NULL)
+          vms_gnv_shell = 1;
+        /* Need to know if CRTL set to report UNIX paths.  Use getcwd as
+           it works on all versions of VMS. */
+        pwd = getcwd(pwdbuf, 256);
+        if (pwd[0] == '/')
+          vms_report_unix_paths = 1;
+        vms_use_mcr_command = get_vms_env_flag ("GNV$MAKE_USE_MCR", 0);
+        vms_always_use_cmd_file = get_vms_env_flag ("GNV$MAKE_USE_CMD_FILE", 0);
+        /* Legacy behavior is on VMS is older behavior that needed to be
+           changed to be compatible with standard make behavior.
+           For now only completely disable when running under a Bash shell.
+           TODO: Update VMS built in recipes and macros to not need this
+           behavior, at which time the default may change. */
+        vms_legacy_behavior = get_vms_env_flag ("GNV$MAKE_OLD_VMS",
+                                                !vms_gnv_shell);
+        /* VMS was changed to use a comma separator in the past, but that is
+           incompatible with built in functions that expect space separated
+           lists.  Allow this to be selectively turned off. */
+        vms_comma_separator = get_vms_env_flag ("GNV$MAKE_COMMA",
+                                                vms_legacy_behavior);
+        /* Some Posix shell syntax options are incompatible with VMS syntax.
+           VMS requires double quotes for strings and escapes quotes
+           differently.  When this option is active, VMS will try
+           to simulate Posix shell simulations instead of using
+           VMS DCL behavior. */
+        vms_unix_simulation = get_vms_env_flag ("GNV$MAKE_SHELL_SIM",
+                                                !vms_legacy_behavior);
+      }
+      if (need_vms_symbol () && !vms_use_mcr_command)
+        create_foreign_command (program_name, argv[0]);
+#else
       if (program == 0)
         program = argv[0];
+        program = argv[0];
       else
+        ++program;
+        ++program;
+#endif
+    }
 …
 #endif
+    {
 #ifdef  HAVE_GETCWD
+#ifdef  HAVE_GETCWD
       perror_with_name ("getcwd", "");
 #else
       error (NILF, "getwd: %s", current_directory);
+      OS (error, NILF, "getwd: %s", current_directory);
 #endif
       current_directory[0] = '\0';
 …
   else
     directory_before_chdir = xstrdup (current_directory);
 #ifdef  __MSDOS__
   /* Make sure we will return to the initial directory, come what may.  */
 …
   define_variable_cname (".RECIPEPREFIX", "", o_default, 0)->special = 1;
   define_variable_cname (".SHELLFLAGS", "-c", o_default, 0);
+  define_variable_cname (".LOADED", "", o_default, 0);
   /* Set up .FEATURES
      We must do this in multiple calls because define_variable_cname() is
      a macro and some compilers (MSVC) don't like conditionals in macros.  */
+     Use a separate variable because define_variable_cname() is a macro and
+     some compilers (MSVC) don't like conditionals in macros.  */
+  {
     const char *features = "target-specific order-only second-expansion"
                            " else-if shortest-stem undefine"
+                           " else-if shortest-stem undefine oneshell"
 #ifndef NO_ARCHIVES
                            " archives"
 …
                            " jobserver"
 #endif
+#ifndef NO_OUTPUT_SYNC
+                           " output-sync"
+#endif
 #ifdef MAKE_SYMLINKS
                            " check-symlink"
 #endif
+#ifdef HAVE_GUILE
+                           " guile"
+#endif
+#ifdef MAKE_LOAD
+                           " load"
+#endif
+                           ;
     define_variable_cname (".FEATURES", features, o_default, 0);
+  }
+  /* Configure GNU Guile support */
+  guile_gmake_setup (NILF);
   /* Read in variables from the environment.  It is important that this be
 …
     for (i = 0; envp[i] != 0; ++i)
+      {
+        int do_not_define = 0;
+        char *ep = envp[i];
+        while (*ep != '\0' && *ep != '=')
+        struct variable *v;
+        const char *ep = envp[i];
+        /* By default, export all variables culled from the environment.  */
+        enum variable_export export = v_export;
+        unsigned int len;
+        while (! STOP_SET (*ep, MAP_EQUALS))
           ++ep;
+        /* If there's no equals sign it's a malformed environment.  Ignore.  */
+        if (*ep == '\0')
+          continue;
 #ifdef WINDOWS32
         if (!unix_path && strneq(envp[i], "PATH=", 5))
+        if (!unix_path && strneq (envp[i], "PATH=", 5))
           unix_path = ep+1;
+        else if (!strnicmp(envp[i], "Path=", 5)) {
+          do_not_define = 1; /* it gets defined after loop exits */
+          if (!windows32_path)
+            windows32_path = ep+1;
+        }
+#endif
+        /* The result of pointer arithmetic is cast to unsigned int for
+           machines where ptrdiff_t is a different size that doesn't widen
+           the same.  */
+        if (!do_not_define)
+        else if (!strnicmp (envp[i], "Path=", 5))
+          {
+            struct variable *v;
+            v = define_variable (envp[i], (unsigned int) (ep - envp[i]),
+                                 ep + 1, o_env, 1);
+            /* Force exportation of every variable culled from the
+               environment.  We used to rely on target_environment's
+               v_default code to do this.  But that does not work for the
+               case where an environment variable is redefined in a makefile
+               with `override'; it should then still be exported, because it
+               was originally in the environment.  */
+            v->export = v_export;
+            /* Another wrinkle is that POSIX says the value of SHELL set in
+               the makefile won't change the value of SHELL given to
+               subprocesses.  */
+            if (streq (v->name, "SHELL"))
+            if (!windows32_path)
+              windows32_path = ep+1;
+            /* PATH gets defined after the loop exits.  */
+            continue;
+          }
+#endif
+        /* Length of the variable name, and skip the '='.  */
+        len = ep++ - envp[i];
+        /* If this is MAKE_RESTARTS, check to see if the "already printed
+           the enter statement" flag is set.  */
+        if (len == 13 && strneq (envp[i], "MAKE_RESTARTS", 13))
+          {
+            if (*ep == '-')
+              {
+                OUTPUT_TRACED ();
+                ++ep;
+              }
+            restarts = (unsigned int) atoi (ep);
+            export = v_noexport;
+          }
+        v = define_variable (envp[i], len, ep, o_env, 1);
+        /* POSIX says the value of SHELL set in the makefile won't change the
+           value of SHELL given to subprocesses.  */
+        if (streq (v->name, "SHELL"))
+          {
 #ifndef __MSDOS__
+                v->export = v_noexport;
+#endif
+                shell_var.name = "SHELL";
+                shell_var.length = 5;
+                shell_var.value = xstrdup (ep + 1);
+              }
+            /* If MAKE_RESTARTS is set, remember it but don't export it.  */
+            if (streq (v->name, "MAKE_RESTARTS"))
+              {
+                v->export = v_noexport;
+                restarts = (unsigned int) atoi (ep + 1);
+              }
+            export = v_noexport;
+#endif
+            shell_var.name = xstrdup ("SHELL");
+            shell_var.length = 5;
+            shell_var.value = xstrdup (ep);
+          }
+        v->export = export;
+      }
+  }
 #ifdef WINDOWS32
     /* If we didn't find a correctly spelled PATH we define PATH as
      * either the first mispelled value or an empty string
+     * either the first misspelled value or an empty string
      */
     if (!unix_path)
 …
 #else /* For Amiga, read the ENV: device, ignoring all dirs */
+    {
+        BPTR env, file, old;
+        char buffer[1024];
+        int len;
+        __aligned struct FileInfoBlock fib;
+        env = Lock ("ENV:", ACCESS_READ);
+        if (env)
+        {
+            old = CurrentDir (DupLock(env));
+            Examine (env, &fib);
+            while (ExNext (env, &fib))
+            {
+                if (fib.fib_DirEntryType < 0) /* File */
+                {
+                    /* Define an empty variable. It will be filled in
+                        variable_lookup(). Makes startup quite a bit
+                        faster. */
+                        define_variable (fib.fib_FileName,
+                            strlen (fib.fib_FileName),
+                        "", o_env, 1)->export = v_export;
+                }
+            }
+            UnLock (env);
+            UnLock(CurrentDir(old));
+        }
+        BPTR env, file, old;
+        char buffer[1024];
+        int len;
+        __aligned struct FileInfoBlock fib;
+        env = Lock ("ENV:", ACCESS_READ);
+        if (env)
+          {
+            old = CurrentDir (DupLock (env));
+            Examine (env, &fib);
+            while (ExNext (env, &fib))
+              {
+                if (fib.fib_DirEntryType < 0) /* File */
+                  {
+                    /* Define an empty variable. It will be filled in
+                       variable_lookup(). Makes startup quite a bit faster. */
+                    define_variable (fib.fib_FileName,
+                                     strlen (fib.fib_FileName),
+                                     "", o_env, 1)->export = v_export;
+                  }
+              }
+            UnLock (env);
+            UnLock (CurrentDir (old));
+          }
+    }
 #endif
   /* Decode the switches.  */
+  decode_env_switches (STRING_SIZE_TUPLE ("GNUMAKEFLAGS"));
+  /* Clear GNUMAKEFLAGS to avoid duplication.  */
+  define_variable_cname ("GNUMAKEFLAGS", "", o_env, 0);
   decode_env_switches (STRING_SIZE_TUPLE ("MAKEFLAGS"));
 #if 0
   /* People write things like:
 …
 #endif
+  decode_switches (argc, argv, 0);
+  /* In output sync mode we need to sync any output generated by reading the
+     makefiles, such as in $(info ...) or stderr from $(shell ...) etc.  */
+  syncing = make_sync.syncout = (output_sync == OUTPUT_SYNC_LINE
+                                 || output_sync == OUTPUT_SYNC_TARGET);
+  OUTPUT_SET (&make_sync);
+  /* Remember the job slots set through the environment vs. command line.  */
+  {
+    int env_slots = arg_job_slots;
+    arg_job_slots = INVALID_JOB_SLOTS;
+    decode_switches (argc, (const char **)argv, 0);
+    argv_slots = arg_job_slots;
+    if (arg_job_slots == INVALID_JOB_SLOTS)
+      arg_job_slots = env_slots;
+  }
+  /* Set a variable specifying whether stdout/stdin is hooked to a TTY.  */
+#ifdef HAVE_ISATTY
+  if (isatty (fileno (stdout)))
+    if (! lookup_variable (STRING_SIZE_TUPLE ("MAKE_TERMOUT")))
+      {
+        const char *tty = TTYNAME (fileno (stdout));
+        define_variable_cname ("MAKE_TERMOUT", tty ? tty : DEFAULT_TTYNAME,
+                               o_default, 0)->export = v_export;
+      }
+  if (isatty (fileno (stderr)))
+    if (! lookup_variable (STRING_SIZE_TUPLE ("MAKE_TERMERR")))
+      {
+        const char *tty = TTYNAME (fileno (stderr));
+        define_variable_cname ("MAKE_TERMERR", tty ? tty : DEFAULT_TTYNAME,
+                               o_default, 0)->export = v_export;
+      }
+#endif
+  /* Reset in case the switches changed our minds.  */
+  syncing = (output_sync == OUTPUT_SYNC_LINE
+             || output_sync == OUTPUT_SYNC_TARGET);
+  if (make_sync.syncout && ! syncing)
+    output_close (&make_sync);
+  make_sync.syncout = syncing;
+  OUTPUT_SET (&make_sync);
+  /* Figure out the level of recursion.  */
+  {
+    struct variable *v = lookup_variable (STRING_SIZE_TUPLE (MAKELEVEL_NAME));
+    if (v && v->value[0] != '\0' && v->value[0] != '-')
+      makelevel = (unsigned int) atoi (v->value);
+    else
+      makelevel = 0;
+  }
 #ifdef WINDOWS32
+  if (suspend_flag) {
+        fprintf(stderr, "%s (pid = %ld)\n", argv[0], GetCurrentProcessId());
+        fprintf(stderr, _("%s is suspending for 30 seconds..."), argv[0]);
+        Sleep(30 * 1000);
+        fprintf(stderr, _("done sleep(30). Continuing.\n"));
+  }
+#endif
+  decode_debug_flags ();
+  if (suspend_flag)
+    {
+      fprintf (stderr, "%s (pid = %ld)\n", argv[0], GetCurrentProcessId ());
+      fprintf (stderr, _("%s is suspending for 30 seconds..."), argv[0]);
+      Sleep (30 * 1000);
+      fprintf (stderr, _("done sleep(30). Continuing.\n"));
+    }
+#endif
   /* Set always_make_flag if -B was given and we've not restarted already.  */
   always_make_flag = always_make_set && (restarts == 0);
   /* Print version information.  */
   if (print_version_flag || print_data_base_flag || db_level)
+  /* Print version information, and exit.  */
+  if (print_version_flag)
+    {
       print_version ();
       /* `make --version' is supposed to just print the version and exit.  */
+      if (print_version_flag)
         die (0);
+    }
+      die (MAKE_SUCCESS);
+    }
+  if (ISDB (DB_BASIC))
+    print_version ();
 #ifndef VMS
 …
    * CreateProcess().
    */
+  if (strpbrk(argv[0], "/:\\") ||
+      strstr(argv[0], "..") ||
+      strneq(argv[0], "//", 2))
+    argv[0] = xstrdup(w32ify(argv[0],1));
+  if (strpbrk (argv[0], "/:\\") || strstr (argv[0], "..")
+      || strneq (argv[0], "//", 2))
+    argv[0] = xstrdup (w32ify (argv[0], 1));
 #else /* WINDOWS32 */
 #if defined (__MSDOS__) || defined (__EMX__)
 …
       argv[0] = xstrdup (argv[0]);
       for (p = argv[0]; *p; p++)
         if (*p == '\\')
           *p = '/';
+        if (*p == '\\')
+          *p = '/';
+    }
   /* If argv[0] is not in absolute form, prepend the current
 …
 #endif
+  /* We may move, but until we do, here we are.  */
+  starting_directory = current_directory;
+  /* Set up the job_slots value and the jobserver.  This can't be usefully set
+     in the makefile, and we want to verify the authorization is valid before
+     make has a chance to start using it for something else.  */
+  if (jobserver_auth)
+    {
+      if (argv_slots == INVALID_JOB_SLOTS)
+        {
+          if (jobserver_parse_auth (jobserver_auth))
+            {
+              /* Success!  Use the jobserver.  */
+              job_slots = 0;
+              goto job_setup_complete;
+            }
+          O (error, NILF, _("warning: jobserver unavailable: using -j1.  Add '+' to parent make rule."));
+          arg_job_slots = 1;
+        }
+      /* The user provided a -j setting on the command line: use it.  */
+      else if (!restarts)
+        /* If restarts is >0 we already printed this message.  */
+        O (error, NILF,
+           _("warning: -jN forced in submake: disabling jobserver mode."));
+      /* We failed to use our parent's jobserver.  */
+      reset_jobserver ();
+      job_slots = (unsigned int)arg_job_slots;
+    }
+  else if (arg_job_slots == INVALID_JOB_SLOTS)
+    /* The default is one job at a time.  */
+    job_slots = 1;
+  else
+    /* Use whatever was provided.  */
+    job_slots = (unsigned int)arg_job_slots;
+ job_setup_complete:
   /* The extra indirection through $(MAKE_COMMAND) is done
      for hysterical raisins.  */
+#ifdef VMS
+  if (vms_use_mcr_command)
+    define_variable_cname ("MAKE_COMMAND", vms_command (argv[0]), o_default, 0);
+  else
+    define_variable_cname ("MAKE_COMMAND", program, o_default, 0);
+#else
   define_variable_cname ("MAKE_COMMAND", argv[0], o_default, 0);
+#endif
   define_variable_cname ("MAKE", "$(MAKE_COMMAND)", o_default, 1);
 …
       /* Figure out how much space will be taken up by the command-line
          variable definitions.  */
+         variable definitions.  */
       for (cv = command_variables; cv != 0; cv = cv->next)
+        {
           v = cv->variable;
           len += 2 * strlen (v->name);
           if (! v->recursive)
             ++len;
           ++len;
           len += 2 * strlen (v->value);
           ++len;
+        }
+        {
+          v = cv->variable;
+          len += 2 * strlen (v->name);
+          if (! v->recursive)
+            ++len;
+          ++len;
+          len += 2 * strlen (v->value);
+          ++len;
+        }
       /* Now allocate a buffer big enough and fill it.  */
       p = value = alloca (len);
       for (cv = command_variables; cv != 0; cv = cv->next)
+        {
           v = cv->variable;
           p = quote_for_env (p, v->name);
           if (! v->recursive)
             *p++ = ':';
           *p++ = '=';
           p = quote_for_env (p, v->value);
           *p++ = ' ';
+        }
       p[-1] = '\0';             /* Kill the final space and terminate.  */
+        {
+          v = cv->variable;
+          p = quote_for_env (p, v->name);
+          if (! v->recursive)
+            *p++ = ':';
+          *p++ = '=';
+          p = quote_for_env (p, v->value);
+          *p++ = ' ';
+        }
+      p[-1] = '\0';             /* Kill the final space and terminate.  */
       /* Define an unchangeable variable with a name that no POSIX.2
          makefile could validly use for its own variable.  */
+         makefile could validly use for its own variable.  */
       define_variable_cname ("-*-command-variables-*-", value, o_automatic, 0);
 …
       define_variable_cname ("MAKEOVERRIDES", "${-*-command-variables-*-}",
                              o_env, 1);
+#ifdef VMS
+      vms_export_dcl_symbol ("MAKEOVERRIDES", "${-*-command-variables-*-}");
+#endif
+    }
 …
    * at the wrong place when it was first evaluated.
    */
+   no_default_sh_exe = !find_and_set_default_shell(NULL);
+   no_default_sh_exe = !find_and_set_default_shell (NULL);
 #endif /* WINDOWS32 */
-  /* Figure out the level of recursion.  */
+  {
-    struct variable *v = lookup_variable (STRING_SIZE_TUPLE (MAKELEVEL_NAME));
-    if (v != 0 && v->value[0] != '\0' && v->value[0] != '-')
-      makelevel = (unsigned int) atoi (v->value);
-    else
-      makelevel = 0;
+  }
   /* Except under -s, always do -w in sub-makes and under -C.  */
 …
                           ? 0 : include_directories->list);
+  /* Figure out where we are now, after chdir'ing.  */
+  if (directories == 0)
+    /* We didn't move, so we're still in the same place.  */
+    starting_directory = current_directory;
+  else
+  /* If we chdir'ed, figure out where we are now.  */
+  if (directories)
+    {
 #ifdef WINDOWS32
 …
       if (getcwd (current_directory, GET_PATH_MAX) == 0)
 #endif
+        {
 #ifdef  HAVE_GETCWD
           perror_with_name ("getcwd", "");
+        {
+#ifdef  HAVE_GETCWD
+          perror_with_name ("getcwd", "");
 #else
           error (NILF, "getwd: %s", current_directory);
 #endif
           starting_directory = 0;
+        }
+          OS (error, NILF, "getwd: %s", current_directory);
+#endif
+          starting_directory = 0;
+        }
       else
         starting_directory = current_directory;
+        starting_directory = current_directory;
+    }
 …
       unsigned int i;
       for (i = 0; i < makefiles->idx; ++i)
+        if (makefiles->list[i][0] == '-' && makefiles->list[i][1] == '\0')
+          {
+            /* This makefile is standard input.  Since we may re-exec
+               and thus re-read the makefiles, we read standard input
+               into a temporary file and read from that.  */
+            FILE *outfile;
+            char *template, *tmpdir;
+        if (makefiles->list[i][0] == '-' && makefiles->list[i][1] == '\0')
+          {
+            /* This makefile is standard input.  Since we may re-exec
+               and thus re-read the makefiles, we read standard input
+               into a temporary file and read from that.  */
+            FILE *outfile;
+            char *template;
+            const char *tmpdir;
             if (stdin_nm)
+              fatal (NILF, _("Makefile from standard input specified twice."));
+              O (fatal, NILF,
+                 _("Makefile from standard input specified twice."));
 #ifdef VMS
 # define DEFAULT_TMPDIR     "sys$scratch:"
+# define DEFAULT_TMPDIR     "/sys$scratch/"
 #else
 # ifdef P_tmpdir
 …
 #define DEFAULT_TMPFILE     "GmXXXXXX"
             if (((tmpdir = getenv ("TMPDIR")) == NULL || *tmpdir == '\0')
+            if (((tmpdir = getenv ("TMPDIR")) == NULL || *tmpdir == '\0')
 #if defined (__MSDOS__) || defined (WINDOWS32) || defined (__EMX__)
                 /* These are also used commonly on these platforms.  */
 …
 #endif
+               )
               tmpdir = DEFAULT_TMPDIR;
             template = alloca (strlen (tmpdir) + sizeof (DEFAULT_TMPFILE) + 1);
             strcpy (template, tmpdir);
+              tmpdir = DEFAULT_TMPDIR;
+            template = alloca (strlen (tmpdir) + CSTRLEN (DEFAULT_TMPFILE) + 2);
+            strcpy (template, tmpdir);
 #ifdef HAVE_DOS_PATHS
             if (strchr ("/\\", template[strlen (template) - 1]) == NULL)
               strcat (template, "/");
+            if (strchr ("/\\", template[strlen (template) - 1]) == NULL)
+              strcat (template, "/");
 #else
 # ifndef VMS
             if (template[strlen (template) - 1] != '/')
               strcat (template, "/");
+            if (template[strlen (template) - 1] != '/')
+              strcat (template, "/");
 # endif /* !VMS */
 #endif /* !HAVE_DOS_PATHS */
             strcat (template, DEFAULT_TMPFILE);
             outfile = open_tmpfile (&stdin_nm, template);
             if (outfile == 0)
               pfatal_with_name (_("fopen (temporary file)"));
             while (!feof (stdin) && ! ferror (stdin))
+              {
                 char buf[2048];
                 unsigned int n = fread (buf, 1, sizeof (buf), stdin);
                 if (n > 0 && fwrite (buf, 1, n, outfile) != n)
                   pfatal_with_name (_("fwrite (temporary file)"));
+              }
             fclose (outfile);
             /* Replace the name that read_all_makefiles will
                see with the name of the temporary file.  */
+            strcat (template, DEFAULT_TMPFILE);
+            outfile = output_tmpfile (&stdin_nm, template);
+            if (outfile == 0)
+              pfatal_with_name (_("fopen (temporary file)"));
+            while (!feof (stdin) && ! ferror (stdin))
+              {
+                char buf[2048];
+                unsigned int n = fread (buf, 1, sizeof (buf), stdin);
+                if (n > 0 && fwrite (buf, 1, n, outfile) != n)
+                  pfatal_with_name (_("fwrite (temporary file)"));
+              }
+            fclose (outfile);
+            /* Replace the name that read_all_makefiles will
+               see with the name of the temporary file.  */
             makefiles->list[i] = strcache_add (stdin_nm);
             /* Make sure the temporary file will not be remade.  */
+            /* Make sure the temporary file will not be remade.  */
+            {
               struct file *f = enter_file (strcache_add (stdin_nm));
               f->updated = 1;
               f->update_status = 0;
+              f->update_status = us_success;
               f->command_state = cs_finished;
               /* Can't be intermediate, or it'll be removed too early for
 …
               f->dontcare = 0;
+            }
+          }
+          }
+    }
 #ifndef __EMX__ /* Don't use a SIGCHLD handler for OS/2 */
 #if defined(MAKE_JOBSERVER) || !defined(HAVE_WAIT_NOHANG)
+#if !defined(HAVE_WAIT_NOHANG) || defined(MAKE_JOBSERVER)
   /* Set up to handle children dying.  This must be done before
      reading in the makefiles so that `shell' function calls will work.
+     reading in the makefiles so that 'shell' function calls will work.
      If we don't have a hanging wait we have to fall back to old, broken
 …
      children.
      If we're using the jobs pipe we need a signal handler so that
      SIGCHLD is not ignored; we need it to interrupt the read(2) of the
      jobserver pipe in job.c if we're waiting for a token.
+     If we're using the jobs pipe we need a signal handler so that SIGCHLD is
+     not ignored; we need it to interrupt the read(2) of the jobserver pipe if
+     we're waiting for a token.
      If none of these are true, we don't need a signal handler at all.  */
+  {
-    RETSIGTYPE child_handler (int sig);
 # if defined SIGCHLD
     bsd_signal (SIGCHLD, child_handler);
 …
 # endif
+  }
+#ifdef HAVE_PSELECT
+  /* If we have pselect() then we need to block SIGCHLD so it's deferred.  */
+  {
+    sigset_t block;
+    sigemptyset (&block);
+    sigaddset (&block, SIGCHLD);
+    if (sigprocmask (SIG_SETMASK, &block, NULL) < 0)
+      pfatal_with_name ("sigprocmask(SIG_SETMASK, SIGCHLD)");
+  }
+#endif
 #endif
 #endif
 …
   /* Define the initial list of suffixes for old-style rules.  */
   set_default_suffixes ();
 …
      makefiles, it results in the built-in pattern rules taking precedence
      over makefile-specified suffix rules, which is wrong.  */
   install_default_suffix_rules ();
   /* Define some internal and special variables.  */
   define_automatic_variables ();
+  /* Set up the MAKEFLAGS and MFLAGS variables
+     so makefiles can look at them.  */
+  define_makeflags (0, 0);
+  /* Set up the MAKEFLAGS and MFLAGS variables for makefiles to see.
+     Initialize it to be exported but allow the makefile to reset it.  */
+  define_makeflags (0, 0)->export = v_export;
   /* Define the default variables.  */
 …
       char *p, *value;
       unsigned int i;
       unsigned int len = sizeof ("--eval=") * eval_strings->idx;
+      unsigned int len = (CSTRLEN ("--eval=") + 1) * eval_strings->idx;
       for (i = 0; i < eval_strings->idx; ++i)
 …
           p = xstrdup (eval_strings->list[i]);
           len += 2 * strlen (p);
           eval_buffer (p);
+          eval_buffer (p, NULL);
           free (p);
+        }
 …
+        {
           strcpy (p, "--eval=");
           p += strlen (p);
+          p += CSTRLEN ("--eval=");
           p = quote_for_env (p, eval_strings->list[i]);
           *(p++) = ' ';
 …
   /* Read all the makefiles.  */
+  read_makefiles
+    = read_all_makefiles (makefiles == 0 ? 0 : makefiles->list);
+  read_files = read_all_makefiles (makefiles == 0 ? 0 : makefiles->list);
 #ifdef WINDOWS32
   /* look one last time after reading all Makefiles */
   if (no_default_sh_exe)
     no_default_sh_exe = !find_and_set_default_shell(NULL);
+    no_default_sh_exe = !find_and_set_default_shell (NULL);
 #endif /* WINDOWS32 */
 #if defined (__MSDOS__) || defined (__EMX__)
+#if defined (__MSDOS__) || defined (__EMX__) || defined (VMS)
   /* We need to know what kind of shell we will be using.  */
+  {
 …
     struct variable *shv = lookup_variable (STRING_SIZE_TUPLE ("SHELL"));
     extern int unixy_shell;
     extern char *default_shell;
+    extern const char *default_shell;
     if (shv && *shv->value)
+      {
         char *shell_path = recursively_expand(shv);
         if (shell_path && _is_unixy_shell (shell_path))
           unixy_shell = 1;
         else
           unixy_shell = 0;
         if (shell_path)
           default_shell = shell_path;
+        char *shell_path = recursively_expand (shv);
+        if (shell_path && _is_unixy_shell (shell_path))
+          unixy_shell = 1;
+        else
+          unixy_shell = 0;
+        if (shell_path)
+          default_shell = shell_path;
+      }
+  }
 #endif /* __MSDOS__ || __EMX__ */
+  /* Decode switches again, in case the variables were set by the makefile.  */
+  decode_env_switches (STRING_SIZE_TUPLE ("MAKEFLAGS"));
+  {
+    int old_builtin_rules_flag = no_builtin_rules_flag;
+    int old_builtin_variables_flag = no_builtin_variables_flag;
+    /* Decode switches again, for variables set by the makefile.  */
+    decode_env_switches (STRING_SIZE_TUPLE ("GNUMAKEFLAGS"));
+    /* Clear GNUMAKEFLAGS to avoid duplication.  */
+    define_variable_cname ("GNUMAKEFLAGS", "", o_override, 0);
+    decode_env_switches (STRING_SIZE_TUPLE ("MAKEFLAGS"));
 #if 0
+  decode_env_switches (STRING_SIZE_TUPLE ("MFLAGS"));
+#endif
+#if defined (__MSDOS__) || defined (__EMX__)
+  if (job_slots != 1
+    decode_env_switches (STRING_SIZE_TUPLE ("MFLAGS"));
+#endif
+    /* Reset in case the switches changed our mind.  */
+    syncing = (output_sync == OUTPUT_SYNC_LINE
+               || output_sync == OUTPUT_SYNC_TARGET);
+    if (make_sync.syncout && ! syncing)
+      output_close (&make_sync);
+    make_sync.syncout = syncing;
+    OUTPUT_SET (&make_sync);
+    /* If we've disabled builtin rules, get rid of them.  */
+    if (no_builtin_rules_flag && ! old_builtin_rules_flag)
+      {
+        if (suffix_file->builtin)
+          {
+            free_dep_chain (suffix_file->deps);
+            suffix_file->deps = 0;
+          }
+        define_variable_cname ("SUFFIXES", "", o_default, 0);
+      }
+    /* If we've disabled builtin variables, get rid of them.  */
+    if (no_builtin_variables_flag && ! old_builtin_variables_flag)
+      undefine_default_variables ();
+  }
+#if defined (__MSDOS__) || defined (__EMX__) || defined (VMS)
+  if (arg_job_slots != 1
 # ifdef __EMX__
       && _osmode != OS2_MODE /* turn off -j if we are in DOS mode */
 …
+      )
+    {
+      error (NILF,
+             _("Parallel jobs (-j) are not supported on this platform."));
+      error (NILF, _("Resetting to single job (-j1) mode."));
+      job_slots = 1;
+    }
+#endif
+#ifdef MAKE_JOBSERVER
+  /* If the jobserver-fds option is seen, make sure that -j is reasonable.  */
+  if (jobserver_fds)
+    {
+      const char *cp;
+      unsigned int ui;
+      for (ui=1; ui < jobserver_fds->idx; ++ui)
+        if (!streq (jobserver_fds->list[0], jobserver_fds->list[ui]))
+          fatal (NILF, _("internal error: multiple --jobserver-fds options"));
+      /* Now parse the fds string and make sure it has the proper format.  */
+      cp = jobserver_fds->list[0];
+      if (sscanf (cp, "%d,%d", &job_fds[0], &job_fds[1]) != 2)
+        fatal (NILF,
+               _("internal error: invalid --jobserver-fds string `%s'"), cp);
+      DB (DB_JOBS,
+          (_("Jobserver client (fds %d,%d)\n"), job_fds[0], job_fds[1]));
+      /* The combination of a pipe + !job_slots means we're using the
+         jobserver.  If !job_slots and we don't have a pipe, we can start
+         infinite jobs.  If we see both a pipe and job_slots >0 that means the
+         user set -j explicitly.  This is broken; in this case obey the user
+         (ignore the jobserver pipe for this make) but print a message.  */
+      if (job_slots > 0)
+        error (NILF,
+               _("warning: -jN forced in submake: disabling jobserver mode."));
+      /* Create a duplicate pipe, that will be closed in the SIGCHLD
+         handler.  If this fails with EBADF, the parent has closed the pipe
+         on us because it didn't think we were a submake.  If so, print a
+         warning then default to -j1.  */
+      else if ((job_rfd = dup (job_fds[0])) < 0)
+      O (error, NILF,
+         _("Parallel jobs (-j) are not supported on this platform."));
+      O (error, NILF, _("Resetting to single job (-j1) mode."));
+      arg_job_slots = job_slots = 1;
+    }
+#endif
+  /* If we have >1 slot at this point, then we're a top-level make.
+     Set up the jobserver.
+     Every make assumes that it always has one job it can run.  For the
+     submakes it's the token they were given by their parent.  For the top
+     make, we just subtract one from the number the user wants.  */
+  if (job_slots > 1 && jobserver_setup (job_slots - 1))
+    {
+      /* Fill in the jobserver_auth for our children.  */
+      jobserver_auth = jobserver_get_auth ();
+      if (jobserver_auth)
+        {
+          if (errno != EBADF)
+            pfatal_with_name (_("dup jobserver"));
+          error (NILF,
+                 _("warning: jobserver unavailable: using -j1.  Add `+' to parent make rule."));
+          job_slots = 1;
+          /* We're using the jobserver so set job_slots to 0.  */
+          master_job_slots = job_slots;
+          job_slots = 0;
+        }
+      if (job_slots > 0)
+        {
+          close (job_fds[0]);
+          close (job_fds[1]);
+          job_fds[0] = job_fds[1] = -1;
+          free (jobserver_fds->list);
+          free (jobserver_fds);
+          jobserver_fds = 0;
+        }
+    }
+  /* If we have >1 slot but no jobserver-fds, then we're a top-level make.
+     Set up the pipe and install the fds option for our children.  */
+  if (job_slots > 1)
+    {
+      char *cp;
+      char c = '+';
+      if (pipe (job_fds) < 0 || (job_rfd = dup (job_fds[0])) < 0)
+        pfatal_with_name (_("creating jobs pipe"));
+      /* Every make assumes that it always has one job it can run.  For the
+         submakes it's the token they were given by their parent.  For the
+         top make, we just subtract one from the number the user wants.  We
+         want job_slots to be 0 to indicate we're using the jobserver.  */
+      master_job_slots = job_slots;
+      while (--job_slots)
+        {
+          int r;
+          EINTRLOOP (r, write (job_fds[1], &c, 1));
+          if (r != 1)
+            pfatal_with_name (_("init jobserver pipe"));
+        }
+      /* Fill in the jobserver_fds struct for our children.  */
+      cp = xmalloc ((sizeof ("1024")*2)+1);
+      sprintf (cp, "%d,%d", job_fds[0], job_fds[1]);
+      jobserver_fds = (struct stringlist *)
+                        xmalloc (sizeof (struct stringlist));
+      jobserver_fds->list = xmalloc (sizeof (char *));
+      jobserver_fds->list[0] = cp;
+      jobserver_fds->idx = 1;
+      jobserver_fds->max = 1;
+    }
+#endif
+    }
+  /* If we're not using parallel jobs, then we don't need output sync.
+     This is so people can enable output sync in GNUMAKEFLAGS or similar, but
+     not have it take effect unless parallel builds are enabled.  */
+  if (syncing && job_slots == 1)
+    {
+      OUTPUT_UNSET ();
+      output_close (&make_sync);
+      syncing = 0;
+      output_sync = OUTPUT_SYNC_NONE;
+    }
 #ifndef MAKE_SYMLINKS
   if (check_symlink_flag)
+    {
       error (NILF, _("Symbolic links not supported: disabling -L."));
+      O (error, NILF, _("Symbolic links not supported: disabling -L."));
       check_symlink_flag = 0;
+    }
 …
   define_makeflags (1, 0);
   /* Make each `struct dep' point at the `struct file' for the file
+  /* Make each 'struct goaldep' point at the 'struct file' for the file
      depended on.  Also do magic for special targets.  */
 …
           f->last_mtime = f->mtime_before_update = OLD_MTIME;
           f->updated = 1;
           f->update_status = 0;
+          f->update_status = us_success;
           f->command_state = cs_finished;
+        }
 …
       const char **p;
       for (p = new_files->list; *p != 0; ++p)
+        {
           struct file *f = enter_file (*p);
           f->last_mtime = f->mtime_before_update = NEW_MTIME;
+        }
+        {
+          struct file *f = enter_file (*p);
+          f->last_mtime = f->mtime_before_update = NEW_MTIME;
+        }
+    }
 …
   remote_setup ();
+  if (read_makefiles != 0)
+  /* Dump any output we've collected.  */
+  OUTPUT_UNSET ();
+  output_close (&make_sync);
+  if (read_files != 0)
+    {
       /* Update any makefiles if necessary.  */
 …
       FILE_TIMESTAMP *makefile_mtimes = 0;
       unsigned int mm_idx = 0;
+      char **nargv;
+      char **aargv = NULL;
+      const char **nargv;
       int nargc;
+      int orig_db_level = db_level;
+      int status;
+      if (! ISDB (DB_MAKEFILES))
+        db_level = DB_NONE;
+      enum update_status status;
       DB (DB_BASIC, (_("Updating makefiles....\n")));
       /* Remove any makefiles we don't want to try to update.
          Also record the current modtimes so we can compare them later.  */
+         Also record the current modtimes so we can compare them later.  */
+      {
         register struct dep *d, *last;
         last = 0;
         d = read_makefiles;
         while (d != 0)
+          {
             struct file *f = d->file;
             if (f->double_colon)
               for (f = f->double_colon; f != NULL; f = f->prev)
+                {
                   if (f->deps == 0 && f->cmds != 0)
+                    {
                       /* This makefile is a :: target with commands, but
                          no dependencies.  So, it will always be remade.
                          This might well cause an infinite loop, so don't
                          try to remake it.  (This will only happen if
                          your makefiles are written exceptionally
                          stupidly; but if you work for Athena, that's how
                          you write your makefiles.)  */
                       DB (DB_VERBOSE,
                           (_("Makefile `%s' might loop; not remaking it.\n"),
+        register struct goaldep *d, *last;
+        last = 0;
+        d = read_files;
+        while (d != 0)
+          {
+            struct file *f = d->file;
+            if (f->double_colon)
+              for (f = f->double_colon; f != NULL; f = f->prev)
+                {
+                  if (f->deps == 0 && f->cmds != 0)
+                    {
+                      /* This makefile is a :: target with commands, but
+                         no dependencies.  So, it will always be remade.
+                         This might well cause an infinite loop, so don't
+                         try to remake it.  (This will only happen if
+                         your makefiles are written exceptionally
+                         stupidly; but if you work for Athena, that's how
+                         you write your makefiles.)  */
+                      DB (DB_VERBOSE,
+                          (_("Makefile '%s' might loop; not remaking it.\n"),
                            f->name));
+                      if (last == 0)
+                        read_makefiles = d->next;
+                      else
+                        last->next = d->next;
+                      /* Free the storage.  */
+                      free_dep (d);
+                      d = last == 0 ? read_makefiles : last->next;
+                      break;
+                    }
+                }
+            if (f == NULL || !f->double_colon)
+              {
+                      if (last == 0)
+                        read_files = d->next;
+                      else
+                        last->next = d->next;
+                      /* Free the storage.  */
+                      free_goaldep (d);
+                      d = last == 0 ? read_files : last->next;
+                      break;
+                    }
+                }
+            if (f == NULL || !f->double_colon)
+              {
                 makefile_mtimes = xrealloc (makefile_mtimes,
                                             (mm_idx+1)
                                             * sizeof (FILE_TIMESTAMP));
                 makefile_mtimes[mm_idx++] = file_mtime_no_search (d->file);
                 last = d;
                 d = d->next;
+              }
+          }
+                makefile_mtimes[mm_idx++] = file_mtime_no_search (d->file);
+                last = d;
+                d = d->next;
+              }
+          }
+      }
       /* Set up `MAKEFLAGS' specially while remaking makefiles.  */
+      /* Set up 'MAKEFLAGS' specially while remaking makefiles.  */
       define_makeflags (1, 1);
+      rebuilding_makefiles = 1;
+      status = update_goal_chain (read_makefiles);
+      rebuilding_makefiles = 0;
+      {
+        int orig_db_level = db_level;
+        if (! ISDB (DB_MAKEFILES))
+          db_level = DB_NONE;
+        rebuilding_makefiles = 1;
+        status = update_goal_chain (read_files);
+        rebuilding_makefiles = 0;
+        db_level = orig_db_level;
+      }
       switch (status)
+        {
         case 1:
+        {
+        case us_question:
           /* The only way this can happen is if the user specified -q and asked
+           * for one of the makefiles to be remade as a target on the command
+           * line.  Since we're not actually updating anything with -q we can
+           * treat this as "did nothing".
+           */
+        case -1:
+          /* Did nothing.  */
+          break;
+        case 2:
+          /* Failed to update.  Figure out if we care.  */
+          {
+            /* Nonzero if any makefile was successfully remade.  */
+            int any_remade = 0;
+            /* Nonzero if any makefile we care about failed
+               in updating or could not be found at all.  */
+            int any_failed = 0;
+            unsigned int i;
+            struct dep *d;
+            for (i = 0, d = read_makefiles; d != 0; ++i, d = d->next)
+             for one of the makefiles to be remade as a target on the command
+             line.  Since we're not actually updating anything with -q we can
+             treat this as "did nothing".  */
+        case us_none:
+          /* Did nothing.  */
+          break;
+        case us_failed:
+          /* Failed to update.  Figure out if we care.  */
+          {
+            /* Nonzero if any makefile was successfully remade.  */
+            int any_remade = 0;
+            /* Nonzero if any makefile we care about failed
+               in updating or could not be found at all.  */
+            int any_failed = 0;
+            unsigned int i;
+            struct goaldep *d;
+            for (i = 0, d = read_files; d != 0; ++i, d = d->next)
+              {
-                /* Reset the considered flag; we may need to look at the file
-                   again to print an error.  */
-                d->file->considered = 0;
                 if (d->file->updated)
+                  {
                     /* This makefile was updated.  */
                     if (d->file->update_status == 0)
+                    if (d->file->update_status == us_success)
+                      {
                         /* It was successfully updated.  */
 …
                                        != makefile_mtimes[i]);
+                      }
                     else if (! (d->changed & RM_DONTCARE))
+                    else if (! (d->flags & RM_DONTCARE))
+                      {
                         FILE_TIMESTAMP mtime;
                         /* The update failed and this makefile was not
                            from the MAKEFILES variable, so we care.  */
                         error (NILF, _("Failed to remake makefile `%s'."),
                                d->file->name);
+                        OS (error, NILF, _("Failed to remake makefile '%s'."),
+                            d->file->name);
                         mtime = file_mtime_no_search (d->file);
                         any_remade |= (mtime != NONEXISTENT_MTIME
 …
                 else
                   /* This makefile was not found at all.  */
                   if (! (d->changed & RM_DONTCARE))
+                  if (! (d->flags & RM_DONTCARE))
+                    {
+                      const char *dnm = dep_name (d);
+                      size_t l = strlen (dnm);
                       /* This is a makefile we care about.  See how much.  */
+                      if (d->changed & RM_INCLUDED)
+                        /* An included makefile.  We don't need
+                           to die, but we do want to complain.  */
+                        error (NILF,
+                               _("Included makefile `%s' was not found."),
+                               dep_name (d));
+                      if (d->flags & RM_INCLUDED)
+                        /* An included makefile.  We don't need to die, but we
+                           do want to complain.  */
+                        error (NILF, l,
+                               _("Included makefile '%s' was not found."), dnm);
                       else
+                        {
                           /* A normal makefile.  We must die later.  */
                           error (NILF, _("Makefile `%s' was not found"),
                                  dep_name (d));
+                          error (NILF, l,
+                                 _("Makefile '%s' was not found"), dnm);
                           any_failed = 1;
+                        }
 …
+              }
             /* Reset this to empty so we get the right error message below.  */
             read_makefiles = 0;
             if (any_remade)
               goto re_exec;
             if (any_failed)
               die (2);
+            read_files = 0;
+            if (any_remade)
+              goto re_exec;
+            if (any_failed)
+              die (MAKE_FAILURE);
             break;
+          }
+        case 0:
+        re_exec:
+          /* Updated successfully.  Re-exec ourselves.  */
+          remove_intermediates (0);
+          if (print_data_base_flag)
+            print_data_base ();
+          log_working_directory (0);
+          }
+        case us_success:
+        re_exec:
+          /* Updated successfully.  Re-exec ourselves.  */
+          remove_intermediates (0);
+          if (print_data_base_flag)
+            print_data_base ();
           clean_jobserver (0);
           if (makefiles != 0)
+            {
               /* These names might have changed.  */
               int i, j = 0;
               for (i = 1; i < argc; ++i)
                 if (strneq (argv[i], "-f", 2)) /* XXX */
+                  {
                     if (argv[i][2] == '\0')
+          if (makefiles != 0)
+            {
+              /* These names might have changed.  */
+              int i, j = 0;
+              for (i = 1; i < argc; ++i)
+                if (strneq (argv[i], "-f", 2)) /* XXX */
+                  {
+                    if (argv[i][2] == '\0')
                       /* This cast is OK since we never modify argv.  */
                       argv[++i] = (char *) makefiles->list[j];
                     else
                       argv[i] = xstrdup (concat (2, "-f", makefiles->list[j]));
                     ++j;
+                  }
+            }
+                      argv[++i] = (char *) makefiles->list[j];
+                    else
+                      argv[i] = xstrdup (concat (2, "-f", makefiles->list[j]));
+                    ++j;
+                  }
+            }
           /* Add -o option for the stdin temporary file, if necessary.  */
 …
           if (stdin_nm)
+            {
+              nargv = xmalloc ((nargc + 2) * sizeof (char *));
+              memcpy (nargv, argv, argc * sizeof (char *));
+              nargv[nargc++] = xstrdup (concat (2, "-o", stdin_nm));
+              nargv[nargc] = 0;
+              void *m = xmalloc ((nargc + 2) * sizeof (char *));
+              aargv = m;
+              memcpy (aargv, argv, argc * sizeof (char *));
+              aargv[nargc++] = xstrdup (concat (2, "-o", stdin_nm));
+              aargv[nargc] = 0;
+              nargv = m;
+            }
           else
+            nargv = argv;
+          if (directories != 0 && directories->idx > 0)
+            {
+              int bad = 1;
+              if (directory_before_chdir != 0)
+                {
+                  if (chdir (directory_before_chdir) < 0)
+                      perror_with_name ("chdir", "");
+                  else
+                    bad = 0;
+                }
+              if (bad)
+                fatal (NILF, _("Couldn't change back to original directory."));
+            }
+            nargv = (const char**)argv;
+          if (directories != 0 && directories->idx > 0)
+            {
+              int bad = 1;
+              if (directory_before_chdir != 0)
+                {
+                  if (chdir (directory_before_chdir) < 0)
+                      perror_with_name ("chdir", "");
+                  else
+                    bad = 0;
+                }
+              if (bad)
+                O (fatal, NILF,
+                   _("Couldn't change back to original directory."));
+            }
           ++restarts;
+          /* Reset makeflags in case they were changed.  */
+          {
+            const char *pv = define_makeflags (1, 1);
+            char *p = alloca (sizeof ("MAKEFLAGS=") + strlen (pv) + 1);
+            sprintf (p, "MAKEFLAGS=%s", pv);
+            putenv (p);
+          }
+          if (ISDB (DB_BASIC))
+            {
+              char **p;
+              printf (_("Re-executing[%u]:"), restarts);
+              for (p = nargv; *p != 0; ++p)
+                printf (" %s", *p);
+              putchar ('\n');
+            }
+          if (ISDB (DB_BASIC))
+            {
+              const char **p;
+              printf (_("Re-executing[%u]:"), restarts);
+              for (p = nargv; *p != 0; ++p)
+                printf (" %s", *p);
+              putchar ('\n');
+              fflush (stdout);
+            }
 #ifndef _AMIGA
 …
             for (p = environ; *p != 0; ++p)
+              {
+                if (strneq (*p, MAKELEVEL_NAME, MAKELEVEL_LENGTH)
+                    && (*p)[MAKELEVEL_LENGTH] == '=')
+                if (strneq (*p, MAKELEVEL_NAME "=", MAKELEVEL_LENGTH+1))
+                  {
                     *p = alloca (40);
                     sprintf (*p, "%s=%u", MAKELEVEL_NAME, makelevel);
+#ifdef VMS
+                    vms_putenv_symbol (*p);
+#endif
+                  }
                 if (strneq (*p, "MAKE_RESTARTS=", 14))
+                else if (strneq (*p, "MAKE_RESTARTS=", CSTRLEN ("MAKE_RESTARTS=")))
+                  {
                     *p = alloca (40);
+                    sprintf (*p, "MAKE_RESTARTS=%u", restarts);
+                    sprintf (*p, "MAKE_RESTARTS=%s%u",
+                             OUTPUT_IS_TRACED () ? "-" : "", restarts);
                     restarts = 0;
+                  }
 …
+          }
 #else /* AMIGA */
+          {
             char buffer[256];
+          {
+            char buffer[256];
             sprintf (buffer, "%u", makelevel);
             SetVar (MAKELEVEL_NAME, buffer, -1, GVF_GLOBAL_ONLY);
             sprintf (buffer, "%u", restarts);
+            sprintf (buffer, "%s%u", OUTPUT_IS_TRACED () ? "-" : "", restarts);
             SetVar ("MAKE_RESTARTS", buffer, -1, GVF_GLOBAL_ONLY);
             restarts = 0;
+          }
+          }
 #endif
 …
+            {
               char *b = alloca (40);
+              sprintf (b, "MAKE_RESTARTS=%u", restarts);
+              sprintf (b, "MAKE_RESTARTS=%s%u",
+                       OUTPUT_IS_TRACED () ? "-" : "", restarts);
               putenv (b);
+            }
+          fflush (stdout);
+          fflush (stderr);
+          /* Close the dup'd jobserver pipe if we opened one.  */
+          if (job_rfd >= 0)
+            close (job_rfd);
+          fflush (stdout);
+          fflush (stderr);
 #ifdef _AMIGA
           exec_command (nargv);
           exit (0);
+          exec_command (nargv);
+          exit (0);
 #elif defined (__EMX__)
+          {
             /* It is not possible to use execve() here because this
                would cause the parent process to be terminated with
                exit code 0 before the child process has been terminated.
                Therefore it may be the best solution simply to spawn the
                child process including all file handles and to wait for its
                termination. */
             int pid;
             int status;
             pid = child_execute_job (0, 1, nargv, environ);
             /* is this loop really necessary? */
             do {
               pid = wait (&status);
             } while (pid <= 0);
             /* use the exit code of the child process */
             exit (WIFEXITED(status) ? WEXITSTATUS(status) : EXIT_FAILURE);
+          }
+          {
+            /* It is not possible to use execve() here because this
+               would cause the parent process to be terminated with
+               exit code 0 before the child process has been terminated.
+               Therefore it may be the best solution simply to spawn the
+               child process including all file handles and to wait for its
+               termination. */
+            int pid;
+            int r;
+            pid = child_execute_job (NULL, 1, nargv, environ);
+            /* is this loop really necessary? */
+            do {
+              pid = wait (&r);
+            } while (pid <= 0);
+            /* use the exit code of the child process */
+            exit (WIFEXITED(r) ? WEXITSTATUS(r) : EXIT_FAILURE);
+          }
 #else
+          exec_command (nargv, environ);
+#endif
+          /* NOTREACHED */
+        default:
+#define BOGUS_UPDATE_STATUS 0
+          assert (BOGUS_UPDATE_STATUS);
+          break;
+        }
+      db_level = orig_db_level;
+      /* Free the makefile mtimes (if we allocated any).  */
+      if (makefile_mtimes)
+        free (makefile_mtimes);
+    }
+  /* Set up `MAKEFLAGS' again for the normal targets.  */
+#ifdef SET_STACK_SIZE
+          /* Reset limits, if necessary.  */
+          if (stack_limit.rlim_cur)
+            setrlimit (RLIMIT_STACK, &stack_limit);
+#endif
+          exec_command ((char **)nargv, environ);
+#endif
+          free (aargv);
+          break;
+        }
+      /* Free the makefile mtimes.  */
+      free (makefile_mtimes);
+    }
+  /* Set up 'MAKEFLAGS' again for the normal targets.  */
   define_makeflags (1, 0);
 …
       const char **p;
       for (p = new_files->list; *p != 0; ++p)
+        {
           struct file *f = enter_file (*p);
           f->last_mtime = f->mtime_before_update = NEW_MTIME;
+        }
+        {
+          struct file *f = enter_file (*p);
+          f->last_mtime = f->mtime_before_update = NEW_MTIME;
+        }
+    }
 …
               struct nameseq *ns;
               ns = PARSE_FILE_SEQ (&p, struct nameseq, '\0', NULL, 0);
+              ns = PARSE_SIMPLE_SEQ (&p, struct nameseq);
               if (ns)
+                {
                   /* .DEFAULT_GOAL should contain one target. */
                   if (ns->next != 0)
+                    fatal (NILF, _(".DEFAULT_GOAL contains more than one target"));
+                    O (fatal, NILF,
+                       _(".DEFAULT_GOAL contains more than one target"));
                   f = enter_file (strcache_add (ns->name));
 …
           if (f)
+            {
               goals = alloc_dep ();
+              goals = alloc_goaldep ();
               goals->file = f;
+            }
 …
   if (!goals)
+    {
       if (read_makefiles == 0)
         fatal (NILF, _("No targets specified and no makefile found"));
       fatal (NILF, _("No targets"));
+      if (read_files == 0)
+        O (fatal, NILF, _("No targets specified and no makefile found"));
+      O (fatal, NILF, _("No targets"));
+    }
 …
+  {
-    int status;
     switch (update_goal_chain (goals))
+    {
       case -1:
+      case us_none:
         /* Nothing happened.  */
       case 0:
         /* Updated successfully.  */
         status = makefile_status;
+        /* FALLTHROUGH */
+      case us_success:
+        /* Keep the previous result.  */
         break;
       case 1:
+      case us_question:
         /* We are under -q and would run some commands.  */
         status = MAKE_TROUBLE;
+        makefile_status = MAKE_TROUBLE;
         break;
+      case 2:
+        /* Updating failed.  POSIX.2 specifies exit status >1 for this;
+           but in VMS, there is only success and failure.  */
+        status = MAKE_FAILURE;
+      case us_failed:
+        /* Updating failed.  POSIX.2 specifies exit status >1 for this; */
+        makefile_status = MAKE_FAILURE;
         break;
-      default:
-        abort ();
+    }
     /* If we detected some clock skew, generate one last warning */
     if (clock_skew_detected)
       error (NILF,
              _("warning:  Clock skew detected.  Your build may be incomplete."));
+      O (error, NILF,
+         _("warning:  Clock skew detected.  Your build may be incomplete."));
     /* Exit.  */
     die (status);
+    die (makefile_status);
+  }
   /* NOTREACHED */
   return 0;
+  exit (MAKE_SUCCESS);
+}
 …
 static char options[1 + sizeof (switches) / sizeof (switches[0]) * 3];
 static struct option long_options[(sizeof (switches) / sizeof (switches[0])) +
                                   (sizeof (long_option_aliases) /
                                    sizeof (long_option_aliases[0]))];
+                                  (sizeof (long_option_aliases) /
+                                   sizeof (long_option_aliases[0]))];
 /* Fill in the string and vector for getopt.  */
 …
+    {
       long_options[i].name = (switches[i].long_name == 0 ? "" :
                               switches[i].long_name);
+                              switches[i].long_name);
       long_options[i].flag = 0;
       long_options[i].val = switches[i].c;
       if (short_option (switches[i].c))
         *p++ = switches[i].c;
+        *p++ = switches[i].c;
       switch (switches[i].type)
+        {
+        case flag:
+        case flag_off:
+        case ignore:
+          long_options[i].has_arg = no_argument;
+          break;
+        case string:
+        {
+        case flag:
+        case flag_off:
+        case ignore:
+          long_options[i].has_arg = no_argument;
+          break;
+        case string:
+        case strlist:
         case filename:
         case positive_int:
         case floating:
           if (short_option (switches[i].c))
             *p++ = ':';
           if (switches[i].noarg_value != 0)
+            {
               if (short_option (switches[i].c))
                 *p++ = ':';
               long_options[i].has_arg = optional_argument;
+            }
           else
             long_options[i].has_arg = required_argument;
           break;
+        }
+        case positive_int:
+        case floating:
+          if (short_option (switches[i].c))
+            *p++ = ':';
+          if (switches[i].noarg_value != 0)
+            {
+              if (short_option (switches[i].c))
+                *p++ = ':';
+              long_options[i].has_arg = optional_argument;
+            }
+          else
+            long_options[i].has_arg = required_argument;
+          break;
+        }
+    }
   *p = '\0';
   for (c = 0; c < (sizeof (long_option_aliases) /
                    sizeof (long_option_aliases[0]));
+                   sizeof (long_option_aliases[0]));
        ++c)
     long_options[i++] = long_option_aliases[c];
 …
+}
+/* Non-option argument.  It might be a variable definition.  */
 static void
 handle_non_switch_argument (char *arg, int env)
+handle_non_switch_argument (const char *arg, int env)
+{
-  /* Non-option argument.  It might be a variable definition.  */
   struct variable *v;
   if (arg[0] == '-' && arg[1] == '\0')
     /* Ignore plain `-' for compatibility.  */
+    /* Ignore plain '-' for compatibility.  */
     return;
+#ifdef VMS
+  {
+    /* VMS DCL quoting can result in foo="bar baz" showing up here.
+       Need to remove the double quotes from the value. */
+    char * eq_ptr;
+    char * new_arg;
+    eq_ptr = strchr (arg, '=');
+    if ((eq_ptr != NULL) && (eq_ptr[1] == '"'))
+      {
+         int len;
+         int seg1;
+         int seg2;
+         len = strlen(arg);
+         new_arg = alloca(len);
+         seg1 = eq_ptr - arg + 1;
+         strncpy(new_arg, arg, (seg1));
+         seg2 = len - seg1 - 1;
+         strncpy(&new_arg[seg1], &eq_ptr[2], seg2);
+         new_arg[seg1 + seg2] = 0;
+         if (new_arg[seg1 + seg2 - 1] == '"')
+           new_arg[seg1 + seg2 - 1] = 0;
+         arg = new_arg;
+      }
+  }
+#endif
   v = try_variable_definition (0, arg, o_command, 0);
   if (v != 0)
+    {
       /* It is indeed a variable definition.  If we don't already have this
          one, record a pointer to the variable for later use in
          define_makeflags.  */
+         one, record a pointer to the variable for later use in
+         define_makeflags.  */
       struct command_variable *cv;
 …
           break;
+      if (! cv) {
+        cv = xmalloc (sizeof (*cv));
+        cv->variable = v;
+        cv->next = command_variables;
+        command_variables = cv;
+      }
+      if (! cv)
+        {
+          cv = xmalloc (sizeof (*cv));
+          cv->variable = v;
+          cv->next = command_variables;
+          command_variables = cv;
+        }
+    }
   else if (! env)
+    {
       /* Not an option or variable definition; it must be a goal
          target!  Enter it as a file and add it to the dep chain of
          goals.  */
+         target!  Enter it as a file and add it to the dep chain of
+         goals.  */
       struct file *f = enter_file (strcache_add (expand_command_line_file (arg)));
       f->cmd_target = 1;
       if (goals == 0)
+        {
           goals = alloc_dep ();
           lastgoal = goals;
+        }
+        {
+          goals = alloc_goaldep ();
+          lastgoal = goals;
+        }
       else
+        {
           lastgoal->next = alloc_dep ();
           lastgoal = lastgoal->next;
+        }
+        {
+          lastgoal->next = alloc_goaldep ();
+          lastgoal = lastgoal->next;
+        }
       lastgoal->file = f;
 …
 static void
 decode_switches (int argc, char **argv, int env)
+decode_switches (int argc, const char **argv, int env)
+{
   int bad = 0;
 …
   while (optind < argc)
+    {
+      const char *coptarg;
       /* Parse the next argument.  */
+      c = getopt_long (argc, argv, options, long_options, (int *) 0);
+      c = getopt_long (argc, (char*const*)argv, options, long_options, NULL);
+      coptarg = optarg;
       if (c == EOF)
         /* End of arguments, or "--" marker seen.  */
         break;
+        /* End of arguments, or "--" marker seen.  */
+        break;
       else if (c == 1)
         /* An argument not starting with a dash.  */
         handle_non_switch_argument (optarg, env);
+        /* An argument not starting with a dash.  */
+        handle_non_switch_argument (coptarg, env);
       else if (c == '?')
         /* Bad option.  We will print a usage message and die later.
            But continue to parse the other options so the user can
            see all he did wrong.  */
         bad = 1;
+        /* Bad option.  We will print a usage message and die later.
+           But continue to parse the other options so the user can
+           see all he did wrong.  */
+        bad = 1;
       else
+        for (cs = switches; cs->c != '\0'; ++cs)
+          if (cs->c == c)
+            {
+              /* Whether or not we will actually do anything with
+                 this switch.  We test this individually inside the
+                 switch below rather than just once outside it, so that
+                 options which are to be ignored still consume args.  */
+              int doit = !env || cs->env;
+              switch (cs->type)
+                {
+                default:
+                  abort ();
+                case ignore:
+                  break;
+                case flag:
+                case flag_off:
+                  if (doit)
+                    *(int *) cs->value_ptr = cs->type == flag;
+                  break;
+                case string:
+                case filename:
+                  if (!doit)
+                    break;
+                  if (optarg == 0)
+                    optarg = xstrdup (cs->noarg_value);
+                  else if (*optarg == '\0')
+        for (cs = switches; cs->c != '\0'; ++cs)
+          if (cs->c == c)
+            {
+              /* Whether or not we will actually do anything with
+                 this switch.  We test this individually inside the
+                 switch below rather than just once outside it, so that
+                 options which are to be ignored still consume args.  */
+              int doit = !env || cs->env;
+              switch (cs->type)
+                {
+                default:
+                  abort ();
+                case ignore:
+                  break;
+                case flag:
+                case flag_off:
+                  if (doit)
+                    *(int *) cs->value_ptr = cs->type == flag;
+                  break;
+                case string:
+                case strlist:
+                case filename:
+                  if (!doit)
+                    break;
+                  if (! coptarg)
+                    coptarg = xstrdup (cs->noarg_value);
+                  else if (*coptarg == '\0')
+                    {
                       char opt[2] = "c";
 …
                         op = cs->long_name;
+                      error (NILF, _("the `%s%s' option requires a non-empty string argument"),
+                      error (NILF, strlen (op),
+                             _("the '%s%s' option requires a non-empty string argument"),
                              short_option (cs->c) ? "-" : "--", op);
                       bad = 1;
+                      break;
+                    }
+                  sl = *(struct stringlist **) cs->value_ptr;
+                  if (sl == 0)
+                    {
+                      sl = (struct stringlist *)
+                        xmalloc (sizeof (struct stringlist));
+                      sl->max = 5;
+                      sl->idx = 0;
+                      sl->list = xmalloc (5 * sizeof (char *));
+                      *(struct stringlist **) cs->value_ptr = sl;
+                    }
+                  else if (sl->idx == sl->max - 1)
+                    {
+                      sl->max += 5;
+                  if (cs->type == string)
+                    {
+                      char **val = (char **)cs->value_ptr;
+                      free (*val);
+                      *val = xstrdup (coptarg);
+                      break;
+                    }
+                  sl = *(struct stringlist **) cs->value_ptr;
+                  if (sl == 0)
+                    {
+                      sl = xmalloc (sizeof (struct stringlist));
+                      sl->max = 5;
+                      sl->idx = 0;
+                      sl->list = xmalloc (5 * sizeof (char *));
+                      *(struct stringlist **) cs->value_ptr = sl;
+                    }
+                  else if (sl->idx == sl->max - 1)
+                    {
+                      sl->max += 5;
                       /* MSVC erroneously warns without a cast here.  */
                       sl->list = xrealloc ((void *)sl->list,
+                      sl->list = xrealloc ((void *)sl->list,
                                            sl->max * sizeof (char *));
+                    }
+                    }
                   if (cs->type == filename)
                     sl->list[sl->idx++] = expand_command_line_file (optarg);
+                    sl->list[sl->idx++] = expand_command_line_file (coptarg);
                   else
                     sl->list[sl->idx++] = optarg;
                   sl->list[sl->idx] = 0;
                   break;
                 case positive_int:
+                    sl->list[sl->idx++] = xstrdup (coptarg);
+                  sl->list[sl->idx] = 0;
+                  break;
+                case positive_int:
                   /* See if we have an option argument; if we do require that
                      it's all digits, not something like "10foo".  */
                   if (optarg == 0 && argc > optind)
+                  if (coptarg == 0 && argc > optind)
+                    {
                       const char *cp;
 …
+                        ;
                       if (cp[0] == '\0')
                         optarg = argv[optind++];
+                        coptarg = argv[optind++];
+                    }
                   if (!doit)
                     break;
                   if (optarg != 0)
+                    {
                       int i = atoi (optarg);
+                  if (!doit)
+                    break;
+                  if (coptarg)
+                    {
+                      int i = atoi (coptarg);
                       const char *cp;
                       /* Yes, I realize we're repeating this in some cases.  */
                       for (cp = optarg; ISDIGIT (cp[0]); ++cp)
+                      for (cp = coptarg; ISDIGIT (cp[0]); ++cp)
+                        ;
+                      if (i < 1 || cp[0] != '\0')
+                        {
+                          error (NILF, _("the `-%c' option requires a positive integral argument"),
+                      if (i < 1 || cp[0] != '\0')
+                        {
+                          error (NILF, 0,
+                                 _("the '-%c' option requires a positive integer argument"),
                                  cs->c);
                           bad = 1;
+                        }
                       else
                         *(unsigned int *) cs->value_ptr = i;
+                    }
                   else
                     *(unsigned int *) cs->value_ptr
                       = *(unsigned int *) cs->noarg_value;
                   break;
+                          bad = 1;
+                        }
+                      else
+                        *(unsigned int *) cs->value_ptr = i;
+                    }
+                  else
+                    *(unsigned int *) cs->value_ptr
+                      = *(unsigned int *) cs->noarg_value;
+                  break;
 #ifndef NO_FLOAT
                 case floating:
                   if (optarg == 0 && optind < argc
                       && (ISDIGIT (argv[optind][0]) || argv[optind][0] == '.'))
                     optarg = argv[optind++];
                   if (doit)
                     *(double *) cs->value_ptr
                       = (optarg != 0 ? atof (optarg)
                          : *(double *) cs->noarg_value);
                   break;
 #endif
+                }
               /* We've found the switch.  Stop looking.  */
               break;
+            }
+                case floating:
+                  if (coptarg == 0 && optind < argc
+                      && (ISDIGIT (argv[optind][0]) || argv[optind][0] == '.'))
+                    coptarg = argv[optind++];
+                  if (doit)
+                    *(double *) cs->value_ptr
+                      = (coptarg != 0 ? atof (coptarg)
+                         : *(double *) cs->noarg_value);
+                  break;
+#endif
+                }
+              /* We've found the switch.  Stop looking.  */
+              break;
+            }
+    }
 …
     handle_non_switch_argument (argv[optind++], env);
   if (!env && (bad || print_usage_flag))
+    {
       print_usage (bad);
+      die (bad ? 2 : 0);
+    }
+      die (bad ? MAKE_FAILURE : MAKE_SUCCESS);
+    }
+  /* If there are any options that need to be decoded do it now.  */
+  decode_debug_flags ();
+  decode_output_sync_flags ();
+}
 …
 static void
 decode_env_switches (char *envar, unsigned int len)
+decode_env_switches (const char *envar, unsigned int len)
+{
   char *varref = alloca (2 + len + 2);
   char *value, *p;
+  char *value, *p, *buf;
   int argc;
   char **argv;
+  const char **argv;
   /* Get the variable's value.  */
 …
   /* Skip whitespace, and check for an empty value.  */
   value = next_token (value);
+  NEXT_TOKEN (value);
   len = strlen (value);
   if (len == 0)
 …
   /* Allocate a vector that is definitely big enough.  */
   argv = alloca ((1 + len + 1) * sizeof (char *));
-  /* Allocate a buffer to copy the value into while we split it into words
-     and unquote it.  We must use permanent storage for this because
-     decode_switches may store pointers into the passed argument words.  */
-  p = xmalloc (2 * len);
   /* getopt will look at the arguments starting at ARGV[1].
 …
   argv[0] = 0;
   argc = 1;
+  /* We need a buffer to copy the value into while we split it into words
+     and unquote it.  Set up in case we need to prepend a dash later.  */
+  buf = alloca (1 + len + 1);
+  buf[0] = '-';
+  p = buf+1;
   argv[argc] = p;
   while (*value != '\0')
+    {
       if (*value == '\\' && value[1] != '\0')
         ++value;                /* Skip the backslash.  */
       else if (isblank ((unsigned char)*value))
+        {
           /* End of the word.  */
           *p++ = '\0';
           argv[++argc] = p;
           do
             ++value;
           while (isblank ((unsigned char)*value));
           continue;
+        }
+        ++value;                /* Skip the backslash.  */
+      else if (ISBLANK (*value))
+        {
+          /* End of the word.  */
+          *p++ = '\0';
+          argv[++argc] = p;
+          do
+            ++value;
+          while (ISBLANK (*value));
+          continue;
+        }
       *p++ = *value++;
+    }
   *p = '\0';
   argv[++argc] = 0;
+  assert (p < buf + len + 2);
   if (argv[1][0] != '-' && strchr (argv[1], '=') == 0)
     /* The first word doesn't start with a dash and isn't a variable
+       definition.  Add a dash and pass it along to decode_switches.  We
+       need permanent storage for this in case decode_switches saves
+       pointers into the value.  */
+    argv[1] = xstrdup (concat (2, "-", argv[1]));
+       definition, so add a dash.  */
+    argv[1] = buf;
   /* Parse those words.  */
 …
+    {
       if (*in == '$')
         *out++ = '$';
       else if (isblank ((unsigned char)*in) || *in == '\\')
+        *out++ = '$';
+      else if (ISBLANK (*in) || *in == '\\')
         *out++ = '\\';
       *out++ = *in++;
 …
 /* Define the MAKEFLAGS and MFLAGS variables to reflect the settings of the
    command switches.  Include options with args if ALL is nonzero.
    Don't include options with the `no_makefile' flag set if MAKEFILE.  */
 static const char *
+   Don't include options with the 'no_makefile' flag set if MAKEFILE.  */
+static struct variable *
 define_makeflags (int all, int makefile)
+{
 …
   const struct command_switch *cs;
   char *flagstring;
+  register char *p;
+  unsigned int words;
+  struct variable *v;
+  /* We will construct a linked list of `struct flag's describing
+  char *p;
+  /* We will construct a linked list of 'struct flag's describing
      all the flags which need to go in MAKEFLAGS.  Then, once we
      know how many there are and their lengths, we can put them all
 …
     };
   struct flag *flags = 0;
+  struct flag *last = 0;
   unsigned int flagslen = 0;
+#define ADD_FLAG(ARG, LEN) \
+  do {                                                                        \
+    struct flag *new = alloca (sizeof (struct flag));                         \
+    new->cs = cs;                                                             \
+    new->arg = (ARG);                                                         \
+    new->next = flags;                                                        \
+    flags = new;                                                              \
+    if (new->arg == 0)                                                        \
+      ++flagslen;               /* Just a single flag letter.  */             \
+    else                                                                      \
+      /* " -x foo", plus space to expand "foo".  */                           \
+      flagslen += 1 + 1 + 1 + 1 + (3 * (LEN));                                \
+    if (!short_option (cs->c))                                                \
+#define ADD_FLAG(ARG, LEN) \
+  do {                                                                        \
+    struct flag *new = alloca (sizeof (struct flag));                         \
+    new->cs = cs;                                                             \
+    new->arg = (ARG);                                                         \
+    new->next = 0;                                                            \
+    if (! flags)                                                              \
+      flags = new;                                                            \
+    else                                                                      \
+      last->next = new;                                                       \
+    last = new;                                                               \
+    if (new->arg == 0)                                                        \
+      /* Just a single flag letter: " -x"  */                                 \
+      flagslen += 3;                                                          \
+    else                                                                      \
+      /* " -xfoo", plus space to escape "foo".  */                            \
+      flagslen += 1 + 1 + 1 + (3 * (LEN));                                    \
+    if (!short_option (cs->c))                                                \
       /* This switch has no single-letter version, so we use the long.  */    \
       flagslen += 2 + strlen (cs->long_name);                                 \
+      flagslen += 2 + strlen (cs->long_name);                                 \
   } while (0)
 …
     if (cs->toenv && (!makefile || !cs->no_makefile))
       switch (cs->type)
+        {
+        case ignore:
+          break;
+        case flag:
+        case flag_off:
+          if (!*(int *) cs->value_ptr == (cs->type == flag_off)
+              && (cs->default_value == 0
+                  || *(int *) cs->value_ptr != *(int *) cs->default_value))
+            ADD_FLAG (0, 0);
+          break;
+        case positive_int:
+          if (all)
+            {
+              if ((cs->default_value != 0
+                   && (*(unsigned int *) cs->value_ptr
+                       == *(unsigned int *) cs->default_value)))
+                break;
+              else if (cs->noarg_value != 0
+                       && (*(unsigned int *) cs->value_ptr ==
+                           *(unsigned int *) cs->noarg_value))
+                ADD_FLAG ("", 0); /* Optional value omitted; see below.  */
+              else if (cs->c == 'j')
+                /* Special case for `-j'.  */
+                ADD_FLAG ("1", 1);
+              else
+                {
+                  char *buf = alloca (30);
+                  sprintf (buf, "%u", *(unsigned int *) cs->value_ptr);
+                  ADD_FLAG (buf, strlen (buf));
+                }
+            }
+          break;
+        {
+        case ignore:
+          break;
+        case flag:
+        case flag_off:
+          if ((!*(int *) cs->value_ptr) == (cs->type == flag_off)
+              && (cs->default_value == 0
+                  || *(int *) cs->value_ptr != *(int *) cs->default_value))
+            ADD_FLAG (0, 0);
+          break;
+        case positive_int:
+          if (all)
+            {
+              if ((cs->default_value != 0
+                   && (*(unsigned int *) cs->value_ptr
+                       == *(unsigned int *) cs->default_value)))
+                break;
+              else if (cs->noarg_value != 0
+                       && (*(unsigned int *) cs->value_ptr ==
+                           *(unsigned int *) cs->noarg_value))
+                ADD_FLAG ("", 0); /* Optional value omitted; see below.  */
+              else
+                {
+                  char *buf = alloca (30);
+                  sprintf (buf, "%u", *(unsigned int *) cs->value_ptr);
+                  ADD_FLAG (buf, strlen (buf));
+                }
+            }
+          break;
 #ifndef NO_FLOAT
+        case floating:
+          if (all)
+            {
+              if (cs->default_value != 0
+                  && (*(double *) cs->value_ptr
+                      == *(double *) cs->default_value))
+                break;
+              else if (cs->noarg_value != 0
+                       && (*(double *) cs->value_ptr
+                           == *(double *) cs->noarg_value))
+                ADD_FLAG ("", 0); /* Optional value omitted; see below.  */
+              else
+                {
+                  char *buf = alloca (100);
+                  sprintf (buf, "%g", *(double *) cs->value_ptr);
+                  ADD_FLAG (buf, strlen (buf));
+                }
+            }
+          break;
+#endif
+        case filename:
+        case string:
+          if (all)
+            {
+              struct stringlist *sl = *(struct stringlist **) cs->value_ptr;
+              if (sl != 0)
+                {
+                  /* Add the elements in reverse order, because all the flags
+                     get reversed below; and the order matters for some
+                     switches (like -I).  */
+                  unsigned int i = sl->idx;
+                  while (i-- > 0)
+                    ADD_FLAG (sl->list[i], strlen (sl->list[i]));
+                }
+            }
+          break;
+        default:
+          abort ();
+        }
+  /* Four more for the possible " -- ".  */
+  flagslen += 4 + sizeof (posixref) + sizeof (evalref);
+#undef  ADD_FLAG
+        case floating:
+          if (all)
+            {
+              if (cs->default_value != 0
+                  && (*(double *) cs->value_ptr
+                      == *(double *) cs->default_value))
+                break;
+              else if (cs->noarg_value != 0
+                       && (*(double *) cs->value_ptr
+                           == *(double *) cs->noarg_value))
+                ADD_FLAG ("", 0); /* Optional value omitted; see below.  */
+              else
+                {
+                  char *buf = alloca (100);
+                  sprintf (buf, "%g", *(double *) cs->value_ptr);
+                  ADD_FLAG (buf, strlen (buf));
+                }
+            }
+          break;
+#endif
+        case string:
+          if (all)
+            {
+              p = *((char **)cs->value_ptr);
+              if (p)
+                ADD_FLAG (p, strlen (p));
+            }
+          break;
+        case filename:
+        case strlist:
+          if (all)
+            {
+              struct stringlist *sl = *(struct stringlist **) cs->value_ptr;
+              if (sl != 0)
+                {
+                  unsigned int i;
+                  for (i = 0; i < sl->idx; ++i)
+                    ADD_FLAG (sl->list[i], strlen (sl->list[i]));
+                }
+            }
+          break;
+        default:
+          abort ();
+        }
+#undef  ADD_FLAG
+  /* Four more for the possible " -- ", plus variable references.  */
+  flagslen += 4 + CSTRLEN (posixref) + 1 + CSTRLEN (evalref) + 1;
   /* Construct the value in FLAGSTRING.
 …
   memset (flagstring, '\0', 1 + flagslen + 1);
   p = flagstring;
+  words = 1;
+  /* Start with a dash, for MFLAGS.  */
   *p++ = '-';
+  while (flags != 0)
+    {
+  /* Add simple options as a group.  */
+  while (flags != 0 && !flags->arg && short_option (flags->cs->c))
+    {
+      *p++ = flags->cs->c;
+      flags = flags->next;
+    }
+  /* Now add more complex flags: ones with options and/or long names.  */
+  while (flags)
+    {
+      *p++ = ' ';
+      *p++ = '-';
       /* Add the flag letter or name to the string.  */
       if (short_option (flags->cs->c))
         *p++ = flags->cs->c;
+        *p++ = flags->cs->c;
       else
+        {
+          if (*p != '-')
+            {
+              *p++ = ' ';
+              *p++ = '-';
+            }
+          *p++ = '-';
+          strcpy (p, flags->cs->long_name);
+          p += strlen (p);
+        }
+      if (flags->arg != 0)
+        {
+          /* A flag that takes an optional argument which in this case is
+             omitted is specified by ARG being "".  We must distinguish
+             because a following flag appended without an intervening " -"
+             is considered the arg for the first.  */
+          if (flags->arg[0] != '\0')
+            {
+              /* Add its argument too.  */
+              *p++ = !short_option (flags->cs->c) ? '=' : ' ';
+              p = quote_for_env (p, flags->arg);
+            }
+          ++words;
+          /* Write a following space and dash, for the next flag.  */
+          *p++ = ' ';
+          *p++ = '-';
+        }
+      else if (!short_option (flags->cs->c))
+        {
+          ++words;
+          /* Long options must each go in their own word,
+             so we write the following space and dash.  */
+          *p++ = ' ';
+          *p++ = '-';
+        }
+        {
+          /* Long options require a double-dash.  */
+          *p++ = '-';
+          strcpy (p, flags->cs->long_name);
+          p += strlen (p);
+        }
+      /* An omitted optional argument has an ARG of "".  */
+      if (flags->arg && flags->arg[0] != '\0')
+        {
+          if (!short_option (flags->cs->c))
+            /* Long options require '='.  */
+            *p++ = '=';
+          p = quote_for_env (p, flags->arg);
+        }
       flags = flags->next;
+    }
+  /* Define MFLAGS before appending variable definitions.  */
+  /* If no flags at all, get rid of the initial dash.  */
   if (p == &flagstring[1])
+    /* No flags.  */
+    flagstring[0] = '\0';
+  else if (p[-1] == '-')
+    {
+      /* Kill the final space and dash.  */
+      p -= 2;
+      *p = '\0';
+    }
+  else
+    /* Terminate the string.  */
+    *p = '\0';
+  /* Since MFLAGS is not parsed for flags, there is no reason to
+    {
+      flagstring[0] = '\0';
+      p = flagstring;
+    }
+  /* Define MFLAGS before appending variable definitions.  Omit an initial
+     empty dash.  Since MFLAGS is not parsed for flags, there is no reason to
      override any makefile redefinition.  */
+  define_variable_cname ("MFLAGS", flagstring, o_env, 1);
+  define_variable_cname ("MFLAGS",
+                         flagstring + (flagstring[0] == '-' && flagstring[1] == ' ' ? 2 : 0),
+                         o_env, 1);
   /* Write a reference to -*-eval-flags-*-, which contains all the --eval
 …
   if (eval_strings)
+    {
+      if (p == &flagstring[1])
+        /* No flags written, so elide the leading dash already written.  */
+        p = flagstring;
+      else
+        *p++ = ' ';
+      memcpy (p, evalref, sizeof (evalref) - 1);
+      p += sizeof (evalref) - 1;
+    }
+  if (all && command_variables != 0)
+    {
+      /* Now write a reference to $(MAKEOVERRIDES), which contains all the
+         command-line variable definitions.  */
+      if (p == &flagstring[1])
+        /* No flags written, so elide the leading dash already written.  */
+        p = flagstring;
+      else
+        {
+          /* Separate the variables from the switches with a "--" arg.  */
+          if (p[-1] != '-')
+            {
+              /* We did not already write a trailing " -".  */
+              *p++ = ' ';
+              *p++ = '-';
+            }
+          /* There is a trailing " -"; fill it out to " -- ".  */
+          *p++ = '-';
+          *p++ = ' ';
+        }
+      *p++ = ' ';
+      memcpy (p, evalref, CSTRLEN (evalref));
+      p += CSTRLEN (evalref);
+    }
+  if (all && command_variables)
+    {
+      /* Write a reference to $(MAKEOVERRIDES), which contains all the
+         command-line variable definitions.  Separate the variables from the
+         switches with a "--" arg.  */
+      strcpy (p, " -- ");
+      p += 4;
       /* Copy in the string.  */
       if (posix_pedantic)
+        {
           memcpy (p, posixref, sizeof (posixref) - 1);
           p += sizeof (posixref) - 1;
+        }
+        {
+          memcpy (p, posixref, CSTRLEN (posixref));
+          p += CSTRLEN (posixref);
+        }
       else
+        {
+          memcpy (p, ref, sizeof (ref) - 1);
+          p += sizeof (ref) - 1;
+        }
+    }
+  else if (p == &flagstring[1])
+    {
+      words = 0;
+      --p;
+    }
+  else if (p[-1] == '-')
+    /* Kill the final space and dash.  */
+    p -= 2;
+  /* Terminate the string.  */
+  *p = '\0';
+  /* If there are switches, omit the leading dash unless it is a single long
+     option with two leading dashes.  */
+  if (flagstring[0] == '-' && flagstring[1] != '-')
+        {
+          memcpy (p, ref, CSTRLEN (ref));
+          p += CSTRLEN (ref);
+        }
+    }
+  /* If there is a leading dash, omit it.  */
+  if (flagstring[0] == '-')
     ++flagstring;
+  v = define_variable_cname ("MAKEFLAGS", flagstring,
+                             /* This used to use o_env, but that lost when a
+                                makefile defined MAKEFLAGS.  Makefiles set
+                                MAKEFLAGS to add switches, but we still want
+                                to redefine its value with the full set of
+                                switches.  Of course, an override or command
+                                definition will still take precedence.  */
+                             o_file, 1);
+  if (! all)
+    /* The first time we are called, set MAKEFLAGS to always be exported.
+       We should not do this again on the second call, because that is
+       after reading makefiles which might have done `unexport MAKEFLAGS'. */
+    v->export = v_export;
+  return v->value;
+  /* This used to use o_env, but that lost when a makefile defined MAKEFLAGS.
+     Makefiles set MAKEFLAGS to add switches, but we still want to redefine
+     its value with the full set of switches.  Then we used o_file, but that
+     lost when users added -e, causing a previous MAKEFLAGS env. var. to take
+     precedence over the new one.  Of course, an override or command
+     definition will still take precedence.  */
+  return define_variable_cname ("MAKEFLAGS", flagstring,
+                                env_overrides ? o_env_override : o_file, 1);
+}
 …
   static int printed_version = 0;
   char *precede = print_data_base_flag ? "# " : "";
+  const char *precede = print_data_base_flag ? "# " : "";
   if (printed_version)
 …
      (C) to the copyright symbol, but this string is going to change every
      year, and none of the rest of it should be translated (including the
+     word "Copyright", so it hardly seems worth it.  */
+  printf ("%sCopyright (C) 2010  Free Software Foundation, Inc.\n", precede);
+     word "Copyright"), so it hardly seems worth it.  */
+  printf ("%sCopyright (C) 1988-2016 Free Software Foundation, Inc.\n",
+          precede);
   printf (_("%sLicense GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n\
 …
   /* Flush stdout so the user doesn't have to wait to see the
      version information while things are thought about.  */
+     version information while make thinks about things.  */
   fflush (stdout);
+}
 …
 static void
 print_data_base ()
+print_data_base (void)
+{
+  time_t when;
+  when = time ((time_t *) 0);
+  time_t when = time ((time_t *) 0);
+  print_version ();
   printf (_("\n# Make data base, printed on %s"), ctime (&when));
 …
 clean_jobserver (int status)
+{
-  char token = '+';
   /* Sanity: have we written all our jobserver tokens back?  If our
      exit status is 2 that means some kind of syntax error; we might not
 …
      after any other error code, that's bad.  */
   if (job_fds[0] != -1 && jobserver_tokens)
+  if (jobserver_enabled() && jobserver_tokens)
+    {
       if (status != 2)
         error (NILF,
                "INTERNAL: Exiting with %u jobserver tokens (should be 0)!",
                jobserver_tokens);
+        ON (error, NILF,
+            "INTERNAL: Exiting with %u jobserver tokens (should be 0)!",
+            jobserver_tokens);
       else
+        while (jobserver_tokens--)
+          {
+            int r;
+            EINTRLOOP (r, write (job_fds[1], &token, 1));
+            if (r != 1)
+              perror_with_name ("write", "");
+          }
+        /* Don't write back the "free" token */
+        while (--jobserver_tokens)
+          jobserver_release (0);
+    }
 …
+    {
       /* We didn't write one for ourself, so start at 1.  */
+      unsigned int tcnt = 1;
+      /* Close the write side, so the read() won't hang.  */
+      close (job_fds[1]);
+      while (read (job_fds[0], &token, 1) == 1)
+        ++tcnt;
+      if (tcnt != master_job_slots)
+        error (NILF,
+               "INTERNAL: Exiting with %u jobserver tokens available; should be %u!",
+               tcnt, master_job_slots);
+      close (job_fds[0]);
+      /* Clean out jobserver_fds so we don't pass this information to any
+         sub-makes.  Also reset job_slots since it will be put on the command
+         line, not in MAKEFLAGS.  */
+      job_slots = default_job_slots;
+      if (jobserver_fds)
+        {
+          /* MSVC erroneously warns without a cast here.  */
+          free ((void *)jobserver_fds->list);
+          free (jobserver_fds);
+          jobserver_fds = 0;
+        }
+      unsigned int tokens = 1 + jobserver_acquire_all ();
+      if (tokens != master_job_slots)
+        ONN (error, NILF,
+             "INTERNAL: Exiting with %u jobserver tokens available; should be %u!",
+             tokens, master_job_slots);
+      reset_jobserver ();
+    }
+}
 …
       if (print_version_flag)
         print_version ();
+        print_version ();
       /* Wait for children to die.  */
       err = (status != 0);
       while (job_slots_used > 0)
         reap_children (1, err);
+        reap_children (1, err);
       /* Let the remote job module clean up its state.  */
 …
       if (print_data_base_flag)
+        print_data_base ();
+      verify_file_data_base ();
+        print_data_base ();
+      if (verify_flag)
+        verify_file_data_base ();
       clean_jobserver (status);
+      if (output_context)
+        {
+          /* die() might be called in a recipe output context due to an
+             $(error ...) function.  */
+          output_close (output_context);
+          if (output_context != &make_sync)
+            output_close (&make_sync);
+          OUTPUT_UNSET ();
+        }
+      output_close (NULL);
       /* Try to move back to the original directory.  This is essential on
          MS-DOS (where there is really only one process), and on Unix it
          puts core files in the original directory instead of the -C
          directory.  Must wait until after remove_intermediates(), or unlinks
+         MS-DOS (where there is really only one process), and on Unix it
+         puts core files in the original directory instead of the -C
+         directory.  Must wait until after remove_intermediates(), or unlinks
          of relative pathnames fail.  */
       if (directory_before_chdir != 0)
+        {
           /* If it fails we don't care: shut up GCC.  */
           int _x;
+          int _x UNUSED;
           _x = chdir (directory_before_chdir);
+        }
-      log_working_directory (0);
+    }
   exit (status);
+}
-/* Write a message indicating that we've just entered or
-   left (according to ENTERING) the current directory.  */
-void
-log_working_directory (int entering)
+{
-  static int entered = 0;
-  /* Print nothing without the flag.  Don't print the entering message
-     again if we already have.  Don't print the leaving message if we
-     haven't printed the entering message.  */
-  if (! print_directory_flag || entering == entered)
-    return;
-  entered = entering;
-  if (print_data_base_flag)
-    fputs ("# ", stdout);
-  /* Use entire sentences to give the translators a fighting chance.  */
-  if (makelevel == 0)
-    if (starting_directory == 0)
-      if (entering)
-        printf (_("%s: Entering an unknown directory\n"), program);
-      else
-        printf (_("%s: Leaving an unknown directory\n"), program);
-    else
-      if (entering)
-        printf (_("%s: Entering directory `%s'\n"),
-                program, starting_directory);
-      else
-        printf (_("%s: Leaving directory `%s'\n"),
-                program, starting_directory);
-  else
-    if (starting_directory == 0)
-      if (entering)
-        printf (_("%s[%u]: Entering an unknown directory\n"),
-                program, makelevel);
-      else
-        printf (_("%s[%u]: Leaving an unknown directory\n"),
-                program, makelevel);
-    else
-      if (entering)
-        printf (_("%s[%u]: Entering directory `%s'\n"),
-                program, makelevel, starting_directory);
-      else
-        printf (_("%s[%u]: Leaving directory `%s'\n"),
-                program, makelevel, starting_directory);
-  /* Flush stdout to be sure this comes before any stderr output.  */
-  fflush (stdout);
+}

vendor/gnumake/current/maintMakefile

-              r2596
+              r3138
 # Maintainer-only makefile segment.  This contains things that are relevant
 # only if you have the full copy of the GNU make sources from the CVS
+# only if you have the full copy of the GNU make sources from the Git
 # tree, not a dist copy.
+BUGLIST := bug-make@gnu.org
+# These are related to my personal setup.
+GPG_FINGERPRINT := 6338B6D4
+# SRCROOTDIR is just a handy location to keep source files in
+SRCROOTDIR ?= $(HOME)/src
+# Where the gnulib project has been locally cloned
+GNULIBDIR ?= $(SRCROOTDIR)/gnulib
+# Where to put the CVS checkout of the GNU web repository
+GNUWEBDIR ?= $(SRCROOTDIR)/gnu-www
+# Where to put the CVS checkout of the GNU make web repository
+MAKEWEBDIR ?= $(SRCROOTDIR)/make/make-web
 # We like mondo-warnings!
+AM_CFLAGS += -Wall -Wextra -Wdeclaration-after-statement -Wshadow -Wpointer-arith -Wbad-function-cast
+AM_CFLAGS += -Wall -Wwrite-strings -Wextra -Wdeclaration-after-statement -Wshadow -Wpointer-arith -Wbad-function-cast
+MAKE_MAINTAINER_MODE := -DMAKE_MAINTAINER_MODE
+AM_CPPFLAGS += $(MAKE_MAINTAINER_MODE)
 # I want this one but I have to wait for the const cleanup!
 …
 # These are built as a side-effect of the dist rule
 #all-am: $(TEMPLATES) $(MTEMPLATES) build.sh.in
+# Create preprocessor output files--GCC specific!
+%.i : %.c
+        $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) -E -dD -o $@ $<
 # General rule for turning a .template into a regular file.
 …
          done) > $@
+# Get rid of everything "else".
+#
+maintFILES = configure aclocal.m4 config.h.in Makefile.in stamp-h.in
+CVS-CLEAN-FILES +=      $(maintFILES) $(TEMPLATES) $(MTEMPLATES) NMakefile \
+                        build.sh.in .deps .dep_segment ABOUT-NLS \
+                        ansi2knr.*
+# This rule tries to clean the tree right down to how it looks when you do a
+# virgin CVS checkout.
+# This target is potentially dangerous since it removes _ANY FILE_ that
+# is not in CVS.  Including files you might mean to add to CVS but
+# haven't yet...  I only use this in subdirectories where it's unlikely
+# we have any new files.  Still... be careful!!
+cvsclean = $(PERL) -e '$$k{CVS} = 1; open(E,"< CVS/Entries") || die "CVS/Entries: $$!\n"; while (defined ($$_ = <E>)) { m%^/([^/]*)% or next; $$k{$$1} = 1; } close(E) || die "CVS/Entries: $$!\n"; opendir(D, ".") || die ".: $$!\n"; while (defined ($$_ = readdir(D))) { -f $$_ && ! exists $$k{$$_} && unlink($$_); } closedir(D) || die ".: $$!\n";'
+.PHONY: cvs-clean
+cvs-clean: maintainer-clean
+        -rm -rf *~ $(CVS-CLEAN-FILES)
+        -cd config && $(cvsclean)
+        -cd po     && $(cvsclean)
+        -cd doc    && $(cvsclean)
+        -cd glob   && $(cvsclean)
+# ----------------------------------------------------------------------
+#
+# The sections below were stolen from the Makefile.maint used by fileutils,
+# sh-utils, textutils, CPPI, Bison, and Autoconf.
+# Cleaning
+GIT :=  git
+# git-clean:      Clean all "ignored" files.  Leave untracked files.
+# git-very-clean: Clean all files that aren't stored in source control.
+.PHONY: git-clean git-very-clean
+git-clean:
+        -$(GIT) clean -fdX
+git-very-clean: git-clean
+        -$(GIT) clean -fd
+## ---------------------- ##
+## Generating ChangeLog.  ##
+## ---------------------- ##
+gl2cl-date := 2013-10-10
+gl2cl := $(GNULIBDIR)/build-aux/gitlog-to-changelog
+# Rebuild the changelog whenever a new commit is added
+ChangeLog: .check-git-HEAD
+        if test -f '$(gl2cl)'; then \
+            '$(gl2cl)' --since='$(gl2cl-date)' > '$@'; \
+        else \
+            echo "WARNING: $(gl2cl) is not available.  No $@ generated."; \
+        fi
+.PHONY: .check-git-HEAD
+.check-git-HEAD:
+        sha="`git rev-parse HEAD`"; \
+        [ -f '$@' ] && [ "`cat '$@' 2>/dev/null`" = "$$sha" ] \
+            || echo "$$sha" > '$@'
 …
 ## Updating files.  ##
 ## ---------------- ##
 WGET = wget --passive-ftp -nv
+RSYNC = rsync -Lrtvz
+WGET = wget --passive-ftp -np -nv
 ftp-gnu = ftp://ftp.gnu.org/gnu
 …
                     echo $(target) is unchanged; rm -f $(target).t; \
                   else \
                     mv $(target).t $(target); \
+                    mv -f $(target).t $(target); \
                   fi
 …
 #   ftp://tiger.informatik.hu-berlin.de/pub/po/maint/
+po_wget_flags = --recursive --level=1 --no-directories --no-check-certificate
 po_repo = http://translationproject.org/latest/$(PACKAGE)
+po_sync = translationproject.org::tp/latest/$(PACKAGE)/
 .PHONY: do-po-update po-update
 do-po-update:
 …
           && rm -rf "$$tmppo" \
           && mkdir "$$tmppo" \
           && (cd "$$tmppo" \
                 && $(WGET) -r -l1 -nd --no-parent -A '*.po' $(po_repo)) \
           && cp "$$tmppo"/*.po $(top_srcdir)/po && rm -rf "$$tmppo"
+          && $(RSYNC) $(po_sync)  "$$tmppo" \
+          && cp "$$tmppo"/*.po $(top_srcdir)/po \
+          && rm -rf "$$tmppo"
         cd po && $(MAKE) update-po
         $(MAKE) po-check
 …
+# ---------------------------------- #
+# Alternative configuration checks.  #
+# ---------------------------------- #
+.PHONY: check-alt-config
+check-alt-config: \
+        checkcfg.--disable-job-server \
+        checkcfg.--disable-load \
+        checkcfg.--without-guile \
+        checkcfg.CPPFLAGS^-DNO_OUTPUT_SYNC \
+        checkcfg.CPPFLAGS^-DNO_ARCHIVES
+# Trick GNU make so it doesn't run the submake as a recursive make.
+NR_MAKE = $(MAKE)
+# Check builds both with build.sh and with make
+checkcfg.%: distdir
+        @echo "Building $@ (output in checkcfg.$*.log)"
+        @exec >'checkcfg.$*.log' 2>&1; \
+           rm -rf $(distdir)/_build \
+        && mkdir $(distdir)/_build \
+        && cd $(distdir)/_build \
+        && echo "Testing configure with $(subst ^,=,$*)" \
+        && ../configure --srcdir=.. $(subst ^,=,$*) \
+                $(AM_DISTCHECK_CONFIGURE_FLAGS) $(DISTCHECK_CONFIGURE_FLAGS) \
+                CFLAGS='$(AM_CFLAGS)' \
+        && ./build.sh \
+        && ./make $(AM_MAKEFLAGS) check \
+        && rm -f *.o make \
+        && $(NR_MAKE) $(AM_MAKEFLAGS) \
+        && ./make $(AM_MAKEFLAGS) check
 ## --------------- ##
 ## Sanity checks.  ##
 ## --------------- ##
+# Checks that don't require cvs.  Run `changelog-check' last as
+# Before we build a distribution be sure we run our local checks
+#distdir: local-check
+.PHONY: local-check po-check changelog-check
+# Checks that don't require Git.  Run 'changelog-check' last as
 # previous test may reveal problems requiring new ChangeLog entries.
 local-check: po-check changelog-check
 …
 # Verify that all source files using _() are listed in po/POTFILES.in.
 # Ignore make.h; it defines _().
+# Ignore makeint.h; it defines _().
 po-check:
         if test -f po/POTFILES.in; then \
           grep '^[^#]' po/POTFILES.in | sort > $@-1; \
           $(PERL) -wn -e 'if (/\b_\(/) { $$ARGV eq "make.h" || print "$$ARGV\n" and close ARGV }' *.c *.h | sort > $@-2; \
+          $(PERL) -wn -e 'if (/\b_\(/) { $$ARGV eq "./makeint.h" || print "$$ARGV\n" and close ARGV }' `find . -name '*.[ch]'` | sed 's,^\./,,' | sort > $@-2; \
           diff -u $@-1 $@-2 || exit 1; \
           rm -f $@-1 $@-2; \
         fi
+## --------------- ##
+## Generate docs.  ##
+## --------------- ##
+.PHONY: update-makeweb gendocs
+CVS = cvs
+makeweb-repo = $(USER)@cvs.sv.gnu.org:/web/make
+gnuweb-repo = :pserver:anonymous@cvs.sv.gnu.org:/web/www
+gnuweb-dir = www/server/standards
+# Get the GNU make web page boilerplate etc.
+update-makeweb:
+        [ -d '$(MAKEWEBDIR)' ] || mkdir -p '$(MAKEWEBDIR)'
+        [ -d '$(MAKEWEBDIR)'/CVS ] \
+            && { cd '$(MAKEWEBDIR)' && $(CVS) update; } \
+            || { mkdir -p '$(dir $(MAKEWEBDIR))' && cd '$(dir $(MAKEWEBDIR))' \
+                 && $(CVS) -d $(makeweb-repo) co -d '$(notdir $(MAKEWEBDIR))' make; }
+# Get the GNU web page boilerplate etc.
+update-gnuweb:
+        [ -d '$(GNUWEBDIR)' ] || mkdir -p '$(GNUWEBDIR)'
+        [ -d '$(GNUWEBDIR)/$(gnuweb-dir)'/CVS ] \
+            && { cd '$(GNUWEBDIR)/$(gnuweb-dir)' && $(CVS) update; } \
+            || { cd '$(GNUWEBDIR)' && $(CVS) -d $(gnuweb-repo) co '$(gnuweb-dir)'; }
+gendocs: update-gnuweb update-makeweb
+        cp $(GNULIBDIR)/doc/gendocs_template doc
+        cd doc \
+          && rm -rf doc/manual \
+          && $(GNULIBDIR)/build-aux/gendocs.sh --email '$(BUGLIST)' \
+                make 'GNU Make Manual'
+        find '$(MAKEWEBDIR)'/manual \( -name CVS -prune \) -o \( -name '[!.]*' -type f -exec rm -f '{}' \; \)
+        cp -r doc/manual '$(MAKEWEBDIR)'
+        @echo 'Status of $(MAKEWEBDIR) repo:' && cd '$(MAKEWEBDIR)' \
+            && cvs -q -n update | grep -v '^M ' \
+            && echo '- cvs add <new files>' \
+            && echo '- cvs remove <deleted files>' \
+            && echo '- cvs commit' \
+            && echo '- cvs tag make-$(subst .,-,$(VERSION))'
+## ------------------------- ##
+## Make release targets.     ##
+## ------------------------- ##
+.PHONY: tag-release
+tag-release:
+        case '$(VERSION)' in \
+            (*.*.9*) message=" candidate" ;; \
+            (*)      message= ;; \
+        esac; \
+        $(GIT) tag -m "GNU Make release$$message $(VERSION)" -u '$(GPG_FINGERPRINT)' '$(VERSION)'
 ## ------------------------- ##
 ## GNU FTP upload artifacts. ##
 …
 GPG = gpg
 GPGFLAGS = -u 6338B6D4
+GPGFLAGS = -u $(GPG_FINGERPRINT)
 DIST_ARCHIVES_SIG = $(addsuffix .sig,$(DIST_ARCHIVES))
 …
+# Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+# 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+# Rebuild Makefile.in if this file is modifed.
+Makefile.in: maintMakefile
+# Copyright (C) 1997-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#

vendor/gnumake/current/make.1

-              r2596
+              r3138
 .TH MAKE 1 "22 August 1989" "GNU" "LOCAL USER COMMANDS"
+.TH MAKE 1 "28 February 2016" "GNU" "User Commands"
 .SH NAME
 make \- GNU make utility to maintain groups of programs
 .SH SYNOPSIS
+.B "make "
+[
+.B \-f
+.I makefile
+] [ options ] ... [ targets ] ...
+.SH WARNING
+This man page is an extract of the documentation of GNU
+.IR make .
+It is updated only occasionally, because the GNU project does not use nroff.
+For complete, current documentation, refer to the Info file
+.B make.info
+which is made from the Texinfo source file
+.BR make.texi .
+.B make
+[\fIOPTION\fR]... [\fITARGET\fR]...
 .SH DESCRIPTION
 .LP
 The purpose of the
+The
 .I make
+utility is to determine automatically which
+pieces of a large program need to be recompiled, and issue the commands to
+recompile them.
+The manual describes the GNU implementation of
+.IR make ,
+which was written by Richard Stallman and Roland McGrath, and is
+currently maintained by Paul Smith.
+Our examples show C programs, since they are most common, but you can use
+.I make
+with any programming language whose compiler can be run with a
+shell command.
+utility will determine automatically which pieces of a large program need to
+be recompiled, and issue the commands to recompile them.  The manual describes
+the GNU implementation of
+.BR make ,
+which was written by Richard Stallman and Roland McGrath, and is currently
+maintained by Paul Smith.  Our examples show C programs, since they are very
+common, but you can use
+.B make
+with any programming language whose compiler can be run with a shell command.
 In fact,
+.I make
+is not limited to programs.
+You can use it to describe any task where some files must be
+updated automatically from others whenever the others change.
+.B make
+is not limited to programs.  You can use it to describe any task where some
+files must be updated automatically from others whenever the others change.
 .LP
 To prepare to use
 .IR make ,
+.BR make ,
 you must write a file called the
 .I makefile
 that describes the relationships among files in your program, and the
+states the commands for updating each file.
+In a program, typically the executable file is updated from object
 files, which are in turn made by compiling source files.
+that describes the relationships among files in your program, and the states
+the commands for updating each file.  In a program, typically the executable
+file is updated from object files, which are in turn made by compiling source
+files.
 .LP
 Once a suitable makefile exists, each time you change some source files,
 …
 suffices to perform all necessary recompilations.
 The
 .I make
 program uses the makefile data base and the last-modification times
+of the files to decide which of the files need to be updated.
 For each of those files, it issues the commands recorded in the data base.
 .LP
 .I make
+.B make
+program uses the makefile description and the last-modification times of the
+files to decide which of the files need to be updated.  For each of those
+files, it issues the commands recorded in the makefile.
+.LP
+.B make
 executes commands in the
 .I makefile
+to update
+one or more target
+to update one or more target
 .IR names ,
 where
 …
 .B \-f
 option is present,
 .I make
+.B make
 will look for the makefiles
 .IR GNUmakefile ,
 …
 The first name checked,
 .IR GNUmakefile ,
 is not recommended for most makefiles.
 You should use this name if you have a makefile that is specific to GNU
 .IR make ,
+is not recommended for most makefiles.  You should use this name if you have a
+makefile that is specific to GNU
+.BR make ,
 and will not be understood by other versions of
 .IR make .
+.BR make .
 If
 .I makefile
 is `\-', the standard input is read.
 .LP
 .I make
+is '\-', the standard input is read.
+.LP
+.B make
 updates a target if it depends on prerequisite files
 that have been modified since the target was last modified,
 …
 .sp 1
 .TP 0.5i
+.BR \-b , " \-m"
+\fB\-b\fR, \fB\-m\fR
 These options are ignored for compatibility with other versions of
 .IR make .
 .TP 0.5i
+.BR \-B , " \-\-always\-make"
+.BR make .
+.TP 0.5i
+\fB\-B\fR, \fB\-\-always\-make\fR
 Unconditionally make all targets.
 .TP 0.5i
 …
 .BR "\-C " /etc.
 This is typically used with recursive invocations of
 .IR make .
+.BR make .
 .TP 0.5i
 .B \-d
 …
 which files actually need to be remade, which implicit rules are
 considered and which are applied---everything interesting about how
 .I make
+.B make
 decides what to do.
 .TP 0.5i
 …
 for details on invocation of commands, and
 .I m
+for debugging while remaking makefiles.
+.TP 0.5i
+.BR \-e , " \-\-environment\-overrides"
+for debugging while remaking makefiles.  Use
+.I n
+to disable all previous debugging flags.
+.TP 0.5i
+\fB\-e\fR, \fB\-\-environment\-overrides\fR
 Give variables taken from the environment precedence
 over variables from makefiles.
 …
 as a makefile.
 .TP 0.5i
+.BR \-i , " \-\-ignore\-errors"
+\fB\-i\fR, \fB\-\-ignore\-errors\fR
 Ignore all errors in commands executed to remake files.
 .TP 0.5i
 …
 searched in the order specified.
 Unlike the arguments to other flags of
 .IR make ,
+.BR make ,
 directories given with
 .B \-I
 …
 .BI \-I dir
 is allowed, as well as
+.BI "\-I " dir.
+.B \-I
+.IR dir .
 This syntax is allowed for compatibility with the C
 preprocessor's
 …
 .B \-j
 option is given without an argument,
 .IR make
+.BR make
 will not limit the number of jobs that can run simultaneously.
 .TP 0.5i
+.BR \-k , " \-\-keep\-going"
+\fB\-k\fR, \fB\-\-keep\-going\fR
 Continue as much as possible after an error.
 While the target that failed, and those that depend on it, cannot
 …
 With no argument, removes a previous load limit.
 .TP 0.5i
+.BR \-L , " \-\-check\-symlink\-times"
+\fB\-L\fR, \fB\-\-check\-symlink\-times\fR
 Use the latest mtime between symlinks and target.
 .TP 0.5i
+.BR \-n , " \-\-just\-print" , " \-\-dry\-run" , " \-\-recon"
+\fB\-n\fR, \fB\-\-just\-print\fR, \fB\-\-dry\-run\fR, \fB\-\-recon\fR
 Print the commands that would be executed, but do not execute them (except in
 certain circumstances).
 …
 Essentially the file is treated as very old and its rules are ignored.
 .TP 0.5i
+.BR \-p , " \-\-print\-data\-base"
+\fB\-O\fR[\fItype\fR], \fB\-\-output\-sync\fR[=\fItype\fR]
+When running multiple jobs in parallel with \fB-j\fR, ensure the output of
+each job is collected together rather than interspersed with output from
+other jobs.  If
+.I type
+is not specified or is
+.B target
+the output from the entire recipe for each target is grouped together.  If
+.I type
+is
+.B line
+the output from each command line within a recipe is grouped together.
+If
+.I type
+is
+.B recurse
+output from an entire recursive make is grouped together.  If
+.I type
+is
+.B none
+output synchronization is disabled.
+.TP 0.5i
+\fB\-p\fR, \fB\-\-print\-data\-base\fR
 Print the data base (rules and variable values) that results from
 reading the makefiles; then execute as usual or as otherwise
 …
 switch (see below).
 To print the data base without trying to remake any files, use
+.B make
+.B \-p
+.BI \-f /dev/null.
+.TP 0.5i
+.BR \-q , " \-\-question"
+.IR "make \-p \-f/dev/null" .
+.TP 0.5i
+\fB\-q\fR, \fB\-\-question\fR
 ``Question mode''.
 Do not run any commands, or print anything; just return an exit status
 …
 otherwise.
 .TP 0.5i
+.BR \-r , " \-\-no\-builtin\-rules"
+\fB\-r\fR, \fB\-\-no\-builtin\-rules\fR
 Eliminate use of the built\-in implicit rules.
 Also clear out the default list of suffixes for suffix rules.
 .TP 0.5i
+.BR \-R , " \-\-no\-builtin\-variables"
+\fB\-R\fR, \fB\-\-no\-builtin\-variables\fR
 Don't define any built\-in variables.
 .TP 0.5i
+.BR \-s , " \-\-silent" , " \-\-quiet"
+\fB\-s\fR, \fB\-\-silent\fR, \fB\-\-quiet\fR
 Silent operation; do not print the commands as they are executed.
 .TP 0.5i
+.BR \-S , " \-\-no\-keep\-going" , " \-\-stop"
+\fB\-S\fR, \fB\-\-no\-keep\-going\fR, \fB\-\-stop\fR
 Cancel the effect of the
 .B \-k
 option.
 This is never necessary except in a recursive
 .I make
+.B make
 where
 .B \-k
 might be inherited from the top-level
 .I make
+.B make
 via MAKEFLAGS or if you set
 .B \-k
 in MAKEFLAGS in your environment.
 .TP 0.5i
+.BR \-t , " \-\-touch"
+\fB\-t\fR, \fB\-\-touch\fR
 Touch files (mark them up to date without really changing them)
 instead of running their commands.
 This is used to pretend that the commands were done, in order to fool
 future invocations of
+.IR make .
+.TP 0.5i
+.BR \-v , " \-\-version"
+.BR make .
+.TP 0.5i
+.B \-\-trace
+Information about the disposition of each target is printed (why the target is
+being rebuilt and what commands are run to rebuild it).
+.TP 0.5i
+\fB\-v\fR, \fB\-\-version\fR
 Print the version of the
 .I make
+.B make
 program plus a copyright, a list of authors and a notice that there
 is no warranty.
 .TP 0.5i
+.BR \-w , " \-\-print\-directory"
+\fB\-w\fR, \fB\-\-print\-directory\fR
 Print a message containing the working directory
 before and after other processing.
 This may be useful for tracking down errors from complicated nests of
 recursive
 .I make
+.B make
 commands.
 .TP 0.5i
 …
 .I touch
 command on the given file before running
 .IR make ,
+.BR make ,
 except that the modification time is changed only in the imagination of
 .IR make .
+.BR make .
 .TP 0.5i
 .B \-\-warn\-undefined\-variables
 …
 .SH "EXIT STATUS"
 GNU
 .I make
+.B make
 exits with a status of zero if all makefiles were successfully parsed
 and no targets that were built failed.  A status of one will be returned
 …
 .B \-q
 flag was used and
 .I make
+.B make
 determines that a target needs to be rebuilt.  A status of two will be
 returned if any errors were encountered.
 .SH "SEE ALSO"
+.I "The GNU Make Manual"
+The full documentation for
+.B make
+is maintained as a Texinfo manual.  If the
+.B info
+and
+.B make
+programs are properly installed at your site, the command
+.IP
+.B info make
+.PP
+should give you access to the complete manual.
 .SH BUGS
 See the chapter `Problems and Bugs' in
+See the chapter ``Problems and Bugs'' in
 .IR "The GNU Make Manual" .
 .SH AUTHOR
 This manual page contributed by Dennis Morse of Stanford University.
+It has been reworked by Roland McGrath.  Further updates contributed by
 Mike Frysinger.
+Further updates contributed by Mike Frysinger.  It has been reworked by Roland
+McGrath.  Maintained by Paul Smith.
 .SH "COPYRIGHT"
 Copyright (C) 1992, 1993, 1996, 1999, 2007 Free Software Foundation, Inc.
 This file is part of GNU
 .IR make .
+Copyright \(co 1992-1993, 1996-2016 Free Software Foundation, Inc.
+This file is part of
+.IR "GNU make" .
 .LP
 GNU Make is free software; you can redistribute it and/or modify it under the

vendor/gnumake/current/make.lnk

r501	r3138
1		FROM LIB:cres.o "commands.o"+"job.o"+"dir.o"+"file.o"+"misc.o"+"main.o"+"read.o"+"remake.o"+"rule.o"+"implicit.o"+"default.o"+"variable.o"+"expand.o"+"function.o"+"vpath.o"+"version.o"+"ar.o"+"arscan.o"+"signame.o"+"remote-stub.o"+"getopt.o"+"getopt1.o"+"alloca.o"+"amiga.o"+"hash.o"+"strcache.o"
	1	FROM LIB:cres.o "commands.o"+"job.o"+"dir.o"+"file.o"+"misc.o"+"main.o"+"read.o"+"remake.o"+"rule.o"+"implicit.o"+"default.o"+"variable.o"+"expand.o"+"function.o"+"vpath.o"+"version.o"+"ar.o"+"arscan.o"+"signame.o"+"remote-stub.o"+"getopt.o"+"getopt1.o"+"alloca.o"+"amiga.o"+"hash.o"+"strcache.o"+"output.o"
2	2	TO "make.new"
3	3	LIB glob/glob.lib LIB:sc.lib LIB:amiga.lib

vendor/gnumake/current/make_msvc_net2003.vcproj

-              r501
+              r3138
                                 RelativePath=".\getopt1.c">
                         </File>
+                        <File
+                                RelativePath=".\guile.c">
+                        </File>
                         <File
                                 RelativePath=".\hash.c">
 …
                         <File
                                 RelativePath=".\job.c">
+                        </File>
+                        <File
+                                RelativePath=".\load.c">
+                        </File>
+                        <File
+                                RelativePath=".\output.c">
                         </File>
                         <File
 …
                                 <File
                                         RelativePath=".\w32\compat\dirent.c">
+                                </File>
+                                <File
+                                        RelativePath=".\w32\compat\posixfcn.c">
                                 </File>
                                 <File
 …
                                 </File>
                                 <File
+                                        RelativePath=".\w32\w32os.c">
+                                </File>
+                                <File
                                         RelativePath=".\w32\subproc\sub_proc.c">
                                 </File>
 …
                         </File>
                         <File
+                                RelativePath=".\gmk-default.h">
+                        </File>
+                        <File
                                 RelativePath=".\hash.h">
                         </File>
 …
                         </File>
                         <File
+                                RelativePath=".\make.h">
+                                RelativePath=".\output.h">
+                        </File>
+                        <File
+                                RelativePath=".\makeint.h">
                         </File>
                         <File

vendor/gnumake/current/makefile.com

-              r2596
+              r3138
 $! Makefile.com - builds GNU Make for VMS
 $!
+$! P1 is non-empty if you want to link with the VAXCRTL library instead
+$!    of the shareable executable
+$! P1 = LIST will provide compiler listings.
 $! P2 = DEBUG will build an image with debug information
 $! P3 = WALL will enable all warning messages (some are suppressed since
 …
 $ endif
 $!
+$!
+$ if (p1 .eqs. "LIST")
+$ then
+$   ccopt = ccopt + "/list/show=(expan,inclu)"
+$ endif
+$!
 $! Should we build a debug image
 $!
 …
 $ endif
 $ filelist = "alloca ar arscan commands default dir expand file function " + -
+             "hash implicit job main misc read remake remote-stub rule " + -
+             "signame variable version vmsfunctions vmsify vpath " + -
+             "[.glob]glob [.glob]fnmatch getopt1 getopt strcache"
+             "guile hash implicit job load main misc read remake " + -
+             "remote-stub rule output signame variable version " + -
+             "vmsfunctions vmsify vpath vms_progname vms_exit " + -
+             "vms_export_symbol [.glob]glob [.glob]fnmatch getopt1 " + -
+             "getopt strcache"
+$!
 $ copy config.h-vms config.h
 $ n=0
 …
 $ if cfile .eqs. " " then goto linkit
 $ write sys$output "Compiling ''cfile'..."
 $ call compileit 'cfile' 'p1'
+$ call compileit 'cfile'
 $ n = n + 1
 $ goto loop
 $ linkit:
 $ close optf
-$ if p1 .nes. "" then goto link_using_library
 $ link/exe=make make.opt/opt'lopt
 $ goto cleanup
+$
-$ link_using_library:
-$ link/exe=make make.opt/opt,sys$library:vaxcrtl/lib'lopt
+$
 $ cleanup:
 …
 $ compileit : subroutine
 $ ploc = f$locate("]",p1)
+$ filnam = p1
+$ if ploc .lt. f$length(p1) then filnam=f$extract(ploc+1,100,p1)
+$ write optf "''filnam'"
+$ cc'ccopt'/include=([],[.glob]) -
+  /define=("allocated_variable_expand_for_file=alloc_var_expand_for_file","unlink=remove","HAVE_CONFIG_H","VMS") -
+$! filnam = p1
+$ if ploc .lt. f$length(p1)
+$ then
+$   objdir = f$extract(0, ploc+1, p1)
+$   write optf p1
+$ else
+$   objdir := []
+$   write optf objdir+p1
+$ endif
+$ cc'ccopt'/nested=none/include=([],[.glob])/obj='objdir' -
+  /define=("allocated_variable_expand_for_file=alloc_var_expand_for_file",-
+  "unlink=remove","HAVE_CONFIG_H","VMS") -
   'p1'
 $ exit
 …
 $!
 $!-----------------------------------------------------------------------------
+$!Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+$!2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+$!Copyright (C) 1996-2016 Free Software Foundation, Inc.
 $!This file is part of GNU Make.
 $!

vendor/gnumake/current/makefile.vms

-              r2596
+              r3138
 # -*-Makefile-*- to build GNU make on VMS
+#
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+# 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+# Copyright (C) 1996-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 # Modified for version 3.78.1 by Hartmut.Becker@compaq.com.
 # Modified for version 3.80 by zinser@decus.de
 # Modified for version 3.81 by Hartmut Becker
+# Modified for versions 3.81, 3.99.90 by Hartmut Becker
 CC = cc
 …
 ifeq ($(CC),cc)
+CFLAGS = $(defines) /include=([],[.glob])/prefix=(all,except=(glob,globfree))/standard=relaxed/warn=(disable=questcompare)
+cinclude = /nested=none/include=([],[.glob])
+cprefix = /prefix=(all,except=(glob,globfree))
+cwarn = /standard=relaxed/warn=(disable=questcompare)
+CFLAGS = $(defines) $(cinclude)$(cprefix)$(cwarn)
 else
 CFLAGS = $(defines) /include=([],[.glob])
+CFLAGS = $(defines) $(cinclude)
 endif
 #LDFLAGS = /deb
 …
 glob = ,[.glob]glob.obj,[.glob]fnmatch.obj
 getopt = ,getopt.obj,getopt1.obj
 # Directory to install `make' in.
+# Directory to install 'make' in.
 bindir = []
 # Directory to install the man page in.
 …
 manext = 1
+objs = commands.obj,job.obj,dir.obj,file.obj,misc.obj,hash.obj,\
+       main.obj,read.obj,remake.obj,rule.obj,implicit.obj,\
+guile = ,guile.obj
+objs = commands.obj,job.obj,output.obj,dir.obj,file.obj,misc.obj,hash.obj,\
+       load.obj,main.obj,read.obj,remake.obj,rule.obj,implicit.obj,\
        default.obj,variable.obj,expand.obj,function.obj,strcache.obj,\
+       vpath.obj,version.obj$(ARCHIVES)$(ALLOCA)$(extras)$(getopt)$(glob)
+srcs = commands.c job.c dir.c file.c misc.c  hash.c \
+        main.c read.c remake.c rule.c implicit.c \
+       vpath.obj,version.obj,vms_progname.obj,vms_exit.obj,\
+       vms_export_symbol.obj$(guile)$(ARCHIVES)$(extras)$(getopt)$(glob)
+srcs = commands.c job.c output.c dir.c file.c misc.c guile.c hash.c \
+        load.c main.c read.c remake.c rule.c implicit.c \
         default.c variable.c expand.c function.c strcache.c \
+        vpath.c version.c vmsfunctions.c vmsify.c $(ARCHIVES_SRC) $(ALLOCASRC) \
+        commands.h dep.h filedef.h job.h make.h rule.h variable.h
+        vpath.c version.c vmsfunctions.c vmsify.c vms_progname.c vms_exit.c \
+        vms_export_symbol.c $(ARCHIVES_SRC) $(ALLOCASRC) \
+        commands.h dep.h filedef.h job.h output.h makeint.h rule.h variable.h
 …
 .PHONY: clean realclean
 clean:
         $$ purge [...]
+        -purge [...]
         -$(RM) make.exe;,*.obj;
         -$(RM) [.glob]*.obj;
+# Automatically generated dependencies.
+commands.obj: commands.c make.h dep.h commands.h filedef.h variable.h job.h
+job.obj: job.c vmsjobs.c make.h commands.h job.h filedef.h variable.h
+dir.obj: dir.c make.h
+file.obj: file.c make.h commands.h dep.h filedef.h variable.h
+misc.obj: misc.c make.h dep.h
+hash.obj: hash.c make.h hash.h
+strcache.obj: strcache.c make.h hash.h
+main.obj: main.c make.h commands.h dep.h filedef.h variable.h job.h
+read.obj: read.c make.h commands.h dep.h filedef.h variable.h
+remake.obj: remake.c make.h commands.h job.h dep.h filedef.h
+rule.obj: rule.c make.h commands.h dep.h filedef.h variable.h rule.h
+implicit.obj: implicit.c make.h rule.h dep.h filedef.h
+default.obj: default.c make.h rule.h dep.h filedef.h commands.h variable.h
+variable.obj: variable.c make.h commands.h variable.h dep.h filedef.h
+expand.obj: expand.c make.h commands.h filedef.h variable.h
+function.obj: function.c make.h variable.h dep.h commands.h job.h
+vpath.obj: vpath.c make.h filedef.h variable.h
+ar.obj: ar.c makeint.h config.h gnumake.h gettext.h filedef.h hash.h dep.h \
+     [.glob]fnmatch.h
+arscan.obj: arscan.c makeint.h config.h gnumake.h gettext.h
+commands.obj: commands.c makeint.h config.h gnumake.h gettext.h filedef.h \
+     hash.h dep.h variable.h job.h output.h commands.h
+default.obj: default.c makeint.h config.h gnumake.h gettext.h filedef.h \
+     hash.h variable.h rule.h dep.h job.h output.h commands.h
+dir.obj: dir.c makeint.h config.h gnumake.h gettext.h hash.h filedef.h \
+     dep.h [.glob]glob.h
+expand.obj: expand.c makeint.h config.h gnumake.h gettext.h filedef.h \
+     hash.h job.h output.h commands.h variable.h rule.h
+file.obj: file.c makeint.h config.h gnumake.h gettext.h filedef.h hash.h \
+     dep.h job.h output.h commands.h variable.h debug.h
+[.glob]fnmatch.obj: [.glob]fnmatch.c config.h [.glob]fnmatch.h
+function.obj: function.c makeint.h config.h gnumake.h gettext.h filedef.h \
+     hash.h variable.h dep.h job.h output.h commands.h debug.h
+getopt.obj: getopt.c config.h gettext.h getopt.h
+getopt1.obj: getopt1.c config.h getopt.h
+[.glob]glob.obj: [.glob]glob.c config.h [.glob]fnmatch.h [.glob]glob.h
+guile.obj: guile.c makeint.h config.h gnumake.h gettext.h
+hash.obj: hash.c makeint.h config.h gnumake.h gettext.h hash.h
+implicit.obj: implicit.c makeint.h config.h gnumake.h gettext.h filedef.h \
+     hash.h rule.h dep.h debug.h variable.h job.h output.h commands.h
+job.obj: job.c makeint.h config.h gnumake.h gettext.h job.h output.h debug.h \
+     filedef.h hash.h commands.h variable.h debug.h vmsjobs.c
+load.obj: load.c makeint.h config.h gnumake.h gettext.h
+main.obj: main.c makeint.h config.h gnumake.h gettext.h filedef.h hash.h \
+     dep.h variable.h job.h output.h commands.h rule.h debug.h getopt.h
+misc.obj: misc.c makeint.h config.h gnumake.h gettext.h filedef.h hash.h \
+     dep.h debug.h
+output.obj: output.c makeint.h config.h gnumake.h gettext.h job.h output.h
+read.obj: read.c makeint.h config.h gnumake.h gettext.h [.glob]glob.h \
+     filedef.h hash.h dep.h job.h output.h commands.h variable.h rule.h \
+     debug.h
+remake.obj: remake.c makeint.h config.h gnumake.h gettext.h filedef.h \
+     hash.h job.h output.h commands.h dep.h variable.h debug.h
+remote-stub.obj: remote-stub.c makeint.h config.h gnumake.h gettext.h \
+     filedef.h hash.h job.h output.h commands.h
+rule.obj: rule.c makeint.h config.h gnumake.h gettext.h filedef.h hash.h \
+     dep.h job.h output.h commands.h variable.h rule.h
+signame.obj: signame.c makeint.h config.h gnumake.h gettext.h
+strcache.obj: strcache.c makeint.h config.h gnumake.h gettext.h hash.h
+variable.obj: variable.c makeint.h config.h gnumake.h gettext.h filedef.h \
+     hash.h dep.h job.h output.h commands.h variable.h rule.h
 version.obj: version.c config.h
+arscan.obj: arscan.c
+ar.obj: ar.c make.h filedef.h
+signame.obj: signame.c
+remote-stub.obj: remote-stub.c
+[.glob]glob.obj: [.glob]glob.c
+[.glob]fnmatch.obj: [.glob]fnmatch.c
+getopt.obj: getopt.c
+getopt1.obj: getopt1.c
+vmsfunctions.obj: vmsfunctions.c make.h vmsdir.h
+vmsify.obj: vmsify.c make.h
+vmsfunctions.obj: vmsfunctions.c makeint.h config.h gnumake.h gettext.h \
+     debug.h job.h output.h vmsdir.h
+vmsify.obj: vmsify.c
+vpath.obj: vpath.c makeint.h config.h gnumake.h gettext.h filedef.h hash.h \
+     variable.h
+vms_progname.obj: vms_progname.c
+vms_exit.obj: vms_exit.c
+vms_export_symbol.obj: vms_export_symbol.c
 config.h: config.h-vms

vendor/gnumake/current/makeint.h

-              r3137
+              r3138
 /* Miscellaneous global declarations and portability cruft for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 /* We use <config.h> instead of "config.h" so that a compilation
    using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h
    (which it would do because make.h was found in $srcdir).  */
+   (which it would do because makeint.h was found in $srcdir).  */
 #include <config.h>
 #undef  HAVE_CONFIG_H
 …
 #endif
+/* Disable assert() unless we're a maintainer.
+   Some asserts are compute-intensive.  */
+#ifndef MAKE_MAINTAINER_MODE
+# define NDEBUG 1
+#endif
+/* Include the externally-visible content.
+   Be sure to use the local one, and not one installed on the system.
+   Define GMK_BUILDING_MAKE for proper selection of dllexport/dllimport
+   declarations for MS-Windows.  */
+#ifdef WINDOWS32
+# define GMK_BUILDING_MAKE
+#endif
+#include "gnumake.h"
 #ifdef  CRAY
 …
 #include <stdio.h>
 #include <ctype.h>
 #ifdef HAVE_SYS_TIMEB_H
+/* SCO 3.2 "devsys 4.2" has a prototype for `ftime' in <time.h> that bombs
+   unless <sys/timeb.h> has been included first.  Does every system have a
+   <sys/timeb.h>?  If any does not, configure should check for it.  */
+/* SCO 3.2 "devsys 4.2" has a prototype for 'ftime' in <time.h> that bombs
+   unless <sys/timeb.h> has been included first.  */
 # include <sys/timeb.h>
 #endif
 #if TIME_WITH_SYS_TIME
 # include <sys/time.h>
 …
 #endif
+#ifndef isblank
+# define isblank(c)     ((c) == ' ' || (c) == '\t')
+#ifdef __VMS
+/* In strict ANSI mode, VMS compilers should not be defining the
+   VMS macro.  Define it here instead of a bulk edit for the correct code.
+ */
+# ifndef VMS
+#  define VMS
+# endif
 #endif
 …
 # include <unistd.h>
 /* Ultrix's unistd.h always defines _POSIX_VERSION, but you only get
    POSIX.1 behavior with `cc -YPOSIX', which predefines POSIX itself!  */
+   POSIX.1 behavior with 'cc -YPOSIX', which predefines POSIX itself!  */
 # if defined (_POSIX_VERSION) && !defined (ultrix) && !defined (VMS)
 #  define POSIX 1
 …
 #ifndef HAVE_SA_RESTART
 # define SA_RESTART 0
+#endif
+#ifdef HAVE_VFORK_H
+# include <vfork.h>
 #endif
 …
 #endif
+/* Nonzero if the integer type T is signed.  */
+#define INTEGER_TYPE_SIGNED(t) ((t) -1 < 0)
+#ifndef USHRT_MAX
+# define USHRT_MAX 65535
+#endif
+/* Nonzero if the integer type T is signed.
+   Use <= to avoid GCC warnings about always-false expressions.  */
+#define INTEGER_TYPE_SIGNED(t) ((t) -1 <= 0)
 /* The minimum and maximum values for the integer type T.
 …
 #ifdef VMS
+# include <fcntl.h>
 # include <types.h>
 # include <unixlib.h>
 …
 /* Needed to use alloca on VMS.  */
 # include <builtins.h>
+extern int vms_use_mcr_command;
+extern int vms_always_use_cmd_file;
+extern int vms_gnv_shell;
+extern int vms_comma_separator;
+extern int vms_legacy_behavior;
+extern int vms_unix_simulation;
 #endif
 …
 #  define __attribute__(x)
 # endif
 /* The __-protected variants of `format' and `printf' attributes
+/* The __-protected variants of 'format' and 'printf' attributes
    are accepted by gcc versions 2.6.4 (effectively 2.7) and later.  */
 # if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
 …
 # include <inttypes.h>
 #endif
+#if HAVE_STDINT_H
+# include <stdint.h>
+#endif
 #define FILE_TIMESTAMP uintmax_t
 …
    POSIX 1003.2-1992 section 2.5.2.1 page 50 lines 1556-1558 says that
    only '0' through '9' are digits.  Prefer ISDIGIT to isdigit() unless
    it's important to use the locale's definition of `digit' even when the
+   it's important to use the locale's definition of 'digit' even when the
    host does not conform to POSIX.  */
 #define ISDIGIT(c) ((unsigned) (c) - '0' <= 9)
 …
 #define S_(msg1,msg2,num)   ngettext (msg1,msg2,num)
-/* Handle other OSs.  */
-#ifndef PATH_SEPARATOR_CHAR
-# if defined(HAVE_DOS_PATHS)
-#  define PATH_SEPARATOR_CHAR ';'
-# elif defined(VMS)
-#  define PATH_SEPARATOR_CHAR ','
-# else
-#  define PATH_SEPARATOR_CHAR ':'
-# endif
-#endif
 /* This is needed for getcwd() and chdir(), on some W32 systems.  */
 #if defined(HAVE_DIRECT_H)
 …
 # define pipe(_p)        _pipe((_p), 512, O_BINARY)
 # define kill(_pid,_sig) w32_kill((_pid),(_sig))
+/* MSVC and Watcom C don't have ftruncate.  */
+# if defined(_MSC_VER) || defined(__WATCOMC__)
+#  define ftruncate(_fd,_len) _chsize(_fd,_len)
+# endif
+/* MinGW64 doesn't have _S_ISDIR.  */
+# ifndef _S_ISDIR
+#  define _S_ISDIR(m)  S_ISDIR(m)
+# endif
 void sync_Path_environment (void);
 int w32_kill (pid_t pid, int sig);
-char *end_of_token_w32 (const char *s, char stopchar);
 int find_and_set_default_shell (const char *token);
 …
 /* is default_shell unixy? */
 extern int unixy_shell;
+/* We don't have a preferred fixed value for LOCALEDIR.  */
+# ifndef LOCALEDIR
+#  define LOCALEDIR NULL
+# endif
+/* Include only the minimal stuff from windows.h.   */
+# define WIN32_LEAN_AND_MEAN
 #endif  /* WINDOWS32 */
+#define ANY_SET(_v,_m)  (((_v)&(_m)) != 0)
+#define NONE_SET(_v,_m) (! ANY_SET ((_v),(_m)))
+#define MAP_NUL         0x0001
+#define MAP_BLANK       0x0002
+#define MAP_NEWLINE     0x0004
+#define MAP_COMMENT     0x0008
+#define MAP_SEMI        0x0010
+#define MAP_EQUALS      0x0020
+#define MAP_COLON       0x0040
+#define MAP_PERCENT     0x0080
+#define MAP_PIPE        0x0100
+#define MAP_DOT         0x0200
+#define MAP_COMMA       0x0400
+/* These are the valid characters for a user-defined function.  */
+#define MAP_USERFUNC    0x2000
+/* This means not only a '$', but skip the variable reference.  */
+#define MAP_VARIABLE    0x4000
+/* The set of characters which are directory separators is OS-specific.  */
+#define MAP_DIRSEP      0x8000
+#ifdef VMS
+# define MAP_VMSCOMMA   MAP_COMMA
+#else
+# define MAP_VMSCOMMA   0x0000
+#endif
+#define MAP_SPACE       (MAP_BLANK|MAP_NEWLINE)
+/* Handle other OSs.
+   To overcome an issue parsing paths in a DOS/Windows environment when
+   built in a unix based environment, override the PATH_SEPARATOR_CHAR
+   definition unless being built for Cygwin. */
+#if defined(HAVE_DOS_PATHS) && !defined(__CYGWIN__)
+# undef PATH_SEPARATOR_CHAR
+# define PATH_SEPARATOR_CHAR ';'
+# define MAP_PATHSEP    MAP_SEMI
+#elif !defined(PATH_SEPARATOR_CHAR)
+# if defined (VMS)
+#  define PATH_SEPARATOR_CHAR (vms_comma_separator ? ',' : ':')
+#  define MAP_PATHSEP    (vms_comma_separator ? MAP_COMMA : MAP_SEMI)
+# else
+#  define PATH_SEPARATOR_CHAR ':'
+#  define MAP_PATHSEP    MAP_COLON
+# endif
+#elif PATH_SEPARATOR_CHAR == ':'
+# define MAP_PATHSEP     MAP_COLON
+#elif PATH_SEPARATOR_CHAR == ';'
+# define MAP_PATHSEP     MAP_SEMI
+#elif PATH_SEPARATOR_CHAR == ','
+# define MAP_PATHSEP     MAP_COMMA
+#else
+# error "Unknown PATH_SEPARATOR_CHAR"
+#endif
+#define STOP_SET(_v,_m) ANY_SET(stopchar_map[(unsigned char)(_v)],(_m))
+#define ISBLANK(c)      STOP_SET((c),MAP_BLANK)
+#define ISSPACE(c)      STOP_SET((c),MAP_SPACE)
+#define NEXT_TOKEN(s)   while (ISSPACE (*(s))) ++(s)
+#define END_OF_TOKEN(s) while (! STOP_SET (*(s), MAP_SPACE|MAP_NUL)) ++(s)
 #if defined(HAVE_SYS_RESOURCE_H) && defined(HAVE_GETRLIMIT) && defined(HAVE_SETRLIMIT)
 …
 #ifdef SET_STACK_SIZE
 # include <sys/resource.h>
+struct rlimit stack_limit;
+#endif
+struct floc
+extern struct rlimit stack_limit;
+#endif
+#include <glob.h>
+#define NILF ((floc *)0)
+#define CSTRLEN(_s)           (sizeof (_s)-1)
+#define STRING_SIZE_TUPLE(_s) (_s), CSTRLEN(_s)
+/* The number of bytes needed to represent the largest integer as a string.  */
+#define INTSTR_LENGTH         CSTRLEN ("18446744073709551616")
+#define DEFAULT_TTYNAME "true"
+#ifdef HAVE_TTYNAME
+# define TTYNAME(_f) ttyname (_f)
+#else
+# define TTYNAME(_f) DEFAULT_TTYNAME
+#endif
+/* Specify the location of elements read from makefiles.  */
+typedef struct
+  {
     const char *filenm;
     unsigned long lineno;
+  };
+#define NILF ((struct floc *)0)
+#define STRING_SIZE_TUPLE(_s) (_s), (sizeof (_s)-1)
+/* We have to have stdarg.h or varargs.h AND v*printf or doprnt to use
+   variadic versions of these functions.  */
+#if HAVE_STDARG_H || HAVE_VARARGS_H
+# if HAVE_VPRINTF || HAVE_DOPRNT
+#  define USE_VARIADIC 1
+# endif
+#endif
+#if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
+    unsigned long offset;
+  } floc;
 const char *concat (unsigned int, ...);
+void message (int prefix, const char *fmt, ...)
+              __attribute__ ((__format__ (__printf__, 2, 3)));
+void error (const struct floc *flocp, const char *fmt, ...)
+            __attribute__ ((__format__ (__printf__, 2, 3)));
+void fatal (const struct floc *flocp, const char *fmt, ...)
+                   __attribute__ ((noreturn, __format__ (__printf__, 2, 3)));
+#else
+const char *concat ();
+void message ();
+void error ();
+void fatal ();
+#endif
+void message (int prefix, size_t length, const char *fmt, ...)
+              __attribute__ ((__format__ (__printf__, 3, 4)));
+void error (const floc *flocp, size_t length, const char *fmt, ...)
+            __attribute__ ((__format__ (__printf__, 3, 4)));
+void fatal (const floc *flocp, size_t length, const char *fmt, ...)
+            __attribute__ ((noreturn, __format__ (__printf__, 3, 4)));
+#define O(_t,_a,_f)           _t((_a), 0, (_f))
+#define OS(_t,_a,_f,_s)       _t((_a), strlen (_s), (_f), (_s))
+#define OSS(_t,_a,_f,_s1,_s2) _t((_a), strlen (_s1) + strlen (_s2), \
+                                 (_f), (_s1), (_s2))
+#define OSSS(_t,_a,_f,_s1,_s2,_s3) _t((_a), strlen (_s1) + strlen (_s2) + strlen (_s3), \
+                                      (_f), (_s1), (_s2), (_s3))
+#define ON(_t,_a,_f,_n)       _t((_a), INTSTR_LENGTH, (_f), (_n))
+#define ONN(_t,_a,_f,_n1,_n2) _t((_a), INTSTR_LENGTH*2, (_f), (_n1), (_n2))
+#define OSN(_t,_a,_f,_s,_n)   _t((_a), strlen (_s) + INTSTR_LENGTH, \
+                                 (_f), (_s), (_n))
+#define ONS(_t,_a,_f,_n,_s)   _t((_a), INTSTR_LENGTH + strlen (_s), \
+                                 (_f), (_n), (_s))
+#define OUT_OF_MEM() O (fatal, NILF, _("virtual memory exhausted"))
 void die (int) __attribute__ ((noreturn));
-void log_working_directory (int);
 void pfatal_with_name (const char *) __attribute__ ((noreturn));
 void perror_with_name (const char *, const char *);
+#define xstrlen(_s) ((_s)==NULL ? 0 : strlen (_s))
 void *xmalloc (unsigned int);
 void *xcalloc (unsigned int);
 …
 char *find_percent (char *);
 const char *find_percent_cached (const char **);
-FILE *open_tmpfile (char **, const char *);
 #ifndef NO_ARCHIVES
 …
 typedef long int (*ar_member_func_t) (int desc, const char *mem, int truncated,
+                                      long int hdrpos, long int datapos,
+                                      long int size, long int date, int uid,
+                                      int gid, int mode, const void *arg);
+                                      long int hdrpos, long int datapos,
+                                      long int size, long int date, int uid,
+                                      int gid, unsigned int mode,
+                                      const void *arg);
 long int ar_scan (const char *archive, ar_member_func_t function, const void *arg);
 …
 void file_impossible (const char *);
 const char *dir_name (const char *);
+void print_dir_data_base (void);
+void dir_setup_glob (glob_t *);
 void hash_init_directories (void);
 void define_default_variables (void);
+void undefine_default_variables (void);
 void set_default_suffixes (void);
 void install_default_suffix_rules (void);
 …
 void child_access (void);
-void close_stdout (void);
 char *strip_whitespace (const char **begpp, const char **endpp);
+void show_goal_error (void);
 /* String caching  */
 …
 int strcache_iscached (const char *str);
 const char *strcache_add (const char *str);
+const char *strcache_add_len (const char *str, int len);
+int strcache_setbufsize (int size);
+#ifdef  HAVE_VFORK_H
+# include <vfork.h>
+#endif
+const char *strcache_add_len (const char *str, unsigned int len);
+/* Guile support  */
+int guile_gmake_setup (const floc *flocp);
+/* Loadable object support.  Sets to the strcached name of the loaded file.  */
+typedef int (*load_func_t)(const floc *flocp);
+int load_file (const floc *flocp, const char **filename, int noerror);
+void unload_file (const char *name);
 /* We omit these declarations on non-POSIX systems which define _POSIX_VERSION,
 …
 # endif
+# ifdef  HAVE_GETCWD
+#  if !defined(VMS) && !defined(__DECC)
+char *getcwd ();
+#  endif
+# else
+char *getwd ();
+#  define getcwd(buf, len)       getwd (buf)
+# endif
 #endif  /* Not GNU C library or POSIX.  */
-#ifdef  HAVE_GETCWD
-# if !defined(VMS) && !defined(__DECC)
-char *getcwd ();
-# endif
-#else
-char *getwd ();
-# define getcwd(buf, len)       getwd (buf)
-#endif
 #if !HAVE_STRCASECMP
 …
 #endif
+extern const struct floc *reading_file;
+extern const struct floc **expanding_var;
+#define OUTPUT_SYNC_NONE    0
+#define OUTPUT_SYNC_LINE    1
+#define OUTPUT_SYNC_TARGET  2
+#define OUTPUT_SYNC_RECURSE 3
+/* Non-GNU systems may not declare this in unistd.h.  */
 extern char **environ;
+extern const floc *reading_file;
+extern const floc **expanding_var;
+extern unsigned short stopchar_map[];
 extern int just_print_flag, silent_flag, ignore_errors_flag, keep_going_flag;
 …
 extern int env_overrides, no_builtin_rules_flag, no_builtin_variables_flag;
 extern int print_version_flag, print_directory_flag, check_symlink_flag;
+extern int warn_undefined_variables_flag, posix_pedantic, not_parallel;
+extern int second_expansion, clock_skew_detected, rebuilding_makefiles;
+extern int one_shell;
+extern int warn_undefined_variables_flag, trace_flag, posix_pedantic;
+extern int not_parallel, second_expansion, clock_skew_detected;
+extern int rebuilding_makefiles, one_shell, output_sync, verify_flag;
+extern const char *default_shell;
 /* can we run commands via 'sh -c xxx' or must we use batch files? */
 …
 extern unsigned int job_slots;
-extern int job_fds[2];
-extern int job_rfd;
 #ifndef NO_FLOAT
 extern double max_load_average;
 …
 #endif
+#ifdef WINDOWS32
 extern char *program;
+#else
+extern const char *program;
+#endif
+#ifdef VMS
+const char *vms_command (const char *argv0);
+const char *vms_progname (const char *argv0);
+void vms_exit (int);
+# define _exit(foo) vms_exit(foo)
+# define exit(foo) vms_exit(foo)
+extern char *program_name;
+void
+set_program_name (const char *arv0);
+int
+need_vms_symbol (void);
+int
+create_foreign_command (const char *command, const char *image);
+int
+vms_export_dcl_symbol (const char *name, const char *value);
+int
+vms_putenv_symbol (const char *string);
+void
+vms_restore_symbol (const char *string);
+#endif
+void remote_setup (void);
+void remote_cleanup (void);
+int start_remote_job_p (int);
+int start_remote_job (char **, char **, int, int *, int *, int *);
+int remote_status (int *, int *, int *, int);
+void block_remote_children (void);
+void unblock_remote_children (void);
+int remote_kill (int id, int sig);
+void print_variable_data_base (void);
+void print_vpath_data_base (void);
 extern char *starting_directory;
 extern unsigned int makelevel;
 …
 #endif
+#ifdef VMS
+#  define MAKE_SUCCESS 1
+#  define MAKE_TROUBLE 2
+#  define MAKE_FAILURE 3
+#else
+#  define MAKE_SUCCESS 0
+#  define MAKE_TROUBLE 1
+#  define MAKE_FAILURE 2
+#endif
+#define MAKE_SUCCESS 0
+#define MAKE_TROUBLE 1
+#define MAKE_FAILURE 2
 /* Set up heap debugging library dmalloc.  */

vendor/gnumake/current/misc.c

-              r2596
+              r3138
 /* Miscellaneous generic support functions for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
+#include "make.h"
+#include "makeint.h"
+#include "filedef.h"
 #include "dep.h"
 #include "debug.h"
+/* Variadic functions.  We go through contortions to allow proper function
+   prototypes for both ANSI and pre-ANSI C compilers, and also for those
+   which support stdarg.h vs. varargs.h, and finally those which have
+   vfprintf(), etc. and those who have _doprnt... or nothing.
+   This fancy stuff all came from GNU fileutils, except for the VA_PRINTF and
+   VA_END macros used here since we have multiple print functions.  */
+#if USE_VARIADIC
+# if HAVE_STDARG_H
+#  include <stdarg.h>
+#  define VA_START(args, lastarg) va_start(args, lastarg)
+# else
+#  include <varargs.h>
+#  define VA_START(args, lastarg) va_start(args)
+# endif
+# if HAVE_VPRINTF
+#  define VA_PRINTF(fp, lastarg, args) vfprintf((fp), (lastarg), (args))
+# else
+#  define VA_PRINTF(fp, lastarg, args) _doprnt((lastarg), (args), (fp))
+# endif
+# define VA_END(args) va_end(args)
+#else
+/* We can't use any variadic interface! */
+# define va_alist a1, a2, a3, a4, a5, a6, a7, a8
+# define va_dcl char *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8;
+# define VA_START(args, lastarg)
+# define VA_PRINTF(fp, lastarg, args) fprintf((fp), (lastarg), va_alist)
+# define VA_END(args)
+#endif
+/* GNU make no longer supports pre-ANSI89 environments.  */
+#include <stdarg.h>
+#ifdef HAVE_FCNTL_H
+# include <fcntl.h>
+#else
+# include <sys/file.h>
+#endif
 /* Compare strings *S1 and *S2.
 …
 collapse_continuations (char *line)
+{
+  register char *in, *out, *p;
+  register int backslash;
+  register unsigned int bs_write;
+  char *in, *out, *p;
   in = strchr (line, '\n');
 …
+    {
       /* BS_WRITE gets the number of quoted backslashes at
          the end just before IN, and BACKSLASH gets nonzero
          if the next character is quoted.  */
       backslash = 0;
       bs_write = 0;
+         the end just before IN, and BACKSLASH gets nonzero
+         if the next character is quoted.  */
+      unsigned int backslash = 0;
+      unsigned int bs_write = 0;
       for (p = in - 1; p >= line && *p == '\\'; --p)
+        {
           if (backslash)
             ++bs_write;
           backslash = !backslash;
           /* It should be impossible to go back this far without exiting,
              but if we do, we can't get the right answer.  */
           if (in == out - 1)
             abort ();
+        }
+        {
+          if (backslash)
+            ++bs_write;
+          backslash = !backslash;
+          /* It should be impossible to go back this far without exiting,
+             but if we do, we can't get the right answer.  */
+          if (in == out - 1)
+            abort ();
+        }
       /* Output the appropriate number of backslashes.  */
       while (bs_write-- > 0)
         *out++ = '\\';
+        *out++ = '\\';
       /* Skip the newline.  */
       ++in;
-      /* If the newline is escaped, discard following whitespace leaving just
-         one space.  POSIX requires that each backslash/newline/following
-         whitespace sequence be reduced to a single space.  */
       if (backslash)
+        {
+          in = next_token (in);
+          /* Removing this loop will fix Savannah bug #16670: do we want to? */
+          while (out > line && isblank ((unsigned char)out[-1]))
+            --out;
+          *out++ = ' ';
+        }
+        {
+          /* Backslash/newline handling:
+             In traditional GNU make all trailing whitespace, consecutive
+             backslash/newlines, and any leading non-newline whitespace on the
+             next line is reduced to a single space.
+             In POSIX, each backslash/newline and is replaced by a space.  */
+          while (ISBLANK (*in))
+            ++in;
+          if (! posix_pedantic)
+            while (out > line && ISBLANK (out[-1]))
+              --out;
+          *out++ = ' ';
+        }
       else
         /* If the newline isn't quoted, put it in the output.  */
         *out++ = '\n';
+        /* If the newline isn't quoted, put it in the output.  */
+        *out++ = '\n';
       /* Now copy the following line to the output.
          Stop when we find backslashes followed by a newline.  */
+         Stop when we find backslashes followed by a newline.  */
       while (*in != '\0')
         if (*in == '\\')
+          {
             p = in + 1;
             while (*p == '\\')
               ++p;
             if (*p == '\n')
+              {
                 in = p;
                 break;
+              }
             while (in < p)
               *out++ = *in++;
+          }
         else
           *out++ = *in++;
+        if (*in == '\\')
+          {
+            p = in + 1;
+            while (*p == '\\')
+              ++p;
+            if (*p == '\n')
+              {
+                in = p;
+                break;
+              }
+            while (in < p)
+              *out++ = *in++;
+          }
+        else
+          *out++ = *in++;
+    }
 …
 const char *
-#if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
 concat (unsigned int num, ...)
-#else
-concat (num, va_alist)
-     unsigned int num;
-     va_dcl
-#endif
+{
   static unsigned int rlen = 0;
   static char *result = NULL;
+  int ri = 0;
+#if USE_VARIADIC
+  unsigned int ri = 0;
   va_list args;
+#endif
+  VA_START (args, num);
+  va_start (args, num);
   while (num-- > 0)
+    {
       const char *s = va_arg (args, const char *);
       unsigned int l = s ? strlen (s) : 0;
+      unsigned int l = xstrlen (s);
       if (l == 0)
 …
+    }
   VA_END (args);
+  va_end (args);
   /* Get some more memory if we don't have enough space for the
 …
-/* Print a message on stdout.  */
-void
-#if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
-message (int prefix, const char *fmt, ...)
-#else
-message (prefix, fmt, va_alist)
-     int prefix;
-     const char *fmt;
-     va_dcl
-#endif
+{
-#if USE_VARIADIC
-  va_list args;
-#endif
-  log_working_directory (1);
-  if (fmt != 0)
+    {
-      if (prefix)
+        {
-          if (makelevel == 0)
-            printf ("%s: ", program);
-          else
-            printf ("%s[%u]: ", program, makelevel);
+        }
-      VA_START (args, fmt);
-      VA_PRINTF (stdout, fmt, args);
-      VA_END (args);
-      putchar ('\n');
+    }
-  fflush (stdout);
+}
-/* Print an error message.  */
-void
-#if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
-error (const struct floc *flocp, const char *fmt, ...)
-#else
-error (flocp, fmt, va_alist)
-     const struct floc *flocp;
-     const char *fmt;
-     va_dcl
-#endif
+{
-#if USE_VARIADIC
-  va_list args;
-#endif
-  log_working_directory (1);
-  if (flocp && flocp->filenm)
-    fprintf (stderr, "%s:%lu: ", flocp->filenm, flocp->lineno);
-  else if (makelevel == 0)
-    fprintf (stderr, "%s: ", program);
-  else
-    fprintf (stderr, "%s[%u]: ", program, makelevel);
-  VA_START(args, fmt);
-  VA_PRINTF (stderr, fmt, args);
-  VA_END (args);
-  putc ('\n', stderr);
-  fflush (stderr);
+}
-/* Print an error message and exit.  */
-void
-#if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
-fatal (const struct floc *flocp, const char *fmt, ...)
-#else
-fatal (flocp, fmt, va_alist)
-     const struct floc *flocp;
-     const char *fmt;
-     va_dcl
-#endif
+{
-#if USE_VARIADIC
-  va_list args;
-#endif
-  log_working_directory (1);
-  if (flocp && flocp->filenm)
-    fprintf (stderr, "%s:%lu: *** ", flocp->filenm, flocp->lineno);
-  else if (makelevel == 0)
-    fprintf (stderr, "%s: *** ", program);
-  else
-    fprintf (stderr, "%s[%u]: *** ", program, makelevel);
-  VA_START(args, fmt);
-  VA_PRINTF (stderr, fmt, args);
-  VA_END (args);
-  fputs (_(".  Stop.\n"), stderr);
-  die (2);
+}
 #ifndef HAVE_STRERROR
+#undef  strerror
+#undef  strerror
 char *
 strerror (int errnum)
 …
+}
 #endif
-/* Print an error message from errno.  */
-void
-perror_with_name (const char *str, const char *name)
+{
-  error (NILF, _("%s%s: %s"), str, name, strerror (errno));
+}
-/* Print an error message from errno and exit.  */
-void
-pfatal_with_name (const char *name)
+{
-  fatal (NILF, _("%s: %s"), name, strerror (errno));
-  /* NOTREACHED */
+}
 …
   void *result = malloc (size ? size : 1);
   if (result == 0)
     fatal (NILF, _("virtual memory exhausted"));
+    OUT_OF_MEM();
   return result;
+}
 …
   void *result = calloc (size ? size : 1, 1);
   if (result == 0)
     fatal (NILF, _("virtual memory exhausted"));
+    OUT_OF_MEM();
   return result;
+}
 …
   result = ptr ? realloc (ptr, size) : malloc (size);
   if (result == 0)
     fatal (NILF, _("virtual memory exhausted"));
+    OUT_OF_MEM();
   return result;
+}
 …
   if (result == 0)
     fatal (NILF, _("virtual memory exhausted"));
+    OUT_OF_MEM();
 #ifdef HAVE_STRDUP
 …
   result = strndup (str, length);
   if (result == 0)
     fatal (NILF, _("virtual memory exhausted"));
+    OUT_OF_MEM();
 #else
   result = xmalloc (length + 1);
 …
 end_of_token (const char *s)
+{
+  while (*s != '\0' && !isblank ((unsigned char)*s))
+    ++s;
+  END_OF_TOKEN (s);
   return (char *)s;
+}
-#ifdef WINDOWS32
-/*
- * Same as end_of_token, but take into account a stop character
- */
-char *
-end_of_token_w32 (const char *s, char stopchar)
+{
-  const char *p = s;
-  int backslash = 0;
-  while (*p != '\0' && *p != stopchar
-         && (backslash || !isblank ((unsigned char)*p)))
+    {
-      if (*p++ == '\\')
+        {
-          backslash = !backslash;
-          while (*p == '\\')
+            {
-              backslash = !backslash;
-              ++p;
+            }
+        }
-      else
-        backslash = 0;
+    }
-  return (char *)p;
+}
-#endif
 /* Return the address of the first nonwhitespace or null in the string S.  */
 …
 next_token (const char *s)
+{
+  while (isblank ((unsigned char)*s))
+    ++s;
+  NEXT_TOKEN (s);
   return (char *)s;
+}
 …
 /* Copy a chain of `struct dep'.  For 2nd expansion deps, dup the name.  */
+/* Copy a chain of 'struct dep'.  For 2nd expansion deps, dup the name.  */
 struct dep *
 …
       c->next = 0;
       if (firstnew == 0)
         firstnew = lastnew = c;
+        firstnew = lastnew = c;
       else
         lastnew = lastnew->next = c;
+        lastnew = lastnew->next = c;
       d = d->next;
 …
   return firstnew;
+}
-/* Free a chain of 'struct dep'.  */
-void
-free_dep_chain (struct dep *d)
+{
-  while (d != 0)
+    {
-      struct dep *df = d;
-      d = d->next;
-      free_dep (df);
+    }
+}
 …
       struct nameseq *t = ns;
       ns = ns->next;
       free (t);
+      free_ns (t);
+    }
+}
 …
 #if !HAVE_STRCASECMP && !HAVE_STRICMP && !HAVE_STRCMPI
 /* If we don't have strcasecmp() (from POSIX), or anything that can substitute
    for it, define our own version.  */
 …
 #if !HAVE_STRNCASECMP && !HAVE_STRNICMP && !HAVE_STRNCMPI
 /* If we don't have strncasecmp() (from POSIX), or anything that can
    substitute for it, define our own version.  */
 …
 #ifdef  GETLOADAVG_PRIVILEGED
+#ifdef  GETLOADAVG_PRIVILEGED
 #ifdef POSIX
 …
 #undef HAVE_SETREGID
 #else   /* Not POSIX.  */
+#else   /* Not POSIX.  */
 /* Some POSIX.1 systems have the seteuid and setegid functions.  In a
 …
 #undef HAVE_SETEGID
 #endif  /* POSIX.  */
 #ifndef HAVE_UNISTD_H
+#endif  /* POSIX.  */
+#ifndef HAVE_UNISTD_H
 extern int getuid (), getgid (), geteuid (), getegid ();
 extern int setuid (), setgid ();
 …
 extern int seteuid ();
 #else
 #ifdef  HAVE_SETREUID
+#ifdef  HAVE_SETREUID
 extern int setreuid ();
 #endif  /* Have setreuid.  */
 #endif  /* Have seteuid.  */
+#endif  /* Have setreuid.  */
+#endif  /* Have seteuid.  */
 #ifdef HAVE_SETEGID
 extern int setegid ();
 #else
 #ifdef  HAVE_SETREGID
+#ifdef  HAVE_SETREGID
 extern int setregid ();
 #endif  /* Have setregid.  */
 #endif  /* Have setegid.  */
 #endif  /* No <unistd.h>.  */
+#endif  /* Have setregid.  */
+#endif  /* Have setegid.  */
+#endif  /* No <unistd.h>.  */
 /* Keep track of the user and group IDs for user- and make- access.  */
 static int user_uid = -1, user_gid = -1, make_uid = -1, make_gid = -1;
 #define access_inited   (user_uid != -1)
+#define access_inited   (user_uid != -1)
 static enum { make, user } current_access;
 …
   fprintf (stderr, _("%s: user %lu (real %lu), group %lu (real %lu)\n"),
            flavor, (unsigned long) geteuid (), (unsigned long) getuid (),
+           flavor, (unsigned long) geteuid (), (unsigned long) getuid (),
            (unsigned long) getegid (), (unsigned long) getgid ());
   fflush (stderr);
 …
+}
 #endif  /* GETLOADAVG_PRIVILEGED */
+#endif  /* GETLOADAVG_PRIVILEGED */
 /* Give the process appropriate permissions for access to
 …
 user_access (void)
+{
 #ifdef  GETLOADAVG_PRIVILEGED
+#ifdef  GETLOADAVG_PRIVILEGED
   if (!access_inited)
 …
      which are the IDs of the process that exec'd make.  */
 #ifdef  HAVE_SETEUID
+#ifdef  HAVE_SETEUID
   /* Modern systems have the seteuid/setegid calls which set only the
 …
     pfatal_with_name ("user_access: seteuid");
 #else   /* Not HAVE_SETEUID.  */
 #ifndef HAVE_SETREUID
+#else   /* Not HAVE_SETEUID.  */
+#ifndef HAVE_SETREUID
   /* System V has only the setuid/setgid calls to set user/group IDs.
 …
     pfatal_with_name ("user_access: setuid");
 #else   /* HAVE_SETREUID.  */
+#else   /* HAVE_SETREUID.  */
   /* In 4BSD, the setreuid/setregid calls set both the real and effective IDs.
 …
     pfatal_with_name ("user_access: setreuid");
 #endif  /* Not HAVE_SETREUID.  */
 #endif  /* HAVE_SETEUID.  */
 #ifdef  HAVE_SETEGID
+#endif  /* Not HAVE_SETREUID.  */
+#endif  /* HAVE_SETEUID.  */
+#ifdef  HAVE_SETEGID
   if (setegid (user_gid) < 0)
     pfatal_with_name ("user_access: setegid");
 #else
 #ifndef HAVE_SETREGID
+#ifndef HAVE_SETREGID
   if (setgid (user_gid) < 0)
     pfatal_with_name ("user_access: setgid");
 …
   log_access (_("User access"));
 #endif  /* GETLOADAVG_PRIVILEGED */
+#endif  /* GETLOADAVG_PRIVILEGED */
+}
 …
 make_access (void)
+{
 #ifdef  GETLOADAVG_PRIVILEGED
+#ifdef  GETLOADAVG_PRIVILEGED
   if (!access_inited)
 …
   /* See comments in user_access, above.  */
 #ifdef  HAVE_SETEUID
+#ifdef  HAVE_SETEUID
   if (seteuid (make_uid) < 0)
     pfatal_with_name ("make_access: seteuid");
 #else
 #ifndef HAVE_SETREUID
+#ifndef HAVE_SETREUID
   if (setuid (make_uid) < 0)
     pfatal_with_name ("make_access: setuid");
 …
 #endif
 #ifdef  HAVE_SETEGID
+#ifdef  HAVE_SETEGID
   if (setegid (make_gid) < 0)
     pfatal_with_name ("make_access: setegid");
 #else
 #ifndef HAVE_SETREGID
+#ifndef HAVE_SETREGID
   if (setgid (make_gid) < 0)
     pfatal_with_name ("make_access: setgid");
 …
   log_access (_("Make access"));
 #endif  /* GETLOADAVG_PRIVILEGED */
+#endif  /* GETLOADAVG_PRIVILEGED */
+}
 …
 child_access (void)
+{
 #ifdef  GETLOADAVG_PRIVILEGED
+#ifdef  GETLOADAVG_PRIVILEGED
   if (!access_inited)
 …
      They cannot be changed back to make's.  */
 #ifndef HAVE_SETREUID
+#ifndef HAVE_SETREUID
   if (setuid (user_uid) < 0)
     pfatal_with_name ("child_access: setuid");
 …
 #endif
 #ifndef HAVE_SETREGID
+#ifndef HAVE_SETREGID
   if (setgid (user_gid) < 0)
     pfatal_with_name ("child_access: setgid");
 …
   log_access (_("Child access"));
+#endif  /* GETLOADAVG_PRIVILEGED */
+}
+#endif  /* GETLOADAVG_PRIVILEGED */
+}
 #ifdef NEED_GET_PATH_MAX
 …
       long int x = pathconf ("/", _PC_PATH_MAX);
       if (x > 0)
         value = x;
+        value = x;
       else
         return MAXPATHLEN;
+        return MAXPATHLEN;
+    }
 …
+}
 #endif
-/* This code is stolen from gnulib.
-   If/when we abandon the requirement to work with K&R compilers, we can
-   remove this (and perhaps other parts of GNU make!) and migrate to using
-   gnulib directly.
-   This is called only through atexit(), which means die() has already been
-   invoked.  So, call exit() here directly.  Apparently that works...?
-*/
-/* Close standard output, exiting with status 'exit_failure' on failure.
-   If a program writes *anything* to stdout, that program should close
-   stdout and make sure that it succeeds before exiting.  Otherwise,
-   suppose that you go to the extreme of checking the return status
-   of every function that does an explicit write to stdout.  The last
-   printf can succeed in writing to the internal stream buffer, and yet
-   the fclose(stdout) could still fail (due e.g., to a disk full error)
-   when it tries to write out that buffered data.  Thus, you would be
-   left with an incomplete output file and the offending program would
-   exit successfully.  Even calling fflush is not always sufficient,
-   since some file systems (NFS and CODA) buffer written/flushed data
-   until an actual close call.
-   Besides, it's wasteful to check the return value from every call
-   that writes to stdout -- just let the internal stream state record
-   the failure.  That's what the ferror test is checking below.
-   It's important to detect such failures and exit nonzero because many
-   tools (most notably `make' and other build-management systems) depend
-   on being able to detect failure in other tools via their exit status.  */
-void
-close_stdout (void)
+{
-  int prev_fail = ferror (stdout);
-  int fclose_fail = fclose (stdout);
-  if (prev_fail || fclose_fail)
+    {
-      if (fclose_fail)
-        error (NILF, _("write error: %s"), strerror (errno));
-      else
-        error (NILF, _("write error"));
-      exit (EXIT_FAILURE);
+    }
+}

vendor/gnumake/current/po/LINGUAS

-              r2596
+              r3138
 # Set of available languages: 24 languages
+# Set of available languages: 25 languages
 be da de es fi fr ga gl he hr id it ja ko lt nl pl pt_BR ru sv tr uk vi zh_CN
+be cs da de es fi fr ga gl he hr id it ja ko lt nl pl pt_BR ru sv tr uk vi zh_CN
 # Can't seem to get en@quot and en@boldquot to build properly?

vendor/gnumake/current/po/Makevars

r2596	r3138
1	1	# This is a --Makefile--
2		# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free
3		# Software Foundation, Inc.
	2	# Copyright (C) 2002-2016 Free Software Foundation, Inc.
4	3	# This file is part of GNU Make.
5	4	#

vendor/gnumake/current/po/POTFILES.in

-              r2596
+              r3138
 # List of source files containing translatable strings.
+# Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+# 2010 Free Software Foundation, Inc.
+# Copyright (C) 2000-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 function.c
 getopt.c
+guile.c
 hash.c
 implicit.c
 job.c
+job.h
+load.c
 main.c
 misc.c
+output.c
+posixos.c
 read.c
 remake.c
 …
 vmsjobs.c
 vpath.c
+w32/w32os.c

vendor/gnumake/current/prepare_w32.bat

r1991	r3138
1	1	@echo off
2		@echo Windows32 ~~CVS~~ build preparation of config.h.W32 and NMakefile.
	2	@echo Windows32 SCM build preparation of config.h.W32 and NMakefile.
3	3	if not exist config.h.W32 copy config.h.W32.template config.h.W32
4	4	if not exist config.h copy config.h.W32 config.h

vendor/gnumake/current/read.c

-              r2596
+              r3138
 /* Reading and parsing of makefiles for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include <assert.h>
+#include <glob.h>
+#include "filedef.h"
 #include "dep.h"
-#include "filedef.h"
 #include "job.h"
 #include "commands.h"
 …
+#ifndef WINDOWS32
+#ifdef WINDOWS32
+#include <windows.h>
+#include "sub_proc.h"
+#else  /* !WINDOWS32 */
 #ifndef _AMIGA
 #ifndef VMS
 …
     unsigned int size;  /* Malloc'd size of buffer. */
     FILE *fp;           /* File, or NULL if this is an internal buffer.  */
     struct floc floc;   /* Info on the file in fp (if any).  */
+    floc floc;          /* Info on the file in fp (if any).  */
   };
 …
 /* A `struct conditionals' contains the information describing
+/* A 'struct conditionals' contains the information describing
    all the active conditionals in a makefile.
    The global variable `conditionals' contains the conditionals
+   The global variable 'conditionals' contains the conditionals
    information for the current makefile.  It is initialized from
    the static structure `toplevel_conditionals' and is later changed
+   the static structure 'toplevel_conditionals' and is later changed
    to new structures for included makefiles.  */
 struct conditionals
+  {
     unsigned int if_cmds;       /* Depth of conditional nesting.  */
     unsigned int allocated;     /* Elts allocated in following arrays.  */
     char *ignoring;             /* Are we ignoring or interpreting?
+    unsigned int if_cmds;       /* Depth of conditional nesting.  */
+    unsigned int allocated;     /* Elts allocated in following arrays.  */
+    char *ignoring;             /* Are we ignoring or interpreting?
 =interpreting, 1=not yet interpreted,
 =already interpreted */
     char *seen_else;            /* Have we already seen an `else'?  */
+    char *seen_else;            /* Have we already seen an 'else'?  */
   };
 …
    makefile currently being read in.  */
 const struct floc *reading_file = 0;
 /* The chain of makefiles read by read_makefile.  */
 static struct dep *read_makefiles = 0;
 static int eval_makefile (const char *filename, int flags);
+const floc *reading_file = 0;
+/* The chain of files read by read_all_makefiles.  */
+static struct goaldep *read_files = 0;
+static struct goaldep *eval_makefile (const char *filename, int flags);
 static void eval (struct ebuffer *buffer, int flags);
 …
 static struct variable *do_define (char *name, enum variable_origin origin,
                                    struct ebuffer *ebuf);
 static int conditional_line (char *line, int len, const struct floc *flocp);
+static int conditional_line (char *line, int len, const floc *flocp);
 static void record_files (struct nameseq *filenames, const char *pattern,
                           const char *pattern_percent, char *depstr,
                           unsigned int cmds_started, char *commands,
                           unsigned int commands_idx, int two_colon,
                           const struct floc *flocp);
+                          char prefix, const floc *flocp);
 static void record_target_var (struct nameseq *filenames, char *defn,
                                enum variable_origin origin,
                                struct vmodifiers *vmod,
                                const struct floc *flocp);
+                               const floc *flocp);
 static enum make_word_type get_next_mword (char *buffer, char *delim,
                                            char **startp, unsigned int *length);
 static void remove_comments (char *line);
 static char *find_char_unquote (char *string, int stop1, int stop2,
                                 int blank, int ignorevars);
+static char *find_char_unquote (char *string, int map);
+static char *unescape_char (char *string, int c);
 …
    P must point to the word to be tested, and WLEN must be the length.
 */
 #define word1eq(s)      (wlen == sizeof(s)-1 && strneq (s, p, sizeof(s)-1))
 /* Read in all the makefiles and return the chain of their names.  */
 struct dep *
+#define word1eq(s)      (wlen == CSTRLEN (s) && strneq (s, p, CSTRLEN (s)))
+/* Read in all the makefiles and return a chain of targets to rebuild.  */
+struct goaldep *
 read_all_makefiles (const char **makefiles)
+{
 …
     while ((name = find_next_token ((const char **)&p, &length)) != 0)
+      {
         if (*p != '\0')
           *p++ = '\0';
         eval_makefile (name, RM_NO_DEFAULT_GOAL|RM_INCLUDED|RM_DONTCARE);
+        if (*p != '\0')
+          *p++ = '\0';
+        eval_makefile (name, RM_NO_DEFAULT_GOAL|RM_INCLUDED|RM_DONTCARE);
+      }
 …
     while (*makefiles != 0)
+      {
+        struct dep *tail = read_makefiles;
+        register struct dep *d;
+        if (! eval_makefile (*makefiles, 0))
+          perror_with_name ("", *makefiles);
+        /* Find the right element of read_makefiles.  */
+        d = read_makefiles;
+        while (d->next != tail)
+          d = d->next;
+        /* Use the storage read_makefile allocates.  */
+        *makefiles = dep_name (d);
+        ++num_makefiles;
+        ++makefiles;
+        struct goaldep *d = eval_makefile (*makefiles, 0);
+        if (errno)
+          perror_with_name ("", *makefiles);
+        /* Reuse the storage allocated for the read_file.  */
+        *makefiles = dep_name (d);
+        ++num_makefiles;
+        ++makefiles;
+      }
 …
   if (num_makefiles == 0)
+    {
       static char *default_makefiles[] =
+      static const char *default_makefiles[] =
 #ifdef VMS
+        /* all lower case since readdir() (the vms version) 'lowercasifies' */
+        { "makefile.vms", "gnumakefile.", "makefile.", 0 };
+        /* all lower case since readdir() (the vms version) 'lowercasifies' */
+        /* TODO: Above is not always true, this needs more work */
+        { "makefile.vms", "gnumakefile", "makefile", 0 };
 #else
 #ifdef _AMIGA
         { "GNUmakefile", "Makefile", "SMakefile", 0 };
+        { "GNUmakefile", "Makefile", "SMakefile", 0 };
 #else /* !Amiga && !VMS */
+        { "GNUmakefile", "makefile", "Makefile", 0 };
+#ifdef WINDOWS32
+        { "GNUmakefile", "makefile", "Makefile", "makefile.mak", 0 };
+#else /* !Amiga && !VMS && !WINDOWS32 */
+        { "GNUmakefile", "makefile", "Makefile", 0 };
+#endif /* !Amiga && !VMS && !WINDOWS32 */
 #endif /* AMIGA */
 #endif /* VMS */
       register char **p = default_makefiles;
+      const char **p = default_makefiles;
       while (*p != 0 && !file_exists_p (*p))
         ++p;
+        ++p;
       if (*p != 0)
+        {
+          if (! eval_makefile (*p, 0))
+            perror_with_name ("", *p);
+        }
+        {
+          eval_makefile (*p, 0);
+          if (errno)
+            perror_with_name ("", *p);
+        }
       else
+        {
+          /* No default makefile was found.  Add the default makefiles to the
+             `read_makefiles' chain so they will be updated if possible.  */
+          struct dep *tail = read_makefiles;
+          /* Add them to the tail, after any MAKEFILES variable makefiles.  */
+          while (tail != 0 && tail->next != 0)
+            tail = tail->next;
+          for (p = default_makefiles; *p != 0; ++p)
+            {
+              struct dep *d = alloc_dep ();
+              d->file = enter_file (strcache_add (*p));
+              d->dontcare = 1;
+              /* Tell update_goal_chain to bail out as soon as this file is
+                 made, and main not to die if we can't make this file.  */
+              d->changed = RM_DONTCARE;
+              if (tail == 0)
+                read_makefiles = d;
+              else
+                tail->next = d;
+              tail = d;
+            }
+          if (tail != 0)
+            tail->next = 0;
+        }
+    }
+  return read_makefiles;
+        {
+          /* No default makefile was found.  Add the default makefiles to the
+             'read_files' chain so they will be updated if possible.  */
+          struct goaldep *tail = read_files;
+          /* Add them to the tail, after any MAKEFILES variable makefiles.  */
+          while (tail != 0 && tail->next != 0)
+            tail = tail->next;
+          for (p = default_makefiles; *p != 0; ++p)
+            {
+              struct goaldep *d = alloc_goaldep ();
+              d->file = enter_file (strcache_add (*p));
+              /* Tell update_goal_chain to bail out as soon as this file is
+                 made, and main not to die if we can't make this file.  */
+              d->flags = RM_DONTCARE;
+              if (tail == 0)
+                read_files = d;
+              else
+                tail->next = d;
+              tail = d;
+            }
+          if (tail != 0)
+            tail->next = 0;
+        }
+    }
+  return read_files;
+}
 …
+{
   /* Free any space allocated by conditional_line.  */
+  if (conditionals->ignoring)
+    free (conditionals->ignoring);
+  if (conditionals->seen_else)
+    free (conditionals->seen_else);
+  free (conditionals->ignoring);
+  free (conditionals->seen_else);
   /* Restore state.  */
 …
 static int
+static struct goaldep *
 eval_makefile (const char *filename, int flags)
+{
   struct dep *deps;
+  struct goaldep *deps;
   struct ebuffer ebuf;
   const struct floc *curfile;
+  const floc *curfile;
   char *expanded = 0;
   int makefile_errno;
+  filename = strcache_add (filename);
+  ebuf.floc.filenm = filename;
+  ebuf.floc.filenm = filename; /* Use the original file name.  */
   ebuf.floc.lineno = 1;
+  ebuf.floc.offset = 0;
   if (ISDB (DB_VERBOSE))
+    {
       printf (_("Reading makefile `%s'"), filename);
+      printf (_("Reading makefile '%s'"), filename);
       if (flags & RM_NO_DEFAULT_GOAL)
         printf (_(" (no default goal)"));
+        printf (_(" (no default goal)"));
       if (flags & RM_INCLUDED)
         printf (_(" (search path)"));
+        printf (_(" (search path)"));
       if (flags & RM_DONTCARE)
         printf (_(" (don't care)"));
+        printf (_(" (don't care)"));
       if (flags & RM_NO_TILDE)
         printf (_(" (no ~ expansion)"));
+        printf (_(" (no ~ expansion)"));
       puts ("...");
+    }
 …
   /* First, get a stream to read.  */
   /* Expand ~ in FILENAME unless it came from `include',
+  /* Expand ~ in FILENAME unless it came from 'include',
      in which case it was already done.  */
   if (!(flags & RM_NO_TILDE) && filename[0] == '~')
 …
       expanded = tilde_expand (filename);
       if (expanded != 0)
+        filename = expanded;
+    }
+  ebuf.fp = fopen (filename, "r");
+        filename = expanded;
+    }
+  ENULLLOOP (ebuf.fp, fopen (filename, "r"));
   /* Save the error code so we print the right message later.  */
   makefile_errno = errno;
+  /* Check for unrecoverable errors: out of mem or FILE slots.  */
+  switch (makefile_errno)
+    {
+#ifdef EMFILE
+    case EMFILE:
+#endif
+#ifdef ENFILE
+    case ENFILE:
+#endif
+    case ENOMEM:
+      {
+        const char *err = strerror (makefile_errno);
+        OS (fatal, reading_file, "%s", err);
+      }
+    }
   /* If the makefile wasn't found and it's either a makefile from
      the `MAKEFILES' variable or an included makefile,
+     the 'MAKEFILES' variable or an included makefile,
      search the included makefile search path for this makefile.  */
   if (ebuf.fp == 0 && (flags & RM_INCLUDED) && *filename != '/')
 …
       unsigned int i;
       for (i = 0; include_directories[i] != 0; ++i)
+        {
           const char *included = concat (3, include_directories[i],
+        {
+          const char *included = concat (3, include_directories[i],
                                          "/", filename);
+          ebuf.fp = fopen (included, "r");
+          if (ebuf.fp)
+            {
+              filename = strcache_add (included);
+              break;
+            }
+        }
+    }
+          ebuf.fp = fopen (included, "r");
+          if (ebuf.fp)
+            {
+              filename = included;
+              break;
+            }
+        }
+    }
+  /* Now we have the final name for this makefile. Enter it into
+     the cache.  */
+  filename = strcache_add (filename);
   /* Add FILENAME to the chain of read makefiles.  */
   deps = alloc_dep ();
   deps->next = read_makefiles;
   read_makefiles = deps;
+  deps = alloc_goaldep ();
+  deps->next = read_files;
+  read_files = deps;
   deps->file = lookup_file (filename);
   if (deps->file == 0)
     deps->file = enter_file (filename);
   filename = deps->file->name;
+  deps->changed = flags;
+  if (flags & RM_DONTCARE)
+    deps->dontcare = 1;
+  if (expanded)
+    free (expanded);
+  deps->flags = flags;
+  free (expanded);
   /* If the makefile can't be found at all, give up entirely.  */
 …
+    {
       /* If we did some searching, errno has the error from the last
          attempt, rather from FILENAME itself.  Restore it in case the
          caller wants to use it in a message.  */
+         attempt, rather from FILENAME itself.  Store it in case the
+         caller wants to use it in a message.  */
       errno = makefile_errno;
       return 0;
+      return deps;
+    }
 …
   alloca (0);
+  return 1;
+  errno = 0;
+  return deps;
+}
 void
 eval_buffer (char *buffer)
+eval_buffer (char *buffer, const floc *flocp)
+{
   struct ebuffer ebuf;
   struct conditionals *saved;
   struct conditionals new;
   const struct floc *curfile;
+  const floc *curfile;
   /* Evaluate the buffer */
 …
   ebuf.fp = NULL;
+  if (reading_file)
+  if (flocp)
+    ebuf.floc = *flocp;
+  else if (reading_file)
     ebuf.floc = *reading_file;
   else
+    ebuf.floc.filenm = NULL;
+    {
+      ebuf.floc.filenm = NULL;
+      ebuf.floc.lineno = 1;
+      ebuf.floc.offset = 0;
+    }
   curfile = reading_file;
 …
   /* Find the start of the next token.  If there isn't one we're done.  */
   line = next_token (line);
+  NEXT_TOKEN (line);
   if (*line == '\0')
     return (char *)line;
 …
       int wlen;
       const char *p2;
       enum variable_flavor flavor;
       p2 = parse_variable_definition (p, &flavor);
+      struct variable v;
+      p2 = parse_variable_definition (p, &v);
       /* If this is a variable assignment, we're done.  */
 …
   unsigned int cmds_started, tgts_started;
   int ignoring = 0, in_ignored_define = 0;
   int no_targets = 0;           /* Set when reading a rule without targets.  */
+  int no_targets = 0;           /* Set when reading a rule without targets.  */
   struct nameseq *filenames = 0;
   char *depstr = 0;
   long nlines = 0;
   int two_colon = 0;
+  char prefix = cmd_prefix;
   const char *pattern = 0;
   const char *pattern_percent;
   struct floc *fstart;
   struct floc fi;
 #define record_waiting_files()                                                \
   do                                                                          \
     {                                                                         \
       if (filenames != 0)                                                     \
+  floc *fstart;
+  floc fi;
+#define record_waiting_files()                                                \
+  do                                                                          \
+    {                                                                         \
+      if (filenames != 0)                                                     \
         {                                                                     \
+          fi.lineno = tgts_started;                                           \
+          record_files (filenames, pattern, pattern_percent, depstr,          \
+          fi.lineno = tgts_started;                                           \
+          fi.offset = 0;                                                      \
+          record_files (filenames, pattern, pattern_percent, depstr,          \
                         cmds_started, commands, commands_idx, two_colon,      \
                         &fi);                                                 \
           filenames = 0;                                                      \
+                        prefix, &fi);                                         \
+          filenames = 0;                                                      \
         }                                                                     \
       commands_idx = 0;                                                       \
+      commands_idx = 0;                                                       \
       no_targets = 0;                                                         \
       pattern = 0;                                                            \
 …
      When you see a "continue" in the loop below, that means we are moving on
+     to the next line _without_ ending any rule that we happen to be working
+     with at the moment.  If you see a "goto rule_complete", then the
+     statement we just parsed also finishes the previous rule.  */
+     to the next line.  If you see record_waiting_files(), then the statement
+     we are parsing also finishes the previous rule.  */
   commands = xmalloc (200);
 …
         break;
+      line = ebuf->buffer;
+      /* If this is the first line, check for a UTF-8 BOM and skip it.  */
+      if (ebuf->floc.lineno == 1 && line[0] == (char)0xEF
+          && line[1] == (char)0xBB && line[2] == (char)0xBF)
+        {
+          line += 3;
+          if (ISDB(DB_BASIC))
+            {
+              if (ebuf->floc.filenm)
+                printf (_("Skipping UTF-8 BOM in makefile '%s'\n"),
+                        ebuf->floc.filenm);
+              else
+                printf (_("Skipping UTF-8 BOM in makefile buffer\n"));
+            }
+        }
       /* If this line is empty, skip it.  */
-      line = ebuf->buffer;
       if (line[0] == '\0')
         continue;
 …
       /* Check for a shell command line first.
          If it is not one, we can stop treating tab specially.  */
+         If it is not one, we can stop treating cmd_prefix specially.  */
       if (line[0] == cmd_prefix)
+        {
+          if (no_targets)
+            /* Ignore the commands in a rule with no targets.  */
+            continue;
+          /* If there is no preceding rule line, don't treat this line
+             as a command, even though it begins with a recipe prefix.
+             SunOS 4 make appears to behave this way.  */
+          if (filenames != 0)
+            {
+              if (ignoring)
+                /* Yep, this is a shell command, and we don't care.  */
+                continue;
+              /* Append this command line to the line being accumulated.
+                 Strip command prefix chars that appear after newlines.  */
+              if (commands_idx == 0)
+                cmds_started = ebuf->floc.lineno;
+              if (linelen + commands_idx > commands_len)
+                {
+                  commands_len = (linelen + commands_idx) * 2;
+                  commands = xrealloc (commands, commands_len);
+                }
+              p = &commands[commands_idx];
+              p2 = line + 1;
+              while (--linelen)
+        {
+          if (no_targets)
+            /* Ignore the commands in a rule with no targets.  */
+            continue;
+          /* If there is no preceding rule line, don't treat this line
+             as a command, even though it begins with a recipe prefix.
+             SunOS 4 make appears to behave this way.  */
+          if (filenames != 0)
+            {
+              if (ignoring)
+                /* Yep, this is a shell command, and we don't care.  */
+                continue;
+              if (commands_idx == 0)
+                cmds_started = ebuf->floc.lineno;
+              /* Append this command line to the line being accumulated.
+                 Skip the initial command prefix character.  */
+              if (linelen + commands_idx > commands_len)
+                {
+                  ++commands_idx;
+                  *(p++) = *p2;
+                  if (p2[0] == '\n' && p2[1] == cmd_prefix)
+                    {
+                      ++p2;
+                      --linelen;
+                    }
+                  ++p2;
+                  commands_len = (linelen + commands_idx) * 2;
+                  commands = xrealloc (commands, commands_len);
+                }
               *p = '\n';
               ++commands_idx;
               continue;
+            }
+        }
+              memcpy (&commands[commands_idx], line + 1, linelen - 1);
+              commands_idx += linelen - 1;
+              commands[commands_idx++] = '\n';
+              continue;
+            }
+        }
       /* This line is not a shell command line.  Don't worry about whitespace.
 …
       if (collapsed_length < linelen+1)
+        {
+          collapsed_length = linelen+1;
+          if (collapsed)
+            free (collapsed);
+        {
+          collapsed_length = linelen+1;
+          free (collapsed);
           /* Don't need xrealloc: we don't need to preserve the content.  */
           collapsed = xmalloc (collapsed_length);
+        }
+          collapsed = xmalloc (collapsed_length);
+        }
       strcpy (collapsed, line);
       /* Collapse continuation lines.  */
 …
       /* Get rid if starting space (including formfeed, vtab, etc.)  */
       p = collapsed;
+      while (isspace ((unsigned char)*p))
+        ++p;
+      NEXT_TOKEN (p);
       /* See if this is a variable assignment.  We need to do this early, to
          allow variables with names like 'ifdef', 'export', 'private', etc.  */
       p = parse_var_assignment(p, &vmod);
+      p = parse_var_assignment (p, &vmod);
       if (vmod.assign_v)
+        {
 …
           /* If we're ignoring then we're done now.  */
           if (ignoring)
+          if (ignoring)
+            {
               if (vmod.define_v)
 …
+            }
+          /* Variable assignment ends the previous rule.  */
+          record_waiting_files ();
           if (vmod.undefine_v)
+          {
             do_undefine (p, origin, ebuf);
+            /* This line has been dealt with.  */
+            goto rule_complete;
+            continue;
+          }
           else if (vmod.define_v)
 …
           /* This line has been dealt with.  */
           goto rule_complete;
+          continue;
+        }
       /* If this line is completely empty, ignore it.  */
       if (*p == '\0')
         continue;
+        continue;
       p2 = end_of_token (p);
       wlen = p2 - p;
       p2 = next_token (p2);
+      NEXT_TOKEN (p2);
       /* If we're in an ignored define, skip this line (but maybe get out).  */
       if (in_ignored_define)
+        {
+        {
           /* See if this is an endef line (plus optional comment).  */
           if (word1eq ("endef") && (*p2 == '\0' || *p2 == '#'))
+          if (word1eq ("endef") && STOP_SET (*p2, MAP_COMMENT|MAP_NUL))
             in_ignored_define = 0;
           continue;
+        }
+          continue;
+        }
       /* Check for conditional state changes.  */
 …
+          {
             if (i == -1)
               fatal (fstart, _("invalid syntax in conditional"));
+              O (fatal, fstart, _("invalid syntax in conditional"));
             ignoring = i;
 …
       /* Nothing to see here... move along.  */
       if (ignoring)
         continue;
+        continue;
       /* Manage the "export" keyword used outside of variable assignment
          as well as "unexport".  */
       if (word1eq ("export") || word1eq ("unexport"))
+        {
+        {
           int exporting = *p == 'u' ? 0 : 1;
+          /* Export/unexport ends the previous rule.  */
+          record_waiting_files ();
           /* (un)export by itself causes everything to be (un)exported. */
           if (*p2 == '\0')
+          if (*p2 == '\0')
             export_all_variables = exporting;
           else
 …
                   struct variable *v = lookup_variable (p, l);
                   if (v == 0)
                     v = define_variable_loc (p, l, "", o_file, 0, fstart);
+                    v = define_variable_global (p, l, "", o_file, 0, fstart);
                   v->export = exporting ? v_export : v_noexport;
+                }
 …
               free (ap);
+            }
           goto rule_complete;
+        }
+          continue;
+        }
       /* Handle the special syntax for vpath.  */
       if (word1eq ("vpath"))
+        {
+        {
           const char *cp;
+          char *vpat;
+          unsigned int l;
+          cp = variable_expand (p2);
+          p = find_next_token (&cp, &l);
+          if (p != 0)
+            {
+              vpat = xstrndup (p, l);
+              p = find_next_token (&cp, &l);
+              /* No searchpath means remove all previous
+                 selective VPATH's with the same pattern.  */
+            }
+          else
+            /* No pattern means remove all previous selective VPATH's.  */
+            vpat = 0;
+          construct_vpath_list (vpat, p);
+          if (vpat != 0)
+            free (vpat);
+          goto rule_complete;
+        }
+          char *vpat;
+          unsigned int l;
+          /* vpath ends the previous rule.  */
+          record_waiting_files ();
+          cp = variable_expand (p2);
+          p = find_next_token (&cp, &l);
+          if (p != 0)
+            {
+              vpat = xstrndup (p, l);
+              p = find_next_token (&cp, &l);
+              /* No searchpath means remove all previous
+                 selective VPATH's with the same pattern.  */
+            }
+          else
+            /* No pattern means remove all previous selective VPATH's.  */
+            vpat = 0;
+          construct_vpath_list (vpat, p);
+          free (vpat);
+          continue;
+        }
       /* Handle include and variants.  */
       if (word1eq ("include") || word1eq ("-include") || word1eq ("sinclude"))
+        {
           /* We have found an `include' line specifying a nested
              makefile to be read at this point.  */
           struct conditionals *save;
+        {
+          /* We have found an 'include' line specifying a nested
+             makefile to be read at this point.  */
+          struct conditionals *save;
           struct conditionals new_conditionals;
+          struct nameseq *files;
+          /* "-include" (vs "include") says no error if the file does not
+             exist.  "sinclude" is an alias for this from SGI.  */
+          int noerror = (p[0] != 'i');
+          p = allocated_variable_expand (p2);
+          struct nameseq *files;
+          /* "-include" (vs "include") says no error if the file does not
+             exist.  "sinclude" is an alias for this from SGI.  */
+          int noerror = (p[0] != 'i');
+          /* Include ends the previous rule.  */
+          record_waiting_files ();
+          p = allocated_variable_expand (p2);
           /* If no filenames, it's a no-op.  */
           if (*p == '\0')
+          if (*p == '\0')
+            {
               free (p);
 …
+            }
           /* Parse the list of file names.  Don't expand archive references!  */
           p2 = p;
           files = PARSE_FILE_SEQ (&p2, struct nameseq, '\0', NULL,
+          /* Parse the list of file names.  Don't expand archive references!  */
+          p2 = p;
+          files = PARSE_FILE_SEQ (&p2, struct nameseq, MAP_NUL, NULL,
                                   PARSEFS_NOAR);
+          free (p);
+          /* Save the state of conditionals and start
+             the included makefile with a clean slate.  */
+          save = install_conditionals (&new_conditionals);
+          /* Record the rules that are waiting so they will determine
+             the default goal before those in the included makefile.  */
+          record_waiting_files ();
+          /* Read each included makefile.  */
+          while (files != 0)
+            {
+              struct nameseq *next = files->next;
+              const char *name = files->name;
+          free (p);
+          /* Save the state of conditionals and start
+             the included makefile with a clean slate.  */
+          save = install_conditionals (&new_conditionals);
+          /* Record the rules that are waiting so they will determine
+             the default goal before those in the included makefile.  */
+          record_waiting_files ();
+          /* Read each included makefile.  */
+          while (files != 0)
+            {
+              struct nameseq *next = files->next;
+              int flags = (RM_INCLUDED | RM_NO_TILDE
+                           | (noerror ? RM_DONTCARE : 0)
+                           | (set_default ? 0 : RM_NO_DEFAULT_GOAL));
+              struct goaldep *d = eval_makefile (files->name, flags);
+              if (errno)
+                {
+                  d->error = (unsigned short)errno;
+                  d->floc = *fstart;
+                }
+              free_ns (files);
+              files = next;
+            }
+          /* Restore conditional state.  */
+          restore_conditionals (save);
+          continue;
+        }
+      /* Handle the load operations.  */
+      if (word1eq ("load") || word1eq ("-load"))
+        {
+          /* A 'load' line specifies a dynamic object to load.  */
+          struct nameseq *files;
+          int noerror = (p[0] == '-');
+          /* Load ends the previous rule.  */
+          record_waiting_files ();
+          p = allocated_variable_expand (p2);
+          /* If no filenames, it's a no-op.  */
+          if (*p == '\0')
+            {
+              free (p);
+              continue;
+            }
+          /* Parse the list of file names.
+             Don't expand archive references or strip "./"  */
+          p2 = p;
+          files = PARSE_FILE_SEQ (&p2, struct nameseq, MAP_NUL, NULL,
+                                  PARSEFS_NOAR);
+          free (p);
+          /* Load each file.  */
+          while (files != 0)
+            {
+              struct nameseq *next = files->next;
+              const char *name = files->name;
+              struct goaldep *deps;
               int r;
+              free_ns (files);
+              files = next;
+              r = eval_makefile (name,
+                                 (RM_INCLUDED | RM_NO_TILDE
+                                  | (noerror ? RM_DONTCARE : 0)
+                                  | (set_default ? 0 : RM_NO_DEFAULT_GOAL)));
+              if (!r && !noerror)
+                error (fstart, "%s: %s", name, strerror (errno));
+            }
+          /* Restore conditional state.  */
+          restore_conditionals (save);
+          goto rule_complete;
+        }
+              /* Load the file.  0 means failure.  */
+              r = load_file (&ebuf->floc, &name, noerror);
+              if (! r && ! noerror)
+                OS (fatal, &ebuf->floc, _("%s: failed to load"), name);
+              free_ns (files);
+              files = next;
+              /* Return of -1 means a special load: don't rebuild it.  */
+              if (r == -1)
+                continue;
+              /* It succeeded, so add it to the list "to be rebuilt".  */
+              deps = alloc_goaldep ();
+              deps->next = read_files;
+              read_files = deps;
+              deps->file = lookup_file (name);
+              if (deps->file == 0)
+                deps->file = enter_file (name);
+              deps->file->loaded = 1;
+            }
+          continue;
+        }
       /* This line starts with a tab but was not caught above because there
 …
          variable definition.  But now we know it is definitely lossage.  */
       if (line[0] == cmd_prefix)
         fatal(fstart, _("recipe commences before first target"));
+        O (fatal, fstart, _("recipe commences before first target"));
       /* This line describes some target files.  This is complicated by
          the existence of target-specific variables, because we can't
          expand the entire line until we know if we have one or not.  So
          we expand the line word by word until we find the first `:',
+         we expand the line word by word until we find the first ':',
          then check to see if it's a target-specific variable.
          In this algorithm, `lb_next' will point to the beginning of the
          unexpanded parts of the input buffer, while `p2' points to the
+         In this algorithm, 'lb_next' will point to the beginning of the
+         unexpanded parts of the input buffer, while 'p2' points to the
          parts of the expanded buffer we haven't searched yet. */
 …
         /* Search the line for an unquoted ; that is not after an
            unquoted #.  */
         cmdleft = find_char_unquote (line, ';', '#', 0, 1);
+        cmdleft = find_char_unquote (line, MAP_SEMI|MAP_COMMENT|MAP_VARIABLE);
         if (cmdleft != 0 && *cmdleft == '#')
+          {
 …
            beginning, expanding as we go, and looking for "interesting"
            chars.  The first word is always expandable.  */
         wtype = get_next_mword(line, NULL, &lb_next, &wlen);
+        wtype = get_next_mword (line, NULL, &lb_next, &wlen);
         switch (wtype)
+          {
           case w_eol:
             if (cmdleft != 0)
               fatal(fstart, _("missing rule before recipe"));
+              O (fatal, fstart, _("missing rule before recipe"));
             /* This line contained something but turned out to be nothing
                but whitespace (a comment?).  */
 …
+          }
         p2 = variable_expand_string(NULL, lb_next, wlen);
+        p2 = variable_expand_string (NULL, lb_next, wlen);
         while (1)
 …
+              {
                 /* Look for a semicolon in the expanded line.  */
                 cmdleft = find_char_unquote (p2, ';', 0, 0, 0);
+                cmdleft = find_char_unquote (p2, MAP_SEMI);
                 if (cmdleft != 0)
 …
                     unsigned long p2_off = p2 - variable_buffer;
                     unsigned long cmd_off = cmdleft - variable_buffer;
                     char *pend = p2 + strlen(p2);
+                    char *pend = p2 + strlen (p2);
                     /* Append any remnants of lb, then cut the line short
 …
                        and into a command script.  However, the old parser
                        expanded the whole line, so we continue that for
                        backwards-compatiblity.  Also, it wouldn't be
+                       backwards-compatibility.  Also, it wouldn't be
                        entirely consistent, since we do an unconditional
                        expand below once we know we don't have a
                        target-specific variable. */
                     (void)variable_expand_string(pend, lb_next, (long)-1);
                     lb_next += strlen(lb_next);
+                    (void)variable_expand_string (pend, lb_next, (long)-1);
+                    lb_next += strlen (lb_next);
                     p2 = variable_buffer + p2_off;
                     cmdleft = variable_buffer + cmd_off + 1;
 …
+              }
             colonp = find_char_unquote(p2, ':', 0, 0, 0);
+            colonp = find_char_unquote (p2, MAP_COLON);
 #ifdef HAVE_DOS_PATHS
             /* The drive spec brain-damage strikes again...  */
 …
                    colonp > p2 && isalpha ((unsigned char)colonp[-1]) &&
                    (colonp == p2 + 1 || strchr (" \t(", colonp[-2]) != 0))
               colonp = find_char_unquote(colonp + 1, ':', 0, 0, 0);
+              colonp = find_char_unquote (colonp + 1, MAP_COLON);
 #endif
             if (colonp != 0)
               break;
             wtype = get_next_mword(lb_next, NULL, &lb_next, &wlen);
+            wtype = get_next_mword (lb_next, NULL, &lb_next, &wlen);
             if (wtype == w_eol)
               break;
             p2 += strlen(p2);
+            p2 += strlen (p2);
             *(p2++) = ' ';
             p2 = variable_expand_string(p2, lb_next, wlen);
+            p2 = variable_expand_string (p2, lb_next, wlen);
             /* We don't need to worry about cmdleft here, because if it was
                found in the variable_buffer the entire buffer has already
 …
         if (wtype == w_eol)
+          {
+            if (*p2 != '\0')
+              /* There's no need to be ivory-tower about this: check for
+                 one of the most common bugs found in makefiles...  */
+              fatal (fstart, _("missing separator%s"),
+                     (cmd_prefix == '\t' && !strneq(line, "        ", 8))
+                     ? "" : _(" (did you mean TAB instead of 8 spaces?)"));
+            continue;
+            if (*p2 == '\0')
+              continue;
+            /* There's no need to be ivory-tower about this: check for
+               one of the most common bugs found in makefiles...  */
+            if (cmd_prefix == '\t' && strneq (line, "        ", 8))
+              O (fatal, fstart, _("missing separator (did you mean TAB instead of 8 spaces?)"));
+            else
+              O (fatal, fstart, _("missing separator"));
+          }
         /* Make the colon the end-of-string so we know where to stop
            looking for targets.  */
+           looking for targets.  Start there again once we're done.  */
         *colonp = '\0';
+        filenames = PARSE_FILE_SEQ (&p2, struct nameseq, '\0', NULL, 0);
+        *p2 = ':';
+        filenames = PARSE_SIMPLE_SEQ (&p2, struct nameseq);
+        *colonp = ':';
+        p2 = colonp;
         if (!filenames)
 …
             if (semip)
+              {
                 unsigned int l = p - variable_buffer;
+                unsigned int l = p2 - variable_buffer;
                 *(--semip) = ';';
                 collapse_continuations (semip);
                 variable_buffer_output (p2 + strlen (p2),
                                         semip, strlen (semip)+1);
                 p = variable_buffer + l;
+                p2 = variable_buffer + l;
+              }
             record_target_var (filenames, p2,
 …
         /* This is a normal target, _not_ a target-specific variable.
            Unquote any = in the dependency list.  */
+        find_char_unquote (lb_next, '=', 0, 0, 0);
+        find_char_unquote (lb_next, MAP_EQUALS);
+        /* Remember the command prefix for this target.  */
+        prefix = cmd_prefix;
         /* We have some targets, so don't ignore the following commands.  */
 …
             if (cmdleft == 0)
+              {
                 cmdleft = find_char_unquote (p2, ';', 0, 0, 0);
+                cmdleft = find_char_unquote (p2, MAP_SEMI);
                 if (cmdleft != 0)
                   *(cmdleft++) = '\0';
 …
+          }
         /* Is this a static pattern rule: `target: %targ: %dep; ...'?  */
+        /* Is this a static pattern rule: 'target: %targ: %dep; ...'?  */
         p = strchr (p2, ':');
         while (p != 0 && p[-1] == '\\')
 …
            OR a space around the :.
         */
+        if (p && !(isspace ((unsigned char)p[1]) || !p[1]
+                   || isspace ((unsigned char)p[-1])))
+        if (p && !(ISSPACE (p[1]) || !p[1] || ISSPACE (p[-1])))
           p = 0;
 #endif
 …
+          {
             struct nameseq *target;
             target = PARSE_FILE_SEQ (&p2, struct nameseq, ':', NULL,
+            target = PARSE_FILE_SEQ (&p2, struct nameseq, MAP_COLON, NULL,
                                      PARSEFS_NOGLOB);
             ++p2;
             if (target == 0)
               fatal (fstart, _("missing target pattern"));
+              O (fatal, fstart, _("missing target pattern"));
             else if (target->next != 0)
               fatal (fstart, _("multiple target patterns"));
+              O (fatal, fstart, _("multiple target patterns"));
             pattern_percent = find_percent_cached (&target->name);
             pattern = target->name;
             if (pattern_percent == 0)
               fatal (fstart, _("target pattern contains no `%%'"));
+              O (fatal, fstart, _("target pattern contains no '%%'"));
             free_ns (target);
+          }
 …
         if (set_default && default_goal_var->value[0] == '\0')
+          {
-            const char *name;
             struct dep *d;
             struct nameseq *t = filenames;
 …
+              {
                 int reject = 0;
                 name = t->name;
+                const char *name = t->name;
                 /* We have nothing to do if this is an implicit rule. */
 …
                   break;
                 /* See if this target's name does not start with a `.',
+                /* See if this target's name does not start with a '.',
                    unless it contains a slash.  */
                 if (*name == '.' && strchr (name, '/') == 0
 …
       /* We get here except in the case that we just read a rule line.
+         Record now the last rule we read, so following spurious
+         commands are properly diagnosed.  */
+ rule_complete:
+         Record now the last rule we read, so following spurious
+         commands are properly diagnosed.  */
       record_waiting_files ();
+    }
 #undef  word1eq
+#undef word1eq
   if (conditionals->if_cmds)
     fatal (fstart, _("missing `endif'"));
+    O (fatal, fstart, _("missing 'endif'"));
   /* At eof, record the last rule.  */
   record_waiting_files ();
+  if (collapsed)
+    free (collapsed);
+  free (collapsed);
   free (commands);
+}
 …
   char *comment;
   comment = find_char_unquote (line, '#', 0, 0, 0);
+  comment = find_char_unquote (line, MAP_COMMENT);
   if (comment != 0)
 …
+}
 /* Execute a `undefine' directive.
+/* Execute a 'undefine' directive.
    The undefine line has already been read, and NAME is the name of
    the variable to be undefined. */
 …
   name = next_token (var);
   if (*name == '\0')
     fatal (&ebuf->floc, _("empty variable name"));
+    O (fatal, &ebuf->floc, _("empty variable name"));
   p = name + strlen (name) - 1;
   while (p > name && isblank ((unsigned char)*p))
+  while (p > name && ISBLANK (*p))
     --p;
   p[1] = '\0';
 …
+}
 /* Execute a `define' directive.
+/* Execute a 'define' directive.
    The first line has already been read, and NAME is the name of
    the variable to be defined.  The following lines remain to be read.  */
 …
+{
   struct variable *v;
   enum variable_flavor flavor;
   struct floc defstart;
+  struct variable var;
+  floc defstart;
   int nlevels = 1;
   unsigned int length = 100;
   char *definition = xmalloc (length);
   unsigned int idx = 0;
   char *p, *var;
+  char *p, *n;
   defstart = ebuf->floc;
   p = parse_variable_definition (name, &flavor);
+  p = parse_variable_definition (name, &var);
   if (p == NULL)
     /* No assignment token, so assume recursive.  */
     flavor = f_recursive;
+    var.flavor = f_recursive;
   else
+    {
       if (*(next_token (p)) != '\0')
         error (&defstart, _("extraneous text after `define' directive"));
+      if (var.value[0] != '\0')
+        O (error, &defstart, _("extraneous text after 'define' directive"));
       /* Chop the string before the assignment token to get the name.  */
       p[flavor == f_recursive ? -1 : -2] = '\0';
+      var.name[var.length] = '\0';
+    }
   /* Expand the variable name and find the beginning (NAME) and end.  */
   var = allocated_variable_expand (name);
   name = next_token (var);
   if (*name == '\0')
     fatal (&defstart, _("empty variable name"));
+  n = allocated_variable_expand (name);
+  name = next_token (n);
+  if (name[0] == '\0')
+    O (fatal, &defstart, _("empty variable name"));
   p = name + strlen (name) - 1;
   while (p > name && isblank ((unsigned char)*p))
+  while (p > name && ISBLANK (*p))
     --p;
   p[1] = '\0';
 …
       /* If there is nothing left to be eval'd, there's no 'endef'!!  */
       if (nlines < 0)
         fatal (&defstart, _("missing `endef', unterminated `define'"));
+        O (fatal, &defstart, _("missing 'endef', unterminated 'define'"));
       ebuf->floc.lineno += nlines;
 …
           /* If this is another 'define', increment the level count.  */
           if ((len == 6 || (len > 6 && isblank ((unsigned char)p[6])))
+          if ((len == 6 || (len > 6 && ISBLANK (p[6])))
               && strneq (p, "define", 6))
             ++nlevels;
 …
           /* If this is an 'endef', decrement the count.  If it's now 0,
              we've found the last one.  */
           else if ((len == 5 || (len > 5 && isblank ((unsigned char)p[5])))
+          else if ((len == 5 || (len > 5 && ISBLANK (p[5])))
                    && strneq (p, "endef", 5))
+            {
 …
               remove_comments (p);
               if (*(next_token (p)) != '\0')
                 error (&ebuf->floc,
                        _("extraneous text after `endef' directive"));
+                O (error, &ebuf->floc,
+                   _("extraneous text after 'endef' directive"));
               if (--nlevels == 0)
 …
     definition[idx - 1] = '\0';
+  v = do_variable_definition (&defstart, name, definition, origin, flavor, 0);
+  v = do_variable_definition (&defstart, name,
+                              definition, origin, var.flavor, 0);
   free (definition);
   free (var);
+  free (n);
   return (v);
+}
 …
 static int
 conditional_line (char *line, int len, const struct floc *flocp)
+conditional_line (char *line, int len, const floc *flocp)
+{
   char *cmdname;
+  const char *cmdname;
   enum { c_ifdef, c_ifndef, c_ifeq, c_ifneq, c_else, c_endif } cmdtype;
   unsigned int i;
 …
   /* Compare a word, both length and contents. */
 #define word1eq(s)      (len == sizeof(s)-1 && strneq (s, line, sizeof(s)-1))
 #define chkword(s, t)   if (word1eq (s)) { cmdtype = (t); cmdname = (s); }
+#define word1eq(s)      (len == CSTRLEN (s) && strneq (s, line, CSTRLEN (s)))
+#define chkword(s, t)   if (word1eq (s)) { cmdtype = (t); cmdname = (s); }
   /* Make sure this line is a conditional.  */
 …
   /* Found one: skip past it and any whitespace after it.  */
+  line = next_token (line + len);
+#define EXTRANEOUS() error (flocp, _("Extraneous text after `%s' directive"), cmdname)
+  line += len;
+  NEXT_TOKEN (line);
+#define EXTRATEXT() OS (error, flocp, _("extraneous text after '%s' directive"), cmdname)
+#define EXTRACMD()  OS (fatal, flocp, _("extraneous '%s'"), cmdname)
   /* An 'endif' cannot contain extra text, and reduces the if-depth by 1  */
 …
+    {
       if (*line != '\0')
         EXTRANEOUS ();
+        EXTRATEXT ();
       if (!conditionals->if_cmds)
         fatal (flocp, _("extraneous `%s'"), cmdname);
+        EXTRACMD ();
       --conditionals->if_cmds;
 …
       if (!conditionals->if_cmds)
         fatal (flocp, _("extraneous `%s'"), cmdname);
+        EXTRACMD ();
       o = conditionals->if_cmds - 1;
       if (conditionals->seen_else[o])
         fatal (flocp, _("only one `else' per conditional"));
+        O (fatal, flocp, _("only one 'else' per conditional"));
       /* Change the state of ignorance.  */
 …
       /* Find the length of the next word.  */
       for (p = line+1; *p != '\0' && !isspace ((unsigned char)*p); ++p)
+      for (p = line+1; ! STOP_SET (*p, MAP_SPACE|MAP_NUL); ++p)
+        ;
       len = p - line;
       /* If it's 'else' or 'endif' or an illegal conditional, fail.  */
       if (word1eq("else") || word1eq("endif")
+      if (word1eq ("else") || word1eq ("endif")
           || conditional_line (line, len, flocp) < 0)
         EXTRANEOUS ();
+        EXTRATEXT ();
       else
+        {
 …
+    }
   /* Record that we have seen an `if...' but no `else' so far.  */
+  /* Record that we have seen an 'if...' but no 'else' so far.  */
   conditionals->seen_else[o] = 0;
 …
     if (conditionals->ignoring[i])
+      {
         /* We are already ignoring, so just push a level to match the next
            "else" or "endif", and keep ignoring.  We don't want to expand
            variables in the condition.  */
         conditionals->ignoring[o] = 1;
         return 1;
+        /* We are already ignoring, so just push a level to match the next
+           "else" or "endif", and keep ignoring.  We don't want to expand
+           variables in the condition.  */
+        conditionals->ignoring[o] = 1;
+        return 1;
+      }
 …
       p = end_of_token (var);
       i = p - var;
       p = next_token (p);
+      NEXT_TOKEN (p);
       if (*p != '\0')
         return -1;
+        return -1;
       var[i] = '\0';
 …
       if (termin != ',' && termin != '"' && termin != '\'')
         return -1;
+        return -1;
       s1 = ++line;
       /* Find the end of the first string.  */
       if (termin == ',')
+        {
           int count = 0;
           for (; *line != '\0'; ++line)
             if (*line == '(')
               ++count;
             else if (*line == ')')
               --count;
             else if (*line == ',' && count <= 0)
               break;
+        }
+        {
+          int count = 0;
+          for (; *line != '\0'; ++line)
+            if (*line == '(')
+              ++count;
+            else if (*line == ')')
+              --count;
+            else if (*line == ',' && count <= 0)
+              break;
+        }
       else
         while (*line != '\0' && *line != termin)
           ++line;
+        while (*line != '\0' && *line != termin)
+          ++line;
       if (*line == '\0')
         return -1;
+        return -1;
       if (termin == ',')
+        {
           /* Strip blanks after the first string.  */
           char *p = line++;
           while (isblank ((unsigned char)p[-1]))
             --p;
           *p = '\0';
+        }
+        {
+          /* Strip blanks after the first string.  */
+          char *p = line++;
+          while (ISBLANK (p[-1]))
+            --p;
+          *p = '\0';
+        }
       else
         *line++ = '\0';
+        *line++ = '\0';
       s2 = variable_expand (s1);
       /* We must allocate a new copy of the expanded string because
          variable_expand re-uses the same buffer.  */
+         variable_expand re-uses the same buffer.  */
       l = strlen (s2);
       s1 = alloca (l + 1);
 …
       if (termin != ',')
         /* Find the start of the second string.  */
         line = next_token (line);
+        /* Find the start of the second string.  */
+        NEXT_TOKEN (line);
       termin = termin == ',' ? ')' : *line;
       if (termin != ')' && termin != '"' && termin != '\'')
         return -1;
+        return -1;
       /* Find the end of the second string.  */
       if (termin == ')')
+        {
           int count = 0;
           s2 = next_token (line);
           for (line = s2; *line != '\0'; ++line)
+            {
               if (*line == '(')
                 ++count;
               else if (*line == ')')
+                {
                   if (count <= 0)
                     break;
                   else
                     --count;
+                }
+            }
+        }
+        {
+          int count = 0;
+          s2 = next_token (line);
+          for (line = s2; *line != '\0'; ++line)
+            {
+              if (*line == '(')
+                ++count;
+              else if (*line == ')')
+                {
+                  if (count <= 0)
+                    break;
+                  else
+                    --count;
+                }
+            }
+        }
       else
+        {
           ++line;
           s2 = line;
           while (*line != '\0' && *line != termin)
             ++line;
+        }
+        {
+          ++line;
+          s2 = line;
+          while (*line != '\0' && *line != termin)
+            ++line;
+        }
       if (*line == '\0')
         return -1;
       *line = '\0';
       line = next_token (++line);
+        return -1;
+      *(line++) = '\0';
+      NEXT_TOKEN (line);
       if (*line != '\0')
         EXTRANEOUS ();
+        EXTRATEXT ();
       s2 = variable_expand (s2);
 …
 record_target_var (struct nameseq *filenames, char *defn,
                    enum variable_origin origin, struct vmodifiers *vmod,
                    const struct floc *flocp)
+                   const floc *flocp)
+{
   struct nameseq *nextf;
 …
       struct variable *v;
       const char *name = filenames->name;
-      const char *fname;
       const char *percent;
       struct pattern_var *p;
 …
           else
             v->value = xstrdup (v->value);
-          fname = p->target;
+        }
       else
 …
           initialize_file_variables (f, 1);
-          fname = f->name;
           current_variable_set_list = f->variables;
           v = try_variable_definition (flocp, defn, origin, 1);
           if (!v)
             fatal (flocp, _("Malformed target-specific variable definition"));
+            O (fatal, flocp, _("Malformed target-specific variable definition"));
           current_variable_set_list = global;
+        }
 …
+        {
           struct variable *gv;
           int len = strlen(v->name);
+          int len = strlen (v->name);
           gv = lookup_variable (v->name, len);
+          if (gv && (gv->origin == o_env_override || gv->origin == o_command))
+          if (gv && v != gv
+              && (gv->origin == o_env_override || gv->origin == o_command))
+            {
+              if (v->value != 0)
+                free (v->value);
+              free (v->value);
               v->value = xstrdup (gv->value);
               v->origin = gv->origin;
 …
    by COMMANDS and COMMANDS_IDX, coming from FILENAME:COMMANDS_STARTED.
    TWO_COLON is nonzero if a double colon was used.
    If not nil, PATTERN is the `%' pattern to make this
+   If not nil, PATTERN is the '%' pattern to make this
    a static pattern rule, and PATTERN_PERCENT is a pointer
    to the `%' within it.
+   to the '%' within it.
    The links of FILENAMES are freed, and so are any names in it
 …
               unsigned int cmds_started, char *commands,
               unsigned int commands_idx, int two_colon,
               const struct floc *flocp)
+              char prefix, const floc *flocp)
+{
   struct commands *cmds;
 …
      See Savannah bug # 12124.  */
   if (snapped_deps)
     fatal (flocp, _("prerequisites cannot be defined in recipes"));
+    O (fatal, flocp, _("prerequisites cannot be defined in recipes"));
   /* Determine if this is a pattern rule or not.  */
 …
       cmds->fileinfo.filenm = flocp->filenm;
       cmds->fileinfo.lineno = cmds_started;
+      cmds->fileinfo.offset = 0;
       cmds->commands = xstrndup (commands, commands_idx);
       cmds->command_lines = 0;
+      cmds->recipe_prefix = prefix;
+    }
   else
 …
   if (depstr == 0)
     deps = 0;
-  else if (second_expansion && strchr (depstr, '$'))
+    {
-      deps = alloc_dep ();
-      deps->name = depstr;
-      deps->need_2nd_expansion = 1;
-      deps->staticpattern = pattern != 0;
+    }
   else
+    {
+      deps = split_prereqs (depstr);
+      free (depstr);
+      /* We'll enter static pattern prereqs later when we have the stem.  We
+         don't want to enter pattern rules at all so that we don't think that
+         they ought to exist (make manual "Implicit Rule Search Algorithm",
+         item 5c).  */
+      if (! pattern && ! implicit_percent)
+        deps = enter_prereqs (deps, NULL);
+      depstr = unescape_char (depstr, ':');
+      if (second_expansion && strchr (depstr, '$'))
+        {
+          deps = alloc_dep ();
+          deps->name = depstr;
+          deps->need_2nd_expansion = 1;
+          deps->staticpattern = pattern != 0;
+        }
+      else
+        {
+          deps = split_prereqs (depstr);
+          free (depstr);
+          /* We'll enter static pattern prereqs later when we have the stem.
+             We don't want to enter pattern rules at all so that we don't
+             think that they ought to exist (make manual "Implicit Rule Search
+             Algorithm", item 5c).  */
+          if (! pattern && ! implicit_percent)
+            deps = enter_prereqs (deps, NULL);
+        }
+    }
 …
       if (pattern != 0)
         fatal (flocp, _("mixed implicit and static pattern rules"));
+        O (fatal, flocp, _("mixed implicit and static pattern rules"));
       /* Count the targets to create an array of target names.
 …
           if (implicit_percent == 0)
             fatal (flocp, _("mixed implicit and normal rules"));
           targets[c] = name;
           target_pats[c] = implicit_percent;
+            O (fatal, flocp, _("mixed implicit and normal rules"));
+          targets[c] = name;
+          target_pats[c] = implicit_percent;
           ++c;
 …
           posix_pedantic = 1;
           define_variable_cname (".SHELLFLAGS", "-ec", o_default, 0);
+          /* These default values are based on IEEE Std 1003.1-2008.  */
+          define_variable_cname ("ARFLAGS", "-rv", o_default, 0);
+          define_variable_cname ("CC", "c99", o_default, 0);
+          define_variable_cname ("CFLAGS", "-O", o_default, 0);
+          define_variable_cname ("FC", "fort77", o_default, 0);
+          define_variable_cname ("FFLAGS", "-O 1", o_default, 0);
+          define_variable_cname ("SCCSGETFLAGS", "-s", o_default, 0);
+        }
       else if (streq (name, ".SECONDEXPANSION"))
         second_expansion = 1;
 #if !defined(WINDOWS32) && !defined (__MSDOS__) && !defined (__EMX__)
+#if !defined (__MSDOS__) && !defined (__EMX__)
       else if (streq (name, ".ONESHELL"))
         one_shell = 1;
 …
       /* If this is a static pattern rule:
          `targets: target%pattern: prereq%pattern; recipe',
+         'targets: target%pattern: prereq%pattern; recipe',
          make sure the pattern matches this target name.  */
       if (pattern && !pattern_matches (pattern, pattern_percent, name))
+        error (flocp, _("target `%s' doesn't match the target pattern"), name);
+        OS (error, flocp,
+            _("target '%s' doesn't match the target pattern"), name);
       else if (deps)
         /* If there are multiple targets, copy the chain DEPS for all but the
 …
       /* Find or create an entry in the file database for this target.  */
       if (!two_colon)
+        {
+          /* Single-colon.  Combine this rule with the file's existing record,
+             if any.  */
+          f = enter_file (strcache_add (name));
+          if (f->double_colon)
+            fatal (flocp,
+                   _("target file `%s' has both : and :: entries"), f->name);
+          /* If CMDS == F->CMDS, this target was listed in this rule
+             more than once.  Just give a warning since this is harmless.  */
+          if (cmds != 0 && cmds == f->cmds)
+            error (flocp,
+                   _("target `%s' given more than once in the same rule."),
+                   f->name);
+          /* Check for two single-colon entries both with commands.
+             Check is_target so that we don't lose on files such as .c.o
+             whose commands were preinitialized.  */
+          else if (cmds != 0 && f->cmds != 0 && f->is_target)
+            {
+              error (&cmds->fileinfo,
+                     _("warning: overriding recipe for target `%s'"),
+        {
+          /* Single-colon.  Combine this rule with the file's existing record,
+             if any.  */
+          f = enter_file (strcache_add (name));
+          if (f->double_colon)
+            OS (fatal, flocp,
+                _("target file '%s' has both : and :: entries"), f->name);
+          /* If CMDS == F->CMDS, this target was listed in this rule
+             more than once.  Just give a warning since this is harmless.  */
+          if (cmds != 0 && cmds == f->cmds)
+            OS (error, flocp,
+                _("target '%s' given more than once in the same rule"),
+                f->name);
+          /* Check for two single-colon entries both with commands.
+             Check is_target so that we don't lose on files such as .c.o
+             whose commands were preinitialized.  */
+          else if (cmds != 0 && f->cmds != 0 && f->is_target)
+            {
+              size_t l = strlen (f->name);
+              error (&cmds->fileinfo, l,
+                     _("warning: overriding recipe for target '%s'"),
                      f->name);
               error (&f->cmds->fileinfo,
                      _("warning: ignoring old recipe for target `%s'"),
+              error (&f->cmds->fileinfo, l,
+                     _("warning: ignoring old recipe for target '%s'"),
                      f->name);
+            }
           /* Defining .DEFAULT with no deps or cmds clears it.  */
           if (f == default_file && this == 0 && cmds == 0)
             f->cmds = 0;
           if (cmds != 0)
             f->cmds = cmds;
           /* Defining .SUFFIXES with no dependencies clears out the list of
              suffixes.  */
           if (f == suffix_file && this == 0)
+            {
+            }
+          /* Defining .DEFAULT with no deps or cmds clears it.  */
+          if (f == default_file && this == 0 && cmds == 0)
+            f->cmds = 0;
+          if (cmds != 0)
+            f->cmds = cmds;
+          /* Defining .SUFFIXES with no dependencies clears out the list of
+             suffixes.  */
+          if (f == suffix_file && this == 0)
+            {
               free_dep_chain (f->deps);
               f->deps = 0;
+            }
+        }
+              f->deps = 0;
+            }
+        }
       else
+        {
           /* Double-colon.  Make a new record even if there already is one.  */
           f = lookup_file (name);
           /* Check for both : and :: rules.  Check is_target so we don't lose
              on default suffix rules or makefiles.  */
           if (f != 0 && f->is_target && !f->double_colon)
             fatal (flocp,
                    _("target file `%s' has both : and :: entries"), f->name);
           f = enter_file (strcache_add (name));
           /* If there was an existing entry and it was a double-colon entry,
              enter_file will have returned a new one, making it the prev
              pointer of the old one, and setting its double_colon pointer to
              the first one.  */
           if (f->double_colon == 0)
             /* This is the first entry for this name, so we must set its
                double_colon pointer to itself.  */
             f->double_colon = f;
           f->cmds = cmds;
+        }
+        {
+          /* Double-colon.  Make a new record even if there already is one.  */
+          f = lookup_file (name);
+          /* Check for both : and :: rules.  Check is_target so we don't lose
+             on default suffix rules or makefiles.  */
+          if (f != 0 && f->is_target && !f->double_colon)
+            OS (fatal, flocp,
+                _("target file '%s' has both : and :: entries"), f->name);
+          f = enter_file (strcache_add (name));
+          /* If there was an existing entry and it was a double-colon entry,
+             enter_file will have returned a new one, making it the prev
+             pointer of the old one, and setting its double_colon pointer to
+             the first one.  */
+          if (f->double_colon == 0)
+            /* This is the first entry for this name, so we must set its
+               double_colon pointer to itself.  */
+            f->double_colon = f;
+          f->cmds = cmds;
+        }
       f->is_target = 1;
       /* If this is a static pattern rule, set the stem to the part of its
          name that matched the `%' in the pattern, so you can use $* in the
+         name that matched the '%' in the pattern, so you can use $* in the
          commands.  If we didn't do it before, enter the prereqs now.  */
       if (pattern)
 …
       name = filenames->name;
       if (find_percent_cached (&name))
+        fatal (flocp, _("mixed implicit and normal rules"));
+        O (error, flocp,
+           _("*** mixed implicit and normal rules: deprecated syntax"));
+    }
+}
 …
 static char *
+find_char_unquote (char *string, int stop1, int stop2, int blank,
+                   int ignorevars)
+find_char_unquote (char *string, int map)
+{
   unsigned int string_len = 0;
   char *p = string;
   if (ignorevars)
     ignorevars = '$';
+  /* Always stop on NUL.  */
+  map |= MAP_NUL;
   while (1)
+    {
+      if (stop2 && blank)
+        while (*p != '\0' && *p != ignorevars && *p != stop1 && *p != stop2
+               && ! isblank ((unsigned char) *p))
+          ++p;
+      else if (stop2)
+        while (*p != '\0' && *p != ignorevars && *p != stop1 && *p != stop2)
+          ++p;
+      else if (blank)
+        while (*p != '\0' && *p != ignorevars && *p != stop1
+               && ! isblank ((unsigned char) *p))
+          ++p;
+      else
+        while (*p != '\0' && *p != ignorevars && *p != stop1)
+          ++p;
+      while (! STOP_SET (*p, map))
+        ++p;
       if (*p == '\0')
         break;
+        break;
       /* If we stopped due to a variable reference, skip over its contents.  */
       if (*p == ignorevars)
+      if (STOP_SET (*p, MAP_VARIABLE))
+        {
           char openparen = p[1];
+          /* Check if '$' is the last character in the string.  */
+          if (openparen == '\0')
+            break;
           p += 2;
 …
       if (p > string && p[-1] == '\\')
+        {
           /* Search for more backslashes.  */
           int i = -2;
           while (&p[i] >= string && p[i] == '\\')
             --i;
           ++i;
           /* Only compute the length if really needed.  */
           if (string_len == 0)
             string_len = strlen (string);
           /* The number of backslashes is now -I.
              Copy P over itself to swallow half of them.  */
           memmove (&p[i], &p[i/2], (string_len - (p - string)) - (i/2) + 1);
           p += i/2;
           if (i % 2 == 0)
             /* All the backslashes quoted each other; the STOPCHAR was
                unquoted.  */
             return p;
           /* The STOPCHAR was quoted by a backslash.  Look for another.  */
+        }
+        {
+          /* Search for more backslashes.  */
+          int i = -2;
+          while (&p[i] >= string && p[i] == '\\')
+            --i;
+          ++i;
+          /* Only compute the length if really needed.  */
+          if (string_len == 0)
+            string_len = strlen (string);
+          /* The number of backslashes is now -I.
+             Copy P over itself to swallow half of them.  */
+          memmove (&p[i], &p[i/2], (string_len - (p - string)) - (i/2) + 1);
+          p += i/2;
+          if (i % 2 == 0)
+            /* All the backslashes quoted each other; the STOPCHAR was
+               unquoted.  */
+            return p;
+          /* The STOPCHAR was quoted by a backslash.  Look for another.  */
+        }
       else
         /* No backslash in sight.  */
         return p;
+        /* No backslash in sight.  */
+        return p;
+    }
 …
+}
+/* Unescape a character in a string.  The string is compressed onto itself.  */
+static char *
+unescape_char (char *string, int c)
+{
+  char *p = string;
+  char *s = string;
+  while (*s != '\0')
+    {
+      if (*s == '\\')
+        {
+          char *e = s;
+          int l;
+          /* We found a backslash.  See if it's escaping our character.  */
+          while (*e == '\\')
+            ++e;
+          l = e - s;
+          if (*e != c || l%2 == 0)
+            {
+              /* It's not; just take it all without unescaping.  */
+              memmove (p, s, l);
+              p += l;
+              // If we hit the end of the string, we're done
+              if (*e == '\0')
+                break;
+            }
+          else if (l > 1)
+            {
+              /* It is, and there's >1 backslash.  Take half of them.  */
+              l /= 2;
+              memmove (p, s, l);
+              p += l;
+            }
+          s = e;
+        }
+      *(p++) = *(s++);
+    }
+  *p = '\0';
+  return string;
+}
 /* Search PATTERN for an unquoted % and handle quoting.  */
 …
 find_percent (char *pattern)
+{
   return find_char_unquote (pattern, '%', 0, 0, 0);
+  return find_char_unquote (pattern, MAP_PERCENT);
+}
 …
   while (1)
+    {
       while (*p != '\0' && *p != '%')
+      while (! STOP_SET (*p, MAP_PERCENT|MAP_NUL))
         ++p;
 …
  */
 static unsigned long
+static long
 readstring (struct ebuffer *ebuf)
+{
 …
       len = strlen (p);
       if (len == 0)
+        {
           /* This only happens when the first thing on the line is a '\0'.
              It is a pretty hopeless case, but (wonder of wonders) Athena
              lossage strikes again!  (xmkmf puts NULs in its makefiles.)
              There is nothing really to be done; we synthesize a newline so
              the following line doesn't appear to be part of this line.  */
           error (&ebuf->floc,
                  _("warning: NUL character seen; rest of line ignored"));
           p[0] = '\n';
           len = 1;
+        }
+        {
+          /* This only happens when the first thing on the line is a '\0'.
+             It is a pretty hopeless case, but (wonder of wonders) Athena
+             lossage strikes again!  (xmkmf puts NULs in its makefiles.)
+             There is nothing really to be done; we synthesize a newline so
+             the following line doesn't appear to be part of this line.  */
+          O (error, &ebuf->floc,
+             _("warning: NUL character seen; rest of line ignored"));
+          p[0] = '\n';
+          len = 1;
+        }
       /* Jump past the text we just read.  */
 …
+        {
           --p;
           p[-1] = '\n';
+          memmove (p-1, p, strlen (p) + 1);
+        }
 #endif
 …
       backslash = 0;
       for (p2 = p - 2; p2 >= start; --p2)
+        {
           if (*p2 != '\\')
             break;
+        {
+          if (*p2 != '\\')
+            break;
           backslash = !backslash;
+        }
+        }
       if (!backslash)
+        {
           p[-1] = '\0';
           break;
+        }
+        {
+          p[-1] = '\0';
+          break;
+        }
       /* It was a backslash/newline combo.  If we have more space, read
 …
      w_dcolon       A double-colon
      w_semicolon    A semicolon
      w_varassign    A variable assignment operator (=, :=, +=, or ?=)
+     w_varassign    A variable assignment operator (=, :=, ::=, +=, ?=, or !=)
    Note that this function is only used when reading certain parts of the
 …
   /* Skip any leading whitespace.  */
   while (isblank ((unsigned char)*p))
+  while (ISBLANK (*p))
     ++p;
 …
         case ':':
           ++p;
+          wtype = w_dcolon;
+          if (p[1] != '=')
+            wtype = w_dcolon;
+          else
+            {
+              wtype = w_varassign;
+              ++p;
+            }
           break;
 …
     case '+':
     case '?':
+    case '!':
       if (*p == '=')
+        {
 …
   /* This is some non-operator word.  A word consists of the longest
      string of characters that doesn't contain whitespace, one of [:=#],
      or [?+]=, or one of the chars in the DELIM string.  */
+     or [?+!]=, or one of the chars in the DELIM string.  */
   /* We start out assuming a static word; if we see a variable we'll
 …
         case ':':
 #ifdef HAVE_DOS_PATHS
           /* A word CAN include a colon in its drive spec.  The drive
              spec is allowed either at the beginning of a word, or as part
              of the archive member name, like in "libfoo.a(d:/foo/bar.o)".  */
           if (!(p - beg >= 2
                 && (*p == '/' || *p == '\\') && isalpha ((unsigned char)p[-2])
                 && (p - beg == 2 || p[-3] == '(')))
+          /* A word CAN include a colon in its drive spec.  The drive
+             spec is allowed either at the beginning of a word, or as part
+             of the archive member name, like in "libfoo.a(d:/foo/bar.o)".  */
+          if (!(p - beg >= 2
+                && (*p == '/' || *p == '\\') && isalpha ((unsigned char)p[-2])
+                && (p - beg == 2 || p[-3] == '(')))
 #endif
           goto done_word;
+          goto done_word;
         case '$':
 …
           if (c == '$')
             break;
+          if (c == '\0')
+            goto done_word;
           /* This is a variable reference, so note that it's expandable.
 …
 construct_include_path (const char **arg_dirs)
+{
 #ifdef VAXC             /* just don't ask ... */
+#ifdef VAXC             /* just don't ask ... */
   stat_t stbuf;
 #else
 …
     while (*arg_dirs != 0)
+      {
         const char *dir = *(arg_dirs++);
+        const char *dir = *(arg_dirs++);
         char *expanded = 0;
         int e;
         if (dir[0] == '~')
+          {
             expanded = tilde_expand (dir);
             if (expanded != 0)
               dir = expanded;
+          }
+        if (dir[0] == '~')
+          {
+            expanded = tilde_expand (dir);
+            if (expanded != 0)
+              dir = expanded;
+          }
         EINTRLOOP (e, stat (dir, &stbuf));
         if (e == 0 && S_ISDIR (stbuf.st_mode))
+        if (e == 0 && S_ISDIR (stbuf.st_mode))
+          {
             unsigned int len = strlen (dir);
 …
+          }
+        if (expanded)
+          free (expanded);
+        free (expanded);
+      }
 …
+      {
         unsigned int len = strlen (djdir->value) + 8;
         char *defdir = alloca (len + 1);
         strcat (strcpy (defdir, djdir->value), "/include");
         dirs[idx++] = strcache_add (defdir);
+        char *defdir = alloca (len + 1);
+        strcat (strcpy (defdir, djdir->value), "/include");
+        dirs[idx++] = strcache_add (defdir);
         if (len > max_incl_len)
 …
   if (name[1] == '/' || name[1] == '\0')
+    {
-      extern char *getenv ();
       char *home_dir;
       int is_variable;
+      {
         /* Turn off --warn-undefined-variables while we expand HOME.  */
         int save = warn_undefined_variables_flag;
         warn_undefined_variables_flag = 0;
         home_dir = allocated_variable_expand ("$(HOME)");
         warn_undefined_variables_flag = save;
+        /* Turn off --warn-undefined-variables while we expand HOME.  */
+        int save = warn_undefined_variables_flag;
+        warn_undefined_variables_flag = 0;
+        home_dir = allocated_variable_expand ("$(HOME)");
+        warn_undefined_variables_flag = save;
+      }
       is_variable = home_dir[0] != '\0';
       if (!is_variable)
+        {
           free (home_dir);
           home_dir = getenv ("HOME");
+        }
+        {
+          free (home_dir);
+          home_dir = getenv ("HOME");
+        }
 # if !defined(_AMIGA) && !defined(WINDOWS32)
       if (home_dir == 0 || home_dir[0] == '\0')
+        {
+          extern char *getlogin ();
+          char *logname = getlogin ();
+          home_dir = 0;
+          if (logname != 0)
+            {
+              struct passwd *p = getpwnam (logname);
+              if (p != 0)
+                home_dir = p->pw_dir;
+            }
+        }
+        {
+          char *logname = getlogin ();
+          home_dir = 0;
+          if (logname != 0)
+            {
+              struct passwd *p = getpwnam (logname);
+              if (p != 0)
+                home_dir = p->pw_dir;
+            }
+        }
 # endif /* !AMIGA && !WINDOWS32 */
       if (home_dir != 0)
+        {
           char *new = xstrdup (concat (2, home_dir, name + 1));
           if (is_variable)
             free (home_dir);
           return new;
+        }
+        {
+          char *new = xstrdup (concat (2, home_dir, name + 1));
+          if (is_variable)
+            free (home_dir);
+          return new;
+        }
+    }
 # if !defined(_AMIGA) && !defined(WINDOWS32)
 …
       char *userend = strchr (name + 1, '/');
       if (userend != 0)
         *userend = '\0';
+        *userend = '\0';
       pwent = getpwnam (name + 1);
       if (pwent != 0)
+        {
           if (userend == 0)
             return xstrdup (pwent->pw_dir);
           else
             return xstrdup (concat (3, pwent->pw_dir, "/", userend + 1));
+        }
+        {
+          if (userend == 0)
+            return xstrdup (pwent->pw_dir);
+          else
+            return xstrdup (concat (3, pwent->pw_dir, "/", userend + 1));
+        }
       else if (userend != 0)
         *userend = '/';
+        *userend = '/';
+    }
 # endif /* !AMIGA && !WINDOWS32 */
 …
 void *
 parse_file_seq (char **stringp, unsigned int size, int stopchar,
+parse_file_seq (char **stringp, unsigned int size, int stopmap,
                 const char *prefix, int flags)
+{
-  extern void dir_setup_glob (glob_t *glob);
   /* tmp points to tmpbuf after the prefix, if any.
      tp is the end of the buffer. */
   static char *tmpbuf = NULL;
+  static int tmpbuf_len = 0;
+  int cachep = (! (flags & PARSEFS_NOCACHE));
+  int cachep = NONE_SET (flags, PARSEFS_NOCACHE);
   struct nameseq *new = 0;
 …
   char *tp;
+#ifdef VMS
+# define VMS_COMMA ','
+#else
+# define VMS_COMMA 0
+#endif
+  /* Always stop on NUL.  */
+  stopmap |= MAP_NUL;
   if (size < sizeof (struct nameseq))
     size = sizeof (struct nameseq);
   if (! (flags & PARSEFS_NOGLOB))
+  if (NONE_SET (flags, PARSEFS_NOGLOB))
     dir_setup_glob (&gl);
   /* Get enough temporary space to construct the largest possible target.  */
+  {
+    static int tmpbuf_len = 0;
     int l = strlen (*stringp) + 1;
     if (l > tmpbuf_len)
 …
       const char **nlist = 0;
       char *tildep = 0;
+      int globme = 1;
 #ifndef NO_ARCHIVES
       char *arname = 0;
 …
       /* Skip whitespace; at the end of the string or STOPCHAR we're done.  */
       p = next_token (p);
       if (*p == '\0' || *p == stopchar)
         break;
+      NEXT_TOKEN (p);
+      if (STOP_SET (*p, stopmap))
+        break;
       /* There are names left, so find the end of the next name.
          Throughout this iteration S points to the start.  */
       s = p;
       p = find_char_unquote (p, stopchar, VMS_COMMA, 1, 0);
+      p = find_char_unquote (p, stopmap|MAP_VMSCOMMA|MAP_BLANK);
 #ifdef VMS
         /* convert comma separated list to space separated */
+        /* convert comma separated list to space separated */
       if (p && *p == ',')
         *p =' ';
+        *p =' ';
 #endif
 #ifdef _AMIGA
+      if (stopchar == ':' && p && *p == ':'
+          && !(isspace ((unsigned char)p[1]) || !p[1]
+               || isspace ((unsigned char)p[-1])))
+        p = find_char_unquote (p+1, stopchar, VMS_COMMA, 1, 0);
+      if (p && STOP_SET (*p, stopmap & MAP_COLON)
+          && !(ISSPACE (p[1]) || !p[1] || ISSPACE (p[-1])))
+        p = find_char_unquote (p+1, stopmap|MAP_VMSCOMMA|MAP_BLANK);
 #endif
 #ifdef HAVE_DOS_PATHS
 …
        Note that tokens separated by spaces should be treated as separate
        tokens since make doesn't allow path names with spaces */
     if (stopchar == ':')
       while (p != 0 && !isspace ((unsigned char)*p) &&
+    if (stopmap | MAP_COLON)
+      while (p != 0 && !ISSPACE (*p) &&
              (p[1] == '\\' || p[1] == '/') && isalpha ((unsigned char)p[-1]))
         p = find_char_unquote (p + 1, stopchar, VMS_COMMA, 1, 0);
+        p = find_char_unquote (p + 1, stopmap|MAP_VMSCOMMA|MAP_BLANK);
 #endif
       if (p == 0)
         p = s + strlen (s);
+        p = s + strlen (s);
       /* Strip leading "this directory" references.  */
       if (! (flags & PARSEFS_NOSTRIP))
+      if (NONE_SET (flags, PARSEFS_NOSTRIP))
 #ifdef VMS
+        /* Skip leading `[]'s.  */
+        while (p - s > 2 && s[0] == '[' && s[1] == ']')
+#else
+        /* Skip leading `./'s.  */
+        while (p - s > 2 && s[0] == '.' && s[1] == '/')
+        /* Skip leading '[]'s. should only be one set or bug somwhere else */
+        if (p - s > 2 && s[0] == '[' && s[1] == ']')
+            s += 2;
+        /* Skip leading '<>'s. should only be one set or bug somwhere else */
+        if (p - s > 2 && s[0] == '<' && s[1] == '>')
+            s += 2;
 #endif
+          {
+        /* Skip leading './'s.  */
+        while (p - s > 2 && s[0] == '.' && s[1] == '/')
+          {
             /* Skip "./" and all following slashes.  */
             s += 2;
             while (*s == '/')
               ++s;
+          }
+            s += 2;
+            while (*s == '/')
+              ++s;
+          }
       /* Extract the filename just found, and skip it.
 …
       if (s == p)
+        {
+        /* The name was stripped to empty ("./"). */
+#if defined(VMS)
+          continue;
+#elif defined(_AMIGA)
+        /* The name was stripped to empty ("./"). */
+#if defined(_AMIGA)
           /* PDS-- This cannot be right!! */
           tp[0] = '\0';
 …
+        }
       else
+        {
+        {
 #ifdef VMS
 /* VMS filenames can have a ':' in them but they have to be '\'ed but we need
 …
  * xstrdup called because S may be read-only string constant.
  */
           char *n = tp;
           while (s < p)
+            {
               if (s[0] == '\\' && s[1] == ':')
+          char *n = tp;
+          while (s < p)
+            {
+              if (s[0] == '\\' && s[1] == ':')
                 ++s;
               *(n++) = *(s++);
+            }
+              *(n++) = *(s++);
+            }
           n[0] = '\0';
           nlen = strlen (tp);
 …
          TP == TMP means we're not already in an archive group.  Ignore
          something starting with `(', as that cannot actually be an
+         something starting with '(', as that cannot actually be an
          archive-member reference (and treating it as such results in an empty
          file name, which causes much lossage).  Also if it ends in ")" then
 …
          character, so ensure there's some word ending like that before
          considering this an archive group.  */
       if (! (flags & PARSEFS_NOAR)
+      if (NONE_SET (flags, PARSEFS_NOAR)
           && tp == tmpbuf && tp[0] != '(' && tp[nlen-1] != ')')
+        {
 …
               /* This looks like the first element in an open archive group.
                  A valid group MUST have ')' as the last character.  */
               const char *e = p + nlen;
+              const char *e = p;
               do
+                {
+                  e = next_token (e);
+                  const char *o = e;
+                  NEXT_TOKEN (e);
                   /* Find the end of this word.  We don't want to unquote and
                      we don't care about quoting since we're looking for the
                      last char in the word. */
+                  while (*e != '\0' && *e != stopchar && *e != VMS_COMMA
+                         && ! isblank ((unsigned char) *e))
+                  while (! STOP_SET (*e, stopmap|MAP_BLANK|MAP_VMSCOMMA))
                     ++e;
+                  /* If we didn't move, we're done now.  */
+                  if (e == o)
+                    break;
                   if (e[-1] == ')')
+                    {
 …
                       tp = n + 1;
-                      /* If we have just "lib(", part of something like
-                         "lib( a b)", go to the next item.  */
-                      if (! nlen)
-                        continue;
                       /* We can stop looking now.  */
                       break;
 …
+                }
               while (*e != '\0');
+              /* If we have just "lib(", part of something like "lib( a b)",
+                 go to the next item.  */
+              if (! nlen)
+                continue;
+            }
+        }
 …
       /* If we're not globbing we're done: add it to the end of the chain.
          Go to the next item in the string.  */
       if (flags & PARSEFS_NOGLOB)
+        {
           NEWELT (concat (2, prefix, tp));
+      if (ANY_SET (flags, PARSEFS_NOGLOB))
+        {
+          NEWELT (concat (2, prefix, tmpbuf));
           continue;
+        }
 …
          TP is a string in tmpbuf.  NLEN is no longer used.
          We may need to do more work: after this NAME will be set.  */
       name = tp;
+      name = tmpbuf;
       /* Expand tilde if applicable.  */
       if (tp[0] == '~')
+        {
           tildep = tilde_expand (tp);
           if (tildep != 0)
+      if (tmpbuf[0] == '~')
+        {
+          tildep = tilde_expand (tmpbuf);
+          if (tildep != 0)
             name = tildep;
+        }
+        }
 #ifndef NO_ARCHIVES
 …
          file name, and save the member name in MEMNAME.  We will glob on the
          archive name and then reattach MEMNAME later.  */
       if (! (flags & PARSEFS_NOAR) && ar_name (name))
+        {
           ar_parse_name (name, &arname, &memname);
           name = arname;
+        }
+      if (NONE_SET (flags, PARSEFS_NOAR) && ar_name (name))
+        {
+          ar_parse_name (name, &arname, &memname);
+          name = arname;
+        }
 #endif /* !NO_ARCHIVES */
+      switch (glob (name, GLOB_NOSORT|GLOB_ALTDIRFUNC, NULL, &gl))
+        {
+        case GLOB_NOSPACE:
+          fatal (NILF, _("virtual memory exhausted"));
+        case 0:
+          /* Success.  */
+          i = gl.gl_pathc;
+          nlist = (const char **)gl.gl_pathv;
+          break;
+        case GLOB_NOMATCH:
+          /* If we want only existing items, skip this one.  */
+          if (flags & PARSEFS_EXISTS)
+            {
+              i = 0;
+              break;
+            }
+          /* FALLTHROUGH */
+        default:
+          /* By default keep this name.  */
+      /* glob() is expensive: don't call it unless we need to.  */
+      if (NONE_SET (flags, PARSEFS_EXISTS) && strpbrk (name, "?*[") == NULL)
+        {
+          globme = 0;
           i = 1;
           nlist = &name;
+          break;
+        }
+        }
+      else
+        switch (glob (name, GLOB_NOSORT|GLOB_ALTDIRFUNC, NULL, &gl))
+          {
+          case GLOB_NOSPACE:
+            OUT_OF_MEM();
+          case 0:
+            /* Success.  */
+            i = gl.gl_pathc;
+            nlist = (const char **)gl.gl_pathv;
+            break;
+          case GLOB_NOMATCH:
+            /* If we want only existing items, skip this one.  */
+            if (ANY_SET (flags, PARSEFS_EXISTS))
+              {
+                i = 0;
+                break;
+              }
+            /* FALLTHROUGH */
+          default:
+            /* By default keep this name.  */
+            i = 1;
+            nlist = &name;
+            break;
+          }
       /* For each matched element, add it to the list.  */
 …
+              {
                 /* We got a chain of items.  Attach them.  */
+                (*newp)->next = found;
+                if (*newp)
+                  (*newp)->next = found;
+                else
+                  *newp = found;
                 /* Find and set the new end.  Massage names if necessary.  */
 …
           NEWELT (concat (2, prefix, nlist[i]));
+      globfree (&gl);
+      if (globme)
+        globfree (&gl);
 #ifndef NO_ARCHIVES
+      if (arname)
+        free (arname);
+      free (arname);
 #endif
+      if (tildep)
+        free (tildep);
+      free (tildep);
+    }

vendor/gnumake/current/remake.c

-              r2596
+              r3138
 /* Basic dependency engine for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include "filedef.h"
 #include "job.h"
 …
 #endif
-extern int try_implicit_rule (struct file *file, unsigned int depth);
 /* The test for circular dependencies is based on the 'updating' bit in
    `struct file'.  However, double colon targets have seperate `struct
+   'struct file'.  However, double colon targets have separate 'struct
    file's; make sure we always use the base of the double colon chain. */
 …
 unsigned int commands_started = 0;
+/* Current value for pruning the scan of the goal chain (toggle 0/1).  */
+static unsigned int considered;
+static int update_file (struct file *file, unsigned int depth);
+static int update_file_1 (struct file *file, unsigned int depth);
+static int check_dep (struct file *file, unsigned int depth,
+                      FILE_TIMESTAMP this_mtime, int *must_make_ptr);
+static int touch_file (struct file *file);
+/* Set to the goal dependency.  Mostly needed for remaking makefiles.  */
+static struct goaldep *goal_list;
+static struct dep *goal_dep;
+/* Current value for pruning the scan of the goal chain.
+   All files start with considered == 0.  */
+static unsigned int considered = 0;
+static enum update_status update_file (struct file *file, unsigned int depth);
+static enum update_status update_file_1 (struct file *file, unsigned int depth);
+static enum update_status check_dep (struct file *file, unsigned int depth,
+                                     FILE_TIMESTAMP this_mtime, int *must_make);
+static enum update_status touch_file (struct file *file);
 static void remake_file (struct file *file);
 static FILE_TIMESTAMP name_mtime (const char *name);
 …
 /* Remake all the goals in the `struct dep' chain GOALS.  Return -1 if nothing
+/* Remake all the goals in the 'struct dep' chain GOALS.  Return -1 if nothing
    was done, 0 if all goals were updated successfully, or 1 if a goal failed.
 …
    and -n should be disabled for them unless they were also command-line
    targets, and we should only make one goal at a time and return as soon as
    one goal whose `changed' member is nonzero is successfully made.  */
+int
 update_goal_chain (struct dep *goals)
+   one goal whose 'changed' member is nonzero is successfully made.  */
+enum update_status
+update_goal_chain (struct goaldep *goaldeps)
+{
   int t = touch_flag, q = question_flag, n = just_print_flag;
+  int status = -1;
+#define MTIME(file) (rebuilding_makefiles ? file_mtime_no_search (file) \
+                     : file_mtime (file))
+  enum update_status status = us_none;
   /* Duplicate the chain so we can remove things from it.  */
+  goals = copy_dep_chain (goals);
+  {
+    /* Clear the `changed' flag of each goal in the chain.
+       We will use the flag below to notice when any commands
+       have actually been run for a target.  When no commands
+       have been run, we give an "up to date" diagnostic.  */
+    struct dep *g;
+    for (g = goals; g != 0; g = g->next)
+      g->changed = 0;
+  }
+  /* All files start with the considered bit 0, so the global value is 1.  */
+  considered = 1;
+  struct dep *goals = copy_dep_chain ((struct dep *)goaldeps);
+  goal_list = rebuilding_makefiles ? goaldeps : NULL;
+#define MTIME(file) (rebuilding_makefiles ? file_mtime_no_search (file) \
+                     : file_mtime (file))
+  /* Start a fresh batch of consideration.  */
+  ++considered;
   /* Update all the goals until they are all finished.  */
 …
       g = goals;
       while (g != 0)
+        {
+          /* Iterate over all double-colon entries for this file.  */
+          struct file *file;
+          int stop = 0, any_not_updated = 0;
+          for (file = g->file->double_colon ? g->file->double_colon : g->file;
+               file != NULL;
+               file = file->prev)
+            {
+              unsigned int ocommands_started;
+              int x;
+              file->dontcare = g->dontcare;
+              check_renamed (file);
+              if (rebuilding_makefiles)
+                {
+                  if (file->cmd_target)
+                    {
+                      touch_flag = t;
+                      question_flag = q;
+                      just_print_flag = n;
+                    }
+                  else
+                    touch_flag = question_flag = just_print_flag = 0;
+                }
+              /* Save the old value of `commands_started' so we can compare
+                 later.  It will be incremented when any commands are
+                 actually run.  */
+              ocommands_started = commands_started;
+              x = update_file (file, rebuilding_makefiles ? 1 : 0);
+              check_renamed (file);
+              /* Set the goal's `changed' flag if any commands were started
+                 by calling update_file above.  We check this flag below to
+                 decide when to give an "up to date" diagnostic.  */
+        {
+          /* Iterate over all double-colon entries for this file.  */
+          struct file *file;
+          int stop = 0, any_not_updated = 0;
+          goal_dep = g;
+          for (file = g->file->double_colon ? g->file->double_colon : g->file;
+               file != NULL;
+               file = file->prev)
+            {
+              unsigned int ocommands_started;
+              enum update_status fail;
+              file->dontcare = ANY_SET (g->flags, RM_DONTCARE);
+              check_renamed (file);
+              if (rebuilding_makefiles)
+                {
+                  if (file->cmd_target)
+                    {
+                      touch_flag = t;
+                      question_flag = q;
+                      just_print_flag = n;
+                    }
+                  else
+                    touch_flag = question_flag = just_print_flag = 0;
+                }
+              /* Save the old value of 'commands_started' so we can compare
+                 later.  It will be incremented when any commands are
+                 actually run.  */
+              ocommands_started = commands_started;
+              fail = update_file (file, rebuilding_makefiles ? 1 : 0);
+              check_renamed (file);
+              /* Set the goal's 'changed' flag if any commands were started
+                 by calling update_file above.  We check this flag below to
+                 decide when to give an "up to date" diagnostic.  */
               if (commands_started > ocommands_started)
                 g->changed = 1;
+              /* If we updated a file and STATUS was not already 1, set it to
+if updating failed, or to 0 if updating succeeded.  Leave
+                 STATUS as it is if no updating was done.  */
+              stop = 0;
+              if ((x != 0 || file->updated) && status < 1)
+              stop = 0;
+              if ((fail || file->updated) && status < us_question)
+                {
+                  if (file->update_status != 0)
+                  /* We updated this goal.  Update STATUS and decide whether
+                     to stop.  */
+                  if (file->update_status)
+                    {
                       /* Updating failed, or -q triggered.  The STATUS value
 …
                           if (!rebuilding_makefiles
                               || (!just_print_flag && !question_flag))
                             status = 0;
+                            status = us_success;
                           if (rebuilding_makefiles && file->dontcare)
                             /* This is a default makefile; stop remaking.  */
 …
+                }
               /* Keep track if any double-colon entry is not finished.
+              /* Keep track if any double-colon entry is not finished.
                  When they are all finished, the goal is finished.  */
               any_not_updated |= !file->updated;
+              any_not_updated |= !file->updated;
               file->dontcare = 0;
               if (stop)
                 break;
+            }
           /* Reset FILE since it is null at the end of the loop.  */
           file = g->file;
           if (stop || !any_not_updated)
+            {
               /* If we have found nothing whatever to do for the goal,
                  print a message saying nothing needs doing.  */
               if (!rebuilding_makefiles
                   /* If the update_status is zero, we updated successfully
                      or not at all.  G->changed will have been set above if
                      any commands were actually started for this goal.  */
                   && file->update_status == 0 && !g->changed
                   /* Never give a message under -s or -q.  */
                   && !silent_flag && !question_flag)
                 message (1, ((file->phony || file->cmds == 0)
                              ? _("Nothing to be done for `%s'.")
                              : _("`%s' is up to date.")),
                          file->name);
               /* This goal is finished.  Remove it from the chain.  */
               if (lastgoal == 0)
                 goals = g->next;
               else
                 lastgoal->next = g->next;
               /* Free the storage.  */
               free (g);
               g = lastgoal == 0 ? goals : lastgoal->next;
               if (stop)
                 break;
+            }
           else
+            {
               lastgoal = g;
               g = g->next;
+            }
+        }
       /* If we reached the end of the dependency graph toggle the considered
          flag for the next pass.  */
+              if (stop)
+                break;
+            }
+          /* Reset FILE since it is null at the end of the loop.  */
+          file = g->file;
+          if (stop || !any_not_updated)
+            {
+              /* If we have found nothing whatever to do for the goal,
+                 print a message saying nothing needs doing.  */
+              if (!rebuilding_makefiles
+                  /* If the update_status is success, we updated successfully
+                     or not at all.  G->changed will have been set above if
+                     any commands were actually started for this goal.  */
+                  && file->update_status == us_success && !g->changed
+                  /* Never give a message under -s or -q.  */
+                  && !silent_flag && !question_flag)
+                OS (message, 1, ((file->phony || file->cmds == 0)
+                                 ? _("Nothing to be done for '%s'.")
+                                 : _("'%s' is up to date.")),
+                    file->name);
+              /* This goal is finished.  Remove it from the chain.  */
+              if (lastgoal == 0)
+                goals = g->next;
+              else
+                lastgoal->next = g->next;
+              /* Free the storage.  */
+              free (g);
+              g = lastgoal == 0 ? goals : lastgoal->next;
+              if (stop)
+                break;
+            }
+          else
+            {
+              lastgoal = g;
+              g = g->next;
+            }
+        }
+      /* If we reached the end of the dependency graph update CONSIDERED
+         for the next pass.  */
       if (g == 0)
         considered = !considered;
+        ++considered;
+    }
 …
+/* If we're rebuilding an included makefile that failed, and we care
+   about errors, show an error message the first time.  */
+void
+show_goal_error (void)
+{
+  struct goaldep *goal;
+  if ((goal_dep->flags & (RM_INCLUDED|RM_DONTCARE)) != RM_INCLUDED)
+    return;
+  for (goal = goal_list; goal; goal = goal->next)
+    if (goal_dep->file == goal->file)
+      {
+        if (goal->error)
+          {
+            OSS (error, &goal->floc, "%s: %s",
+                 goal->file->name, strerror ((int)goal->error));
+            goal->error = 0;
+          }
+        return;
+      }
+}
 /* If FILE is not up to date, execute the commands for it.
    Return 0 if successful, 1 if unsuccessful;
    but with some flag settings, just call `exit' if unsuccessful.
+   Return 0 if successful, non-0 if unsuccessful;
+   but with some flag settings, just call 'exit' if unsuccessful.
    DEPTH is the depth in recursions of this function.
 …
    each is considered in turn.  */
 static int
+static enum update_status
 update_file (struct file *file, unsigned int depth)
+{
   register int status = 0;
   register struct file *f;
+  enum update_status status = us_success;
+  struct file *f;
   f = file->double_colon ? file->double_colon : file;
 …
+    {
       /* Check for the case where a target has been tried and failed but
          the diagnostics hasn't been issued. If we need the diagnostics
+         the diagnostics haven't been issued. If we need the diagnostics
          then we will have to continue. */
+      if (!(f->updated && f->update_status > 0 && !f->dontcare && f->no_diag))
+        {
+          DBF (DB_VERBOSE, _("Pruning file `%s'.\n"));
+          return f->command_state == cs_finished ? f->update_status : 0;
+      if (!(f->updated && f->update_status > us_none
+            && !f->dontcare && f->no_diag))
+        {
+          DBF (DB_VERBOSE, _("Pruning file '%s'.\n"));
+          return f->command_state == cs_finished ? f->update_status : us_success;
+        }
+    }
 …
   for (; f != 0; f = f->prev)
+    {
+      enum update_status new;
       f->considered = considered;
       status |= update_file_1 (f, depth);
+      new = update_file_1 (f, depth);
       check_renamed (f);
 …
       /* If we got an error, don't bother with double_colon etc.  */
       if (status != 0 && !keep_going_flag)
         return status;
+      if (new && !keep_going_flag)
+        return new;
       if (f->command_state == cs_running
           || f->command_state == cs_deps_running)
+        {
+          /* Don't run the other :: rules for this
+             file until this rule is finished.  */
+          status = 0;
           break;
+        }
+        /* Don't run other :: rules for this target until
+           this rule is finished.  */
+        return us_success;
+      if (new > status)
+        status = new;
+    }
 …
         for (d = f->deps; d != 0; d = d->next)
+          status |= update_file (d->file, depth + 1);
+          {
+            enum update_status new = update_file (d->file, depth + 1);
+            if (new > status)
+              status = new;
+          }
+      }
 …
 complain (struct file *file)
+{
-  const char *msg_noparent
-    = _("%sNo rule to make target `%s'%s");
-  const char *msg_parent
-    = _("%sNo rule to make target `%s', needed by `%s'%s");
   /* If this file has no_diag set then it means we tried to update it
      before in the dontcare mode and failed. The target that actually
 …
   for (d = file->deps; d != 0; d = d->next)
+    {
       if (d->file->updated && d->file->update_status > 0 && file->no_diag)
+      if (d->file->updated && d->file->update_status > us_none && file->no_diag)
+        {
           complain (d->file);
 …
   if (d == 0)
+    {
+      show_goal_error ();
       /* Didn't find any dependencies to complain about. */
       if (!keep_going_flag)
+        {
           if (file->parent == 0)
             fatal (NILF, msg_noparent, "", file->name, "");
           fatal (NILF, msg_parent, "", file->name, file->parent->name, "");
+        }
       if (file->parent == 0)
         error (NILF, msg_noparent, "*** ", file->name, ".");
+      if (file->parent)
+        {
+          size_t l = strlen (file->name) + strlen (file->parent->name) + 4;
+          const char *m = _("%sNo rule to make target '%s', needed by '%s'%s");
+          if (!keep_going_flag)
+            fatal (NILF, l, m, "", file->name, file->parent->name, "");
+          error (NILF, l, m, "*** ", file->name, file->parent->name, ".");
+        }
       else
+        error (NILF, msg_parent, "*** ", file->name, file->parent->name, ".");
+        {
+          size_t l = strlen (file->name) + 4;
+          const char *m = _("%sNo rule to make target '%s'%s");
+          if (!keep_going_flag)
+            fatal (NILF, l, m, "", file->name, "");
+          error (NILF, l, m, "*** ", file->name, ".");
+        }
       file->no_diag = 0;
 …
+}
+/* Consider a single `struct file' and update it as appropriate.  */
+static int
+/* Consider a single 'struct file' and update it as appropriate.
+   Return 0 on success, or non-0 on failure.  */
+static enum update_status
 update_file_1 (struct file *file, unsigned int depth)
+{
+  enum update_status dep_status = us_success;
   FILE_TIMESTAMP this_mtime;
   int noexist, must_make, deps_changed;
-  int dep_status = 0;
   struct file *ofile;
   struct dep *d, *ad;
 …
   int running = 0;
   DBF (DB_VERBOSE, _("Considering target file `%s'.\n"));
+  DBF (DB_VERBOSE, _("Considering target file '%s'.\n"));
   if (file->updated)
+    {
       if (file->update_status > 0)
+        {
           DBF (DB_VERBOSE,
                _("Recently tried and failed to update file `%s'.\n"));
+      if (file->update_status > us_none)
+        {
+          DBF (DB_VERBOSE,
+               _("Recently tried and failed to update file '%s'.\n"));
           /* If the file we tried to make is marked no_diag then no message
 …
               complain (file);
           return file->update_status;
+        }
       DBF (DB_VERBOSE, _("File `%s' was considered already.\n"));
+          return file->update_status;
+        }
+      DBF (DB_VERBOSE, _("File '%s' was considered already.\n"));
       return 0;
+    }
 …
       break;
     case cs_running:
       DBF (DB_VERBOSE, _("Still updating file `%s'.\n"));
+      DBF (DB_VERBOSE, _("Still updating file '%s'.\n"));
       return 0;
     case cs_finished:
       DBF (DB_VERBOSE, _("Finished updating file `%s'.\n"));
+      DBF (DB_VERBOSE, _("Finished updating file '%s'.\n"));
       return file->update_status;
     default:
 …
   noexist = this_mtime == NONEXISTENT_MTIME;
   if (noexist)
     DBF (DB_BASIC, _("File `%s' does not exist.\n"));
+    DBF (DB_BASIC, _("File '%s' does not exist.\n"));
   else if (ORDINARY_MTIME_MIN <= this_mtime && this_mtime <= ORDINARY_MTIME_MAX
            && file->low_resolution_time)
+           && file->low_resolution_time)
+    {
       /* Avoid spurious rebuilds due to low resolution time stamps.  */
       int ns = FILE_TIMESTAMP_NS (this_mtime);
       if (ns != 0)
+        error (NILF, _("*** Warning: .LOW_RESOLUTION_TIME file `%s' has a high resolution time stamp"),
+               file->name);
+        OS (error, NILF,
+            _("*** Warning: .LOW_RESOLUTION_TIME file '%s' has a high resolution time stamp"),
+            file->name);
       this_mtime += FILE_TIMESTAMPS_PER_S - 1 - ns;
+    }
 …
+    {
       if (try_implicit_rule (file, depth))
         DBF (DB_IMPLICIT, _("Found an implicit rule for `%s'.\n"));
+        DBF (DB_IMPLICIT, _("Found an implicit rule for '%s'.\n"));
       else
         DBF (DB_IMPLICIT, _("No implicit rule found for `%s'.\n"));
+        DBF (DB_IMPLICIT, _("No implicit rule found for '%s'.\n"));
       file->tried_implicit = 1;
+    }
 …
       && default_file != 0 && default_file->cmds != 0)
+    {
       DBF (DB_IMPLICIT, _("Using default recipe for `%s'.\n"));
+      DBF (DB_IMPLICIT, _("Using default recipe for '%s'.\n"));
       file->cmds = default_file->cmds;
+    }
 …
       while (d)
+        {
+          enum update_status new;
           FILE_TIMESTAMP mtime;
           int maybe_make;
 …
           if (is_updating (d->file))
+            {
               error (NILF, _("Circular %s <- %s dependency dropped."),
                      file->name, d->file->name);
+              OSS (error, NILF, _("Circular %s <- %s dependency dropped."),
+                   file->name, d->file->name);
               /* We cannot free D here because our the caller will still have
                  a reference to it when we were called recursively via
 …
+            }
+          dep_status |= check_dep (d->file, depth, this_mtime, &maybe_make);
+          new = check_dep (d->file, depth, this_mtime, &maybe_make);
+          if (new > dep_status)
+            dep_status = new;
           /* Restore original dontcare flag. */
 …
+          }
           if (dep_status != 0 && !keep_going_flag)
+          if (dep_status && !keep_going_flag)
             break;
           if (!running)
             /* The prereq is considered changed if the timestamp has changed while
                it was built, OR it doesn't exist.  */
+            /* The prereq is considered changed if the timestamp has changed
+               while it was built, OR it doesn't exist.  */
             d->changed = ((file_mtime (d->file) != mtime)
                           || (mtime == NONEXISTENT_MTIME));
 …
+    {
       for (d = file->deps; d != 0; d = d->next)
+        if (d->file->intermediate)
+          {
+        if (d->file->intermediate)
+          {
+            enum update_status new;
             int dontcare = 0;
             FILE_TIMESTAMP mtime = file_mtime (d->file);
             check_renamed (d->file);
             d->file->parent = file;
+            FILE_TIMESTAMP mtime = file_mtime (d->file);
+            check_renamed (d->file);
+            d->file->parent = file;
             /* Inherit dontcare flag from our parent. */
 …
+              }
+            dep_status |= update_file (d->file, depth);
+            /* We may have already considered this file, when we didn't know
+               we'd need to update it.  Force update_file() to consider it and
+               not prune it.  */
+            d->file->considered = 0;
+            new = update_file (d->file, depth);
+            if (new > dep_status)
+              dep_status = new;
             /* Restore original dontcare flag. */
 …
               d->file->dontcare = dontcare;
             check_renamed (d->file);
+            {
               register struct file *f = d->file;
               if (f->double_colon)
                 f = f->double_colon;
               do
+                {
                   running |= (f->command_state == cs_running
                               || f->command_state == cs_deps_running);
                   f = f->prev;
+                }
               while (f != 0);
+            }
             if (dep_status != 0 && !keep_going_flag)
               break;
             if (!running)
               d->changed = ((file->phony && file->cmds != 0)
                             || file_mtime (d->file) != mtime);
+          }
+            check_renamed (d->file);
+            {
+              register struct file *f = d->file;
+              if (f->double_colon)
+                f = f->double_colon;
+              do
+                {
+                  running |= (f->command_state == cs_running
+                              || f->command_state == cs_deps_running);
+                  f = f->prev;
+                }
+              while (f != 0);
+            }
+            if (dep_status && !keep_going_flag)
+              break;
+            if (!running)
+              d->changed = ((file->phony && file->cmds != 0)
+                            || file_mtime (d->file) != mtime);
+          }
+    }
 …
   finish_updating (ofile);
   DBF (DB_VERBOSE, _("Finished prerequisites of target file `%s'.\n"));
+  DBF (DB_VERBOSE, _("Finished prerequisites of target file '%s'.\n"));
   if (running)
 …
       set_command_state (file, cs_deps_running);
       --depth;
       DBF (DB_VERBOSE, _("The prerequisites of `%s' are being made.\n"));
+      DBF (DB_VERBOSE, _("The prerequisites of '%s' are being made.\n"));
       return 0;
+    }
 …
   /* If any dependency failed, give up now.  */
+  if (dep_status != 0)
+    {
+      file->update_status = dep_status;
+  if (dep_status)
+    {
+      /* I'm not sure if we can't just assign dep_status...  */
+      file->update_status = dep_status == us_none ? us_failed : dep_status;
       notice_finished_file (file);
       --depth;
       DBF (DB_VERBOSE, _("Giving up on target file `%s'.\n"));
+      DBF (DB_VERBOSE, _("Giving up on target file '%s'.\n"));
       if (depth == 0 && keep_going_flag
           && !just_print_flag && !question_flag)
         error (NILF,
                _("Target `%s' not remade because of errors."), file->name);
+          && !just_print_flag && !question_flag)
+        OS (error, NILF,
+            _("Target '%s' not remade because of errors."), file->name);
       return dep_status;
 …
 #if 1
           /* %%% In version 4, remove this code completely to
            implement not remaking deps if their deps are newer
            than their parents.  */
+           implement not remaking deps if their deps are newer
+           than their parents.  */
           if (d_mtime == NONEXISTENT_MTIME && !d->file->intermediate)
             /* We must remake if this dep does not
 …
       /* Set D->changed if either this dep actually changed,
          or its dependent, FILE, is older or does not exist.  */
+         or its dependent, FILE, is older or does not exist.  */
       d->changed |= noexist || d_mtime > this_mtime;
       if (!noexist && ISDB (DB_BASIC|DB_VERBOSE))
+        {
+        {
           const char *fmt = 0;
 …
+            {
               if (ISDB (DB_VERBOSE))
                 fmt = _("Prerequisite `%s' is order-only for target `%s'.\n");
+                fmt = _("Prerequisite '%s' is order-only for target '%s'.\n");
+            }
           else if (d_mtime == NONEXISTENT_MTIME)
+            {
               if (ISDB (DB_BASIC))
                 fmt = _("Prerequisite `%s' of target `%s' does not exist.\n");
+            }
           else if (d->changed)
+                fmt = _("Prerequisite '%s' of target '%s' does not exist.\n");
+            }
+          else if (d->changed)
+            {
               if (ISDB (DB_BASIC))
                 fmt = _("Prerequisite `%s' is newer than target `%s'.\n");
+                fmt = _("Prerequisite '%s' is newer than target '%s'.\n");
+            }
           else if (ISDB (DB_VERBOSE))
             fmt = _("Prerequisite `%s' is older than target `%s'.\n");
+            fmt = _("Prerequisite '%s' is older than target '%s'.\n");
           if (fmt)
 …
               fflush (stdout);
+            }
+        }
+        }
+    }
 …
       must_make = 1;
       DBF (DB_BASIC,
            _("Target `%s' is double-colon and has no prerequisites.\n"));
+           _("Target '%s' is double-colon and has no prerequisites.\n"));
+    }
   else if (!noexist && file->is_target && !deps_changed && file->cmds == 0
 …
       must_make = 0;
       DBF (DB_VERBOSE,
            _("No recipe for `%s' and no prerequisites actually changed.\n"));
+           _("No recipe for '%s' and no prerequisites actually changed.\n"));
+    }
   else if (!must_make && file->cmds != 0 && always_make_flag)
+    {
       must_make = 1;
       DBF (DB_VERBOSE, _("Making `%s' due to always-make flag.\n"));
+      DBF (DB_VERBOSE, _("Making '%s' due to always-make flag.\n"));
+    }
 …
+        {
           print_spaces (depth);
           printf (_("No need to remake target `%s'"), file->name);
+          printf (_("No need to remake target '%s'"), file->name);
           if (!streq (file->name, file->hname))
               printf (_("; using VPATH name `%s'"), file->hname);
+              printf (_("; using VPATH name '%s'"), file->hname);
           puts (".");
           fflush (stdout);
 …
+    }
   DBF (DB_BASIC, _("Must remake target `%s'.\n"));
+  DBF (DB_BASIC, _("Must remake target '%s'.\n"));
   /* It needs to be remade.  If it's VPATH and not reset via GPATH, toss the
      VPATH.  */
   if (!streq(file->name, file->hname))
+    {
       DB (DB_BASIC, (_("  Ignoring VPATH name `%s'.\n"), file->hname));
+  if (!streq (file->name, file->hname))
+    {
+      DB (DB_BASIC, (_("  Ignoring VPATH name '%s'.\n"), file->hname));
       file->ignore_vpath = 1;
+    }
 …
   if (file->command_state != cs_finished)
+    {
       DBF (DB_VERBOSE, _("Recipe of `%s' is being run.\n"));
+      DBF (DB_VERBOSE, _("Recipe of '%s' is being run.\n"));
       return 0;
+    }
 …
   switch (file->update_status)
+    {
     case 2:
       DBF (DB_BASIC, _("Failed to remake target file `%s'.\n"));
+    case us_failed:
+      DBF (DB_BASIC, _("Failed to remake target file '%s'.\n"));
       break;
     case 0:
       DBF (DB_BASIC, _("Successfully remade target file `%s'.\n"));
+    case us_success:
+      DBF (DB_BASIC, _("Successfully remade target file '%s'.\n"));
       break;
     case 1:
       DBF (DB_BASIC, _("Target file `%s' needs remade under -q.\n"));
+    case us_question:
+      DBF (DB_BASIC, _("Target file '%s' needs to be remade under -q.\n"));
       break;
+    default:
+      assert (file->update_status >= 0 && file->update_status <= 2);
+    case us_none:
       break;
+    }
 …
 /* Set FILE's `updated' flag and re-check its mtime and the mtime's of all
    files listed in its `also_make' member.  Under -t, this function also
+/* Set FILE's 'updated' flag and re-check its mtime and the mtime's of all
+   files listed in its 'also_make' member.  Under -t, this function also
    touches FILE.
    On return, FILE->update_status will no longer be -1 if it was.  */
+   On return, FILE->update_status will no longer be us_none if it was.  */
 void
 …
   if (touch_flag
       /* The update status will be:
                 -1      if this target was not remade;
        if 0 or more commands (+ or ${MAKE}) were run and won;
        if some commands were run and lost.
          We touch the target if it has commands which either were not run
          or won when they ran (i.e. status is 0).  */
       && file->update_status == 0)
+           us_success   if 0 or more commands (+ or ${MAKE}) were run and won;
+           us_none      if this target was not remade;
+           >us_none     if some commands were run and lost.
+         We touch the target if it has commands which either were not run
+         or won when they ran (i.e. status is 0).  */
+      && file->update_status == us_success)
+    {
       if (file->cmds != 0 && file->cmds->any_recurse)
+        {
           /* If all the command lines were recursive,
              we don't want to do the touching.  */
           unsigned int i;
           for (i = 0; i < file->cmds->ncommand_lines; ++i)
             if (!(file->cmds->lines_flags[i] & COMMANDS_RECURSE))
               goto have_nonrecursing;
+        }
+        {
+          /* If all the command lines were recursive,
+             we don't want to do the touching.  */
+          unsigned int i;
+          for (i = 0; i < file->cmds->ncommand_lines; ++i)
+            if (!(file->cmds->lines_flags[i] & COMMANDS_RECURSE))
+              goto have_nonrecursing;
+        }
       else
+        {
         have_nonrecursing:
           if (file->phony)
             file->update_status = 0;
+        {
+        have_nonrecursing:
+          if (file->phony)
+            file->update_status = us_success;
           /* According to POSIX, -t doesn't affect targets with no cmds.  */
           else if (file->cmds != 0)
+          else if (file->cmds != 0)
+            {
               /* Should set file's modification date and do nothing else.  */
 …
               /* Pretend we ran a real touch command, to suppress the
                  "`foo' is up to date" message.  */
+                 "'foo' is up to date" message.  */
               commands_started++;
 …
               touched = 1;
+            }
+        }
+        }
+    }
 …
       else if (file->is_target && file->cmds == 0)
         i = 1;
+        i = 1;
       file->last_mtime = i == 0 ? UNKNOWN_MTIME : NEW_MTIME;
 …
+    }
   if (ran && file->update_status != -1)
+  if (ran && file->update_status != us_none)
     /* We actually tried to update FILE, which has
        updated its also_make's as well (if it worked).
 …
     for (d = file->also_make; d != 0; d = d->next)
+      {
         d->file->command_state = cs_finished;
         d->file->updated = 1;
         d->file->update_status = file->update_status;
         if (ran && !d->file->phony)
           /* Fetch the new modification time.
              We do this instead of just invalidating the cached time
              so that a vpath_search can happen.  Otherwise, it would
              never be done because the target is already updated.  */
           f_mtime (d->file, 0);
+        d->file->command_state = cs_finished;
+        d->file->updated = 1;
+        d->file->update_status = file->update_status;
+        if (ran && !d->file->phony)
+          /* Fetch the new modification time.
+             We do this instead of just invalidating the cached time
+             so that a vpath_search can happen.  Otherwise, it would
+             never be done because the target is already updated.  */
+          f_mtime (d->file, 0);
+      }
   else if (file->update_status == -1)
+  else if (file->update_status == us_none)
     /* Nothing was done for FILE, but it needed nothing done.
        So mark it now as "succeeded".  */
     file->update_status = 0;
+    file->update_status = us_success;
+}
 …
    failed.  */
 static int
+static enum update_status
 check_dep (struct file *file, unsigned int depth,
            FILE_TIMESTAMP this_mtime, int *must_make_ptr)
 …
   struct file *ofile;
   struct dep *d;
   int dep_status = 0;
+  enum update_status dep_status = us_success;
   ++depth;
 …
       check_renamed (file);
       if (mtime == NONEXISTENT_MTIME || mtime > this_mtime)
         *must_make_ptr = 1;
+        *must_make_ptr = 1;
+    }
   else
 …
       if (!file->phony && file->cmds == 0 && !file->tried_implicit)
+        {
           if (try_implicit_rule (file, depth))
             DBF (DB_IMPLICIT, _("Found an implicit rule for `%s'.\n"));
           else
             DBF (DB_IMPLICIT, _("No implicit rule found for `%s'.\n"));
           file->tried_implicit = 1;
+        }
+        {
+          if (try_implicit_rule (file, depth))
+            DBF (DB_IMPLICIT, _("Found an implicit rule for '%s'.\n"));
+          else
+            DBF (DB_IMPLICIT, _("No implicit rule found for '%s'.\n"));
+          file->tried_implicit = 1;
+        }
       if (file->cmds == 0 && !file->is_target
           && default_file != 0 && default_file->cmds != 0)
+        {
           DBF (DB_IMPLICIT, _("Using default commands for `%s'.\n"));
           file->cmds = default_file->cmds;
+        }
+          && default_file != 0 && default_file->cmds != 0)
+        {
+          DBF (DB_IMPLICIT, _("Using default commands for '%s'.\n"));
+          file->cmds = default_file->cmds;
+        }
       check_renamed (file);
 …
         /* If the intermediate file actually exists and is newer, then we
            should remake from it.  */
         *must_make_ptr = 1;
+        *must_make_ptr = 1;
       else
+        {
+        {
           /* Otherwise, update all non-intermediate files we depend on, if
              necessary, and see whether any of them is more recent than the
              file on whose behalf we are checking.  */
           struct dep *ld;
+          struct dep *ld;
           int deps_running = 0;
 …
              prerequisite and so wasn't rebuilt then, but should be now.  */
           if (file->command_state != cs_running)
+            set_command_state (file, cs_not_started);
+          ld = 0;
+          d = file->deps;
+          while (d != 0)
+            {
+            {
+              /* If the target was waiting for a dependency it has to be
+                 reconsidered, as that dependency might have finished.  */
+              if (file->command_state == cs_deps_running)
+                file->considered = 0;
+              set_command_state (file, cs_not_started);
+            }
+          ld = 0;
+          d = file->deps;
+          while (d != 0)
+            {
+              enum update_status new;
               int maybe_make;
               if (is_updating (d->file))
+                {
                   error (NILF, _("Circular %s <- %s dependency dropped."),
                          file->name, d->file->name);
                   if (ld == 0)
+                    {
                       file->deps = d->next;
+              if (is_updating (d->file))
+                {
+                  OSS (error, NILF, _("Circular %s <- %s dependency dropped."),
+                       file->name, d->file->name);
+                  if (ld == 0)
+                    {
+                      file->deps = d->next;
                       free_dep (d);
                       d = file->deps;
+                    }
                   else
+                    {
                       ld->next = d->next;
+                      d = file->deps;
+                    }
+                  else
+                    {
+                      ld->next = d->next;
                       free_dep (d);
                       d = ld->next;
+                    }
                   continue;
+                }
               d->file->parent = file;
+                      d = ld->next;
+                    }
+                  continue;
+                }
+              d->file->parent = file;
               maybe_make = *must_make_ptr;
+              dep_status |= check_dep (d->file, depth, this_mtime,
+                                       &maybe_make);
+              new = check_dep (d->file, depth, this_mtime, &maybe_make);
+              if (new > dep_status)
+                dep_status = new;
               if (! d->ignore_mtime)
                 *must_make_ptr = maybe_make;
               check_renamed (d->file);
               if (dep_status != 0 && !keep_going_flag)
                 break;
               if (d->file->command_state == cs_running
                   || d->file->command_state == cs_deps_running)
                 deps_running = 1;
               ld = d;
               d = d->next;
+            }
+              check_renamed (d->file);
+              if (dep_status && !keep_going_flag)
+                break;
+              if (d->file->command_state == cs_running
+                  || d->file->command_state == cs_deps_running)
+                deps_running = 1;
+              ld = d;
+              d = d->next;
+            }
           if (deps_running)
 …
                commands are finished.  */
             set_command_state (file, cs_deps_running);
+        }
+        }
+    }
 …
+/* Touch FILE.  Return zero if successful, one if not.  */
+#define TOUCH_ERROR(call) return (perror_with_name (call, file->name), 1)
+static int
+/* Touch FILE.  Return us_success if successful, us_failed if not.  */
+#define TOUCH_ERROR(call) do{ perror_with_name ((call), file->name);    \
+                              return us_failed; }while(0)
+static enum update_status
 touch_file (struct file *file)
+{
   if (!silent_flag)
+    message (0, "touch %s", file->name);
+#ifndef NO_ARCHIVES
+    OS (message, 0, "touch %s", file->name);
+  /* Print-only (-n) takes precedence over touch (-t).  */
+  if (just_print_flag)
+    return us_success;
+#ifndef NO_ARCHIVES
   if (ar_name (file->name))
     return ar_touch (file->name);
+    return ar_touch (file->name) ? us_failed : us_success;
   else
 #endif
+    {
+      int fd = open (file->name, O_RDWR | O_CREAT, 0666);
+      int fd;
+      EINTRLOOP (fd, open (file->name, O_RDWR | O_CREAT, 0666));
       if (fd < 0)
         TOUCH_ERROR ("touch: open: ");
+        TOUCH_ERROR ("touch: open: ");
       else
+        {
           struct stat statbuf;
           char buf = 'x';
+        {
+          struct stat statbuf;
+          char buf = 'x';
           int e;
           EINTRLOOP (e, fstat (fd, &statbuf));
+          if (e < 0)
+            TOUCH_ERROR ("touch: fstat: ");
+          /* Rewrite character 0 same as it already is.  */
+          if (read (fd, &buf, 1) < 0)
+            TOUCH_ERROR ("touch: read: ");
+          if (lseek (fd, 0L, 0) < 0L)
+            TOUCH_ERROR ("touch: lseek: ");
+          if (write (fd, &buf, 1) < 0)
+            TOUCH_ERROR ("touch: write: ");
+          /* If file length was 0, we just
+             changed it, so change it back.  */
+          if (statbuf.st_size == 0)
+            {
+              (void) close (fd);
+              fd = open (file->name, O_RDWR | O_TRUNC, 0666);
+              if (fd < 0)
+                TOUCH_ERROR ("touch: open: ");
+            }
+          (void) close (fd);
+        }
+    }
+  return 0;
+          if (e < 0)
+            TOUCH_ERROR ("touch: fstat: ");
+          /* Rewrite character 0 same as it already is.  */
+          EINTRLOOP (e, read (fd, &buf, 1));
+          if (e < 0)
+            TOUCH_ERROR ("touch: read: ");
+          {
+            off_t o;
+            EINTRLOOP (o, lseek (fd, 0L, 0));
+            if (o < 0L)
+              TOUCH_ERROR ("touch: lseek: ");
+          }
+          EINTRLOOP (e, write (fd, &buf, 1));
+          if (e < 0)
+            TOUCH_ERROR ("touch: write: ");
+          /* If file length was 0, we just changed it, so change it back.  */
+          if (statbuf.st_size == 0)
+            {
+              (void) close (fd);
+              EINTRLOOP (fd, open (file->name, O_RDWR | O_TRUNC, 0666));
+              if (fd < 0)
+                TOUCH_ERROR ("touch: open: ");
+            }
+          (void) close (fd);
+        }
+    }
+  return us_success;
+}
 …
+    {
       if (file->phony)
         /* Phony target.  Pretend it succeeded.  */
         file->update_status = 0;
+        /* Phony target.  Pretend it succeeded.  */
+        file->update_status = us_success;
       else if (file->is_target)
         /* This is a nonexistent target file we cannot make.
            Pretend it was successfully remade.  */
         file->update_status = 0;
+        /* This is a nonexistent target file we cannot make.
+           Pretend it was successfully remade.  */
+        file->update_status = us_success;
       else
+        {
 …
           if (!rebuilding_makefiles || !file->dontcare)
             complain (file);
           file->update_status = 2;
+          file->update_status = us_failed;
+        }
+    }
 …
       /* The normal case: start some commands.  */
       if (!touch_flag || file->cmds->any_recurse)
+        {
           execute_file_commands (file);
           return;
+        }
+        {
+          execute_file_commands (file);
+          return;
+        }
       /* This tells notice_finished_file it is ok to touch the file.  */
       file->update_status = 0;
+      file->update_status = us_success;
+    }
 …
 /* Return the mtime of a file, given a `struct file'.
+/* Return the mtime of a file, given a 'struct file'.
    Caches the time in the struct file to avoid excess stat calls.
 …
+{
   FILE_TIMESTAMP mtime;
+  int propagate_timestamp;
   /* File's mtime is not known; must get it from the system.  */
 #ifndef NO_ARCHIVES
+#ifndef NO_ARCHIVES
   if (ar_name (file->name))
+    {
 …
       /* Find the modification time of the archive itself.
          Also allow for its name to be changed via VPATH search.  */
+         Also allow for its name to be changed via VPATH search.  */
       arfile = lookup_file (arname);
       if (arfile == 0)
 …
       check_renamed (arfile);
       if (search && strcmp (arfile->hname, arname))
+        {
           /* The archive's name has changed.
              Change the archive-member reference accordingly.  */
+        {
+          /* The archive's name has changed.
+             Change the archive-member reference accordingly.  */
           char *name;
           unsigned int arlen, memlen;
           arlen = strlen (arfile->hname);
           memlen = strlen (memname);
           name = xmalloc (arlen + 1 + memlen + 2);
           memcpy (name, arfile->hname, arlen);
           name[arlen] = '(';
           memcpy (name + arlen + 1, memname, memlen);
           name[arlen + 1 + memlen] = ')';
           name[arlen + 1 + memlen + 1] = '\0';
+          unsigned int arlen, memlen;
+          arlen = strlen (arfile->hname);
+          memlen = strlen (memname);
+          name = alloca (arlen + 1 + memlen + 2);
+          memcpy (name, arfile->hname, arlen);
+          name[arlen] = '(';
+          memcpy (name + arlen + 1, memname, memlen);
+          name[arlen + 1 + memlen] = ')';
+          name[arlen + 1 + memlen + 1] = '\0';
           /* If the archive was found with GPATH, make the change permanent;
              otherwise defer it until later.  */
           if (arfile->name == arfile->hname)
             rename_file (file, name);
+            rename_file (file, strcache_add (name));
           else
             rehash_file (file, name);
+            rehash_file (file, strcache_add (name));
           check_renamed (file);
+        }
+        }
       free (arname);
 …
       if (mtime == NONEXISTENT_MTIME)
         /* The archive doesn't exist, so its members don't exist either.  */
         return NONEXISTENT_MTIME;
+        /* The archive doesn't exist, so its members don't exist either.  */
+        return NONEXISTENT_MTIME;
       member_date = ar_member_date (file->hname);
 …
       if (mtime == NONEXISTENT_MTIME && search && !file->ignore_vpath)
+        {
+          /* If name_mtime failed, search VPATH.  */
+          const char *name = vpath_search (file->name, &mtime, NULL, NULL);
+          if (name
+              /* Last resort, is it a library (-lxxx)?  */
+              || (file->name[0] == '-' && file->name[1] == 'l'
+                  && (name = library_search (file->name, &mtime)) != 0))
+            {
+              if (mtime != UNKNOWN_MTIME)
+                /* vpath_search and library_search store UNKNOWN_MTIME
+                   if they didn't need to do a stat call for their work.  */
+                file->last_mtime = mtime;
+        {
+          /* If name_mtime failed, search VPATH.  */
+          const char *name = vpath_search (file->name, &mtime, NULL, NULL);
+          if (name
+              /* Last resort, is it a library (-lxxx)?  */
+              || (file->name[0] == '-' && file->name[1] == 'l'
+                  && (name = library_search (file->name, &mtime)) != 0))
+            {
+              int name_len;
+              if (mtime != UNKNOWN_MTIME)
+                /* vpath_search and library_search store UNKNOWN_MTIME
+                   if they didn't need to do a stat call for their work.  */
+                file->last_mtime = mtime;
               /* If we found it in VPATH, see if it's in GPATH too; if so,
                  change the name right now; if not, defer until after the
                  dependencies are updated. */
+              if (gpath_search (name, strlen(name) - strlen(file->name) - 1))
+#ifndef VMS
+              name_len = strlen (name) - strlen (file->name) - 1;
+#else
+              name_len = strlen (name) - strlen (file->name);
+              if (name[name_len - 1] == '/')
+                  name_len--;
+#endif
+              if (gpath_search (name, name_len))
+                {
                   rename_file (file, name);
 …
+                }
               rehash_file (file, name);
               check_renamed (file);
+              rehash_file (file, name);
+              check_renamed (file);
               /* If the result of a vpath search is -o or -W, preserve it.
                  Otherwise, find the mtime of the resulting file.  */
               if (mtime != OLD_MTIME && mtime != NEW_MTIME)
                 mtime = name_mtime (name);
+            }
+        }
+            }
+        }
+    }
 …
+            {
 #ifdef NO_FLOAT
+              error (NILF, _("Warning: File `%s' has modification time in the future"),
+                     file->name);
+              OS (error, NILF,
+                  _("Warning: File '%s' has modification time in the future"),
+                  file->name);
 #else
               double from_now =
 …
               else
                 sprintf (from_now_string, "%.2g", from_now);
+              error (NILF, _("Warning: File `%s' has modification time %s s in the future"),
+                     file->name, from_now_string);
+              OSS (error, NILF,
+                   _("Warning: File '%s' has modification time %s s in the future"),
+                   file->name, from_now_string);
 #endif
               clock_skew_detected = 1;
 …
+    }
+  /* Store the mtime into all the entries for this file.  */
+  /* Store the mtime into all the entries for this file for which it is safe
+     to do so: avoid propagating timestamps to double-colon rules that haven't
+     been examined so they're run or not based on the pre-update timestamp.  */
   if (file->double_colon)
     file = file->double_colon;
+  propagate_timestamp = file->updated;
   do
+    {
       /* If this file is not implicit but it is intermediate then it was
          made so by the .INTERMEDIATE target.  If this file has never
          been built by us but was found now, it existed before make
          started.  So, turn off the intermediate bit so make doesn't
          delete it, since it didn't create it.  */
+         made so by the .INTERMEDIATE target.  If this file has never
+         been built by us but was found now, it existed before make
+         started.  So, turn off the intermediate bit so make doesn't
+         delete it, since it didn't create it.  */
       if (mtime != NONEXISTENT_MTIME && file->command_state == cs_not_started
+          && file->command_state == cs_not_started
+          && !file->tried_implicit && file->intermediate)
+        file->intermediate = 0;
       file->last_mtime = mtime;
+          && !file->tried_implicit && file->intermediate)
+        file->intermediate = 0;
+      if (file->updated == propagate_timestamp)
+        file->last_mtime = mtime;
       file = file->prev;
+    }
 …
 library_search (const char *lib, FILE_TIMESTAMP *mtime_ptr)
+{
   static char *dirs[] =
+  static const char *dirs[] =
+    {
 #ifndef _AMIGA
 …
 #define LIBDIR "."
 #endif
       LIBDIR,                   /* Defined by configuration.  */
+      LIBDIR,                   /* Defined by configuration.  */
     };
 …
   /* Information about the earliest (in the vpath sequence) match.  */
+  unsigned int best_vpath, best_path;
+  unsigned int std_dirs = 0;
+  char **dp;
+  unsigned int best_vpath = 0, best_path = 0;
+  const char **dp;
   libpatterns = xstrdup (variable_expand ("$(.LIBPATTERNS)"));
 …
       static unsigned int buflen = 0;
       static int libdir_maxlen = -1;
+      static unsigned int std_dirs = 0;
       char *libbuf = variable_expand ("");
       /* Expand the pattern using LIB as a replacement.  */
+      {
+        char c = p[len];
+        char *p3, *p4;
+        p[len] = '\0';
+        p3 = find_percent (p);
+        if (!p3)
+          {
+            /* Give a warning if there is no pattern.  */
+            error (NILF, _(".LIBPATTERNS element `%s' is not a pattern"), p);
+        char c = p[len];
+        char *p3, *p4;
+        p[len] = '\0';
+        p3 = find_percent (p);
+        if (!p3)
+          {
+            /* Give a warning if there is no pattern.  */
+            OS (error, NILF,
+                _(".LIBPATTERNS element '%s' is not a pattern"), p);
             p[len] = c;
             continue;
+          }
         p4 = variable_buffer_output (libbuf, p, p3-p);
         p4 = variable_buffer_output (p4, lib, liblen);
         p4 = variable_buffer_output (p4, p3+1, len - (p3-p));
         p[len] = c;
+            continue;
+          }
+        p4 = variable_buffer_output (libbuf, p, p3-p);
+        p4 = variable_buffer_output (p4, lib, liblen);
+        p4 = variable_buffer_output (p4, p3+1, len - (p3-p));
+        p[len] = c;
+      }
       /* Look first for `libNAME.a' in the current directory.  */
+      /* Look first for 'libNAME.a' in the current directory.  */
       mtime = name_mtime (libbuf);
       if (mtime != NONEXISTENT_MTIME)
+        {
           if (mtime_ptr != 0)
             *mtime_ptr = mtime;
           file = strcache_add (libbuf);
+        {
+          if (mtime_ptr != 0)
+            *mtime_ptr = mtime;
+          file = strcache_add (libbuf);
           /* This by definition will have the best index, so stop now.  */
           break;
+        }
+        }
       /* Now try VPATH search on that.  */
 …
+            }
           buflen = strlen (libbuf);
           buf = xmalloc(libdir_maxlen + buflen + 2);
+          buf = xmalloc (libdir_maxlen + buflen + 2);
+        }
       else if (buflen < strlen (libbuf))
 …
         for (dp = dirs; *dp != 0; ++dp)
+          {
+          {
             sprintf (buf, "%s/%s", *dp, libbuf);
             mtime = name_mtime (buf);
             if (mtime != NONEXISTENT_MTIME)
+              {
+              {
                 if (file == 0 || vpath_index < best_vpath)
+                  {

vendor/gnumake/current/remote-cstms.c

-              r2596
+              r3138
    the Make maintainers.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
+#include "make.h"
+#include "job.h"
+#include "makeint.h"
 #include "filedef.h"
 #include "commands.h"
 …
 char *remote_description = "Customs";
 /* File name of the Customs `export' client command.
+/* File name of the Customs 'export' client command.
    A full path name can be used to avoid some path-searching overhead.  */
 #define EXPORT_COMMAND  "/usr/local/bin/export"
+#define EXPORT_COMMAND  "/usr/local/bin/export"
 /* ExportPermit gotten by start_remote_job_p, and used by start_remote_job.  */
 …
       /* For secure Customs, make is installed setuid root and
          Customs requires a privileged source port be used.  */
+         Customs requires a privileged source port be used.  */
       make_access ();
       if (ISDB (DB_JOBS))
         Rpc_Debug(1);
+        Rpc_Debug (1);
       /* Ping the daemon once to see if it is there.  */
 …
       if (starting_directory == 0)
         /* main couldn't figure it out.  */
         inited = -1;
+        /* main couldn't figure it out.  */
+        inited = -1;
       else
+        {
           /* Normalize the current directory path name to something
              that should work on all machines exported to.  */
           normalized_cwd = xmalloc (GET_PATH_MAX);
           strcpy (normalized_cwd, starting_directory);
           if (Customs_NormPath (normalized_cwd, GET_PATH_MAX) < 0)
             /* Path normalization failure means using Customs
                won't work, but it's not really an error.  */
             inited = -1;
+        }
+        {
+          /* Normalize the current directory path name to something
+             that should work on all machines exported to.  */
+          normalized_cwd = xmalloc (GET_PATH_MAX);
+          strcpy (normalized_cwd, starting_directory);
+          if (Customs_NormPath (normalized_cwd, GET_PATH_MAX) < 0)
+            /* Path normalization failure means using Customs
+               won't work, but it's not really an error.  */
+            inited = -1;
+        }
+    }
 …
   njobs = job_slots_used;
   if (!first_p)
     njobs -= 1;         /* correction for being called from reap_children() */
+    njobs -= 1;         /* correction for being called from reap_children() */
   /* the first job should run locally, or, if the -l flag is given, we use
 …
   if (retsock < 0)
+    {
       error (NILF, "exporting: Couldn't create return socket.");
+      O (error, NILF, "exporting: Couldn't create return socket.");
       return 1;
+    }
 …
   /* Create a WayBill to give to the server.  */
   len = Customs_MakeWayBill (&permit, normalized_cwd, argv[0], argv,
                              envp, retport, waybill);
   /* Modify the waybill as if the remote child had done `child_access ()'.  */
+                             envp, retport, waybill);
+  /* Modify the waybill as if the remote child had done 'child_access ()'.  */
+  {
     WayBill *wb = (WayBill *) waybill;
 …
   sin.sin_addr = permit.addr;
   status = Rpc_Call (sock, &sin, (Rpc_Proc) CUSTOMS_IMPORT,
+                     len, (Rpc_Opaque) waybill,
+                     sizeof(msg), (Rpc_Opaque) msg,
+, &timeout);
+  host = gethostbyaddr((char *)&permit.addr, sizeof(permit.addr), AF_INET);
+  if (status != RPC_SUCCESS)
+    {
+      (void) close (retsock);
+      (void) close (sock);
+      error (NILF, "exporting to %s: %s",
+             host ? host->h_name : inet_ntoa (permit.addr),
+             Rpc_ErrorMessage (status));
+      return 1;
+    }
+  else if (msg[0] != 'O' || msg[1] != 'k' || msg[2] != '\0')
+    {
+      (void) close (retsock);
+      (void) close (sock);
+      error (NILF, "exporting to %s: %s",
+             host ? host->h_name : inet_ntoa (permit.addr),
+             msg);
+      return 1;
+    }
+  else
+    {
+      error (NILF, "*** exported to %s (id %u)",
+              host ? host->h_name : inet_ntoa (permit.addr),
+              permit.id);
+    }
+  fflush (stdout);
+  fflush (stderr);
+                     len, (Rpc_Opaque) waybill,
+                     sizeof (msg), (Rpc_Opaque) msg,
+, &timeout);
+  host = gethostbyaddr ((char *)&permit.addr, sizeof(permit.addr), AF_INET);
+  {
+    const char *hnm = host ? host->h_name : inet_ntoa (permit.addr);
+    size_t hlen = strlen (hnm);
+    if (status != RPC_SUCCESS)
+      {
+        const char *err = Rpc_ErrorMessage (status);
+        (void) close (retsock);
+        (void) close (sock);
+        error (NILF, hlen + strlen (err),
+               "exporting to %s: %s", hnm, err);
+        return 1;
+      }
+    else if (msg[0] != 'O' || msg[1] != 'k' || msg[2] != '\0')
+      {
+        (void) close (retsock);
+        (void) close (sock);
+        error (NILF, hlen + strlen (msg), "exporting to %s: %s", hnm, msg);
+        return 1;
+      }
+    else
+      {
+        error (NILF, hlen + INTSTR_LENGTH,
+               "*** exported to %s (id %u)", hnm, permit.id);
+      }
+    fflush (stdout);
+    fflush (stderr);
+  }
   pid = vfork ();
 …
+    {
       /* The fork failed!  */
       perror_with_name ("vfork", "");
+      perror_with_name ("fork", "");
       return 1;
+    }
   else if (pid == 0)
+    {
       /* Child side.  Run `export' to handle the connection.  */
+      /* Child side.  Run 'export' to handle the connection.  */
       static char sock_buf[20], retsock_buf[20], id_buf[20];
       static char *new_argv[6] =
         { EXPORT_COMMAND, "-id", sock_buf, retsock_buf, id_buf, 0 };
+        { EXPORT_COMMAND, "-id", sock_buf, retsock_buf, id_buf, 0 };
       /* Set up the arguments.  */
 …
       /* Get the right stdin.  */
       if (stdin_fd != 0)
         (void) dup2 (stdin_fd, 0);
+        (void) dup2 (stdin_fd, 0);
       /* Unblock signals in the child.  */
 …
+    }
   /* Parent side.  Return the `export' process's ID.  */
+  /* Parent side.  Return the 'export' process's ID.  */
   (void) close (retsock);
   (void) close (sock);

vendor/gnumake/current/remote-stub.c

-              r2596
+              r3138
 /* Template for the remote job exportation interface to GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include "filedef.h"
 #include "job.h"

vendor/gnumake/current/rule.c

-              r2596
+              r3138
 /* Pattern and suffix rule internals for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include <assert.h>
+#include "filedef.h"
 #include "dep.h"
-#include "filedef.h"
 #include "job.h"
 #include "commands.h"
 …
   char *name;
   int namelen;
   struct rule *rule, *lastrule;
+  struct rule *rule;
   num_pattern_rules = max_pattern_targets = max_pattern_deps = 0;
 …
   namelen = 0;
   rule = pattern_rules;
-  lastrule = 0;
   while (rule != 0)
+    {
 …
       if (rule->num > max_pattern_targets)
         max_pattern_targets = rule->num;
+        max_pattern_targets = rule->num;
       for (dep = rule->deps; dep != 0; dep = dep->next)
+        {
+        {
           const char *dname = dep_name (dep);
           unsigned int len = strlen (dname);
 …
           ndeps++;
           if (len > max_pattern_dep_length)
             max_pattern_dep_length = len;
           if (p != 0 && p2 > p)
+            {
               /* There is a slash before the % in the dep name.
                  Extract the directory name.  */
               if (p == dname)
                 ++p;
               if (p - dname > namelen)
+                {
                   namelen = p - dname;
                   name = xrealloc (name, namelen + 1);
+                }
               memcpy (name, dname, p - dname);
               name[p - dname] = '\0';
               /* In the deps of an implicit rule the `changed' flag
                  actually indicates that the dependency is in a
                  nonexistent subdirectory.  */
               dep->changed = !dir_file_exists_p (name, "");
+            }
           else
             /* This dependency does not reside in a subdirectory.  */
             dep->changed = 0;
+        }
+          if (len > max_pattern_dep_length)
+            max_pattern_dep_length = len;
+          if (p != 0 && p2 > p)
+            {
+              /* There is a slash before the % in the dep name.
+                 Extract the directory name.  */
+              if (p == dname)
+                ++p;
+              if (p - dname > namelen)
+                {
+                  namelen = p - dname;
+                  name = xrealloc (name, namelen + 1);
+                }
+              memcpy (name, dname, p - dname);
+              name[p - dname] = '\0';
+              /* In the deps of an implicit rule the 'changed' flag
+                 actually indicates that the dependency is in a
+                 nonexistent subdirectory.  */
+              dep->changed = !dir_file_exists_p (name, "");
+            }
+          else
+            /* This dependency does not reside in a subdirectory.  */
+            dep->changed = 0;
+        }
       if (ndeps > max_pattern_deps)
+        max_pattern_deps = ndeps;
+      lastrule = rule;
+        max_pattern_deps = ndeps;
       rule = next;
+    }
+  if (name != 0)
+    free (name);
+  free (name);
+}
 …
    TARGET is the target suffix; SOURCE is the source suffix.
    CMDS are the commands.
    If TARGET is nil, it means the target pattern should be `(%.o)'.
+   If TARGET is nil, it means the target pattern should be '(%.o)'.
    If SOURCE is nil, it means there should be no deps.  */
 …
   if (target == 0)
+    {
       /* Special case: TARGET being nil means we are defining a `.X.a' suffix
          rule; the target pattern is always `(%.o)'.  */
+      /* Special case: TARGET being nil means we are defining a '.X.a' suffix
+         rule; the target pattern is always '(%.o)'.  */
 #ifdef VMS
       *names = strcache_add_len ("(%.obj)", 7);
 …
       unsigned int l = strlen (dep_name (d));
       if (l > maxsuffix)
         maxsuffix = l;
+        maxsuffix = l;
+    }
 …
       /* Make a rule that is just the suffix, with no deps or commands.
          This rule exists solely to disqualify match-anything rules.  */
+         This rule exists solely to disqualify match-anything rules.  */
       convert_suffix_rule (dep_name (d), 0, 0);
       if (d->file->cmds != 0)
         /* Record a pattern for this suffix's null-suffix rule.  */
         convert_suffix_rule ("", dep_name (d), d->file->cmds);
+        /* Record a pattern for this suffix's null-suffix rule.  */
+        convert_suffix_rule ("", dep_name (d), d->file->cmds);
       /* Add every other suffix to this one and see if it exists as a
 …
       for (d2 = suffix_file->deps; d2 != 0; d2 = d2->next)
+        {
+        {
           struct file *f;
           unsigned int s2len;
           s2len = strlen (dep_name (d2));
+          s2len = strlen (dep_name (d2));
           /* Can't build something from itself.  */
           if (slen == s2len && streq (dep_name (d), dep_name (d2)))
             continue;
           memcpy (rulename + slen, dep_name (d2), s2len + 1);
           f = lookup_file (rulename);
           if (f == 0 || f->cmds == 0)
             continue;
           if (s2len == 2 && rulename[slen] == '.' && rulename[slen + 1] == 'a')
             /* A suffix rule `.X.a:' generates the pattern rule `(%.o): %.X'.
                It also generates a normal `%.a: %.X' rule below.  */
             convert_suffix_rule (NULL, /* Indicates `(%.o)'.  */
                                  dep_name (d),
                                  f->cmds);
           /* The suffix rule `.X.Y:' is converted
              to the pattern rule `%.Y: %.X'.  */
           convert_suffix_rule (dep_name (d2), dep_name (d), f->cmds);
+        }
+          if (slen == s2len && streq (dep_name (d), dep_name (d2)))
+            continue;
+          memcpy (rulename + slen, dep_name (d2), s2len + 1);
+          f = lookup_file (rulename);
+          if (f == 0 || f->cmds == 0)
+            continue;
+          if (s2len == 2 && rulename[slen] == '.' && rulename[slen + 1] == 'a')
+            /* A suffix rule '.X.a:' generates the pattern rule '(%.o): %.X'.
+               It also generates a normal '%.a: %.X' rule below.  */
+            convert_suffix_rule (NULL, /* Indicates '(%.o)'.  */
+                                 dep_name (d),
+                                 f->cmds);
+          /* The suffix rule '.X.Y:' is converted
+             to the pattern rule '%.Y: %.X'.  */
+          convert_suffix_rule (dep_name (d2), dep_name (d), f->cmds);
+        }
+    }
+}
 …
     for (i = 0; i < rule->num; ++i)
+      {
         for (j = 0; j < r->num; ++j)
           if (!streq (rule->targets[i], r->targets[j]))
             break;
+        for (j = 0; j < r->num; ++j)
+          if (!streq (rule->targets[i], r->targets[j]))
+            break;
         /* If all the targets matched...  */
         if (j == r->num)
+          {
             struct dep *d, *d2;
             for (d = rule->deps, d2 = r->deps;
                  d != 0 && d2 != 0; d = d->next, d2 = d2->next)
               if (!streq (dep_name (d), dep_name (d2)))
                 break;
             if (d == 0 && d2 == 0)
+              {
                 /* All the dependencies matched.  */
                 if (override)
+                  {
                     /* Remove the old rule.  */
                     freerule (r, lastrule);
                     /* Install the new one.  */
                     if (pattern_rules == 0)
                       pattern_rules = rule;
                     else
                       last_pattern_rule->next = rule;
                     last_pattern_rule = rule;
                     /* We got one.  Stop looking.  */
                     goto matched;
+                  }
                 else
+                  {
                     /* The old rule stays intact.  Destroy the new one.  */
                     freerule (rule, (struct rule *) 0);
                     return 0;
+                  }
+              }
+          }
+        if (j == r->num)
+          {
+            struct dep *d, *d2;
+            for (d = rule->deps, d2 = r->deps;
+                 d != 0 && d2 != 0; d = d->next, d2 = d2->next)
+              if (!streq (dep_name (d), dep_name (d2)))
+                break;
+            if (d == 0 && d2 == 0)
+              {
+                /* All the dependencies matched.  */
+                if (override)
+                  {
+                    /* Remove the old rule.  */
+                    freerule (r, lastrule);
+                    /* Install the new one.  */
+                    if (pattern_rules == 0)
+                      pattern_rules = rule;
+                    else
+                      last_pattern_rule->next = rule;
+                    last_pattern_rule = rule;
+                    /* We got one.  Stop looking.  */
+                    goto matched;
+                  }
+                else
+                  {
+                    /* The old rule stays intact.  Destroy the new one.  */
+                    freerule (rule, (struct rule *) 0);
+                    return 0;
+                  }
+              }
+          }
+      }
 …
       /* There was no rule to replace.  */
       if (pattern_rules == 0)
         pattern_rules = rule;
+        pattern_rules = rule;
       else
         last_pattern_rule->next = rule;
+        last_pattern_rule->next = rule;
       last_pattern_rule = rule;
+    }
 …
    in the structure P points to.  These strings come from one of
    the arrays of default implicit pattern rules.
    TERMINAL specifies what the `terminal' field of the rule should be.  */
+   TERMINAL specifies what the 'terminal' field of the rule should be.  */
 void
 …
+{
   struct rule *r;
   char *ptr;
+  const char *ptr;
   r = xmalloc (sizeof (struct rule));
 …
   ptr = p->dep;
   r->deps = PARSE_FILE_SEQ (&ptr, struct dep, '\0', NULL, 0);
+  r->deps = PARSE_SIMPLE_SEQ ((char **)&ptr, struct dep);
   if (new_pattern_rule (r, 0))
 …
       r->cmds->fileinfo.filenm = 0;
       r->cmds->fileinfo.lineno = 0;
+      r->cmds->fileinfo.offset = 0;
       /* These will all be string literals, but we malloc space for them
          anyway because somebody might want to free them later.  */
+         anyway because somebody might want to free them later.  */
       r->cmds->commands = xstrdup (p->commands);
       r->cmds->command_lines = 0;
+      r->cmds->recipe_prefix = RECIPEPREFIX_DEFAULT;
+    }
+}
 …
      are ways that they could be in more than one place:
        * If the commands came from a suffix rule, they could also be in
        the `struct file's for other suffix rules or plain targets given
+       the 'struct file's for other suffix rules or plain targets given
        on the same makefile line.
        * If two suffixes that together make a two-suffix rule were each
        given twice in the .SUFFIXES list, and in the proper order, two
        identical pattern rules would be created and the second one would
        be discarded here, but both would contain the same `struct commands'
        pointer from the `struct file' for the suffix rule.  */
+       be discarded here, but both would contain the same 'struct commands'
+       pointer from the 'struct file' for the suffix rule.  */
   free (rule);
 …
 /* Print the data base of rules.  */
 static void                     /* Useful to call from gdb.  */
+static void                     /* Useful to call from gdb.  */
 print_rule (struct rule *r)
+{
 …
       if (r->terminal)
         ++terminal;
+        ++terminal;
+    }
 …
+    {
       printf (_("\n# %u implicit rules, %u"), rules, terminal);
 #ifndef NO_FLOAT
+#ifndef NO_FLOAT
       printf (" (%.1f%%)", (double) terminal / (double) rules * 100.0);
 #else
+      {
         int f = (terminal * 1000 + 5) / rules;
         printf (" (%d.%d%%)", f/10, f%10);
+        int f = (terminal * 1000 + 5) / rules;
+        printf (" (%d.%d%%)", f/10, f%10);
+      }
 #endif
 …
          makefiles and thus count_implicit_rule_limits wasn't called yet.  */
       if (num_pattern_rules != 0)
         fatal (NILF, _("BUG: num_pattern_rules is wrong!  %u != %u"),
                num_pattern_rules, rules);
+    }
+}
+        ONN (fatal, NILF, _("BUG: num_pattern_rules is wrong!  %u != %u"),
+             num_pattern_rules, rules);
+    }
+}

vendor/gnumake/current/rule.h

-              r2596
+              r3138
 /* Definitions for using pattern rules in GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
+  {
     struct rule *next;
     const char **targets;       /* Targets of the rule.  */
     unsigned int *lens;         /* Lengths of each target.  */
     const char **suffixes;      /* Suffixes (after `%') of each target.  */
     struct dep *deps;           /* Dependencies of the rule.  */
     struct commands *cmds;      /* Commands to execute.  */
+    const char **targets;       /* Targets of the rule.  */
+    unsigned int *lens;         /* Lengths of each target.  */
+    const char **suffixes;      /* Suffixes (after '%') of each target.  */
+    struct dep *deps;           /* Dependencies of the rule.  */
+    struct commands *cmds;      /* Commands to execute.  */
     unsigned short num;         /* Number of targets.  */
     char terminal;              /* If terminal (double-colon).  */
     char in_use;                /* If in use by a parent pattern_search.  */
+    char terminal;              /* If terminal (double-colon).  */
+    char in_use;                /* If in use by a parent pattern_search.  */
   };
 …
 struct pspec
+  {
     char *target, *dep, *commands;
+    const char *target, *dep, *commands;
   };
 …
                           unsigned int num, int terminal, struct dep *deps,
                           struct commands *commands, int override);
+void print_rule_data_base (void);

vendor/gnumake/current/signame.c

-              r2596
+              r3138
 /* Convert between signal names and numbers.
+Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
+Foundation, Inc.
+Copyright (C) 1990-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 /* If the system provides strsignal, we don't need it. */
 …
 /* Some systems do not define NSIG in <signal.h>.  */
 #ifndef NSIG
 #ifdef  _NSIG
 #define NSIG    _NSIG
+#ifndef NSIG
+#ifdef  _NSIG
+#define NSIG    _NSIG
 #else
 #define NSIG    32
+#define NSIG    32
 #endif
 #endif
 …
 #endif
 #if defined (SIGIO)
   /* "I/O pending" has also been suggested.  A disadvantage is
      that signal only happens when the process has
      asked for it, not everytime I/O is pending.  Another disadvantage
      is the confusion from giving it a different name than under Unix.  */
+  /* "I/O pending" has also been suggested.  A disadvantage is that signal
+     only happens when the process has asked for it, not every time I/O is
+     pending.  Another disadvantage is the confusion from giving it a
+     different name than under Unix.  */
   init_sig (SIGIO, "IO", _("I/O possible"));
 #endif
 …
 #endif
   if (sig > 0 || sig < NSIG)
+  if (sig > 0 && sig < NSIG)
     return (char *) sys_siglist[sig];

vendor/gnumake/current/strcache.c

-              r2596
+              r3138
 /* Constant string caching for GNU Make.
 Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 2006-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
+#include "make.h"
+#include "makeint.h"
+#include <stddef.h>
 #include <assert.h>
 #include "hash.h"
-/* The size (in bytes) of each cache buffer.
-   Try to pick something that will map well into the heap.  */
-#define CACHE_BUFFER_SIZE   (8192 - 16)
 /* A string cached here will never be freed, so we don't need to worry about
 …
    hash so it can be looked up again. */
+typedef unsigned short int sc_buflen_t;
 struct strcache {
   struct strcache *next;    /* The next block of strings.  */
   char *end;                /* Pointer to the beginning of the free space.  */
   int count;                /* # of strings in this buffer (for stats).  */
   int bytesfree;            /* The amount of the buffer that is free.  */
+  struct strcache *next;    /* The next block of strings.  Must be first!  */
+  sc_buflen_t end;          /* Offset to the beginning of free space.  */
+  sc_buflen_t bytesfree;    /* Free space left in this buffer.  */
+  sc_buflen_t count;        /* # of strings in this buffer (for stats).  */
   char buffer[1];           /* The buffer comes after this.  */
 };
+static int bufsize = CACHE_BUFFER_SIZE;
+/* The size (in bytes) of each cache buffer.
+   Try to pick something that will map well into the heap.
+   This must be able to be represented by a short int (<=65535).  */
+#define CACHE_BUFFER_BASE       (8192)
+#define CACHE_BUFFER_ALLOC(_s)  ((_s) - (2 * sizeof (size_t)))
+#define CACHE_BUFFER_OFFSET     (offsetof (struct strcache, buffer))
+#define CACHE_BUFFER_SIZE(_s)   (CACHE_BUFFER_ALLOC(_s) - CACHE_BUFFER_OFFSET)
+#define BUFSIZE                 CACHE_BUFFER_SIZE (CACHE_BUFFER_BASE)
 static struct strcache *strcache = NULL;
+static struct strcache *fullcache = NULL;
+static unsigned long total_buffers = 0;
+static unsigned long total_strings = 0;
+static unsigned long total_size = 0;
 /* Add a new buffer to the cache.  Add it at the front to reduce search time.
 …
  */
 static struct strcache *
+new_cache()
+{
+  struct strcache *new;
+  new = xmalloc (sizeof (*new) + bufsize);
+  new->end = new->buffer;
+new_cache (struct strcache **head, sc_buflen_t buflen)
+{
+  struct strcache *new = xmalloc (buflen + CACHE_BUFFER_OFFSET);
+  new->end = 0;
   new->count = 0;
+  new->bytesfree = bufsize;
+  new->next = strcache;
+  strcache = new;
+  new->bytesfree = buflen;
+  new->next = *head;
+  *head = new;
+  ++total_buffers;
   return new;
+}
 static const char *
+add_string(const char *str, int len)
+{
+  struct strcache *best = NULL;
+copy_string (struct strcache *sp, const char *str, unsigned int len)
+{
+  /* Add the string to this cache.  */
+  char *res = &sp->buffer[sp->end];
+  memmove (res, str, len);
+  res[len++] = '\0';
+  sp->end += len;
+  sp->bytesfree -= len;
+  ++sp->count;
+  return res;
+}
+static const char *
+add_string (const char *str, unsigned int len)
+{
+  const char *res;
   struct strcache *sp;
+  const char *res;
+  struct strcache **spp = &strcache;
+  /* We need space for the nul char.  */
+  unsigned int sz = len + 1;
+  ++total_strings;
+  total_size += sz;
   /* If the string we want is too large to fit into a single buffer, then
+     we're screwed; nothing will ever fit!  Change the maximum size of the
+     cache to be big enough.  */
+  if (len > bufsize)
+    bufsize = len * 2;
+  /* First, find a cache with enough free space.  We always look through all
+     the blocks and choose the one with the best fit (the one that leaves the
+     least amount of space free).  */
+  for (sp = strcache; sp != NULL; sp = sp->next)
+    if (sp->bytesfree > len && (!best || best->bytesfree > sp->bytesfree))
+      best = sp;
+  /* If nothing is big enough, make a new cache.  */
+  if (!best)
+    best = new_cache();
+  assert (best->bytesfree > len);
+  /* Add the string to the best cache.  */
+  res = best->end;
+  memcpy (best->end, str, len);
+  best->end += len;
+  *(best->end++) = '\0';
+  best->bytesfree -= len + 1;
+  ++best->count;
+     no existing cache is large enough.  Add it directly to the fullcache.  */
+  if (sz > BUFSIZE)
+    {
+      sp = new_cache (&fullcache, sz);
+      return copy_string (sp, str, len);
+    }
+  /* Find the first cache with enough free space.  */
+  for (; *spp != NULL; spp = &(*spp)->next)
+    if ((*spp)->bytesfree > sz)
+      break;
+  sp = *spp;
+  /* If nothing is big enough, make a new cache at the front.  */
+  if (sp == NULL)
+    {
+      sp = new_cache (&strcache, BUFSIZE);
+      spp = &strcache;
+    }
+  /* Add the string to this cache.  */
+  res = copy_string (sp, str, len);
+  /* If the amount free in this cache is less than the average string size,
+     consider it full and move it to the full list.  */
+  if (total_strings > 20 && sp->bytesfree < (total_size / total_strings) + 1)
+    {
+      *spp = sp->next;
+      sp->next = fullcache;
+      fullcache = sp;
+    }
   return res;
+}
+/* For strings too large for the strcache, we just save them in a list.  */
+struct hugestring {
+  struct hugestring *next;  /* The next string.  */
+  char buffer[1];           /* The string.  */
+};
+static struct hugestring *hugestrings = NULL;
+static const char *
+add_hugestring (const char *str, unsigned int len)
+{
+  struct hugestring *new = xmalloc (sizeof (struct hugestring) + len);
+  memcpy (new->buffer, str, len);
+  new->buffer[len] = '\0';
+  new->next = hugestrings;
+  hugestrings = new;
+  return new->buffer;
+}
 /* Hash table of strings in the cache.  */
 …
 static const char *
+add_hash (const char *str, int len)
+{
+add_hash (const char *str, unsigned int len)
+{
+  char *const *slot;
+  const char *key;
+  /* If it's too large for the string cache, just copy it.
+     We don't bother trying to match these.  */
+  if (len > USHRT_MAX - 1)
+    return add_hugestring (str, len);
   /* Look up the string in the hash.  If it's there, return it.  */
   char *const *slot = (char *const *) hash_find_slot (&strings, str);
   const char *key = *slot;
   /* Count the total number of adds we performed.  */
+  slot = (char *const *) hash_find_slot (&strings, str);
+  key = *slot;
+  /* Count the total number of add operations we performed.  */
   ++total_adds;
 …
   for (sp = strcache; sp != 0; sp = sp->next)
     if (str >= sp->buffer && str < sp->end)
+    if (str >= sp->buffer && str < sp->buffer + sp->end)
       return 1;
+  for (sp = fullcache; sp != 0; sp = sp->next)
+    if (str >= sp->buffer && str < sp->buffer + sp->end)
+      return 1;
+  {
+    struct hugestring *hp;
+    for (hp = hugestrings; hp != 0; hp = hp->next)
+      if (str == hp->buffer)
+        return 1;
+  }
   return 0;
 …
 const char *
 strcache_add_len (const char *str, int len)
+strcache_add_len (const char *str, unsigned int len)
+{
   /* If we're not given a nul-terminated string we have to create one, because
 …
+}
-int
-strcache_setbufsize(int size)
+{
-  if (size > bufsize)
-    bufsize = size;
-  return bufsize;
+}
 void
 strcache_init (void)
 …
 strcache_print_stats (const char *prefix)
+{
+  int numbuffs = 0, numstrs = 0;
+  int totsize = 0, avgsize, maxsize = 0, minsize = bufsize;
+  int totfree = 0, avgfree, maxfree = 0, minfree = bufsize;
+  int lastused = 0, lastfree = 0;
+  if (strcache)
+    {
+      const struct strcache *sp;
+      /* Count the first buffer separately since it's not full.  */
+      lastused = strcache->end - strcache->buffer;
+      lastfree = strcache->bytesfree;
+      for (sp = strcache->next; sp != NULL; sp = sp->next)
+        {
+          int bf = sp->bytesfree;
+          int sz = sp->end - sp->buffer;
+          ++numbuffs;
+          numstrs += sp->count;
+          totsize += sz;
+          maxsize = (sz > maxsize ? sz : maxsize);
+          minsize = (sz < minsize ? sz : minsize);
+          totfree += bf;
+          maxfree = (bf > maxfree ? bf : maxfree);
+          minfree = (bf < minfree ? bf : minfree);
+        }
+    }
+  avgsize = numbuffs ? (int)(totsize / numbuffs) : 0;
+  avgfree = numbuffs ? (int)(totfree / numbuffs) : 0;
+  printf (_("\n%s # of strings in strcache: %d / lookups = %lu / hits = %lu\n"),
+          prefix, numstrs, total_adds, (total_adds - numstrs));
+  printf (_("%s # of strcache buffers: %d (* %d B/buffer = %d B)\n"),
+          prefix, (numbuffs + 1), bufsize, ((numbuffs + 1) * bufsize));
+  printf (_("%s strcache used: total = %d (%d) / max = %d / min = %d / avg = %d\n"),
+          prefix, totsize, lastused, maxsize, minsize, avgsize);
+  printf (_("%s strcache free: total = %d (%d) / max = %d / min = %d / avg = %d\n"),
+          prefix, totfree, lastfree, maxfree, minfree, avgfree);
+  fputs (_("\n# strcache hash-table stats:\n# "), stdout);
+  const struct strcache *sp;
+  unsigned long numbuffs = 0, fullbuffs = 0;
+  unsigned long totfree = 0, maxfree = 0, minfree = BUFSIZE;
+  if (! strcache)
+    {
+      printf (_("\n%s No strcache buffers\n"), prefix);
+      return;
+    }
+  /* Count the first buffer separately since it's not full.  */
+  for (sp = strcache->next; sp != NULL; sp = sp->next)
+    {
+      sc_buflen_t bf = sp->bytesfree;
+      totfree += bf;
+      maxfree = (bf > maxfree ? bf : maxfree);
+      minfree = (bf < minfree ? bf : minfree);
+      ++numbuffs;
+    }
+  for (sp = fullcache; sp != NULL; sp = sp->next)
+    {
+      sc_buflen_t bf = sp->bytesfree;
+      totfree += bf;
+      maxfree = (bf > maxfree ? bf : maxfree);
+      minfree = (bf < minfree ? bf : minfree);
+      ++numbuffs;
+      ++fullbuffs;
+    }
+  /* Make sure we didn't lose any buffers.  */
+  assert (total_buffers == numbuffs + 1);
+  printf (_("\n%s strcache buffers: %lu (%lu) / strings = %lu / storage = %lu B / avg = %lu B\n"),
+          prefix, numbuffs + 1, fullbuffs, total_strings, total_size,
+          (total_size / total_strings));
+  printf (_("%s current buf: size = %hu B / used = %hu B / count = %hu / avg = %hu B\n"),
+          prefix, (sc_buflen_t)BUFSIZE, strcache->end, strcache->count,
+          (strcache->end / strcache->count));
+  if (numbuffs)
+    {
+      /* Show information about non-current buffers.  */
+      unsigned long sz = total_size - strcache->end;
+      unsigned long cnt = total_strings - strcache->count;
+      sc_buflen_t avgfree = totfree / numbuffs;
+      printf (_("%s other used: total = %lu B / count = %lu / avg = %lu B\n"),
+              prefix, sz, cnt, sz / cnt);
+      printf (_("%s other free: total = %lu B / max = %lu B / min = %lu B / avg = %hu B\n"),
+              prefix, totfree, maxfree, minfree, avgfree);
+    }
+  printf (_("\n%s strcache performance: lookups = %lu / hit rate = %lu%%\n"),
+          prefix, total_adds, (long unsigned)(100.0 * (total_adds - total_strings) / total_adds));
+  fputs (_("# hash-table stats:\n# "), stdout);
   hash_print_stats (&strings, stdout);
+}

vendor/gnumake/current/subproc.bat

-              r2596
+              r3138
 @echo off
+rem Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+rem 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+rem Copyright (C) 1996-2016 Free Software Foundation, Inc.
 rem This file is part of GNU Make.
 rem
 …
 if x%2 == x set MAKE=nmake
 %MAKE% /f %MAKEFILE%
+if ERRORLEVEL 1 exit /B
 cd ..\..

vendor/gnumake/current/tests/ChangeLog.1

-              r3137
+              r3138
+-10-09  Paul Smith  <psmith@gnu.org>
+        * scripts/features/patspecific_vars: Typo fixes.
+-10-05  Paul Smith  <psmith@gnu.org>
+        * test_driver.pl (run_all_tests): Rewrite to be more clear.
+        * scripts/features/jobserver: Avoid using $ENV{HOME} as it doesn't
+        exist everywhere.
+        * scripts/features/default_names: End with 1;
+        * scripts/features/loadapi: Use new calling signatures.  Verify
+        the NOEXPAND flag works.  Test with all valid function name
+        characters.
+-09-29  Paul Smith  <psmith@gnu.org>
+        * scripts/variables/SHELL: Solaris /bin/sh can't handle options in
+        multiple words; skip that test.
+        * scripts/targets/ONESHELL: Ditto.
+        * scripts/variables/GNUMAKEFLAGS: Verify that GNUMAKEFLAGS is
+        cleared and options are not duplicated.
+-09-23  Paul Smith  <psmith@gnu.org>
+        * scripts/options/print-directory: Rename dash-w to
+        print-directory to avoid conflicts with dash-W on case-insensitive
+        filesystems.
+-09-22  Paul Smith  <psmith@gnu.org>
+        * scripts/features/se_implicit: Verify that order-only tokens
+        inside second expansion are parsed correctly.
+        Test for Savannah bug #31155.
+        * run_make_tests.pl (set_more_defaults): If we can't find
+        gnumake.h based on the make program we might be running from a
+        remote build directory.  Parse the Makefile for the right path.
+        Fix some test issues on Solaris.
+        * scripts/features/archives: Determine what output ar gives when
+        adding and replacing objects and compare with that.
+        * scripts/features/escape: Solaris /bin/sh doesn't properly handle
+        backslashes inside single quotes, so don't rely on it.
+        * scripts/features/output-sync: false(1) gives different exit
+        codes on different systems; use "exit 1" instead.
+        * scripts/features/parallelism: Increase the timeout for slower systems.
+-09-21  Paul Smith  <psmith@gnu.org>
+        * scripts/features/archives: Some versions of ar (MacOSX) generate
+        different output when creating archives.  Run it and verify the
+        real output.
+        * scripts/features/default_names: MacOSX is, like Windows,
+        case-preserving / case-insensitive.  Redo the test to avoid
+        checking for "UNIX".
+        * test_driver.pl (attach_default_output): Don't dup stdout into
+        stderr.  Reported by Denis Excoffier <bug-tar@Denis-Excoffier.org>
+        * scripts/features/se_explicit: Fix a test that behaves
+        differently with/without archive capability enabled.
+        * scripts/features/output-sync: Don't test output-sync if it's not
+        enabled.  We also skip it if parallelism is not enabled, although
+        strictly speaking some of the output-sync tests are valid even
+        without parallelism.
+        * scripts/features/jobserver: Move some tests that require the
+        jobserver from features/parallelism to a separate suite.  Only run
+        this if jobserver mode is enabled.
+        * scripts/features/output-sync: Test shell functions writing to
+        stderr in recipes: ensure it's captured via output-sync.  Test
+        output generated while reading makefiles and make sure it's
+        captured via output-sync.  Make sure that fatal errors dump the
+        output so it's not lost.
+        * scripts/options/dash-w: Add a test for -w flag.
+-09-15  Paul Smith  <psmith@gnu.org>
+        * scripts/misc/fopen-fail: Check for failure on infinite recursion.
+        * run_make_tests.pl (run_make_test): Allow the answer string to be
+        undef, which means that we shouldn't compare it at all.  Only the
+        exit code matters in this case.
+        * test_driver.pl (compare_output): Ditto.
+        Test for Savannah bug #27374.
+        * scripts/features/parallelism: Test broken jobserver on recursion.
+        Test for Savannah bug #39934.
+        * scripts/options/eval: Verify --eval during restart.
+        Test for Savannah bug #39203.
+-09-14  Paul Smith  <psmith@gnu.org>
+        * scripts/features/output-sync: Verify -Orecurse properly.
+-09-12  Paul Smith  <psmith@gnu.org>
+        * scripts/features/output-sync: Modify for output sync behavior.
+        * scripts/variables/MAKE_RESTARTS: Ditto.
+        * scripts/variables/MAKEFLAGS: Remove mode for --trace.
+        * scripts/variables/GNUMAKEFLAGS: Ditto.
+-07-22  Paul Smith  <psmith@gnu.org>
+        * scripts/features/rule_glob: Add tests for wildcards in rules.
+        Test for Savannah bug #39310.
+-07-09  Paul Smith  <psmith@gnu.org>
+        * scripts/features/se_implicit: Add a test for SE rules depending
+        on other SE rules to be built.
+-05-26  Paul Smith  <psmith@gnu.org>
+        * scripts/features/archives: Test for Savannah bug #38442.
+        * scripts/misc/bs-nl: Test for Savannah bug #39035.
+        Add a test for Savannah bug #38945.
+-05-22  Paul Smith  <psmith@gnu.org>
+        * scripts/options/dash-n: Fix results after MAKEFLAGS fixes.
+        * scripts/variables/MAKEFLAGS: Ditto.
+        * scripts/variables/GNUMAKEFLAGS: Ditto.
+-05-14  Paul Smith  <psmith@gnu.org>
+        * scripts/features/loadapi: Add plugin_is_GPL_compatible symbol.
+        * scripts/features/load: Ditto.
+-05-13  Paul Smith  <psmith@gnu.org>
+        * scripts/features/output-sync (output_sync_set): Update for new
+        --trace behavior.
+-05-05  Paul Smith  <psmith@gnu.org>
+        * scripts/features/output-sync (output_sync_set): Remove
+        extraneous enter/leave lines, which are no longer printed.
+        Add tests for syncing command line printing.
+        (output_sync_set): Rename options: "job"->"line"; "make"->"recurse"
+-05-04  Paul Smith  <psmith@gnu.org>
+        * scripts/features/loadapi: Use the new alloc functions.
+        * scripts/features/output-sync (output_sync_set): New test for
+        ordered recursive output for -Ojob / -Otarget.
+-05-03  Eli Zaretskii  <eliz@gnu.org>
+        * scripts/features/load: Fix signatures of testload_gmk_setup and
+        explicit_setup, to bring them in line with the documentation.
+-04-28  Paul Smith  <psmith@gnu.org>
+        * scripts/features/output-sync (output_sync_set): Add tests for
+        the per-job syntax mode.
+        (output_sync_set): Test improved error message location.
+-04-15  Paul Smith  <psmith@gnu.org>
+        * scripts/features/output-sync (output_sync_set): New arg syntax.
+-04-14  Paul Smith  <psmith@gnu.org>
+        * scripts/features/output-sync: Rewrite to be more reliable.
+        * test_driver.pl (_run_command): Don't set SIGALRM until after we
+        start the child.  Print errors to the top-level output, which will
+        be stderr.
+        (attach_default_output): Use a list of file handles as the stack.
+        (detach_default_output): Ditto.
+        * scripts/features/output-sync: Add a test for output-sync.
+-02-25  Paul Smith  <psmith@gnu.org>
+        * run_make_tests.pl (valid_option): Support the -srcdir flag.
+        (set_more_defaults): Set up $srcdir if it's not set yet.
+        * scripts/functions/guile: Verify gmk-eval doesn't expand twice.
+        * scripts/features/load: Rework to test just the load capability.
+        * scripts/features/loadapi: New set of tests for the load API.
+-01-19  Paul Smith  <psmith@gnu.org>
+        * scripts/features/load: Test loaded files with and without "./"
+        prefix.  Add tests for automatically rebuilding loaded files if
+        they are out of date or non-existent.
+-01-13  Paul Smith  <psmith@gnu.org>
+        * scripts/features/archives: Add a check targets that have parens,
+        but are not archives.  See Savannah bug #37878.
+        * scripts/options/dash-n: Verify -n is preserved after recursive /
+        re-exec.  See Savannah bug #38051.
+-01-12  Paul Smith  <psmith@gnu.org>
+        * scripts/features/parallelism: Change rule so it doesn't depend
+        on invocation order, etc.
+-10-29  Paul Smith  <psmith@gnu.org>
+        * scripts/features/load: New test suite for the "load" directive.
+-09-09  Paul Smith  <psmith@gnu.org>
+        * scripts/functions/file: Get errors in the C locale, not the
+        current locale.  Fixes Savannah bug #35764.
+        * scripts/features/escape: Check that backslashes before
+        non-special characters are not removed.
+        * scripts/features/utf8: New test for UTF-8 support.
+        See Savannah bug #36529.
+        * scripts/targets/POSIX: Add tests for default macro values as
+        specified by IEEE Std 1003.1-2008.  See Savannah bug #37069.
+-03-04  Paul Smith  <psmith@gnu.org>
+        * scripts/features/se_explicit: Test $(x:%=%) format in secondary
+        expansion prerequisite lists.  See Savannah bug #16545.
+        * scripts/features/escape: Test escaped ":" in prerequisite lists.
+        See Savannah bug #12126.
+        * scripts/variables/private: Test appending private variables in
+        pattern-specific target rules.  See Savannah bug #35468.
+-03-03  Paul Smith  <psmith@gnu.org>
+        * scripts/variables/SHELL: Ensure .SHELLFLAGS works with options
+        separated by whitespace.
+        * scripts/targets/ONESHELL: Try .ONESHELL in combination with
+        whitespace-separated options in .SHELLFLAGS.  See Savannah bug #35397.
+        * scripts/functions/filter-out: Add filter tests and test escape
+        operations.  See Savannah bug #35410.
+        * guile.supp: Suppress valgrind errors from Guile
+        * run_make_tests.pl: Use the Guile suppression file.
+        * scripts/misc/bs-nl: Check for POSIX and non-POSIX
+        backslash/newline handling.  Addresses Savannah bug #16670.
+-01-29  Paul Smith  <psmith@gnu.org>
+        * scripts/variables/flavors: Add tests for ::=
+        * scripts/variables/define: Ditto
+        * scripts/functions/file: Test the new $(file ...) function.
+-01-12  Paul Smith  <psmith@gnu.org>
+        * scripts/functions/guile: New regression tests for Guile support.
+-12-10  Paul Smith  <psmith@gnu.org>
+        * scripts/targets/SECONDARY: Add prereq statements to ensure rules
+        are printed in the right order for test #9
+-11-14  Paul Smith  <psmith@gnu.org>
+        * scripts/features/double_colon: Check double-colon with escaped
+        filenames.  See Savannah bug #33399.
+-09-18  Paul Smith  <psmith@gnu.org>
+        * scripts/features/parallelism: On re-exec make sure we preserve
+        the value of MAKEFLAGS when necessary.  See Savannah bug #33873.
+        * scripts/features/vpath3: Verify handling of -lfoo libraries
+        found via vpath vs. the standard directory search.
+        See Savannah bug #32511.
+-09-12  Paul Smith  <psmith@gnu.org>
+        * scripts/functions/call: Verify that using export in a $(call ...)
+        context creates a global variable.  See Savannah bug #32498.
+-09-02  Paul Smith  <psmith@gnu.org>
+        * scripts/options/dash-n: Verify that in "-n -t", the -n takes
+        priority.  Patch from Michael Witten <mfwitten@gmail.com>.
+-08-29  Paul Smith  <psmith@gnu.org>
+        * scripts/features/varnesting: Test resetting of variables while
+        expanding them.  See Savannah patch #7534
+-06-12  Paul Smith  <psmith@gnu.org>
+        * scripts/features/archives: Check archives with whitespace at the
+        beginning, end, and extra in the middle.
+        Another test for Savannah bug #30612.
+-05-07  Paul Smith  <psmith@gnu.org>
+        * scripts/variables/private: Ensure we skip private variables when
+        appending.  Test for Savannah bug #32872.
+        * scripts/functions/wildcard: Verify wildcard used to test for
+        file existence/non-existence.
+-05-02  Paul Smith  <psmith@gnu.org>
+        * scripts/functions/sort: Add a test for Savannah bug #33125.
+-04-17  David A. Wheeler  <dwheeler@dwheeler.com>
+        * scripts/features/shell_assignment: Regression for "!=" feature
+-11-06  Paul Smith  <psmith@gnu.org>
+        * scripts/features/targetvars: Fix known-good output for BS/NL changes.
+        * scripts/functions/call: Ditto.
+        * scripts/variables/special: Ditto.
+        * scripts/misc/bs-nl: New test suite for backslash/newline testing.
+-08-29  Paul Smith  <psmith@gnu.org>
+        * scripts/features/errors: Add new error message to output text.
+        * scripts/variables/SHELL: Ditto.
+        * scripts/targets/POSIX: Ditto.
+        * scripts/options/dash-k: Ditto.
+        * scripts/features/vpathplus: Ditto.
+        * scripts/features/patternrules: Ditto.
+        * scripts/features/parallelism: Ditto.
+-08-13  Paul Smith  <psmith@gnu.org>
+        * scripts/features/archives: New regression tests for archive
+        support.  Test for fix to Savannah bug #30612.
+        * run_make_tests.pl (set_more_defaults): Set a %FEATURES hash to
+        the features available in $(.FEATURES).
+-08-10  Paul Smith  <psmith@gnu.org>
+        * scripts/features/reinvoke: Ensure command line variable settings
+        are preserved across make re-exec.  Tests Savannah bug #30723.
 -07-28  Paul Smith  <psmith@gnu.org>
 …
         beginning with ".").
         * scripts/functions/andor: Tests for $(and ..) and $(or ...)
+        * scripts/functions/andor: Tests for $(and ...) and $(or ...)
         functions.
 …
 -08-13  Boris Kolpackov  <boris@kolpackov.net>
         * scripts/functions/wildcard: Wrap calls to $(wildcard ) with
+        * scripts/functions/wildcard: Wrap calls to $(wildcard) with
         $(sort) so that the resulting order is no longer filesystem-
         dependant.
+        dependent.
 -08-10  Boris Kolpackov  <boris@kolpackov.net>
 …
 -06-09  Paul D. Smith  <psmith@gnu.org>
         * scripts/functions/foreach: Add a test for Savannah bug #11913.
+        * scripts/functions/foreach: Add a test for Savannah bug #11913.
 -05-31  Boris Kolpackov  <boris@kolpackov.net>
 …
         * scripts/features/parallelism: Add a test for exporting recursive
         variables containing $(shell ) calls.  Rewrite this script to use
+        variables containing $(shell) calls.  Rewrite this script to use
         run_make_test() everywhere.
 …
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+Copyright (C) 1992-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.

vendor/gnumake/current/tests/NEWS

-              r2596
+              r3138
     Also, some tests and stuff still haven't made it in because I
     haven't had time to write the test scripts for them.  But they,
     too, will get in eventually.  Contributions of scripts (ie, tests
+    too, will get in eventually.  Contributions of scripts (i.e., tests
     that I can just drop in) are particularly welcome and will be
     incorporated immediately.
 …
 -------------------------------------------------------------------------------
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+Copyright (C) 1992-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.

vendor/gnumake/current/tests/README

-              r2596
+              r3138
  -----------------------------------------------------------------------------
+ Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 1992-2016 Free Software Foundation, Inc.
  This file is part of GNU Make.
 …
 By default, the test engine picks up the first executable called "make"
 that it finds in your path.  You may use the -make_path option (ie,
+that it finds in your path.  You may use the -make_path option (i.e.,
 "perl run_make_tests -make_path /usr/local/src/make-3.78/make") if
 you want to run a particular copy.  This now works correctly with
 …
 make to be setgid sys or kmem for this; if you don't want to install
 make just to test it, make it setgid to kmem or whatever group /dev/kmem
 is (ie, "chgrp kmem make;chmod g+s make" as root).  In any case, the
+is (i.e., "chgrp kmem make;chmod g+s make" as root).  In any case, the
 options/dash-l test should no longer *fail* because make can't read
 /dev/kmem.

vendor/gnumake/current/tests/mkshadow

-              r2596
+              r3138
 # Typically you'd put the shadow in /tmp or another local disk
+#
+# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
+# Foundation, Inc.
+# Copyright (C) 1992-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 if [ ! -d "$dest" ]; then
   echo "Destination directory \`$dest' must exist!"
+  echo "Destination directory '$dest' must exist!"
   exit 1
 fi
 …
 rm -rf work
 echo "Shadow test suite created in \`$dest/$name'."
+echo "Shadow test suite created in '$dest/$name'."
 exit 0

vendor/gnumake/current/tests/run_make_tests.pl

-              r2596
+              r3138
 #                        (and others)
+# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
+# Foundation, Inc.
+# Copyright (C) 1992-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 # this program.  If not, see <http://www.gnu.org/licenses/>.
+%FEATURES = ();
 $valgrind = 0;              # invoke make with valgrind
 $valgrind_args = '';
 $memcheck_args = '--num-callers=15 --tool=memcheck --leak-check=full';
+$memcheck_args = '--num-callers=15 --tool=memcheck --leak-check=full --suppressions=guile.supp';
 $massif_args = '--num-callers=15 --tool=massif --alloc-fn=xmalloc --alloc-fn=xcalloc --alloc-fn=xrealloc --alloc-fn=xstrdup --alloc-fn=xstrndup';
 $pure_log = undef;
+# The location of the GNU make source directory
+$srcdir = '';
 $command_string = '';
 $all_tests = 0;
+# rmdir broken in some Perls on VMS.
+if ($^O eq 'VMS')
+{
+  require VMS::Filespec;
+  VMS::Filespec->import();
+  sub vms_rmdir {
+    my $vms_file = vmspath($_[0]);
+    $vms_file = fileify($vms_file);
+    my $ret = unlink(vmsify($vms_file));
+    return $ret
+  };
+  *CORE::GLOBAL::rmdir = \&vms_rmdir;
+}
 require "test_driver.pl";
+require "config-flags.pm";
 # Some target systems might not have the POSIX module...
 …
+   }
+   if ($option =~ /^-srcdir$/i) {
+       $srcdir = shift @argv;
+       if (! -f "$srcdir/gnumake.h") {
+           print "$option $srcdir: Not a valid GNU make source directory.\n";
+           exit 0;
+       }
+       return 1;
+   }
    if ($option =~ /^-all([-_]?tests)?$/i) {
        $all_tests = 1;
 …
 $old_makefile = undef;
+sub subst_make_string
+{
+    local $_ = shift;
+    $makefile and s/#MAKEFILE#/$makefile/g;
+    s/#MAKEPATH#/$mkpath/g;
+    s/#MAKE#/$make_name/g;
+    s/#PERL#/$perl_name/g;
+    s/#PWD#/$pwd/g;
+    return $_;
+}
 sub run_make_test
+{
   local ($makestring, $options, $answer, $err_code, $timeout) = @_;
+  my @call = caller;
   # If the user specified a makefile string, create a new makefile to contain
 …
+    }
     # Make sure it ends in a newline.
+    # Make sure it ends in a newline and substitute any special tokens.
     $makestring && $makestring !~ /\n$/s and $makestring .= "\n";
+    # Replace @MAKEFILE@ with the makefile name and @MAKE@ with the path to
+    # make
+    $makestring =~ s/#MAKEFILE#/$makefile/g;
+    $makestring =~ s/#MAKEPATH#/$mkpath/g;
+    $makestring =~ s/#MAKE#/$make_name/g;
+    $makestring =~ s/#PERL#/$perl_name/g;
+    $makestring =~ s/#PWD#/$pwd/g;
+    $makestring = subst_make_string($makestring);
     # Populate the makefile!
 …
   # Do the same processing on $answer as we did on $makestring.
+  $answer && $answer !~ /\n$/s and $answer .= "\n";
+  $answer =~ s/#MAKEFILE#/$makefile/g;
+  $answer =~ s/#MAKEPATH#/$mkpath/g;
+  $answer =~ s/#MAKE#/$make_name/g;
+  $answer =~ s/#PERL#/$perl_name/g;
+  $answer =~ s/#PWD#/$pwd/g;
+  if (defined $answer) {
+      $answer && $answer !~ /\n$/s and $answer .= "\n";
+      $answer = subst_make_string($answer);
+  }
   run_make_with_options($makefile, $options, &get_logfile(0),
                         $err_code, $timeout);
+                        $err_code, $timeout, @call);
   &compare_output($answer, &get_logfile(1));
 …
 # The old-fashioned way...
 sub run_make_with_options {
+  local ($filename,$options,$logname,$expected_code,$timeout) = @_;
+  my ($filename,$options,$logname,$expected_code,$timeout,@call) = @_;
+  @call = caller unless @call;
   local($code);
   local($command) = $make_path;
 …
   if ($options) {
+    if ($^O eq 'VMS') {
+      # Try to make sure arguments are properly quoted.
+      # This does not handle all cases.
+      # VMS uses double quotes instead of single quotes.
+      $options =~ s/\'/\"/g;
+      # If the leading quote is inside non-whitespace, then the
+      # quote must be doubled, because it will be enclosed in another
+      # set of quotes.
+      $options =~ s/(\S)(\".*\")/$1\"$2\"/g;
+      # Options must be quoted to preserve case if not already quoted.
+      $options =~ s/(\S+)/\"$1\"/g;
+      # Special fixup for embedded quotes.
+      $options =~ s/(\"\".+)\"(\s+)\"(.+\"\")/$1$2$3/g;
+      $options =~ s/(\A)(?:\"\")(.+)(?:\"\")/$1\"$2\"/g;
+      # Special fixup for misc/general4 test.
+      $options =~ s/""\@echo" "cc""/\@echo cc"/;
+      $options =~ s/"\@echo link"""/\@echo link"/;
+      # Remove shell escapes expected to be removed by bash
+      if ($options !~ /path=pre/) {
+        $options =~ s/\\//g;
+      }
+      # special fixup for options/eval
+      $options =~ s/"--eval=\$\(info" "eval/"--eval=\$\(info eval/;
+      print ("Options fixup = -$options-\n") if $debug;
+    }
     $command .= " $options";
+  }
+  $command_string = "$command\n";
+  $command_string = "";
+  if (@call) {
+      $command_string = "#$call[1]:$call[2]\n";
+  }
+  $command_string .= "$command\n";
   if ($valgrind) {
 …
       $code = &run_command_with_output($logname,$command);
       $test_timeout = $old_timeout;
+  }
 …
+{
    &print_standard_usage ("run_make_tests",
                           "[-make_path make_pathname] [-memcheck] [-massif]",);
+                          "[-make MAKE_PATHNAME] [-srcdir SRCDIR] [-memcheck] [-massif]",);
+}
 …
+{
    &print_standard_help (
         "-make_path",
+        "-make",
         "\tYou may specify the pathname of the copy of make to run.",
+        "-srcdir",
+        "\tSpecify the make source directory.",
         "-valgrind",
         "-memcheck",
 …
      $port_type = 'OS/2';
+   }
+   # VMS has a GNV Unix mode or a DCL mode.
+   # The SHELL environment variable should not be defined in VMS-DCL mode.
+   elsif ($osname eq 'VMS' && !defined $ENV{"SHELL"}) {
+     $port_type = 'VMS-DCL';
+   }
    # Everything else, right now, is UNIX.  Note that we should integrate
    # the VOS support into this as well and get rid of $vos; we'll do
 …
    # Find the full pathname of Make.  For DOS systems this is more
    # complicated, so we ask make itself.
+   my $mk = `sh -c 'echo "all:;\@echo \\\$(MAKE)" | $make_path -f-'`;
+   chop $mk;
+   $mk or die "FATAL ERROR: Cannot determine the value of \$(MAKE):\n
+   if ($osname eq 'VMS') {
+     $port_type = 'VMS-DCL' unless defined $ENV{"SHELL"};
+     # On VMS pre-setup make to be found with simply 'make'.
+     $make_path = 'make';
+   } else {
+     my $mk = `sh -c 'echo "all:;\@echo \\\$(MAKE)" | $make_path -f-'`;
+     chop $mk;
+     $mk or die "FATAL ERROR: Cannot determine the value of \$(MAKE):\n
 'echo \"all:;\@echo \\\$(MAKE)\" | $make_path -f-' failed!\n";
+   $make_path = $mk;
+   print "Make\t= `$make_path'\n" if $debug;
+   $string = `$make_path -v -f /dev/null 2> /dev/null`;
+     $make_path = $mk;
+   }
+   print "Make\t= '$make_path'\n" if $debug;
+   my $redir2 = '2> /dev/null';
+   $redir2 = '' if os_name eq 'VMS';
+   $string = `$make_path -v -f /dev/null $redir2`;
    $string =~ /^(GNU Make [^,\n]*)/;
    $testee_version = "$1\n";
+   $string = `sh -c "$make_path -f /dev/null 2>&1"`;
+   my $redir = '2>&1';
+   $redir = '' if os_name eq 'VMS';
+   $string = `sh -c "$make_path -f /dev/null $redir"`;
    if ($string =~ /(.*): \*\*\* No targets\.  Stop\./) {
      $make_name = $1;
+   }
    else {
+     if ($make_path =~ /$pathsep([^\n$pathsep]*)$/) {
+       $make_name = $1;
+     }
+     else {
+       $make_name = $make_path;
+     }
+     $make_path =~ /^(?:.*$pathsep)?(.+)$/;
+     $make_name = $1;
+   }
 …
+   {
       $mkpath = $make_path;
+   }
+   # If srcdir wasn't provided on the command line, see if the
+   # location of the make program gives us a clue.  Don't fail if not;
+   # we'll assume it's been installed into /usr/include or wherever.
+   if (! $srcdir) {
+       $make_path =~ /^(.*$pathsep)?/;
+       my $d = $1 || '../';
+       -f "${d}gnumake.h" and $srcdir = $d;
+   }
+   # Not with the make program, so see if we can get it out of the makefile
+   if (! $srcdir && open(MF, "< ../Makefile")) {
+       local $/ = undef;
+       $_ = <MF>;
+       close(MF);
+       /^abs_srcdir\s*=\s*(.*?)\s*$/m;
+       -f "$1/gnumake.h" and $srcdir = $1;
+   }
 …
+   }
    $string = `sh -c "$make_path -j 2 -f /dev/null 2>&1"`;
+   $string = `sh -c "$make_path -j 2 -f /dev/null $redir"`;
    if ($string =~ /not supported/) {
      $parallel_jobs = 0;
 …
+   }
+   %FEATURES = map { $_ => 1 } split /\s+/, `sh -c "echo '\\\$(info \\\$(.FEATURES))' | $make_path -f- 2>/dev/null"`;
    # Set up for valgrind, if requested.
+   $make_command = $make_path;
    if ($valgrind) {

vendor/gnumake/current/tests/scripts/features/conditionals

-              r2596
+              r3138
               'success');
+# SV 47960 : ensure variable assignments in non-taken legs don't cause problems
+run_make_test('
+ifneq ($(FOO),yes)
+target:
+else
+BAR = bar
+target:
+endif
+        @echo one
+',
+              '', "one\n");
 # This tells the test driver that the perl test script executed properly.
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/features/default_names

-              r2596
+              r3138
 close(MAKEFILE);
+# DOS/WIN32 platforms preserve case, but Makefile is the same file as makefile.
+# Just test what we can here (avoid Makefile versus makefile test).
+# Create another makefile called "makefile"
+open(MAKEFILE,"> makefile");
+print MAKEFILE "SECOND: ; \@echo It chose makefile\n";
+close(MAKEFILE);
+if ($port_type eq 'UNIX') {
+  # Create another makefile called "makefile"
+  open(MAKEFILE,"> makefile");
+  print MAKEFILE "SECOND: ; \@echo It chose makefile\n";
+  close(MAKEFILE);
+# DOS/WIN32/MacOSX platforms are case-insensitive / case-preserving, so
+# Makefile is the same file as makefile.  Just test what we can here.
+my $case_sensitive = 0;
+if (! -f 'Makefile') {
+    # Create another makefile called "Makefile"
+    $case_sensitive = 1;
+    open(MAKEFILE,"> Makefile");
+    print MAKEFILE "THIRD: ; \@echo It chose Makefile\n";
+    close(MAKEFILE);
+}
+# Create another makefile called "Makefile"
+open(MAKEFILE,"> Makefile");
+print MAKEFILE "THIRD: ; \@echo It chose Makefile\n";
+close(MAKEFILE);
+run_make_with_options("","",&get_logfile);
+compare_output("It chose GNUmakefile\n",&get_logfile(1));
+unlink($makefile);
+run_make_with_options("","",&get_logfile);
+compare_output("It chose makefile\n",&get_logfile(1));
+unlink("makefile");
+&run_make_with_options("","",&get_logfile);
+&compare_output("It chose GNUmakefile\n",&get_logfile(1));
+unlink $makefile;
+if ($port_type eq 'UNIX') {
+  &run_make_with_options("","",&get_logfile);
+  &compare_output("It chose makefile\n",&get_logfile(1));
+  unlink "makefile";
+if ($case_sensitive) {
+    run_make_with_options("","",&get_logfile);
+    compare_output("It chose Makefile\n",&get_logfile(1));
+    unlink("Makefile");
+}
+&run_make_with_options("","",&get_logfile);
+&compare_output("It chose Makefile\n",&get_logfile(1));
+unlink "Makefile";
+;

vendor/gnumake/current/tests/scripts/features/double_colon

-              r2596
+              r3138
 unlink('result','one','two');
+# TEST 10: SV 33399 : check for proper backslash handling
+run_make_test('
+a\ xb :: ; @echo one
+a\ xb :: ; @echo two
+',
+              '', "one\ntwo\n");
+# Test 11: SV 44742 : All double-colon rules should be run in parallel build.
+run_make_test('result :: 01
+        @echo update
+        @touch $@
+result :: 02
+        @echo update
+        @touch $@
+result :: 03
+        @echo update
+        @touch $@
+result :: 04
+        @echo update
+        @touch $@
+result :: 05
+        @echo update
+        @touch $@
+02 03 04 05:
+        @touch 01 02 03 04 05
+',
+              '-j10 result', "update\nupdate\nupdate\nupdate\nupdate\n");
+unlink('result', '01', '02', '03', '04', '05');
+# Test 12: SV 44742 : Double-colon rules with parallelism
+run_make_test('
+root: all
+        echo root
+all::
+        echo all_one
+all:: 3
+        echo all_two
+%:
+        sleep $*
+',
+              '-rs -j2 1 2 root', "all_one\nall_two\nroot\n");
+# SV 47995 : Parallel double-colon rules with FORCE
+run_make_test('
+all:: ; @echo one
+all:: joe ; @echo four
+joe: FORCE ; touch joe-is-forced
+FORCE:
+',
+              '-j5', "one\ntouch joe-is-forced\nfour\n");
+unlink('joe-is-forced');
 # This tells the test driver that the perl test script executed properly.
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/features/errors

-              r2596
+              r3138
               ."\t-$rm_command cleanit\n"
               ."\t$rm_command foo\n"
               ."clean2: \n"
+              ."clean2: \n"
               ."\t$rm_command cleanit\n"
               ."\t$rm_command foo\n";
 …
 unlink("cleanit");
 $cleanit_error = `sh -c "$rm_command cleanit 2>&1"`;
+chomp $cleanit_error;
 $delete_error_code = $? >> 8;
 …
 # -------
 $answer = "$rm_command cleanit\n"
          . $cleanit_error
+         ."$make_name: [clean] Error $delete_error_code (ignored)\n"
          ."$rm_command foo\n";
+$answer = "$rm_command cleanit
+$cleanit_error
+$make_name: [$makefile:2: clean] Error $delete_error_code (ignored)
+$rm_command foo\n";
 &run_make_with_options($makefile,"",&get_logfile);
 …
 # -------
 $answer = "$rm_command cleanit\n"
          . $cleanit_error
+         ."$make_name: [clean2] Error $delete_error_code (ignored)\n"
          ."$rm_command foo\n";
+$answer = "$rm_command cleanit
+$cleanit_error
+$make_name: [$makefile:5: clean2] Error $delete_error_code (ignored)
+$rm_command foo\n";
 &run_make_with_options($makefile,"clean2 -i",&get_logfile);
 …
+}
+# Test that error line offset works
+run_make_test(q!
+all:
+        @echo hi
+        @echo there
+        @exit 1
+!,
+              '', "hi\nthere\n#MAKE#: *** [#MAKEFILE#:5: all] Error 1", 512);
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/features/escape

-              r2596
+              r3138
 $details = "\
 Make sure that escaping of `:' works in target names.
+Make sure that escaping of ':' works in target names.
 Make sure escaping of whitespace works in target names.
+Make sure that escaping of '#' works.";
+close(MAKEFILE);
+Make sure that escaping of '#' works.
+Make sure that backslash before non-special characters are kept.";
 …
 run_make_test(undef,
               'path=pre:',
               "#MAKEFILE#:2: *** target pattern contains no `%'.  Stop.",
+              "#MAKEFILE#:2: *** target pattern contains no '%'.  Stop.",
 );
 …
 run_make_test(undef,
               "'path=pre\\\\:'",
               "#MAKEFILE#:2: *** target pattern contains no `%'.  Stop.",
+              "#MAKEFILE#:2: *** target pattern contains no '%'.  Stop.",
 );
 …
               'foo#bar.ext = (foo#bar.ext)');
+# Test escaped colons in prerequisites
+# Quoting of backslashes in q!! is kind of messy.
+# Solaris sh does not properly handle backslashes even in '' so just
+# check the output make prints, not what the shell interprets.
+run_make_test(q!
+foo: foo\\:bar foo\\\\\\:bar foo\\\\\\\\\\:bar
+foo foo\\:bar foo\\\\\\:bar foo\\\\\\\\\\:bar: ; : '$@'
+!,
+              '', ": 'foo:bar'\n: 'foo\\:bar'\n: 'foo\\\\:bar'\n: 'foo'\n");
+# Test backslash before non-special chars: should be kept as-is
+run_make_test(q!
+all: ..\foo
+.DEFAULT: ; : '$@'
+!,
+              '', ": '..\\foo'\n");
 # This tells the test driver that the perl test script executed properly.
 ;

vendor/gnumake/current/tests/scripts/features/include

-              r2596
+              r3138
 #                                     -*-mode: perl; rm-trailing-spaces: nil-*-
 $description = "Test various forms of the GNU make `include' command.";
+$description = "Test various forms of the GNU make 'include' command.";
 $details = "\
 …
 ',
    '',
    "#MAKE#: *** No rule to make target `foo.mk', needed by `error'.  Stop.\n",
+   "#MAKE#: *** No rule to make target 'foo.mk', needed by 'error'.  Stop.\n",
   );
 …
 ',
 '',
 "#MAKE#: *** No rule to make target `baz', needed by `bar'.  Stop.\n",
+"#MAKE#: *** No rule to make target 'baz', needed by 'bar'.  Stop.\n",
 );
 …
 ',
 '',
 "#MAKE#: *** No rule to make target `end', needed by `baz'.  Stop.\n",
+"#MAKE#: *** No rule to make target 'end', needed by 'baz'.  Stop.\n",
 );
 …
 '',
 "#MAKEFILE#:2: bar: No such file or directory
 #MAKE#: *** No rule to make target `end', needed by `baz'.  Stop.\n",
+#MAKE#: *** No rule to make target 'end', needed by 'baz'.  Stop.\n",
 );
+# Test include of make-able file doesn't show an error (Savannah #102)
+run_make_test(q!
+.PHONY: default
+default:; @echo DONE
+inc1:; echo > $@
+include inc1
+include inc2
+inc2:; echo > $@
+!,
+              '', "echo > inc2\necho > inc1\nDONE\n");
+rmfiles('inc1', 'inc2');
+# Test include of non-make-able file does show an error (Savannah #102)
+run_make_test(q!
+.PHONY: default
+default:; @echo DONE
+inc1:; echo > $@
+include inc1
+include inc2
+!,
+              '', "#MAKEFILE#:7: inc2: No such file or directory\n#MAKE#: *** No rule to make target 'inc2'.  Stop.\n", 512);
+rmfiles('inc1');
+# Include same file multiple times
+run_make_test(q!
+default:; @echo DEFAULT
+include inc1
+inc1:; echo > $@
+include inc1
+!,
+              '', "echo > inc1\nDEFAULT\n");
+rmfiles('inc1');
+# Included file has a prerequisite that fails to build
+run_make_test(q!
+default:; @echo DEFAULT
+include inc1
+inc1: foo; echo > $@
+foo:; exit 1
+!,
+              '', "exit 1\n#MAKEFILE#:3: inc1: No such file or directory\n#MAKE#: *** [#MAKEFILE#:5: foo] Error 1\n", 512);
+rmfiles('inc1');
+# Included file has a prerequisite we don't know how to build
+run_make_test(q!
+default:; @echo DEFAULT
+include inc1
+inc1: foo; echo > $@
+!,
+              '', "#MAKEFILE#:3: inc1: No such file or directory\n#MAKE#: *** No rule to make target 'foo', needed by 'inc1'.  Stop.\n", 512);
+rmfiles('inc1');
+# include a directory
 if ($all_tests) {
 …
 foo: ; @echo foo = bar > $@
 !,
                   '', "#MAKE#: `foo' is up to date.\n");
+                  '', "#MAKE#: 'foo' is up to date.\n");
     rmfiles('foo');
+}

vendor/gnumake/current/tests/scripts/features/mult_rules

r2596	r3138
48	48
49	49	# Create the answer to what should be produced by this Makefile
50		$answer = "$make_name: *** No rule to make target ~~`extra.h', needed by `~~foo.o'. Stop.\n";
	50	$answer = "$make_name: *** No rule to make target 'extra.h', needed by 'foo.o'. Stop.\n";
51	51
52	52	&compare_output($answer,&get_logfile(1));

vendor/gnumake/current/tests/scripts/features/parallelism

-              r2596
+              r3138
 .inc: ; \@$sleep_command 1; echo THREE.inc; echo '2: ; \@$sleep_command 1; echo THREE' > \$\@",
               "-j4",
               "ONE.inc\nTHREE.inc\nTWO.inc\nONE\nTHREE\nTWO\nsuccess\n");
+              "ONE.inc\nTHREE.inc\nTWO.inc\nONE\nTHREE\nTWO\nsuccess\n", 0, 7);
 rmfiles(qw(1.inc 2.inc));
 …
 .inc: ; \@$sleep_command 1; echo THREE.inc; echo '2: ; \@$sleep_command 1; echo THREE' > \$\@",
               "-j4",
               "ONE.inc\nTHREE.inc\nTWO.inc\nONE\nTHREE\nTWO\nsuccess\n");
+              "ONE.inc\nTHREE.inc\nTWO.inc\nONE\nTHREE\nTWO\nsuccess\n", 0, 7);
 rmfiles(qw(1.inc 2.inc));
 …
 fail.1 fail.2 fail.3:
         \@sleep \$(patsubst fail.%,%,\$\@)
+        \@$sleep_command \$(patsubst fail.%,%,\$\@)
         \@echo Fail
         \@exit 1
 ok:
         \@sleep 4
+        \@$sleep_command 4
         \@echo Ok done",
               '-rR -j5', 'Fail
 #MAKE#: *** [fail.1] Error 1
+              '-rR -j5', "Fail
+#MAKE#: *** [#MAKEFILE#:8: fail.1] Error 1
 #MAKE#: *** Waiting for unfinished jobs....
 Fail
 #MAKE#: *** [fail.2] Error 1
+#MAKE#: *** [#MAKEFILE#:8: fail.2] Error 1
 Fail
 #MAKE#: *** [fail.3] Error 1
 Ok done',
+#MAKE#: *** [#MAKEFILE#:8: fail.3] Error 1
+Ok done",
 );
 …
 rmfiles('target');
+# TEST #10: Don't put --jobserver-fds into a re-exec'd MAKEFLAGS.
+# We can't test this directly because there's no way a makefile can
+# show the value of MAKEFLAGS we were re-exec'd with.  We can intuit it
+# by looking for "disabling jobserver mode" warnings; we should only
+# get one from the original invocation and none from the re-exec.
+# See Savannah bug #18124
+# TEST #11: Make sure -jN from MAKEFLAGS is processed even when we re-exec
+# See Savannah bug #33873
+$extraENV{MAKEFLAGS} = '-j4';
 run_make_test(q!
+things = thing1 thing2
+all: $(things)
+thing1:; @sleep 1; echo '$@ start'; sleep 2; echo '$@ end'
+thing2:; @echo '$@ start'; sleep 2; echo '$@ end'
 -include inc.mk
+recur:
+#       @echo 'MAKEFLAGS = $(MAKEFLAGS)'
+        @rm -f inc.mk
+        @$(MAKE) -j2 -f #MAKEFILE# all
+all:
+#       @echo 'MAKEFLAGS = $(MAKEFLAGS)'
+        @echo $@
+inc.mk:
+#       @echo 'MAKEFLAGS = $(MAKEFLAGS)'
+        @echo 'FOO = bar' > $@
+inc.mk: ; @touch $@
 !,
+              '--no-print-directory -j2', "#MAKE#[1]: warning: -jN forced in submake: disabling jobserver mode.\nall\n");
+              '', "thing2 start\nthing1 start\nthing2 end\nthing1 end\n");
+delete $extraENV{MAKEFLAGS};
 rmfiles('inc.mk');
+if ($all_tests) {
+    # Implicit files aren't properly recreated during parallel builds
+    # Savannah bug #26864
+    # The first run works fine
+    run_make_test(q!
+%.bar: %.x foo.y ; cat $^ > $@
+%.x: ; touch $@
+foo.y: foo.y.in ; cp $< $@
+foo.y.in: ; touch $@
+# Ensure intermediate/secondary files are not pruned incorrectly.
+# See Savannah bug #30653
+utouch(-15, 'file2');
+utouch(-10, 'file4');
+utouch(-5,  'file1');
+run_make_test(q!
+.INTERMEDIATE: file3
+file4: file3 ; @mv -f $< $@
+file3: file2 ; touch $@
+file2: file1 ; @touch $@
 !,
+                  '-j2 main.bar',
+                  "touch foo.y.in
+touch main.x
+cp foo.y.in foo.y
+cat main.x foo.y > main.bar
+rm main.x");
+    # Now we touch the .in file and make sure it still works
+    touch('foo.y.in');
+    run_make_test(undef, '-j2 main.bar', "cp foo.y.in foo.y
+touch main.x
+cat main.x foo.y > main.bar
+rm main.x");
+    # Clean up
+    rmfiles(qw(foo.y foo.y.in main.bar));
+}
+if ($all_tests) {
+    # Jobserver FD handling is messed up in some way.
+    # Savannah bug #28189
+    # It doesn't look like that bug anymore but this is the code it runs
+    run_make_test(q!
+ifdef EXTRA
+vpath %.dst /
+xxx.dst: ; true
+yyy.dst: ; true
+endif
+M := $(MAKE)
+xx: ; $M --no-print-directory -j2 -f $(MAKEFILE_LIST) xxx.dst yyy.dst EXTRA=1
+!,
+                  '-j2',
+                  '#MAKE#[1]: warning: -jN forced in submake: disabling jobserver mode.
+true
+true
+');
+}
+              '--no-print-directory -j2', "touch file3");
+rmfiles('file1', 'file2', 'file3', 'file4');
 # Make sure that all jobserver FDs are closed if we need to re-exec the
 …
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/features/patspecific_vars

-              r2596
+              r3138
 b%: pattern := good $$t
 global := orginal $$t
+global := original $$t
 …
 endif
 %z: ; @echo \'pattrn: $a;\'
+%z: ; @echo \'pattern: $a;\'
 …
 ',
 '',
 'normal: global: orginal $t pattern:  inherit: ;
 pattrn: global: orginal $t pattern:  inherit: ;');
+'normal: global: original $t pattern:  inherit: ;
+pattern: global: original $t pattern:  inherit: ;');
 …
 'rec=1',
 'normal: global: new $t pattern: good $t inherit: good $t;
 pattrn: global: new $t pattern: good $t inherit: good $t;');
+pattern: global: new $t pattern: good $t inherit: good $t;');
 # TEST #8: override in pattern-specific variables

vendor/gnumake/current/tests/scripts/features/patternrules

-              r2596
+              r3138
 ',
 "dir=$dir",
 "#MAKE#: *** [$dir/foo.bar] Error 1",
+"#MAKE#: *** [#MAKEFILE#:6: $dir/foo.bar] Error 1",
 );
 …
 !,
               'foo.tex',
               "#MAKE#: *** No rule to make target `foo.tex'.  Stop.", 512);
+              "#MAKE#: *** No rule to make target 'foo.tex'.  Stop.", 512);
 unlink(@f);
 …
 # This tells the test driver that the perl test script executed properly.
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/features/recursion

-              r2596
+              r3138
               ('CFLAGS=-O -w' . ($parallel_jobs ? ' -j 2' : '')),
               ($vos
                ? "#MAKE#: Entering directory `#PWD#'
+               ? "#MAKE#: Entering directory '#PWD#'
 make 'CFLAGS=-O' -f #MAKEFILE# foo
 make CFLAGS=-O
 …
 MAKELEVEL = 0
 THE END
 #MAKE#: Leaving directory `#PWD#'"
                : "#MAKE#: Entering directory `#PWD#'
+#MAKE#: Leaving directory '#PWD#'"
+               : "#MAKE#: Entering directory '#PWD#'
 #MAKEPATH# -f #MAKEFILE# foo
 #MAKE#[1]: Entering directory `#PWD#'
+#MAKE#[1]: Entering directory '#PWD#'
 #MAKEPATH#
 MAKELEVEL = 1
 #MAKEPATH# -f #MAKEFILE# last
 #MAKE#[2]: Entering directory `#PWD#'
+#MAKE#[2]: Entering directory '#PWD#'
 #MAKEPATH#
 MAKELEVEL = 2
 THE END
 #MAKE#[2]: Leaving directory `#PWD#'
 #MAKE#[1]: Leaving directory `#PWD#'
 #MAKE#: Leaving directory `#PWD#'"));
+#MAKE#[2]: Leaving directory '#PWD#'
+#MAKE#[1]: Leaving directory '#PWD#'
+#MAKE#: Leaving directory '#PWD#'"));

vendor/gnumake/current/tests/scripts/features/reinvoke

-              r2596
+              r3138
 # including: this and the previous one test different parts of the code.
 run_make_test(undef, "F=b", "[ -f b ] || echo >> b\nhello\n")
+run_make_test(undef, 'F=b', "[ -f b ] || echo >> b\nhello\n")
 &rmfiles('a','b','c');
+# Ensure command line variables are preserved properly across re-exec
+# Tests for Savannah bug #30723
+run_make_test('
+ifdef RECURSE
+-include foo30723
+endif
+recurse: ; @$(MAKE) -f $(MAKEFILE_LIST) RECURSE=1 test
+test: ; @echo F.O=$(F.O)
+foo30723: ; @touch $@
+',
+              '--no-print-directory F.O=bar', "F.O=bar\n");
+unlink('foo30723');
 # This tells the test driver that the perl test script executed properly.
 ;

vendor/gnumake/current/tests/scripts/features/se_explicit

-              r2596
+              r3138
 # TEST #0: Test handing of '$' in prerequisites with and without second
 # expansion.
+# If we don't support archives then the prerequisite is different
+my $prereq = exists $FEATURES{'archives'} ? '$' : '$(PRE)';
 run_make_test(q!
 …
 !,
               '',
               "\$\nbar\$biz\nfoo\$bar : bar\$baz bar\$biz");
+              "$prereq\nbar\$biz\nfoo\$bar : bar\$baz bar\$biz");
 run_make_test(undef, 'SE=1', "three\nfour\nbariz\nfoo\$bar : baraz bariz");
 …
 all : $$(eval $$(info test))
 !,
             '', "test\n#MAKE#: Nothing to be done for `all'.\n");
+            '', "test\n#MAKE#: Nothing to be done for 'all'.\n");
 # TEST #5: (NEGATIVE) catch eval in a prereq list trying to create new
 …
+# This tells the test driver that the perl test script executed properly.
+# Allow patsubst shorthand in second expansion context.
+# Requires the colon to be quoted.  Savannah bug #16545
+run_make_test(q!
+.PHONY: foo.bar
+.SECONDEXPANSION:
+foo: $$(@\\:%=%.bar); @echo '$^'
+!,
+              '', "foo.bar\n");
 ;

vendor/gnumake/current/tests/scripts/features/se_implicit

-              r2596
+              r3138
               '', "\n");
+# Test #10: Test second expansion with second expansion prerequisites
+# Ensures pattern_search() recurses with SE prereqs.
+touch('a');
+run_make_test(q!
+.SECONDEXPANSION:
+sim_base_rgg := just_a_name
+sim_base_src := a
+sim_base_f := a a a
+sim_%.f: $${sim_$$*_f}
+        echo $@
+sim_%.src: $${sim_$$*_src}
+        echo $@
+sim_%: \
+        $$(if $$(sim_$$*_src),sim_%.src) \
+        $$(if $$(sim_$$*_f),sim_%.f) \
+        $$(if $$(sim_$$*_rgg),$$(sim_$$*_rgg).s)
+        echo $@
+!,
+              '-s sim_base', "#MAKE#: *** No rule to make target 'sim_base'.  Stop.", 512);
+unlink('a');
+# Ensure that order-only tokens embedded in second expansions are parsed
+run_make_test(q!
+.SECONDEXPANSION:
+PREREQS=p1|p2
+P2=p2
+all : foo bar
+f%o: $$(PREREQS) ; @echo '$@' from '$^' and '$|'
+b%r: p1|$$(P2)   ; @echo '$@' from '$^' and '$|'
+p% : ; : $@
+!,
+              "", ": p1\n: p2\nfoo from p1 and p2\nbar from p1 and p2\n");
 # This tells the test driver that the perl test script executed properly.
 ;

vendor/gnumake/current/tests/scripts/features/targetvars

-              r2596
+              r3138
 run_make_test(undef, 'FOO=C', "C f1\n");
+# TEST #19: Conditional variables with command-line settings
+run_make_test('
+a: FOO ?= f1
+a: ; @echo "$(FOO)"
+',
+              '', "f1\n");
+run_make_test(undef, 'FOO=C', "C\n");
 # TEST #20: Check for continuation after semicolons
 run_make_test(q!
 a: A = 'hello; \
+a: A = 'hello;\
 world'
 a: ; @echo $(A)

vendor/gnumake/current/tests/scripts/features/varnesting

-              r2596
+              r3138
+$description = "The following test creates a makefile to ...";
+#                                                                    -*-perl-*-
+$description = "Test recursive variables";
 $details = "";
+open(MAKEFILE,"> $makefile");
+run_make_test('
+x = variable1
+variable2 := Hello
+y = $(subst 1,2,$(x))
+z = y
+a := $($($(z)))
+all:
+        @echo $(a)
+',
+              '', "Hello\n");
+# The Contents of the MAKEFILE ...
+# This tests resetting the value of a variable while expanding it.
+# You may only see problems with this if you're using valgrind or
+# some other memory checker that poisons freed memory.
+# See Savannah patch #7534
+print MAKEFILE "x = variable1\n"
+              ."variable2 := Hello\n"
+              ."y = \$(subst 1,2,\$(x))\n"
+              ."z = y\n"
+              ."a := \$(\$(\$(z)))\n"
+              ."all: \n"
+              ."\t\@echo \$(a)\n";
+# END of Contents of MAKEFILE
+close(MAKEFILE);
+&run_make_with_options($makefile,"",&get_logfile);
+# Create the answer to what should be produced by this Makefile
+$answer = "Hello\n";
+&compare_output($answer,&get_logfile(1));
+run_make_test('
+VARIABLE = $(eval VARIABLE := echo hi)$(VARIABLE)
+wololo:
+        @$(VARIABLE)
+',
+              '', "hi\n");
 ;

vendor/gnumake/current/tests/scripts/features/vpath

r2596	r3138
75	75	vpath-d/fail.te:
76	76	!,
77		'', "#MAKE#: Nothing to be done for `default'.\n");
	77	'', "#MAKE#: Nothing to be done for 'default'.\n");
78	78
79	79	rmdir('vpath-d');

vendor/gnumake/current/tests/scripts/features/vpath3

-              r2596
+              r3138
 #                                                                     -*-perl-*-
+#                                                                    -*-perl-*-
 $description = "Test the interaction of the -lfoo feature and vpath";
 $details = "";
+open(MAKEFILE,"> $makefile");
+my @dirs_to_make = qw(a1 b1 a2 b2 b3);
+for my $d (@dirs_to_make) {
+    mkdir($d, 0777);
+}
+# The Contents of the MAKEFILE ...
+print MAKEFILE "vpath %.a a1\n";
+print MAKEFILE "vpath %.so b1\n";
+print MAKEFILE "vpath % a2 b2\n";
+print MAKEFILE "vpath % b3\n";
+print MAKEFILE "all: -l1 -l2 -l3; \@echo \$^\n";
+# END of Contents of MAKEFILE
+close(MAKEFILE);
+mkdir("a1", 0777);
+mkdir("b1", 0777);
+mkdir("a2", 0777);
+mkdir("b2", 0777);
+mkdir("b3", 0777);
+@files_to_touch = ("a1${pathsep}lib1.a",
+                   "b1${pathsep}lib1.so",
+                   "a2${pathsep}lib2.a",
+                   "b2${pathsep}lib2.so",
+                   "lib3.a",
+                   "b3${pathsep}lib3.so");
+my @files_to_touch = ("a1${pathsep}lib1.a",
+                      "a1${pathsep}libc.a",
+                      "b1${pathsep}lib1.so",
+                      "a2${pathsep}lib2.a",
+                      "b2${pathsep}lib2.so",
+                      "lib3.a",
+                      "b3${pathsep}lib3.so");
 &touch(@files_to_touch);
+&run_make_with_options($makefile,"",&get_logfile);
+my $answer = "a1${pathsep}lib1.a a1${pathsep}libc.a " .
+             "a2${pathsep}lib2.a lib3.a\n";
+if ($port_type eq 'VMS-DCL') {
+    $answer =~ s/ /,/g;
+}
+# Create the answer to what should be produced by this Makefile
+$answer = "a1${pathsep}lib1.a a2${pathsep}lib2.a lib3.a\n";
+run_make_test('
+vpath %.h b3
+vpath %.a a1
+vpath %.so b1
+vpath % a2 b2
+vpath % b3
+all: -l1 -lc -l2 -l3; @echo $^
+',
+              '', $answer);
+if (&compare_output($answer,&get_logfile(1)))
+{
+  unlink @files_to_touch;
+  rmdir("a1");
+  rmdir("b1");
+  rmdir("a2");
+  rmdir("b2");
+  rmdir("b3");
+unlink(@files_to_touch);
+for my $d (@dirs_to_make) {
+    rmdir($d);
+}

vendor/gnumake/current/tests/scripts/features/vpathgpath

r2596	r3138
58	58	push(@touchedfiles, "bar.c");
59	59
60		$answer = "$make_name: Nothing to be done for `general'.\n";
	60	$answer = "$make_name: Nothing to be done for 'general'.\n";
61	61
62	62	&compare_output($answer,&get_logfile(1));

vendor/gnumake/current/tests/scripts/features/vpathplus

-              r2596
+              r3138
 $answer = "not creating notarget.c from notarget.d
 cat notarget.c > notarget.b 2>/dev/null || exit 1
 $make_name: *** [notarget.b] Error 1
+$make_name: *** [$makefile:16: notarget.b] Error 1
 ";
 …
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/functions/call

-              r2596
+              r3138
 results.\n";
+open(MAKEFILE, "> $makefile");
+# The Contents of the MAKEFILE ...
+print MAKEFILE <<'EOMAKE';
+run_make_test(q!
 # Simple, just reverse two things
+#
 reverse = $2 $1
 # A complex `map' function, using recursive `call'.
+# A complex 'map' function, using recursive 'call'.
+#
 map = $(foreach a,$2,$(call $1,$a))
 …
 DEP_baz = quux blarp
 rest = $(wordlist 2,$(words ${1}),${1})
 tclose = $(if $1,$(firstword $1) \
+tclose = $(if $1,$(firstword $1)\
                 $(call tclose,$(sort ${DEP_$(firstword $1)} $(call rest,$1))))
 …
         echo '$(call my-if,a,b,c)'; \
         echo '$(call two,bar,baz)'; \
+        echo '$(call tclose,foo)'
+        echo '$(call tclose,foo)';
+!,
+              "", "foo bar\ndefault file file\nb d f\n\n\nb\nbar foo baz\nfoo bar baz blarp quux \n");
+EOMAKE
+# These won't work until/unless PR/1527 is resolved.
+#        echo '$(call my-foreach,a,x y z,$(a)$(a))'; \
+#        echo '$(call my-if,,$(warning don't print this),ok)'
+# These won't work because call expands all its arguments first, before
+# passing them on, then marks them as resolved/simple, so they're not
+# expanded again by the function.
+#
+# $answer = "xx yy zz\nok\n";
+# END of Contents of MAKEFILE
+close(MAKEFILE);
+&run_make_with_options($makefile, "", &get_logfile);
+$answer = "foo bar\ndefault file file\nb d f\n\n\nb\nbar foo baz\nfoo bar baz blarp quux \n";
+&compare_output($answer, &get_logfile(1));
+#        echo '$(call my-foreach,a,x y z,$$(a)$$(a))'; \
+#        echo '$(call my-if,,$$(info don't print this),$$(info do print this))'
+#
+# $answer = "xx yy zz\ndo print this\n";
 # TEST eclipsing of arguments when invoking sub-calls
+$makefile2 = &get_tmpfile;
+open(MAKEFILE,"> $makefile2");
+print MAKEFILE <<'EOF';
+run_make_test(q!
 all = $1 $2 $3 $4 $5 $6 $7 $8 $9
 …
         @echo $(call level2,1,2,3,4,5,6,7,8)
         @echo $(call level3,1,2,3,4,5,6,7,8)
+EOF
+!,
+              "", "1 2 3 4 5 6 7 8 9\n1 2 3 4 5\n1 2 3\n1 2 3\n");
+close(MAKEFILE);
+# Ensure that variables are defined in global scope even in a $(call ...)
+&run_make_with_options($makefile2, "", &get_logfile);
+$answer = "1 2 3 4 5 6 7 8 9\n1 2 3 4 5\n1 2 3\n1 2 3\n";
+&compare_output($answer,&get_logfile(1));
+delete $ENV{X123};
+run_make_test('
+tst = $(eval export X123)
+$(call tst)
+all: ; @echo "$${X123-not set}"
+',
+              '', "\n");
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/functions/error

-              r2596
+              r3138
 &run_make_with_options($makefile, "ERROR4=definitely", &get_logfile, 512);
 $answer = "Some stuff\n$makefile:16: *** error is definitely.  Stop.\n";
+$answer = "Some stuff\n$makefile:17: *** error is definitely.  Stop.\n";
 &compare_output($answer,&get_logfile(1));
 …
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/functions/filter-out

-              r2596
+              r3138
 #                                                                    -*-perl-*-
 $description = "Test the filter-out function.";
+$description = "Test the filter and filter-out functions.";
 $details = "The makefile created in this test has two variables.  The
 …
 functions is the same single .elc name.\n";
+open(MAKEFILE,"> $makefile");
+# Basic test -- filter
+run_make_test(q!
+files1 := $(filter %.o, foo.elc bar.o lose.o)
+files2 := $(filter %.o foo.i, foo.i bar.i lose.i foo.elc bar.o lose.o)
+all: ; @echo '$(files1) $(files2)'
+!,
+              '', "bar.o lose.o foo.i bar.o lose.o\n");
+print MAKEFILE <<'EOF';
+# Basic test -- filter-out
+run_make_test(q!
 files1 := $(filter-out %.o, foo.elc bar.o lose.o)
 files2 := $(filter-out foo.i bar.i lose.i %.o, foo.i bar.i lose.i foo.elc bar.o lose.o)
+all: ; @echo $(files1) $(files2)
+EOF
+all: ; @echo '$(files1) $(files2)'
+!,
+              '', "foo.elc foo.elc\n");
+close(MAKEFILE);
+# Escaped patterns
+run_make_test(q!all:;@echo '$(filter foo\%bar,foo%bar fooXbar)'!,
+              '', "foo%bar\n");
+&run_make_with_options($makefile, "", &get_logfile, 0);
+$answer = "foo.elc foo.elc\n";
+&compare_output($answer,&get_logfile(1));
+run_make_test(q!all:;@echo '$(filter foo\%\%\\\\\%\%bar,foo%%\\%%bar fooX\\Ybar)'!,
+              '', "foo%%\\%%bar\n");
+run_make_test(q!
+X = $(filter foo\\\\\%bar,foo\%bar foo\Xbar)
+all:;@echo '$(X)'!,
+              '', "foo\\%bar\n");
 ;

vendor/gnumake/current/tests/scripts/functions/foreach

-              r2596
+              r3138
 #                                                                    -*-perl-*-
 # $Id: foreach,v 1.5 2006/03/10 02:20:46 psmith Exp $
+# $Id$
 $description = "Test the foreach function.";
 …
               'FOREACH');
+# Allow variable names with trailing space
+run_make_test(q!
+$(foreach \
+  a \
+, b c d \
+, $(info $a))
+all:;@:
+!,
+              "", "b\nc\nd\n");
+# TEST 2: Check some error conditions.
+# Allow empty variable names.  We still expand the body.
+run_make_test('
+x = $(foreach ,1 2 3,a)
+y := $x
+all: ; @echo $y',
+              '', "a a a\n");
+# Check some error conditions.
 run_make_test('
 …
 all: ; @echo $y',
               '',
               "#MAKEFILE#:2: *** insufficient number of arguments (1) to function `foreach'.  Stop.",
+              "#MAKEFILE#:2: *** insufficient number of arguments (1) to function 'foreach'.  Stop.",
 );
 run_make_test('
 x = $(foreach )
+x = $(foreach x,y)
 y := $x
 all: ; @echo $y',
               '',
               "#MAKEFILE#:2: *** insufficient number of arguments (1) to function `foreach'.  Stop.",
+              "#MAKEFILE#:2: *** insufficient number of arguments (2) to function 'foreach'.  Stop.",
 );

vendor/gnumake/current/tests/scripts/functions/shell

-              r2596
+              r3138
 $details = '';
+# Test standard shell
+run_make_test('.PHONY: all
+OUT := $(shell echo hi)
+all: ; @echo $(OUT)
+              ','','hi');
 # Test shells inside rules.
 run_make_test('.PHONY: all
 all: ; @echo $(shell echo hi)
+','','hi');
+              ','','hi');
+# Verify .SHELLSTATUS
+run_make_test('.PHONY: all
+PRE := $(.SHELLSTATUS)
+$(shell exit 0)
+OK := $(.SHELLSTATUS)
+$(shell exit 1)
+BAD := $(.SHELLSTATUS)
+all: ; @echo PRE=$(PRE) OK=$(OK) BAD=$(BAD)
+              ','','PRE= OK=0 BAD=1');
 …
 .PHONY: all
 all: ; @echo $$HI
+','','hi');
+    ','','hi');
+# Test shell errors in recipes including offset
+run_make_test('
+all:
+        @echo hi
+        $(shell ./basdfdfsed there)
+        @echo there
+',
+              '', "#MAKE#: ./basdfdfsed: Command not found\nhi\nthere\n");
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/functions/sort

-              r2596
+              r3138
+$description = "The following test creates a makefile to verify\n"
+              ."the ability of make to sort lists of object. Sort\n"
+              ."will also remove any duplicate entries. This will also\n"
+              ."be tested.";
+#                                                                    -*-perl-*-
+$details = "The make file is built with a list of object in a random order\n"
+          ."and includes some duplicates. Make should sort all of the elements\n"
+          ."remove all duplicates\n";
+$description = "The following test creates a makefile to verify
+the ability of make to sort lists of object. Sort
+will also remove any duplicate entries. This will also
+be tested.";
+open(MAKEFILE,"> $makefile");
+$details = "The make file is built with a list of object in a random order
+and includes some duplicates. Make should sort all of the elements
+remove all duplicates\n";
+# The Contents of the MAKEFILE ...
+print MAKEFILE "foo := moon_light days \n"
+              ."foo1:= jazz\n"
+              ."bar := captured \n"
+              ."bar2 = boy end, has rise A midnight \n"
+              ."bar3:= \$(foo)\n"
+              ."s1  := _by\n"
+              ."s2  := _and_a\n"
+              ."t1  := \$(addsuffix \$(s1), \$(bar) )\n"
+              ."t2  := \$(addsuffix \$(s2), \$(foo1) )\n"
+              ."t3  := \$(t2) \$(t2) \$(t2) \$(t2) \$(t2) \$(t2) \$(t2) \$(t2) \$(t2) \$(t2) \n"
+              ."t4  := \$(t3) \$(t3) \$(t3) \$(t3) \$(t3) \$(t3) \$(t3) \$(t3) \$(t3) \$(t3) \n"
+              ."t5  := \$(t4) \$(t4) \$(t4) \$(t4) \$(t4) \$(t4) \$(t4) \$(t4) \$(t4) \$(t4) \n"
+              ."t6  := \$(t5) \$(t5) \$(t5) \$(t5) \$(t5) \$(t5) \$(t5) \$(t5) \$(t5) \$(t5) \n"
+              ."t7  := \$(t6) \$(t6) \$(t6) \n"
+              ."p1  := \$(addprefix \$(foo1), \$(s2) )\n"
+              ."blank:= \n"
+              ."all:\n"
+              ."\t\@echo \$(sort \$(bar2) \$(foo)  \$(addsuffix \$(s1), \$(bar) ) \$(t2) \$(bar2) \$(bar3))\n"
+              ."\t\@echo \$(sort \$(blank) \$(foo) \$(bar2) \$(t1) \$(p1) )\n"
+              ."\t\@echo \$(sort \$(foo) \$(bar2) \$(t1) \$(t4) \$(t5) \$(t7) \$(t6) )\n";
+run_make_test('
+foo := moon_light days
+foo1:= jazz
+bar := captured
+bar2 = boy end, has rise A midnight
+bar3:= $(foo)
+s1  := _by
+s2  := _and_a
+t1  := $(addsuffix $(s1), $(bar) )
+t2  := $(addsuffix $(s2), $(foo1) )
+t3  := $(t2) $(t2) $(t2) $(t2) $(t2) $(t2) $(t2) $(t2) $(t2) $(t2)
+t4  := $(t3) $(t3) $(t3) $(t3) $(t3) $(t3) $(t3) $(t3) $(t3) $(t3)
+t5  := $(t4) $(t4) $(t4) $(t4) $(t4) $(t4) $(t4) $(t4) $(t4) $(t4)
+t6  := $(t5) $(t5) $(t5) $(t5) $(t5) $(t5) $(t5) $(t5) $(t5) $(t5)
+t7  := $(t6) $(t6) $(t6)
+p1  := $(addprefix $(foo1), $(s2) )
+blank:=
+all:
+        @echo $(sort $(bar2) $(foo)  $(addsuffix $(s1), $(bar) ) $(t2) $(bar2) $(bar3))
+        @echo $(sort $(blank) $(foo) $(bar2) $(t1) $(p1) )
+        @echo $(sort $(foo) $(bar2) $(t1) $(t4) $(t5) $(t7) $(t6) )
+',
+              '', 'A boy captured_by days end, has jazz_and_a midnight moon_light rise
+A boy captured_by days end, has jazz_and_a midnight moon_light rise
+A boy captured_by days end, has jazz_and_a midnight moon_light rise
+');
+# END of Contents of MAKEFILE
+# Test with non-space/tab whitespace.  Note that you can't see the
+# original bug except using valgrind.
+close(MAKEFILE);
+&run_make_with_options($makefile,"",&get_logfile);
+# Create the answer to what should be produced by this Makefile
+$answer = "A boy captured_by days end, has jazz_and_a midnight moon_light rise\n"
+         ."A boy captured_by days end, has jazz_and_a midnight moon_light rise\n"
+         ."A boy captured_by days end, has jazz_and_a midnight moon_light rise\n";
+&compare_output($answer,&get_logfile(1));
+run_make_test("FOO = a b\tc\rd\fe \f \f \f \f \ff
+all: ; \@echo \$(words \$(sort \$(FOO)))\n",
+              '', "6\n");
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/functions/warning

-              r2596
+              r3138
 &run_make_with_options($makefile, "WARNING4=definitely", &get_logfile, 0);
 $answer = "Some stuff\n$makefile:14: warning is definitely\nhi\nthere\n";
+$answer = "Some stuff\n$makefile:15: warning is definitely\nhi\nthere\n";
 &compare_output($answer,&get_logfile(1));
+# Test linenumber offset
+run_make_test(q!
+all: one two
+        $(warning in $@ line 3)
+        @true
+        $(warning in $@ line 5)
+one two:
+        $(warning in $@ line 8)
+        @true
+        $(warning in $@ line 10)
+!,
+              '', "#MAKEFILE#:8: in one line 8
+#MAKEFILE#:10: in one line 10
+#MAKEFILE#:8: in two line 8
+#MAKEFILE#:10: in two line 10
+#MAKEFILE#:3: in all line 3
+#MAKEFILE#:5: in all line 5\n");
 # This tells the test driver that the perl test script executed properly.
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/functions/wildcard

-              r2596
+              r3138
               '', "\n");
+# TEST #5: wildcard used to verify file existence
+touch('xxx.yyy');
+run_make_test(q!exists: ; @echo file=$(wildcard xxx.yyy)!,
+              '', "file=xxx.yyy\n");
+unlink('xxx.yyy');
+run_make_test(q!exists: ; @echo file=$(wildcard xxx.yyy)!,
+              '', "file=\n");
 ;

vendor/gnumake/current/tests/scripts/functions/word

-              r2596
+              r3138
 wordlist-e3: ; @echo $(wordlist 1, 12a ,$(FOO))',
               'word-e1',
               "#MAKEFILE#:3: *** non-numeric first argument to `word' function: ''.  Stop.",
+              "#MAKEFILE#:3: *** non-numeric first argument to 'word' function: ''.  Stop.",
 );
 run_make_test(undef,
               'word-e2',
               "#MAKEFILE#:4: *** non-numeric first argument to `word' function: 'abc '.  Stop.",
+              "#MAKEFILE#:4: *** non-numeric first argument to 'word' function: 'abc '.  Stop.",
 );
 run_make_test(undef,
               'word-e3',
               "#MAKEFILE#:5: *** non-numeric first argument to `word' function: '1a'.  Stop.",
+              "#MAKEFILE#:5: *** non-numeric first argument to 'word' function: '1a'.  Stop.",
 );
 run_make_test(undef,
               'wordlist-e1',
               "#MAKEFILE#:7: *** non-numeric first argument to `wordlist' function: ''.  Stop.",
+              "#MAKEFILE#:7: *** non-numeric first argument to 'wordlist' function: ''.  Stop.",
 );
 run_make_test(undef,
               'wordlist-e2',
               "#MAKEFILE#:8: *** non-numeric first argument to `wordlist' function: 'abc '.  Stop.",
+              "#MAKEFILE#:8: *** non-numeric first argument to 'wordlist' function: 'abc '.  Stop.",
 );
 run_make_test(undef,
               'wordlist-e3',
               "#MAKEFILE#:9: *** non-numeric second argument to `wordlist' function: ' 12a '.  Stop.",
+              "#MAKEFILE#:9: *** non-numeric second argument to 'wordlist' function: ' 12a '.  Stop.",
 );
 …
 wordlist-e: ; @echo $(WL)',
               'word-e x=',
               "#MAKEFILE#:3: *** non-numeric first argument to `word' function: ''.  Stop.",
+              "#MAKEFILE#:3: *** non-numeric first argument to 'word' function: ''.  Stop.",
 );
 run_make_test(undef,
               'word-e x=abc',
               "#MAKEFILE#:3: *** non-numeric first argument to `word' function: 'abc'.  Stop.",
+              "#MAKEFILE#:3: *** non-numeric first argument to 'word' function: 'abc'.  Stop.",
 );
 run_make_test(undef,
               'word-e x=0',
               "#MAKEFILE#:3: *** first argument to `word' function must be greater than 0.  Stop.",
+              "#MAKEFILE#:3: *** first argument to 'word' function must be greater than 0.  Stop.",
 );
 run_make_test(undef,
               'wordlist-e s= e=',
               "#MAKEFILE#:4: *** non-numeric first argument to `wordlist' function: ''.  Stop.",
+              "#MAKEFILE#:4: *** non-numeric first argument to 'wordlist' function: ''.  Stop.",
 );
 run_make_test(undef,
               'wordlist-e s=abc e=',
               "#MAKEFILE#:4: *** non-numeric first argument to `wordlist' function: 'abc'.  Stop.",
+              "#MAKEFILE#:4: *** non-numeric first argument to 'wordlist' function: 'abc'.  Stop.",
 );
 run_make_test(undef,
               'wordlist-e s=4 e=12a',
               "#MAKEFILE#:4: *** non-numeric second argument to `wordlist' function: '12a'.  Stop.",
+              "#MAKEFILE#:4: *** non-numeric second argument to 'wordlist' function: '12a'.  Stop.",
 );
 run_make_test(undef,
               'wordlist-e s=0 e=12',
               "#MAKEFILE#:4: *** invalid first argument to `wordlist' function: `0'.  Stop.",
+              "#MAKEFILE#:4: *** invalid first argument to 'wordlist' function: '0'.  Stop.",
 );

vendor/gnumake/current/tests/scripts/misc/general3

-              r2596
+              r3138
 \$(STR) \$(TAB)",
               '', "#MAKE#: Nothing to be done for `all'.");
+              '', "#MAKE#: Nothing to be done for 'all'.");
 # TEST 2
 …
 foo     bar');
+run_make_test('x:;@-exit 1', '', "#MAKE#: [#MAKEFILE#:1: x] Error 1 (ignored)\n");
 ;

vendor/gnumake/current/tests/scripts/options/dash-B

-              r2596
+              r3138
               '', 'cp bar.x foo');
 run_make_test(undef, '', "#MAKE#: Nothing to be done for `all'.");
+run_make_test(undef, '', "#MAKE#: Nothing to be done for 'all'.");
 run_make_test(undef, '-B', 'cp bar.x foo');
 …
 utouch(1000, 'foo');
 run_make_test(undef, '', "#MAKE#: Nothing to be done for `all'.");
+run_make_test(undef, '', "#MAKE#: Nothing to be done for 'all'.");
 run_make_test(undef, '-B', 'cp bar.x foo');
 …
 ',
               '-B', 'MAKE_RESTARTS=
-#MAKEFILE#:4: foo.x: No such file or directory
 MAKE_RESTARTS=1');
 …
 ',
               '-B', 'MAKE_RESTARTS=
-#MAKEFILE#:4: foo.x: No such file or directory
 MAKE_RESTARTS=1
 blah.x
 …
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/options/dash-C

-              r2596
+              r3138
 # Create the answer to what should be produced by this Makefile
 $answer = "$make_name: Entering directory `$wpath'\n"
+$answer = "$make_name: Entering directory '$wpath'\n"
         . "$delete_command EXAMPLE\n"
         . "$make_name: Leaving directory `$wpath'\n";
+        . "$make_name: Leaving directory '$wpath'\n";
 &compare_output($answer,&get_logfile(1));
 …
 # Create the answer to what should be produced by this Makefile
 $answer = "$make_name: Entering directory `$wpath'\n"
+$answer = "$make_name: Entering directory '$wpath'\n"
         . "$delete_command EXAMPLEslash\n"
         . "$make_name: Leaving directory `$wpath'\n";
+        . "$make_name: Leaving directory '$wpath'\n";
 &compare_output($answer,&get_logfile(1));

vendor/gnumake/current/tests/scripts/options/dash-I

-              r2596
+              r3138
 $answer = "$mkpath ANOTHER -f $makefile
 ${make_name}[1]: Entering directory `$pwd'
+${make_name}[1]: Entering directory '$pwd'
 This is another included makefile
 ${make_name}[1]: Leaving directory `$pwd'\n";
+${make_name}[1]: Leaving directory '$pwd'\n";
 &run_make_with_options($makefile,"-I $workdir recurse",&get_logfile);

vendor/gnumake/current/tests/scripts/options/dash-W

-              r2596
+              r3138
 # Run it again: nothing should happen
 run_make_test(undef, '', "#MAKE#: `a.x' is up to date.");
+run_make_test(undef, '', "#MAKE#: 'a.x' is up to date.");
 # Now run it with -W b.x: should rebuild a.x
 …
 utouch(1000, 'a.x');
 run_make_test(undef, '', "#MAKE#: `a.x' is up to date.");
+run_make_test(undef, '', "#MAKE#: 'a.x' is up to date.");
 run_make_test(undef, '-W b.x', 'echo >> a.x');
 …
 baz.x: bar.x ; @echo "touch $@"
 ',
+              '', '#MAKEFILE#:3: foo.x: No such file or directory
+echo >> bar.x
+              '', 'echo >> bar.x
 touch foo.x
 restarts=1
 …
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/options/dash-k

-              r2596
+              r3138
                "$workdir${pathsep}commands.c","$workdir${pathsep}display.c",
                "$workdir${pathsep}buffer.h",
                "$workdir${pathsep}command.c");
+               "$workdir${pathsep}command.c");
 &touch(@files_to_touch);
 …
 # Create the answer to what should be produced by this Makefile
 $answer = "cc -c main.c
 $make_name: *** No rule to make target `kbd.c', needed by `kbd.o'.
+$make_name: *** No rule to make target 'kbd.c', needed by 'kbd.o'.
 cc -c commands.c
 cc -c display.c
 $make_name: Target `edit' not remade because of errors.\n";
+$make_name: Target 'edit' not remade because of errors.\n";
 # COMPARE RESULTS
 …
 $answer = "exit 1
 $make_name: *** [foo.o] Error 1
 $make_name: Target `all' not remade because of errors.\n";
+$make_name: *** [$makefile2:9: foo.o] Error 1
+$make_name: Target 'all' not remade because of errors.\n";
 &compare_output($answer, &get_logfile(1));
 …
               '-k',
               "#MAKEFILE#:2: ifile: No such file or directory
 #MAKE#: *** No rule to make target `no-such-file', needed by `ifile'.
 #MAKE#: Failed to remake makefile `ifile'.
+#MAKE#: *** No rule to make target 'no-such-file', needed by 'ifile'.
+#MAKE#: Failed to remake makefile 'ifile'.
 hi\n",
 );

vendor/gnumake/current/tests/scripts/options/dash-n

-              r2596
+              r3138
 $details = "Try various uses of -n and ensure they all give the correct results.\n";
 open(MAKEFILE, "> $makefile");
+touch('orig');
+# The Contents of the MAKEFILE ...
+print MAKEFILE <<'EOMAKE';
+run_make_test(q!
 final: intermediate ; echo >> $@
 intermediate: orig ; echo >> $@
+EOMAKE
+close(MAKEFILE);
+&touch('orig');
+# TEST 0
+&run_make_with_options($makefile, "", &get_logfile);
+$answer = "echo >> intermediate\necho >> final\n";
+&compare_output($answer, &get_logfile(1));
+!,
+              '', "echo >> intermediate\necho >> final\n");
 # TEST 1
+&run_make_with_options($makefile, "-Worig -n", &get_logfile);
+$answer = "echo >> intermediate\necho >> final\n";
+&compare_output($answer, &get_logfile(1));
+run_make_test(undef, '-Worig -n', "echo >> intermediate\necho >> final\n");
 unlink('orig', 'intermediate', 'final');
+rmfiles(qw(orig intermediate final));
 # We consider the actual updated timestamp of targets with all
+# recursive commands, even with -n.
+# recursive commands, even with -n.  Switching this to the new model
+# is non-trivial because we use a trick below to change the log content
+# before we compare it ...
 $makefile2 = &get_tmpfile;
 …
 &run_make_with_options($makefile2, "", &get_logfile);
 $answer = "$make_name: `a' is up to date.\n";
+$answer = "$make_name: 'a' is up to date.\n";
 &compare_output($answer, &get_logfile(1));
 …
 &run_make_with_options($makefile2, "-n", &get_logfile);
 $answer = "$make_name: `a' is up to date.\n";
+$answer = "$make_name: 'a' is up to date.\n";
 &compare_output($answer, &get_logfile(1));
+unlink('a', 'b', 'c');
+# TEST 4
+unlink(qw(a b));
+&run_make_with_options($makefile2, "-t -n", &get_logfile);
+open(DASH_N_LOG, ">>" . &get_logfile(1));
+print DASH_N_LOG "a exists but should not!\n" if -e 'a';
+print DASH_N_LOG "b exists but should not!\n" if -e 'b';
+close(DASH_N_LOG);
+&compare_output("touch b\ntouch a\n", &get_logfile(1));
+# CLEANUP
+unlink(qw(a b c));
+# Ensure -n continues to be included with recursive/re-execed make
+# See Savannah bug #38051
+$topmake = &get_tmpfile;
+$submake = &get_tmpfile;
+open(MAKEFILE, "> $topmake");
+print MAKEFILE <<"EOF";
+foo: ; \@\$(MAKE) -f "$submake" bar
+EOF
+close(MAKEFILE);
+# The bar target should print what would happen, but not actually run
+open(MAKEFILE, "> $submake");
+print MAKEFILE <<'EOF';
+inc: ; touch $@
+-include inc
+bar: ; @echo $(strip $(MAKEFLAGS))
+EOF
+close(MAKEFILE);
+&run_make_with_options($topmake, '-n --no-print-directory', &get_logfile);
+$answer = "$make_command -f \"$submake\" bar\ntouch inc\necho n --no-print-directory\n";
+&compare_output($answer, &get_logfile(1));
+unlink('inc');
 ;

vendor/gnumake/current/tests/scripts/options/dash-q

-              r2596
+              r3138
 # TEST 0
 run_make_test('
+run_make_test(qq!
 one:
 two: ;
 three: ; :
 four: ; $(.XY)
 five: ; \
  $(.XY)
 six: ; \
  $(.XY)
         $(.XY)
 seven: ; \
  $(.XY)
         : foo
         $(.XY)
 ',
+four: ; \$(.XY)
+five: ; \\
+ \$(.XY)
+six: ; \\
+ \$(.XY)
+\t\$(.XY)
+seven: ; \\
+ \$(.XY)
+\t: foo
+\t\$(.XY)
+!,
               '-q one', '');
 …
               '-q', '', 256);
+# TEST 7 : Savannah bug # 42249
+# Make sure we exit with 1 even for prerequisite updates
+run_make_test('
+build-stamp: ; echo $@
+build-arch: build-stamp
+build-x: build-arch
+build-y: build-x
+',
+              '-q build-y', '', 256);
+# TEST 8
+# Make sure we exit with 2 on error even with -q
+run_make_test('
+build-stamp: ; echo $@
+build-arch: build-stamp-2
+build-x: build-arch
+build-y: build-x
+',
+              '-q build-y', "#MAKE#: *** No rule to make target 'build-stamp-2', needed by 'build-arch'.  Stop.\n", 512);
+# TEST 9 : Savannah bug # 47151
+# Make sure we exit with 1 when invoking a recursive make
+run_make_test('
+foo: bar ; echo foo
+bar: ; @$(MAKE) -f #MAKEFILE# baz
+baz: ; echo baz
+',
+              '-q foo', '', 256);
 ;

vendor/gnumake/current/tests/scripts/options/eval

-              r2596
+              r3138
               "eval\neval\nall\nrecurse");
+# Make sure that --eval is handled correctly during restarting
+run_make_test(q!
+all: ; @echo $@
+-include gen.mk
+gen.mk: ; @echo > $@
+!,
+              '--eval=\$\(info\ eval\)', "eval\neval\nall");
+unlink('gen.mk');
 ;

vendor/gnumake/current/tests/scripts/options/symlinks

-              r2596
+              r3138
   # With -L, it should update targ
   run_make_test('targ: sym ; @echo make $@ from $<', '',
                 "#MAKE#: `targ' is up to date.");
+                "#MAKE#: 'targ' is up to date.");
   run_make_test(undef, '-L', "make targ from sym");
 …
   # Now update targ; in all cases targ should be up to date.
   &touch('targ');
   run_make_test(undef, '', "#MAKE#: `targ' is up to date.");
   run_make_test(undef, '-L', "#MAKE#: `targ' is up to date.");
+  run_make_test(undef, '', "#MAKE#: 'targ' is up to date.");
+  run_make_test(undef, '-L', "#MAKE#: 'targ' is up to date.");
   # Add in a new link between sym and dep.  Be sure it's newer than targ.
 …
   # Without -L, nothing should happen
   # With -L, it should update targ
   run_make_test(undef, '', "#MAKE#: `targ' is up to date.");
+  run_make_test(undef, '', "#MAKE#: 'targ' is up to date.");
   run_make_test(undef, '-L', "make targ from sym");
 …
   symlink("../$dirname/dep", 'sym');
   run_make_test('targ: sym ; @echo make $@ from $<', '',
                 "#MAKE#: *** No rule to make target `sym', needed by `targ'.  Stop.", 512);
+                "#MAKE#: *** No rule to make target 'sym', needed by 'targ'.  Stop.", 512);
   run_make_test('targ: sym ; @echo make $@ from $<', '-L',

vendor/gnumake/current/tests/scripts/options/warn-undefined-variables

-              r2596
+              r3138
 # With --warn-undefined-variables, it should warn me
 run_make_test(undef, '--warn-undefined-variables',
               "#MAKEFILE#:7: warning: undefined variable `UNDEFINED'
 #MAKEFILE#:9: warning: undefined variable `UNDEFINED'
+              "#MAKEFILE#:7: warning: undefined variable 'UNDEFINED'
+#MAKEFILE#:9: warning: undefined variable 'UNDEFINED'
 ref");

vendor/gnumake/current/tests/scripts/targets/DEFAULT

-              r2596
+              r3138
 # Create the answer to what should be produced by this Makefile
 $answer = "${make_name}[1]: Entering directory `$pwd'\n"
+$answer = "${make_name}[1]: Entering directory '$pwd'\n"
         . "Executing rule BAR\n"
         . "${make_name}[1]: Leaving directory `$pwd'\n";
+        . "${make_name}[1]: Leaving directory '$pwd'\n";
 # COMPARE RESULTS

vendor/gnumake/current/tests/scripts/targets/INTERMEDIATE

-              r2596
+              r3138
 &run_make_with_options($makefile,'foo.d',&get_logfile);
 $answer = "$make_name: `foo.d' is up to date.\n";
+$answer = "$make_name: 'foo.d' is up to date.\n";
 &compare_output($answer, &get_logfile(1));
 …
 &run_make_with_options($makefile,'foo.c',&get_logfile);
 $answer = "$make_name: `foo.c' is up to date.\n";
+$answer = "$make_name: 'foo.c' is up to date.\n";
 &compare_output($answer, &get_logfile(1));

vendor/gnumake/current/tests/scripts/targets/ONESHELL

-              r2596
+              r3138
 $details = "";
+# Some shells (*shakes fist at Solaris*) cannot handle multiple flags in
+# separate arguments.
+my $t = `/bin/sh -e -c true 2>/dev/null`;
+my $multi_ok = $? == 0;
 # Simple
 …
 [ 0"$a" -eq "$$" ] || echo fail
 ');
+# Simple but use multi-word SHELLFLAGS
+if ($multi_ok) {
+    run_make_test(q!
+.ONESHELL:
+.SHELLFLAGS = -e -c
+all:
+        a=$$$$
+        [ 0"$$a" -eq "$$$$" ] || echo fail
+!,
+              '', 'a=$$
+[ 0"$a" -eq "$$" ] || echo fail
+');
+}
 # Again, but this time with inner prefix chars

vendor/gnumake/current/tests/scripts/targets/POSIX

-              r2596
+              r3138
 #                                                                    -*-perl-*-
 $description = "Test the behaviour of the .PHONY target.";
+$description = "Test the behaviour of the .POSIX target.";
 $details = "";
 …
 all: ; \@$script
 !,
               '', "#MAKE#: *** [all] Error $err\n", 512);
+              '', "#MAKE#: *** [#MAKEFILE#:3: all] Error $err\n", 512);
 # User settings must override .POSIX
 …
               '', $out);
+# Test the default value of various POSIX-specific variables
+my %POSIX = (AR => 'ar', ARFLAGS => '-rv',
+             YACC => 'yacc', YFLAGS => '',
+             LEX => 'lex', LFLAGS => '',
+             LDFLAGS => '',
+             CC => 'c99', CFLAGS => '-O',
+             FC => 'fort77', FFLAGS => '-O 1',
+             GET => 'get', GFLAGS => '',
+             SCCSFLAGS => '', SCCSGETFLAGS => '-s');
+my $make = join('', map { "\t\@echo '$_=\$($_)'\n" } sort keys %POSIX);
+my $r = join('', map { "$_=$POSIX{$_}\n"} sort keys %POSIX);
+run_make_test(qq!
+.POSIX:
+all:
+$make
+!,
+              '', $r);
+# Make sure that local settings take precedence
+%extraENV = map { $_ => "xx-$_" } keys %POSIX;
+$r = join('', map { "$_=xx-$_\n"} sort keys %POSIX);
+run_make_test(undef, '', $r);
 # This tells the test driver that the perl test script executed properly.
 ;

vendor/gnumake/current/tests/scripts/targets/SECONDARY

-              r2596
+              r3138
 &run_make_with_options($makefile,'foo.d',&get_logfile);
 $answer = "$make_name: `foo.d' is up to date.\n";
+$answer = "$make_name: 'foo.d' is up to date.\n";
 &compare_output($answer, &get_logfile(1));
 …
 &run_make_with_options($makefile,'foo.c',&get_logfile);
 $answer = "$make_name: `foo.c' is up to date.\n";
+$answer = "$make_name: 'foo.c' is up to date.\n";
 &compare_output($answer, &get_logfile(1));
 …
 &run_make_with_options($makefile2, '', &get_logfile);
 $answer = "$make_name: `final' is up to date.\n";
+$answer = "$make_name: 'final' is up to date.\n";
 &compare_output($answer, &get_logfile(1));
 …
 %.c : %.b ; cp $< $@
 %.b : %.a ; cp $< $@
+all : 1.c 2.c', '-rR -j',
+all : 1.c 2.c
+.a: 1.c', '-rR -j',
 'cp 1.a 1.b
+cp 1.b 1.c
 cp 2.a 2.b
-cp 1.b 1.c
 cp 2.b 2.c
 rm 1.b 2.b');

vendor/gnumake/current/tests/scripts/variables/DEFAULT_GOAL

r2596	r3138
43	43	',
44	44	'',
45		~~'#MAKE#: *** No rule to make target `foo\'. Stop.'~~,
	45	"#MAKE#: *** No rule to make target 'foo'. Stop.",
46	46	512);
47	47

vendor/gnumake/current/tests/scripts/variables/LIBPATTERNS

r2596	r3138
21	21	all: -lfoo ; @echo "build $@ from $<"
22	22	',
23		'', "#MAKE#: .LIBPATTERNS element `mtest_foo.a' is not a pattern
	23	'', "#MAKE#: .LIBPATTERNS element 'mtest_foo.a' is not a pattern
24	24	build all from mtest_foo.a\n");
25	25

vendor/gnumake/current/tests/scripts/variables/MAKE

-              r2596
+              r3138
               '',
               "#MAKEPATH#\n#MAKEPATH# -f #MAKEFILE# foo\n"
               . "#MAKE#[1]: Entering directory `#PWD#'\n"
               . "#MAKEPATH#\n#MAKE#[1]: Leaving directory `#PWD#'\n");
+              . "#MAKE#[1]: Entering directory '#PWD#'\n"
+              . "#MAKEPATH#\n#MAKE#[1]: Leaving directory '#PWD#'\n");
 rmfiles("foo");

vendor/gnumake/current/tests/scripts/variables/MAKEFLAGS

-              r2596
+              r3138
 #                                                                    -*-perl-*-
+#                                                                    -*-perl-*-
 $description = "Test proper behavior of MAKEFLAGS";
 …
 all: ; @echo $(MAKEFLAGS)
 !,
               '-e -r -R', 'Rre');
+              '-e -r -R', 'erR');
 # Long arguments mean everything is prefixed with "-"
 …
 all: ; @echo $(MAKEFLAGS)
 !,
+              '--no-print-directory -e -r -R', '--no-print-directory -Rre');
+              '--no-print-directory -e -r -R --trace', "#MAKEFILE#:2: target 'all' does not exist
+echo erR --trace --no-print-directory
+erR --trace --no-print-directory");
+if ($all_tests) {
+    # Recursive invocations of make should accumulate MAKEFLAGS values.
+    # Savannah bug #2216
+    run_make_test(q!
+# Recursive invocations of make should accumulate MAKEFLAGS values.
+# Savannah bug #2216
+run_make_test(q!
 MSG = Fails
 all:
 …
         @MSG=Works $(MAKE) -e -f #MAKEFILE# jump
 jump:
         @echo '$@: MAKEFLAGS=$(MAKEFLAGS)'
+        @echo '$@ $(MSG): MAKEFLAGS=$(MAKEFLAGS)'
         @$(MAKE) -f #MAKEFILE# print
 print:
+        @echo '$@: MAKEFLAGS=$(MAKEFLAGS)'
+        @echo $(MSG)
+        @echo '$@ $(MSG): MAKEFLAGS=$(MAKEFLAGS)'
 .PHONY: all jump print
 !,
                   '--no-print-directory',
                   'all: MAKEFLAGS= --no-print-directory
+jump: MAKEFLAGS= --no-print-directory -e
+print: MAKEFLAGS= --no-print-directory -e
+Works');
+}
+jump Works: MAKEFLAGS=e --no-print-directory
+print Works: MAKEFLAGS=e --no-print-directory');
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/variables/MAKE_RESTARTS

-              r2596
+              r3138
 ',
               '', 'MAKE_RESTARTS=
-#MAKEFILE#:4: foo.x: No such file or directory
 MAKE_RESTARTS=1');
 …
 ',
               '', 'MAKE_RESTARTS=
-#MAKEFILE#:4: foo.x: No such file or directory
 MAKE_RESTARTS=1
-foo.x:1: bar.x: No such file or directory
 MAKE_RESTARTS=2');
 …
 ',
               '', "MAKE_RESTARTS=
-#MAKEFILE#:8: foo.x: No such file or directory
 MAKE_RESTARTS=1
-foo.x:1: bar.x: No such file or directory
 MAKE_RESTARTS=2
 recurse MAKE_RESTARTS=
+#MAKE#[1]: Entering directory '#PWD#'
 MAKE_RESTARTS=
-#MAKE#[1]: Entering directory `#PWD#'
 all MAKE_RESTARTS=
 #MAKE#[1]: Leaving directory `#PWD#'");
+#MAKE#[1]: Leaving directory '#PWD#'");
 rmfiles('foo.x', 'bar.x');
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/scripts/variables/SHELL

-              r2596
+              r3138
               '', $out);
+# Do it again but add spaces to SHELLFLAGS
+# Some shells (*shakes fist at Solaris*) cannot handle multiple flags in
+# separate arguments.
+my $t = `/bin/sh -e -c true 2>/dev/null`;
+my $multi_ok = $? == 0;
+if ($multi_ok) {
+    $flags = '-x -c';
+    run_make_test(qq!
+.SHELLFLAGS = $flags
+all: ; \@$script
+!,
+              '', $out);
+}
 # We can't just use "false" because on different systems it provides a
 # different exit code--once again Solaris: false exits with 255 not 1
 …
 all: ; \@$script
 !,
               '', "$out#MAKE#: *** [all] Error $err\n", 512);
+              '', "$out#MAKE#: *** [#MAKEFILE#:3: all] Error $err\n", 512);
 ;

vendor/gnumake/current/tests/scripts/variables/define

-              r2596
+              r3138
 endef
+define posix ::=
+@echo $(FOO)
+endef
 append = @echo a
 …
 all: ; $(multi)
         $(simple)
+        $(posix)
         $(append)
         $(cond)
 ',
+              '', "echo hi\nhi\nthere\nfoo\na\nb\nfirst\n");
+              '', "echo hi\nhi\nthere\nfoo\nfoo\na\nb\nfirst\n");
+# TEST 1a: Various new-style define/endef, with no spaces
+run_make_test('
+FOO = foo
+define multi=
+echo hi
+@echo $(FOO)
+endef # this is the end
+define simple:=
+@echo $(FOO)
+endef
+define posix::=
+@echo $(FOO)
+endef
+append = @echo a
+define append+=
+@echo b
+endef
+define cond?= # this is a conditional
+@echo first
+endef
+define cond?=
+@echo second
+endef
+FOO = there
+all: ; $(multi)
+        $(simple)
+        $(posix)
+        $(append)
+        $(cond)
+',
+              '', "echo hi\nhi\nthere\nfoo\nfoo\na\nb\nfirst\n");
 # TEST 2: define in true section of conditional (containing conditional)
 …
 all: ; @echo ok
 ',
               '', "#MAKEFILE#:3: extraneous text after `define' directive\nok\n");
+              '', "#MAKEFILE#:3: extraneous text after 'define' directive\nok\n");
 # TEST 7: NEGATIVE: extra text after endef
 …
 all: ; @echo ok
 ',
               '', "#MAKEFILE#:5: extraneous text after `endef' directive\nok\n");
+              '', "#MAKEFILE#:5: extraneous text after 'endef' directive\nok\n");
 # TEST 8: NEGATIVE: missing endef
 …
 endef$(NAME)
 ',
               '', "#MAKEFILE#:4: *** missing `endef', unterminated `define'.  Stop.\n", 512);
+              '', "#MAKEFILE#:4: *** missing 'endef', unterminated 'define'.  Stop.\n", 512);
 # -------------------------

vendor/gnumake/current/tests/scripts/variables/flavors

-              r2596
+              r3138
               '', "Hello\n");
+# TEST 6: Simple using POSIX syntax
+run_make_test('
+bar = Goodbye
+foo ::= $(bar)
+bar = ${ugh}
+ugh = Hello
+all: ; @echo $(foo)
+',
+              '', "Goodbye\n");
+# TEST 7: POSIX syntax no spaces
+run_make_test('
+bar = Goodbye
+foo::=$(bar)
+bar = ${ugh}
+ugh = Hello
+all: ; @echo $(foo)
+',
+              '', "Goodbye\n");
 ;

vendor/gnumake/current/tests/scripts/variables/private

-              r2596
+              r3138
                '', "b=a\na=a\n");
+# 9: make sure private suppresses inheritance
+run_make_test(q!
+DEFS = FOO
+all: bar1
+bar1: private DEFS += 1
+bar3: private DEFS += 3
+bar1: bar2
+bar2: bar3
+bar1 bar2 bar3: ; @echo '$@: $(DEFS)'
+!,
+              '', "bar3: FOO 3\nbar2: FOO\nbar1: FOO 1\n");
+# 10: Test append with pattern-specific variables and private
+run_make_test(q!
+IA = global
+PA = global
+PS = global
+S = global
+PS = global
+SV = global
+b%: IA += b%
+b%: private PA += b%
+b%: private PS = b%
+bar: all
+bar: IA += bar
+bar: private PA += bar
+bar: private PS = bar
+a%: IA += a%
+a%: private PA += a%
+a%: private PS = a%
+all: IA += all
+all: private PA += all
+all: private PS = all
+bar all: ; @echo '$@: IA=$(IA)'; echo '$@: PA=$(PA)'; echo '$@: PS=$(PS)'
+!,
+              '', "all: IA=global b% bar a% all
+all: PA=global a% all
+all: PS=all
+bar: IA=global b% bar
+bar: PA=global b% bar
+bar: PS=bar\n");
 ;

vendor/gnumake/current/tests/scripts/variables/special

-              r2596
+              r3138
 BAR := bar
+all:
+        @echo X1 = $(X1)
+        @echo X2 = $(X2)
+        @echo LAST = $(sort $(filter FOO BAR,$(.VARIABLES)))
+all: ; @echo X1 = $(X1); echo X2 = $(X2); echo LAST = $(sort $(filter FOO BAR,$(.VARIABLES)))
 ',
                '', "X1 =\nX2 = FOO\nLAST = BAR FOO\n");
+# SV 45728: Test that undefining a variable is reflected properly
+&run_make_test('
+FOO := foo
+BAR := bar
+$(info one: $(sort $(filter FOO BAR BAZ,$(.VARIABLES))))
+undefine BAR
+BAZ := baz
+$(info two: $(sort $(filter FOO BAR BAZ,$(.VARIABLES))))
+all:;@:
+',
+               '', "one: BAR FOO\ntwo: BAZ FOO\n");
 # $makefile2 = &get_tmpfile;
 …
 # all: foo
 #       @echo X1 = $(X1)
 #       @echo X2 = $(X2)
 #       @echo LAST = $(sort $(.TARGETS))
+#       @echo X1 = $(X1)
+#       @echo X2 = $(X2)
+#       @echo LAST = $(sort $(.TARGETS))
 # X2 := $(sort $(.TARGETS))
 …
 &run_make_test('
 define foo
 : foo-one \
+: foo-one\
 foo-two
 : foo-three
 …
 : foo-four');
+# Test that the "did you mean TAB" message is printed properly
+run_make_test(q!
+$x.
+!,
+              '', '#MAKEFILE#:2: *** missing separator.  Stop.', 512);
+run_make_test(q!
+foo:
+        bar
+!,
+              '', '#MAKEFILE#:3: *** missing separator (did you mean TAB instead of 8 spaces?).  Stop.', 512);
+run_make_test(q!
+.RECIPEPREFIX = :
+foo:
+        bar
+!,
+              '', '#MAKEFILE#:4: *** missing separator.  Stop.', 512);
 ;
+### Local Variables:
+### eval: (setq whitespace-action (delq 'auto-cleanup whitespace-action))
+### End:

vendor/gnumake/current/tests/test_driver.pl

-              r2596
+              r3138
 # Modified 92-02-11 through 92-02-22 by Chris Arthur to further generalize.
+#
+# Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
+# 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
+# Foundation, Inc.
+# Copyright (C) 1991-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 # variables and then calls &toplevel, which does all the real work.
 # $Id: test_driver.pl,v 1.30 2010/07/28 05:39:50 psmith Exp $
+# $Id$
 …
 $test_passed = 1;
 # Timeout in seconds.  If the test takes longer than this we'll fail it.
 $test_timeout = 5;
+$test_timeout = 10 if $^O eq 'VMS';
 # Path to Perl
 …
 %extraENV = ();
+sub vms_get_process_logicals {
+  # Sorry for the long note here, but to keep this test running on
+  # VMS, it is needed to be understood.
+  #
+  # Perl on VMS by default maps the %ENV array to the system wide logical
+  # name table.
+  #
+  # This is a very large dynamically changing table.
+  # On Linux, this would be the equivalent of a table that contained
+  # every mount point, temporary pipe, and symbolic link on every
+  # file system.  You normally do not have permission to clear or replace it,
+  # and if you did, the results would be catastrophic.
+  #
+  # On VMS, added/changed %ENV items show up in the process logical
+  # name table.  So to track changes, a copy of it needs to be captured.
+  my $raw_output = `show log/process/access_mode=supervisor`;
+  my @raw_output_lines = split('\n',$raw_output);
+  my %log_hash;
+  foreach my $line (@raw_output_lines) {
+    if ($line =~ /^\s+"([A-Za-z\$_]+)"\s+=\s+"(.+)"$/) {
+      $log_hash{$1} = $2;
+    }
+  }
+  return \%log_hash
+}
 # %origENV is the caller's original environment
+%origENV = %ENV;
+if ($^O ne 'VMS') {
+  %origENV = %ENV;
+} else {
+  my $proc_env = vms_get_process_logicals;
+  %origENV = %{$proc_env};
+}
 sub resetENV
 …
   # through Perl 5.004.  It was fixed in Perl 5.004_01, but we don't
   # want to require that here, so just delete each one individually.
+  foreach $v (keys %ENV) {
+    delete $ENV{$v};
+  }
+  %ENV = %makeENV;
+  if ($^O ne 'VMS') {
+    foreach $v (keys %ENV) {
+      delete $ENV{$v};
+    }
+    %ENV = %makeENV;
+  } else {
+    my $proc_env = vms_get_process_logicals();
+    my %delta = %{$proc_env};
+    foreach my $v (keys %delta) {
+      if (exists $origENV{$v}) {
+        if ($origENV{$v} ne $delta{$v}) {
+          $ENV{$v} = $origENV{$v};
+        }
+      } else {
+        delete $ENV{$v};
+      }
+    }
+  }
   foreach $v (keys %extraENV) {
     $ENV{$v} = $extraENV{$v};
 …
   foreach (# UNIX-specific things
            'TZ', 'TMPDIR', 'HOME', 'USER', 'LOGNAME', 'PATH',
+           'LD_LIBRARY_PATH',
            # Purify things
            'PURIFYOPTIONS',
 …
   # Replace the environment with the new one
+  #
   %origENV = %ENV;
+  %origENV = %ENV unless $^O eq 'VMS';
   resetENV();
 …
   &parse_command_line (@ARGV);
   print "OS name = `$osname'\n" if $debug;
+  print "OS name = '$osname'\n" if $debug;
   $workpath = "$cwdslash$workdir";
 …
   &print_banner;
+  if ($osname eq 'VMS' && $cwdslash eq "")
+  {
+    # Porting this script to VMS revealed a small bug in opendir() not
+    # handling search lists correctly when the directory only exists in
+    # one of the logical_devices.  Need to find the first directory in
+    # the search list, as that is where things will be written to.
+    my @dirs = split("/", $pwd);
+    my $logical_device = $ENV{$dirs[1]};
+    if ($logical_device =~ /([A-Za-z0-9_]+):(:?.+:)+/)
+    {
+        # A search list was found.  Grab the first logical device
+        # and use it instead of the search list.
+        $dirs[1]=$1;
+        my $lcl_pwd = join('/', @dirs);
+        $workpath = $lcl_pwd . '/' . $workdir
+    }
+  }
   if (-d $workpath)
 …
         push (@rmdirs, $dir);
         -d "$workpath/$dir"
            || mkdir ("$workpath/$dir", 0777)
+           || mkdir ("$workpath/$dir", 0777)
            || &error ("Couldn't mkdir $workpath/$dir: $!\n");
+      }
 …
     print "Finding tests...\n";
     opendir (SCRIPTDIR, $scriptpath)
         || &error ("Couldn't opendir $scriptpath: $!\n");
+        || &error ("Couldn't opendir $scriptpath: $!\n");
     @dirs = grep (!/^(\..*|CVS|RCS)$/, readdir (SCRIPTDIR) );
     closedir (SCRIPTDIR);
 …
       next if ($dir =~ /^(\..*|CVS|RCS)$/ || ! -d "$scriptpath/$dir");
       push (@rmdirs, $dir);
+      # VMS can have overlayed file systems, so directories may repeat.
+      next if -d "$workpath/$dir";
       mkdir ("$workpath/$dir", 0777)
            || &error ("Couldn't mkdir $workpath/$dir: $!\n");
+          || &error ("Couldn't mkdir $workpath/$dir: $!\n");
       opendir (SCRIPTDIR, "$scriptpath/$dir")
           || &error ("Couldn't opendir $scriptpath/$dir: $!\n");
+          || &error ("Couldn't opendir $scriptpath/$dir: $!\n");
       @files = grep (!/^(\..*|CVS|RCS|.*~)$/, readdir (SCRIPTDIR) );
       closedir (SCRIPTDIR);
 …
+      {
         -d $test and next;
         push (@TESTS, "$dir/$test");
+        push (@TESTS, "$dir/$test");
+      }
+    }
 …
   print "\n";
   &run_each_test;
+  run_all_tests();
   foreach $dir (@rmdirs)
 …
     print " in $categories_failed Categor";
     print ($categories_failed == 1 ? "y" : "ies");
     print " Failed (See .$diffext files in $workdir dir for details) :-(\n\n";
+    print " Failed (See .$diffext* files in $workdir dir for details) :-(\n\n";
     return 0;
+  }
 …
   $osname = defined($^O) ? $^O : '';
+  if ($osname eq 'VMS')
+  {
+    $vos = 0;
+    $pathsep = "/";
+    return;
+  }
   # Find a path to Perl
 …
     if ($osname =~ /not found/i)
+    {
         $osname = "(something posixy with no uname)";
+        $osname = "(something posixy with no uname)";
+    }
     elsif ($@ ne "" || $?)
 …
         if ($@ ne "" || $?)
+        {
             $osname = "(something posixy)";
+        }
+            $osname = "(something posixy)";
+        }
+    }
     $vos = 0;
 …
+}
+sub run_each_test
+{
+  $categories_run = 0;
+  foreach $testname (sort @TESTS)
+  {
+    ++$categories_run;
+    $suite_passed = 1;       # reset by test on failure
+    $num_of_logfiles = 0;
+    $num_of_tmpfiles = 0;
+    $description = "";
+    $details = "";
+    $old_makefile = undef;
+    $testname =~ s/^$scriptpath$pathsep//;
+    $perl_testname = "$scriptpath$pathsep$testname";
+    $testname =~ s/(\.pl|\.perl)$//;
+    $testpath = "$workpath$pathsep$testname";
+    # Leave enough space in the extensions to append a number, even
+    # though it needs to fit into 8+3 limits.
+    if ($short_filenames) {
+      $logext = 'l';
+      $diffext = 'd';
+      $baseext = 'b';
+      $runext = 'r';
+      $extext = '';
+    } else {
+      $logext = 'log';
+      $diffext = 'diff';
+      $baseext = 'base';
+      $runext = 'run';
+      $extext = '.';
+    }
+    $log_filename = "$testpath.$logext";
+    $diff_filename = "$testpath.$diffext";
+    $base_filename = "$testpath.$baseext";
+    $run_filename = "$testpath.$runext";
+    $tmp_filename = "$testpath.$tmpfilesuffix";
+    &setup_for_test;          # suite-defined
+    $output = "........................................................ ";
+    substr($output,0,length($testname)) = "$testname ";
+    print $output;
+    # Run the actual test!
+    $tests_run = 0;
+    $tests_passed = 0;
+    $code = do $perl_testname;
+    $total_tests_run += $tests_run;
+    $total_tests_passed += $tests_passed;
+    # How did it go?
+    if (!defined($code))
+    {
+      $suite_passed = 0;
+      if (length ($@)) {
+        warn "\n*** Test died ($testname): $@\n";
+      } else {
+        warn "\n*** Couldn't run $perl_testname\n";
+      }
+    }
+    elsif ($code == -1) {
+      $suite_passed = 0;
+    }
+    elsif ($code != 1 && $code != -1) {
+      $suite_passed = 0;
+      warn "\n*** Test returned $code\n";
+    }
+    if ($suite_passed) {
+      ++$categories_passed;
+      $status = "ok     ($tests_passed passed)";
+      for ($i = $num_of_tmpfiles; $i; $i--)
+      {
+        &rmfiles ($tmp_filename . &num_suffix ($i) );
+      }
+      for ($i = $num_of_logfiles ? $num_of_logfiles : 1; $i; $i--)
+      {
+        &rmfiles ($log_filename . &num_suffix ($i) );
+        &rmfiles ($base_filename . &num_suffix ($i) );
+      }
+    }
+    elsif (!defined $code || $code > 0) {
+      $status = "FAILED ($tests_passed/$tests_run passed)";
+    }
+    elsif ($code < 0) {
+      $status = "N/A";
+      --$categories_run;
+    }
+    # If the verbose option has been specified, then a short description
+    # of each test is printed before displaying the results of each test
+    # describing WHAT is being tested.
+    if ($verbose)
+    {
+      if ($detail)
+      {
+        print "\nWHAT IS BEING TESTED\n";
+        print "--------------------";
+      }
+      print "\n\n$description\n\n";
+    }
+    # If the detail option has been specified, then the details of HOW
+    # the test is testing what it says it is testing in the verbose output
+    # will be displayed here before the results of the test are displayed.
+    if ($detail)
+    {
+      print "\nHOW IT IS TESTED\n";
+      print "----------------";
+      print "\n\n$details\n\n";
+    }
+    print "$status\n";
+  }
+sub run_all_tests
+{
+    $categories_run = 0;
+    $lasttest = '';
+    foreach $testname (sort @TESTS) {
+        # Skip duplicates on VMS caused by logical name search lists.
+        next if $testname eq $lasttest;
+        $lasttest = $testname;
+        $suite_passed = 1;       # reset by test on failure
+        $num_of_logfiles = 0;
+        $num_of_tmpfiles = 0;
+        $description = "";
+        $details = "";
+        $old_makefile = undef;
+        $testname =~ s/^$scriptpath$pathsep//;
+        $perl_testname = "$scriptpath$pathsep$testname";
+        $testname =~ s/(\.pl|\.perl)$//;
+        $testpath = "$workpath$pathsep$testname";
+        # Leave enough space in the extensions to append a number, even
+        # though it needs to fit into 8+3 limits.
+        if ($short_filenames) {
+            $logext = 'l';
+            $diffext = 'd';
+            $baseext = 'b';
+            $runext = 'r';
+            $extext = '';
+        } else {
+            $logext = 'log';
+            $diffext = 'diff';
+            $baseext = 'base';
+            $runext = 'run';
+            $extext = '.';
+        }
+        $extext = '_' if $^O eq 'VMS';
+        $log_filename = "$testpath.$logext";
+        $diff_filename = "$testpath.$diffext";
+        $base_filename = "$testpath.$baseext";
+        $run_filename = "$testpath.$runext";
+        $tmp_filename = "$testpath.$tmpfilesuffix";
+        setup_for_test();
+        $output = "........................................................ ";
+        substr($output,0,length($testname)) = "$testname ";
+        print $output;
+        $tests_run = 0;
+        $tests_passed = 0;
+        # Run the test!
+        $code = do $perl_testname;
+        ++$categories_run;
+        $total_tests_run += $tests_run;
+        $total_tests_passed += $tests_passed;
+        # How did it go?
+        if (!defined($code)) {
+            # Failed to parse or called die
+            if (length ($@)) {
+                warn "\n*** Test died ($testname): $@\n";
+            } else {
+                warn "\n*** Couldn't parse $perl_testname\n";
+            }
+            $status = "FAILED ($tests_passed/$tests_run passed)";
+        }
+        elsif ($code == -1) {
+            # Skipped... not supported
+            $status = "N/A";
+            --$categories_run;
+        }
+        elsif ($code != 1) {
+            # Bad result... this shouldn't really happen.  Usually means that
+            # the suite forgot to end with "1;".
+            warn "\n*** Test returned $code\n";
+            $status = "FAILED ($tests_passed/$tests_run passed)";
+        }
+        elsif ($tests_run == 0) {
+            # Nothing was done!!
+            $status = "FAILED (no tests found!)";
+        }
+        elsif ($tests_run > $tests_passed) {
+            # Lose!
+            $status = "FAILED ($tests_passed/$tests_run passed)";
+        }
+        else {
+            # Win!
+            ++$categories_passed;
+            $status = "ok     ($tests_passed passed)";
+            # Clean up
+            for ($i = $num_of_tmpfiles; $i; $i--) {
+                rmfiles($tmp_filename . num_suffix($i));
+            }
+            for ($i = $num_of_logfiles ? $num_of_logfiles : 1; $i; $i--) {
+                rmfiles($log_filename . num_suffix($i));
+                rmfiles($base_filename . num_suffix($i));
+            }
+        }
+        # If the verbose option has been specified, then a short description
+        # of each test is printed before displaying the results of each test
+        # describing WHAT is being tested.
+        if ($verbose) {
+            if ($detail) {
+                print "\nWHAT IS BEING TESTED\n";
+                print "--------------------";
+            }
+            print "\n\n$description\n\n";
+        }
+        # If the detail option has been specified, then the details of HOW
+        # the test is testing what it says it is testing in the verbose output
+        # will be displayed here before the results of the test are displayed.
+        if ($detail) {
+            print "\nHOW IT IS TESTED\n";
+            print "----------------";
+            print "\n\n$details\n\n";
+        }
+        print "$status\n";
+    }
+}
 …
   local($slurp, $answer_matched) = ('', 0);
-  print "Comparing Output ........ " if $debug;
-  $slurp = &read_file_into_string ($logfile);
-  # For make, get rid of any time skew error before comparing--too bad this
-  # has to go into the "generic" driver code :-/
-  $slurp =~ s/^.*modification time .*in the future.*\n//gm;
-  $slurp =~ s/^.*Clock skew detected.*\n//gm;
   ++$tests_run;
+  if ($slurp eq $answer) {
+    $answer_matched = 1;
+  if (! defined $answer) {
+      print "Ignoring output ........ " if $debug;
+      $answer_matched = 1;
   } else {
+    # See if it is a slash or CRLF problem
+    local ($answer_mod, $slurp_mod) = ($answer, $slurp);
+    $answer_mod =~ tr,\\,/,;
+    $answer_mod =~ s,\r\n,\n,gs;
+    $slurp_mod =~ tr,\\,/,;
+    $slurp_mod =~ s,\r\n,\n,gs;
+    $answer_matched = ($slurp_mod eq $answer_mod);
+    # If it still doesn't match, see if the answer might be a regex.
+    if (!$answer_matched && $answer =~ m,^/(.+)/$,) {
+      $answer_matched = ($slurp =~ /$1/);
+      if (!$answer_matched && $answer_mod =~ m,^/(.+)/$,) {
+          $answer_matched = ($slurp_mod =~ /$1/);
+      print "Comparing Output ........ " if $debug;
+      $slurp = &read_file_into_string ($logfile);
+      # For make, get rid of any time skew error before comparing--too bad this
+      # has to go into the "generic" driver code :-/
+      $slurp =~ s/^.*modification time .*in the future.*\n//gm;
+      $slurp =~ s/^.*Clock skew detected.*\n//gm;
+      if ($slurp eq $answer) {
+          $answer_matched = 1;
+      } else {
+          # See if it is a slash or CRLF problem
+          local ($answer_mod, $slurp_mod) = ($answer, $slurp);
+          $answer_mod =~ tr,\\,/,;
+          $answer_mod =~ s,\r\n,\n,gs;
+          $slurp_mod =~ tr,\\,/,;
+          $slurp_mod =~ s,\r\n,\n,gs;
+          $answer_matched = ($slurp_mod eq $answer_mod);
+          if ($^O eq 'VMS') {
+            # VMS has extra blank lines in output sometimes.
+            # Ticket #41760
+            if (!$answer_matched) {
+              $slurp_mod =~ s/\n\n+/\n/gm;
+              $slurp_mod =~ s/\A\n+//g;
+              $answer_matched = ($slurp_mod eq $answer_mod);
+            }
+            # VMS adding a "Waiting for unfinished jobs..."
+            # Remove it for now to see what else is going on.
+            if (!$answer_matched) {
+              $slurp_mod =~ s/^.+\*\*\* Waiting for unfinished jobs.+$//m;
+              $slurp_mod =~ s/\n\n/\n/gm;
+              $slurp_mod =~ s/^\n+//gm;
+              $answer_matched = ($slurp_mod eq $answer_mod);
+            }
+            # VMS wants target device to exist or generates an error,
+            # Some test tagets look like VMS devices and trip this.
+            if (!$answer_matched) {
+              $slurp_mod =~ s/^.+\: no such device or address.*$//gim;
+              $slurp_mod =~ s/\n\n/\n/gm;
+              $slurp_mod =~ s/^\n+//gm;
+              $answer_matched = ($slurp_mod eq $answer_mod);
+            }
+            # VMS error message has a different case
+            if (!$answer_matched) {
+              $slurp_mod =~ s/no such file /No such file /gm;
+              $answer_matched = ($slurp_mod eq $answer_mod);
+            }
+            # VMS is putting comas instead of spaces in output
+            if (!$answer_matched) {
+              $slurp_mod =~ s/,/ /gm;
+              $answer_matched = ($slurp_mod eq $answer_mod);
+            }
+            # VMS Is sometimes adding extra leading spaces to output?
+            if (!$answer_matched) {
+               my $slurp_mod = $slurp_mod;
+               $slurp_mod =~ s/^ +//gm;
+               $answer_matched = ($slurp_mod eq $answer_mod);
+            }
+            # VMS port not handling POSIX encoded child status
+            # Translate error case it for now.
+            if (!$answer_matched) {
+              $slurp_mod =~ s/0x1035a00a/1/gim;
+              $answer_matched = 1 if $slurp_mod =~ /\Q$answer_mod\E/i;
+            }
+            if (!$answer_matched) {
+              $slurp_mod =~ s/0x1035a012/2/gim;
+              $answer_matched = ($slurp_mod eq $answer_mod);
+            }
+            # Tests are using a UNIX null command, temp hack
+            # until this can be handled by the VMS port.
+            # ticket # 41761
+            if (!$answer_matched) {
+              $slurp_mod =~ s/^.+DCL-W-NOCOMD.*$//gim;
+              $slurp_mod =~ s/\n\n+/\n/gm;
+              $slurp_mod =~ s/^\n+//gm;
+              $answer_matched = ($slurp_mod eq $answer_mod);
+            }
+            # Tests are using exit 0;
+            # this generates a warning that should stop the make, but does not
+            if (!$answer_matched) {
+              $slurp_mod =~ s/^.+NONAME-W-NOMSG.*$//gim;
+              $slurp_mod =~ s/\n\n+/\n/gm;
+              $slurp_mod =~ s/^\n+//gm;
+              $answer_matched = ($slurp_mod eq $answer_mod);
+            }
+            # VMS is sometimes adding single quotes to output?
+            if (!$answer_matched) {
+              my $noq_slurp_mod = $slurp_mod;
+              $noq_slurp_mod =~ s/\'//gm;
+              $answer_matched = ($noq_slurp_mod eq $answer_mod);
+              # And missing an extra space in output
+              if (!$answer_matched) {
+                $noq_answer_mod = $answer_mod;
+                $noq_answer_mod =~ s/\h\h+/ /gm;
+                $answer_matched = ($noq_slurp_mod eq $noq_answer_mod);
+              }
+              # VMS adding ; to end of some lines.
+              if (!$answer_matched) {
+                $noq_slurp_mod =~ s/;\n/\n/gm;
+                $answer_matched = ($noq_slurp_mod eq $noq_answer_mod);
+              }
+              # VMS adding trailing space to end of some quoted lines.
+              if (!$answer_matched) {
+                $noq_slurp_mod =~ s/\h+\n/\n/gm;
+                $answer_matched = ($noq_slurp_mod eq $noq_answer_mod);
+              }
+              # And VMS missing leading blank line
+              if (!$answer_matched) {
+                $noq_answer_mod =~ s/\A\n//g;
+                $answer_matched = ($noq_slurp_mod eq $noq_answer_mod);
+              }
+              # Unix double quotes showing up as single quotes on VMS.
+              if (!$answer_matched) {
+                $noq_answer_mod =~ s/\"//g;
+                $answer_matched = ($noq_slurp_mod eq $noq_answer_mod);
+              }
+            }
+          }
+          # If it still doesn't match, see if the answer might be a regex.
+          if (!$answer_matched && $answer =~ m,^/(.+)/$,) {
+              $answer_matched = ($slurp =~ /$1/);
+              if (!$answer_matched && $answer_mod =~ m,^/(.+)/$,) {
+                  $answer_matched = ($slurp_mod =~ /$1/);
+              }
+          }
+      }
+    }
+  }
 …
     local($command) = "diff -c " . &get_basefile . " " . $logfile;
     &run_command_with_output(&get_difffile,$command);
+  } else {
+      &rmfiles ();
+  }
+  $suite_passed = 0;
+  }
   return 0;
+}
 …
+}
+my @OUTSTACK = ();
+my @ERRSTACK = ();
 sub attach_default_output
+{
 …
+  }
+  open ("SAVEDOS" . $default_output_stack_level . "out", ">&STDOUT")
+        || &error ("ado: $! duping STDOUT\n", 1);
+  open ("SAVEDOS" . $default_output_stack_level . "err", ">&STDERR")
+        || &error ("ado: $! duping STDERR\n", 1);
+  open (STDOUT, "> " . $filename)
+        || &error ("ado: $filename: $!\n", 1);
+  open (STDERR, ">&STDOUT")
+        || &error ("ado: $filename: $!\n", 1);
+  $default_output_stack_level++;
+  my $dup = undef;
+  open($dup, '>&', STDOUT) or error("ado: $! duping STDOUT\n", 1);
+  push @OUTSTACK, $dup;
+  $dup = undef;
+  open($dup, '>&', STDERR) or error("ado: $! duping STDERR\n", 1);
+  push @ERRSTACK, $dup;
+  open(STDOUT, '>', $filename) or error("ado: $filename: $!\n", 1);
+  open(STDERR, ">&STDOUT") or error("ado: $filename: $!\n", 1);
+}
 …
+  }
+  if (--$default_output_stack_level < 0)
+  {
+    &error ("default output stack has flown under!\n", 1);
+  }
+  close (STDOUT);
+  close (STDERR);
+  open (STDOUT, ">&SAVEDOS" . $default_output_stack_level . "out")
+        || &error ("ddo: $! duping STDOUT\n", 1);
+  open (STDERR, ">&SAVEDOS" . $default_output_stack_level . "err")
+        || &error ("ddo: $! duping STDERR\n", 1);
+  close ("SAVEDOS" . $default_output_stack_level . "out")
+        || &error ("ddo: $! closing SCSDOSout\n", 1);
+  close ("SAVEDOS" . $default_output_stack_level . "err")
+         || &error ("ddo: $! closing SAVEDOSerr\n", 1);
+  @OUTSTACK or error("default output stack has flown under!\n", 1);
+  close(STDOUT);
+  close(STDERR) unless $^O eq 'VMS';
+  open (STDOUT, '>&', pop @OUTSTACK) or error("ddo: $! duping STDOUT\n", 1);
+  open (STDERR, '>&', pop @ERRSTACK) or error("ddo: $! duping STDERR\n", 1);
+}
 …
   eval {
+      local $SIG{ALRM} = sub { die "timeout\n"; };
+      alarm $test_timeout;
+      $code = system(@_);
+      if ($^O eq 'VMS') {
+          local $SIG{ALRM} = sub {
+              my $e = $ERRSTACK[0];
+              print $e "\nTest timed out after $test_timeout seconds\n";
+              die "timeout\n"; };
+#          alarm $test_timeout;
+          system(@_);
+          my $severity = ${^CHILD_ERROR_NATIVE} & 7;
+          $code = 0;
+          if (($severity & 1) == 0) {
+              $code = 512;
+          }
+          # Get the vms status.
+          my $vms_code = ${^CHILD_ERROR_NATIVE};
+          # Remove the print status bit
+          $vms_code &= ~0x10000000;
+          # Posix code translation.
+          if (($vms_code & 0xFFFFF000) == 0x35a000) {
+              $code = (($vms_code & 0xFFF) >> 3) * 256;
+          }
+      } else {
+          my $pid = fork();
+          if (! $pid) {
+              exec(@_) or die "Cannot execute $_[0]\n";
+          }
+          local $SIG{ALRM} = sub { my $e = $ERRSTACK[0]; print $e "\nTest timed out after $test_timeout seconds\n"; die "timeout\n"; };
+          alarm $test_timeout;
+          waitpid($pid, 0) > 0 or die "No such pid: $pid\n";
+          $code = $?;
+      }
       alarm 0;
   };
   if ($@) {
       # The eval failed.  If it wasn't SIGALRM then die.
       $@ eq "timeout\n" or die;
+      $@ eq "timeout\n" or die "Command failed: $@";
       # Timed out.  Resend the alarm to our process group to kill the children.
 …
   my $code = _run_command(@_);
   print "run_command returned $code.\n" if $debug;
+  print "vms status = ${^CHILD_ERROR_NATIVE}\n" if $debug and $^O eq 'VMS';
   return $code;
+}
 …
   print "\nrun_command_with_output($filename,$runname): @_\n" if $debug;
   &attach_default_output ($filename);
+  my $code = _run_command(@_);
+  my $code = eval { _run_command(@_) };
+  my $err = $@;
   &detach_default_output;
+  $err and die $err;
   print "run_command_with_output returned $code.\n" if $debug;
+  print "vms status = ${^CHILD_ERROR_NATIVE}\n" if $debug and $^O eq 'VMS';
   return $code;
+}
 …
     else
+    {
+      unlink $object || return 0;
+      if ($^O ne 'VMS')
+      {
+        unlink $object || return 0;
+      }
+      else
+      {
+        # VMS can have multiple versions of a file.
+while unlink $object;
+      }
+    }
+  }
 …
   foreach $file (@_) {
     (open(T, ">> $file") && print(T "\n") && close(T))
         || &error("Couldn't touch $file: $!\n", 1);
+        || &error("Couldn't touch $file: $!\n", 1);
+  }
+}

vendor/gnumake/current/variable.c

-              r2596
+              r3138
 /* Internals of variables for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include <assert.h>
+#include "filedef.h"
 #include "dep.h"
-#include "filedef.h"
 #include "job.h"
 #include "commands.h"
 …
 #endif
 #include "hash.h"
+/* Incremented every time we add or remove a global variable.  */
+static unsigned long variable_changenum;
 /* Chain of all pattern-specific variables.  */
 …
+{
   struct pattern_var *p;
   unsigned int targlen = strlen(target);
+  unsigned int targlen = strlen (target);
   for (p = start ? start->next : pattern_vars; p != 0; p = p->next)
 …
+}
 #ifndef VARIABLE_BUCKETS
 #define VARIABLE_BUCKETS                523
+#ifndef VARIABLE_BUCKETS
+#define VARIABLE_BUCKETS                523
 #endif
 #ifndef PERFILE_VARIABLE_BUCKETS
 #define PERFILE_VARIABLE_BUCKETS        23
+#ifndef PERFILE_VARIABLE_BUCKETS
+#define PERFILE_VARIABLE_BUCKETS        23
 #endif
 #ifndef SMALL_SCOPE_VARIABLE_BUCKETS
 #define SMALL_SCOPE_VARIABLE_BUCKETS    13
+#ifndef SMALL_SCOPE_VARIABLE_BUCKETS
+#define SMALL_SCOPE_VARIABLE_BUCKETS    13
 #endif
 …
+{
   hash_init (&global_variable_set.table, VARIABLE_BUCKETS,
              variable_hash_1, variable_hash_2, variable_hash_cmp);
+             variable_hash_1, variable_hash_2, variable_hash_cmp);
+}
 …
                         const char *value, enum variable_origin origin,
                         int recursive, struct variable_set *set,
                         const struct floc *flocp)
+                        const floc *flocp)
+{
   struct variable *v;
 …
   var_key.length = length;
   var_slot = (struct variable **) hash_find_slot (&set->table, &var_key);
+  v = *var_slot;
+#ifdef VMS
+  /* VMS does not populate envp[] with DCL symbols and logical names which
+     historically are mapped to environent variables.
+     If the variable is not yet defined, then we need to check if getenv()
+     can find it.  Do not do this for origin == o_env to avoid infinte
+     recursion */
+  if (HASH_VACANT (v) && (origin != o_env))
+    {
+      struct variable * vms_variable;
+      char * vname = alloca (length + 1);
+      char * vvalue;
+      strncpy (vname, name, length);
+      vvalue = getenv(vname);
+      /* Values starting with '$' are probably foreign commands.
+         We want to treat them as Shell aliases and not look them up here */
+      if ((vvalue != NULL) && (vvalue[0] != '$'))
+        {
+          vms_variable =  lookup_variable(name, length);
+          /* Refresh the slot */
+          var_slot = (struct variable **) hash_find_slot (&set->table,
+                                                          &var_key);
+          v = *var_slot;
+        }
+    }
+#endif
   if (env_overrides && origin == o_env)
     origin = o_env_override;
-  v = *var_slot;
   if (! HASH_VACANT (v))
+    {
       if (env_overrides && v->origin == o_env)
         /* V came from in the environment.  Since it was defined
            before the switches were parsed, it wasn't affected by -e.  */
         v->origin = o_env_override;
+        /* V came from in the environment.  Since it was defined
+           before the switches were parsed, it wasn't affected by -e.  */
+        v->origin = o_env_override;
       /* A variable of this name is already defined.
          If the old definition is from a stronger source
          than this one, don't redefine it.  */
+         If the old definition is from a stronger source
+         than this one, don't redefine it.  */
       if ((int) origin >= (int) v->origin)
+        {
+          if (v->value != 0)
+            free (v->value);
+          v->value = xstrdup (value);
+        {
+          free (v->value);
+          v->value = xstrdup (value);
           if (flocp != 0)
             v->fileinfo = *flocp;
           else
             v->fileinfo.filenm = 0;
           v->origin = origin;
           v->recursive = recursive;
+        }
+          v->origin = origin;
+          v->recursive = recursive;
+        }
       return v;
+    }
 …
   v->length = length;
   hash_insert_at (&set->table, v, var_slot);
+  if (set == &global_variable_set)
+    ++variable_changenum;
   v->value = xstrdup (value);
   if (flocp != 0)
 …
 static void
+free_variable_name_and_value (const void *item);
+free_variable_name_and_value (const void *item)
+{
+  struct variable *v = (struct variable *) item;
+  free (v->name);
+  free (v->value);
+}
+void
+free_variable_set (struct variable_set_list *list)
+{
+  hash_map (&list->set->table, free_variable_name_and_value);
+  hash_free (&list->set->table, 1);
+  free (list->set);
+  free (list);
+}
 void
 …
+    {
       if (env_overrides && v->origin == o_env)
         /* V came from in the environment.  Since it was defined
            before the switches were parsed, it wasn't affected by -e.  */
         v->origin = o_env_override;
       /* If the definition is from a stronger source than this one, don't
          undefine it.  */
+        /* V came from in the environment.  Since it was defined
+           before the switches were parsed, it wasn't affected by -e.  */
+        v->origin = o_env_override;
+      /* Undefine only if this undefinition is from an equal or stronger
+         source than the variable definition.  */
       if ((int) origin >= (int) v->origin)
+        {
+        {
           hash_delete_at (&set->table, var_slot);
           free_variable_name_and_value (v);
+        }
+          free (v);
+          if (set == &global_variable_set)
+            ++variable_changenum;
+        }
+    }
+}
 …
 lookup_special_var (struct variable *var)
+{
   static unsigned long last_var_count = 0;
+  static unsigned long last_changenum = 0;
 …
   */
+  if (streq (var->name, ".VARIABLES")
+      && global_variable_set.table.ht_fill != last_var_count)
+  if (variable_changenum != last_changenum && streq (var->name, ".VARIABLES"))
+    {
       unsigned long max = EXPANSION_INCREMENT (strlen (var->value));
 …
       *(p-1) = '\0';
+      /* Remember how many variables are in our current count.  Since we never
+         remove variables from the list, this is a reliable way to know whether
+         the list is up to date or needs to be recomputed.  */
+      last_var_count = global_variable_set.table.ht_fill;
+      /* Remember the current variable change number.  */
+      last_changenum = variable_changenum;
+    }
 …
 /* Lookup a variable whose name is a string starting at NAME
    and with LENGTH chars.  NAME need not be null-terminated.
    Returns address of the `struct variable' containing all info
+   Returns address of the 'struct variable' containing all info
    on the variable, or nil if no such variable is defined.  */
 …
       v = (struct variable *) hash_find_item ((struct hash_table *) &set->table, &var_key);
       if (v && (!is_parent || !v->private_var))
         return v->special ? lookup_special_var (v) : v;
+        return v->special ? lookup_special_var (v) : v;
       is_parent |= setlist->next_is_parent;
 …
 #ifdef VMS
   /* since we don't read envp[] on startup, try to get the
      variable via getenv() here.  */
+  /* VMS does not populate envp[] with DCL symbols and logical names which
+     historically are mapped to enviroment varables and returned by getenv() */
+  {
     char *vname = alloca (length + 1);
 …
 /* Lookup a variable whose name is a string starting at NAME
    and with LENGTH chars in set SET.  NAME need not be null-terminated.
    Returns address of the `struct variable' containing all info
+   Returns address of the 'struct variable' containing all info
    on the variable, or nil if no such variable is defined.  */
 …
+    {
       l = (struct variable_set_list *)
         xmalloc (sizeof (struct variable_set_list));
+        xmalloc (sizeof (struct variable_set_list));
       l->set = xmalloc (sizeof (struct variable_set));
       hash_init (&l->set->table, PERFILE_VARIABLE_BUCKETS,
 …
   set = xmalloc (sizeof (struct variable_set));
   hash_init (&set->table, SMALL_SCOPE_VARIABLE_BUCKETS,
              variable_hash_1, variable_hash_2, variable_hash_cmp);
+             variable_hash_1, variable_hash_2, variable_hash_cmp);
   setlist = (struct variable_set_list *)
 …
+}
-static void
-free_variable_name_and_value (const void *item)
+{
-  struct variable *v = (struct variable *) item;
-  free (v->name);
-  free (v->value);
+}
-void
-free_variable_set (struct variable_set_list *list)
+{
-  hash_map (&list->set->table, free_variable_name_and_value);
-  hash_free (&list->set->table, 1);
-  free (list->set);
-  free (list);
+}
 /* Create a new variable set and push it on the current setlist.
    If we're pushing a global scope (that is, the current scope is the global
 …
 push_new_variable_scope (void)
+{
   current_variable_set_list = create_new_variable_set();
+  current_variable_set_list = create_new_variable_set ();
   if (current_variable_set_list->next == &global_setlist)
+    {
 …
   /* Can't call this if there's no scope to pop!  */
   assert(current_variable_set_list->next != NULL);
+  assert (current_variable_set_list->next != NULL);
   if (current_variable_set_list != &global_setlist)
 …
   struct variable **from_var_end = from_var_slot + from_set->table.ht_size;
+  int inc = to_set == &global_variable_set ? 1 : 0;
   for ( ; from_var_slot < from_var_end; from_var_slot++)
     if (! HASH_VACANT (*from_var_slot))
+      {
+        struct variable *from_var = *from_var_slot;
+        struct variable **to_var_slot
+          = (struct variable **) hash_find_slot (&to_set->table, *from_var_slot);
+        if (HASH_VACANT (*to_var_slot))
+          hash_insert_at (&to_set->table, from_var, to_var_slot);
+        else
+          {
+            /* GKM FIXME: delete in from_set->table */
+            free (from_var->value);
+            free (from_var);
+          }
+        struct variable *from_var = *from_var_slot;
+        struct variable **to_var_slot
+          = (struct variable **) hash_find_slot (&to_set->table, *from_var_slot);
+        if (HASH_VACANT (*to_var_slot))
+          {
+            hash_insert_at (&to_set->table, from_var, to_var_slot);
+            variable_changenum += inc;
+          }
+        else
+          {
+            /* GKM FIXME: delete in from_set->table */
+            free (from_var->value);
+            free (from_var);
+          }
+      }
+}
 …
+    {
       if (last0 == 0)
         *setlist0 = setlist1;
+        *setlist0 = setlist1;
       else
         last0->next = setlist1;
+        last0->next = setlist1;
+    }
+}
 …
 define_automatic_variables (void)
+{
+#if defined(WINDOWS32) || defined(__EMX__)
+  extern char* default_shell;
+#else
+  extern char default_shell[];
+#endif
+  register struct variable *v;
+  struct variable *v;
   char buf[200];
 …
   sprintf (buf, "%s%s%s",
            version_string,
            (remote_description == 0 || remote_description[0] == '\0')
            ? "" : "-",
            (remote_description == 0 || remote_description[0] == '\0')
            ? "" : remote_description);
+           version_string,
+           (remote_description == 0 || remote_description[0] == '\0')
+           ? "" : "-",
+           (remote_description == 0 || remote_description[0] == '\0')
+           ? "" : remote_description);
   define_variable_cname ("MAKE_VERSION", buf, o_default, 0);
+  define_variable_cname ("MAKE_HOST", make_host, o_default, 0);
 #ifdef  __MSDOS__
 …
     if (mshp)
       (void) define_variable (shell_str, shlen,
                               mshp->value, o_env_override, 0);
+                              mshp->value, o_env_override, 0);
     else if (comp)
+      {
         /* $(COMSPEC) shouldn't override $(SHELL).  */
         struct variable *shp = lookup_variable (shell_str, shlen);
         if (!shp)
           (void) define_variable (shell_str, shlen, comp->value, o_env, 0);
+        /* $(COMSPEC) shouldn't override $(SHELL).  */
+        struct variable *shp = lookup_variable (shell_str, shlen);
+        if (!shp)
+          (void) define_variable (shell_str, shlen, comp->value, o_env, 0);
+      }
+  }
 …
     if (!replace || !*replace->value)
       if (shell && *shell->value && (shell->origin == o_env
           || shell->origin == o_env_override))
+        {
           /* overwrite whatever we got from the environment */
           free(shell->value);
           shell->value = xstrdup (default_shell);
           shell->origin = o_default;
+        }
+          || shell->origin == o_env_override))
+        {
+          /* overwrite whatever we got from the environment */
+          free (shell->value);
+          shell->value = xstrdup (default_shell);
+          shell->origin = o_default;
+        }
     /* Some people do not like cmd to be used as the default
 …
       /* overwrite $SHELL */
       (void) define_variable (shell_str, shlen, replace->value,
                               replace->origin, 0);
+                              replace->origin, 0);
     else
       /* provide a definition if there is none */
       (void) define_variable (shell_str, shlen, default_shell,
                               o_default, 0);
+                              o_default, 0);
+  }
 …
      the automatic variables they are variations of.  */
+#ifdef VMS
+  define_variable_cname ("@D", "$(dir $@)", o_automatic, 1);
+  define_variable_cname ("%D", "$(dir $%)", o_automatic, 1);
+  define_variable_cname ("*D", "$(dir $*)", o_automatic, 1);
+  define_variable_cname ("<D", "$(dir $<)", o_automatic, 1);
+  define_variable_cname ("?D", "$(dir $?)", o_automatic, 1);
+  define_variable_cname ("^D", "$(dir $^)", o_automatic, 1);
+  define_variable_cname ("+D", "$(dir $+)", o_automatic, 1);
+#else
+#if defined(__MSDOS__) || defined(WINDOWS32)
+  /* For consistency, remove the trailing backslash as well as slash.  */
+  define_variable_cname ("@D", "$(patsubst %/,%,$(patsubst %\\,%,$(dir $@)))",
+                         o_automatic, 1);
+  define_variable_cname ("%D", "$(patsubst %/,%,$(patsubst %\\,%,$(dir $%)))",
+                         o_automatic, 1);
+  define_variable_cname ("*D", "$(patsubst %/,%,$(patsubst %\\,%,$(dir $*)))",
+                         o_automatic, 1);
+  define_variable_cname ("<D", "$(patsubst %/,%,$(patsubst %\\,%,$(dir $<)))",
+                         o_automatic, 1);
+  define_variable_cname ("?D", "$(patsubst %/,%,$(patsubst %\\,%,$(dir $?)))",
+                         o_automatic, 1);
+  define_variable_cname ("^D", "$(patsubst %/,%,$(patsubst %\\,%,$(dir $^)))",
+                         o_automatic, 1);
+  define_variable_cname ("+D", "$(patsubst %/,%,$(patsubst %\\,%,$(dir $+)))",
+                         o_automatic, 1);
+#else  /* not __MSDOS__, not WINDOWS32 */
   define_variable_cname ("@D", "$(patsubst %/,%,$(dir $@))", o_automatic, 1);
   define_variable_cname ("%D", "$(patsubst %/,%,$(dir $%))", o_automatic, 1);
 …
 /* Create a new environment for FILE's commands.
    If FILE is nil, this is for the `shell' function.
+   If FILE is nil, this is for the 'shell' function.
    The child's MAKELEVEL variable is incremented.  */
 …
   hash_init (&table, VARIABLE_BUCKETS,
              variable_hash_1, variable_hash_2, variable_hash_cmp);
+             variable_hash_1, variable_hash_2, variable_hash_cmp);
   /* Run through all the variable sets in the list,
 …
       v_end = v_slot + set->table.ht_size;
       for ( ; v_slot < v_end; v_slot++)
         if (! HASH_VACANT (*v_slot))
+          {
             struct variable **new_slot;
             struct variable *v = *v_slot;
             /* If this is a per-target variable and it hasn't been touched
                already then look up the global version and take its export
                value.  */
             if (v->per_target && v->export == v_default)
+              {
                 struct variable *gv;
                 gv = lookup_variable_in_set (v->name, strlen(v->name),
+        if (! HASH_VACANT (*v_slot))
+          {
+            struct variable **new_slot;
+            struct variable *v = *v_slot;
+            /* If this is a per-target variable and it hasn't been touched
+               already then look up the global version and take its export
+               value.  */
+            if (v->per_target && v->export == v_default)
+              {
+                struct variable *gv;
+                gv = lookup_variable_in_set (v->name, strlen (v->name),
                                              &global_variable_set);
                 if (gv)
                   v->export = gv->export;
+              }
             switch (v->export)
+              {
               case v_default:
                 if (v->origin == o_default || v->origin == o_automatic)
                   /* Only export default variables by explicit request.  */
                   continue;
+                if (gv)
+                  v->export = gv->export;
+              }
+            switch (v->export)
+              {
+              case v_default:
+                if (v->origin == o_default || v->origin == o_automatic)
+                  /* Only export default variables by explicit request.  */
+                  continue;
                 /* The variable doesn't have a name that can be exported.  */
 …
                   continue;
+                if (! export_all_variables
+                    && v->origin != o_command
+                    && v->origin != o_env && v->origin != o_env_override)
+                  continue;
+                break;
+              case v_export:
+                break;
+              case v_noexport:
+                {
+                  /* If this is the SHELL variable and it's not exported,
+                     then add the value from our original environment, if
+                     the original environment defined a value for SHELL.  */
+                  extern struct variable shell_var;
+                  if (streq (v->name, "SHELL") && shell_var.value)
+                    {
+                      v = &shell_var;
+                      break;
+                    }
+                  continue;
+                }
+              case v_ifset:
+                if (v->origin == o_default)
+                  continue;
+                break;
+              }
+            new_slot = (struct variable **) hash_find_slot (&table, v);
+            if (HASH_VACANT (*new_slot))
+              hash_insert_at (&table, v, new_slot);
+          }
+    }
+  makelevel_key.name = MAKELEVEL_NAME;
+                if (! export_all_variables
+                    && v->origin != o_command
+                    && v->origin != o_env && v->origin != o_env_override)
+                  continue;
+                break;
+              case v_export:
+                break;
+              case v_noexport:
+                {
+                  /* If this is the SHELL variable and it's not exported,
+                     then add the value from our original environment, if
+                     the original environment defined a value for SHELL.  */
+                  if (streq (v->name, "SHELL") && shell_var.value)
+                    {
+                      v = &shell_var;
+                      break;
+                    }
+                  continue;
+                }
+              case v_ifset:
+                if (v->origin == o_default)
+                  continue;
+                break;
+              }
+            new_slot = (struct variable **) hash_find_slot (&table, v);
+            if (HASH_VACANT (*new_slot))
+              hash_insert_at (&table, v, new_slot);
+          }
+    }
+  makelevel_key.name = (char *)MAKELEVEL_NAME;
   makelevel_key.length = MAKELEVEL_LENGTH;
   hash_delete (&table, &makelevel_key);
 …
     if (! HASH_VACANT (*v_slot))
+      {
         struct variable *v = *v_slot;
         /* If V is recursively expanded and didn't come from the environment,
            expand its value.  If it came from the environment, it should
            go back into the environment unchanged.  */
         if (v->recursive
             && v->origin != o_env && v->origin != o_env_override)
+          {
             char *value = recursively_expand_for_file (v, file);
+        struct variable *v = *v_slot;
+        /* If V is recursively expanded and didn't come from the environment,
+           expand its value.  If it came from the environment, it should
+           go back into the environment unchanged.  */
+        if (v->recursive
+            && v->origin != o_env && v->origin != o_env_override)
+          {
+            char *value = recursively_expand_for_file (v, file);
 #ifdef WINDOWS32
             if (strcmp(v->name, "Path") == 0 ||
                 strcmp(v->name, "PATH") == 0)
               convert_Path_to_windows32(value, ';');
+            if (strcmp (v->name, "Path") == 0 ||
+                strcmp (v->name, "PATH") == 0)
+              convert_Path_to_windows32 (value, ';');
 #endif
             *result++ = xstrdup (concat (3, v->name, "=", value));
             free (value);
+          }
         else
+          {
+            *result++ = xstrdup (concat (3, v->name, "=", value));
+            free (value);
+          }
+        else
+          {
 #ifdef WINDOWS32
             if (strcmp(v->name, "Path") == 0 ||
                 strcmp(v->name, "PATH") == 0)
               convert_Path_to_windows32(v->value, ';');
+            if (strcmp (v->name, "Path") == 0 ||
+                strcmp (v->name, "PATH") == 0)
+              convert_Path_to_windows32 (v->value, ';');
 #endif
             *result++ = xstrdup (concat (3, v->name, "=", v->value));
+          }
+            *result++ = xstrdup (concat (3, v->name, "=", v->value));
+          }
+      }
 …
+/* Given a string, shell-execute it and return a malloc'ed string of the
+ * result. This removes only ONE newline (if any) at the end, for maximum
+ * compatibility with the *BSD makes.  If it fails, returns NULL. */
+static char *
+shell_result (const char *p)
+{
+  char *buf;
+  unsigned int len;
+  char *args[2];
+  char *result;
+  install_variable_buffer (&buf, &len);
+  args[0] = (char *) p;
+  args[1] = NULL;
+  variable_buffer_output (func_shell_base (variable_buffer, args, 0), "\0", 1);
+  result = strdup (variable_buffer);
+  restore_variable_buffer (buf, len);
+  return result;
+}
 /* Given a variable, a value, and a flavor, define the variable.
    See the try_variable_definition() function for details on the parameters. */
 struct variable *
 do_variable_definition (const struct floc *flocp, const char *varname,
+do_variable_definition (const floc *flocp, const char *varname,
                         const char *value, enum variable_origin origin,
                         enum variable_flavor flavor, int target_var)
 …
       /* A simple variable definition "var := value".  Expand the value.
          We have to allocate memory since otherwise it'll clobber the
          variable buffer, and we may still need that if we're looking at a
+         variable buffer, and we may still need that if we're looking at a
          target-specific variable.  */
       p = alloc_value = allocated_variable_expand (value);
       break;
+    case f_shell:
+      {
+        /* A shell definition "var != value".  Expand value, pass it to
+           the shell, and store the result in recursively-expanded var. */
+        char *q = allocated_variable_expand (value);
+        p = alloc_value = shell_result (q);
+        free (q);
+        flavor = f_recursive;
+        break;
+      }
     case f_conditional:
       /* A conditional variable definition "var ?= value".
 …
     case f_recursive:
       /* A recursive variable definition "var = value".
          The value is used verbatim.  */
+         The value is used verbatim.  */
       p = value;
       break;
 …
             memcpy (&alloc_value[oldlen + 1], val, vallen + 1);
+            if (tp)
+              free (tp);
+            free (tp);
+          }
+      }
 …
   /* Many Unix Makefiles include a line saying "SHELL=/bin/sh", but
      non-Unix systems don't conform to this default configuration (in
      fact, most of them don't even have `/bin').  On the other hand,
+     fact, most of them don't even have '/bin').  On the other hand,
      $SHELL in the environment, if set, points to the real pathname of
      the shell.
 …
       /* See if we can find "/bin/sh.exe", "/bin/sh.com", etc.  */
       if (__dosexec_find_on_path (p, NULL, shellpath))
+        {
           char *tp;
           for (tp = shellpath; *tp; tp++)
+        {
+          char *tp;
+          for (tp = shellpath; *tp; tp++)
             if (*tp == '\\')
               *tp = '/';
           v = define_variable_loc (varname, strlen (varname),
+          v = define_variable_loc (varname, strlen (varname),
                                    shellpath, origin, flavor == f_recursive,
                                    flocp);
+        }
+        }
       else
+        {
           const char *shellbase, *bslash;
           struct variable *pathv = lookup_variable ("PATH", 4);
           char *path_string;
           char *fake_env[2];
           size_t pathlen = 0;
           shellbase = strrchr (p, '/');
           bslash = strrchr (p, '\\');
           if (!shellbase || bslash > shellbase)
             shellbase = bslash;
           if (!shellbase && p[1] == ':')
             shellbase = p + 1;
           if (shellbase)
             shellbase++;
           else
             shellbase = p;
           /* Search for the basename of the shell (with standard
              executable extensions) along the $PATH.  */
           if (pathv)
             pathlen = strlen (pathv->value);
           path_string = xmalloc (5 + pathlen + 2 + 1);
           /* On MSDOS, current directory is considered as part of $PATH.  */
           sprintf (path_string, "PATH=.;%s", pathv ? pathv->value : "");
           fake_env[0] = path_string;
           fake_env[1] = 0;
           if (__dosexec_find_on_path (shellbase, fake_env, shellpath))
+            {
               char *tp;
               for (tp = shellpath; *tp; tp++)
+        {
+          const char *shellbase, *bslash;
+          struct variable *pathv = lookup_variable ("PATH", 4);
+          char *path_string;
+          char *fake_env[2];
+          size_t pathlen = 0;
+          shellbase = strrchr (p, '/');
+          bslash = strrchr (p, '\\');
+          if (!shellbase || bslash > shellbase)
+            shellbase = bslash;
+          if (!shellbase && p[1] == ':')
+            shellbase = p + 1;
+          if (shellbase)
+            shellbase++;
+          else
+            shellbase = p;
+          /* Search for the basename of the shell (with standard
+             executable extensions) along the $PATH.  */
+          if (pathv)
+            pathlen = strlen (pathv->value);
+          path_string = xmalloc (5 + pathlen + 2 + 1);
+          /* On MSDOS, current directory is considered as part of $PATH.  */
+          sprintf (path_string, "PATH=.;%s", pathv ? pathv->value : "");
+          fake_env[0] = path_string;
+          fake_env[1] = 0;
+          if (__dosexec_find_on_path (shellbase, fake_env, shellpath))
+            {
+              char *tp;
+              for (tp = shellpath; *tp; tp++)
                 if (*tp == '\\')
                   *tp = '/';
               v = define_variable_loc (varname, strlen (varname),
+              v = define_variable_loc (varname, strlen (varname),
                                        shellpath, origin,
                                        flavor == f_recursive, flocp);
+            }
           else
             v = lookup_variable (varname, strlen (varname));
           free (path_string);
+        }
+            }
+          else
+            v = lookup_variable (varname, strlen (varname));
+          free (path_string);
+        }
+    }
   else
 …
       && streq (varname, "SHELL"))
+    {
       extern char *default_shell;
+      extern const char *default_shell;
       /* Call shell locator function. If it returns TRUE, then
          set no_default_sh_exe to indicate sh was found and
+         set no_default_sh_exe to indicate sh was found and
          set new value for SHELL variable.  */
 …
             v = lookup_variable (varname, strlen (varname));
+          if (tp)
+            free (tp);
+          free (tp);
+        }
+    }
 …
   v->conditional = conditional;
+  if (alloc_value)
+    free (alloc_value);
+  free (alloc_value);
   return v->special ? set_special_var (v) : v;
 …
 /* Parse P (a null-terminated string) as a variable definition.
+   If it is not a variable definition, return NULL.
+   If it is not a variable definition, return NULL and the contents of *VAR
+   are undefined, except NAME is set to the first non-space character or NIL.
    If it is a variable definition, return a pointer to the char after the
+   assignment token and set *FLAVOR to the type of variable assignment.  */
+   assignment token and set the following fields (only) of *VAR:
+    name   : name of the variable (ALWAYS SET) (NOT NUL-TERMINATED!)
+    length : length of the variable name
+    value  : value of the variable (nul-terminated)
+    flavor : flavor of the variable
+   Other values in *VAR are unchanged.
+  */
 char *
 parse_variable_definition (const char *p, enum variable_flavor *flavor)
+parse_variable_definition (const char *p, struct variable *var)
+{
   int wspace = 0;
+  p = next_token (p);
+  const char *e = NULL;
+  NEXT_TOKEN (p);
+  var->name = (char *)p;
+  var->length = 0;
   while (1)
 …
       /* If we find a comment or EOS, it's not a variable definition.  */
       if (c == '\0' || c == '#')
         return NULL;
+      if (STOP_SET (c, MAP_COMMENT|MAP_NUL))
+        return NULL;
       if (c == '$')
+        {
+          /* This begins a variable expansion reference.  Make sure we don't
+             treat chars inside the reference as assignment tokens.  */
+          char closeparen;
+          int count;
+          c = *p++;
+          if (c == '(')
+            closeparen = ')';
+          else if (c == '{')
+            closeparen = '}';
+          else
+        {
+          /* This begins a variable expansion reference.  Make sure we don't
+             treat chars inside the reference as assignment tokens.  */
+          char closeparen;
+          unsigned int count;
+          c = *p++;
+          if (c == '(')
+            closeparen = ')';
+          else if (c == '{')
+            closeparen = '}';
+          else if (c == '\0')
+            return NULL;
+          else
             /* '$$' or '$X'.  Either way, nothing special to do here.  */
+            continue;
+          /* P now points past the opening paren or brace.
+             Count parens or braces until it is matched.  */
+          count = 0;
+          for (; *p != '\0'; ++p)
+            {
+              if (*p == c)
+                ++count;
+              else if (*p == closeparen && --count < 0)
+                {
+                  ++p;
+                  break;
+                }
+            }
+            continue;
+          /* P now points past the opening paren or brace.
+             Count parens or braces until it is matched.  */
+          for (count = 1; *p != '\0'; ++p)
+            {
+              if (*p == closeparen && --count == 0)
+                {
+                  ++p;
+                  break;
+                }
+              if (*p == c)
+                ++count;
+            }
           continue;
+        }
+        }
       /* If we find whitespace skip it, and remember we found it.  */
       if (isblank ((unsigned char)c))
+      if (ISBLANK (c))
+        {
           wspace = 1;
+          p = next_token (p);
+          e = p - 1;
+          NEXT_TOKEN (p);
           c = *p;
           if (c == '\0')
 …
       if (c == '=')
+        {
+          *flavor = f_recursive;
+          return (char *)p;
+        }
+      /* Match assignment variants (:=, +=, ?=)  */
+        {
+          var->flavor = f_recursive;
+          if (! e)
+            e = p - 1;
+          break;
+        }
+      /* Match assignment variants (:=, +=, ?=, !=)  */
       if (*p == '=')
+        {
 …
+            {
               case ':':
                 *flavor = f_simple;
+                var->flavor = f_simple;
                 break;
               case '+':
                 *flavor = f_append;
+                var->flavor = f_append;
                 break;
               case '?':
+                *flavor = f_conditional;
+                var->flavor = f_conditional;
+                break;
+              case '!':
+                var->flavor = f_shell;
                 break;
               default:
 …
                 continue;
+            }
+          return (char *)++p;
+          if (! e)
+            e = p - 1;
+          ++p;
+          break;
+        }
+      else if (c == ':')
+        /* A colon other than := is a rule line, not a variable defn.  */
+        return NULL;
+      /* Check for POSIX ::= syntax  */
+      if (c == ':')
+        {
+          /* A colon other than :=/::= is not a variable defn.  */
+          if (*p != ':' || p[1] != '=')
+            return NULL;
+          /* POSIX allows ::= to be the same as GNU make's := */
+          var->flavor = f_simple;
+          if (! e)
+            e = p - 1;
+          p += 2;
+          break;
+        }
       /* If we skipped whitespace, non-assignments means no var.  */
 …
+    }
+  var->length = e - var->name;
+  var->value = next_token (p);
   return (char *)p;
+}
 …
 /* Try to interpret LINE (a null-terminated string) as a variable definition.
    If LINE was recognized as a variable definition, a pointer to its `struct
+   If LINE was recognized as a variable definition, a pointer to its 'struct
    variable' is returned.  If LINE is not a variable definition, NULL is
    returned.  */
 struct variable *
+assign_variable_definition (struct variable *v, char *line)
+{
+  char *beg;
+  char *end;
+  enum variable_flavor flavor;
+assign_variable_definition (struct variable *v, const char *line)
+{
   char *name;
+  beg = next_token (line);
+  line = parse_variable_definition (beg, &flavor);
+  if (!line)
+  if (!parse_variable_definition (line, v))
     return NULL;
-  end = line - (flavor == f_recursive ? 1 : 2);
-  while (end > beg && isblank ((unsigned char)end[-1]))
-    --end;
-  line = next_token (line);
-  v->value = line;
-  v->flavor = flavor;
   /* Expand the name, so "$(foo)bar = baz" works.  */
   name = alloca (end - beg + 1);
   memcpy (name, beg, end - beg);
   name[end - beg] = '\0';
+  name = alloca (v->length + 1);
+  memcpy (name, v->name, v->length);
+  name[v->length] = '\0';
   v->name = allocated_variable_expand (name);
   if (v->name[0] == '\0')
     fatal (&v->fileinfo, _("empty variable name"));
+    O (fatal, &v->fileinfo, _("empty variable name"));
   return v;
 …
    See the comments for assign_variable_definition().
    If LINE was recognized as a variable definition, a pointer to its `struct
+   If LINE was recognized as a variable definition, a pointer to its 'struct
    variable' is returned.  If LINE is not a variable definition, NULL is
    returned.  */
 struct variable *
 try_variable_definition (const struct floc *flocp, char *line,
+try_variable_definition (const floc *flocp, const char *line,
                          enum variable_origin origin, int target_var)
+{
 …
   switch (v->origin)
+    {
+    case o_automatic:
+      origin = _("automatic");
+      break;
     case o_default:
       origin = _("default");
 …
       break;
     case o_override:
+      origin = _("`override' directive");
+      break;
+    case o_automatic:
+      origin = _("automatic");
+      origin = _("'override' directive");
       break;
     case o_invalid:
 …
     fputs (" private", stdout);
   if (v->fileinfo.filenm)
     printf (_(" (from `%s', line %lu)"),
             v->fileinfo.filenm, v->fileinfo.lineno);
+    printf (_(" (from '%s', line %lu)"),
+            v->fileinfo.filenm, v->fileinfo.lineno + v->fileinfo.offset);
   putchar ('\n');
   fputs (prefix, stdout);
   /* Is this a `define'?  */
+  /* Is this a 'define'?  */
   if (v->recursive && strchr (v->value, '\n') != 0)
     printf ("define %s\n%s\nendef\n", v->name, v->value);
 …
       p = next_token (v->value);
       if (p != v->value && *p == '\0')
         /* All whitespace.  */
         printf ("$(subst ,,%s)", v->value);
+        /* All whitespace.  */
+        printf ("$(subst ,,%s)", v->value);
       else if (v->recursive)
         fputs (v->value, stdout);
+        fputs (v->value, stdout);
       else
         /* Double up dollar signs.  */
         for (p = v->value; *p != '\0'; ++p)
+          {
             if (*p == '$')
               putchar ('$');
             putchar (*p);
+          }
+        /* Double up dollar signs.  */
+        for (p = v->value; *p != '\0'; ++p)
+          {
+            if (*p == '$')
+              putchar ('$');
+            putchar (*p);
+          }
       putchar ('\n');
+    }
+}
+static void
+print_auto_variable (const void *item, void *arg)
+{
+  const struct variable *v = item;
+  if (v->origin == o_automatic)
+    print_variable (item, arg);
+}
+static void
+print_noauto_variable (const void *item, void *arg)
+{
+  const struct variable *v = item;
+  if (v->origin != o_automatic)
+    print_variable (item, arg);
+}
 …
    the actual variable definitions (everything else is comments).  */
+void
+print_variable_set (struct variable_set *set, char *prefix)
+{
+  hash_map_arg (&set->table, print_variable, prefix);
+static void
+print_variable_set (struct variable_set *set, const char *prefix, int pauto)
+{
+  hash_map_arg (&set->table, (pauto ? print_auto_variable : print_variable),
+                (void *)prefix);
   fputs (_("# variable set hash-table stats:\n"), stdout);
 …
   puts (_("\n# Variables\n"));
   print_variable_set (&global_variable_set, "");
+  print_variable_set (&global_variable_set, "", 0);
   puts (_("\n# Pattern-specific Variable Values"));
 …
+  {
     struct pattern_var *p;
     int rules = 0;
+    unsigned int rules = 0;
     for (p = pattern_vars; p != 0; p = p->next)
 …
         ++rules;
         printf ("\n%s :\n", p->target);
         print_variable (&p->variable, "# ");
+        print_variable (&p->variable, (void *)"# ");
+      }
 …
+{
   if (file->variables != 0)
+    print_variable_set (file->variables->set, "# ");
+    print_variable_set (file->variables->set, "# ", 1);
+}
+void
+print_target_variables (const struct file *file)
+{
+  if (file->variables != 0)
+    {
+      int l = strlen (file->name);
+      char *t = alloca (l + 3);
+      strcpy (t, file->name);
+      t[l] = ':';
+      t[l+1] = ' ';
+      t[l+2] = '\0';
+      hash_map_arg (&file->variables->set->table, print_noauto_variable, t);
+    }
+}
 …
     return;
+  /*
+   * If done this before, don't leak memory unnecessarily.
+   * Free the previous entry before allocating new one.
+   */
+  if (environ_path)
+    free (environ_path);
+  /*
+   * Create something WINDOWS32 world can grok
+   */
+  /* If done this before, free the previous entry before allocating new one.  */
+  free (environ_path);
+  /* Create something WINDOWS32 world can grok.  */
   convert_Path_to_windows32 (path, ';');
   environ_path = xstrdup (concat (3, "PATH", "=", path));

vendor/gnumake/current/variable.h

-              r2596
+              r3138
 /* Definitions for using variables in GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 enum variable_origin
+  {
     o_default,          /* Variable from the default set.  */
     o_env,              /* Variable from environment.  */
     o_file,             /* Variable given in a makefile.  */
     o_env_override,     /* Variable from environment, if -e.  */
     o_command,          /* Variable given by user.  */
     o_override,         /* Variable from an `override' directive.  */
     o_automatic,        /* Automatic variable -- cannot be set.  */
     o_invalid           /* Core dump time.  */
+    o_default,          /* Variable from the default set.  */
+    o_env,              /* Variable from environment.  */
+    o_file,             /* Variable given in a makefile.  */
+    o_env_override,     /* Variable from environment, if -e.  */
+    o_command,          /* Variable given by user.  */
+    o_override,         /* Variable from an 'override' directive.  */
+    o_automatic,        /* Automatic variable -- cannot be set.  */
+    o_invalid           /* Core dump time.  */
   };
 …
+  {
     f_bogus,            /* Bogus (error) */
     f_simple,           /* Simple definition (:=) */
+    f_simple,           /* Simple definition (:= or ::=) */
     f_recursive,        /* Recursive definition (=) */
     f_append,           /* Appending definition (+=) */
+    f_conditional       /* Conditional definition (?=) */
+    f_conditional,      /* Conditional definition (?=) */
+    f_shell             /* Shell assignment (!=) */
   };
 /* Structure that represents one variable definition.
    Each bucket of the hash table is a chain of these,
    chained through `next'.  */
+   chained through 'next'.  */
 #define EXP_COUNT_BITS  15      /* This gets all the bitfields into 32 bits */
 …
 struct variable
+  {
     char *name;                 /* Variable name.  */
     int length;                 /* strlen (name) */
     char *value;                /* Variable value.  */
     struct floc fileinfo;       /* Where the variable was defined.  */
     unsigned int recursive:1;   /* Gets recursively re-evaluated.  */
     unsigned int append:1;      /* Nonzero if an appending target-specific
+    char *name;                 /* Variable name.  */
+    char *value;                /* Variable value.  */
+    floc fileinfo;              /* Where the variable was defined.  */
+    int length;                 /* strlen (name) */
+    unsigned int recursive:1;   /* Gets recursively re-evaluated.  */
+    unsigned int append:1;      /* Nonzero if an appending target-specific
                                    variable.  */
     unsigned int conditional:1; /* Nonzero if set with a ?=. */
     unsigned int per_target:1;  /* Nonzero if a target-specific variable.  */
+    unsigned int per_target:1;  /* Nonzero if a target-specific variable.  */
     unsigned int special:1;     /* Nonzero if this is a special variable.  */
     unsigned int exportable:1;  /* Nonzero if the variable _could_ be
                                    exported.  */
     unsigned int expanding:1;   /* Nonzero if currently being expanded.  */
+    unsigned int expanding:1;   /* Nonzero if currently being expanded.  */
     unsigned int private_var:1; /* Nonzero avoids inheritance of this
                                    target-specific variable.  */
 …
                                    expansions.  */
     enum variable_flavor
       flavor ENUM_BITFIELD (3); /* Variable flavor.  */
+      flavor ENUM_BITFIELD (3); /* Variable flavor.  */
     enum variable_origin
       origin ENUM_BITFIELD (3); /* Variable origin.  */
+      origin ENUM_BITFIELD (3); /* Variable origin.  */
     enum variable_export
+      {
         v_export,               /* Export this variable.  */
         v_noexport,             /* Don't export this variable.  */
         v_ifset,                /* Export it if it has a non-default value.  */
         v_default               /* Decide in target_environment.  */
+        v_export,               /* Export this variable.  */
+        v_noexport,             /* Don't export this variable.  */
+        v_ifset,                /* Export it if it has a non-default value.  */
+        v_default               /* Decide in target_environment.  */
       } export ENUM_BITFIELD (2);
   };
 …
 struct variable_set
+  {
     struct hash_table table;    /* Hash table of variables.  */
+    struct hash_table table;    /* Hash table of variables.  */
   };
 …
 struct variable_set_list
+  {
     struct variable_set_list *next;     /* Link in the chain.  */
     struct variable_set *set;           /* Variable set.  */
+    struct variable_set_list *next;     /* Link in the chain.  */
+    struct variable_set *set;           /* Variable set.  */
     int next_is_parent;                 /* True if next is a parent target.  */
   };
 …
 extern struct variable_set_list *current_variable_set_list;
 extern struct variable *default_goal_var;
+extern struct variable shell_var;
 /* expand.c */
 …
 char *variable_expand_for_file (const char *line, struct file *file);
 char *allocated_variable_expand_for_file (const char *line, struct file *file);
 #define allocated_variable_expand(line) \
+#define allocated_variable_expand(line) \
   allocated_variable_expand_for_file (line, (struct file *) 0)
 char *expand_argument (const char *str, const char *end);
 …
                            const char *replace_percent);
 char *patsubst_expand (char *o, const char *text, char *pattern, char *replace);
+char *func_shell_base (char *o, char **argv, int trim_newlines);
+void shell_completed (int exit_code, int exit_sig);
 /* expand.c */
 …
 void initialize_file_variables (struct file *file, int reading);
 void print_file_variables (const struct file *file);
 void print_variable_set (struct variable_set *set, char *prefix);
+void print_target_variables (const struct file *file);
 void merge_variable_set_lists (struct variable_set_list **to_list,
                                struct variable_set_list *from_list);
 struct variable *do_variable_definition (const struct floc *flocp,
+struct variable *do_variable_definition (const floc *flocp,
                                          const char *name, const char *value,
                                          enum variable_origin origin,
 …
                                          int target_var);
 char *parse_variable_definition (const char *line,
                                  enum variable_flavor *flavor);
 struct variable *assign_variable_definition (struct variable *v, char *line);
 struct variable *try_variable_definition (const struct floc *flocp, char *line,
+                                 struct variable *v);
+struct variable *assign_variable_definition (struct variable *v, const char *line);
+struct variable *try_variable_definition (const floc *flocp, const char *line,
                                           enum variable_origin origin,
                                           int target_var);
 void init_hash_global_variable_set (void);
 void hash_init_function_table (void);
+void define_new_function(const floc *flocp, const char *name,
+                         unsigned int min, unsigned int max, unsigned int flags,
+                         gmk_func_ptr func);
 struct variable *lookup_variable (const char *name, unsigned int length);
 struct variable *lookup_variable_in_set (const char *name, unsigned int length,
 …
                                          int recursive,
                                          struct variable_set *set,
                                          const struct floc *flocp);
+                                         const floc *flocp);
 /* Define a variable in the current variable set.  */
 …
 #define warn_undefined(n,l) do{\
                               if (warn_undefined_variables_flag) \
                                 error (reading_file, \
                                        _("warning: undefined variable `%.*s'"), \
                                 (int)(l), (n)); \
+                              if (warn_undefined_variables_flag)        \
+                                error (reading_file, (l),               \
+                                       _("warning: undefined variable '%.*s'"), \
+                                       (int)(l), (n));                  \
                               }while(0)
 …
 #define MAKELEVEL_NAME "MAKELEVEL"
 #define MAKELEVEL_LENGTH (sizeof (MAKELEVEL_NAME) - 1)
+#define MAKELEVEL_LENGTH (CSTRLEN (MAKELEVEL_NAME))

vendor/gnumake/current/version.c

-              r2596
+              r3138
 /* Record version and build host architecture for GNU make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 /* We use <config.h> instead of "config.h" so that a compilation
    using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h
    (which it would do because make.h was found in $srcdir).  */
+   (which it would do because makeint.h was found in $srcdir).  */
 #include <config.h>
 …
 #endif
 char *version_string = VERSION;
 char *make_host = MAKE_HOST;
+const char *version_string = VERSION;
+const char *make_host = MAKE_HOST;

vendor/gnumake/current/vmsdir.h

-              r2596
+              r3138
 /* dirent.h for vms
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
     + 3) & ~3)
 #define d_ino   d_fileno                /* compatability */
+#define d_ino   d_fileno                /* compatibility */

vendor/gnumake/current/vmsfunctions.c

-              r2596
+              r3138
 /* VMS functions
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include "debug.h"
 #include "job.h"
+#include <ctype.h>
+#include <string.h>
 #ifdef __DECC
 #include <starlet.h>
 #endif
+#include <descrip.h>
 #include <rms.h>
-#include <iodef.h>
-#include <atrdef.h>
-#include <fibdef.h>
 #include "vmsdir.h"
 …
       struct NAM *dnam = (struct NAM *)(dfab->fab$l_nam);
       if (dnam != NULL)
         free (dnam->nam$l_esa);
+        free (dnam->nam$l_esa);
       free (dnam);
       free (dir);
 …
 #endif /* compiled for OpenVMS prior to V7.x */
+char *
+getwd (char *cwd)
+{
+  static char buf[512];
+  if (cwd)
+    return (getcwd (cwd, 512));
+  else
+    return (getcwd (buf, 512));
+}
+#if 0
+/*
+ * Is this used? I don't see any reference, so I suggest to remove it.
+ */
+int
+vms_stat (char *name, struct stat *buf)
+/* Argv0 will be a full vms file specification, like
+   node$dka100:[utils.gnumake]make.exe;47
+   prefix it with "mcr " to make it a vms command, executable for DCL. */
+const char *
+vms_command(const char* argv0)
+{
+  size_t l = strlen(argv0) + 1;
+  char* s = xmalloc(l + 4);
+  memcpy(s, "mcr ", 4);
+  memcpy(s+4, argv0, l);
+  return s;
+}
+/* Argv0 aka argv[0] will be a full vms file specification, like
+   node$dka100:[utils.gnumake]make.exe;47, set up by the CRTL.
+   The vms progname should be ^^^^, the file name without
+   file type .exe and ;version.
+   Use sys$parse to get the name part of the file specification. That is
+   in the above example, pick up "make" and return a copy of that string.
+   If something goes wrong in sys$parse (unlikely, this is a VMS/CRTL supplied
+   file specification) or if there is an empty name part (not easy to produce,
+   but it is possible) just return "make".
+   Somes notes ...
+   NAM[L]$M_SYNCHK requests a syntax check, only.
+   NAM is for ODS2 names (shorter parts, output usually converted to UPPERCASE).
+   NAML is for ODS2/ODS5 names (longer parts, output unchanged).
+   NAM$M_NO_SHORT_UPCASE may not be available for older versions of VMS.
+   NAML is not available on older versions of VMS (NAML$C_BID not defined).
+   argv[0] on older versions of VMS (no extended parse style and no
+   CRTL feature DECC$ARGV_PARSE_STYLE) is always in lowercase. */
+const char *
+vms_progname(const char* argv0)
+{
   int status;
+  int i;
+  static struct FAB Fab;
+  static struct NAM Nam;
+  static struct fibdef Fib;     /* short fib */
+  static struct dsc$descriptor FibDesc =
+  { sizeof (Fib), DSC$K_DTYPE_Z, DSC$K_CLASS_S, (char *) &Fib };
+  static struct dsc$descriptor_s DevDesc =
+  { 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, &Nam.nam$t_dvi[1] };
+  static char EName[NAM$C_MAXRSS];
+  static char RName[NAM$C_MAXRSS];
+  static struct dsc$descriptor_s FileName =
+  { 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, 0 };
+  static struct dsc$descriptor_s string =
+  { 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, 0 };
+  static unsigned long Rdate[2];
+  static unsigned long Cdate[2];
+  static struct atrdef Atr[] =
+  {
+#if defined(VAX)
+    /* Revision date */
+    { sizeof (Rdate), ATR$C_REVDATE, (unsigned int) &Rdate[0] },
+    /* Creation date */
+    { sizeof (Cdate), ATR$C_CREDATE, (unsigned int) &Cdate[0] },
+  static struct FAB fab;
+  char *progname;
+  const char *fallback = "make";
+#ifdef NAML$C_BID
+  static char esa[NAML$C_MAXRSS];
+  static struct NAML naml;
 #else
+    /* Revision date */
+    { sizeof (Rdate), ATR$C_REVDATE, &Rdate[0] },
+    /* Creation date */
+    { sizeof (Cdate), ATR$C_CREDATE, &Cdate[0]},
+#endif
+    { 0, 0, 0 }
+  };
+  static short int DevChan;
+  static short int iosb[4];
+  name = vmsify (name, 0);
+  /* initialize RMS structures, we need a NAM to retrieve the FID */
+  Fab = cc$rms_fab;
+  Fab.fab$l_fna = name;         /* name of file */
+  Fab.fab$b_fns = strlen (name);
+  Fab.fab$l_nam = &Nam;         /* FAB has an associated NAM */
+  Nam = cc$rms_nam;
+  Nam.nam$l_esa = EName;        /* expanded filename */
+  Nam.nam$b_ess = sizeof (EName);
+  Nam.nam$l_rsa = RName;        /* resultant filename */
+  Nam.nam$b_rss = sizeof (RName);
+  /* do $PARSE and $SEARCH here */
+  status = sys$parse (&Fab);
+  static char esa[NAM$C_MAXRSS];
+  static struct NAM nam;
+#endif
+  fab = cc$rms_fab;
+  fab.fab$l_fna = (char*)argv0;
+  fab.fab$b_fns = strlen(argv0);
+#ifdef NAML$C_BID
+  fab.fab$l_naml = &naml;
+  naml = cc$rms_naml;
+  naml.naml$l_long_expand = esa;
+  naml.naml$l_long_expand_alloc = NAML$C_MAXRSS;
+  naml.naml$b_nop = NAML$M_SYNCHK;
+  naml.naml$l_input_flags = NAML$M_NO_SHORT_OUTPUT;
+#else
+  fab.fab$l_nam = &nam;
+  nam = cc$rms_nam;
+  nam.nam$l_esa = esa;
+  nam.nam$b_ess = NAM$C_MAXRSS;
+# ifdef NAM$M_NO_SHORT_UPCASE
+  nam.nam$b_nop = NAM$M_SYNCHK | NAM$M_NO_SHORT_UPCASE;
+# else
+  nam.nam$b_nop = NAM$M_SYNCHK;
+# endif
+#endif
+  status = sys$parse(&fab);
   if (!(status & 1))
+    return -1;
+  DevDesc.dsc$w_length = Nam.nam$t_dvi[0];
+  status = sys$assign (&DevDesc, &DevChan, 0, 0);
+  if (!(status & 1))
+    return -1;
+  FileName.dsc$a_pointer = Nam.nam$l_name;
+  FileName.dsc$w_length = Nam.nam$b_name + Nam.nam$b_type + Nam.nam$b_ver;
+  /* Initialize the FIB */
+  for (i = 0; i < 3; i++)
+    {
+#ifndef __VAXC
+      Fib.fib$w_fid[i] = Nam.nam$w_fid[i];
+      Fib.fib$w_did[i] = Nam.nam$w_did[i];
+    return fallback;
+#ifdef NAML$C_BID
+  if (naml.naml$l_long_name_size == 0)
+    return fallback;
+  progname = xmalloc(naml.naml$l_long_name_size + 1);
+  memcpy(progname, naml.naml$l_long_name, naml.naml$l_long_name_size);
+  progname[naml.naml$l_long_name_size] = '\0';
 #else
+      Fib.fib$r_fid_overlay.fib$w_fid[i] = Nam.nam$w_fid[i];
+      Fib.fib$r_did_overlay.fib$w_did[i] = Nam.nam$w_did[i];
+#endif
+    }
+  status = sys$qiow (0, DevChan, IO$_ACCESS, &iosb, 0, 0,
+                     &FibDesc, &FileName, 0, 0, &Atr, 0);
+  sys$dassgn (DevChan);
+  if (!(status & 1))
+    return -1;
+  status = iosb[0];
+  if (!(status & 1))
+    return -1;
+  status = stat (name, buf);
+  if (status)
+    return -1;
+  buf->st_mtime = ((Rdate[0] >> 24) & 0xff) + ((Rdate[1] << 8) & 0xffffff00);
+  buf->st_ctime = ((Cdate[0] >> 24) & 0xff) + ((Cdate[1] << 8) & 0xffffff00);
+  return 0;
+}
+#endif
+char *
+cvt_time (unsigned long tval)
+{
+  static long int date[2];
+  static char str[27];
+  static struct dsc$descriptor date_str =
+  { 26, DSC$K_DTYPE_T, DSC$K_CLASS_S, str };
+  date[0] = (tval & 0xff) << 24;
+  date[1] = ((tval >> 8) & 0xffffff);
+  if ((date[0] == 0) && (date[1] == 0))
+    return ("never");
+  sys$asctim (0, &date_str, date, 0);
+  str[26] = '\0';
+  return (str);
+}
+  if (nam.nam$b_name == 0)
+    return fallback;
+  progname = xmalloc(nam.nam$b_name + 1);
+# ifdef NAM$M_NO_SHORT_UPCASE
+  memcpy(progname, nam.nam$l_name, nam.nam$b_name);
+# else
+    {
+      int i;
+      for (i = 0; i < nam.nam$b_name; i++)
+        progname[i] = tolower(nam.nam$l_name[i]);
+    }
+# endif
+  progname[nam.nam$b_name] = '\0';
+#endif
+  return progname;
+}

vendor/gnumake/current/vmsify.c

-              r2596
+              r3138
 /* vmsify.c -- Module for vms <-> unix file name conversion
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 #include <string.h>
 #include <ctype.h>
+#include "makeint.h"
 #if VMS
 …
   reslt[resltlen] = '\0';
+  s = malloc (resltlen+1);
+  if (s == 0)
+    return "";
+  s = xmalloc (resltlen+1);
   strcpy (s, reslt);
   return s;
 …
    max 5 version
 */
+#define MAXPATHLEN 512
+/* todo: VMSMAXPATHLEN is defined for ODS2 names: it needs to be adjusted. */
+#define VMSMAXPATHLEN 512
   enum namestate nstate;
   static char vmsname[MAXPATHLEN+1];
+  static char vmsname[VMSMAXPATHLEN+1];
   const char *fptr;
   const char *t;
 …
             if (*fptr == 0)             /* just // */
+              {
                 char cwdbuf[MAXPATHLEN+1];
                 s1 = getcwd(cwdbuf, MAXPATHLEN);
+                char cwdbuf[VMSMAXPATHLEN+1];
+                s1 = getcwd(cwdbuf, VMSMAXPATHLEN);
                 if (s1 == 0)
+                  {
 …
             {                                   /* got '..' or '../' */
               char *vp;
               char cwdbuf[MAXPATHLEN+1];
               vp = getcwd(cwdbuf, MAXPATHLEN);
+              char cwdbuf[VMSMAXPATHLEN+1];
+              vp = getcwd(cwdbuf, VMSMAXPATHLEN);
               if (vp == 0)
+                {
 …
+            {
               char *vp;
               char cwdbuf[MAXPATHLEN+1];
               vp = getcwd(cwdbuf, MAXPATHLEN);
+              char cwdbuf[VMSMAXPATHLEN+1];
+              vp = getcwd(cwdbuf, VMSMAXPATHLEN);
               if (vp == 0)
+                {

vendor/gnumake/current/vmsjobs.c

-              r2596
+              r3138
    This file must be #included in job.c, as it accesses static functions.
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 #include <clidef.h>
+/* TODO - VMS specific header file conditionally included in makeint.h */
+#include <stsdef.h>
+#include <ssdef.h>
+void
+decc$exit (int status);
+/* Lowest legal non-success VMS exit code is 8 */
+/* GNU make only defines codes 0, 1, 2 */
+/* So assume any exit code > 8 is a VMS exit code */
+#ifndef MAX_EXPECTED_EXIT_CODE
+# define MAX_EXPECTED_EXIT_CODE 7
+#endif
+#if __CRTL_VER >= 70302000 && !defined(__VAX)
+# define MAX_DCL_LINE_LENGTH 4095
+# define MAX_DCL_CMD_LINE_LENGTH 8192
+#else
+# define MAX_DCL_LINE_LENGTH 255
+# define MAX_DCL_CMD_LINE_LENGTH 1024
+#endif
+#define MAX_DCL_TOKEN_LENGTH 255
+#define MAX_DCL_TOKENS 127
+enum auto_pipe { nopipe, add_pipe, dcl_pipe };
 char *vmsify (char *name, int type);
 static int vms_jobsefnmask = 0;
+/* returns whether path is assumed to be a unix like shell. */
+int
+_is_unixy_shell (const char *path)
+{
+  return vms_gnv_shell;
+}
+#define VMS_GETMSG_MAX 256
+static char vms_strsignal_text[VMS_GETMSG_MAX + 2];
+char *
+vms_strsignal (int status)
+{
+  if (status <= MAX_EXPECTED_EXIT_CODE)
+    sprintf (vms_strsignal_text, "lib$spawn returned %x", status);
+  else
+    {
+      int vms_status;
+      unsigned short * msg_len;
+      unsigned char out[4];
+      vms_status = SYS$GETMSG (status, &msg_len,
+                               vms_strsignal_text, 7, *out);
+    }
+  return vms_strsignal_text;
+}
 /* Wait for nchildren children to terminate */
 static void
 vmsWaitForChildren(int *status)
+vmsWaitForChildren (int *status)
+{
   while (1)
+    {
       if (!vms_jobsefnmask)
+        {
           *status = 0;
           return;
+        }
+        {
+          *status = 0;
+          return;
+        }
       *status = sys$wflor (32, vms_jobsefnmask);
+    }
   return;
+}
-/* Set up IO redirection.  */
-char *
-vms_redirect (struct dsc$descriptor_s *desc, char *fname, char *ibuf)
+{
-  char *fptr;
-  ibuf++;
-  while (isspace ((unsigned char)*ibuf))
-    ibuf++;
-  fptr = ibuf;
-  while (*ibuf && !isspace ((unsigned char)*ibuf))
-    ibuf++;
-  *ibuf = 0;
-  if (strcmp (fptr, "/dev/null") != 0)
+    {
-      strcpy (fname, vmsify (fptr, 0));
-      if (strchr (fname, '.') == 0)
-        strcat (fname, ".");
+    }
-  desc->dsc$w_length = strlen(fname);
-  desc->dsc$a_pointer = fname;
-  desc->dsc$b_dtype = DSC$K_DTYPE_T;
-  desc->dsc$b_class = DSC$K_CLASS_S;
-  if (*fname == 0)
-    printf (_("Warning: Empty redirection\n"));
-  return ibuf;
+}
-/* found apostrophe at (p-1)
-   inc p until after closing apostrophe.
- */
-char *
-vms_handle_apos (char *p)
+{
-  int alast;
-#define SEPCHARS ",/()= "
-  alast = 0;
-  while (*p != 0)
+    {
-      if (*p == '"')
+        {
-          if (alast)
+            {
-              alast = 0;
-              p++;
+            }
-          else
+            {
-              p++;
-              if (strchr (SEPCHARS, *p))
-                break;
-              alast = 1;
+            }
+        }
-      else
-        p++;
+    }
-  return p;
+}
 …
    inner mode level AST.
 */
 int
 vmsHandleChildTerm(struct child *child)
+static int
+vmsHandleChildTerm (struct child *child)
+{
+    int status;
+    register struct child *lastc, *c;
+    int child_failed;
+  int exit_code;
+  register struct child *lastc, *c;
+  int child_failed;
+  /* The child efn is 0 when a built-in or null command is executed
+     successfully with out actually creating a child.
+  */
+  if (child->efn > 0)
+  {
     vms_jobsefnmask &= ~(1 << (child->efn - 32));
+    lib$free_ef(&child->efn);
+    if (child->comname)
+      {
+        if (!ISDB (DB_JOBS)&&!ctrlYPressed)
+          unlink (child->comname);
+        free (child->comname);
+      }
+    (void) sigblock (fatal_signal_mask);
+    child_failed = !(child->cstatus & 1 || ((child->cstatus & 7) == 0));
+    /* Search for a child matching the deceased one.  */
+    lastc = 0;
+#if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */
+    for (c = children; c != 0 && c != child; lastc = c, c = c->next)
+      ;
+    lib$free_ef (&child->efn);
+  }
+  if (child->comname)
+    {
+      if (!ISDB (DB_JOBS) && !ctrlYPressed)
+        unlink (child->comname);
+      free (child->comname);
+    }
+  (void) sigblock (fatal_signal_mask);
+  /* First check to see if this is a POSIX exit status and handle */
+  if ((child->cstatus & VMS_POSIX_EXIT_MASK) == VMS_POSIX_EXIT_MASK)
+    {
+      exit_code = (child->cstatus >> 3) & 255;
+      if (exit_code != MAKE_SUCCESS)
+        child_failed = 1;
+    }
+  else
+    {
+      child_failed = !$VMS_STATUS_SUCCESS (child->cstatus);
+      if (child_failed)
+        exit_code = child->cstatus;
+    }
+  /* Search for a child matching the deceased one.  */
+  lastc = 0;
+#if defined(RECURSIVEJOBS)
+  /* I've had problems with recursive stuff and process handling */
+  for (c = children; c != 0 && c != child; lastc = c, c = c->next)
+    ;
 #else
     c = child;
+  c = child;
 #endif
+    if (child_failed && !c->noerror && !ignore_errors_flag)
+      {
+        /* The commands failed.  Write an error message,
+           delete non-precious targets, and abort.  */
+        child_error (c->file->name, c->cstatus, 0, 0, 0);
+        c->file->update_status = 1;
+        delete_child_targets (c);
+      }
+    else
+      {
+        if (child_failed)
+          {
+            /* The commands failed, but we don't care.  */
+            child_error (c->file->name, c->cstatus, 0, 0, 1);
+            child_failed = 0;
+          }
+#if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */
+        /* If there are more commands to run, try to start them.  */
+        start_job (c);
+        switch (c->file->command_state)
+          {
+          case cs_running:
+            /* Successfully started.  */
+            break;
+          case cs_finished:
+            if (c->file->update_status != 0) {
+                /* We failed to start the commands.  */
+                delete_child_targets (c);
+            }
+            break;
+          default:
+            error (NILF, _("internal error: `%s' command_state"),
+                   c->file->name);
+            abort ();
+            break;
+          }
+#endif /* RECURSIVEJOBS */
+      }
+    /* Set the state flag to say the commands have finished.  */
+    c->file->command_state = cs_finished;
+    notice_finished_file (c->file);
+#if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */
+    /* Remove the child from the chain and free it.  */
+    if (lastc == 0)
+      children = c->next;
+    else
+      lastc->next = c->next;
+    free_child (c);
+#endif /* RECURSIVEJOBS */
+    /* There is now another slot open.  */
+    if (job_slots_used > 0)
+      --job_slots_used;
+    /* If the job failed, and the -k flag was not given, die.  */
+    if (child_failed && !keep_going_flag)
+      die (EXIT_FAILURE);
+    (void) sigsetmask (sigblock (0) & ~(fatal_signal_mask));
+    return 1;
+  if ($VMS_STATUS_SUCCESS (child->vms_launch_status))
+    {
+      /* Convert VMS success status to 0 for UNIX code to be happy */
+      child->vms_launch_status = 0;
+    }
+  /* Set the state flag to say the commands have finished.  */
+  c->file->command_state = cs_finished;
+  notice_finished_file (c->file);
+  (void) sigsetmask (sigblock (0) & ~(fatal_signal_mask));
+  return 1;
+}
 /* VMS:
    Spawn a process executing the command in ARGV and return its pid. */
-#define MAXCMDLEN 200
 /* local helpers to make ctrl+c and ctrl+y working, see below */
 …
 reEnableAst(void)
+{
         lib$enable_ctrl (&oldCtrlMask,0);
+  lib$enable_ctrl (&oldCtrlMask,0);
+}
 …
 astYHandler (void)
+{
         struct child *c;
         for (c = children; c != 0; c = c->next)
                 sys$delprc (&c->pid, 0, 0);
         ctrlYPressed= 1;
         kill (getpid(),SIGQUIT);
         return SS$_NORMAL;
+  struct child *c;
+  for (c = children; c != 0; c = c->next)
+    sys$delprc (&c->pid, 0, 0);
+  ctrlYPressed= 1;
+  kill (getpid(),SIGQUIT);
+  return SS$_NORMAL;
+}
 …
 tryToSetupYAst(void)
+{
+        $DESCRIPTOR(inputDsc,"SYS$COMMAND");
+        int     status;
+        struct {
+                short int       status, count;
+                int     dvi;
+        } iosb;
+        unsigned short int loc_chan;
+        setupYAstTried++;
+        if (chan)
+          loc_chan= chan;
+        else {
+                status= sys$assign(&inputDsc,&loc_chan,0,0);
+                if (!(status&SS$_NORMAL)) {
+                        lib$signal(status);
+                        return;
+                }
+        }
+        status= sys$qiow (0, loc_chan, IO$_SETMODE|IO$M_CTRLYAST,&iosb,0,0,
+                          astYHandler,0,0,0,0,0);
+        if (status==SS$_NORMAL)
+                status= iosb.status;
+        if (status!=SS$_NORMAL) {
+                if (!chan)
+                        sys$dassgn(loc_chan);
+                if (status!=SS$_ILLIOFUNC && status!=SS$_NOPRIV)
+                        lib$signal(status);
+                return;
+        }
+        /* called from AST handler ? */
+        if (setupYAstTried>1)
+                return;
+        if (atexit(reEnableAst))
+                fprintf (stderr,
+                         _("-warning, you may have to re-enable CTRL-Y handling from DCL.\n"));
+        status= lib$disable_ctrl (&ctrlMask, &oldCtrlMask);
+        if (!(status&SS$_NORMAL)) {
+                lib$signal(status);
+                return;
+        }
+        if (!chan)
+                chan = loc_chan;
+  $DESCRIPTOR(inputDsc,"SYS$COMMAND");
+  int     status;
+  struct {
+    short int       status, count;
+    int     dvi;
+  } iosb;
+  unsigned short int loc_chan;
+  setupYAstTried++;
+  if (chan)
+    loc_chan= chan;
+  else
+    {
+      status= sys$assign(&inputDsc,&loc_chan,0,0);
+      if (!(status&SS$_NORMAL))
+        {
+          lib$signal(status);
+          return;
+        }
+    }
+  status= sys$qiow (0, loc_chan, IO$_SETMODE|IO$M_CTRLYAST,&iosb,0,0,
+                    astYHandler,0,0,0,0,0);
+  if (status==SS$_NORMAL)
+    status= iosb.status;
+  if (status!=SS$_NORMAL)
+    {
+      if (!chan)
+        sys$dassgn(loc_chan);
+      if (status!=SS$_ILLIOFUNC && status!=SS$_NOPRIV)
+        lib$signal(status);
+      return;
+    }
+  /* called from AST handler ? */
+  if (setupYAstTried>1)
+    return;
+  if (atexit(reEnableAst))
+    fprintf (stderr,
+             _("-warning, you may have to re-enable CTRL-Y handling from DCL.\n"));
+  status= lib$disable_ctrl (&ctrlMask, &oldCtrlMask);
+  if (!(status&SS$_NORMAL))
+    {
+      lib$signal(status);
+      return;
+    }
+  if (!chan)
+    chan = loc_chan;
+}
+/* Check if a token is too long */
+#define INC_TOKEN_LEN_OR_RETURN(x) {token->length++; \
+  if (token->length >= MAX_DCL_TOKEN_LENGTH) \
+    { token->cmd_errno = ERANGE; return x; }}
+#define INC_TOKEN_LEN_OR_BREAK {token->length++; \
+  if (token->length >= MAX_DCL_TOKEN_LENGTH) \
+    { token->cmd_errno = ERANGE; break; }}
+#define ADD_TOKEN_LEN_OR_RETURN(add_len, x) {token->length += add_len; \
+  if (token->length >= MAX_DCL_TOKEN_LENGTH) \
+    { token->cmd_errno = ERANGE; return x; }}
+/* Check if we are out of space for more tokens */
+#define V_NEXT_TOKEN { if (cmd_tkn_index < MAX_DCL_TOKENS) \
+  cmd_tokens[++cmd_tkn_index] = NULL; \
+  else { token.cmd_errno = E2BIG; break; } \
+  token.length = 0;}
+#define UPDATE_TOKEN {cmd_tokens[cmd_tkn_index] = strdup(token.text); \
+  V_NEXT_TOKEN;}
+#define EOS_ERROR(x) { if (*x == 0) { token->cmd_errno = ERANGE; break; }}
+struct token_info
+  {
+    char *text;       /* Parsed text */
+    int length;       /* Length of parsed text */
+    char *src;        /* Pointer to source text */
+    int cmd_errno;    /* Error status of parse */
+    int use_cmd_file; /* Force use of a command file */
+  };
+/* Extract a Posix single quoted string from input line */
+static char *
+posix_parse_sq (struct token_info *token)
+{
+  /* A Posix quoted string with no expansion unless in a string
+     Unix simulation means no lexical functions present.
+  */
+  char * q;
+  char * p;
+  q = token->text;
+  p = token->src;
+  *q++ = '"';
+  p++;
+  INC_TOKEN_LEN_OR_RETURN (p);
+  while (*p != '\'' && (token->length < MAX_DCL_TOKEN_LENGTH))
+    {
+      EOS_ERROR (p);
+      if (*p == '"')
+        {
+          /* Embedded double quotes need to be doubled */
+          *q++ = '"';
+          INC_TOKEN_LEN_OR_BREAK;
+          *q = '"';
+        }
+      else
+        *q = *p;
+      q++;
+      p++;
+      INC_TOKEN_LEN_OR_BREAK;
+    }
+  *q++ = '"';
+  p++;
+  INC_TOKEN_LEN_OR_RETURN (p);
+  *q = 0;
+  return p;
+}
+/* Extract a Posix double quoted string from input line */
+static char *
+posix_parse_dq (struct token_info *token)
+{
+  /* Unix mode:  Any imbedded \" becomes doubled.
+                 \t is tab, \\, \$ leading character stripped.
+                 $ character replaced with \' unless escaped.
+  */
+  char * q;
+  char * p;
+  q = token->text;
+  p = token->src;
+  *q++ = *p++;
+  INC_TOKEN_LEN_OR_RETURN (p);
+  while (*p != 0)
+    {
+      if (*p == '\\')
+        {
+          switch(p[1])
+            {
+            case 't':     /* Convert tabs */
+              *q = '\t';
+              p++;
+              break;
+            case '\\':     /* Just remove leading backslash */
+            case '$':
+              p++;
+              *q = *p;
+              break;
+            case '"':
+              p++;
+              *q = *p;
+              *q++ = '"';
+              INC_TOKEN_LEN_OR_BREAK;
+            default:      /* Pass through unchanged */
+              *q++ = *p++;
+              INC_TOKEN_LEN_OR_BREAK;
+            }
+          INC_TOKEN_LEN_OR_BREAK;
+        }
+      else if (*p == '$' && isalpha (p[1]))
+        {
+          /* A symbol we should be able to substitute */
+          *q++ = '\'';
+          INC_TOKEN_LEN_OR_BREAK;
+          *q = '\'';
+          INC_TOKEN_LEN_OR_BREAK;
+          token->use_cmd_file = 1;
+        }
+      else
+        {
+          *q = *p;
+          INC_TOKEN_LEN_OR_BREAK;
+          if (*p == '"')
+            {
+              p++;
+              q++;
+              break;
+            }
+        }
+      p++;
+      q++;
+    }
+  *q = 0;
+  return p;
+}
+/* Extract a VMS quoted string or substitution string from input line */
+static char *
+vms_parse_quotes (struct token_info *token)
+{
+  /* VMS mode, the \' means that a symbol substitution is starting
+     so while you might think you can just copy until the next
+     \'.  Unfortunately the substitution can be a lexical function
+     which can contain embedded strings and lexical functions.
+     Messy, so both types need to be handled together.
+  */
+  char * q;
+  char * p;
+  q = token->text;
+  p = token->src;
+  int parse_level[MAX_DCL_TOKENS + 1];
+  int nest = 0;
+  parse_level[0] = *p;
+  if (parse_level[0] == '\'')
+    token->use_cmd_file = 1;
+  *q++ = *p++;
+  INC_TOKEN_LEN_OR_RETURN (p);
+  /* Copy everything until after the next single quote at nest == 0 */
+  while (token->length < MAX_DCL_TOKEN_LENGTH)
+    {
+      EOS_ERROR (p);
+      *q = *p;
+      INC_TOKEN_LEN_OR_BREAK;
+      if ((*p == parse_level[nest]) && (p[1] != '"'))
+        {
+          if (nest == 0)
+            {
+              *q++ = *p++;
+              break;
+            }
+          nest--;
+        }
+      else
+        {
+          switch(*p)
+            {
+            case '\\':
+              /* Handle continuation on to next line */
+              if (p[1] != '\n')
+                break;
+              p++;
+              p++;
+              *q = *p;
+              break;
+            case '(':
+              /* Parenthesis only in single quote level */
+              if (parse_level[nest] == '\'')
+                {
+                  nest++;
+                  parse_level[nest] == ')';
+                }
+              break;
+            case '"':
+              /* Double quotes only in parenthesis */
+              if (parse_level[nest] == ')')
+                {
+                  nest++;
+                  parse_level[nest] == '"';
+                }
+              break;
+            case '\'':
+              /* Symbol substitution ony in double quotes */
+              if ((p[1] == '\'') && (parse_level[nest] == '"'))
+                {
+                  nest++;
+                  parse_level[nest] == '\'';
+                  *p++ = *q++;
+                  token->use_cmd_file = 1;
+                  INC_TOKEN_LEN_OR_BREAK;
+                  break;
+                }
+              *q = *p;
+            }
+        }
+      p++;
+      q++;
+      /* Pass through doubled double quotes */
+      if ((*p == '"') && (p[1] == '"') && (parse_level[nest] == '"'))
+      {
+        *p++ = *q++;
+        INC_TOKEN_LEN_OR_BREAK;
+        *p++ = *q++;
+        INC_TOKEN_LEN_OR_BREAK;
+      }
+    }
+  *q = 0;
+  return p;
+}
+/* Extract a $ string from the input line */
+static char *
+posix_parse_dollar (struct token_info *token)
+{
+  /* $foo becomes 'foo' */
+  char * q;
+  char * p;
+  q = token->text;
+  p = token->src;
+  token->use_cmd_file = 1;
+  p++;
+  *q++ = '\'';
+  INC_TOKEN_LEN_OR_RETURN (p);
+  while ((isalnum (*p)) || (*p == '_'))
+    {
+      *q++ = *p++;
+      INC_TOKEN_LEN_OR_BREAK;
+    }
+  *q++ = '\'';
+  while (1)
+    {
+      INC_TOKEN_LEN_OR_BREAK;
+      break;
+    }
+  *q = 0;
+  return p;
+}
+const char *vms_filechars = "0123456789abcdefghijklmnopqrstuvwxyz" \
+   "ABCDEFGHIJKLMNOPQRSTUVWXYZ[]<>:/_-.$";
+/* Simple text copy */
+static char *
+parse_text (struct token_info *token, int assignment_hack)
+{
+  char * q;
+  char * p;
+  int str_len;
+  q = token->text;
+  p = token->src;
+  /* If assignment hack, then this text needs to be double quoted. */
+  if (vms_unix_simulation && (assignment_hack == 2))
+    {
+      *q++ = '"';
+      INC_TOKEN_LEN_OR_RETURN (p);
+    }
+  *q++ = *p++;
+  INC_TOKEN_LEN_OR_RETURN (p);
+  while (*p != 0)
+    {
+      str_len = strspn (p, vms_filechars);
+      if (str_len == 0)
+        {
+          /* Pass through backslash escapes in Unix simulation
+             probably will not work anyway.
+             All any character after a ^ otherwise to support EFS.
+          */
+          if (vms_unix_simulation && (p[0] == '\\') && (p[1] != 0))
+            str_len = 2;
+          else if ((p[0] == '^') && (p[1] != 0))
+            str_len = 2;
+          else if (!vms_unix_simulation && (p[0] == ';'))
+            str_len = 1;
+          if (str_len == 0)
+            {
+              /* If assignment hack, then this needs to be double quoted. */
+              if (vms_unix_simulation && (assignment_hack == 2))
+              {
+                *q++ = '"';
+                INC_TOKEN_LEN_OR_RETURN (p);
+              }
+              *q = 0;
+              return p;
+            }
+        }
+      if (str_len > 0)
+        {
+          ADD_TOKEN_LEN_OR_RETURN (str_len, p);
+          strncpy (q, p, str_len);
+          p += str_len;
+          q += str_len;
+          *q = 0;
+        }
+    }
+  /* If assignment hack, then this text needs to be double quoted. */
+  if (vms_unix_simulation && (assignment_hack == 2))
+    {
+      *q++ = '"';
+      INC_TOKEN_LEN_OR_RETURN (p);
+    }
+  return p;
+}
+/* single character copy */
+static char *
+parse_char (struct token_info *token, int count)
+{
+  char * q;
+  char * p;
+  q = token->text;
+  p = token->src;
+  while (count > 0)
+    {
+      *q++ = *p++;
+      INC_TOKEN_LEN_OR_RETURN (p);
+      count--;
+    }
+  *q = 0;
+  return p;
+}
+/* Build a command string from the collected tokens
+   and process built-ins now
+*/
+static struct dsc$descriptor_s *
+build_vms_cmd (char **cmd_tokens,
+               enum auto_pipe use_pipe_cmd,
+               int append_token)
+{
+  struct dsc$descriptor_s *cmd_dsc;
+  int cmd_tkn_index;
+  char * cmd;
+  int cmd_len;
+  int semicolon_seen;
+  cmd_tkn_index = 0;
+  cmd_dsc = xmalloc (sizeof (struct dsc$descriptor_s));
+  /* Empty command? */
+  if (cmd_tokens[0] == NULL)
+    {
+      cmd_dsc->dsc$a_pointer = NULL;
+      cmd_dsc->dsc$w_length = 0;
+      return cmd_dsc;
+    }
+  /* Max DCL command + 1 extra token and trailing space */
+  cmd = xmalloc (MAX_DCL_CMD_LINE_LENGTH + 256);
+  cmd[0] = '$';
+  cmd[1] = 0;
+  cmd_len = 1;
+  /* Handle real or auto-pipe */
+  if (use_pipe_cmd == add_pipe)
+    {
+      /* We need to auto convert to a pipe command */
+      strcat (cmd, "pipe ");
+      cmd_len += 5;
+    }
+  semicolon_seen = 0;
+  while (cmd_tokens[cmd_tkn_index] != NULL)
+    {
+      /* Check for buffer overflow */
+      if (cmd_len > MAX_DCL_CMD_LINE_LENGTH)
+        {
+          errno = E2BIG;
+          break;
+        }
+      /* Eliminate double ';' */
+      if (semicolon_seen && (cmd_tokens[cmd_tkn_index][0] == ';'))
+        {
+          semicolon_seen = 0;
+          free (cmd_tokens[cmd_tkn_index++]);
+          if (cmd_tokens[cmd_tkn_index] == NULL)
+            break;
+        }
+      /* Special handling for CD built-in */
+      if (strncmp (cmd_tokens[cmd_tkn_index], "builtin_cd", 11) == 0)
+        {
+          int result;
+          semicolon_seen = 0;
+          free (cmd_tokens[cmd_tkn_index]);
+          cmd_tkn_index++;
+          if (cmd_tokens[cmd_tkn_index] == NULL)
+            break;
+          DB(DB_JOBS, (_("BUILTIN CD %s\n"), cmd_tokens[cmd_tkn_index]));
+          /* TODO: chdir fails with some valid syntaxes */
+          result = chdir (cmd_tokens[cmd_tkn_index]);
+          if (result != 0)
+            {
+              /* TODO: Handle failure better */
+              free (cmd);
+              while (cmd_tokens[cmd_tkn_index] == NULL)
+                free (cmd_tokens[cmd_tkn_index++]);
+              cmd_dsc->dsc$w_length = -1;
+              cmd_dsc->dsc$a_pointer = NULL;
+              return cmd_dsc;
+            }
+        }
+      else if (strncmp (cmd_tokens[cmd_tkn_index], "exit", 5) == 0)
+        {
+          /* Copy the exit command */
+          semicolon_seen = 0;
+          strcpy (&cmd[cmd_len], cmd_tokens[cmd_tkn_index]);
+          cmd_len += strlen (cmd_tokens[cmd_tkn_index]);
+          free (cmd_tokens[cmd_tkn_index++]);
+          if (cmd_len > MAX_DCL_CMD_LINE_LENGTH)
+            {
+              errno = E2BIG;
+              break;
+            }
+          /* Optional whitespace */
+          if (isspace (cmd_tokens[cmd_tkn_index][0]))
+            {
+              strcpy (&cmd[cmd_len], cmd_tokens[cmd_tkn_index]);
+              cmd_len += strlen (cmd_tokens[cmd_tkn_index]);
+              free (cmd_tokens[cmd_tkn_index++]);
+              if (cmd_len > MAX_DCL_CMD_LINE_LENGTH)
+              {
+                errno = E2BIG;
+                break;
+              }
+            }
+          /* There should be a status, but it is optional */
+          if (cmd_tokens[cmd_tkn_index][0] == ';')
+            continue;
+          /* If Unix simulation, add '((' */
+          if (vms_unix_simulation)
+            {
+              strcpy (&cmd[cmd_len], "((");
+              cmd_len += 2;
+              if (cmd_len > MAX_DCL_CMD_LINE_LENGTH)
+                {
+                  errno = E2BIG;
+                  break;
+                }
+            }
+          /* Add the parameter */
+          strcpy (&cmd[cmd_len], cmd_tokens[cmd_tkn_index]);
+          cmd_len += strlen (cmd_tokens[cmd_tkn_index]);
+          free (cmd_tokens[cmd_tkn_index++]);
+          if (cmd_len > MAX_DCL_CMD_LINE_LENGTH)
+            {
+              errno = E2BIG;
+              break;
+            }
+          /* Add " * 8) .and. %x7f8) .or. %x1035a002" */
+          if (vms_unix_simulation)
+            {
+              const char *end_str = " * 8) .and. %x7f8) .or. %x1035a002";
+              strcpy (&cmd[cmd_len], end_str);
+              cmd_len += strlen (end_str);
+              if (cmd_len > MAX_DCL_CMD_LINE_LENGTH)
+                {
+                  errno = E2BIG;
+                  break;
+                }
+            }
+          continue;
+        }
+      /* auto pipe needs spaces before semicolon */
+      if (use_pipe_cmd == add_pipe)
+        if (cmd_tokens[cmd_tkn_index][0] == ';')
+          {
+            cmd[cmd_len++] = ' ';
+            semicolon_seen = 1;
+            if (cmd_len > MAX_DCL_CMD_LINE_LENGTH)
+              {
+                errno = E2BIG;
+                break;
+              }
+          }
+        else
+          {
+            char ch;
+            ch = cmd_tokens[cmd_tkn_index][0];
+            if (!(ch == ' ' || ch == '\t'))
+              semicolon_seen = 0;
+          }
+      strcpy (&cmd[cmd_len], cmd_tokens[cmd_tkn_index]);
+      cmd_len += strlen (cmd_tokens[cmd_tkn_index]);
+      free (cmd_tokens[cmd_tkn_index++]);
+      /* Skip the append tokens if they exist */
+      if (cmd_tkn_index == append_token)
+        {
+          free (cmd_tokens[cmd_tkn_index++]);
+          if (isspace (cmd_tokens[cmd_tkn_index][0]))
+            free (cmd_tokens[cmd_tkn_index++]);
+          free (cmd_tokens[cmd_tkn_index++]);
+        }
+    }
+  cmd[cmd_len] = 0;
+  cmd_dsc->dsc$w_length = cmd_len;
+  cmd_dsc->dsc$a_pointer = cmd;
+  cmd_dsc->dsc$b_dtype = DSC$K_DTYPE_T;
+  cmd_dsc->dsc$b_class = DSC$K_CLASS_S;
+  return cmd_dsc;
+}
 int
 child_execute_job (char *argv, struct child *child)
+child_execute_job (struct child *child, char *argv)
+{
   int i;
+  static struct dsc$descriptor_s cmddsc;
+  static struct dsc$descriptor_s *cmd_dsc;
   static struct dsc$descriptor_s pnamedsc;
-  static struct dsc$descriptor_s ifiledsc;
-  static struct dsc$descriptor_s ofiledsc;
-  static struct dsc$descriptor_s efiledsc;
-  int have_redirection = 0;
-  int have_append = 0;
-  int have_newline = 0;
   int spflags = CLI$M_NOWAIT;
   int status;
-  char *cmd = alloca (strlen (argv) + 512), *p, *q;
-  char ifile[256], ofile[256], efile[256];
   int comnamelen;
   char procname[100];
+  int in_string;
+  char *p;
+  char *cmd_tokens[(MAX_DCL_TOKENS * 2) + 1]; /* whitespace does not count */
+  char token_str[MAX_DCL_TOKEN_LENGTH + 1];
+  struct token_info token;
+  int cmd_tkn_index;
+  int paren_level = 0;
+  enum auto_pipe use_pipe_cmd = nopipe;
+  int append_token = -1;
+  char *append_file = NULL;
+  int unix_echo_cmd = 0;  /* Special handle Unix echo command */
+  int assignment_hack = 0; /* Handle x=y command as piped command */
   /* Parse IO redirection.  */
-  ifile[0] = 0;
-  ofile[0] = 0;
-  efile[0] = 0;
   child->comname = NULL;
 …
   if (*argv == 0)
+    return 0;
+    {
+      /* Only a built-in or a null command - Still need to run term AST */
+      child->cstatus = VMS_POSIX_EXIT_MASK;
+      child->vms_launch_status = SS$_NORMAL;
+      /* TODO what is this "magic number" */
+      child->pid = 270163; /* Special built-in */
+      child->efn = 0;
+      vmsHandleChildTerm (child);
+      return 1;
+    }
   sprintf (procname, "GMAKE_%05x", getpid () & 0xfffff);
   pnamedsc.dsc$w_length = strlen(procname);
+  pnamedsc.dsc$w_length = strlen (procname);
   pnamedsc.dsc$a_pointer = procname;
   pnamedsc.dsc$b_dtype = DSC$K_DTYPE_T;
   pnamedsc.dsc$b_class = DSC$K_CLASS_S;
+  in_string = 0;
+  /* Handle comments and redirection. */
+  for (p = argv, q = cmd; *p; p++, q++)
+    {
+      if (*p == '"')
+        in_string = !in_string;
+      if (in_string)
+        {
+          *q = *p;
+          continue;
+        }
+  /* Old */
+  /* Handle comments and redirection.
+     For ONESHELL, the redirection must be on the first line. Any other
+     redirection token is handled by DCL, that is, the pipe command with
+     redirection can be used, but it should not be used on the first line
+     for ONESHELL. */
+  /* VMS parser notes:
+. A token is any of DCL verbs, qualifiers, parameters, or punctuation.
+. Only MAX_DCL_TOKENS per line in both one line or command file mode.
+. Each token limited to MAC_DCL_TOKEN_LENGTH
+. If the line to DCL is greater than MAX_DCL_LINE_LENGTH then a
+        command file must be used.
+. Currently a command file must be used symbol substitution is to
+        be performed.
+. Currently limiting command files to 2 * MAX_DCL_TOKENS.
+     Build both a command file token list and command line token list
+     until it is determined that the command line limits are exceeded.
+  */
+  cmd_tkn_index = 0;
+  cmd_tokens[cmd_tkn_index] = NULL;
+  p = argv;
+  token.text = token_str;
+  token.length = 0;
+  token.cmd_errno = 0;
+  token.use_cmd_file = 0;
+  while (*p != 0)
+    {
+      /* We can not build this command so give up */
+      if (token.cmd_errno != 0)
+        break;
+      token.src = p;
       switch (*p)
+        {
+          case '#':
+            *p-- = 0;
+            *q-- = 0;
+            break;
+          case '\\':
+            p++;
+            if (*p == '\n')
+              p++;
+            if (isspace ((unsigned char)*p))
+              {
+                do { p++; } while (isspace ((unsigned char)*p));
+                p--;
+              }
+            *q = *p;
+            break;
+          case '<':
+            p = vms_redirect (&ifiledsc, ifile, p);
+            *q = ' ';
+            have_redirection = 1;
+            break;
+          case '>':
+            have_redirection = 1;
+            if (*(p-1) == '2')
+              {
+                q--;
+                if (strncmp (p, ">&1", 3) == 0)
+                  {
+                    p += 3;
+                    strcpy (efile, "sys$output");
+                    efiledsc.dsc$w_length = strlen(efile);
+                    efiledsc.dsc$a_pointer = efile;
+                    efiledsc.dsc$b_dtype = DSC$K_DTYPE_T;
+                    efiledsc.dsc$b_class = DSC$K_CLASS_S;
+                  }
+                else
+                  {
+                    p = vms_redirect (&efiledsc, efile, p);
+                  }
+              }
+            else
+              {
+                if (*(p+1) == '>')
+                  {
+                    have_append = 1;
+                    p += 1;
+                  }
+                p = vms_redirect (&ofiledsc, ofile, p);
+              }
+            *q = ' ';
+            break;
+          case '\n':
+            have_newline = 1;
+          default:
+            *q = *p;
+            break;
+        }
+    }
+  *q = *p;
+  while (isspace ((unsigned char)*--q))
+    *q = '\0';
+  if (strncmp (cmd, "builtin_", 8) == 0)
+    {
+      child->pid = 270163;
+        {
+        case '\'':
+          if (vms_unix_simulation || unix_echo_cmd)
+            {
+              p = posix_parse_sq (&token);
+              UPDATE_TOKEN;
+              break;
+            }
+          /* VMS mode, the \' means that a symbol substitution is starting
+             so while you might think you can just copy until the next
+             \'.  Unfortunately the substitution can be a lexical function
+             which can contain embedded strings and lexical functions.
+             Messy.
+          */
+          p = vms_parse_quotes (&token);
+          UPDATE_TOKEN;
+          break;
+        case '"':
+          if (vms_unix_simulation)
+            {
+              p = posix_parse_dq (&token);
+              UPDATE_TOKEN;
+              break;
+            }
+          /* VMS quoted string, can contain lexical functions with
+             quoted strings and nested lexical functions.
+          */
+          p = vms_parse_quotes (&token);
+          UPDATE_TOKEN;
+          break;
+        case '$':
+          if (vms_unix_simulation)
+            {
+              p = posix_parse_dollar (&token);
+              UPDATE_TOKEN;
+              break;
+            }
+          /* Otherwise nothing special */
+          p = parse_text (&token, 0);
+          UPDATE_TOKEN;
+          break;
+        case '\\':
+          if (p[1] == '\n')
+            {
+              /* Line continuation, remove it */
+              p += 2;
+              break;
+            }
+          /* Ordinary character otherwise */
+          if (assignment_hack != 0)
+            assignment_hack++;
+          if (assignment_hack > 2)
+            {
+              assignment_hack = 0;          /* Reset */
+              if (use_pipe_cmd == nopipe)   /* force pipe use */
+                use_pipe_cmd = add_pipe;
+              token_str[0] = ';';              /* add ; token */
+              token_str[1] = 0;
+              UPDATE_TOKEN;
+            }
+          p = parse_text (&token, assignment_hack);
+          UPDATE_TOKEN;
+          break;
+        case '!':
+        case '#':
+          /* Unix '#' is VMS '!' which comments out the rest of the line.
+             Historically the rest of the line has been skipped.
+             Not quite the right thing to do, as the f$verify lexical
+             function works in comments.  But this helps keep the line
+             lengths short.
+          */
+          unix_echo_cmd = 0;
+          while (*p != '\n' && *p != 0)
+            p++;
+          break;
+        case '(':
+          /* Subshell, equation, or lexical function argument start */
+          p = parse_char (&token, 1);
+          UPDATE_TOKEN;
+          paren_level++;
+          break;
+        case ')':
+          /* Close out a paren level */
+          p = parse_char (&token, 1);
+          UPDATE_TOKEN;
+          paren_level--;
+          /* TODO: Should we diagnose if paren_level goes negative? */
+          break;
+        case '&':
+          if (isalpha (p[1]) && !vms_unix_simulation)
+            {
+              /* VMS symbol substitution */
+              p = parse_text (&token, 0);
+              token.use_cmd_file = 1;
+              UPDATE_TOKEN;
+              break;
+            }
+          if (use_pipe_cmd == nopipe)
+            use_pipe_cmd = add_pipe;
+          if (p[1] != '&')
+            p = parse_char (&token, 1);
+          else
+            p = parse_char (&token, 2);
+          UPDATE_TOKEN;
+          break;
+        case '|':
+          if (use_pipe_cmd == nopipe)
+            use_pipe_cmd = add_pipe;
+          if (p[1] != '|')
+            p = parse_char (&token, 1);
+          else
+            p = parse_char (&token, 2);
+          UPDATE_TOKEN;
+          break;
+        case ';':
+          /* Separator - convert to a pipe command. */
+          unix_echo_cmd = 0;
+        case '<':
+          if (use_pipe_cmd == nopipe)
+            use_pipe_cmd = add_pipe;
+          p = parse_char (&token, 1);
+          UPDATE_TOKEN;
+          break;
+        case '>':
+          if (use_pipe_cmd == nopipe)
+            use_pipe_cmd = add_pipe;
+          if (p[1] == '>')
+            {
+              /* Parsing would have been simple until support for the >>
+                 append redirect was added.
+                 Implementation needs:
+                 * if not exist output file create empty
+                 * open/append gnv$make_temp??? output_file
+                 * define/user sys$output gnv$make_temp???
+                 ** And all this done before the command previously tokenized.
+                 * command previously tokenized
+                 * close gnv$make_temp???
+              */
+              p = parse_char (&token, 2);
+              append_token = cmd_tkn_index;
+              token.use_cmd_file = 1;
+            }
+          else
+            p = parse_char (&token, 1);
+          UPDATE_TOKEN;
+          break;
+        case '/':
+          /* Unix path or VMS option start, read until non-path symbol */
+          if (assignment_hack != 0)
+            assignment_hack++;
+          if (assignment_hack > 2)
+            {
+              assignment_hack = 0;          /* Reset */
+              if (use_pipe_cmd == nopipe)   /* force pipe use */
+                use_pipe_cmd = add_pipe;
+              token_str[0] = ';';              /* add ; token */
+              token_str[1] = 0;
+              UPDATE_TOKEN;
+            }
+          p = parse_text (&token, assignment_hack);
+          UPDATE_TOKEN;
+          break;
+        case ':':
+          if ((p[1] == 0) || isspace (p[1]))
+            {
+              /* Unix Null command - treat as comment until next command */
+              unix_echo_cmd = 0;
+              p++;
+              while (*p != 0)
+                {
+                  if (*p == ';')
+                    {
+                      /* Remove Null command from pipeline */
+                      p++;
+                      break;
+                    }
+                  p++;
+                }
+              break;
+            }
+          /* String assignment */
+          /* := :== or : */
+          if (p[1] != '=')
+            p = parse_char (&token, 1);
+          else if (p[2] != '=')
+            p = parse_char (&token, 2);
+          else
+            p = parse_char (&token, 3);
+          UPDATE_TOKEN;
+          break;
+        case '=':
+          /* = or == */
+          /* If this is not an echo statement, this could be a shell
+             assignment.  VMS requires the target to be quoted if it
+             is not a macro substitution */
+          if (!unix_echo_cmd && vms_unix_simulation && (assignment_hack == 0))
+            assignment_hack = 1;
+          if (p[1] != '=')
+            p = parse_char (&token, 1);
+          else
+            p = parse_char (&token, 2);
+          UPDATE_TOKEN;
+          break;
+        case '+':
+        case '-':
+        case '*':
+          p = parse_char (&token, 1);
+          UPDATE_TOKEN;
+          break;
+        case '.':
+          /* .xxx. operation, VMS does not require the trailing . */
+          p = parse_text (&token, 0);
+          UPDATE_TOKEN;
+          break;
+        default:
+          /* Skip repetitive whitespace */
+          if (isspace (*p))
+            {
+              p = parse_char (&token, 1);
+              /* Force to a space or a tab */
+              if ((token_str[0] != ' ') ||
+                  (token_str[0] != '\t'))
+                token_str[0] = ' ';
+              UPDATE_TOKEN;
+              while (isspace (*p))
+                p++;
+              if (assignment_hack != 0)
+                assignment_hack++;
+              break;
+            }
+          if (assignment_hack != 0)
+            assignment_hack++;
+          if (assignment_hack > 2)
+            {
+              assignment_hack = 0;          /* Reset */
+              if (use_pipe_cmd == nopipe)   /* force pipe use */
+                use_pipe_cmd = add_pipe;
+              token_str[0] = ';';              /* add ; token */
+              token_str[1] = 0;
+              UPDATE_TOKEN;
+            }
+          p = parse_text (&token, assignment_hack);
+          if (strncasecmp (token.text, "echo", 4) == 0)
+            unix_echo_cmd = 1;
+          else if (strncasecmp (token.text, "pipe", 4) == 0)
+            use_pipe_cmd = dcl_pipe;
+          UPDATE_TOKEN;
+          break;
+        }
+    }
+  /* End up here with a list of tokens to build a command line.
+     Deal with errors detected during parsing.
+   */
+  if (token.cmd_errno != 0)
+    {
+      while (cmd_tokens[cmd_tkn_index] == NULL)
+        free (cmd_tokens[cmd_tkn_index++]);
+      child->cstatus = VMS_POSIX_EXIT_MASK | (MAKE_TROUBLE << 3);
+      child->vms_launch_status = SS$_ABORT;
+      /* TODO what is this "magic number" */
+      child->pid = 270163; /* Special built-in */
       child->efn = 0;
+      child->cstatus = 1;
+      DB (DB_JOBS, (_("BUILTIN [%s][%s]\n"), cmd, cmd+8));
+      p = cmd + 8;
+      if ((*(p) == 'c')
+          && (*(p+1) == 'd')
+          && ((*(p+2) == ' ') || (*(p+2) == '\t')))
+        {
+          p += 3;
+          while ((*p == ' ') || (*p == '\t'))
+            p++;
+          DB (DB_JOBS, (_("BUILTIN CD %s\n"), p));
+          if (chdir (p))
+            return 0;
+          else
+            return 1;
+        }
+      else if ((*(p) == 'r')
+          && (*(p+1) == 'm')
+          && ((*(p+2) == ' ') || (*(p+2) == '\t')))
+        {
+          int in_arg;
+          /* rm  */
+          p += 3;
+          while ((*p == ' ') || (*p == '\t'))
+            p++;
+          in_arg = 1;
+          DB (DB_JOBS, (_("BUILTIN RM %s\n"), p));
+          while (*p)
+            {
+              switch (*p)
+                {
+                  case ' ':
+                  case '\t':
+                    if (in_arg)
+                      {
+                        *p++ = ';';
+                        in_arg = 0;
+                      }
+                    break;
+                  default:
+                    break;
+                }
+              p++;
+            }
+        }
+      errno = token.cmd_errno;
+      return 0;
+    }
+  /* Save any redirection to append file */
+  if (append_token != -1)
+    {
+      int file_token;
+      char * lastdot;
+      char * lastdir;
+      char * raw_append_file;
+      file_token = append_token;
+      file_token++;
+      if (isspace (cmd_tokens[file_token][0]))
+        file_token++;
+      raw_append_file = vmsify (cmd_tokens[file_token], 0);
+      /* VMS DCL needs a trailing dot if null file extension */
+      lastdot = strrchr(raw_append_file, '.');
+      lastdir = strrchr(raw_append_file, ']');
+      if (lastdir == NULL)
+        lastdir = strrchr(raw_append_file, '>');
+      if (lastdir == NULL)
+        lastdir = strrchr(raw_append_file, ':');
+      if ((lastdot == NULL) || (lastdot > lastdir))
+        {
+          append_file = xmalloc (strlen (raw_append_file) + 1);
+          strcpy (append_file, raw_append_file);
+          strcat (append_file, ".");
+        }
       else
+        {
+          printf(_("Unknown builtin command '%s'\n"), cmd);
+          fflush(stdout);
+          return 0;
+        }
+    }
+  /* Create a *.com file if either the command is too long for
+     lib$spawn, or the command contains a newline, or if redirection
+     is desired. Forcing commands with newlines into DCLs allows to
+     store search lists on user mode logicals.  */
+  if (strlen (cmd) > MAXCMDLEN
+      || (have_redirection != 0)
+      || (have_newline != 0))
+        append_file = strdup(raw_append_file);
+    }
+  cmd_dsc = build_vms_cmd (cmd_tokens, use_pipe_cmd, append_token);
+  if (cmd_dsc->dsc$a_pointer == NULL)
+    {
+      if (cmd_dsc->dsc$w_length < 0)
+        {
+          free (cmd_dsc);
+          child->cstatus = VMS_POSIX_EXIT_MASK | (MAKE_TROUBLE << 3);
+          child->vms_launch_status = SS$_ABORT;
+          /* TODO what is this "magic number" */
+          child->pid = 270163; /* Special built-in */
+          child->efn = 0;
+          return 0;
+        }
+      /* Only a built-in or a null command - Still need to run term AST */
+      free (cmd_dsc);
+      child->cstatus = VMS_POSIX_EXIT_MASK;
+      child->vms_launch_status = SS$_NORMAL;
+      /* TODO what is this "magic number" */
+      child->pid = 270163; /* Special built-in */
+      child->efn = 0;
+      vmsHandleChildTerm (child);
+      return 1;
+    }
+  if (cmd_dsc->dsc$w_length > MAX_DCL_LINE_LENGTH)
+    token.use_cmd_file = 1;
+  DB(DB_JOBS, (_("DCL: %s\n"), cmd_dsc->dsc$a_pointer));
+  /* Enforce the creation of a command file if "vms_always_use_cmd_file" is
+     non-zero.
+     Further, this way DCL reads the input stream and therefore does
+     'forced' symbol substitution, which it doesn't do for one-liners when
+     they are 'lib$spawn'ed.
+     Otherwise the behavior is:
+     Create a *.com file if either the command is too long for
+     lib$spawn, or if a redirect appending to a file is desired, or
+     symbol substitition.
+  */
+  if (vms_always_use_cmd_file || token.use_cmd_file)
+    {
       FILE *outfile;
+      char c;
+      char *sep;
+      int alevel = 0;   /* apostrophe level */
+      if (strlen (cmd) == 0)
+        {
+          printf (_("Error, empty command\n"));
+          fflush (stdout);
+          return 0;
+        }
+      outfile = open_tmpfile (&child->comname, "sys$scratch:CMDXXXXXX.COM");
+      int cmd_len;
+      outfile = output_tmpfile (&child->comname,
+                                "sys$scratch:gnv$make_cmdXXXXXX.com");
+      /*                                          012345678901234567890 */
       if (outfile == 0)
         pfatal_with_name (_("fopen (temporary file)"));
+        pfatal_with_name (_("fopen (temporary file)"));
       comnamelen = strlen (child->comname);
+      if (ifile[0])
+        {
+          fprintf (outfile, "$ assign/user %s sys$input\n", ifile);
+          DB (DB_JOBS, (_("Redirected input from %s\n"), ifile));
+          ifiledsc.dsc$w_length = 0;
+        }
+      if (efile[0])
+        {
+          fprintf (outfile, "$ define sys$error %s\n", efile);
+          DB (DB_JOBS, (_("Redirected error to %s\n"), efile));
+          efiledsc.dsc$w_length = 0;
+        }
+      if (ofile[0])
+        {
+          if (have_append)
+            {
+              fprintf (outfile, "$ set noon\n");
+              fprintf (outfile, "$ define sys$output %.*s\n", comnamelen-3, child->comname);
+              DB (DB_JOBS, (_("Append output to %s\n"), ofile));
+              ofiledsc.dsc$w_length = 0;
+            }
+          else
+            {
+              fprintf (outfile, "$ define sys$output %s\n", ofile);
+              DB (DB_JOBS, (_("Redirected output to %s\n"), ofile));
+              ofiledsc.dsc$w_length = 0;
+            }
+        }
+      p = sep = q = cmd;
+      for (c = '\n'; c; c = *q++)
+        {
+          switch (c)
+            {
+            case '\n':
+              /* At a newline, skip any whitespace around a leading $
+                 from the command and issue exactly one $ into the DCL. */
+              while (isspace ((unsigned char)*p))
+                p++;
+              if (*p == '$')
+                p++;
+              while (isspace ((unsigned char)*p))
+                p++;
+              fwrite (p, 1, q - p, outfile);
+              fputc ('$', outfile);
+              fputc (' ', outfile);
+              /* Reset variables. */
+              p = sep = q;
+              break;
+              /* Nice places for line breaks are after strings, after
+                 comma or space and before slash. */
+            case '"':
+              q = vms_handle_apos (q);
+              sep = q;
+              break;
+            case ',':
+            case ' ':
+              sep = q;
+              break;
+            case '/':
+            case '\0':
+              sep = q - 1;
+              break;
+            default:
+              break;
+            }
+          if (sep - p > 78)
+            {
+              /* Enough stuff for a line. */
+              fwrite (p, 1, sep - p, outfile);
+              p = sep;
+              if (*sep)
+                {
+                  /* The command continues.  */
+                  fputc ('-', outfile);
+                }
+              fputc ('\n', outfile);
+            }
+        }
+      if (*p)
+        {
+          fwrite (p, 1, --q - p, outfile);
+      fputc ('\n', outfile);
+        }
+      if (have_append)
+        {
+          fprintf (outfile, "$ deassign sys$output ! 'f$verify(0)\n");
+          fprintf (outfile, "$ append:=append\n");
+          fprintf (outfile, "$ delete:=delete\n");
+          fprintf (outfile, "$ append/new %.*s %s\n", comnamelen-3, child->comname, ofile);
+          fprintf (outfile, "$ delete %.*s;*\n", comnamelen-3, child->comname);
+          DB (DB_JOBS, (_("Append %.*s and cleanup\n"), comnamelen-3, child->comname));
+        }
+      /* The whole DCL "script" is executed as one action, and it behaves as
+         any DCL "script", that is errors stop it but warnings do not. Usually
+         the command on the last line, defines the exit code.  However, with
+         redirections there is a prolog and possibly an epilog to implement
+         the redirection.  Both are part of the script which is actually
+         executed. So if the redirection encounters an error in the prolog,
+         the user actions will not run; if in the epilog, the user actions
+         ran, but output is not captured. In both error cases, the error of
+         redirection is passed back and not the exit code of the actions. The
+         user should be able to enable DCL "script" verification with "set
+         verify". However, the prolog and epilog commands are not shown. Also,
+         if output redirection is used, the verification output is redirected
+         into that file as well. */
+      fprintf (outfile, "$ gnv$$make_verify = \"''f$verify(0)'\"\n");
+      fprintf (outfile, "$ gnv$$make_pid = f$getjpi(\"\",\"pid\")\n");
+      fprintf (outfile, "$ on error then $ goto gnv$$make_error\n");
+      /* Handle append redirection */
+      if (append_file != NULL)
+        {
+          /* If file does not exist, create it */
+          fprintf (outfile,
+                   "$ gnv$$make_al = \"gnv$$make_append''gnv$$make_pid'\"\n");
+          fprintf (outfile,
+                   "$ if f$search(\"%s\") .eqs. \"\" then create %s\n",
+                   append_file, append_file);
+          fprintf (outfile,
+                   "$ open/append 'gnv$$make_al' %s\n", append_file);
+          /* define sys$output to that file */
+          fprintf (outfile,
+                   "$ define/user sys$output 'gnv$$make_al'\n");
+          DB (DB_JOBS, (_("Append output to %s\n"), append_file));
+          free(append_file);
+        }
+      fprintf (outfile, "$ gnv$$make_verify = f$verify(gnv$$make_verify)\n");
+      /* TODO:
+         Only for ONESHELL there will be several commands separated by
+         '\n'. But there can always be multiple continuation lines.
+      */
+      fprintf (outfile, "%s\n", cmd_dsc->dsc$a_pointer);
+      fprintf (outfile, "$ gnv$$make_status_2 = $status\n");
+      fprintf (outfile, "$ goto gnv$$make_exit\n");
+      /* Exit and clean up */
+      fprintf (outfile, "$ gnv$$make_error: ! 'f$verify(0)\n");
+      fprintf (outfile, "$ gnv$$make_status_2 = $status\n");
+      if (append_token != -1)
+        {
+          fprintf (outfile, "$ deassign sys$output\n");
+          fprintf (outfile, "$ close 'gnv$$make_al'\n");
+          DB (DB_JOBS,
+              (_("Append %.*s and cleanup\n"), comnamelen-3, child->comname));
+        }
+      fprintf (outfile, "$ gnv$$make_exit: ! 'f$verify(0)\n");
+      fprintf (outfile,
+             "$ exit 'gnv$$make_status_2' + (0*f$verify(gnv$$make_verify))\n");
       fclose (outfile);
+      sprintf (cmd, "$ @%s", child->comname);
+      DB (DB_JOBS, (_("Executing %s instead\n"), cmd));
+    }
+  cmddsc.dsc$w_length = strlen(cmd);
+  cmddsc.dsc$a_pointer = cmd;
+  cmddsc.dsc$b_dtype = DSC$K_DTYPE_T;
+  cmddsc.dsc$b_class = DSC$K_CLASS_S;
+      free (cmd_dsc->dsc$a_pointer);
+      cmd_dsc->dsc$a_pointer = xmalloc (256 + 4);
+      sprintf (cmd_dsc->dsc$a_pointer, "$ @%s", child->comname);
+      cmd_dsc->dsc$w_length = strlen (cmd_dsc->dsc$a_pointer);
+      DB (DB_JOBS, (_("Executing %s instead\n"), child->comname));
+    }
   child->efn = 0;
   while (child->efn < 32 || child->efn > 63)
+    {
       status = lib$get_ef ((unsigned long *)&child->efn);
       if (!(status & 1))
+      status = LIB$GET_EF ((unsigned long *)&child->efn);
+      if (!$VMS_STATUS_SUCCESS (status))
+        {
           if (child->comname)
 …
+    }
   sys$clref (child->efn);
+  SYS$CLREF (child->efn);
   vms_jobsefnmask |= (1 << (child->efn - 32));
+/*
+             LIB$SPAWN  [command-string]
+                        [,input-file]
+                        [,output-file]
+                        [,flags]
+                        [,process-name]
+                        [,process-id] [,completion-status-address] [,byte-integer-event-flag-num]
+                        [,AST-address] [,varying-AST-argument]
+                        [,prompt-string] [,cli] [,table]
+*/
+  /* Export the child environment into DCL symbols */
+  if (child->environment != 0)
+    {
+      char **ep = child->environment;
+      while (*ep != 0)
+        {
+          vms_putenv_symbol (*ep);
+          *ep++;
+        }
+    }
+  /*
+    LIB$SPAWN  [command-string]
+    [,input-file]
+    [,output-file]
+    [,flags]
+    [,process-name]
+    [,process-id] [,completion-status-address] [,byte-integer-event-flag-num]
+    [,AST-address] [,varying-AST-argument]
+    [,prompt-string] [,cli] [,table]
+  */
 #ifndef DONTWAITFORCHILD
 /*
  *      Code to make ctrl+c and ctrl+y working.
  *      The problem starts with the synchronous case where after lib$spawn is
  *      called any input will go to the child. But with input re-directed,
  *      both control characters won't make it to any of the programs, neither
  *      the spawning nor to the spawned one. Hence the caller needs to spawn
  *      with CLI$M_NOWAIT to NOT give up the input focus. A sys$waitfr
  *      has to follow to simulate the wanted synchronous behaviour.
  *      The next problem is ctrl+y which isn't caught by the crtl and
  *      therefore isn't converted to SIGQUIT (for a signal handler which is
  *      already established). The only way to catch ctrl+y, is an AST
  *      assigned to the input channel. But ctrl+y handling of DCL needs to be
  *      disabled, otherwise it will handle it. Not to mention the previous
  *      ctrl+y handling of DCL needs to be re-established before make exits.
  *      One more: At the time of LIB$SPAWN signals are blocked. SIGQUIT will
  *      make it to the signal handler after the child "normally" terminates.
  *      This isn't enough. It seems reasonable for simple command lines like
  *      a 'cc foobar.c' spawned in a subprocess but it is unacceptable for
  *      spawning make. Therefore we need to abort the process in the AST.
+ *
  *      Prior to the spawn it is checked if an AST is already set up for
  *      ctrl+y, if not one is set up for a channel to SYS$COMMAND. In general
  *      this will work except if make is run in a batch environment, but there
  *      nobody can press ctrl+y. During the setup the DCL handling of ctrl+y
  *      is disabled and an exit handler is established to re-enable it.
  *      If the user interrupts with ctrl+y, the assigned AST will fire, force
  *      an abort to the subprocess and signal SIGQUIT, which will be caught by
  *      the already established handler and will bring us back to common code.
  *      After the spawn (now /nowait) a sys$waitfr simulates the /wait and
  *      enables the ctrl+y be delivered to this code. And the ctrl+c too,
  *      which the crtl converts to SIGINT and which is caught by the common
  *      signal handler. Because signals were blocked before entering this code
  *      sys$waitfr will always complete and the SIGQUIT will be processed after
  *      it (after termination of the current block, somewhere in common code).
  *      And SIGINT too will be delayed. That is ctrl+c can only abort when the
  *      current command completes. Anyway it's better than nothing :-)
  */
+  /*
+   * Code to make ctrl+c and ctrl+y working.
+   * The problem starts with the synchronous case where after lib$spawn is
+   * called any input will go to the child. But with input re-directed,
+   * both control characters won't make it to any of the programs, neither
+   * the spawning nor to the spawned one. Hence the caller needs to spawn
+   * with CLI$M_NOWAIT to NOT give up the input focus. A sys$waitfr
+   * has to follow to simulate the wanted synchronous behaviour.
+   * The next problem is ctrl+y which isn't caught by the crtl and
+   * therefore isn't converted to SIGQUIT (for a signal handler which is
+   * already established). The only way to catch ctrl+y, is an AST
+   * assigned to the input channel. But ctrl+y handling of DCL needs to be
+   * disabled, otherwise it will handle it. Not to mention the previous
+   * ctrl+y handling of DCL needs to be re-established before make exits.
+   * One more: At the time of LIB$SPAWN signals are blocked. SIGQUIT will
+   * make it to the signal handler after the child "normally" terminates.
+   * This isn't enough. It seems reasonable for simple command lines like
+   * a 'cc foobar.c' spawned in a subprocess but it is unacceptable for
+   * spawning make. Therefore we need to abort the process in the AST.
+   *
+   * Prior to the spawn it is checked if an AST is already set up for
+   * ctrl+y, if not one is set up for a channel to SYS$COMMAND. In general
+   * this will work except if make is run in a batch environment, but there
+   * nobody can press ctrl+y. During the setup the DCL handling of ctrl+y
+   * is disabled and an exit handler is established to re-enable it.
+   * If the user interrupts with ctrl+y, the assigned AST will fire, force
+   * an abort to the subprocess and signal SIGQUIT, which will be caught by
+   * the already established handler and will bring us back to common code.
+   * After the spawn (now /nowait) a sys$waitfr simulates the /wait and
+   * enables the ctrl+y be delivered to this code. And the ctrl+c too,
+   * which the crtl converts to SIGINT and which is caught by the common
+   * signal handler. Because signals were blocked before entering this code
+   * sys$waitfr will always complete and the SIGQUIT will be processed after
+   * it (after termination of the current block, somewhere in common code).
+   * And SIGINT too will be delayed. That is ctrl+c can only abort when the
+   * current command completes. Anyway it's better than nothing :-)
+   */
   if (!setupYAstTried)
     tryToSetupYAst();
+  status = lib$spawn (&cmddsc,                                  /* cmd-string  */
+                      (ifiledsc.dsc$w_length == 0)?0:&ifiledsc, /* input-file  */
+                      (ofiledsc.dsc$w_length == 0)?0:&ofiledsc, /* output-file */
+                      &spflags,                                 /* flags  */
+                      &pnamedsc,                                /* proc name  */
+                      &child->pid, &child->cstatus, &child->efn,
+, 0,
+, 0, 0);
+  if (status & 1)
+    {
+      status= sys$waitfr (child->efn);
+      vmsHandleChildTerm(child);
+  child->vms_launch_status = lib$spawn (cmd_dsc,               /* cmd-string */
+                     NULL, /* input-file */
+                     NULL, /* output-file */
+                     &spflags,                                 /* flags */
+                     &pnamedsc,                                /* proc name */
+                     &child->pid, &child->cstatus, &child->efn,
+, 0,
+, 0, 0);
+  status = child->vms_launch_status;
+  if ($VMS_STATUS_SUCCESS (status))
+    {
+      status = sys$waitfr (child->efn);
+      vmsHandleChildTerm (child);
+    }
 #else
+  status = lib$spawn (&cmddsc,
+                      (ifiledsc.dsc$w_length == 0)?0:&ifiledsc,
+                      (ofiledsc.dsc$w_length == 0)?0:&ofiledsc,
+                      &spflags,
+                      &pnamedsc,
+                      &child->pid, &child->cstatus, &child->efn,
+                      vmsHandleChildTerm, child,
+, 0, 0);
+  child->vms_launch_status = lib$spawn (cmd_dsc,
+                      NULL,
+                      NULL,
+                      &spflags,
+                      &pnamedsc,
+                      &child->pid, &child->cstatus, &child->efn,
+                      vmsHandleChildTerm, child,
+, 0, 0);
+   status = child->vms_launch_status;
 #endif
+  if (!(status & 1))
+    {
+      printf (_("Error spawning, %d\n") ,status);
+      fflush (stdout);
+  /* Free the pointer if not a command file */
+  if (!vms_always_use_cmd_file && !token.use_cmd_file)
+    free (cmd_dsc->dsc$a_pointer);
+  free (cmd_dsc);
+  if (!$VMS_STATUS_SUCCESS (status))
+    {
       switch (status)
+        {
         case 0x1c:
+        case SS$_EXQUOTA:
           errno = EPROCLIM;
           break;
 …
+    }
+  /* Restore the VMS symbols that were changed */
+  if (child->environment != 0)
+    {
+      char **ep = child->environment;
+      while (*ep != 0)
+        {
+          vms_restore_symbol (*ep);
+          *ep++;
+        }
+    }
   return (status & 1);
+}

vendor/gnumake/current/vpath.c

-              r2596
+              r3138
 /* Implementation of pattern-matching file search paths for GNU Make.
+Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
+, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+Free Software Foundation, Inc.
+Copyright (C) 1988-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include "filedef.h"
 #include "variable.h"
 …
 struct vpath
+  {
     struct vpath *next; /* Pointer to next struct in the linked list.  */
+    struct vpath *next; /* Pointer to next struct in the linked list.  */
     const char *pattern;/* The pattern to match.  */
     const char *percent;/* Pointer into `pattern' where the `%' is.  */
+    const char *percent;/* Pointer into 'pattern' where the '%' is.  */
     unsigned int patlen;/* Length of the pattern.  */
     const char **searchpath; /* Null-terminated list of directories.  */
 …
 void
 build_vpath_lists ()
+build_vpath_lists (void)
+{
   register struct vpath *new = 0;
 …
       char gp[] = "%";
       /* Empty `vpaths' so the new one will have no next, and `vpaths'
          will still be nil if P contains no existing directories.  */
+      /* Empty 'vpaths' so the new one will have no next, and 'vpaths'
+         will still be nil if P contains no existing directories.  */
       vpaths = 0;
 …
       /* Store the created path as the general path,
          and restore the old list of vpaths.  */
+         and restore the old list of vpaths.  */
       general_vpath = vpaths;
       vpaths = save_vpaths;
 …
       char gp[] = "%";
       /* Empty `vpaths' so the new one will have no next, and `vpaths'
          will still be nil if P contains no existing directories.  */
+      /* Empty 'vpaths' so the new one will have no next, and 'vpaths'
+         will still be nil if P contains no existing directories.  */
       vpaths = 0;
 …
       /* Store the created path as the GPATH,
          and restore the old list of vpaths.  */
+         and restore the old list of vpaths.  */
       gpaths = vpaths;
       vpaths = save_vpaths;
 …
    pattern.  If PATTERN is nil, remove all VPATH listings.  Existing
    and readable directories that are not "." given in the DIRPATH
    separated by the path element separator (defined in make.h) are
+   separated by the path element separator (defined in makeint.h) are
    loaded into the directory hash table if they are not there already
    and put in the VPATH searchpath for the given pattern with trailing
 …
       path = vpaths;
       while (path != 0)
+        {
           struct vpath *next = path->next;
           if (pattern == 0
               || (((percent == 0 && path->percent == 0)
                    || (percent - pattern == path->percent - path->pattern))
                   && streq (pattern, path->pattern)))
+            {
               /* Remove it from the linked list.  */
               if (lastpath == 0)
                 vpaths = path->next;
               else
                 lastpath->next = next;
               /* Free its unused storage.  */
+        {
+          struct vpath *next = path->next;
+          if (pattern == 0
+              || (((percent == 0 && path->percent == 0)
+                   || (percent - pattern == path->percent - path->pattern))
+                  && streq (pattern, path->pattern)))
+            {
+              /* Remove it from the linked list.  */
+              if (lastpath == 0)
+                vpaths = path->next;
+              else
+                lastpath->next = next;
+              /* Free its unused storage.  */
               /* MSVC erroneously warns without a cast here.  */
               free ((void *)path->searchpath);
               free (path);
+            }
           else
             lastpath = path;
           path = next;
+        }
+              free ((void *)path->searchpath);
+              free (path);
+            }
+          else
+            lastpath = path;
+          path = next;
+        }
       return;
 …
 #ifdef WINDOWS32
     convert_vpath_to_windows32(dirpath, ';');
+    convert_vpath_to_windows32 (dirpath, ';');
 #endif
   /* Skip over any initial separators and blanks.  */
   while (*dirpath == PATH_SEPARATOR_CHAR || isblank ((unsigned char)*dirpath))
+  while (STOP_SET (*dirpath, MAP_BLANK|MAP_PATHSEP))
     ++dirpath;
 …
   p = dirpath;
   while (*p != '\0')
     if (*p++ == PATH_SEPARATOR_CHAR || isblank ((unsigned char)*p))
+    if (STOP_SET (*p++, MAP_BLANK|MAP_PATHSEP))
       ++maxelem;
 …
       while (*p != '\0'
 #if defined(HAVE_DOS_PATHS) && (PATH_SEPARATOR_CHAR == ':')
              /* Platforms whose PATH_SEPARATOR_CHAR is ':' and which
                 also define HAVE_DOS_PATHS would like us to recognize
                 colons after the drive letter in the likes of
                 "D:/foo/bar:C:/xyzzy".  */
              && (*p != PATH_SEPARATOR_CHAR
                  || (p == v + 1 && (p[1] == '/' || p[1] == '\\')))
+             /* Platforms whose PATH_SEPARATOR_CHAR is ':' and which
+                also define HAVE_DOS_PATHS would like us to recognize
+                colons after the drive letter in the likes of
+                "D:/foo/bar:C:/xyzzy".  */
+             && (*p != PATH_SEPARATOR_CHAR
+                 || (p == v + 1 && (p[1] == '/' || p[1] == '\\')))
 #else
              && *p != PATH_SEPARATOR_CHAR
 #endif
              && !isblank ((unsigned char)*p))
         ++p;
+             && *p != PATH_SEPARATOR_CHAR
+#endif
+             && !ISBLANK (*p))
+        ++p;
       len = p - v;
       /* Make sure there's no trailing slash,
          but still allow "/" as a directory.  */
+         but still allow "/" as a directory.  */
 #if defined(__MSDOS__) || defined(__EMX__) || defined(HAVE_DOS_PATHS)
       /* We need also to leave alone a trailing slash in "d:/".  */
 …
 #endif
       if (len > 1 && p[-1] == '/')
         --len;
+        --len;
       /* Put the directory on the vpath list.  */
       if (len > 1 || *v != '.')
+        {
+        {
           vpath[elem++] = dir_name (strcache_add_len (v, len));
           if (len > maxvpath)
             maxvpath = len;
+        }
+        }
       /* Skip over separators and blanks between entries.  */
       while (*p == PATH_SEPARATOR_CHAR || isblank ((unsigned char)*p))
         ++p;
+      while (STOP_SET (*p, MAP_BLANK|MAP_PATHSEP))
+        ++p;
+    }
 …
       struct vpath *path;
       /* ELEM is now incremented one element past the last
          entry, to where the nil-pointer terminator goes.
          Usually this is maxelem - 1.  If not, shrink down.  */
+         entry, to where the nil-pointer terminator goes.
+         Usually this is maxelem - 1.  If not, shrink down.  */
       if (elem < (maxelem - 1))
         vpath = xrealloc (vpath, (elem+1) * sizeof (const char *));
+        vpath = xrealloc (vpath, (elem+1) * sizeof (const char *));
       /* Put the nil-pointer terminator on the end of the VPATH list.  */
 …
 gpath_search (const char *file, unsigned int len)
+{
-  const char **gp;
   if (gpaths && (len <= gpaths->maxlen))
+    for (gp = gpaths->searchpath; *gp != NULL; ++gp)
+      if (strneq (*gp, file, len) && (*gp)[len] == '\0')
+        return 1;
+    {
+      const char **gp;
+      for (gp = gpaths->searchpath; *gp != NULL; ++gp)
+        if (strneq (*gp, file, len) && (*gp)[len] == '\0')
+          return 1;
+    }
   return 0;
 …
   unsigned int maxvpath = path->maxlen;
   unsigned int i;
   unsigned int flen, vlen, name_dplen;
+  unsigned int flen, name_dplen;
   int exists = 0;
 …
   /* We need the rightmost slash or backslash.  */
+  {
     const char *bslash = strrchr(file, '\\');
+    const char *bslash = strrchr (file, '\\');
     if (!n || bslash > n)
       n = bslash;
 …
+    {
       int exists_in_cache = 0;
+      char *p;
+      p = name;
+      char *p = name;
+      unsigned int vlen = strlen (vpath[i]);
       /* Put the next VPATH entry into NAME at P and increment P past it.  */
-      vlen = strlen (vpath[i]);
       memcpy (p, vpath[i], vlen);
       p += vlen;
 …
       /* Add the directory prefix already in *FILE.  */
       if (name_dplen > 0)
+        {
+        {
 #ifndef VMS
+          *p++ = '/';
+#endif
+          memcpy (p, file, name_dplen);
+          p += name_dplen;
+        }
+          *p++ = '/';
+#else
+          /* VMS: if this is not in VMS format, treat as Unix format */
+          if ((*p != ':') && (*p != ']') && (*p != '>'))
+            *p++ = '/';
+#endif
+          memcpy (p, file, name_dplen);
+          p += name_dplen;
+        }
 #ifdef HAVE_DOS_PATHS
       /* Cause the next if to treat backslash and slash alike.  */
       if (p != name && p[-1] == '\\' )
         p[-1] = '/';
+        p[-1] = '/';
 #endif
       /* Now add the name-within-directory at the end of NAME.  */
 #ifndef VMS
       if (p != name && p[-1] != '/')
+        {
           *p = '/';
           memcpy (p + 1, filename, flen + 1);
+        }
+        {
+          *p = '/';
+          memcpy (p + 1, filename, flen + 1);
+        }
       else
+#endif
+        memcpy (p, filename, flen + 1);
+#else
+      /* VMS use a slash if no directory terminator present */
+      if (p != name && p[-1] != '/' && p[-1] != ':' &&
+          p[-1] != '>' && p[-1] != ']')
+        {
+          *p = '/';
+          memcpy (p + 1, filename, flen + 1);
+        }
+      else
+#endif
+        memcpy (p, filename, flen + 1);
       /* Check if the file is mentioned in a makefile.  If *FILE is not
          a target, that is enough for us to decide this file exists.
          If *FILE is a target, then the file must be mentioned in the
          makefile also as a target to be chosen.
          The restriction that *FILE must not be a target for a
          makefile-mentioned file to be chosen was added by an
          inadequately commented change in July 1990; I am not sure off
          hand what problem it fixes.
          In December 1993 I loosened this restriction to allow a file
          to be chosen if it is mentioned as a target in a makefile.  This
          seem logical.
+         a target, that is enough for us to decide this file exists.
+         If *FILE is a target, then the file must be mentioned in the
+         makefile also as a target to be chosen.
+         The restriction that *FILE must not be a target for a
+         makefile-mentioned file to be chosen was added by an
+         inadequately commented change in July 1990; I am not sure off
+         hand what problem it fixes.
+         In December 1993 I loosened this restriction to allow a file
+         to be chosen if it is mentioned as a target in a makefile.  This
+         seem logical.
          Special handling for -W / -o: make sure we preserve the special
 …
       */
+      {
         struct file *f = lookup_file (name);
         if (f != 0)
+        struct file *f = lookup_file (name);
+        if (f != 0)
+          {
             exists = not_target || f->is_target;
 …
       if (!exists)
+        {
           /* That file wasn't mentioned in the makefile.
              See if it actually exists.  */
+        {
+          /* That file wasn't mentioned in the makefile.
+             See if it actually exists.  */
 #ifdef VMS
+          exists_in_cache = exists = dir_file_exists_p (vpath[i], filename);
+          /* For VMS syntax just use the original vpath */
+          if (*p != '/')
+            exists_in_cache = exists = dir_file_exists_p (vpath[i], filename);
+          else
+#endif
+            {
+              /* Clobber a null into the name at the last slash.
+                 Now NAME is the name of the directory to look in.  */
+              *p = '\0';
+              /* We know the directory is in the hash table now because either
+                 construct_vpath_list or the code just above put it there.
+                 Does the file we seek exist in it?  */
+              exists_in_cache = exists = dir_file_exists_p (name, filename);
+            }
+        }
+      if (exists)
+        {
+          /* The file is in the directory cache.
+             Now check that it actually exists in the filesystem.
+             The cache may be out of date.  When vpath thinks a file
+             exists, but stat fails for it, confusion results in the
+             higher levels.  */
+          struct stat st;
+#ifndef VMS
+          /* Put the slash back in NAME.  */
+          *p = '/';
 #else
+          /* Clobber a null into the name at the last slash.
+             Now NAME is the name of the directory to look in.  */
+          *p = '\0';
+          /* We know the directory is in the hash table now because either
+             construct_vpath_list or the code just above put it there.
+             Does the file we seek exist in it?  */
+          exists_in_cache = exists = dir_file_exists_p (name, filename);
+#endif
+        }
+      if (exists)
+        {
+          /* The file is in the directory cache.
+             Now check that it actually exists in the filesystem.
+             The cache may be out of date.  When vpath thinks a file
+             exists, but stat fails for it, confusion results in the
+             higher levels.  */
+          struct stat st;
+#ifndef VMS
+          /* Put the slash back in NAME.  */
+          *p = '/';
+#endif
+          if (exists_in_cache)  /* Makefile-mentioned file need not exist.  */
+            {
+          /* If the slash was removed, put it back */
+          if (*p == 0)
+            *p = '/';
+#endif
+          if (exists_in_cache)  /* Makefile-mentioned file need not exist.  */
+            {
               int e;
 …
           return strcache_add_len (name, (p + 1 - name) + flen);
+        }
+        }
+    }
 …
       for (i = 0; v->searchpath[i] != 0; ++i)
         printf ("%s%c", v->searchpath[i],
                 v->searchpath[i + 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR);
+        printf ("%s%c", v->searchpath[i],
+                v->searchpath[i + 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR);
+    }
   if (vpaths == 0)
     puts (_("# No `vpath' search paths."));
+    puts (_("# No 'vpath' search paths."));
   else
     printf (_("\n# %u `vpath' search paths.\n"), nvpaths);
+    printf (_("\n# %u 'vpath' search paths.\n"), nvpaths);
   if (general_vpath == 0)
     puts (_("\n# No general (`VPATH' variable) search path."));
+    puts (_("\n# No general ('VPATH' variable) search path."));
   else
+    {
 …
       unsigned int i;
       fputs (_("\n# General (`VPATH' variable) search path:\n# "), stdout);
+      fputs (_("\n# General ('VPATH' variable) search path:\n# "), stdout);
       for (i = 0; path[i] != 0; ++i)
         printf ("%s%c", path[i],
                 path[i + 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR);
+        printf ("%s%c", path[i],
+                path[i + 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR);
+    }
+}

vendor/gnumake/current/w32/Makefile.am

-              r2596
+              r3138
 # Makefile.am to create libw32.a for mingw32 host.
+# Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+# 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+# Copyright (C) 1997-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#
 …
 # this program.  If not, see <http://www.gnu.org/licenses/>.
+AUTOMAKE_OPTIONS = subdir-objects
 noinst_LIBRARIES = libw32.a
 libw32_a_SOURCES =  subproc/misc.c subproc/sub_proc.c subproc/w32err.c \
                     pathstuff.c
+                    compat/posixfcn.c pathstuff.c w32os.c
+libw32_a_CPPFLAGS = -I$(srcdir)/include -I$(srcdir)/subproc -I$(top_srcdir)
+libw32_a_CPPFLAGS = -I$(srcdir)/include -I$(srcdir)/subproc -I$(top_srcdir) \
+                    -I$(top_srcdir)/glob

vendor/gnumake/current/w32/compat/dirent.c

-              r2596
+              r3138
 /* Directory entry code for Window platforms.
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 opendir(const char* pDirName)
+{
         struct stat sb;
         DIR*    pDir;
         char*   pEndDirName;
         int     nBufferLen;
         /* sanity checks */
         if (!pDirName) {
                 errno = EINVAL;
                 return NULL;
+        }
         if (stat(pDirName, &sb) != 0) {
                 errno = ENOENT;
                 return NULL;
+        }
         if ((sb.st_mode & S_IFMT) != S_IFDIR) {
                 errno = ENOTDIR;
                 return NULL;
+        }
         /* allocate a DIR structure to return */
         pDir = (DIR *) malloc(sizeof (DIR));
         if (!pDir)
                 return NULL;
         /* input directory name length */
         nBufferLen = strlen(pDirName);
         /* copy input directory name to DIR buffer */
         strcpy(pDir->dir_pDirectoryName, pDirName);
         /* point to end of the copied directory name */
         pEndDirName = &pDir->dir_pDirectoryName[nBufferLen - 1];
         /* if directory name did not end in '/' or '\', add '/' */
         if ((*pEndDirName != '/') && (*pEndDirName != '\\')) {
                 pEndDirName++;
                 *pEndDirName = '/';
+        }
         /* now append the wildcard character to the buffer */
         pEndDirName++;
         *pEndDirName = '*';
         pEndDirName++;
         *pEndDirName = '\0';
         /* other values defaulted */
         pDir->dir_nNumFiles = 0;
         pDir->dir_hDirHandle = INVALID_HANDLE_VALUE;
         pDir->dir_ulCookie = __DIRENT_COOKIE;
         return pDir;
+        struct stat sb;
+        DIR*    pDir;
+        char*   pEndDirName;
+        int     nBufferLen;
+        /* sanity checks */
+        if (!pDirName) {
+                errno = EINVAL;
+                return NULL;
+        }
+        if (stat(pDirName, &sb) != 0) {
+                errno = ENOENT;
+                return NULL;
+        }
+        if ((sb.st_mode & S_IFMT) != S_IFDIR) {
+                errno = ENOTDIR;
+                return NULL;
+        }
+        /* allocate a DIR structure to return */
+        pDir = (DIR *) malloc(sizeof (DIR));
+        if (!pDir)
+                return NULL;
+        /* input directory name length */
+        nBufferLen = strlen(pDirName);
+        /* copy input directory name to DIR buffer */
+        strcpy(pDir->dir_pDirectoryName, pDirName);
+        /* point to end of the copied directory name */
+        pEndDirName = &pDir->dir_pDirectoryName[nBufferLen - 1];
+        /* if directory name did not end in '/' or '\', add '/' */
+        if ((*pEndDirName != '/') && (*pEndDirName != '\\')) {
+                pEndDirName++;
+                *pEndDirName = '/';
+        }
+        /* now append the wildcard character to the buffer */
+        pEndDirName++;
+        *pEndDirName = '*';
+        pEndDirName++;
+        *pEndDirName = '\0';
+        /* other values defaulted */
+        pDir->dir_nNumFiles = 0;
+        pDir->dir_hDirHandle = INVALID_HANDLE_VALUE;
+        pDir->dir_ulCookie = __DIRENT_COOKIE;
+        return pDir;
+}
 …
 closedir(DIR *pDir)
+{
         /* got a valid pointer? */
         if (!pDir) {
                 errno = EINVAL;
                 return;
+        }
         /* sanity check that this is a DIR pointer */
         if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
                 errno = EINVAL;
                 return;
+        }
         /* close the WINDOWS32 directory handle */
         if (pDir->dir_hDirHandle != INVALID_HANDLE_VALUE)
                 FindClose(pDir->dir_hDirHandle);
         free(pDir);
         return;
+        /* got a valid pointer? */
+        if (!pDir) {
+                errno = EINVAL;
+                return;
+        }
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
+                errno = EINVAL;
+                return;
+        }
+        /* close the WINDOWS32 directory handle */
+        if (pDir->dir_hDirHandle != INVALID_HANDLE_VALUE)
+                FindClose(pDir->dir_hDirHandle);
+        free(pDir);
+        return;
+}
 …
 readdir(DIR* pDir)
+{
         WIN32_FIND_DATA wfdFindData;
         if (!pDir) {
                 errno = EINVAL;
                 return NULL;
+        }
         /* sanity check that this is a DIR pointer */
         if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
                 errno = EINVAL;
                 return NULL;
+        }
         if (pDir->dir_nNumFiles == 0) {
                 pDir->dir_hDirHandle = FindFirstFile(pDir->dir_pDirectoryName, &wfdFindData);
                 if (pDir->dir_hDirHandle == INVALID_HANDLE_VALUE)
                         return NULL;
         } else if (!FindNextFile(pDir->dir_hDirHandle, &wfdFindData))
                         return NULL;
         /* bump count for next call to readdir() or telldir() */
         pDir->dir_nNumFiles++;
         /* fill in struct dirent values */
         pDir->dir_sdReturn.d_ino = (ino_t)-1;
         strcpy(pDir->dir_sdReturn.d_name, wfdFindData.cFileName);
         return &pDir->dir_sdReturn;
+        WIN32_FIND_DATA wfdFindData;
+        if (!pDir) {
+                errno = EINVAL;
+                return NULL;
+        }
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
+                errno = EINVAL;
+                return NULL;
+        }
+        if (pDir->dir_nNumFiles == 0) {
+                pDir->dir_hDirHandle = FindFirstFile(pDir->dir_pDirectoryName, &wfdFindData);
+                if (pDir->dir_hDirHandle == INVALID_HANDLE_VALUE)
+                        return NULL;
+        } else if (!FindNextFile(pDir->dir_hDirHandle, &wfdFindData))
+                        return NULL;
+        /* bump count for next call to readdir() or telldir() */
+        pDir->dir_nNumFiles++;
+        /* fill in struct dirent values */
+        pDir->dir_sdReturn.d_ino = (ino_t)-1;
+        strcpy(pDir->dir_sdReturn.d_name, wfdFindData.cFileName);
+        return &pDir->dir_sdReturn;
+}
 …
 rewinddir(DIR* pDir)
+{
         if (!pDir) {
                 errno = EINVAL;
                 return;
+        }
         /* sanity check that this is a DIR pointer */
         if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
                 errno = EINVAL;
                 return;
+        }
         /* close the WINDOWS32 directory handle */
         if (pDir->dir_hDirHandle != INVALID_HANDLE_VALUE)
                 if (!FindClose(pDir->dir_hDirHandle))
                         errno = EBADF;
         /* reset members which control readdir() */
         pDir->dir_hDirHandle = INVALID_HANDLE_VALUE;
         pDir->dir_nNumFiles = 0;
         return;
+        if (!pDir) {
+                errno = EINVAL;
+                return;
+        }
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
+                errno = EINVAL;
+                return;
+        }
+        /* close the WINDOWS32 directory handle */
+        if (pDir->dir_hDirHandle != INVALID_HANDLE_VALUE)
+                if (!FindClose(pDir->dir_hDirHandle))
+                        errno = EBADF;
+        /* reset members which control readdir() */
+        pDir->dir_hDirHandle = INVALID_HANDLE_VALUE;
+        pDir->dir_nNumFiles = 0;
+        return;
+}
 …
 telldir(DIR* pDir)
+{
         if (!pDir) {
                 errno = EINVAL;
                 return -1;
+        }
         /* sanity check that this is a DIR pointer */
         if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
                 errno = EINVAL;
                 return -1;
+        }
         /* return number of times readdir() called */
         return pDir->dir_nNumFiles;
+        if (!pDir) {
+                errno = EINVAL;
+                return -1;
+        }
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE) {
+                errno = EINVAL;
+                return -1;
+        }
+        /* return number of times readdir() called */
+        return pDir->dir_nNumFiles;
+}
 …
 seekdir(DIR* pDir, long nPosition)
+{
         if (!pDir)
                 return;
         /* sanity check that this is a DIR pointer */
         if (pDir->dir_ulCookie != __DIRENT_COOKIE)
                 return;
         /* go back to beginning of directory */
         rewinddir(pDir);
         /* loop until we have found position we care about */
         for (--nPosition; nPosition && readdir(pDir); nPosition--);
         /* flag invalid nPosition value */
         if (nPosition)
                 errno = EINVAL;
         return;
+}
+        if (!pDir)
+                return;
+        /* sanity check that this is a DIR pointer */
+        if (pDir->dir_ulCookie != __DIRENT_COOKIE)
+                return;
+        /* go back to beginning of directory */
+        rewinddir(pDir);
+        /* loop until we have found position we care about */
+        for (--nPosition; nPosition && readdir(pDir); nPosition--);
+        /* flag invalid nPosition value */
+        if (nPosition)
+                errno = EINVAL;
+        return;
+}

vendor/gnumake/current/w32/include/dirent.h

-              r2596
+              r3138
 /* Windows version of dirent.h
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 struct dirent
+{
   ino_t d_ino;                  /* unused - no equivalent on WINDOWS32 */
+  ino_t d_ino;                  /* unused - no equivalent on WINDOWS32 */
   char d_name[NAME_MAX+1];
 };
 typedef struct dir_struct {
         ULONG   dir_ulCookie;
         HANDLE  dir_hDirHandle;
         DWORD   dir_nNumFiles;
         char    dir_pDirectoryName[NAME_MAX+1];
         struct dirent dir_sdReturn;
+        ULONG   dir_ulCookie;
+        HANDLE  dir_hDirHandle;
+        DWORD   dir_nNumFiles;
+        char    dir_pDirectoryName[NAME_MAX+1];
+        struct dirent dir_sdReturn;
 } DIR;

vendor/gnumake/current/w32/include/pathstuff.h

r2596	r3138
1	1	/* Definitions for Windows path manipulation.
2		Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3		2007, 2008, 2009, 2010 Free Software Foundation, Inc.
	2	Copyright (C) 1996-2016 Free Software Foundation, Inc.
4	3	This file is part of GNU Make.
5	4

vendor/gnumake/current/w32/include/sub_proc.h

-              r2596
+              r3138
 /* Definitions for Windows process invocation.
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
  * Component Name:
+ *
  * $Date: 2010/07/13 01:20:43 $
+ * $Date$
+ *
  * $Source: /sources/make/make/w32/include/sub_proc.h,v $
+ * $Source$
+ *
  * $Id: sub_proc.h,v 1.12 2010/07/13 01:20:43 psmith Exp $
+ * $Id$
  */
 …
 EXTERN_DECL(HANDLE process_init, (VOID_DECL));
 EXTERN_DECL(HANDLE process_init_fd, (HANDLE stdinh, HANDLE stdouth,
         HANDLE stderrh));
+                                     HANDLE stderrh));
 EXTERN_DECL(long process_begin, (HANDLE proc, char **argv, char **envp,
         char *exec_path, char *as_user));
+                                 char *exec_path, char *as_user));
 EXTERN_DECL(long process_pipe_io, (HANDLE proc, char *stdin_data,
         int stdin_data_len));
+                                   int stdin_data_len));
 EXTERN_DECL(long process_file_io, (HANDLE proc));
 EXTERN_DECL(void process_cleanup, (HANDLE proc));
 EXTERN_DECL(HANDLE process_wait_for_any, (VOID_DECL));
+EXTERN_DECL(HANDLE process_wait_for_any, (int block, DWORD* pdwWaitStatus));
 EXTERN_DECL(void process_register, (HANDLE proc));
+EXTERN_DECL(HANDLE process_easy, (char** argv, char** env));
+EXTERN_DECL(HANDLE process_easy, (char** argv, char** env,
+                                  int outfd, int errfd));
 EXTERN_DECL(BOOL process_kill, (HANDLE proc, int signal));
 EXTERN_DECL(int process_used_slots, (VOID_DECL));
+EXTERN_DECL(DWORD process_set_handles, (HANDLE *handles));
 /* support routines */
 …
 EXTERN_DECL(int process_errcnt, (HANDLE proc));
 EXTERN_DECL(void process_pipes, (HANDLE proc, int pipes[3]));
+EXTERN_DECL(void process_noinherit, (int fildes));
 #endif

vendor/gnumake/current/w32/include/w32err.h

-              r2596
+              r3138
 /* Definitions for Windows error handling.
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 #endif
 EXTERN_DECL(char * map_windows32_error_to_string, (DWORD error));
+EXTERN_DECL(const char * map_windows32_error_to_string, (DWORD error));
 #endif /* !_W32ERR_H */

vendor/gnumake/current/w32/pathstuff.c

-              r2596
+              r3138
 /* Path conversion for Windows pathnames.
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
+, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "make.h"
+#include "makeint.h"
 #include <string.h>
 #include <stdlib.h>
 …
     char *etok;            /* token separator for old Path */
         /*
          * Convert all spaces to delimiters. Note that pathnames which
          * contain blanks get trounced here. Use 8.3 format as a workaround.
          */
         for (etok = Path; etok && *etok; etok++)
                 if (isblank ((unsigned char) *etok))
                         *etok = to_delim;
         return (convert_Path_to_windows32(Path, to_delim));
+        /*
+         * Convert all spaces to delimiters. Note that pathnames which
+         * contain blanks get trounced here. Use 8.3 format as a workaround.
+         */
+        for (etok = Path; etok && *etok; etok++)
+                if (ISBLANK ((unsigned char) *etok))
+                        *etok = to_delim;
+        return (convert_Path_to_windows32(Path, to_delim));
+}
 …
                 *etok = to_delim;
                 p = ++etok;
             } else
+            } else
                 p += strlen(p);
         } else {
 …
 getcwd_fs(char* buf, int len)
+{
         char *p = getcwd(buf, len);
         if (p) {
                 char *q = w32ify(buf, 0);
                 strncpy(buf, q, len);
+        }
         return p;
+        char *p = getcwd(buf, len);
+        if (p) {
+                char *q = w32ify(buf, 0);
+                strncpy(buf, q, len);
+        }
+        return p;
+}

vendor/gnumake/current/w32/subproc/NMakefile

-              r2596
+              r3138
 # NOTE: If you have no `make' program at all to process this makefile, run
 # `build.bat' instead.
+# NOTE: If you have no 'make' program at all to process this makefile, run
+# 'build.bat' instead.
+#
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+# 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+# Copyright (C) 1996-2016 Free Software Foundation, Inc.
 # This file is part of GNU Make.
+#

vendor/gnumake/current/w32/subproc/misc.c

-              r2596
+              r3138
 /* Process handling for Windows
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 /*
  * Description:  Convert a NULL string terminated UNIX environment block to
  *              an environment block suitable for a windows32 system call
+ *              an environment block suitable for a windows32 system call
+ *
  * Returns:  TRUE= success, FALSE=fail
+ *
  * Notes/Dependencies:  the environment block is sorted in case-insensitive
  *      order, is double-null terminated, and is a char *, not a char **
+ *      order, is double-null terminated, and is a char *, not a char **
  */
 int _cdecl compare(const void *a1, const void *a2)
+{
         return _stricoll(*((char**)a1),*((char**)a2));
+        return _stricoll(*((char**)a1),*((char**)a2));
+}
 bool_t
 arr2envblk(char **arr, char **envblk_out)
+arr2envblk(char **arr, char **envblk_out, int *envsize_needed)
+{
         char **tmp;
         int size_needed;
         int arrcnt;
         char *ptr;
+        char **tmp;
+        int size_needed;
+        int arrcnt;
+        char *ptr;
         arrcnt = 0;
         while (arr[arrcnt]) {
                 arrcnt++;
+        }
+        arrcnt = 0;
+        while (arr[arrcnt]) {
+                arrcnt++;
+        }
         tmp = (char**) calloc(arrcnt + 1, sizeof(char *));
         if (!tmp) {
                 return FALSE;
+        }
+        tmp = (char**) calloc(arrcnt + 1, sizeof(char *));
+        if (!tmp) {
+                return FALSE;
+        }
+        arrcnt = 0;
+        size_needed = 0;
+        while (arr[arrcnt]) {
+                tmp[arrcnt] = arr[arrcnt];
+                size_needed += strlen(arr[arrcnt]) + 1;
+                arrcnt++;
+        }
+        size_needed++;
+        arrcnt = 0;
+        size_needed = *envsize_needed = 0;
+        while (arr[arrcnt]) {
+                tmp[arrcnt] = arr[arrcnt];
+                size_needed += strlen(arr[arrcnt]) + 1;
+                arrcnt++;
+        }
+        size_needed++;
+        *envsize_needed = size_needed;
         qsort((void *) tmp, (size_t) arrcnt, sizeof (char*), compare);
+        qsort((void *) tmp, (size_t) arrcnt, sizeof (char*), compare);
         ptr = *envblk_out = calloc(size_needed, 1);
         if (!ptr) {
                 free(tmp);
                 return FALSE;
+        }
+        ptr = *envblk_out = calloc(size_needed, 1);
+        if (!ptr) {
+                free(tmp);
+                return FALSE;
+        }
         arrcnt = 0;
         while (tmp[arrcnt]) {
                 strcpy(ptr, tmp[arrcnt]);
                 ptr += strlen(tmp[arrcnt]) + 1;
                 arrcnt++;
+        }
+        arrcnt = 0;
+        while (tmp[arrcnt]) {
+                strcpy(ptr, tmp[arrcnt]);
+                ptr += strlen(tmp[arrcnt]) + 1;
+                arrcnt++;
+        }
         free(tmp);
         return TRUE;
+        free(tmp);
+        return TRUE;
+}

vendor/gnumake/current/w32/subproc/proc.h

-              r2596
+              r3138
 /* Definitions for Windows
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 typedef int bool_t;
 #define E_SCALL         101
 #define E_IO            102
 #define E_NO_MEM        103
 #define E_FORK          104
+#define E_SCALL         101
+#define E_IO            102
+#define E_NO_MEM        103
+#define E_FORK          104
 extern bool_t arr2envblk(char **arr, char **envblk_out);
+extern bool_t arr2envblk(char **arr, char **envblk_out, int *envsize_needed);
 #endif

vendor/gnumake/current/w32/subproc/sub_proc.c

-              r2596
+              r3138
 /* Process handling for Windows.
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 #include <stdlib.h>
 #include <stdio.h>
+#include <io.h>         /* for _get_osfhandle */
 #ifdef _MSC_VER
 # include <stddef.h>    /* for intptr_t */
 …
 # include <stdint.h>
 #endif
+#include <string.h>
 #include <process.h>  /* for msvc _beginthreadex, _endthreadex */
 #include <signal.h>
 #include <windows.h>
+#include "makeint.h"
+#include "filedef.h"
+#include "variable.h"
 #include "sub_proc.h"
 #include "proc.h"
 …
 static char *make_command_line(char *shell_name, char *exec_path, char **argv);
-extern char *xmalloc (unsigned int);
 typedef struct sub_process_t {
         intptr_t sv_stdin[2];
         intptr_t sv_stdout[2];
         intptr_t sv_stderr[2];
         int using_pipes;
         char *inp;
         DWORD incnt;
         char * volatile outp;
         volatile DWORD outcnt;
         char * volatile errp;
         volatile DWORD errcnt;
         pid_t pid;
         int exit_code;
         int signal;
         long last_err;
         long lerrno;
+        intptr_t sv_stdin[2];
+        intptr_t sv_stdout[2];
+        intptr_t sv_stderr[2];
+        int using_pipes;
+        char *inp;
+        DWORD incnt;
+        char * volatile outp;
+        volatile DWORD outcnt;
+        char * volatile errp;
+        volatile DWORD errcnt;
+        pid_t pid;
+        int exit_code;
+        int signal;
+        long last_err;
+        long lerrno;
 } sub_process;
 …
 static int proc_index = 0;
 static int fake_exits_pending = 0;
+/*
+ * Fill a HANDLE list with handles to wait for.
+ */
+DWORD
+process_set_handles(HANDLE *handles)
+{
+    DWORD count = 0;
+    int i;
+    /* Build array of handles to wait for */
+    for (i = 0; i < proc_index; i++) {
+        /* Don't wait on child processes that have already finished */
+        if (fake_exits_pending && proc_array[i]->exit_code)
+            continue;
+        handles[count++] = (HANDLE) proc_array[i]->pid;
+    }
+    return count;
+}
 /*
 …
 process_adjust_wait_state(sub_process* pproc)
+{
         int i;
         if (!proc_index)
                 return;
         for (i = 0; i < proc_index; i++)
                 if (proc_array[i]->pid == pproc->pid)
                         break;
         if (i < proc_index) {
                 proc_index--;
                 if (i != proc_index)
                         memmove(&proc_array[i], &proc_array[i+1],
                                 (proc_index-i) * sizeof(sub_process*));
                 proc_array[proc_index] = NULL;
+        }
+        int i;
+        if (!proc_index)
+                return;
+        for (i = 0; i < proc_index; i++)
+                if (proc_array[i]->pid == pproc->pid)
+                        break;
+        if (i < proc_index) {
+                proc_index--;
+                if (i != proc_index)
+                        memmove(&proc_array[i], &proc_array[i+1],
+                                (proc_index-i) * sizeof(sub_process*));
+                proc_array[proc_index] = NULL;
+        }
+}
 …
  */
 static sub_process *
+process_wait_for_any_private(void)
+{
+        HANDLE handles[MAXIMUM_WAIT_OBJECTS];
+        DWORD retval, which;
+        int i;
+        if (!proc_index)
+                return NULL;
+        /* build array of handles to wait for */
+        for (i = 0; i < proc_index; i++) {
+                handles[i] = (HANDLE) proc_array[i]->pid;
+                if (fake_exits_pending && proc_array[i]->exit_code)
+                        break;
+        }
+        /* wait for someone to exit */
+        if (!fake_exits_pending) {
+                retval = WaitForMultipleObjects(proc_index, handles, FALSE, INFINITE);
+                which = retval - WAIT_OBJECT_0;
+        } else {
+                fake_exits_pending--;
+                retval = !WAIT_FAILED;
+                which = i;
+        }
+        /* return pointer to process */
+        if (retval != WAIT_FAILED) {
+                sub_process* pproc = proc_array[which];
+                process_adjust_wait_state(pproc);
+                return pproc;
+        } else
+                return NULL;
+process_wait_for_any_private(int block, DWORD* pdwWaitStatus)
+{
+        HANDLE handles[MAXIMUM_WAIT_OBJECTS];
+        DWORD retval, which;
+        int i;
+        if (!proc_index)
+                return NULL;
+        /* build array of handles to wait for */
+        for (i = 0; i < proc_index; i++) {
+                handles[i] = (HANDLE) proc_array[i]->pid;
+                if (fake_exits_pending && proc_array[i]->exit_code)
+                        break;
+        }
+        /* wait for someone to exit */
+        if (!fake_exits_pending) {
+                retval = WaitForMultipleObjects(proc_index, handles, FALSE, (block ? INFINITE : 0));
+                which = retval - WAIT_OBJECT_0;
+        } else {
+                fake_exits_pending--;
+                retval = !WAIT_FAILED;
+                which = i;
+        }
+        /* If the pointer is not NULL, set the wait status result variable. */
+        if (pdwWaitStatus)
+            *pdwWaitStatus = retval;
+        /* return pointer to process */
+        if ((retval == WAIT_TIMEOUT) || (retval == WAIT_FAILED)) {
+                return NULL;
+        }
+        else {
+                sub_process* pproc = proc_array[which];
+                process_adjust_wait_state(pproc);
+                return pproc;
+        }
+}
 …
 process_kill(HANDLE proc, int signal)
+{
         sub_process* pproc = (sub_process*) proc;
         pproc->signal = signal;
         return (TerminateProcess((HANDLE) pproc->pid, signal));
+        sub_process* pproc = (sub_process*) proc;
+        pproc->signal = signal;
+        return (TerminateProcess((HANDLE) pproc->pid, signal));
+}
 …
 process_register(HANDLE proc)
+{
         if (proc_index < MAXIMUM_WAIT_OBJECTS)
                 proc_array[proc_index++] = (sub_process *) proc;
+        if (proc_index < MAXIMUM_WAIT_OBJECTS)
+                proc_array[proc_index++] = (sub_process *) proc;
+}
 …
 process_used_slots(void)
+{
         return proc_index;
+        return proc_index;
+}
 …
  * you must do 1 of things:
+ *
  *      x = process_easy(...);
+ *      x = process_easy(...);
+ *
  * or
+ *
  *      x = process_init_fd();
  *      process_register(x);
+ *      x = process_init_fd();
+ *      process_register(x);
+ *
  * or
+ *
  *      x = process_init();
  *      process_register(x);
+ *      x = process_init();
+ *      process_register(x);
+ *
  * You must NOT then call process_pipe_io() because this function is
 …
 HANDLE
 process_wait_for_any(void)
+{
         sub_process* pproc = process_wait_for_any_private();
         if (!pproc)
                 return NULL;
         else {
                 /*
                  * Ouch! can't tell caller if this fails directly. Caller
                  * will have to use process_last_err()
+process_wait_for_any(int block, DWORD* pdwWaitStatus)
+{
+        sub_process* pproc = process_wait_for_any_private(block, pdwWaitStatus);
+        if (!pproc)
+                return NULL;
+        else {
+                /*
+                 * Ouch! can't tell caller if this fails directly. Caller
+                 * will have to use process_last_err()
                  */
                 (void) process_file_io(pproc);
                 return ((HANDLE) pproc);
+        }
+                (void) process_file_io(pproc);
+                return ((HANDLE) pproc);
+        }
+}
 …
+{
         if (proc == INVALID_HANDLE_VALUE) return ERROR_INVALID_HANDLE;
         return (((sub_process *)proc)->last_err);
+        return (((sub_process *)proc)->last_err);
+}
 …
+{
         if (proc == INVALID_HANDLE_VALUE) return EXIT_FAILURE;
+        return (((sub_process *)proc)->exit_code);
+        return (((sub_process *)proc)->exit_code);
+}
+void
+process_noinherit(int fd)
+{
+  HANDLE fh = (HANDLE)_get_osfhandle(fd);
+  if (fh && fh != INVALID_HANDLE_VALUE)
+        SetHandleInformation(fh, HANDLE_FLAG_INHERIT, 0);
+}
 …
 process_outbuf(HANDLE proc)
+{
         return (((sub_process *)proc)->outp);
+        return (((sub_process *)proc)->outp);
+}
 …
 process_errbuf(HANDLE proc)
+{
         return (((sub_process *)proc)->errp);
+        return (((sub_process *)proc)->errp);
+}
 …
 process_outcnt(HANDLE proc)
+{
         return (((sub_process *)proc)->outcnt);
+        return (((sub_process *)proc)->outcnt);
+}
 …
 process_errcnt(HANDLE proc)
+{
         return (((sub_process *)proc)->errcnt);
+        return (((sub_process *)proc)->errcnt);
+}
 …
 process_pipes(HANDLE proc, int pipes[3])
+{
         pipes[0] = ((sub_process *)proc)->sv_stdin[0];
         pipes[1] = ((sub_process *)proc)->sv_stdout[0];
         pipes[2] = ((sub_process *)proc)->sv_stderr[0];
         return;
+        pipes[0] = ((sub_process *)proc)->sv_stdin[0];
+        pipes[1] = ((sub_process *)proc)->sv_stdout[0];
+        pipes[2] = ((sub_process *)proc)->sv_stderr[0];
+        return;
+}
 */
         HANDLE
+        HANDLE
 process_init()
+{
         sub_process *pproc;
         /*
          * open file descriptors for attaching stdin/stdout/sterr
          */
         HANDLE stdin_pipes[2];
         HANDLE stdout_pipes[2];
         HANDLE stderr_pipes[2];
         SECURITY_ATTRIBUTES inherit;
         BYTE sd[SECURITY_DESCRIPTOR_MIN_LENGTH];
         pproc = malloc(sizeof(*pproc));
         memset(pproc, 0, sizeof(*pproc));
         /* We can't use NULL for lpSecurityDescriptor because that
            uses the default security descriptor of the calling process.
            Instead we use a security descriptor with no DACL.  This
            allows nonrestricted access to the associated objects. */
         if (!InitializeSecurityDescriptor((PSECURITY_DESCRIPTOR)(&sd),
                                           SECURITY_DESCRIPTOR_REVISION)) {
                 pproc->last_err = GetLastError();
                 pproc->lerrno = E_SCALL;
                 return((HANDLE)pproc);
+        }
         inherit.nLength = sizeof(inherit);
         inherit.lpSecurityDescriptor = (PSECURITY_DESCRIPTOR)(&sd);
         inherit.bInheritHandle = TRUE;
         // By convention, parent gets pipe[0], and child gets pipe[1]
         // This means the READ side of stdin pipe goes into pipe[1]
         // and the WRITE side of the stdout and stderr pipes go into pipe[1]
         if (CreatePipe( &stdin_pipes[1], &stdin_pipes[0], &inherit, 0) == FALSE ||
         CreatePipe( &stdout_pipes[0], &stdout_pipes[1], &inherit, 0) == FALSE ||
         CreatePipe( &stderr_pipes[0], &stderr_pipes[1], &inherit, 0) == FALSE) {
                 pproc->last_err = GetLastError();
                 pproc->lerrno = E_SCALL;
                 return((HANDLE)pproc);
+        }
         //
         // Mark the parent sides of the pipes as non-inheritable
         //
         if (SetHandleInformation(stdin_pipes[0],
                                 HANDLE_FLAG_INHERIT, 0) == FALSE ||
                 SetHandleInformation(stdout_pipes[0],
                                 HANDLE_FLAG_INHERIT, 0) == FALSE ||
                 SetHandleInformation(stderr_pipes[0],
                                 HANDLE_FLAG_INHERIT, 0) == FALSE) {
                 pproc->last_err = GetLastError();
                 pproc->lerrno = E_SCALL;
                 return((HANDLE)pproc);
+        }
         pproc->sv_stdin[0]  = (intptr_t) stdin_pipes[0];
         pproc->sv_stdin[1]  = (intptr_t) stdin_pipes[1];
         pproc->sv_stdout[0] = (intptr_t) stdout_pipes[0];
         pproc->sv_stdout[1] = (intptr_t) stdout_pipes[1];
         pproc->sv_stderr[0] = (intptr_t) stderr_pipes[0];
         pproc->sv_stderr[1] = (intptr_t) stderr_pipes[1];
         pproc->using_pipes = 1;
         pproc->lerrno = 0;
         return((HANDLE)pproc);
+}
         HANDLE
+        sub_process *pproc;
+        /*
+         * open file descriptors for attaching stdin/stdout/sterr
+         */
+        HANDLE stdin_pipes[2];
+        HANDLE stdout_pipes[2];
+        HANDLE stderr_pipes[2];
+        SECURITY_ATTRIBUTES inherit;
+        BYTE sd[SECURITY_DESCRIPTOR_MIN_LENGTH];
+        pproc = malloc(sizeof(*pproc));
+        memset(pproc, 0, sizeof(*pproc));
+        /* We can't use NULL for lpSecurityDescriptor because that
+           uses the default security descriptor of the calling process.
+           Instead we use a security descriptor with no DACL.  This
+           allows nonrestricted access to the associated objects. */
+        if (!InitializeSecurityDescriptor((PSECURITY_DESCRIPTOR)(&sd),
+                                          SECURITY_DESCRIPTOR_REVISION)) {
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                return((HANDLE)pproc);
+        }
+        inherit.nLength = sizeof(inherit);
+        inherit.lpSecurityDescriptor = (PSECURITY_DESCRIPTOR)(&sd);
+        inherit.bInheritHandle = TRUE;
+        // By convention, parent gets pipe[0], and child gets pipe[1]
+        // This means the READ side of stdin pipe goes into pipe[1]
+        // and the WRITE side of the stdout and stderr pipes go into pipe[1]
+        if (CreatePipe( &stdin_pipes[1], &stdin_pipes[0], &inherit, 0) == FALSE ||
+        CreatePipe( &stdout_pipes[0], &stdout_pipes[1], &inherit, 0) == FALSE ||
+        CreatePipe( &stderr_pipes[0], &stderr_pipes[1], &inherit, 0) == FALSE) {
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                return((HANDLE)pproc);
+        }
+        //
+        // Mark the parent sides of the pipes as non-inheritable
+        //
+        if (SetHandleInformation(stdin_pipes[0],
+                                HANDLE_FLAG_INHERIT, 0) == FALSE ||
+                SetHandleInformation(stdout_pipes[0],
+                                HANDLE_FLAG_INHERIT, 0) == FALSE ||
+                SetHandleInformation(stderr_pipes[0],
+                                HANDLE_FLAG_INHERIT, 0) == FALSE) {
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                return((HANDLE)pproc);
+        }
+        pproc->sv_stdin[0]  = (intptr_t) stdin_pipes[0];
+        pproc->sv_stdin[1]  = (intptr_t) stdin_pipes[1];
+        pproc->sv_stdout[0] = (intptr_t) stdout_pipes[0];
+        pproc->sv_stdout[1] = (intptr_t) stdout_pipes[1];
+        pproc->sv_stderr[0] = (intptr_t) stderr_pipes[0];
+        pproc->sv_stderr[1] = (intptr_t) stderr_pipes[1];
+        pproc->using_pipes = 1;
+        pproc->lerrno = 0;
+        return((HANDLE)pproc);
+}
+        HANDLE
 process_init_fd(HANDLE stdinh, HANDLE stdouth, HANDLE stderrh)
+{
+        sub_process *pproc;
+        pproc = malloc(sizeof(*pproc));
+        memset(pproc, 0, sizeof(*pproc));
+        /*
+         * Just pass the provided file handles to the 'child side' of the
+         * pipe, bypassing pipes altogether.
+         */
+        pproc->sv_stdin[1]  = (intptr_t) stdinh;
+        pproc->sv_stdout[1] = (intptr_t) stdouth;
+        pproc->sv_stderr[1] = (intptr_t) stderrh;
+        pproc->last_err = pproc->lerrno = 0;
+        return((HANDLE)pproc);
+        sub_process *pproc;
+        pproc = malloc(sizeof(*pproc));
+        if (pproc) {
+                memset(pproc, 0, sizeof(*pproc));
+                /*
+                 * Just pass the provided file handles to the 'child
+                 * side' of the pipe, bypassing pipes altogether.
+                 */
+                pproc->sv_stdin[1]  = (intptr_t) stdinh;
+                pproc->sv_stdout[1] = (intptr_t) stdouth;
+                pproc->sv_stderr[1] = (intptr_t) stderrh;
+                pproc->last_err = pproc->lerrno = 0;
+        }
+        return((HANDLE)pproc);
+}
 …
 static HANDLE
 find_file(const char *exec_path, const char *path_var,
+          char *full_fname, DWORD full_len)
+{
+        HANDLE exec_handle;
+        char *fname;
+        char *ext;
+        DWORD req_len;
+        int i;
+        static const char *extensions[] =
+          /* Should .com come before no-extension case?  */
+          { ".exe", ".cmd", ".bat", "", ".com", NULL };
+        fname = xmalloc(strlen(exec_path) + 5);
+        strcpy(fname, exec_path);
+        ext = fname + strlen(fname);
+        for (i = 0; extensions[i]; i++) {
+                strcpy(ext, extensions[i]);
+                if (((req_len = SearchPath (path_var, fname, NULL, full_len,
+                                            full_fname, NULL)) > 0
+                     /* For compatibility with previous code, which
+                        used OpenFile, and with Windows operation in
+                        general, also look in various default
+                        locations, such as Windows directory and
+                        Windows System directory.  Warning: this also
+                        searches PATH in the Make's environment, which
+                        might not be what the Makefile wants, but it
+                        seems to be OK as a fallback, after the
+                        previous SearchPath failed to find on child's
+                        PATH.  */
+                     || (req_len = SearchPath (NULL, fname, NULL, full_len,
+                                               full_fname, NULL)) > 0)
+                    && req_len <= full_len
+                    && (exec_handle =
+                                CreateFile(full_fname,
+                                           GENERIC_READ,
+                                           FILE_SHARE_READ | FILE_SHARE_WRITE,
+                                           NULL,
+                                           OPEN_EXISTING,
+                                           FILE_ATTRIBUTE_NORMAL,
+                                           NULL)) != INVALID_HANDLE_VALUE) {
+                        free(fname);
+                        return(exec_handle);
+                }
+        }
+        free(fname);
+        return INVALID_HANDLE_VALUE;
+          char *full_fname, DWORD full_len)
+{
+        HANDLE exec_handle;
+        char *fname;
+        char *ext;
+        DWORD req_len;
+        int i;
+        static const char *extensions[] =
+          /* Should .com come before no-extension case?  */
+          { ".exe", ".cmd", ".bat", "", ".com", NULL };
+        fname = xmalloc(strlen(exec_path) + 5);
+        strcpy(fname, exec_path);
+        ext = fname + strlen(fname);
+        for (i = 0; extensions[i]; i++) {
+                strcpy(ext, extensions[i]);
+                if (((req_len = SearchPath (path_var, fname, NULL, full_len,
+                                            full_fname, NULL)) > 0
+                     /* For compatibility with previous code, which
+                        used OpenFile, and with Windows operation in
+                        general, also look in various default
+                        locations, such as Windows directory and
+                        Windows System directory.  Warning: this also
+                        searches PATH in the Make's environment, which
+                        might not be what the Makefile wants, but it
+                        seems to be OK as a fallback, after the
+                        previous SearchPath failed to find on child's
+                        PATH.  */
+                     || (req_len = SearchPath (NULL, fname, NULL, full_len,
+                                               full_fname, NULL)) > 0)
+                    && req_len <= full_len
+                    && (exec_handle =
+                                CreateFile(full_fname,
+                                           GENERIC_READ,
+                                           FILE_SHARE_READ | FILE_SHARE_WRITE,
+                                           NULL,
+                                           OPEN_EXISTING,
+                                           FILE_ATTRIBUTE_NORMAL,
+                                           NULL)) != INVALID_HANDLE_VALUE) {
+                        free(fname);
+                        return(exec_handle);
+                }
+        }
+        free(fname);
+        return INVALID_HANDLE_VALUE;
+}
+/*
+ * Return non-zero of FNAME specifies a batch file and its name
+ * includes embedded whitespace.
+ */
+static int
+batch_file_with_spaces(const char *fname)
+{
+        size_t fnlen = strlen(fname);
+        return (fnlen > 4
+                && (_strnicmp(fname + fnlen - 4, ".bat", 4) == 0
+                    || _strnicmp(fname + fnlen - 4, ".cmd", 4) == 0)
+                /* The set of characters in the 2nd arg to strpbrk
+                   should be the same one used by make_command_line
+                   below to decide whether an argv[] element needs
+                   quoting.  */
+                && strpbrk(fname, " \t") != NULL);
+}
 …
 long
 process_begin(
+        HANDLE proc,
+        char **argv,
+        char **envp,
+        char *exec_path,
+        char *as_user)
+{
+        sub_process *pproc = (sub_process *)proc;
+        char *shell_name = 0;
+        int file_not_found=0;
+        HANDLE exec_handle;
+        char exec_fname[MAX_PATH];
+        const char *path_var = NULL;
+        char **ep;
+        char buf[256];
+        DWORD bytes_returned;
+        DWORD flags;
+        char *command_line;
+        STARTUPINFO startInfo;
+        PROCESS_INFORMATION procInfo;
+        char *envblk=NULL;
+        /*
+         *  Shell script detection...  if the exec_path starts with #! then
+         *  we want to exec shell-script-name exec-path, not just exec-path
+         *  NT doesn't recognize #!/bin/sh or #!/etc/Tivoli/bin/perl.  We do not
+         *  hard-code the path to the shell or perl or whatever:  Instead, we
+         *  assume it's in the path somewhere (generally, the NT tools
+         *  bin directory)
+         */
+        /* Use the Makefile's value of PATH to look for the program to
+           execute, because it could be different from Make's PATH
+           (e.g., if the target sets its own value.  */
+        if (envp)
+                for (ep = envp; *ep; ep++) {
+                        if (strncmp (*ep, "PATH=", 5) == 0
+                            || strncmp (*ep, "Path=", 5) == 0) {
+                                path_var = *ep + 5;
+                                break;
+                        }
+                }
+        exec_handle = find_file(exec_path, path_var,
+                                exec_fname, sizeof(exec_fname));
+        /*
+         * If we couldn't open the file, just assume that Windows will be
+         * somehow able to find and execute it.
+         */
+        if (exec_handle == INVALID_HANDLE_VALUE) {
+                file_not_found++;
+        }
+        else {
+                /* Attempt to read the first line of the file */
+                if (ReadFile( exec_handle,
+                                buf, sizeof(buf) - 1, /* leave room for trailing NULL */
+                                &bytes_returned, 0) == FALSE || bytes_returned < 2) {
+                        pproc->last_err = GetLastError();
+                        pproc->lerrno = E_IO;
+                        CloseHandle(exec_handle);
+                        return(-1);
+                }
+                if (buf[0] == '#' && buf[1] == '!') {
+                        /*
+                         *  This is a shell script...  Change the command line from
+                         *      exec_path args to shell_name exec_path args
+                         */
+                        char *p;
+                        /*  Make sure buf is NULL terminated */
+                        buf[bytes_returned] = 0;
+                        /*
+                         * Depending on the file system type, etc. the first line
+                         * of the shell script may end with newline or newline-carriage-return
+                         * Whatever it ends with, cut it off.
+                         */
+                        p= strchr(buf, '\n');
+                        if (p)
+                                *p = 0;
+                        p = strchr(buf, '\r');
+                        if (p)
+                                *p = 0;
+                        /*
+                         *  Find base name of shell
+                         */
+                        shell_name = strrchr( buf, '/');
+                        if (shell_name) {
+                                shell_name++;
+                        } else {
+                                shell_name = &buf[2];/* skipping "#!" */
+                        }
+                }
+                CloseHandle(exec_handle);
+        }
+        flags = 0;
+        if (file_not_found)
+                command_line = make_command_line( shell_name, exec_path, argv);
+        else
+                command_line = make_command_line( shell_name, exec_fname, argv);
+        if ( command_line == NULL ) {
+                pproc->last_err = 0;
+                pproc->lerrno = E_NO_MEM;
+                return(-1);
+        }
+        if (envp) {
+                if (arr2envblk(envp, &envblk) ==FALSE) {
+                        pproc->last_err = 0;
+                        pproc->lerrno = E_NO_MEM;
+                        free( command_line );
+                        return(-1);
+                }
+        }
+        if ((shell_name) || (file_not_found)) {
+                exec_path = 0;  /* Search for the program in %Path% */
+        } else {
+                exec_path = exec_fname;
+        }
+        /*
+         *  Set up inherited stdin, stdout, stderr for child
+         */
+        GetStartupInfo(&startInfo);
+        startInfo.dwFlags = STARTF_USESTDHANDLES;
+        startInfo.lpReserved = 0;
+        startInfo.cbReserved2 = 0;
+        startInfo.lpReserved2 = 0;
+        startInfo.lpTitle = shell_name ? shell_name : exec_path;
+        startInfo.hStdInput = (HANDLE)pproc->sv_stdin[1];
+        startInfo.hStdOutput = (HANDLE)pproc->sv_stdout[1];
+        startInfo.hStdError = (HANDLE)pproc->sv_stderr[1];
+        if (as_user) {
+                if (envblk) free(envblk);
+                return -1;
+        } else {
+                DB (DB_JOBS, ("CreateProcess(%s,%s,...)\n",
+                        exec_path ? exec_path : "NULL",
+                        command_line ? command_line : "NULL"));
+                if (CreateProcess(
+                        exec_path,
+                        command_line,
+                        NULL,
+, /* default security attributes for thread */
+                        TRUE, /* inherit handles (e.g. helper pipes, oserv socket) */
+                        flags,
+                        envblk,
+, /* default starting directory */
+                        &startInfo,
+                        &procInfo) == FALSE) {
+                        pproc->last_err = GetLastError();
+                        pproc->lerrno = E_FORK;
+                        fprintf(stderr, "process_begin: CreateProcess(%s, %s, ...) failed.\n",
+        HANDLE proc,
+        char **argv,
+        char **envp,
+        char *exec_path,
+        char *as_user)
+{
+        sub_process *pproc = (sub_process *)proc;
+        char *shell_name = 0;
+        int file_not_found=0;
+        HANDLE exec_handle;
+        char exec_fname[MAX_PATH];
+        const char *path_var = NULL;
+        char **ep;
+        char buf[MAX_PATH];
+        DWORD bytes_returned;
+        DWORD flags;
+        char *command_line;
+        STARTUPINFO startInfo;
+        PROCESS_INFORMATION procInfo;
+        char *envblk=NULL;
+        int envsize_needed = 0;
+        int pass_null_exec_path = 0;
+        /*
+         *  Shell script detection...  if the exec_path starts with #! then
+         *  we want to exec shell-script-name exec-path, not just exec-path
+         *  NT doesn't recognize #!/bin/sh or #!/etc/Tivoli/bin/perl.  We do not
+         *  hard-code the path to the shell or perl or whatever:  Instead, we
+         *  assume it's in the path somewhere (generally, the NT tools
+         *  bin directory)
+         */
+        /* Use the Makefile's value of PATH to look for the program to
+           execute, because it could be different from Make's PATH
+           (e.g., if the target sets its own value.  */
+        if (envp)
+                for (ep = envp; *ep; ep++) {
+                        if (strncmp (*ep, "PATH=", 5) == 0
+                            || strncmp (*ep, "Path=", 5) == 0) {
+                                path_var = *ep + 5;
+                                break;
+                        }
+                }
+        exec_handle = find_file(exec_path, path_var,
+                                exec_fname, sizeof(exec_fname));
+        /*
+         * If we couldn't open the file, just assume that Windows will be
+         * somehow able to find and execute it.  If the first character
+         * of the command is '/', assume they set SHELL to a Unixy shell
+         * that have some magic mounts known only to it, and run the whole
+         * command via $SHELL -c "COMMAND" instead.
+         */
+        if (exec_handle == INVALID_HANDLE_VALUE) {
+                if (exec_path[0] == '/') {
+                        char *new_argv0;
+                        char **argvi = argv;
+                        int arglen = 0;
+                        strcpy(buf, variable_expand ("$(SHELL)"));
+                        shell_name = &buf[0];
+                        strcpy(exec_fname, "-c");
+                        /* Construct a single command string in argv[0].  */
+                        while (*argvi) {
+                                arglen += strlen(*argvi) + 1;
+                                argvi++;
+                        }
+                        new_argv0 = xmalloc(arglen + 1);
+                        new_argv0[0] = '\0';
+                        for (argvi = argv; *argvi; argvi++) {
+                                strcat(new_argv0, *argvi);
+                                strcat(new_argv0, " ");
+                        }
+                        /* Remove the extra blank at the end.  */
+                        new_argv0[arglen-1] = '\0';
+                        free(argv[0]);
+                        argv[0] = new_argv0;
+                        argv[1] = NULL;
+                }
+                else
+                        file_not_found++;
+        }
+        else {
+                /* Attempt to read the first line of the file */
+                if (ReadFile( exec_handle,
+                                buf, sizeof(buf) - 1, /* leave room for trailing NULL */
+                                &bytes_returned, 0) == FALSE || bytes_returned < 2) {
+                        pproc->last_err = GetLastError();
+                        pproc->lerrno = E_IO;
+                        CloseHandle(exec_handle);
+                        return(-1);
+                }
+                if (buf[0] == '#' && buf[1] == '!') {
+                        /*
+                         *  This is a shell script...  Change the command line from
+                         *      exec_path args to shell_name exec_path args
+                         */
+                        char *p;
+                        /*  Make sure buf is NULL terminated */
+                        buf[bytes_returned] = 0;
+                        /*
+                         * Depending on the file system type, etc. the first line
+                         * of the shell script may end with newline or newline-carriage-return
+                         * Whatever it ends with, cut it off.
+                         */
+                        p= strchr(buf, '\n');
+                        if (p)
+                                *p = 0;
+                        p = strchr(buf, '\r');
+                        if (p)
+                                *p = 0;
+                        /*
+                         *  Find base name of shell
+                         */
+                        shell_name = strrchr( buf, '/');
+                        if (shell_name) {
+                                shell_name++;
+                        } else {
+                                shell_name = &buf[2];/* skipping "#!" */
+                        }
+                }
+                CloseHandle(exec_handle);
+        }
+        flags = 0;
+        if (file_not_found)
+                command_line = make_command_line( shell_name, exec_path, argv);
+        else {
+                /* If exec_fname includes whitespace, CreateProcess
+                   behaves erratically and unreliably, and often fails
+                   if argv[0] also includes whitespace (and thus will
+                   be quoted by make_command_line below).  So in that
+                   case, we don't pass exec_fname as the 1st arg to
+                   CreateProcess, but instead replace argv[0] with
+                   exec_fname (to keep its leading directories and
+                   extension as found by find_file), and pass NULL to
+                   CreateProcess as its 1st arg.  This works around
+                   the bugs in CreateProcess, which are probably
+                   caused by its passing the command to cmd.exe with
+                   some incorrect quoting.  */
+                if (!shell_name
+                    && batch_file_with_spaces(exec_fname)
+                    && _stricmp(exec_path, argv[0]) == 0) {
+                        char *new_argv, *p;
+                        char **argvi;
+                        int arglen, i;
+                        pass_null_exec_path = 1;
+                        /* Rewrite argv[] replacing argv[0] with exec_fname.  */
+                        for (argvi = argv + 1, arglen = strlen(exec_fname) + 1;
+                             *argvi;
+                             argvi++) {
+                                arglen += strlen(*argvi) + 1;
+                        }
+                        new_argv = xmalloc(arglen);
+                        p = strcpy(new_argv, exec_fname) + strlen(exec_fname) + 1;
+                        for (argvi = argv + 1, i = 1; *argvi; argvi++, i++) {
+                                strcpy(p, *argvi);
+                                argv[i] = p;
+                                p += strlen(*argvi) + 1;
+                        }
+                        argv[i] = NULL;
+                        free (argv[0]);
+                        argv[0] = new_argv;
+                }
+                command_line = make_command_line( shell_name, exec_fname, argv);
+        }
+        if ( command_line == NULL ) {
+                pproc->last_err = 0;
+                pproc->lerrno = E_NO_MEM;
+                return(-1);
+        }
+        if (envp) {
+                if (arr2envblk(envp, &envblk, &envsize_needed) == FALSE) {
+                        pproc->lerrno = E_NO_MEM;
+                        free( command_line );
+                        if ((pproc->last_err == ERROR_INVALID_PARAMETER
+                             || pproc->last_err == ERROR_MORE_DATA)
+                            && envsize_needed > 32*1024) {
+                                fprintf (stderr, "CreateProcess failed, probably because environment is too large (%d bytes).\n",
+                                         envsize_needed);
+                        }
+                        pproc->last_err = 0;
+                        return(-1);
+                }
+        }
+        if (shell_name || file_not_found || pass_null_exec_path) {
+                exec_path = 0;  /* Search for the program in %Path% */
+        } else {
+                exec_path = exec_fname;
+        }
+        /*
+         *  Set up inherited stdin, stdout, stderr for child
+         */
+        memset(&startInfo, '\0', sizeof(startInfo));
+        GetStartupInfo(&startInfo);
+        startInfo.dwFlags = STARTF_USESTDHANDLES;
+        startInfo.lpReserved = 0;
+        startInfo.cbReserved2 = 0;
+        startInfo.lpReserved2 = 0;
+        startInfo.hStdInput = (HANDLE)pproc->sv_stdin[1];
+        startInfo.hStdOutput = (HANDLE)pproc->sv_stdout[1];
+        startInfo.hStdError = (HANDLE)pproc->sv_stderr[1];
+        if (as_user) {
+                free(envblk);
+                return -1;
+        } else {
+                DB (DB_JOBS, ("CreateProcess(%s,%s,...)\n",
+                        exec_path ? exec_path : "NULL",
+                        command_line ? command_line : "NULL"));
+                if (CreateProcess(
+                        exec_path,
+                        command_line,
+                        NULL,
+, /* default security attributes for thread */
+                        TRUE, /* inherit handles (e.g. helper pipes, oserv socket) */
+                        flags,
+                        envblk,
+, /* default starting directory */
+                        &startInfo,
+                        &procInfo) == FALSE) {
+                        pproc->last_err = GetLastError();
+                        pproc->lerrno = E_FORK;
+                        fprintf(stderr, "process_begin: CreateProcess(%s, %s, ...) failed.\n",
                                 exec_path ? exec_path : "NULL", command_line);
+                        if (envblk) free(envblk);
+                        free( command_line );
+                        return(-1);
+                }
+        }
+        pproc->pid = (pid_t)procInfo.hProcess;
+        /* Close the thread handle -- we'll just watch the process */
+        CloseHandle(procInfo.hThread);
+        /* Close the halves of the pipes we don't need */
+        CloseHandle((HANDLE)pproc->sv_stdin[1]);
+        CloseHandle((HANDLE)pproc->sv_stdout[1]);
+        CloseHandle((HANDLE)pproc->sv_stderr[1]);
+                        free(envblk);
+                        free( command_line );
+                        return(-1);
+                }
+        }
+        pproc->pid = (pid_t)procInfo.hProcess;
+        /* Close the thread handle -- we'll just watch the process */
+        CloseHandle(procInfo.hThread);
+        /* Close the halves of the pipes we don't need */
+        if ((HANDLE)pproc->sv_stdin[1] != INVALID_HANDLE_VALUE)
+          CloseHandle((HANDLE)pproc->sv_stdin[1]);
+        if ((HANDLE)pproc->sv_stdout[1] != INVALID_HANDLE_VALUE)
+          CloseHandle((HANDLE)pproc->sv_stdout[1]);
+        if ((HANDLE)pproc->sv_stderr[1] != INVALID_HANDLE_VALUE)
+          CloseHandle((HANDLE)pproc->sv_stderr[1]);
         pproc->sv_stdin[1] = 0;
         pproc->sv_stdout[1] = 0;
         pproc->sv_stderr[1] = 0;
+        free( command_line );
+        if (envblk) free(envblk);
+        pproc->lerrno=0;
+        return 0;
+}
+        free( command_line );
+        free(envblk);
+        pproc->lerrno=0;
+        return 0;
+}
+#if 0   /* unused */
 static DWORD
 proc_stdin_thread(sub_process *pproc)
+{
         DWORD in_done;
         for (;;) {
                 if (WriteFile( (HANDLE) pproc->sv_stdin[0], pproc->inp, pproc->incnt,
                                          &in_done, NULL) == FALSE)
                         _endthreadex(0);
                 // This if should never be true for anonymous pipes, but gives
                 // us a chance to change I/O mechanisms later
                 if (in_done < pproc->incnt) {
                         pproc->incnt -= in_done;
                         pproc->inp += in_done;
                 } else {
                         _endthreadex(0);
+                }
+        }
         return 0; // for compiler warnings only.. not reached
+        DWORD in_done;
+        for (;;) {
+                if (WriteFile( (HANDLE) pproc->sv_stdin[0], pproc->inp, pproc->incnt,
+                                         &in_done, NULL) == FALSE)
+                        _endthreadex(0);
+                // This if should never be true for anonymous pipes, but gives
+                // us a chance to change I/O mechanisms later
+                if (in_done < pproc->incnt) {
+                        pproc->incnt -= in_done;
+                        pproc->inp += in_done;
+                } else {
+                        _endthreadex(0);
+                }
+        }
+        return 0; // for compiler warnings only.. not reached
+}
 …
 proc_stdout_thread(sub_process *pproc)
+{
         DWORD bufsize = 1024;
         char c;
         DWORD nread;
         pproc->outp = malloc(bufsize);
         if (pproc->outp == NULL)
                 _endthreadex(0);
         pproc->outcnt = 0;
         for (;;) {
                 if (ReadFile( (HANDLE)pproc->sv_stdout[0], &c, 1, &nread, NULL)
                                         == FALSE) {
 /*                      map_windows32_error_to_string(GetLastError());*/
                         _endthreadex(0);
+                }
                 if (nread == 0)
                         _endthreadex(0);
                 if (pproc->outcnt + nread > bufsize) {
                         bufsize += nread + 512;
                         pproc->outp = realloc(pproc->outp, bufsize);
                         if (pproc->outp == NULL) {
                                 pproc->outcnt = 0;
                                 _endthreadex(0);
+                        }
+                }
                 pproc->outp[pproc->outcnt++] = c;
+        }
         return 0;
+        DWORD bufsize = 1024;
+        char c;
+        DWORD nread;
+        pproc->outp = malloc(bufsize);
+        if (pproc->outp == NULL)
+                _endthreadex(0);
+        pproc->outcnt = 0;
+        for (;;) {
+                if (ReadFile( (HANDLE)pproc->sv_stdout[0], &c, 1, &nread, NULL)
+                                        == FALSE) {
+/*                      map_windows32_error_to_string(GetLastError());*/
+                        _endthreadex(0);
+                }
+                if (nread == 0)
+                        _endthreadex(0);
+                if (pproc->outcnt + nread > bufsize) {
+                        bufsize += nread + 512;
+                        pproc->outp = realloc(pproc->outp, bufsize);
+                        if (pproc->outp == NULL) {
+                                pproc->outcnt = 0;
+                                _endthreadex(0);
+                        }
+                }
+                pproc->outp[pproc->outcnt++] = c;
+        }
+        return 0;
+}
 …
 proc_stderr_thread(sub_process *pproc)
+{
         DWORD bufsize = 1024;
         char c;
         DWORD nread;
         pproc->errp = malloc(bufsize);
         if (pproc->errp == NULL)
                 _endthreadex(0);
         pproc->errcnt = 0;
         for (;;) {
                 if (ReadFile( (HANDLE)pproc->sv_stderr[0], &c, 1, &nread, NULL) == FALSE) {
                         map_windows32_error_to_string(GetLastError());
                         _endthreadex(0);
+                }
                 if (nread == 0)
                         _endthreadex(0);
                 if (pproc->errcnt + nread > bufsize) {
                         bufsize += nread + 512;
                         pproc->errp = realloc(pproc->errp, bufsize);
                         if (pproc->errp == NULL) {
                                 pproc->errcnt = 0;
                                 _endthreadex(0);
+                        }
+                }
                 pproc->errp[pproc->errcnt++] = c;
+        }
         return 0;
+        DWORD bufsize = 1024;
+        char c;
+        DWORD nread;
+        pproc->errp = malloc(bufsize);
+        if (pproc->errp == NULL)
+                _endthreadex(0);
+        pproc->errcnt = 0;
+        for (;;) {
+                if (ReadFile( (HANDLE)pproc->sv_stderr[0], &c, 1, &nread, NULL) == FALSE) {
+                        map_windows32_error_to_string(GetLastError());
+                        _endthreadex(0);
+                }
+                if (nread == 0)
+                        _endthreadex(0);
+                if (pproc->errcnt + nread > bufsize) {
+                        bufsize += nread + 512;
+                        pproc->errp = realloc(pproc->errp, bufsize);
+                        if (pproc->errp == NULL) {
+                                pproc->errcnt = 0;
+                                _endthreadex(0);
+                        }
+                }
+                pproc->errp[pproc->errcnt++] = c;
+        }
+        return 0;
+}
 …
  * Notes/Dependencies:
  */
         long
+        long
 process_pipe_io(
         HANDLE proc,
         char *stdin_data,
         int stdin_data_len)
+{
         sub_process *pproc = (sub_process *)proc;
         bool_t stdin_eof = FALSE, stdout_eof = FALSE, stderr_eof = FALSE;
         HANDLE childhand = (HANDLE) pproc->pid;
         HANDLE tStdin = NULL, tStdout = NULL, tStderr = NULL;
         unsigned int dwStdin, dwStdout, dwStderr;
         HANDLE wait_list[4];
         DWORD wait_count;
         DWORD wait_return;
         HANDLE ready_hand;
         bool_t child_dead = FALSE;
         BOOL GetExitCodeResult;
         /*
          *  Create stdin thread, if needed
          */
         pproc->inp = stdin_data;
         pproc->incnt = stdin_data_len;
         if (!pproc->inp) {
                 stdin_eof = TRUE;
                 CloseHandle((HANDLE)pproc->sv_stdin[0]);
                 pproc->sv_stdin[0] = 0;
         } else {
                 tStdin = (HANDLE) _beginthreadex( 0, 1024,
                         (unsigned (__stdcall *) (void *))proc_stdin_thread,
                                                   pproc, 0, &dwStdin);
                 if (tStdin == 0) {
                         pproc->last_err = GetLastError();
                         pproc->lerrno = E_SCALL;
                         goto done;
+                }
+        }
         /*
          *   Assume child will produce stdout and stderr
          */
         tStdout = (HANDLE) _beginthreadex( 0, 1024,
                 (unsigned (__stdcall *) (void *))proc_stdout_thread, pproc, 0,
                 &dwStdout);
         tStderr = (HANDLE) _beginthreadex( 0, 1024,
                 (unsigned (__stdcall *) (void *))proc_stderr_thread, pproc, 0,
                 &dwStderr);
         if (tStdout == 0 || tStderr == 0) {
                 pproc->last_err = GetLastError();
                 pproc->lerrno = E_SCALL;
                 goto done;
+        }
         /*
          *  Wait for all I/O to finish and for the child process to exit
          */
         while (!stdin_eof || !stdout_eof || !stderr_eof || !child_dead) {
                 wait_count = 0;
                 if (!stdin_eof) {
                         wait_list[wait_count++] = tStdin;
+                }
                 if (!stdout_eof) {
                         wait_list[wait_count++] = tStdout;
+                }
                 if (!stderr_eof) {
                         wait_list[wait_count++] = tStderr;
+                }
                 if (!child_dead) {
                         wait_list[wait_count++] = childhand;
+                }
                 wait_return = WaitForMultipleObjects(wait_count, wait_list,
                          FALSE, /* don't wait for all: one ready will do */
                          child_dead? 1000 :INFINITE); /* after the child dies, subthreads have
                                 one second to collect all remaining output */
                 if (wait_return == WAIT_FAILED) {
 /*                      map_windows32_error_to_string(GetLastError());*/
                         pproc->last_err = GetLastError();
                         pproc->lerrno = E_SCALL;
                         goto done;
+                }
                 ready_hand = wait_list[wait_return - WAIT_OBJECT_0];
                 if (ready_hand == tStdin) {
                         CloseHandle((HANDLE)pproc->sv_stdin[0]);
                         pproc->sv_stdin[0] = 0;
                         CloseHandle(tStdin);
                         tStdin = 0;
                         stdin_eof = TRUE;
                 } else if (ready_hand == tStdout) {
                         CloseHandle((HANDLE)pproc->sv_stdout[0]);
                         pproc->sv_stdout[0] = 0;
                         CloseHandle(tStdout);
                         tStdout = 0;
                         stdout_eof = TRUE;
                 } else if (ready_hand == tStderr) {
                         CloseHandle((HANDLE)pproc->sv_stderr[0]);
                         pproc->sv_stderr[0] = 0;
                         CloseHandle(tStderr);
                         tStderr = 0;
                         stderr_eof = TRUE;
                 } else if (ready_hand == childhand) {
                         DWORD ierr;
                         GetExitCodeResult = GetExitCodeProcess(childhand, &ierr);
                         if (ierr == CONTROL_C_EXIT) {
                                 pproc->signal = SIGINT;
                         } else {
                                 pproc->exit_code = ierr;
+                        }
                         if (GetExitCodeResult == FALSE) {
                                 pproc->last_err = GetLastError();
                                 pproc->lerrno = E_SCALL;
                                 goto done;
+                        }
                         child_dead = TRUE;
                 } else {
                         /* ?? Got back a handle we didn't query ?? */
                         pproc->last_err = 0;
                         pproc->lerrno = E_FAIL;
                         goto done;
+                }
+        }
+        HANDLE proc,
+        char *stdin_data,
+        int stdin_data_len)
+{
+        sub_process *pproc = (sub_process *)proc;
+        bool_t stdin_eof = FALSE, stdout_eof = FALSE, stderr_eof = FALSE;
+        HANDLE childhand = (HANDLE) pproc->pid;
+        HANDLE tStdin = NULL, tStdout = NULL, tStderr = NULL;
+        unsigned int dwStdin, dwStdout, dwStderr;
+        HANDLE wait_list[4];
+        DWORD wait_count;
+        DWORD wait_return;
+        HANDLE ready_hand;
+        bool_t child_dead = FALSE;
+        BOOL GetExitCodeResult;
+        /*
+         *  Create stdin thread, if needed
+         */
+        pproc->inp = stdin_data;
+        pproc->incnt = stdin_data_len;
+        if (!pproc->inp) {
+                stdin_eof = TRUE;
+                CloseHandle((HANDLE)pproc->sv_stdin[0]);
+                pproc->sv_stdin[0] = 0;
+        } else {
+                tStdin = (HANDLE) _beginthreadex( 0, 1024,
+                        (unsigned (__stdcall *) (void *))proc_stdin_thread,
+                                                  pproc, 0, &dwStdin);
+                if (tStdin == 0) {
+                        pproc->last_err = GetLastError();
+                        pproc->lerrno = E_SCALL;
+                        goto done;
+                }
+        }
+        /*
+         *   Assume child will produce stdout and stderr
+         */
+        tStdout = (HANDLE) _beginthreadex( 0, 1024,
+                (unsigned (__stdcall *) (void *))proc_stdout_thread, pproc, 0,
+                &dwStdout);
+        tStderr = (HANDLE) _beginthreadex( 0, 1024,
+                (unsigned (__stdcall *) (void *))proc_stderr_thread, pproc, 0,
+                &dwStderr);
+        if (tStdout == 0 || tStderr == 0) {
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                goto done;
+        }
+        /*
+         *  Wait for all I/O to finish and for the child process to exit
+         */
+        while (!stdin_eof || !stdout_eof || !stderr_eof || !child_dead) {
+                wait_count = 0;
+                if (!stdin_eof) {
+                        wait_list[wait_count++] = tStdin;
+                }
+                if (!stdout_eof) {
+                        wait_list[wait_count++] = tStdout;
+                }
+                if (!stderr_eof) {
+                        wait_list[wait_count++] = tStderr;
+                }
+                if (!child_dead) {
+                        wait_list[wait_count++] = childhand;
+                }
+                wait_return = WaitForMultipleObjects(wait_count, wait_list,
+                         FALSE, /* don't wait for all: one ready will do */
+                         child_dead? 1000 :INFINITE); /* after the child dies, subthreads have
+                                one second to collect all remaining output */
+                if (wait_return == WAIT_FAILED) {
+/*                      map_windows32_error_to_string(GetLastError());*/
+                        pproc->last_err = GetLastError();
+                        pproc->lerrno = E_SCALL;
+                        goto done;
+                }
+                ready_hand = wait_list[wait_return - WAIT_OBJECT_0];
+                if (ready_hand == tStdin) {
+                        CloseHandle((HANDLE)pproc->sv_stdin[0]);
+                        pproc->sv_stdin[0] = 0;
+                        CloseHandle(tStdin);
+                        tStdin = 0;
+                        stdin_eof = TRUE;
+                } else if (ready_hand == tStdout) {
+                        CloseHandle((HANDLE)pproc->sv_stdout[0]);
+                        pproc->sv_stdout[0] = 0;
+                        CloseHandle(tStdout);
+                        tStdout = 0;
+                        stdout_eof = TRUE;
+                } else if (ready_hand == tStderr) {
+                        CloseHandle((HANDLE)pproc->sv_stderr[0]);
+                        pproc->sv_stderr[0] = 0;
+                        CloseHandle(tStderr);
+                        tStderr = 0;
+                        stderr_eof = TRUE;
+                } else if (ready_hand == childhand) {
+                        DWORD ierr;
+                        GetExitCodeResult = GetExitCodeProcess(childhand, &ierr);
+                        if (ierr == CONTROL_C_EXIT) {
+                                pproc->signal = SIGINT;
+                        } else {
+                                pproc->exit_code = ierr;
+                        }
+                        if (GetExitCodeResult == FALSE) {
+                                pproc->last_err = GetLastError();
+                                pproc->lerrno = E_SCALL;
+                                goto done;
+                        }
+                        child_dead = TRUE;
+                } else {
+                        /* ?? Got back a handle we didn't query ?? */
+                        pproc->last_err = 0;
+                        pproc->lerrno = E_FAIL;
+                        goto done;
+                }
+        }
  done:
+        if (tStdin != 0)
+                CloseHandle(tStdin);
+        if (tStdout != 0)
+                CloseHandle(tStdout);
+        if (tStderr != 0)
+                CloseHandle(tStderr);
+        if (pproc->lerrno)
+                return(-1);
+        else
+                return(0);
+}
+        if (tStdin != 0)
+                CloseHandle(tStdin);
+        if (tStdout != 0)
+                CloseHandle(tStdout);
+        if (tStderr != 0)
+                CloseHandle(tStderr);
+        if (pproc->lerrno)
+                return(-1);
+        else
+                return(0);
+}
+#endif  /* unused */
 /*
 …
  * Notes/Dependencies:
  */
         long
+        long
 process_file_io(
         HANDLE proc)
+{
         sub_process *pproc;
         HANDLE childhand;
         DWORD wait_return;
         BOOL GetExitCodeResult;
+        HANDLE proc)
+{
+        sub_process *pproc;
+        HANDLE childhand;
+        DWORD wait_return;
+        BOOL GetExitCodeResult;
         DWORD ierr;
         if (proc == NULL)
                 pproc = process_wait_for_any_private();
         else
                 pproc = (sub_process *)proc;
         /* some sort of internal error */
         if (!pproc)
                 return -1;
         childhand = (HANDLE) pproc->pid;
         /*
          * This function is poorly named, and could also be used just to wait
          * for child death if you're doing your own pipe I/O.  If that is
          * the case, close the pipe handles here.
          */
         if (pproc->sv_stdin[0]) {
                 CloseHandle((HANDLE)pproc->sv_stdin[0]);
                 pproc->sv_stdin[0] = 0;
+        }
         if (pproc->sv_stdout[0]) {
                 CloseHandle((HANDLE)pproc->sv_stdout[0]);
                 pproc->sv_stdout[0] = 0;
+        }
         if (pproc->sv_stderr[0]) {
                 CloseHandle((HANDLE)pproc->sv_stderr[0]);
                 pproc->sv_stderr[0] = 0;
+        }
         /*
          *  Wait for the child process to exit
          */
         wait_return = WaitForSingleObject(childhand, INFINITE);
         if (wait_return != WAIT_OBJECT_0) {
 /*              map_windows32_error_to_string(GetLastError());*/
                 pproc->last_err = GetLastError();
                 pproc->lerrno = E_SCALL;
                 goto done2;
+        }
         GetExitCodeResult = GetExitCodeProcess(childhand, &ierr);
         if (ierr == CONTROL_C_EXIT) {
                 pproc->signal = SIGINT;
         } else {
                 pproc->exit_code = ierr;
+        }
         if (GetExitCodeResult == FALSE) {
                 pproc->last_err = GetLastError();
                 pproc->lerrno = E_SCALL;
+        }
+        if (proc == NULL)
+                pproc = process_wait_for_any_private(1, 0);
+        else
+                pproc = (sub_process *)proc;
+        /* some sort of internal error */
+        if (!pproc)
+                return -1;
+        childhand = (HANDLE) pproc->pid;
+        /*
+         * This function is poorly named, and could also be used just to wait
+         * for child death if you're doing your own pipe I/O.  If that is
+         * the case, close the pipe handles here.
+         */
+        if (pproc->sv_stdin[0]) {
+                CloseHandle((HANDLE)pproc->sv_stdin[0]);
+                pproc->sv_stdin[0] = 0;
+        }
+        if (pproc->sv_stdout[0]) {
+                CloseHandle((HANDLE)pproc->sv_stdout[0]);
+                pproc->sv_stdout[0] = 0;
+        }
+        if (pproc->sv_stderr[0]) {
+                CloseHandle((HANDLE)pproc->sv_stderr[0]);
+                pproc->sv_stderr[0] = 0;
+        }
+        /*
+         *  Wait for the child process to exit
+         */
+        wait_return = WaitForSingleObject(childhand, INFINITE);
+        if (wait_return != WAIT_OBJECT_0) {
+/*              map_windows32_error_to_string(GetLastError());*/
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+                goto done2;
+        }
+        GetExitCodeResult = GetExitCodeProcess(childhand, &ierr);
+        if (ierr == CONTROL_C_EXIT) {
+                pproc->signal = SIGINT;
+        } else {
+                pproc->exit_code = ierr;
+        }
+        if (GetExitCodeResult == FALSE) {
+                pproc->last_err = GetLastError();
+                pproc->lerrno = E_SCALL;
+        }
 done2:
         if (pproc->lerrno)
                 return(-1);
         else
                 return(0);
+        if (pproc->lerrno)
+                return(-1);
+        else
+                return(0);
+}
 …
 /*
  * Description:  Clean up any leftover handles, etc.  It is up to the
  * caller to manage and free the input, ouput, and stderr buffers.
+ * caller to manage and free the input, output, and stderr buffers.
  */
         void
+        void
 process_cleanup(
+        HANDLE proc)
+{
+        sub_process *pproc = (sub_process *)proc;
+        int i;
+        if (pproc->using_pipes) {
+                for (i= 0; i <= 1; i++) {
+                        if ((HANDLE)pproc->sv_stdin[i])
+                                CloseHandle((HANDLE)pproc->sv_stdin[i]);
+                        if ((HANDLE)pproc->sv_stdout[i])
+                                CloseHandle((HANDLE)pproc->sv_stdout[i]);
+                        if ((HANDLE)pproc->sv_stderr[i])
+                                CloseHandle((HANDLE)pproc->sv_stderr[i]);
+                }
+        }
+        if ((HANDLE)pproc->pid)
+                CloseHandle((HANDLE)pproc->pid);
+        free(pproc);
+        HANDLE proc)
+{
+        sub_process *pproc = (sub_process *)proc;
+        int i;
+        if (pproc->using_pipes) {
+                for (i= 0; i <= 1; i++) {
+                        if ((HANDLE)pproc->sv_stdin[i]
+                            && (HANDLE)pproc->sv_stdin[i] != INVALID_HANDLE_VALUE)
+                                CloseHandle((HANDLE)pproc->sv_stdin[i]);
+                        if ((HANDLE)pproc->sv_stdout[i]
+                            && (HANDLE)pproc->sv_stdout[i] != INVALID_HANDLE_VALUE)
+                                CloseHandle((HANDLE)pproc->sv_stdout[i]);
+                        if ((HANDLE)pproc->sv_stderr[i]
+                            && (HANDLE)pproc->sv_stderr[i] != INVALID_HANDLE_VALUE)
+                                CloseHandle((HANDLE)pproc->sv_stderr[i]);
+                }
+        }
+        if ((HANDLE)pproc->pid)
+                CloseHandle((HANDLE)pproc->pid);
+        free(pproc);
+}
 …
 /*
  * Description:
  *       Create a command line buffer to pass to CreateProcess
+ *       Create a command line buffer to pass to CreateProcess
+ *
  * Returns:  the buffer or NULL for failure
  *      Shell case:  sh_name a:/full/path/to/script argv[1] argv[2] ...
+ *      Shell case:  sh_name a:/full/path/to/script argv[1] argv[2] ...
  *  Otherwise:   argv[0] argv[1] argv[2] ...
+ *
 …
 make_command_line( char *shell_name, char *full_exec_path, char **argv)
+{
         int             argc = 0;
         char**          argvi;
         int*            enclose_in_quotes = NULL;
         int*            enclose_in_quotes_i;
         unsigned int    bytes_required = 0;
         char*           command_line;
         char*           command_line_i;
         int  cygwin_mode = 0; /* HAVE_CYGWIN_SHELL */
         int have_sh = 0; /* HAVE_CYGWIN_SHELL */
+        int             argc = 0;
+        char**          argvi;
+        int*            enclose_in_quotes = NULL;
+        int*            enclose_in_quotes_i;
+        unsigned int    bytes_required = 0;
+        char*           command_line;
+        char*           command_line_i;
+        int  cygwin_mode = 0; /* HAVE_CYGWIN_SHELL */
+        int have_sh = 0; /* HAVE_CYGWIN_SHELL */
 #ifdef HAVE_CYGWIN_SHELL
         have_sh = (shell_name != NULL || strstr(full_exec_path, "sh.exe"));
         cygwin_mode = 1;
+        have_sh = (shell_name != NULL || strstr(full_exec_path, "sh.exe"));
+        cygwin_mode = 1;
 #endif
+        if (shell_name && full_exec_path) {
+                bytes_required
+                  = strlen(shell_name) + 1 + strlen(full_exec_path);
+                /*
+                 * Skip argv[0] if any, when shell_name is given.
+                 */
+                if (*argv) argv++;
+                /*
+                 * Add one for the intervening space.
+                 */
+                if (*argv) bytes_required++;
+        }
+        argvi = argv;
+        while (*(argvi++)) argc++;
+        if (argc) {
+                enclose_in_quotes = (int*) calloc(1, argc * sizeof(int));
+                if (!enclose_in_quotes) {
+                        return NULL;
+                }
+        }
+        /* We have to make one pass through each argv[i] to see if we need
+         * to enclose it in ", so we might as well figure out how much
+         * memory we'll need on the same pass.
+         */
+        argvi = argv;
+        enclose_in_quotes_i = enclose_in_quotes;
+        while(*argvi) {
+                char* p = *argvi;
+                unsigned int backslash_count = 0;
+                /*
+                 * We have to enclose empty arguments in ".
+                 */
+                if (!(*p)) *enclose_in_quotes_i = 1;
+                while(*p) {
+                        switch (*p) {
+                        case '\"':
+                                /*
+                                 * We have to insert a backslash for each "
+                                 * and each \ that precedes the ".
+                                 */
+                                bytes_required += (backslash_count + 1);
+                                backslash_count = 0;
+                                break;
+        if (shell_name && full_exec_path) {
+                bytes_required
+                  = strlen(shell_name) + 1 + strlen(full_exec_path);
+                /*
+                 * Skip argv[0] if any, when shell_name is given.
+                 * The special case of "-c" in full_exec_path means
+                 * argv[0] is not the shell name, but the command string
+                 * to pass to the shell.
+                 */
+                if (*argv && strcmp(full_exec_path, "-c")) argv++;
+                /*
+                 * Add one for the intervening space.
+                 */
+                if (*argv) bytes_required++;
+        }
+        argvi = argv;
+        while (*(argvi++)) argc++;
+        if (argc) {
+                enclose_in_quotes = (int*) calloc(1, argc * sizeof(int));
+                if (!enclose_in_quotes) {
+                        return NULL;
+                }
+        }
+        /* We have to make one pass through each argv[i] to see if we need
+         * to enclose it in ", so we might as well figure out how much
+         * memory we'll need on the same pass.
+         */
+        argvi = argv;
+        enclose_in_quotes_i = enclose_in_quotes;
+        while(*argvi) {
+                char* p = *argvi;
+                unsigned int backslash_count = 0;
+                /*
+                 * We have to enclose empty arguments in ".
+                 */
+                if (!(*p)) *enclose_in_quotes_i = 1;
+                while(*p) {
+                        switch (*p) {
+                        case '\"':
+                                /*
+                                 * We have to insert a backslash for each "
+                                 * and each \ that precedes the ".
+                                 */
+                                bytes_required += (backslash_count + 1);
+                                backslash_count = 0;
+                                break;
 #if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
                         case '\\':
                                 backslash_count++;
                                 break;
+                        case '\\':
+                                backslash_count++;
+                                break;
 #endif
         /*
          * At one time we set *enclose_in_quotes_i for '*' or '?' to suppress
          * wildcard expansion in programs linked with MSVC's SETARGV.OBJ so
          * that argv in always equals argv out. This was removed.  Say you have
          * such a program named glob.exe.  You enter
          * glob '*'
          * at the sh command prompt.  Obviously the intent is to make glob do the
          * wildcarding instead of sh.  If we set *enclose_in_quotes_i for '*' or '?',
          * then the command line that glob would see would be
          * glob "*"
          * and the _setargv in SETARGV.OBJ would _not_ expand the *.
          */
                         case ' ':
                         case '\t':
                                 *enclose_in_quotes_i = 1;
                                 /* fall through */
                         default:
                                 backslash_count = 0;
                                 break;
+                        }
                         /*
                          * Add one for each character in argv[i].
                          */
                         bytes_required++;
                         p++;
+                }
                 if (*enclose_in_quotes_i) {
                         /*
                          * Add one for each enclosing ",
                          * and one for each \ that precedes the
                          * closing ".
                          */
                         bytes_required += (backslash_count + 2);
+                }
                 /*
                  * Add one for the intervening space.
                  */
                 if (*(++argvi)) bytes_required++;
                 enclose_in_quotes_i++;
+        }
         /*
          * Add one for the terminating NULL.
          */
         bytes_required++;
         command_line = (char*) malloc(bytes_required);
         if (!command_line) {
                 if (enclose_in_quotes) free(enclose_in_quotes);
                 return NULL;
+        }
         command_line_i = command_line;
         if (shell_name && full_exec_path) {
                 while(*shell_name) {
                         *(command_line_i++) = *(shell_name++);
+                }
                 *(command_line_i++) = ' ';
                 while(*full_exec_path) {
                         *(command_line_i++) = *(full_exec_path++);
+                }
                 if (*argv) {
                         *(command_line_i++) = ' ';
+                }
+        }
         argvi = argv;
         enclose_in_quotes_i = enclose_in_quotes;
         while(*argvi) {
                 char* p = *argvi;
                 unsigned int backslash_count = 0;
                 if (*enclose_in_quotes_i) {
                         *(command_line_i++) = '\"';
+                }
                 while(*p) {
                         if (*p == '\"') {
                                 if (cygwin_mode && have_sh) { /* HAVE_CYGWIN_SHELL */
                                         /* instead of a \", cygwin likes "" */
                                         *(command_line_i++) = '\"';
                                 } else {
                                 /*
                                  * We have to insert a backslash for the "
                                  * and each \ that precedes the ".
                                  */
                                 backslash_count++;
                                 while(backslash_count) {
                                         *(command_line_i++) = '\\';
                                         backslash_count--;
                                 };
+                                }
+        /*
+         * At one time we set *enclose_in_quotes_i for '*' or '?' to suppress
+         * wildcard expansion in programs linked with MSVC's SETARGV.OBJ so
+         * that argv in always equals argv out. This was removed.  Say you have
+         * such a program named glob.exe.  You enter
+         * glob '*'
+         * at the sh command prompt.  Obviously the intent is to make glob do the
+         * wildcarding instead of sh.  If we set *enclose_in_quotes_i for '*' or '?',
+         * then the command line that glob would see would be
+         * glob "*"
+         * and the _setargv in SETARGV.OBJ would _not_ expand the *.
+         */
+                        case ' ':
+                        case '\t':
+                                *enclose_in_quotes_i = 1;
+                                /* fall through */
+                        default:
+                                backslash_count = 0;
+                                break;
+                        }
+                        /*
+                         * Add one for each character in argv[i].
+                         */
+                        bytes_required++;
+                        p++;
+                }
+                if (*enclose_in_quotes_i) {
+                        /*
+                         * Add one for each enclosing ",
+                         * and one for each \ that precedes the
+                         * closing ".
+                         */
+                        bytes_required += (backslash_count + 2);
+                }
+                /*
+                 * Add one for the intervening space.
+                 */
+                if (*(++argvi)) bytes_required++;
+                enclose_in_quotes_i++;
+        }
+        /*
+         * Add one for the terminating NULL.
+         */
+        bytes_required++;
+        command_line = (char*) malloc(bytes_required);
+        if (!command_line) {
+                free(enclose_in_quotes);
+                return NULL;
+        }
+        command_line_i = command_line;
+        if (shell_name && full_exec_path) {
+                while(*shell_name) {
+                        *(command_line_i++) = *(shell_name++);
+                }
+                *(command_line_i++) = ' ';
+                while(*full_exec_path) {
+                        *(command_line_i++) = *(full_exec_path++);
+                }
+                if (*argv) {
+                        *(command_line_i++) = ' ';
+                }
+        }
+        argvi = argv;
+        enclose_in_quotes_i = enclose_in_quotes;
+        while(*argvi) {
+                char* p = *argvi;
+                unsigned int backslash_count = 0;
+                if (*enclose_in_quotes_i) {
+                        *(command_line_i++) = '\"';
+                }
+                while(*p) {
+                        if (*p == '\"') {
+                                if (cygwin_mode && have_sh) { /* HAVE_CYGWIN_SHELL */
+                                        /* instead of a \", cygwin likes "" */
+                                        *(command_line_i++) = '\"';
+                                } else {
+                                /*
+                                 * We have to insert a backslash for the "
+                                 * and each \ that precedes the ".
+                                 */
+                                backslash_count++;
+                                while(backslash_count) {
+                                        *(command_line_i++) = '\\';
+                                        backslash_count--;
+                                };
+                                }
 #if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
                         } else if (*p == '\\') {
                                 backslash_count++;
                         } else {
                                 backslash_count = 0;
+                        } else if (*p == '\\') {
+                                backslash_count++;
+                        } else {
+                                backslash_count = 0;
 #endif
+                        }
                         /*
                          * Copy the character.
                          */
                         *(command_line_i++) = *(p++);
+                }
                 if (*enclose_in_quotes_i) {
+                        }
+                        /*
+                         * Copy the character.
+                         */
+                        *(command_line_i++) = *(p++);
+                }
+                if (*enclose_in_quotes_i) {
 #if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL)
                         /*
                          * Add one \ for each \ that precedes the
                          * closing ".
                          */
                         while(backslash_count--) {
                                 *(command_line_i++) = '\\';
                         };
+                        /*
+                         * Add one \ for each \ that precedes the
+                         * closing ".
+                         */
+                        while(backslash_count--) {
+                                *(command_line_i++) = '\\';
+                        };
 #endif
                         *(command_line_i++) = '\"';
+                }
                 /*
                  * Append an intervening space.
                  */
                 if (*(++argvi)) {
                         *(command_line_i++) = ' ';
+                }
                 enclose_in_quotes_i++;
+        }
         /*
          * Append the terminating NULL.
          */
         *command_line_i = '\0';
         if (enclose_in_quotes) free(enclose_in_quotes);
         return command_line;
+                        *(command_line_i++) = '\"';
+                }
+                /*
+                 * Append an intervening space.
+                 */
+                if (*(++argvi)) {
+                        *(command_line_i++) = ' ';
+                }
+                enclose_in_quotes_i++;
+        }
+        /*
+         * Append the terminating NULL.
+         */
+        *command_line_i = '\0';
+        free(enclose_in_quotes);
+        return command_line;
+}
 …
  *              using the default stdin, stdout, and stderr handles.
  *              Also, register process so that process_wait_for_any_private()
  *              can be used via process_file_io(NULL) or
  *              process_wait_for_any().
+ *              can be used via process_file_io(NULL) or
+ *              process_wait_for_any().
+ *
  * Returns:
 …
 HANDLE
 process_easy(
+        char **argv,
+        char **envp)
+{
+  HANDLE hIn;
+  HANDLE hOut;
+  HANDLE hErr;
+  HANDLE hProcess;
+        char **argv,
+        char **envp,
+        int outfd,
+        int errfd)
+{
+  HANDLE hIn = INVALID_HANDLE_VALUE;
+  HANDLE hOut = INVALID_HANDLE_VALUE;
+  HANDLE hErr = INVALID_HANDLE_VALUE;
+  HANDLE hProcess, tmpIn, tmpOut, tmpErr;
+  DWORD e;
   if (proc_index >= MAXIMUM_WAIT_OBJECTS) {
         DB (DB_JOBS, ("process_easy: All process slots used up\n"));
         return INVALID_HANDLE_VALUE;
+        DB (DB_JOBS, ("process_easy: All process slots used up\n"));
+        return INVALID_HANDLE_VALUE;
+  }
+  /* Standard handles returned by GetStdHandle can be NULL or
+     INVALID_HANDLE_VALUE if the parent process closed them.  If that
+     happens, we open the null device and pass its handle to
+     CreateProcess as the corresponding handle to inherit.  */
+  tmpIn = GetStdHandle(STD_INPUT_HANDLE);
   if (DuplicateHandle(GetCurrentProcess(),
                       GetStdHandle(STD_INPUT_HANDLE),
+                      tmpIn,
                       GetCurrentProcess(),
                       &hIn,
 …
                       TRUE,
                       DUPLICATE_SAME_ACCESS) == FALSE) {
+    fprintf(stderr,
+            "process_easy: DuplicateHandle(In) failed (e=%ld)\n",
+            GetLastError());
+    return INVALID_HANDLE_VALUE;
+    if ((e = GetLastError()) == ERROR_INVALID_HANDLE) {
+      tmpIn = CreateFile("NUL", GENERIC_READ,
+                         FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+      if (tmpIn != INVALID_HANDLE_VALUE
+          && DuplicateHandle(GetCurrentProcess(),
+                             tmpIn,
+                             GetCurrentProcess(),
+                             &hIn,
+,
+                             TRUE,
+                             DUPLICATE_SAME_ACCESS) == FALSE)
+        CloseHandle(tmpIn);
+    }
+    if (hIn == INVALID_HANDLE_VALUE) {
+      fprintf(stderr, "process_easy: DuplicateHandle(In) failed (e=%ld)\n", e);
+      return INVALID_HANDLE_VALUE;
+    }
+  }
+  if (outfd >= 0)
+    tmpOut = (HANDLE)_get_osfhandle (outfd);
+  else
+    tmpOut = GetStdHandle (STD_OUTPUT_HANDLE);
   if (DuplicateHandle(GetCurrentProcess(),
                       GetStdHandle(STD_OUTPUT_HANDLE),
+                      tmpOut,
                       GetCurrentProcess(),
                       &hOut,
 …
                       TRUE,
                       DUPLICATE_SAME_ACCESS) == FALSE) {
+    fprintf(stderr,
+           "process_easy: DuplicateHandle(Out) failed (e=%ld)\n",
+           GetLastError());
+    return INVALID_HANDLE_VALUE;
+    if ((e = GetLastError()) == ERROR_INVALID_HANDLE) {
+      tmpOut = CreateFile("NUL", GENERIC_WRITE,
+                          FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+                          OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+      if (tmpOut != INVALID_HANDLE_VALUE
+          && DuplicateHandle(GetCurrentProcess(),
+                             tmpOut,
+                             GetCurrentProcess(),
+                             &hOut,
+,
+                             TRUE,
+                             DUPLICATE_SAME_ACCESS) == FALSE)
+        CloseHandle(tmpOut);
+    }
+    if (hOut == INVALID_HANDLE_VALUE) {
+      fprintf(stderr, "process_easy: DuplicateHandle(Out) failed (e=%ld)\n", e);
+      return INVALID_HANDLE_VALUE;
+    }
+  }
+  if (errfd >= 0)
+    tmpErr = (HANDLE)_get_osfhandle (errfd);
+  else
+    tmpErr = GetStdHandle(STD_ERROR_HANDLE);
   if (DuplicateHandle(GetCurrentProcess(),
                       GetStdHandle(STD_ERROR_HANDLE),
+                      tmpErr,
                       GetCurrentProcess(),
                       &hErr,
 …
                       TRUE,
                       DUPLICATE_SAME_ACCESS) == FALSE) {
+    fprintf(stderr,
+            "process_easy: DuplicateHandle(Err) failed (e=%ld)\n",
+            GetLastError());
+    return INVALID_HANDLE_VALUE;
+    if ((e = GetLastError()) == ERROR_INVALID_HANDLE) {
+      tmpErr = CreateFile("NUL", GENERIC_WRITE,
+                          FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+                          OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+      if (tmpErr != INVALID_HANDLE_VALUE
+          && DuplicateHandle(GetCurrentProcess(),
+                             tmpErr,
+                             GetCurrentProcess(),
+                             &hErr,
+,
+                             TRUE,
+                             DUPLICATE_SAME_ACCESS) == FALSE)
+        CloseHandle(tmpErr);
+    }
+    if (hErr == INVALID_HANDLE_VALUE) {
+      fprintf(stderr, "process_easy: DuplicateHandle(Err) failed (e=%ld)\n", e);
+      return INVALID_HANDLE_VALUE;
+    }
+  }
 …
     /* close up unused handles */
+    CloseHandle(hIn);
+    CloseHandle(hOut);
+    CloseHandle(hErr);
+    if (hIn != INVALID_HANDLE_VALUE)
+      CloseHandle(hIn);
+    if (hOut != INVALID_HANDLE_VALUE)
+      CloseHandle(hOut);
+    if (hErr != INVALID_HANDLE_VALUE)
+      CloseHandle(hErr);
+  }

vendor/gnumake/current/w32/subproc/w32err.c

-              r2596
+              r3138
 /* Error handling for Windows
+Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+Copyright (C) 1996-2016 Free Software Foundation, Inc.
 This file is part of GNU Make.
 …
 this program.  If not, see <http://www.gnu.org/licenses/>.  */
+#include <stdlib.h>
 #include <windows.h>
+#include "makeint.h"
 #include "w32err.h"
 …
  *      comp.os.ms-windows.programmer.win32
  */
 char *
+const char *
 map_windows32_error_to_string (DWORD ercode) {
+/* __declspec (thread) necessary if you will use multiple threads on MSVC */
+#ifdef _MSC_VER
+__declspec (thread) static char szMessageBuffer[128];
+#else
+static char szMessageBuffer[128];
+#endif
+        /* Fill message buffer with a default message in
+         * case FormatMessage fails
+         */
+/*
+ * We used to have an MSVC-specific '__declspec (thread)' qualifier
+ * here, with the following comment:
+ *
+ * __declspec (thread) necessary if you will use multiple threads on MSVC
+ *
+ * However, Make was never multithreaded on Windows (except when
+ * Ctrl-C is hit, in which case the main thread is stopped
+ * immediately, so it doesn't matter in this context).  The functions
+ * on sub_proc.c that started and stopped additional threads were
+ * never used, and are now #ifdef'ed away.  Until we need more than
+ * one thread, we have no problems with the following buffer being
+ * static.  (If and when we do need it to be in thread-local storage,
+ * the corresponding GCC qualifier is '__thread'.)
+ */
+    static char szMessageBuffer[128];
+        /* Fill message buffer with a default message in
+         * case FormatMessage fails
+         */
     wsprintf (szMessageBuffer, "Error %ld\n", ercode);
+        /*
+         *  Special code for winsock error handling.
+         */
+        if (ercode > WSABASEERR) {
+                HMODULE hModule = GetModuleHandle("wsock32");
+                if (hModule != NULL) {
+                        FormatMessage(FORMAT_MESSAGE_FROM_HMODULE,
+                                hModule,
+                                ercode,
+                                LANG_NEUTRAL,
+                                szMessageBuffer,
+                                sizeof(szMessageBuffer),
+                                NULL);
+                        FreeLibrary(hModule);
+                }
+        } else {
+                /*
+                 *  Default system message handling
+                 */
+        FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
+                  NULL,
+                  ercode,
+                  LANG_NEUTRAL,
+                  szMessageBuffer,
+                  sizeof(szMessageBuffer),
+                  NULL);
+        }
+        /*
+         *  Special code for winsock error handling.
+         */
+        if (ercode > WSABASEERR) {
+#if 0
+                HMODULE hModule = GetModuleHandle("wsock32");
+                if (hModule != NULL) {
+                        FormatMessage(FORMAT_MESSAGE_FROM_HMODULE,
+                                hModule,
+                                ercode,
+                                LANG_NEUTRAL,
+                                szMessageBuffer,
+                                sizeof(szMessageBuffer),
+                                NULL);
+                        FreeLibrary(hModule);
+                }
+#else
+                O (fatal, NILF, szMessageBuffer);
+#endif
+        } else {
+                /*
+                 *  Default system message handling
+                 */
+                FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
+                        NULL,
+                        ercode,
+                        LANG_NEUTRAL,
+                        szMessageBuffer,
+                        sizeof(szMessageBuffer),
+                        NULL);
+        }
     return szMessageBuffer;
+}

Context Navigation

Legend: