* A few cleanups, and 3.77.94 release.

* Terminology change in docs and code.
* Fix jobserver algorithm again.
2026-08-25 03:13:31 +08:00 · 1999-08-25 21:39:28 +00:00 · 1999-08-24 04:49:39 +00:00 · 1999-08-23 22:15:17 +00:00 · 1999-08-23 05:35:14 +00:00 · 1999-08-22 17:50:57 +00:00
29 changed files with 1829 additions and 1244 deletions
--- a/.cvsignore
+++ b/.cvsignore
@@ -22,3 +22,5 @@ sun4 i386 i386-netbsd hp300-netbsd hp300 rs6000 sun3 news800 amiga
 hp700 hp834 mips sol2 i486-linux

 customs
+
+install-sh mkinstalldirs
--- a/315
+++ b/315
@@ -1,3 +1,285 @@
+1999-08-25  Paul D. Smith  <psmith@gnu.org>
+
+	* Version 3.77.94 released.
+
+	* main.c (main) [__MSDOS__]: If the user uses -j, warn that it's
+	not supported and reset it.
+
+	* make.h (ISDIGIT): Obtained this from the textutils distribution.
+	* main.c (decode_switches): Use it.
+	* function.c (is_numeric): Use it.
+
+	* main.c (struct command_switch): Store the switch char in an
+	unsigned char to shut up GCC about using it with ctype.h macros.
+	Besides, it _is_ always unsigned.
+
+1999-08-24  Paul D. Smith  <psmith@gnu.org>
+
+	* make.texinfo: Change "dependency" to "prerequisite" and
+	"dependencies" to "prerequisites".  Various other cleanups related
+	to the terminology change.
+	* file.c: Change debugging and error messages to use
+	"prerequisite" instead of "dependency".
+	* implicit.c: Ditto.
+	* remake.c: Ditto.
+	* NEWS: Document it.
+
+1999-08-23  Paul D. Smith  <psmith@gnu.org>
+
+	* remake.c (update_file): Move the considered check into the
+	double-colon rule loop, so we consider double-colon rules
+	individually (otherwise after the first is pruned, the rest won't
+	get run).
+
+	* README.template: Minor changes.
+
+	Remove the debugging features of the jobserver, so it no longer
+	writes distinct tokens to the pipe.  Thus, we don't need to store
+	the token we get.  A side effect of this is to remove a potential
+	"unavailable token" situation: make-1 invokes make-2 with its
+	special token and make-3 with a normal token; make-2 completes.
+	Now we're waiting for make-3 but using 2 tokens; our special token
+	is idle.  In the new version we don't have special tokens per se,
+	we merely decide if we already have a child or not.  If we don't,
+	we don't need a token.  If we do, we have to get one to run the
+	next child.  Similar for putting tokens back: if we're cleaning up
+	the last child, we don't put a token back.  Otherwise, we do.
+
+	* main.c: Add a new, internal flag --jobserver-fds instead of
+	overloading the meaning of -j.  Remove job_slots_str and add the
+	stringlist jobserver_fds.
+	(struct command_switch): We don't need the int_string type.
+	(switches[]): Add a new option for --jobserver-fds and remove
+	conditions around -j.  Make the description for the former 0 so it
+	doesn't print during "make --help".
+	(main): Rework jobserver parsing.  If we got --jobserver-fds
+	make sure it's valid.  We only get one and job_slots must be 0.
+	If we're the toplevel make (-jN without --jobserver-fds) create
+	the pipe and write generic tokens.
+	Create the stringlist struct for the submakes.
+	Clean up the stringlist where necessary.
+	(init_switches): Remove int_string handling.
+	(print_usage): Don't print internal flags (description ptr is 0).
+	(decode_switches): Remove int_string handling.
+	(define_makeflags): Remove int_string handling.
+
+	* job.c: Remove my_job_token flag and all references to the
+	child->job_token field.
+	(free_job_token): Remove this and merge it into free_child().
+	(reap_children): Rework the "reaped a child" logic slightly.
+	Don't call defunct free_job_token anymore.  Always call
+	free_child, even if we're dying.
+	(free_child): If we're not freeing the only child, put a token
+	back in the pipe.  Then, if we're dying, don't bother to free.
+	(new_job): If we are using the jobserver, loop checking to see if
+	a) there are no children or b) we get a token from the pipe.
+
+	* job.h (struct child): Remove the job_token field.
+
+1999-08-20  Paul D. Smith  <psmith@gnu.org>
+
+	* variable.c (try_variable_definition): Allocate for variable
+	expansion in f_append with a simple variable: if we're looking at
+	target-specific variables we don't want to trash the buffer.
+	Noticed by Reiner Beninga <Reiner.Beninga@mchp.siemens.de>.
+
+1999-08-16  Eli Zaretskii  <eliz@is.elta.co.il>
+
+	* main.c (main) [__MSDOS__]: Mirror any backslashes in argv[0], to
+	avoid problems in shell commands that use backslashes as escape
+	characters.
+
+1999-08-16  Paul D. Smith  <psmith@gnu.org>
+
+	* Version 3.77.93 released.
+
+1999-08-13  Paul D. Smith  <psmith@gnu.org
+
+	* function.c (func_if): New function $(if ...) based on the
+	original by Han-Wen but reworked quite a bit.
+	(function_table): Add it.
+	* NEWS: Introduce it.
+	* make.texinfo (If Function): Document it.
+
+	* job.c (free_job_token): Check for EINTR when writing tokens to
+	the jobserver pipe.
+
+1999-08-12  Paul D. Smith  <psmith@gnu.org>
+
+	Another jobserver algorithm change.  We conveniently forgot that
+	the blocking bit is shared by all users of the pipe, it's not a
+	per-process setting.  Since we have many make processes all
+	sharing the pipe we can't use the blocking bit as a signal handler
+	flag.  Instead, we'll dup the pipe's read FD and have the SIGCHLD
+	handler close the dup'd FD.  This will cause the read() to fail
+	with EBADF the next time we invoke it, so we know we need to reap
+	children.  We then re-dup and reap.
+
+	* main.c (main): Define the job_rfd variable to hold the dup'd FD.
+	Actually dup the read side of the pipe.  Don't bother setting the
+	blocking bit on the file descriptor.
+	* make.h: Declare the job_rfd variable.
+	* job.c (child_handler): If the dup'd jobserver pipe is open,
+	close it and assign -1 to job_rfd to notify the main program that
+	we got a SIGCHLD.
+	(start_job_command): Close the dup'd FD before exec'ing children.
+	Since we open and close this thing so often it doesn't seem
+	worth it to use the close-on-exec bit.
+	(new_job): Remove code for testing/setting the blocking bit.
+	Instead of EAGAIN, test for EBADF.  If the dup'd FD has been
+	closed, re-dup it before we reap children.
+
+	* function.c (func_shell): Be a little more accurate about the
+	length of the error string to allocate.
+
+	* expand.c (variable_expand_for_file): If there's no filenm info
+	(say, from a builtin command) then reset reading_file to 0.
+
+1999-08-09  Paul D. Smith  <psmith@gnu.org>
+
+	* maintMakefile: Use g in sed (s///g) to replace >1 variable per
+	line.
+
+	* Makefile.DOS.template [__MSDOS__]: Fix mostlyclean-aminfo to
+	remove the right files.
+
+1999-08-01  Eli Zaretskii  <eliz@is.elta.co.il>
+
+	* function.c (msdos_openpipe) [__MSDOS__]: *Really* return a FILE
+	ptr.
+
+1999-08-01  Paul D. Smith  <psmith@gnu.org>
+
+	New jobserver algorithm to avoid a possible hole where we could
+	miss SIGCHLDs and get into a deadlock.  The original algorithm was
+	suggested by Roland McGrath with a nice refinement by Paul Eggert.
+	Many thanks as well to Tim Magill and Howard Chu, who also
+	provided many viable ideas and critiques.  We all had a fun week
+	dreaming up interesting ways to use and abuse UNIX syscalls :).
+
+	Previously we could miss a SIGCHLD if it happened after we reaped
+	the children but before we re-entered the blocking read.  If this
+	happened to all makes and/or all children, make would never wake
+	up.
+
+	We avoid this by having the SIGCHLD handler reset the blocking bit
+	on the jobserver pipe read FD (normally read does block in this
+	algorithm).  Now if the handler is called between the time we reap
+	and the time we read(), and there are no tokens available, the
+	read will merely return with EAGAIN instead of blocking.
+
+	* main.c (main): Set the blocking bit explicitly here.
+	* job.c (child_handler): If we have a jobserver pipe, set the
+	non-blocking bit for it.
+	(start_waiting_job): Move the token stuff back to new_job; if we
+	do it here then we're not controlling the number of remote jobs
+	started!
+	(new_job): Move the check for job slots to _after_ we've created a
+	child structure.  If the read returns without getting a token, set
+	the blocking bit then try to reap_children.
+
+	* make.h (EINTR_SET): Define to test errno if EINTR is available,
+	or 0 otherwise.  Just some code cleanup.
+	* arscan.c (ar_member_touch): Use it.
+	* function.c (func_shell): Use it.
+	* job.c (reap_children): Use it.
+	* remake.c (touch_file): Use it.
+
+1999-07-28  Paul D. Smith  <psmith@gnu.org>
+
+	* make.h: Define _() and N_() macros as passthrough to initiate
+	NLS support.
+	* <all>: Add _()/N_() around translatable strings.
+
+1999-07-27  Paul D. Smith  <psmith@gnu.org>
+
+	* read.c: Make sure make.h comes before other headers.
+
+1999-07-26  Paul D. Smith  <psmith@gnu.org>
+
+	* make.texinfo (Quick Reference): Update with the new features.
+
+1999-07-25  Eli Zaretskii  <eliz@is.elta.co.il>
+
+	* remake.c [__MSDOS__]: Don't include variables.h, it's already
+	included.
+
+	* function.c (msdos_openpipe) [__MSDOS__]: Return FILE ptr.
+	(func_shell) [__MSDOS__]: Fix the argument list.
+
+	* Makefile.DOS.template: Update from Makefile.in.
+
+	* README.DOS.template: Configure command fixed.
+
+	* configh.dos.template: Update to provide definitions for
+	uintmax_t, fd_set_size_t, and HAVE_SELECT.
+
+1999-07-24  Paul D. Smith  <psmith@gnu.org>
+
+	* Version 3.77.91 released.
+
+	* configure.in: Changes to the boostrapping code: if build.sh.in
+	doesn't exist configure spits an error and generates an empty
+	build.sh file which causes make to be confused.
+	* maintMakefile: Don't build README early.
+
+1999-07-23  Paul D. Smith  <psmith@gnu.org>
+
+	* job.c (my_job_token): This variable controls whether we've
+	handed our personal token to a subprocess or not.  Note we could
+	probably infer this from the value of job_slots_used, but it's
+	clearer to just keep it separately.  Job_slots_used isn't really
+	relevant when running the job server.
+	(free_job_token): New function: free a job token.  If we don't
+	have one, no-op.  If we have the personal token, reclaim it.  If
+	we have another token, write it back to the pipe.
+	(reap_children): Call free_job_token.
+	(free_child): Call free_job_token.
+	(start_job_command): Remove duplicate test for '+' in the command.
+	If we don't appear to be running a recursive make, close the
+	jobserver filedescriptors.
+	(start_waiting_job): If our personal token is available, use that
+	instead of going to the server pipe.
+	(*): Add the token value to many debugging statements, and print
+	the child target name in addition to the ptr hex value.
+	Change the default "no token" value from '\0' to '-' so it looks
+	better in the output.
+
+	* main.c (main): Install the child_handler with sigaction()
+	instead of signal() if we have it.  On SysV systems, signal() uses
+	SysV semantics which are a pain.  But sigaction() always does what
+	we want.
+	(main): If we got job server FDs from the environment, test them
+	to see if they're open.  If not, the parent make closed them
+	because it didn't think we were a submake.  Print a warning and
+	suggestion to use "+" on the submake invocation, and hard-set to
+	-j1 for this instance of make.
+	(main): Change the algorithm for assigning slots to be more
+	robust.  Previously make checked to see if it thought a subprocess
+	was a submake and if so, didn't give it a token.  Since make's
+	don't consume tokens we could spawn many of makes fighting for a
+	small number of tokens.  Plus this is unreliable because submakes
+	might not be recognized by the parent (see above) then all the
+	tokens could be used up by unrecognized makes, and no one could
+	run.  Now every make consumes a token from its parent.  However,
+	the make can also use this token to spawn a child.  If the make
+	wants more than one, it goes to the jobserver pipe.  Thus there
+	will never be more than N makes running for -jN, and N*2 processes
+	(N makes and their N children).  Every make can always run at
+	least one job, and we'll never deadlock.  (Note the closing of the
+	pipe for non-submakes also solves this, but this is still a better
+	algorithm.)  So!  Only put N-1 tokens into the pipe, since the
+	topmost make keeps one for itself.
+
+	* configure.in: Find sigaction.  Disable job server support unless
+	the system provides it, in addition to either waitpid() or
+	wait3().
+
+1999-07-22  Rob Tulloh  <rob_tulloh@dev.tivoli.com>
+
+	* arscan.c (ar_member_touch) [WINDOWS32]: The ar_date field is a
+	string on Windows, not a timestamp.
+
 1999-07-21  Paul D. Smith  <psmith@gnu.org>

 	* Version 3.77.90 released.
@@ -111,21 +393,24 @@
 	already have one; if we're waiting on the load to go down
 	start_waiting_job() might get called twice on the same file.

-	* remake.c (update_goal_chain): If we try to update a goal and it
-	doesn't complete (e.g., parallel builds) remember that by setting
-	the `deferred' flag in the goal structure.  Later when we're
-	determining the return value we consider a goal updated if either
-	the mtime has changed _or_ this flag was set.  We need this
-	because the mtime doesn't change during the update_file() function
-	if we started a job running; instead it's set during the
-	reap_children() call.  So, the code doesn't know it was updated
-	and returns a status of -1 (nothing done).  This is OK during
-	"normal" builds since our caller (main) treats these cases
-	identically in that case, but if you're building makefiles the
-	difference is very important (whether we re-exec or not).
-
-	* dep.h: Add a `deferred' flag to track whether a goal was run but
-	not completed (parallel builds).
+	* filedef.h (struct file): Add new field, mtime_before_update.
+	When notice_finished_file runs it assigns the cached last_mtime to
+	this field.
+	* remake.c (update_goal_chain): Notice that a file wasn't updated
+	by asking if it changed (g->changed) and comparing the current
+	cached time (last_mtime) with the previous one, stored in
+	mtime_before_update.  The previous check ("did last_mtime changed
+	during the run of update_file?") fails for parallel builds because
+	last_mtime is set during reap_children, before update_file is run.
+	This causes update_goal_chain to always return -1 (nothing
+	rebuilt) when running parallel (-jN).  This is OK during "normal"
+	builds since our caller (main) treats these cases identically in
+	that case, but if when rebuilding makefiles the difference is very
+	important, as it controls whether we re-exec or not.
+	* file.c (file_hash_enter): Copy the mtime_before_update field.
+	(snap_deps): Initialize mtime_before_update to -1.
+	* main.c (main): Initialize mtime_before_update on old (-o) and
+	new (-W) files.

 1999-07-08  Paul D. Smith  <psmith@gnu.org>

--- a/Makefile.DOS.template
+++ b/Makefile.DOS.template
@@ -1,7 +1,7 @@
 # -*-Makefile-*- template for DJGPP
 # Makefile.in generated automatically by automake 1.2 from Makefile.am

-# Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
+# Copyright (C) 1994, 1995-1998, 1999 Free Software Foundation, Inc.
 # This Makefile.DOS is free software; the Free Software Foundation
 # gives unlimited permission to copy, distribute and modify it.

@@ -118,7 +118,11 @@ HEADERS = $(wildcard $(srcdir)/*.h)
 default: all

 .SUFFIXES:
-.SUFFIXES: .c .dvi .info .o .ps .texi .texinfo
+.SUFFIXES: .S .c .dvi .info .o .ps .s .texi .texinfo .txi
+
+mostlyclean-hdr:
+
+clean-hdr:

 distclean-hdr:
 	-rm -f config.h
@@ -141,11 +145,17 @@ install-binPROGRAMS: $(bin_PROGRAMS)

 uninstall-binPROGRAMS:
 	$(NORMAL_UNINSTALL)
-	list='$(bin_PROGRAMS)'; for p in $$list; do    rm -f $(bindir)/`echo $$p|sed '$(transform)'`;  done
+	list='$(bin_PROGRAMS)'; for p in $$list; do    rm -f $(bindir)/`echo $$p|sed '$(transform)'`.exe;  done

 .c.o:
 	$(COMPILE) -c $<

+.s.o:
+	$(COMPILE) -c $<
+
+.S.o:
+	$(COMPILE) -c $<
+
 clean-noinstLIBRARIES:
 	-test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)

@@ -155,7 +165,7 @@ mostlyclean-compile:
 clean-compile:

 distclean-compile:
-	-rm -f *.tab.c
+	-rm -f *.tab.c *_tab.c

 maintainer-clean-compile:

@@ -188,6 +198,12 @@ DVIPS = dvips
 .texinfo.dvi:
 	TEXINPUTS="$(srcdir);$$TEXINPUTS"    MAKEINFO='$(MAKEINFO) -I $(srcdir)' $(TEXI2DVI) $<

+.txi.info:
+	$(MAKEINFO) $(srcdir)/$< -o ./$@
+
+.txi.dvi:
+	TEXINPUTS="$(srcdir);$$TEXINPUTS"    MAKEINFO='$(MAKEINFO) -I $(srcdir)' $(TEXI2DVI) $<
+
 .dvi.ps:
 	$(DVIPS) $< -o $@

@@ -208,7 +224,9 @@ dist-info: $(INFO_DEPS)
 	for base in $(INFO_DEPS); do    d=$(srcdir);    for file in `cd $$d && eval echo $$base*`; do      test -f $(distdir)/$$file      || ln $$d/$$file $(distdir)/$$file 2> /dev/null      || cp -p $$d/$$file $(distdir)/$$file;    done;  done

 mostlyclean-aminfo:
-	rm -f make.aux make.cp make.cps make.dvi make.fn make.fns make.ky    make.kys make.ps make.log make.pg make.toc make.tp make.tps make.vr make.vrs    make.op make.tr make.cv make.cn
+	-rm -f make.aux make.cp make.cps make.dvi make.fn make.fns make.ky \
+	  make.kys make.ps make.log make.pg make.toc make.tp make.tps \
+	  make.vr make.vrs make.op make.tr make.cv make.cn

 clean-aminfo:

--- a/14
+++ b/14
@@ -12,17 +12,21 @@ Please send GNU make bug reports to bug-make@gnu.org.

 Version 3.78

-* Two new functions, $(error ...) and $(warning ...) are provided.  The
+* Two new functions, $(error ...) and $(warning ...) are available.  The
  former will cause make to fail and exit immediately upon expansion of
  the function, with the text provided as the error message.  The latter
  causes the text provided to be printed as a warning message, but make
  proceeds normally.

-* A new function, $(call ...) is provided.  This allows users to create
+* A new function $(call ...) is available.  This allows users to create
  their own parameterized macros and invoke them later.  Original
-  implementation of this feature was provided by Han-Wen Nienhuys
+  implementation of this function was provided by Han-Wen Nienhuys
  <hanwen@cs.uu.nl>.

+* A new function $(if ...) is available.  It provides if-then-else
+  capabilities in a builtin function.  Original implementation of this
+  function was provided by Han-Wen Nienhuys <hanwen@cs.uu.nl>.
+
 * Make defines a new variable, .LIBPATTERNS.  This variable controls how
  library dependency expansion (dependencies like ``-lfoo'') is performed.

@@ -42,6 +46,10 @@ Version 3.78
  each other to ensure that no more than N jobs are started across all
  makes.  To get the old behavior of -j back, you can configure make
  with the --disable-job-server option.
+
+* The confusing term "dependency" has been replaced by the more accurate
+  and standard term "prerequisite", both in the manual and in all GNU make
+  output.

 Version 3.77

--- a/README.DOS.template
+++ b/README.DOS.template
@@ -5,7 +5,7 @@ Builds with DJGPP v2 port of GNU C/C++ compiler and utilities.

 New (since 3.74) DOS-specific features:

-   1. Supports long filenames when run from DOS box on Windows 95.
+   1. Supports long filenames when run from DOS box on Windows 9x.

   2. Supports both stock DOS COMMAND.COM and Unix-style shells
      (details in ``Notes'' below).
@@ -48,9 +48,10 @@ To build:
      [Enter].  Otherwise, you need to supply the path to the source
      directory as an argument to the batch file, like this:

-		configure.bat c:/djgpp/gnu/make-%VERSION%
+	c:\djgpp\gnu\make-%VERSION%\configure.bat c:/djgpp/gnu/make-%VERSION%

-      Note the forward slashes: you MUST use them here.
+      Note the forward slashes in the source path argument: you MUST
+      use them here.

   3. 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
@@ -228,9 +229,9 @@ Notes:

   4. Letter-case in filenames.

-      If you run Make on Windows 95, you should be aware of the
+      If you run Make on Windows 9x, you should be aware of the
      letter-case issue.  Make is internally case-sensitive, but all
-      file operations are case-insensitive on Windows 95, so
+      file operations are case-insensitive on Windows 9x, so
      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
@@ -240,8 +241,8 @@ Notes:
      converted to lower case are explained in the DJGPP libc docs,
      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 legal DOS 8+3 filename and
-      doesn't include characters illegal on MSDOS FAT filesystems,
+      upper case in the directory, is a valid DOS 8+3 filename and
+      doesn't include characters invalid on MSDOS FAT filesystems,
      will be automatically down-cased.)  User reports that I have
      indicate that this default behavior is generally what you'd
      expect; however, your input is most welcome.
--- a/README.template
+++ b/README.template
@@ -1,6 +1,7 @@
 This directory contains the %VERSION% release of GNU Make.
-All bugs reported for previous releases have been fixed.
-Some bugs surely remain.
+
+See the file NEWS for the user-visible changes from previous releases.
+In addition, there have been bugs fixed.

 For general building and installation instructions, see the file INSTALL.

@@ -24,6 +25,8 @@ site.  There is information there about ordering hardcopy documentation.
  http://www.gnu.org/doc/doc.html
  http://www.gnu.org/manual/manual.html

+You can also find the latest versions of GNU Make from there.
+
 Please send GNU make bug reports to bug-make@gnu.org.  Please see the
 section of the manual entitles `Problems and Bugs' for information on
 submitting bug reports.
@@ -61,9 +64,5 @@ 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.)

-See the file NEWS for what has changed since previous releases.
-
-GNU Make is fully documented in make.texinfo.  See the section entitled
-`Problems and Bugs' for information on submitting bug reports.

 GNU Make is free software.  See the file COPYING for copying conditions.
--- a/ar.c
+++ b/ar.c
@@ -47,7 +47,7 @@ ar_name (name)
    return 0;

  if (p[1] == '(' && end[-1] == ')')
-    fatal (NILF, "attempt to use unsupported feature: `%s'", name);
+    fatal (NILF, _("attempt to use unsupported feature: `%s'"), name);

  return 1;
 }
@@ -138,7 +138,7 @@ int
 ar_touch (name)
     char *name;
 {
-  error (NILF, "touch archive member is not available on VMS");
+  error (NILF, _("touch archive member is not available on VMS"));
  return -1;
 }
 #else
@@ -170,24 +170,24 @@ ar_touch (name)
  switch (ar_member_touch (arname, memname))
    {
    case -1:
-      error (NILF, "touch: Archive `%s' does not exist", arname);
+      error (NILF, _("touch: Archive `%s' does not exist"), arname);
      break;
    case -2:
-      error (NILF, "touch: `%s' is not a valid archive", arname);
+      error (NILF, _("touch: `%s' is not a valid archive"), arname);
      break;
    case -3:
      perror_with_name ("touch: ", arname);
      break;
    case 1:
      error (NILF,
-             "touch: Member `%s' does not exist in `%s'", memname, arname);
+             _("touch: Member `%s' does not exist in `%s'"), memname, arname);
      break;
    case 0:
      val = 0;
      break;
    default:
      error (NILF,
-             "touch: Bad return code from ar_member_touch on `%s'", name);
+             _("touch: Bad return code from ar_member_touch on `%s'"), name);
    }

  if (!arname_used)
--- a/arscan.c
+++ b/arscan.c
@@ -70,7 +70,7 @@ VMS_get_member_info (module, rfa)
 			   &bufdesc.dsc$w_length, 0);
  if (! status)
    {
-      error (NILF, "lbr$set_module failed to extract module info, status = %d",
+      error (NILF, _("lbr$set_module failed to extract module info, status = %d"),
 	     status);

      lbr$close (&VMS_lib_idx);
@@ -152,7 +152,7 @@ ar_scan (archive, function, arg)

  if (! status)
    {
-      error (NILF, "lbr$ini_control failed with status = %d",status);
+      error (NILF, _("lbr$ini_control failed with status = %d"),status);
      return -2;
    }

@@ -163,7 +163,7 @@ ar_scan (archive, function, arg)

  if (! status)
    {
-      error (NILF, "unable to open library `%s' to lookup member `%s'",
+      error (NILF, _("unable to open library `%s' to lookup member `%s'"),
 	     archive, (char *)arg);
      return -1;
    }
@@ -775,12 +775,9 @@ ar_member_touch (arname, memname)
  if (AR_HDR_SIZE != write (fd, (char *) &ar_hdr, AR_HDR_SIZE))
    goto lose;
  /* The file's mtime is the time we we want.  */
-#ifdef EINTR
-  while (fstat (fd, &statbuf) < 0 && errno == EINTR);
-#else
-  fstat (fd, &statbuf);
-#endif
-#if defined(ARFMAG) || defined(ARFZMAG) || defined(AIAMAG)
+  while (fstat (fd, &statbuf) < 0 && EINTR_SET)
+    ;
+#if defined(ARFMAG) || defined(ARFZMAG) || defined(AIAMAG) || defined(WINDOWS32)
  /* Advance member's time to that time */
  for (i = 0; i < sizeof ar_hdr.ar_date; i++)
    ar_hdr.ar_date[i] = ' ';
@@ -820,11 +817,11 @@ describe_member (desc, name, truncated,
 {
  extern char *ctime ();

-  printf ("Member `%s'%s: %ld bytes at %ld (%ld).\n",
-	  name, truncated ? " (name might be truncated)" : "",
+  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);
+  printf (_("  Date %s"), ctime (&date));
+  printf (_("  uid = %d, gid = %d, mode = 0%o.\n"), uid, gid, mode);

  return 0;
 }
--- a/commands.c
+++ b/commands.c
@@ -386,7 +386,7 @@ fatal_error_signal (sig)
 #ifdef _AMIGA
  remove_intermediates (1);
  if (sig == SIGINT)
-     fputs ("*** Break.\n", stderr);
+     fputs (_("*** Break.\n"), stderr);

  exit (10);
 #else /* not Amiga */
@@ -478,10 +478,10 @@ delete_target (file, on_behalf_of)
      if (ar_member_date (file->name) != FILE_TIMESTAMP_S (file->last_mtime))
 	{
 	  if (on_behalf_of)
-	    error (NILF, "*** [%s] Archive member `%s' may be bogus; not deleted",
+	    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",
+	    error (NILF, _("*** Archive member `%s' may be bogus; not deleted"),
 		   file->name);
 	}
      return;
@@ -493,9 +493,9 @@ delete_target (file, on_behalf_of)
      && FILE_TIMESTAMP_STAT_MODTIME (st) != file->last_mtime)
    {
      if (on_behalf_of)
-	error (NILF, "*** [%s] Deleting file `%s'", on_behalf_of, file->name);
+	error (NILF, _("*** [%s] Deleting file `%s'"), on_behalf_of, file->name);
      else
-	error (NILF, "*** Deleting file `%s'", file->name);
+	error (NILF, _("*** Deleting file `%s'"), file->name);
      if (unlink (file->name) < 0
 	  && errno != ENOENT)	/* It disappeared; so what.  */
 	perror_with_name ("unlink: ", file->name);
@@ -533,12 +533,12 @@ print_commands (cmds)
 {
  register char *s;

-  fputs ("#  commands to execute", stdout);
+  fputs (_("#  commands to execute"), stdout);

  if (cmds->fileinfo.filenm == 0)
-    puts (" (built-in):");
+    puts (_(" (built-in):"));
  else
-    printf (" (from `%s', line %lu):\n",
+    printf (_(" (from `%s', line %lu):\n"),
            cmds->fileinfo.filenm, cmds->fileinfo.lineno);

  s = cmds->commands;
--- a/configh.dos.template
+++ b/configh.dos.template
@@ -33,3 +33,17 @@
 #define HAVE_MEMMOVE 1

 #define SCCS_GET "get"
+
+/* Define to `unsigned long' or `unsigned long long'
+   if <inttypes.h> doesn't define.  */
+#define uintmax_t unsigned long long
+
+/* Define the type of the first arg to select().  */
+#define fd_set_size_t int
+
+/* Define if you have the select function.  */
+#define HAVE_SELECT 1
+
+/* Define if you have the vprintf library function.  */
+#undef HAVE_VPRINTF
+#define HAVE_VPRINTF 1
--- a/configure.in
+++ b/configure.in
@@ -3,7 +3,7 @@ AC_REVISION([$Id$])
 AC_PREREQ(2.13)dnl		dnl Minimum Autoconf version required.
 AC_INIT(vpath.c)dnl		dnl A distinctive file to look for in srcdir.

-AM_INIT_AUTOMAKE(make, 3.77.90)
+AM_INIT_AUTOMAKE(make, 3.77.94)
 AM_CONFIG_HEADER(config.h)

 dnl Regular configure stuff
@@ -56,8 +56,9 @@ AC_MSG_RESULT($ac_cv_check_symbol_$1)])dnl
 AC_CHECK_LIB(posix4, clock_gettime)

 AC_CHECK_FUNCS(memmove strdup psignal mktemp pstat_getdynamic \
-	       clock_gettime dup2 getcwd sigsetmask getgroups setlinebuf \
-	       seteuid setegid setreuid setregid strerror strsignal pipe)
+	       clock_gettime dup2 getcwd sigsetmask sigaction getgroups \
+	       setlinebuf seteuid setegid setreuid setregid pipe \
+	       strerror strsignal)
 AC_CHECK_SYMBOL(sys_siglist)
 AC_FUNC_ALLOCA
 AC_FUNC_VFORK
@@ -129,11 +130,16 @@ dnl See if we can handle the job server feature, and if the user wants it.

 AC_ARG_ENABLE(job-server,
  [  --disable-job-server    Disallow recursive make communication during -jN],
-  [make_cv_job_server="$enableval"],
+  [make_cv_job_server="$enableval" user_job_server="$enableval"],
  [make_cv_job_server="yes"])

-case "$ac_cv_func_pipe $make_cv_job_server" in
-  "yes yes") AC_DEFINE(MAKE_JOBSERVER) ;;
+has_wait_nohang=yes
+case "$ac_cv_func_waitpid/$ac_cv_func_wait3" in
+  no/no) has_wait_nohang=no ;;
+esac
+
+case "$ac_cv_func_pipe/$ac_cv_func_sigaction/$has_wait_nohang/$make_cv_job_server" in
+  yes/yes/yes/yes) AC_DEFINE(MAKE_JOBSERVER) ;;
 esac

 dnl Allow building with dmalloc
@@ -206,12 +212,14 @@ if test -r $srcdir/maintMakefile; then
 fi
 AC_SUBST_FILE(MAINT_MAKEFILE)

-dnl build.sh is also an AC_OUTPUT, but we can't specify it here because
-dnl it's built from build.template and autoconf will crap out.  So, we
-dnl build it in the makefiles themselves.
-
 AC_OUTPUT(build.sh Makefile glob/Makefile)

+dnl If we don't yet have build.sh.in, build.sh is a bogus 0-length file
+dnl so remove it.
+
+test -f build.sh.in || rm -f build.sh
+
+
 case "$make_badcust" in
  yes) echo
       echo "WARNING: --with-customs specified but no customs.h could be found;"
@@ -232,13 +240,23 @@ case "$with_customs" in
     fi ;;
 esac

-case "$ac_cv_func_waitpid/$ac_cv_func_wait3" in
-  no/no) echo
-         echo "WARNING: Your system has neither waitpid() nor wait3()."
-         echo "         Without one of these, signal handling is unreliable."
-         echo "         You should be aware that running GNU make with -j"
-         echo "         could result in erratic behavior."
-         echo ;;
+case "$has_wait_nohang" in
+  no) echo
+      echo "WARNING: Your system has neither waitpid() nor wait3()."
+      echo "         Without one of these, signal handling is unreliable."
+      echo "         You should be aware that running GNU make with -j"
+      echo "         could result in erratic behavior."
+      echo ;;
+esac
+
+case "$make_cv_job_server/$user_job_server" in
+  no/yes) echo
+	  echo "WARNING: Make job server requires a POSIX-ish system that"
+	  echo "         supports the pipe(), sigaction(), and either"
+          echo "         waitpid() or wait3() functions.  Your system doesn't"
+	  echo "         appear to provide one or more of those."
+	  echo "         Disabling job server support."
+          echo ;;
 esac

 dnl Local Variables:
--- a/dir.c
+++ b/dir.c
@@ -884,7 +884,7 @@ print_dir_data_base ()
  register unsigned int i, dirs, files, impossible;
  register struct directory *dir;

-  puts ("\n# Directories\n");
+  puts (_("\n# Directories\n"));

  dirs = files = impossible = 0;
  for (i = 0; i < DIRECTORY_BUCKETS; ++i)
@@ -892,19 +892,19 @@ print_dir_data_base ()
      {
 	++dirs;
 	if (dir->contents == 0)
-	  printf ("# %s: could not be stat'd.\n", dir->name);
+	  printf (_("# %s: could not be stat'd.\n"), dir->name);
 	else if (dir->contents->files == 0)
 #ifdef WINDOWS32
-          printf ("# %s (key %s, mtime %d): could not be opened.\n",
+          printf (_("# %s (key %s, mtime %d): could not be opened.\n"),
                  dir->name, dir->contents->path_key,dir->contents->mtime);
 #else  /* WINDOWS32 */
 #ifdef VMS
-	  printf ("# %s (device %d, inode [%d,%d,%d]): could not be opened.\n",
+	  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",
+	  printf (_("# %s (device %ld, inode %ld): could not be opened.\n"),
 		  dir->name, (long int) dir->contents->dev,
 		  (long int) dir->contents->ino);
 #endif
@@ -921,34 +921,34 @@ print_dir_data_base ()
 		else
 		  ++f;
 #ifdef WINDOWS32
-            printf ("# %s (key %s, mtime %d): ",
+            printf (_("# %s (key %s, mtime %d): "),
                    dir->name, dir->contents->path_key, dir->contents->mtime);
 #else  /* WINDOWS32 */
 #ifdef VMS
-	    printf ("# %s (device %d, inode [%d,%d,%d]): ",
+	    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): ",
+	    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);
+	      fputs (_("No"), stdout);
 	    else
 	      printf ("%u", f);
-	    fputs (" files, ", stdout);
+	    fputs (_(" files, "), stdout);
 	    if (im == 0)
-	      fputs ("no", stdout);
+	      fputs (_("no"), stdout);
 	    else
 	      printf ("%u", im);
-	    fputs (" impossibilities", stdout);
+	    fputs (_(" impossibilities"), stdout);
 	    if (dir->contents->dirstream == 0)
 	      puts (".");
 	    else
-	      puts (" so far.");
+	      puts (_(" so far."));
 	    files += f;
 	    impossible += im;
 	  }
@@ -956,15 +956,15 @@ print_dir_data_base ()

  fputs ("\n# ", stdout);
  if (files == 0)
-    fputs ("No", stdout);
+    fputs (_("No"), stdout);
  else
    printf ("%u", files);
-  fputs (" files, ", stdout);
+  fputs (_(" files, "), stdout);
  if (impossible == 0)
-    fputs ("no", stdout);
+    fputs (_("no"), stdout);
  else
    printf ("%u", impossible);
-  printf (" impossibilities in %u directories.\n", dirs);
+  printf (_(" impossibilities in %u directories.\n"), dirs);
 }

 /* Hooks for globbing.  */
--- a/expand.c
+++ b/expand.c
@@ -98,7 +98,8 @@ recursively_expand (v)
  if (v->expanding)
    /* Expanding V causes infinite recursion.  Lose.  */
    fatal (reading_file,
-           "Recursive variable `%s' references itself (eventually)", v->name);
+           _("Recursive variable `%s' references itself (eventually)"),
+           v->name);

  v->expanding = 1;
  value = allocated_variable_expand (v->value);
@@ -119,7 +120,7 @@ warn_undefined (name, length)
 {
  if (warn_undefined_variables_flag)
    error (reading_file,
-           "warning: undefined variable `%.*s'", (int)length, name);
+           _("warning: undefined variable `%.*s'"), (int)length, name);
 }

 /* Expand a simple reference to variable NAME, which is LENGTH chars long.  */
@@ -231,7 +232,7 @@ variable_expand_string (line, string, length)
 	    end = index (beg, closeparen);
 	    if (end == 0)
              /* Unterminated variable reference.  */
-              fatal (reading_file, "unterminated variable reference");
+              fatal (reading_file, _("unterminated variable reference"));
 	    p1 = lindex (beg, end, '$');
 	    if (p1 != 0)
 	      {
@@ -441,7 +442,10 @@ variable_expand_for_file (line, file)

  save = current_variable_set_list;
  current_variable_set_list = file->variables;
-  reading_file = &file->cmds->fileinfo;
+  if (file->cmds && file->cmds->fileinfo.filenm)
+    reading_file = &file->cmds->fileinfo;
+  else
+    reading_file = 0;
  fnext = file->variables->next;
  /* See if there's a pattern-specific variable struct for this target.  */
  if (!file->pat_searched)
--- a/file.c
+++ b/file.c
@@ -301,22 +301,22 @@ file_hash_enter (file, name, oldhash, oldname)
 		 but give a message to let the user know what's going on.  */
 	      if (oldfile->cmds->fileinfo.filenm != 0)
                error (&file->cmds->fileinfo,
-                                "Commands were specified for \
-file `%s' at %s:%lu,",
+                                _("Commands were specified for \
+file `%s' at %s:%lu,"),
                                oldname, oldfile->cmds->fileinfo.filenm,
                                oldfile->cmds->fileinfo.lineno);
 	      else
 		error (&file->cmds->fileinfo,
-				"Commands for file `%s' were found by \
-implicit rule search,",
+				_("Commands for file `%s' were found by \
+implicit rule search,"),
 				oldname);
 	      error (&file->cmds->fileinfo,
-			      "but `%s' is now considered the same file \
-as `%s'.",
+			      _("but `%s' is now considered the same file \
+as `%s'."),
 			      oldname, name);
 	      error (&file->cmds->fileinfo,
-			      "Commands for `%s' will be ignored \
-in favor of those for `%s'.",
+			      _("Commands for `%s' will be ignored \
+in favor of those for `%s'."),
 			      name, oldname);
 	    }
 	}
@@ -336,12 +336,12 @@ in favor of those for `%s'.",
      merge_variable_set_lists (&oldfile->variables, file->variables);

      if (oldfile->double_colon && file->is_target && !file->double_colon)
-	fatal (NILF, "can't rename single-colon `%s' to double-colon `%s'",
+	fatal (NILF, _("can't rename single-colon `%s' to double-colon `%s'"),
 	       oldname, name);
      if (!oldfile->double_colon  && file->double_colon)
 	{
 	  if (oldfile->is_target)
-	    fatal (NILF, "can't rename double-colon `%s' to single-colon `%s'",
+	    fatal (NILF, _("can't rename double-colon `%s' to single-colon `%s'"),
 		   oldname, name);
 	  else
 	    oldfile->double_colon = file->double_colon;
@@ -408,7 +408,7 @@ remove_intermediates (sig)
 	  if (!f->dontcare)
 	    {
 	      if (sig)
-		error (NILF, "*** Deleting intermediate file `%s'", f->name);
+		error (NILF, _("*** Deleting intermediate file `%s'"), f->name);
 	      else if (!silent_flag)
 		{
 		  if (! doneany)
@@ -612,7 +612,7 @@ print_file (f)

  putchar ('\n');
  if (!f->is_target)
-    puts ("# Not a target:");
+    puts (_("# Not a target:"));
  printf ("%s:%s", f->name, f->double_colon ? ":" : "");

  for (d = f->deps; d != 0; d = d->next)
@@ -620,45 +620,45 @@ print_file (f)
  putchar ('\n');

  if (f->precious)
-    puts ("#  Precious file (dependency of .PRECIOUS).");
+    puts (_("#  Precious file (prerequisite of .PRECIOUS)."));
  if (f->phony)
-    puts ("#  Phony target (dependency of .PHONY).");
+    puts (_("#  Phony target (prerequisite of .PHONY)."));
  if (f->cmd_target)
-    puts ("#  Command-line target.");
+    puts (_("#  Command-line target."));
  if (f->dontcare)
-    puts ("#  A default or MAKEFILES makefile.");
-  printf ("#  Implicit rule search has%s been done.\n",
-	  f->tried_implicit ? "" : " not");
+    puts (_("#  A default or MAKEFILES makefile."));
+  printf (_("#  Implicit rule search has%s been done.\n"),
+	  f->tried_implicit ? "" : _(" not"));
  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 dependency.");
+    puts (_("#  File is an intermediate prerequisite."));
  if (f->also_make != 0)
    {
-      fputs ("#  Also makes:", stdout);
+      fputs (_("#  Also makes:"), stdout);
      for (d = f->also_make; d != 0; d = d->next)
 	printf (" %s", dep_name (d));
      putchar ('\n');
    }
  if (f->last_mtime == 0)
-    puts ("#  Modification time never checked.");
+    puts (_("#  Modification time never checked."));
  else if (f->last_mtime == (FILE_TIMESTAMP) -1)
-    puts ("#  File does not exist.");
+    puts (_("#  File does not exist."));
  else
    {
      char buf[FILE_TIMESTAMP_PRINT_LEN_BOUND + 1];
      file_timestamp_sprintf (buf, f->last_mtime);
-      printf ("#  Last modified %s\n", buf);
+      printf (_("#  Last modified %s\n"), buf);
    }
-  printf ("#  File has%s been updated.\n",
-	  f->updated ? "" : " not");
+  printf (_("#  File has%s been updated.\n"),
+	  f->updated ? "" : _(" not"));
  switch (f->command_state)
    {
    case cs_running:
-      puts ("#  Commands currently running (THIS IS A BUG).");
+      puts (_("#  Commands currently running (THIS IS A BUG)."));
      break;
    case cs_deps_running:
-      puts ("#  Dependencies commands running (THIS IS A BUG).");
+      puts (_("#  Dependencies commands running (THIS IS A BUG)."));
      break;
    case cs_not_started:
    case cs_finished:
@@ -667,24 +667,24 @@ print_file (f)
 	case -1:
 	  break;
 	case 0:
-	  puts ("#  Successfully updated.");
+	  puts (_("#  Successfully updated."));
 	  break;
 	case 1:
 	  assert (question_flag);
-	  puts ("#  Needs to be updated (-q is set).");
+	  puts (_("#  Needs to be updated (-q is set)."));
 	  break;
 	case 2:
-	  puts ("#  Failed to be updated.");
+	  puts (_("#  Failed to be updated."));
 	  break;
 	default:
-	  puts ("#  Invalid value in `update_status' member!");
+	  puts (_("#  Invalid value in `update_status' member!"));
 	  fflush (stdout);
 	  fflush (stderr);
 	  abort ();
 	}
      break;
    default:
-      puts ("#  Invalid value in `command_state' member!");
+      puts (_("#  Invalid value in `command_state' member!"));
      fflush (stdout);
      fflush (stderr);
      abort ();
@@ -703,7 +703,7 @@ print_file_data_base ()
  register unsigned int i, nfiles, per_bucket;
  register struct file *file;

-  puts ("\n# Files");
+  puts (_("\n# Files"));

  per_bucket = nfiles = 0;
  for (i = 0; i < FILE_BUCKETS; ++i)
@@ -726,12 +726,12 @@ print_file_data_base ()
    }

  if (nfiles == 0)
-    puts ("\n# No files.");
+    puts (_("\n# No files."));
  else
    {
-      printf ("\n# %u files in %u hash buckets.\n", nfiles, FILE_BUCKETS);
+      printf (_("\n# %u files in %u hash buckets.\n"), nfiles, FILE_BUCKETS);
 #ifndef	NO_FLOAT
-      printf ("# average %.3f files per bucket, max %u files in one bucket.\n",
+      printf (_("# average %.3f files per bucket, max %u files in one bucket.\n"),
 	      ((double) nfiles) / ((double) FILE_BUCKETS), per_bucket);
 #endif
    }
--- a/function.c
+++ b/function.c
@@ -699,16 +699,13 @@ int
 is_numeric (p)
     char *p;
 {
-  char *end = p + strlen (p) -1;
+  char *end = p + strlen (p) - 1;
  char *beg = p;
  strip_whitespace (&p, &end);
-  while (p <= end)
-    {
-      if (!isdigit (*p))
-	return 0;

-      p++;
-    }
+  while (p <= end)
+    if (!ISDIGIT (*(p++)))  /* ISDIGIT only evals its arg once: see make.h.  */
+      return 0;

  return (end - beg >= 0);
 }
@@ -735,11 +732,11 @@ func_word(o, argv, funcname)
  char *p=0;

  /* 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 (reading_file, "the `word' function takes a positive index argument");
+    fatal (reading_file, _("the `word' function takes a positive index argument"));


  end_p = argv[1];
@@ -764,10 +761,10 @@ func_wordlist (o, argv, funcname)

  /* Check the first argument.  */
  check_numeric (argv[0],
-		 "non-numeric first argument to `wordlist' function");
+		 _("non-numeric first argument to `wordlist' function"));
  i =atoi(argv[0]);
  check_numeric (argv[1],
-		 "non-numeric second argument to `wordlist' function");
+		 _("non-numeric second argument to `wordlist' function"));

  j = atoi(argv[1]);

@@ -817,9 +814,9 @@ func_foreach (o, argv, funcname)
     const char *funcname;
 {
  /* expand only the first two.  */
-  char *varname = expand_argument (argv[0], argv[1] -1);
+  char *varname = expand_argument (argv[0], argv[1] - 1);
  char *list = expand_argument (argv[1], argv[2] -1);
-  char *body = savestring (argv[2], argv[3] - argv[2] -1 );
+  char *body = savestring (argv[2], argv[3] - argv[2] - 1);

  int len =0;
  char *list_iterator = list;
@@ -1075,6 +1072,68 @@ func_sort (o, argv, funcname)
  return o;
 }

+/*
+  $(if condition,true-part[,false-part])
+
+  CONDITION is false iff it evaluates to an empty string.  White
+  space before and after condition are stripped before evaluation.
+
+  If CONDITION is true, then TRUE-PART is evaluated, otherwise FALSE-PART is
+  evaluated (if it exists).  Because only one of the two PARTs is evaluated,
+  you can use $(if ...) to create side-effects (with $(shell ...), for
+  example).
+*/
+
+static char *
+func_if (o, argv, funcname)
+     char *o;
+     char **argv;
+     const char *funcname;
+{
+  char *begp = argv[0];
+  char *endp = argv[1]-1;
+  int result = 0;
+
+  /* Find the result of the condition: if we have a value, and it's not
+     empty, the condition is true.  If we don't have a value, or it's the
+     empty string, then it's false.  */
+
+  strip_whitespace (&begp, &endp);
+
+  if (begp < endp)
+    {
+      char *expansion = expand_argument (begp, endp);
+
+      result = strlen (expansion);
+      free (expansion);
+    }
+
+  /* If the result is true (1) we want to eval the first argument, and if
+     it's false (0) we want to eval the second.  If the argument doesn't
+     exist we do nothing, otherwise expand it and add to the buffer.  */
+
+  argv += 1 + !result;
+
+  if (argv[0] != NULL && argv[1] != NULL)
+    {
+      char *expansion;
+      char **endp = argv+1;
+
+      /* If we're doing the else-clause, make sure we concatenate any
+         potential extra arguments into the last argument.  */
+      if (!result)
+        while (*endp && **endp != '\0')
+          ++endp;
+
+      expansion = expand_argument (*argv, *endp-1);
+
+      o = variable_buffer_output (o, expansion, strlen (expansion));
+      free (expansion);
+    }
+
+  return o;
+}
+
 static char *
 func_wildcard(o, argv, funcname)
     char *o;
@@ -1156,7 +1215,7 @@ windows32_openpipe (int *pipedes, int *pid_p, char **command_argv, char **envp)
 		      0,
 		      TRUE,
 		      DUPLICATE_SAME_ACCESS) == FALSE) {
-    fatal (NILF, "create_child_process: DuplicateHandle(In) failed (e=%d)\n",
+    fatal (NILF, _("create_child_process: DuplicateHandle(In) failed (e=%d)\n"),
 	   GetLastError());

  }
@@ -1167,19 +1226,19 @@ windows32_openpipe (int *pipedes, int *pid_p, char **command_argv, char **envp)
 		      0,
 		      TRUE,
 		      DUPLICATE_SAME_ACCESS) == FALSE) {
-    fatal (NILF, "create_child_process: DuplicateHandle(Err) failed (e=%d)\n",
+    fatal (NILF, _("create_child_process: DuplicateHandle(Err) failed (e=%d)\n"),
 	   GetLastError());
  }

  if (!CreatePipe(&hChildOutRd, &hChildOutWr, &saAttr, 0))
-    fatal (NILF, "CreatePipe() failed (e=%d)\n", GetLastError());
+    fatal (NILF, _("CreatePipe() failed (e=%d)\n"), GetLastError());



  hProcess = process_init_fd(hIn, hChildOutWr, hErr);

  if (!hProcess)
-    fatal (NILF, "windows32_openpipe (): process_init_fd() failed\n");
+    fatal (NILF, _("windows32_openpipe (): process_init_fd() failed\n"));

  else
    process_register(hProcess);
@@ -1190,7 +1249,7 @@ windows32_openpipe (int *pipedes, int *pid_p, char **command_argv, char **envp)
  if (!process_begin(hProcess, command_argv, envp, command_argv[0], NULL))
    *pid_p = (int) hProcess;
  else
-    fatal (NILF, "windows32_openpipe (): unable to launch process (e=%d)\n",
+    fatal (NILF, _("windows32_openpipe (): unable to launch process (e=%d)\n"),
 	   process_last_err(hProcess));

  /* set up to read data from child */
@@ -1203,15 +1262,11 @@ windows32_openpipe (int *pipedes, int *pid_p, char **command_argv, char **envp)


 #ifdef __MSDOS__
-/*
-  untested
-*/
-int
+FILE *
 msdos_openpipe (int* pipedes, int *pidp, char *text)
 {
  FILE *fpipe=0;
-  /* MSDOS can't fork, but it has `popen'.
-     (Bwt, why isn't `popen' used in all the versions?) */
+  /* MSDOS can't fork, but it has `popen'.  */
  struct variable *sh = lookup_variable ("SHELL", 5);
  int e;
  extern int dos_command_running, dos_status;
@@ -1235,6 +1290,9 @@ msdos_openpipe (int* pipedes, int *pidp, char *text)
  errno = 0;
  dos_command_running = 1;
  dos_status = 0;
+  /* If dos_status becomes non-zero, it means the child process
+     was interrupted by a signal, like SIGINT or SIGQUIT.  See
+     fatal_error_signal in commands.c.  */
  fpipe = popen (text, "rt");
  dos_command_running = 0;
  if (!fpipe || dos_status)
@@ -1250,7 +1308,7 @@ msdos_openpipe (int* pipedes, int *pidp, char *text)
  else
    {
      pipedes[0] = fileno (fpipe);
-      *pidp = 42;		/* uh? The meaning of Life?*/
+      *pidp = 42; /* Yes, the Meaning of Life, the Universe, and Everything! */
      errno = e;
      shell_function_completed = 1;
    }
@@ -1308,11 +1366,9 @@ func_shell (o, argv, funcname)
  /* For error messages.  */
  if (reading_file != 0)
    {
-       error_prefix = (char *) alloca (strlen(reading_file->filenm)+100);
-
+      error_prefix = (char *) alloca (strlen(reading_file->filenm)+11+4);
      sprintf (error_prefix,
 	       "%s:%lu: ", reading_file->filenm, reading_file->lineno);
-
    }
  else
    error_prefix = "";
@@ -1322,11 +1378,11 @@ func_shell (o, argv, funcname)
 #else /* WINDOWS32 */

 # ifdef __MSDOS__
-  fpipe = msdos_openpipe (pipedes, argv[0], command_argv, envp);
-  if (!fpipe || pipedes[0] < 0)
+  fpipe = msdos_openpipe (pipedes, &pid, argv[0]);
+  if (pipedes[0] < 0)
    {
-      	perror_with_name (error_prefix, "pipe");
-	return o;
+      perror_with_name (error_prefix, "pipe");
+      return o;
    }
 # else
  if (pipe (pipedes) < 0)
@@ -1384,11 +1440,7 @@ func_shell (o, argv, funcname)
 	  if (cc > 0)
 	    i += cc;
 	}
-#ifdef EINTR
-      while (cc > 0 || errno == EINTR);
-#else
-      while (cc > 0);
-#endif
+      while (cc > 0 || EINTR_SET);

      /* Close the read side of the pipe.  */
 #ifdef  __MSDOS__
@@ -1405,7 +1457,7 @@ func_shell (o, argv, funcname)

      if (batch_filename) {
 	if (debug_flag)
-	  printf("Cleaning up temporary batch file %s\n", batch_filename);
+	  printf(_("Cleaning up temporary batch file %s\n"), batch_filename);
 	remove(batch_filename);
 	free(batch_filename);
      }
@@ -1553,54 +1605,6 @@ func_not (char* o, char **argv, char *funcname)
  o = variable_buffer_output (o,  result ? "1" : "", result);
  return o;
 }
-
-
-
-/*
- This is an experimental conditional function.
-
- Syntax:
-
-    $(if condition, true-part, false-part)
-
- This is fully not consistent with make's syntax, but more in line
- with `normal' programming languages.
-
- Semantics:
-
- - CONDITION is false iff it evaluates to an empty string.  White
- space before and after condition are stripped before evaluation.
-
- - If CONDITION is true, then TRUE-PART is evaluated, otherwise
- FALSE-PART is evaluated.  Because only one of the two PARTs is
- evaluated, you can use $(if ) to create side-effects with the
- $(shell ) function
-
- */
-static char *
-func_if (char* o, char **argv, char *funcname)
-{
-  char *begp = argv[0];
-  char *endp = argv[1]-2;
-  char *expansion =0;
-  int result = 0;
-
-  strip_whitespace (&begp, &endp);
-  if(begp <= endp)
-    expansion = expand_argument (begp, endp + 1);
-
-  result = expansion
-    ? strlen (expansion)
-    : 0;
-
-  result = !result;
-  free (expansion);
-
-  expansion = expand_argument (argv[1 + result], argv[2+result] -1);
-  o = variable_buffer_output (o, expansion, strlen (expansion));
-
-  return o;
-}
 #endif


@@ -1652,9 +1656,9 @@ static struct function_table_entry function_table[] =
  { STRING_SIZE_TUPLE("call"),         -1,  1,  func_call},
  { STRING_SIZE_TUPLE("error"),         1,  1,  func_error},
  { STRING_SIZE_TUPLE("warning"),       1,  1,  func_error},
+  { STRING_SIZE_TUPLE("if"),           -2,  0,  func_if},
 #ifdef EXPERIMENTAL
  { STRING_SIZE_TUPLE("eq"),            2,  1,  func_eq},
-  { STRING_SIZE_TUPLE("if"),            3,  0,  func_if},
  { STRING_SIZE_TUPLE("not"),           1,  1,  func_not},
 #endif
  { 0 }
@@ -1676,11 +1680,11 @@ expand_builtin_function (o, argc, argv, entry_p)

  if (argc < min)
    fatal (reading_file,
-           "Insufficient number of arguments (%d) to function `%s'",
+           _("Insufficient number of arguments (%d) to function `%s'"),
           argc, entry_p->name);

  if (!entry_p->func_ptr)
-    fatal (reading_file, "Unimplemented on this platform: function `%s'",
+    fatal (reading_file, _("Unimplemented on this platform: function `%s'"),
           entry_p->name);

  return entry_p->func_ptr (o, argv, entry_p->name);
@@ -1736,7 +1740,7 @@ handle_function (op, stringp)

  if (count >= 0)
    fatal (reading_file,
-	   "unterminated call to function `%s': missing `%c'",
+	   _("unterminated call to function `%s': missing `%c'"),
 	   entry_p->name, closeparen);

  /* Get some memory to store the arg pointers.  */
--- a/implicit.c
+++ b/implicit.c
@@ -36,7 +36,7 @@ try_implicit_rule (file, depth)
     struct file *file;
     unsigned int depth;
 {
-  DEBUGPR ("Looking for an implicit rule for `%s'.\n");
+  DEBUGPR (_("Looking for an implicit rule for `%s'.\n"));

  /* The order of these searches was previously reversed.  My logic now is
     that since the non-archive search uses more information in the target
@@ -51,7 +51,7 @@ try_implicit_rule (file, depth)
     archive member name to search for implicit rules.  */
  if (ar_name (file->name))
    {
-      DEBUGPR ("Looking for archive-member implicit rule for `%s'.\n");
+      DEBUGPR (_("Looking for archive-member implicit rule for `%s'.\n"));
      if (pattern_search (file, 1, depth, 0))
 	return 1;
    }
@@ -199,7 +199,7 @@ pattern_search (file, archive, depth, recursions)
 	 don't use it here.  */
      if (rule->in_use)
 	{
-	  DEBUGP2 ("Avoiding implicit rule recursion.%s%s\n", "", "");
+	  DEBUGP2 (_("Avoiding implicit rule recursion.%s%s\n"), "", "");
 	  continue;
 	}

@@ -335,7 +335,7 @@ pattern_search (file, archive, depth, recursions)
 	      stemlen -= (lastslash - filename) + 1;
 	    }

-	  DEBUGP2 ("Trying pattern rule with stem `%.*s'.\n",
+	  DEBUGP2 (_("Trying pattern rule with stem `%.*s'.\n"),
 		   (int) stemlen, stem);

 	  /* Try each dependency; see if it "exists".  */
@@ -376,16 +376,16 @@ pattern_search (file, archive, depth, recursions)
 		     "impossible", then the rule fails and don't
 		     bother trying it on the second pass either
 		     since we know that will fail too.  */
-		  DEBUGP2 ("Rejecting impossible %s dependency `%s'.\n",
-			   p == depname ? "implicit" : "rule", p);
+		  DEBUGP2 (_("Rejecting impossible %s prerequisite `%s'.\n"),
+			   p == depname ? _("implicit") : _("rule"), p);
 		  tryrules[i] = 0;
 		  break;
 		}

 	      intermediate_files[deps_found] = 0;

-	      DEBUGP2 ("Trying %s dependency `%s'.\n",
-		       p == depname ? "implicit" : "rule", p);
+	      DEBUGP2 (_("Trying %s prerequisite `%s'.\n"),
+		       p == depname ? _("implicit") : _("rule"), p);

 	      /* The DEP->changed flag says that this dependency resides in a
 		 nonexistent directory.  So we normally can skip looking for
@@ -408,8 +408,9 @@ pattern_search (file, archive, depth, recursions)
 	      vp = p;
 	      if (vpath_search (&vp, (FILE_TIMESTAMP *) 0))
 		{
-		  DEBUGP2 ("Found dependency `%s' as VPATH `%s'\n", p, vp);
-		  strcpy(vp, p);
+		  DEBUGP2 (_("Found prerequisite `%s' as VPATH `%s'\n"),
+                           p, vp);
+		  strcpy (vp, p);
 		  found_files[deps_found++] = vp;
 		  continue;
 		}
@@ -424,8 +425,8 @@ pattern_search (file, archive, depth, recursions)
 		    intermediate_file
 		      = (struct file *) alloca (sizeof (struct file));

-		  DEBUGP2 ("Looking for a rule with %s file `%s'.\n",
-			   "intermediate", p);
+		  DEBUGP2 (_("Looking for a rule with %s file `%s'.\n"),
+			   _("intermediate"), p);

 		  bzero ((char *) intermediate_file, sizeof (struct file));
 		  intermediate_file->name = p;
--- a/job.c
+++ b/job.c
@@ -145,6 +145,17 @@ extern int wait ();

 #endif	/* Don't have `union wait'.  */

+/* How to set close-on-exec for a file descriptor.  */
+
+#if !defined F_SETFD
+# define CLOSE_ON_EXEC(_d)
+#else
+# ifndef FD_CLOEXEC
+#  define FD_CLOEXEC 1
+# endif
+# define CLOSE_ON_EXEC(_d) (void) fcntl ((_d), F_SETFD, FD_CLOEXEC)
+#endif
+
 #ifdef VMS
 static int vms_jobsefnmask = 0;
 #endif /* !VMS */
@@ -198,6 +209,9 @@ static struct child *waiting_jobs = 0;
 /* Non-zero if we use a *real* shell (always so on Unix).  */

 int unixy_shell = 1;
+
+/* #define debug_flag 1 */
+

 #ifdef WINDOWS32
 /*
@@ -205,10 +219,11 @@ int unixy_shell = 1;
 */
 int w32_kill(int pid, int sig)
 {
-       return ((process_kill(pid, sig) == TRUE) ? 0 : -1);
+  return ((process_kill(pid, sig) == TRUE) ? 0 : -1);
 }
 #endif /* WINDOWS32 */

+
 /* Write an error message describing the exit status given in
   EXIT_CODE, EXIT_SIG, and COREDUMP, for the target TARGET_NAME.
   Append "(ignored)" if IGNORED is nonzero.  */
@@ -224,16 +239,16 @@ child_error (target_name, exit_code, exit_sig, coredump, ignored)

 #ifdef VMS
  if (!(exit_code & 1))
-      error (NILF, "*** [%s] Error 0x%x%s", target_name, exit_code, ((ignored)? " (ignored)" : ""));
+      error (NILF, _("*** [%s] Error 0x%x%s"), target_name, exit_code, ((ignored)? _(" (ignored)") : ""));
 #else
  if (exit_sig == 0)
-    error (NILF, ignored ? "[%s] Error %d (ignored)" :
-	   "*** [%s] Error %d",
+    error (NILF, ignored ? _("[%s] Error %d (ignored)") :
+	   _("*** [%s] Error %d"),
 	   target_name, exit_code);
  else
    error (NILF, "*** [%s] %s%s",
 	   target_name, strsignal (exit_sig),
-	   coredump ? " (core dumped)" : "");
+	   coredump ? _(" (core dumped)") : "");
 #endif /* VMS */
 }

@@ -257,47 +272,66 @@ vmsWaitForChildren(int *status)
 #endif


-/* Count the number of dead children we have.  If we can use wait3() or
-   waitpid() then we'll never use this count: it's completely unnecessary.
-   But we need the handler installed to interrupt the select() call for
-   the jobs pipe, so we might as well keep it.  */
+/* 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 don't have either waitpid or wait3, then make is unreliable, but we
+   use the dead_children count to reap children as best we can.  */

 static unsigned int dead_children = 0;

-/* Notice that a child died.
-   reap_children should be called when convenient.  */
 RETSIGTYPE
 child_handler (sig)
     int sig;
 {
  ++dead_children;

+  if (job_rfd >= 0)
+    {
+      close (job_rfd);
+      job_rfd = -1;
+    }
+
  if (debug_flag)
-    printf ("Got a SIGCHLD; %u unreaped children.\n", dead_children);
+    printf (_("Got a SIGCHLD; %u unreaped children.\n"), dead_children);
 }


 extern int shell_function_pid, shell_function_completed;

-/* Reap dead children, storing the returned status and the new command
+/* 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
-   dead child, and removing the child from the chain.  If BLOCK nonzero,
-   reap at least one child, waiting for it to die if necessary.  If ERR is
-   nonzero, print an error message first.  */
+   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
+   complete child, waiting for it to die if necessary.  If ERR is nonzero,
+   print an error message first.  */

 void
 reap_children (block, err)
     int block, err;
 {
  WAIT_T status;
-#ifdef WAIT_NOHANG
  /* Initially, assume we have some.  */
  int reap_more = 1;
+
+#ifdef WAIT_NOHANG
 # define REAP_MORE reap_more
 #else
 # define REAP_MORE dead_children
 #endif

+  /* As long as:
+
+       We have at least one child outstanding OR a shell function in progress,
+         AND
+       We're blocking for a complete child OR there are more children to reap
+
+     we'll keep reaping children.  */
+
  while ((children != 0 || shell_function_pid != 0) &&
 	 (block || REAP_MORE))
    {
@@ -312,7 +346,7 @@ reap_children (block, err)
 	{
 	  /* We might block for a while, so let the user know why.  */
 	  fflush (stdout);
-	  error (NILF, "*** Waiting for unfinished jobs....");
+	  error (NILF, _("*** Waiting for unfinished jobs...."));
 	}

      /* We have one less dead child to reap.  As noted in
@@ -342,9 +376,9 @@ reap_children (block, err)
 	  any_remote |= c->remote;
 	  any_local |= ! c->remote;
 	  if (debug_flag)
-	    printf ("Live child 0x%08lx PID %ld%s\n",
-		    (unsigned long int) c,
-		    (long) c->pid, c->remote ? " (remote)" : "");
+	    printf (_("Live child 0x%08lx (%s) PID %ld %s\n"),
+		    (unsigned long int) c, c->file->name,
+                    (long) c->pid, c->remote ? _(" (remote)") : "");
 #ifdef VMS
 	  break;
 #endif
@@ -363,19 +397,18 @@ reap_children (block, err)
 	{
          /* A remote status command failed miserably.  Punt.  */
 	remote_status_lose:
-#ifdef	EINTR
-	  if (errno == EINTR)
+	  if (EINTR_SET)
 	    continue;
-#endif
+
 	  pfatal_with_name ("remote_status");
 	}
      else
 	{
 	  /* No remote children.  Check for local children.  */
-
 #if !defined(__MSDOS__) && !defined(_AMIGA) && !defined(WINDOWS32)
 	  if (any_local)
 	    {
+            local_wait:
 #ifdef VMS
 	      vmsWaitForChildren (&status);
 	      pid = c->pid;
@@ -393,16 +426,16 @@ reap_children (block, err)

 	  if (pid < 0)
 	    {
+              /* EINTR?  Try again. */
+	      if (EINTR_SET)
+		goto local_wait;
+
              /* The wait*() failed miserably.  Punt.  */
-#ifdef EINTR
-	      if (errno == EINTR)
-		continue;
-#endif
 	      pfatal_with_name ("wait");
 	    }
 	  else if (pid > 0)
 	    {
-	      /* We got one; chop the status word up.  */
+	      /* We got a child exit; chop the status word up.  */
 	      exit_code = WEXITSTATUS (status);
 	      exit_sig = WIFSIGNALED (status) ? WTERMSIG (status) : 0;
 	      coredump = WCOREDUMP (status);
@@ -410,26 +443,24 @@ reap_children (block, err)
 	  else
 	    {
 	      /* No local children are dead.  */
-#ifdef WAIT_NOHANG
              reap_more = 0;
-#endif
-	      if (block && any_remote)
-		{
-		  /* Now try a blocking wait for a remote child.  */
-		  pid = remote_status (&exit_code, &exit_sig, &coredump, 1);
-		  if (pid < 0)
-		    goto remote_status_lose;
-		  else if (pid == 0)
-		    /* No remote children either.  Finally give up.  */
-		    break;
-		  else
-		    /* We got a remote child.  */
-		    remote = 1;
-		}
-	      else
-		break;
+
+	      if (!block || !any_remote)
+                break;
+
+              /* Now try a blocking wait for a remote child.  */
+              pid = remote_status (&exit_code, &exit_sig, &coredump, 1);
+              if (pid < 0)
+                goto remote_status_lose;
+              else if (pid == 0)
+                /* No remote children either.  Finally give up.  */
+                break;
+
+              /* We got a remote child.  */
+              remote = 1;
 	    }
 #endif /* !__MSDOS__, !Amiga, !WINDOWS32.  */
+
 #ifdef __MSDOS__
 	  /* Life is very different on MSDOS.  */
 	  pid = dos_pid - 1;
@@ -499,162 +530,147 @@ reap_children (block, err)
 	  break;

      if (c == 0)
-	{
-	  /* An unknown child died.
-             Ignore it; it was inherited from our invoker.  */
-          continue;
-	}
+        /* An unknown child died.
+           Ignore it; it was inherited from our invoker.  */
+        continue;
+
+      if (debug_flag)
+        printf (_("Reaping %s child 0x%08lx PID %ld %s\n"),
+                child_failed ? _("losing") : _("winning"),
+                (unsigned long int) c, (long) c->pid,
+                c->remote ? _(" (remote)") : "");
+
+      if (c->sh_batch_file) {
+        if (debug_flag)
+          printf (_("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 this child had the good stdin, say it is now free.  */
+      if (c->good_stdin)
+        good_stdin_used = 0;
+
+      if (child_failed && !c->noerror && !ignore_errors_flag)
+        {
+          /* The commands failed.  Write an error message,
+             delete non-precious targets, and abort.  */
+          static int delete_on_error = -1;
+          child_error (c->file->name, exit_code, exit_sig, coredump, 0);
+          c->file->update_status = 2;
+          if (delete_on_error == -1)
+            {
+              struct file *f = lookup_file (".DELETE_ON_ERROR");
+              delete_on_error = f != 0 && f->is_target;
+            }
+          if (exit_sig != 0 || delete_on_error)
+            delete_child_targets (c);
+        }
      else
-	{
-	  if (debug_flag)
-	    printf ("Reaping %s child 0x%08lx PID %ld%s\n",
-		    child_failed ? "losing" : "winning",
-		    (unsigned long int) c,
-		    (long) c->pid, c->remote ? " (remote)" : "");
+        {
+          if (child_failed)
+            {
+              /* The commands failed, but we don't care.  */
+              child_error (c->file->name,
+                           exit_code, exit_sig, coredump, 1);
+              child_failed = 0;
+            }

-          if (c->sh_batch_file) {
-            if (debug_flag)
-              printf("Cleaning up temp batch file %s\n", c->sh_batch_file);
+          /* If there are more commands to run, try to start them.  */
+          if (job_next_command (c))
+            {
+              if (handling_fatal_signal)
+                {
+                  /* Never start new commands while we are dying.
+                     Since there are more commands that wanted to be run,
+                     the target was not completely remade.  So we treat
+                     this as if a command had failed.  */
+                  c->file->update_status = 2;
+                }
+              else
+                {
+                  /* Check again whether to start remotely.
+                     Whether or not we want to changes over time.
+                     Also, start_remote_job may need state set up
+                     by start_remote_job_p.  */
+                  c->remote = start_remote_job_p (0);
+                  start_job_command (c);
+                  /* Fatal signals are left blocked in case we were
+                     about to put that child on the chain.  But it is
+                     already there, so it is safe for a fatal signal to
+                     arrive now; it will clean up this child's targets.  */
+                  unblock_sigs ();
+                  if (c->file->command_state == cs_running)
+                    /* We successfully started the new command.
+                       Loop to reap more children.  */
+                    continue;
+                }

-            /* just try and remove, don't care if this fails */
-            remove(c->sh_batch_file);
+              if (c->file->update_status != 0)
+                /* We failed to start the commands.  */
+                delete_child_targets (c);
+            }
+          else
+            /* There are no more commands.  We got through them all
+               without an unignored error.  Now the target has been
+               successfully updated.  */
+            c->file->update_status = 0;
+        }

-            /* all done with memory */
-            free(c->sh_batch_file);
-            c->sh_batch_file = NULL;
-          }
+      /* 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
+         ran; notice_finish_file looks for cs_running to tell it that
+         it's interesting to check the file's modtime again now.  */

-	  /* If this child had the good stdin, say it is now free.  */
-	  if (c->good_stdin)
-	    good_stdin_used = 0;
+      if (! handling_fatal_signal)
+        /* Notice if the target of the commands has been changed.
+           This also propagates its values for command_state and
+           update_status to its also_make files.  */
+        notice_finished_file (c->file);

-	  if (child_failed && !c->noerror && !ignore_errors_flag)
-	    {
-	      /* The commands failed.  Write an error message,
-		 delete non-precious targets, and abort.  */
-	      static int delete_on_error = -1;
-	      child_error (c->file->name, exit_code, exit_sig, coredump, 0);
-	      c->file->update_status = 2;
-	      if (delete_on_error == -1)
-		{
-		  struct file *f = lookup_file (".DELETE_ON_ERROR");
-		  delete_on_error = f != 0 && f->is_target;
-		}
-	      if (exit_sig != 0 || delete_on_error)
-		delete_child_targets (c);
-	    }
-	  else
-	    {
-	      if (child_failed)
-		{
-		  /* The commands failed, but we don't care.  */
-		  child_error (c->file->name,
-			       exit_code, exit_sig, coredump, 1);
-		  child_failed = 0;
-		}
+      if (debug_flag)
+        printf (_("Removing child 0x%08lx PID %ld %s from chain.\n"),
+                (unsigned long int) c, (long) c->pid,
+                c->remote ? _(" (remote)") : "");

-	      /* If there are more commands to run, try to start them.  */
-	      if (job_next_command (c))
-		{
-		  if (handling_fatal_signal)
-		    {
-		      /* Never start new commands while we are dying.
-			 Since there are more commands that wanted to be run,
-			 the target was not completely remade.  So we treat
-			 this as if a command had failed.  */
-		      c->file->update_status = 2;
-		    }
-		  else
-		    {
-		      /* Check again whether to start remotely.
-			 Whether or not we want to changes over time.
-			 Also, start_remote_job may need state set up
-			 by start_remote_job_p.  */
-		      c->remote = start_remote_job_p (0);
-		      start_job_command (c);
-		      /* Fatal signals are left blocked in case we were
-			 about to put that child on the chain.  But it is
-			 already there, so it is safe for a fatal signal to
-			 arrive now; it will clean up this child's targets.  */
-		      unblock_sigs ();
-		      if (c->file->command_state == cs_running)
-			/* We successfully started the new command.
-			   Loop to reap more children.  */
-			continue;
-		    }
+      /* Block fatal signals while frobnicating the list, so that
+         children and job_slots_used are always consistent.  Otherwise
+         a fatal signal arriving after the child is off the chain and
+         before job_slots_used is decremented would believe a child was
+         live and call reap_children again.  */
+      block_sigs ();

-		  if (c->file->update_status != 0)
-		    /* We failed to start the commands.  */
-		    delete_child_targets (c);
-		}
-	      else
-		/* There are no more commands.  We got through them all
-		   without an unignored error.  Now the target has been
-		   successfully updated.  */
-		c->file->update_status = 0;
-	    }
+      /* There is now another slot open.  */
+      if (job_slots_used > 0)
+        --job_slots_used;

-	  /* 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
-	     ran; notice_finish_file looks for cs_running to tell it that
-	     it's interesting to check the file's modtime again now.  */
+      /* Remove the child from the chain and free it.  */
+      if (lastc == 0)
+        children = c->next;
+      else
+        lastc->next = c->next;

-	  if (! handling_fatal_signal)
-	    /* Notice if the target of the commands has been changed.
-	       This also propagates its values for command_state and
-	       update_status to its also_make files.  */
-	    notice_finished_file (c->file);
+      free_child (c);

-	  if (debug_flag)
-	    printf ("Removing child 0x%08lx PID %ld%s from chain.\n",
-		    (unsigned long int) c,
-		    (long) c->pid, c->remote ? " (remote)" : "");
+      unblock_sigs ();

-	  /* Block fatal signals while frobnicating the list, so that
-	     children and job_slots_used are always consistent.  Otherwise
-	     a fatal signal arriving after the child is off the chain and
-	     before job_slots_used is decremented would believe a child was
-	     live and call reap_children again.  */
-	  block_sigs ();
-
-#ifdef MAKE_JOBSERVER
-	  /* If this job has a token out, return it.  */
-          if (c->job_token)
-	    {
-	      assert(job_slots_used > 0);
-	      write (job_fds[1], &c->job_token, 1);
-	      if (debug_flag)
-		printf ("Released token `%c' for child 0x%08lx.\n",
-			c->job_token, (unsigned long int) c);
-	      c->job_token = 0;
-	    }
-#endif
-	  /* There is now another slot open.  */
-	  if (job_slots_used > 0)
-	    --job_slots_used;
-
-	  /* Remove the child from the chain and free it.  */
-	  if (lastc == 0)
-	    children = c->next;
-	  else
-	    lastc->next = c->next;
-	  if (! handling_fatal_signal) /* Don't bother if about to die.  */
-	    free_child (c);
-
-	  unblock_sigs ();
-
-	  /* If the job failed, and the -k flag was not given, die,
-	     unless we are already in the process of dying.  */
-	  if (!err && child_failed && !keep_going_flag &&
-	      /* fatal_error_signal will die with the right signal.  */
-	      !handling_fatal_signal)
-	    die (2);
-	}
+      /* If the job failed, and the -k flag was not given, die,
+         unless we are already in the process of dying.  */
+      if (!err && child_failed && !keep_going_flag &&
+          /* fatal_error_signal will die with the right signal.  */
+          !handling_fatal_signal)
+        die (2);

      /* Only block for one child.  */
      block = 0;
    }
+
  return;
 }

@@ -664,6 +680,28 @@ static void
 free_child (child)
     register struct child *child;
 {
+  /* If this child is the only one it was our "free" job, so don't put a
+     token back for it.  This child has already been removed from the list,
+     so if there any left this wasn't the last one.  */
+
+  if (job_fds[1] >= 0 && children)
+    {
+      char token = '+';
+
+      /* Write a job token back to the pipe.  */
+
+      while (write (job_fds[1], &token, 1) != 1)
+        if (!EINTR_SET)
+          pfatal_with_name (_("write jobserver"));
+
+      if (debug_flag)
+        printf (_("Released token for child 0x%08lx (%s).\n"),
+                (unsigned long int) child, child->file->name);
+    }
+
+  if (handling_fatal_signal) /* Don't bother free'ing if about to die.  */
+    return;
+
  if (child->command_lines != 0)
    {
      register unsigned int i;
@@ -680,19 +718,6 @@ free_child (child)
      free ((char *) child->environment);
    }

-#ifdef MAKE_JOBSERVER
-  /* If this child has a token it hasn't relinquished, give it up now.
-     This can happen if the job completes immediately, mainly because
-     all the command lines evaluated to empty strings.  */
-  if (child->job_token)
-    {
-      write (job_fds[1], &child->job_token, 1);
-      if (debug_flag)
-	printf ("Freed token `%c' for child 0x%08lx.\n",
-		child->job_token, (unsigned long int) child);
-    }
-#endif
-
  free ((char *) child);
 }

@@ -764,7 +789,7 @@ start_job_command (child)
 	flags |= COMMANDS_RECURSE;
      else if (*p == '-')
 	child->noerror = 1;
-      else if (!isblank (*p) && *p != '+')
+      else if (!isblank (*p))
 	break;
      ++p;
    }
@@ -840,17 +865,18 @@ start_job_command (child)
 	   ? "%s" : (char *) 0, p);

  /* Optimize an empty command.  People use this for timestamp rules,
-     and forking a useless shell all the time leads to inefficiency. */
+     so avoid forking a useless shell.  */

 #if !defined(VMS) && !defined(_AMIGA)
  if (
 #ifdef __MSDOS__
      unixy_shell	/* the test is complicated and we already did it */
 #else
-      (argv[0] && !strcmp(argv[0], "/bin/sh"))
+      (argv[0] && !strcmp (argv[0], "/bin/sh"))
 #endif
-      && (argv[1] && !strcmp(argv[1], "-c"))
-      && (argv[2] && !strcmp(argv[2], ":"))
+      && (argv[1]
+          && argv[1][0] == '-' && argv[1][1] == 'c' && argv[1][2] == '\0')
+      && (argv[2] && argv[2][0] == ':' && argv[2][1] == '\0')
      && argv[3] == NULL)
    {
      free (argv[0]);
@@ -904,12 +930,7 @@ start_job_command (child)
 	  /* 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.  */
-#ifdef F_SETFD
-#ifndef FD_CLOEXEC
-#define FD_CLOEXEC 1
-#endif
-	  (void) fcntl (bad_stdin, F_SETFD, FD_CLOEXEC);
-#endif
+	  CLOSE_ON_EXEC (bad_stdin);
 	}
    }

@@ -986,6 +1007,17 @@ start_job_command (child)
 	{
 	  /* 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);
+
 	  child_execute_job (child->good_stdin ? 0 : bad_stdin, 1,
                             argv, child->environment);
 	}
@@ -1090,11 +1122,11 @@ start_job_command (child)
        int i;
        unblock_sigs();
        fprintf(stderr,
-          "process_easy() failed failed to launch process (e=%d)\n",
+          _("process_easy() failed failed to launch process (e=%d)\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);
+               fprintf(stderr, _("\nCounted %d args in failed launch\n"), i);
      }
  }
 #endif /* WINDOWS32 */
@@ -1135,64 +1167,16 @@ start_waiting_job (c)

  c->remote = start_remote_job_p (1);

-  /* If not, start it locally.  */
-  if (!c->remote)
+  /* If we are running at least one job already and the load average
+     is too high, make this one wait.  */
+  if (!c->remote && job_slots_used > 0 && load_too_high ())
    {
-#ifdef MAKE_JOBSERVER
-      /* If this is not a recurse command and we are controlling
-	 multiple jobs, and we don't yet have one, obtain a token before
-         starting child. */
-      if (job_fds[0] >= 0 && !f->cmds->any_recurse && !c->job_token)
-	{
-	  fd_set rfds;
-
-	  FD_ZERO(&rfds);
-	  FD_SET(job_fds[0], &rfds);
-
-	  /* Read a token.  We set the non-blocking bit on this earlier,
-	     so if there's no token to be read we'll fall through to the
-	     select.  The select blocks until (a) there's data to read,
-	     in which case we come back around and try to grab the token
-	     before someone else does, or (b) a signal, such as SIGCHLD,
-	     is caught (because we installed a handler for it).  If the
-	     latter, call reap_children() to try to free up some slots.  */
-
-	  while (read (job_fds[0], &c->job_token, 1) < 1)
-	    {
-	      int r = select (job_fds[0]+1, SELECT_FD_SET_CAST &rfds,
-                              NULL, NULL, NULL);
-
-	      if (r < 0)
-		{
-#ifdef EINTR
-		  if (errno != EINTR)
-		    /* We should definitely handle this more gracefully!
-		       What kinds of things can happen here?  ^C closes the
-		       pipe?  Something else closes it?  */
-		    pfatal_with_name ("read jobs pipe");
-#endif
-		  /* We were interrupted; handle any dead children.  */
-		  reap_children (1, 0);
-		}
-	    }
-
-	  assert(c->job_token != 0);
-	  if (debug_flag)
-	    printf ("Obtained token `%c' for child 0x%08lx.\n",
-		    c->job_token, (unsigned long int) c);
-	}
-#endif
-      /* If we are running at least one job already and the load average
-	 is too high, make this one wait.  */
-      if (job_slots_used > 0 && load_too_high ())
-	{
-	  /* Put this child on the chain of children waiting
-	     for the load average to go down.  */
-	  set_command_state (f, cs_running);
-	  c->next = waiting_jobs;
-	  waiting_jobs = c;
-	  return 0;
-	}
+      /* Put this child on the chain of children waiting for the load average
+         to go down.  */
+      set_command_state (f, cs_running);
+      c->next = waiting_jobs;
+      waiting_jobs = c;
+      return 0;
    }

  /* Start the first command; reap_children will run later command lines.  */
@@ -1203,9 +1187,9 @@ start_waiting_job (c)
    case cs_running:
      c->next = children;
      if (debug_flag)
-	printf ("Putting child 0x%08lx PID %ld%s on the chain.\n",
-		(unsigned long int) c,
-		(long) c->pid, c->remote ? " (remote)" : "");
+	printf (_("Putting child 0x%08lx (%s) PID %ld%s on the chain.\n"),
+		(unsigned long int) c, c->file->name,
+                (long) c->pid, c->remote ? _(" (remote)") : "");
      children = c;
      /* One more job slot is in use.  */
      ++job_slots_used;
@@ -1251,12 +1235,6 @@ new_job (file)
  /* Chop the commands up into lines if they aren't already.  */
  chop_commands (cmds);

-  /* Wait for a job slot to be freed up.  If we allow an infinite number
-     don't bother; also job_slots will == 0 if we're using the job pipe.  */
-  if (job_slots != 0)
-    while (job_slots_used == job_slots)
-      reap_children (1, 0);
-
  /* Expand the command lines and store the results in LINES.  */
  lines = (char **) xmalloc (cmds->ncommand_lines * sizeof (char *));
  for (i = 0; i < cmds->ncommand_lines; ++i)
@@ -1368,14 +1346,69 @@ new_job (file)
  c->command_ptr = 0;
  c->environment = 0;
  c->sh_batch_file = NULL;
-  c->job_token = 0;

  /* Fetch the first command line to be run.  */
  job_next_command (c);

+  /* Wait for a job slot to be freed up.  If we allow an infinite number
+     don't bother; also job_slots will == 0 if we're using the jobserver.  */
+
+  if (job_slots != 0)
+    while (job_slots_used == job_slots)
+      reap_children (1, 0);
+
+#ifdef MAKE_JOBSERVER
+  /* If we are controlling multiple jobs make sure we have a token before
+     starting the child. */
+
+  /* This can be inefficient.  There's a decent chance that this job won't
+     actually have to run any subprocesses: the command script may be empty
+     or otherwise optimized away.  It would be nice if we could defer
+     obtaining a token until just before we need it, in start_job_command.
+     To do that we'd need to keep track of whether we'd already obtained a
+     token (since start_job_command is called for each line of the job, not
+     just once).  Also more thought needs to go into the entire algorithm;
+     this is where the old parallel job code waits, so...  */
+
+  else if (job_fds[0] >= 0)
+    while (1)
+      {
+        char token;
+
+        /* If we don't already have a job started, use our "free" token.  */
+        if (!children)
+          break;
+
+        /* Read a token.  As long as there's no token available we'll block.
+           If we get a SIGCHLD we'll return with EINTR.  If one happened
+           before we got here we'll return immediately with EBADF because
+           the signal handler closes the dup'd file descriptor.  */
+
+        if (read (job_rfd, &token, 1) == 1)
+          {
+            if (debug_flag)
+              printf (_("Obtained token for child 0x%08lx (%s).\n"),
+                      (unsigned long int) c, c->file->name);
+            break;
+          }
+
+        if (errno != EINTR && errno != EBADF)
+          pfatal_with_name (_("read jobs pipe"));
+
+        /* Re-dup the read side of the pipe, so the signal handler can
+           notify us if we miss a child.  */
+        if (job_rfd < 0)
+          job_rfd = dup (job_fds[0]);
+
+        /* Something's done.  We don't want to block for a whole child,
+           just reap whatever's there.  */
+        reap_children (0, 0);
+      }
+#endif
+
  /* The job is now primed.  Start it running.
     (This will notice if there are in fact no commands.)  */
-  (void)start_waiting_job (c);
+  (void) start_waiting_job (c);

  if (job_slots == 1)
    /* Since there is only one job slot, make things run linearly.
@@ -1429,9 +1462,9 @@ load_too_high ()
 	{
 	  if (errno == 0)
 	    /* An errno value of zero means getloadavg is just unsupported.  */
-	    error (NILF, "cannot enforce load limits on this operating system");
+	    error (NILF, _("cannot enforce load limits on this operating system"));
 	  else
-	    perror_with_name ("cannot enforce load limit: ", "getloadavg");
+	    perror_with_name (_("cannot enforce load limit: "), "getloadavg");
 	}
      lossage = errno;
      load = 0;
@@ -1534,7 +1567,7 @@ int vmsHandleChildTerm(struct child *child)
 	    break;

 	  default:
-	    error (NILF, "internal error: `%s' command_state", c->file->name);
+	    error (NILF, _("internal error: `%s' command_state"), c->file->name);
 	    abort ();
 	    break;
 	  }
@@ -1640,7 +1673,7 @@ child_execute_job (argv, child)
      sprintf (cmd, "$ @%s", comname);

      if (debug_flag)
-	printf ("Executing %s instead\n", cmd);
+	printf (_("Executing %s instead\n"), cmd);
    }

  cmddsc.dsc$w_length = strlen(cmd);
@@ -1671,7 +1704,7 @@ child_execute_job (argv, child)

  if (!(status & 1))
    {
-      printf("Error spawning, %d\n",status);
+      printf(_("Error spawning, %d\n"),status);
      fflush(stdout);
    }

@@ -1740,11 +1773,11 @@ exec_command (argv, envp)
    {
      int i;
      fprintf(stderr,
-              "process_easy() failed failed to launch process (e=%d)\n",
+              _("process_easy() failed failed to launch process (e=%d)\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);
+      fprintf(stderr, _("\nCounted %d args in failed launch\n"), i);
      exit(EXIT_FAILURE);
    }

@@ -1769,7 +1802,7 @@ exec_command (argv, envp)
          break;
      else
          fprintf(stderr,
-                  "make reaped child pid %d, still waiting for pid %d\n",
+                  _("make reaped child pid %d, still waiting for pid %d\n"),
                  hWaitPID, hPID);
    }

@@ -1788,7 +1821,7 @@ exec_command (argv, envp)
  switch (errno)
    {
    case ENOENT:
-      error (NILF, "%s: Command not found", argv[0]);
+      error (NILF, _("%s: Command not found"), argv[0]);
      break;
    case ENOEXEC:
      {
@@ -1817,7 +1850,7 @@ exec_command (argv, envp)

 	execvp (shell, new_argv);
 	if (errno == ENOENT)
-	  error (NILF, "%s: Shell program not found", shell);
+	  error (NILF, _("%s: Shell program not found"), shell);
 	else
 	  perror_with_name ("execvp: ", shell);
 	break;
@@ -1997,7 +2030,7 @@ construct_command_argv_internal (line, restp, shell, ifs, batch_filename_ptr)
    {
      extern int _is_unixy_shell (const char *_path);

-      message (1, "$SHELL changed (was `%s', now `%s')", default_shell, shell);
+      message (1, _("$SHELL changed (was `%s', now `%s')"), default_shell, shell);
      unixy_shell = _is_unixy_shell (shell);
      default_shell = shell;
    }
@@ -2108,7 +2141,7 @@ construct_command_argv_internal (line, restp, shell, ifs, batch_filename_ptr)
                  /* Note these overlap and strcpy() is undefined for
                     overlapping objects in ANSI C.  The strlen() _IS_ right,
                     since we need to copy the nul byte too.  */
-		  bcopy (p + 1, p, strlen(p));
+		  bcopy (p + 1, p, strlen (p));

 		if (instring)
 		  goto string_char;
@@ -2276,7 +2309,7 @@ construct_command_argv_internal (line, restp, shell, ifs, batch_filename_ptr)
    }
    *dptr = 0;

-    new_argv = (char **) xmalloc(2 * sizeof(char *));
+    new_argv = (char **) xmalloc (2 * sizeof (char *));
    new_argv[0] = buffer;
    new_argv[1] = 0;
  }
@@ -2399,7 +2432,7 @@ construct_command_argv_internal (line, restp, shell, ifs, batch_filename_ptr)
      }

      if (debug_flag)
-        printf("Creating temporary batch file %s\n", *batch_filename_ptr);
+        printf(_("Creating temporary batch file %s\n"), *batch_filename_ptr);

      /* create batch file to execute command */
      batch = fopen (*batch_filename_ptr, "w");
@@ -2440,7 +2473,7 @@ construct_command_argv_internal (line, restp, shell, ifs, batch_filename_ptr)
      }
 #else
    else
-      fatal (NILF, "%s (line %d) Bad shell context (!unixy && !batch_mode_shell)\n",
+      fatal (NILF, _("%s (line %d) Bad shell context (!unixy && !batch_mode_shell)\n"),
            __FILE__, __LINE__);
 #endif
  }
--- a/job.h
+++ b/job.h
@@ -46,7 +46,6 @@ struct child

    unsigned int good_stdin:1;	/* Nonzero if this child has a good stdin.  */
    unsigned int deleted:1;	/* Nonzero if targets have been deleted.  */
-    char job_token;		/* The token read from the job pipe.  */
  };

 extern struct child *children;
--- a/main.c
+++ b/main.c
@@ -79,14 +79,13 @@ static char *quote_as_word PARAMS ((char *out, char *in, int double_dollars));

 struct command_switch
  {
-    char c;			/* The switch character.  */
+    unsigned char 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.  */
-	int_string,		/* One string.  */
 	positive_int,		/* A positive integer.  */
 	floating,		/* A floating-point number (double).  */
 	ignore			/* Ignored.  */
@@ -104,6 +103,7 @@ struct command_switch
    char *long_name;		/* Long option name.  */
    char *argdesc;		/* Descriptive word for argument.  */
    char *description;		/* Description for usage message.  */
+                                /* 0 means internal; don't display help.  */
  };


@@ -195,16 +195,16 @@ static struct stringlist *makefiles = 0;
 unsigned int job_slots = 1;
 unsigned int default_job_slots = 1;

-static char *job_slots_str = "1";
-
-#ifndef MAKE_JOBSERVER
 /* Value of job_slots that means no limit.  */
+
 static unsigned int inf_jobs = 0;
-#endif

 /* File descriptors for the jobs pipe.  */

+static struct stringlist *jobserver_fds = 0;
+
 int job_fds[2] = { -1, -1 };
+int job_rfd = -1;

 /* Maximum load average at which multiple jobs will be run.
   Negative values mean unlimited, while zero means limit to
@@ -249,103 +249,102 @@ static const struct command_switch switches[] =
  {
    { 'b', ignore, 0, 0, 0, 0, 0, 0,
 	0, 0,
-	"Ignored for compatibility" },
+	_("Ignored for compatibility") },
    { 'C', string, (char *) &directories, 0, 0, 0, 0, 0,
-	"directory", "DIRECTORY",
-	"Change to DIRECTORY before doing anything" },
+	"directory", _("DIRECTORY"),
+	_("Change to DIRECTORY before doing anything") },
    { 'd', flag, (char *) &debug_flag, 1, 1, 0, 0, 0,
 	"debug", 0,
-	"Print lots of debugging information" },
+	_("Print lots of debugging information") },
 #ifdef WINDOWS32
    { 'D', flag, (char *) &suspend_flag, 1, 1, 0, 0, 0,
        "suspend-for-debug", 0,
-        "Suspend process to allow a debugger to attach" },
+        _("Suspend process to allow a debugger to attach") },
 #endif
    { 'e', flag, (char *) &env_overrides, 1, 1, 0, 0, 0,
 	"environment-overrides", 0,
-	"Environment variables override makefiles" },
+	_("Environment variables override makefiles") },
    { 'f', string, (char *) &makefiles, 0, 0, 0, 0, 0,
-	"file", "FILE",
-	"Read FILE as a makefile" },
+	"file", _("FILE"),
+	_("Read FILE as a makefile") },
    { 'h', flag, (char *) &print_usage_flag, 0, 0, 0, 0, 0,
 	"help", 0,
-	"Print this message and exit" },
+	_("Print this message and exit") },
    { 'i', flag, (char *) &ignore_errors_flag, 1, 1, 0, 0, 0,
 	"ignore-errors", 0,
-	"Ignore errors from commands" },
+	_("Ignore errors from commands") },
    { 'I', string, (char *) &include_directories, 1, 1, 0, 0, 0,
-	"include-dir", "DIRECTORY",
-	"Search DIRECTORY for included makefiles" },
+	"include-dir", _("DIRECTORY"),
+	_("Search DIRECTORY for included makefiles") },
    { 'j',
-#ifndef MAKE_JOBSERVER
        positive_int, (char *) &job_slots, 1, 1, 0,
 	(char *) &inf_jobs, (char *) &default_job_slots,
-#else
-        int_string, (char *)&job_slots_str, 1, 1, 0, "0", "1",
-#endif
 	"jobs", "N",
-	"Allow N jobs at once; infinite jobs with no arg" },
+	_("Allow N jobs at once; infinite jobs with no arg") },
+    { 2, string, (char *) &jobserver_fds, 1, 1, 0, 0, 0,
+        "jobserver-fds", 0,
+        0 },
    { 'k', flag, (char *) &keep_going_flag, 1, 1, 0,
 	0, (char *) &default_keep_going_flag,
 	"keep-going", 0,
-	"Keep going when some targets can't be made" },
+	_("Keep going when some targets can't be made") },
 #ifndef NO_FLOAT
    { 'l', floating, (char *) &max_load_average, 1, 1, 0,
 	(char *) &default_load_average, (char *) &default_load_average,
 	"load-average", "N",
-	"Don't start multiple jobs unless load is below N" },
+	_("Don't start multiple jobs unless load is below N") },
 #else
    { 'l', positive_int, (char *) &max_load_average, 1, 1, 0,
 	(char *) &default_load_average, (char *) &default_load_average,
 	"load-average", "N",
-	"Don't start multiple jobs unless load is below N" },
+	_("Don't start multiple jobs unless load is below N") },
 #endif
    { 'm', ignore, 0, 0, 0, 0, 0, 0,
 	0, 0,
 	"-b" },
    { 'n', flag, (char *) &just_print_flag, 1, 1, 1, 0, 0,
 	"just-print", 0,
-	"Don't actually run any commands; just print them" },
+	_("Don't actually run any commands; just print them") },
    { 'o', string, (char *) &old_files, 0, 0, 0, 0, 0,
-	"old-file", "FILE",
-	"Consider FILE to be very old and don't remake it" },
+	"old-file", _("FILE"),
+	_("Consider FILE to be very old and don't remake it") },
    { 'p', flag, (char *) &print_data_base_flag, 1, 1, 0, 0, 0,
 	"print-data-base", 0,
-	"Print make's internal database" },
+	_("Print make's internal database") },
    { 'q', flag, (char *) &question_flag, 1, 1, 1, 0, 0,
 	"question", 0,
-	"Run no commands; exit status says if up to date" },
+	_("Run no commands; exit status says if up to date") },
    { 'r', flag, (char *) &no_builtin_rules_flag, 1, 1, 0, 0, 0,
 	"no-builtin-rules", 0,
-	"Disable the built-in implicit rules" },
+	_("Disable the built-in implicit rules") },
    { 'R', flag, (char *) &no_builtin_variables_flag, 1, 1, 0, 0, 0,
 	"no-builtin-variables", 0,
-	"Disable the built-in variable settings" },
+	_("Disable the built-in variable settings") },
    { 's', flag, (char *) &silent_flag, 1, 1, 0, 0, 0,
 	"silent", 0,
-	"Don't echo commands" },
+	_("Don't echo commands") },
    { 'S', flag_off, (char *) &keep_going_flag, 1, 1, 0,
 	0, (char *) &default_keep_going_flag,
 	"no-keep-going", 0,
-	"Turns off -k" },
+	_("Turns off -k") },
    { 't', flag, (char *) &touch_flag, 1, 1, 1, 0, 0,
 	"touch", 0,
-	"Touch targets instead of remaking them" },
+	_("Touch targets instead of remaking them") },
    { 'v', flag, (char *) &print_version_flag, 1, 1, 0, 0, 0,
 	"version", 0,
-	"Print the version number of make and exit" },
+	_("Print the version number of make and exit") },
    { 'w', flag, (char *) &print_directory_flag, 1, 1, 0, 0, 0,
 	"print-directory", 0,
-	"Print the current directory" },
-    { 2, flag, (char *) &inhibit_print_directory_flag, 1, 1, 0, 0, 0,
+	_("Print the current directory") },
+    { 3, flag, (char *) &inhibit_print_directory_flag, 1, 1, 0, 0, 0,
 	"no-print-directory", 0,
-	"Turn off -w, even if it was turned on implicitly" },
+	_("Turn off -w, even if it was turned on implicitly") },
    { 'W', string, (char *) &new_files, 0, 0, 0, 0, 0,
-	"what-if", "FILE",
-	"Consider FILE to be infinitely new" },
-    { 3, flag, (char *) &warn_undefined_variables_flag, 1, 1, 0, 0, 0,
+	"what-if", _("FILE"),
+	_("Consider FILE to be infinitely new") },
+    { 4, flag, (char *) &warn_undefined_variables_flag, 1, 1, 0, 0, 0,
 	"warn-undefined-variables", 0,
-	"Warn when an undefined variable is referenced" },
+	_("Warn when an undefined variable is referenced") },
    { '\0', }
  };

@@ -438,7 +437,7 @@ enter_command_line_file (name)
     char *name;
 {
  if (name[0] == '\0')
-    fatal (NILF, "empty string invalid as file name");
+    fatal (NILF, _("empty string invalid as file name"));

  if (name[0] == '~')
    {
@@ -504,7 +503,7 @@ handle_runtime_exceptions( struct _EXCEPTION_POINTERS *exinfo )

  if (!debug_flag)
    {
-      sprintf(errmsg, "%s: Interrupt/Exception caught ", prg);
+      sprintf(errmsg, _("%s: Interrupt/Exception caught "), prg);
      sprintf(&errmsg[strlen(errmsg)],
              "(code = 0x%x, addr = 0x%x)\r\n",
              exrec->ExceptionCode, exrec->ExceptionAddress);
@@ -513,7 +512,7 @@ handle_runtime_exceptions( struct _EXCEPTION_POINTERS *exinfo )
    }

  sprintf(errmsg,
-          "\r\nUnhandled exception filter called from program %s\r\n", prg);
+          _("\r\nUnhandled exception filter called from program %s\r\n"), prg);
  sprintf(&errmsg[strlen(errmsg)], "ExceptionCode = %x\r\n",
          exrec->ExceptionCode);
  sprintf(&errmsg[strlen(errmsg)], "ExceptionFlags = %x\r\n",
@@ -524,8 +523,8 @@ handle_runtime_exceptions( struct _EXCEPTION_POINTERS *exinfo )
  if (exrec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION
      && exrec->NumberParameters >= 2)
    sprintf(&errmsg[strlen(errmsg)],
-            "Access violation: %s operation at address %x\r\n",
-            exrec->ExceptionInformation[0] ? "write": "read",
+            _("Access violation: %s operation at address %x\r\n"),
+            exrec->ExceptionInformation[0] ? _("write"): _("read"),
            exrec->ExceptionInformation[1]);

  /* turn this on if we want to put stuff in the event log too */
@@ -590,7 +589,7 @@ find_and_set_default_shell(char *token)
    sprintf(sh_path, "%s", search_token);
    default_shell = xstrdup(w32ify(sh_path,0));
    if (debug_flag)
-      printf("find_and_set_shell setting default_shell = %s\n", default_shell);
+      printf(_("find_and_set_shell setting default_shell = %s\n"), default_shell);
    sh_found = 1;
  } else {
    char *p;
@@ -632,7 +631,7 @@ find_and_set_default_shell(char *token)
      }

      if (debug_flag && sh_found)
-        printf("find_and_set_shell path search set default_shell = %s\n", default_shell);
+        printf(_("find_and_set_shell path search set default_shell = %s\n"), default_shell);
    }
  }

@@ -929,9 +928,9 @@ int main (int argc, char ** argv)
 #ifdef WINDOWS32
  if (suspend_flag) {
        fprintf(stderr, "%s (pid = %d)\n", argv[0], GetCurrentProcessId());
-        fprintf(stderr, "%s is suspending for 30 seconds...", argv[0]);
+        fprintf(stderr, _("%s is suspending for 30 seconds..."), argv[0]);
        Sleep(30 * 1000);
-        fprintf(stderr, "done sleep(30). Continuing.\n");
+        fprintf(stderr, _("done sleep(30). Continuing.\n"));
  }
 #endif

@@ -944,7 +943,7 @@ int main (int argc, char ** argv)
  if (print_version_flag)
    die (0);

-#if !defined(__MSDOS__) && !defined(VMS)
+#ifndef VMS
  /* Set the "MAKE_COMMAND" variable to the name we were invoked with.
     (If it is a relative pathname with a slash, prepend our directory name
     so the result will run the same program regardless of the current dir.
@@ -962,9 +961,21 @@ int main (int argc, char ** argv)
      strneq(argv[0], "//", 2))
    argv[0] = xstrdup(w32ify(argv[0],1));
 #else /* WINDOWS32 */
+#ifdef __MSDOS__
+  if (strchr (argv[0], '\\'))
+    {
+      char *p;
+
+      argv[0] = xstrdup (argv[0]);
+      for (p = argv[0]; *p; p++)
+	if (*p == '\\')
+	  *p = '/';
+    }
+#else  /* !__MSDOS__ */
  if (current_directory[0] != '\0'
      && argv[0] != 0 && argv[0][0] != '/' && index (argv[0], '/') != 0)
    argv[0] = concat (current_directory, "/", argv[0]);
+#endif /* !__MSDOS__ */
 #endif /* WINDOWS32 */
 #endif

@@ -1130,17 +1141,17 @@ int main (int argc, char ** argv)
 #endif

            if (stdin_nm)
-              fatal (NILF, "Makefile from standard input specified twice.");
+              fatal (NILF, _("Makefile from standard input specified twice."));

 	    outfile = fopen (name, "w");
 	    if (outfile == 0)
-	      pfatal_with_name ("fopen (temporary file)");
+	      pfatal_with_name (_("fopen (temporary file)"));
 	    while (!feof (stdin))
 	      {
 		char buf[2048];
-		unsigned int n = fread (buf, 1, sizeof(buf), stdin);
+		unsigned int n = fread (buf, 1, sizeof (buf), stdin);
 		if (n > 0 && fwrite (buf, 1, n, outfile) != n)
-		  pfatal_with_name ("fwrite (temporary file)");
+		  pfatal_with_name (_("fwrite (temporary file)"));
 	      }
 	    (void) fclose (outfile);

@@ -1155,7 +1166,7 @@ int main (int argc, char ** argv)
 	    }

 	    /* Make sure the temporary file will not be remade.  */
-            stdin_nm = savestring (name, sizeof(name) -1);
+            stdin_nm = savestring (name, sizeof (name) -1);
 	    f = enter_file (stdin_nm);
 	    f->updated = 1;
 	    f->update_status = 0;
@@ -1168,23 +1179,41 @@ int main (int argc, char ** argv)
    }

 #if defined(MAKE_JOBSERVER) || !defined(HAVE_WAIT_NOHANG)
-  /* If we don't have a hanging wait we have to fall back to old, broken
+  /* Set up to handle children dying.  This must be done before
+     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
     functionality here and rely on the signal handler and counting
     children.

-     Also, if we're using the jobs pipe we need a signal handler so that
-     SIGCHLD is not ignored; we need it to interrupt select(2) in
-     job.c:start_waiting_job() if we're waiting on the pipe 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 in job.c if we're waiting for a token.
+
+     If none of these are true, we don't need a signal handler at all.  */
  {
    extern RETSIGTYPE child_handler PARAMS ((int sig));

-    /* Set up to handle children dying.  This must be done before
-       reading in the makefiles so that `shell' function calls will work.  */
+# if defined HAVE_SIGACTION
+    struct sigaction sa;
+
+    bzero ((char *)&sa, sizeof (struct sigaction));
+    sa.sa_handler = child_handler;
+#  if defined SA_INTERRUPT
+    /* This is supposed to be the default, but what the heck... */
+    sa.sa_flags = SA_INTERRUPT;
+#  endif
+#  define HANDLESIG(s) sigaction (s, &sa, NULL)
+# else
+#  define HANDLESIG(s) signal (s, child_handler)
+# endif
+
+    /* OK, now actually install the handlers.  */
 # if defined SIGCHLD
-    (void) signal (SIGCHLD, child_handler);
+    (void) HANDLESIG (SIGCHLD);
 # endif
 # if defined SIGCLD && SIGCLD != SIGCHLD
-    (void) signal (SIGCLD, child_handler);
+    (void) HANDLESIG (SIGCLD);
 # endif
  }
 #endif
@@ -1231,8 +1260,8 @@ int main (int argc, char ** argv)
    no_default_sh_exe = !find_and_set_default_shell(NULL);

  if (no_default_sh_exe && job_slots != 1) {
-    error (NILF, "Do not specify -j or --jobs if sh.exe is not available.");
-    error (NILF, "Resetting make for single job mode.");
+    error (NILF, _("Do not specify -j or --jobs if sh.exe is not available."));
+    error (NILF, _("Resetting make for single job mode."));
    job_slots = 1;
  }
 #endif /* WINDOWS32 */
@@ -1241,7 +1270,7 @@ int main (int argc, char ** argv)
  /* We need to know what kind of shell we will be using.  */
  {
    extern int _is_unixy_shell (const char *_path);
-    struct variable *shv = lookup_variable("SHELL", 5);
+    struct variable *shv = lookup_variable ("SHELL", 5);
    extern int unixy_shell;
    extern char *default_shell;

@@ -1265,56 +1294,90 @@ int main (int argc, char ** argv)
  decode_env_switches ("MFLAGS", 6);
 #endif

-#ifdef MAKE_JOBSERVER
-  /* If extended jobs are available then the -j option can have one of 4
-     formats: (1) not specified: default is "1"; (2) specified with no
-     value: default is "0" (infinite); (3) specified with a single
-     value: this means the user wants N job slots; or (4) specified with
-     2 values separated by commas.  The latter means we're a submake and
-     the two values are the read and write FDs, respectively, for the
-     pipe.  Note this last form is undocumented for the user!
-   */
-  sscanf(job_slots_str, "%d", &job_slots);
-  {
-    char *cp = index(job_slots_str, ',');
+#ifdef __MSDOS__
+  if (job_slots != 1)
+    {
+      error (NILF, _("Parallel jobs (-j) are not supported on MS-DOS."));
+      error (NILF, _("Resetting to single job mode."));
+      job_slots = 1;
+    }
+#endif

-    if (cp && sscanf(cp+1, "%d", &job_fds[1]) == 1)
+#ifdef MAKE_JOBSERVER
+  /* If the jobserver-fds option is seen, make sure that -j is reasonable.  */
+
+  if (jobserver_fds)
+  {
+    char *cp;
+
+    if (jobserver_fds->idx > 1)
+      fatal (NILF, _("internal error: multiple --jobserver-fds options"));
+
+    /* 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 (job_slots != 0)
+      fatal (NILF, _("internal error: --jobserver-fds unexpected"));
+
+    /* 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);
+
+    /* 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.  */
+
+    if ((job_rfd = dup (job_fds[0])) < 0)
      {
-	job_fds[0] = job_slots;
-	job_slots = 0;
+        if (errno != EBADF)
+          pfatal_with_name (_("dup jobserver"));
+
+        error (NILF,
+               _("warning: jobserver unavailable (using -j1).  Add `+' to parent make rule."));
+        job_slots = 1;
+        job_fds[0] = job_fds[1] = -1;
+        free (jobserver_fds->list);
+        free (jobserver_fds);
+        jobserver_fds = 0;
      }
  }

-  /* In case #3 above, set up the pipe and set up the submake options
-     properly.  */
+  /* 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)
+  else if (job_slots > 1)
    {
-      char buf[(sizeof("1024")*2)+1];
-      char c = '0';
+      char c = '+';

-      if (pipe(job_fds) < 0)
-	pfatal_with_name("creating jobs pipe");
+      if (pipe (job_fds) < 0 || (job_rfd = dup (job_fds[0])) < 0)
+	pfatal_with_name (_("creating jobs pipe"));

-      /* Set the read FD to nonblocking; we'll use select() to wait
-	 for it in job.c.  */
-      fcntl (job_fds[0], F_SETFL, O_NONBLOCK);
+      /* 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.  */

-      for (; job_slots; --job_slots)
-	{
-	  write(job_fds[1], &c, 1);
-	  if (c == '9')
-	    c = 'a';
-	  else if (c == 'z')
-	    c = 'A';
-	  else if (c == 'Z')
-	    c = '0'; /* Start over again!!  */
-	  else
-	    ++c;
-	}
+      while (--job_slots)
+        while (write (job_fds[1], &c, 1) != 1)
+          if (!EINTR_SET)
+            pfatal_with_name (_("init jobserver pipe"));

-      sprintf(buf, "%d,%d", job_fds[0], job_fds[1]);
-      job_slots_str = xstrdup(buf);
+      /* Fill in the jobserver_fds struct for our children.  */
+
+      jobserver_fds = (struct stringlist *)
+                        xmalloc (sizeof (struct stringlist));
+      jobserver_fds->list = (char **) xmalloc (sizeof (char *));
+      jobserver_fds->list[0] = xmalloc ((sizeof ("1024")*2)+1);
+
+      sprintf (jobserver_fds->list[0], "%d,%d", job_fds[0], job_fds[1]);
+      jobserver_fds->idx = 1;
+      jobserver_fds->max = 1;
    }
 #endif

@@ -1385,7 +1448,7 @@ int main (int argc, char ** argv)
      int nargc = argc;

      if (debug_flag)
-	puts ("Updating makefiles....");
+	puts (_("Updating makefiles...."));

      /* Remove any makefiles we don't want to try to update.
 	 Also record the current modtimes so we can compare them later.  */
@@ -1410,7 +1473,7 @@ int main (int argc, char ** argv)
 			 you write your makefiles.)  */

 		      if (debug_flag)
-			printf ("Makefile `%s' might loop; not remaking it.\n",
+			printf (_("Makefile `%s' might loop; not remaking it.\n"),
 				f->name);

 		      if (last == 0)
@@ -1484,7 +1547,7 @@ int main (int argc, char ** argv)
                        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'.",
+                        error (NILF, _("Failed to remake makefile `%s'."),
                               d->file->name);
                        mtime = file_mtime_no_search (d->file);
                        any_remade |= (mtime != (FILE_TIMESTAMP) -1
@@ -1499,12 +1562,13 @@ int main (int argc, char ** argv)
                      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.",
+                        error (NILF,
+                               _("Included makefile `%s' was not found."),
                               dep_name (d));
                      else
                        {
                          /* A normal makefile.  We must die later.  */
-                          error (NILF, "Makefile `%s' was not found",
+                          error (NILF, _("Makefile `%s' was not found"),
                                 dep_name (d));
                          any_failed = 1;
                        }
@@ -1550,9 +1614,9 @@ int main (int argc, char ** argv)
          /* Add -o option for the stdin temporary file, if necessary.  */
          if (stdin_nm)
            {
-              nargv = (char **)xmalloc((nargc + 2) * sizeof(char *));
-              bcopy((char *)argv, (char *)nargv, argc * sizeof(char *));
-              nargv[nargc++] = concat("-o", stdin_nm, "");
+              nargv = (char **) xmalloc ((nargc + 2) * sizeof (char *));
+              bcopy ((char *) argv, (char *) nargv, argc * sizeof (char *));
+              nargv[nargc++] = concat ("-o", stdin_nm, "");
              nargv[nargc] = 0;
            }

@@ -1572,7 +1636,7 @@ int main (int argc, char ** argv)
 	      else
 		bad = 1;
 	      if (bad)
-		fatal (NILF, "Couldn't change back to original directory.");
+		fatal (NILF, _("Couldn't change back to original directory."));
 	    }

 #ifndef _AMIGA
@@ -1606,7 +1670,7 @@ int main (int argc, char ** argv)
 	  if (debug_flag)
 	    {
 	      char **p;
-	      fputs ("Re-executing:", stdout);
+	      fputs (_("Re-executing:"), stdout);
 	      for (p = nargv; *p != 0; ++p)
 		printf (" %s", *p);
 	      puts ("");
@@ -1630,8 +1694,8 @@ int main (int argc, char ** argv)

  /* If there is a temp file from reading a makefile from stdin, get rid of
     it now.  */
-  if (stdin_nm && unlink(stdin_nm) < 0 && errno != ENOENT)
-    perror_with_name("unlink (temporary file): ", stdin_nm);
+  if (stdin_nm && unlink (stdin_nm) < 0 && errno != ENOENT)
+    perror_with_name (_("unlink (temporary file): "), stdin_nm);

  {
    int status;
@@ -1653,15 +1717,15 @@ int main (int argc, char ** argv)
    if (!goals)
      {
        if (read_makefiles == 0)
-          fatal (NILF, "No targets specified and no makefile found");
+          fatal (NILF, _("No targets specified and no makefile found"));

-        fatal (NILF, "No targets");
+        fatal (NILF, _("No targets"));
      }

    /* Update the goals.  */

    if (debug_flag)
-      puts ("Updating goal targets....");
+      puts (_("Updating goal targets...."));

    switch (update_goal_chain (goals, 0))
    {
@@ -1686,7 +1750,7 @@ int main (int argc, char ** argv)

    /* 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.");
+      error (NILF, _("*** Warning:  Clock skew detected.  Your build may be incomplete."));

    /* Exit.  */
    die (status);
@@ -1736,7 +1800,6 @@ init_switches ()
 	  long_options[i].has_arg = no_argument;
 	  break;

-	case int_string:
 	case string:
 	case positive_int:
 	case floating:
@@ -1797,8 +1860,7 @@ handle_non_switch_argument (arg, env)
 	}
      else
 	{
-	  lastgoal->next
-	    = (struct dep *) xmalloc (sizeof (struct dep));
+	  lastgoal->next = (struct dep *) xmalloc (sizeof (struct dep));
 	  lastgoal = lastgoal->next;
 	}
      lastgoal->name = 0;
@@ -1809,7 +1871,7 @@ handle_non_switch_argument (arg, env)
        struct variable *v;
        char *value;

-        v = lookup_variable("MAKECMDGOALS", 12);
+        v = lookup_variable ("MAKECMDGOALS", 12);
        if (v == 0)
          value = f->name;
        else
@@ -1817,14 +1879,14 @@ handle_non_switch_argument (arg, env)
            /* Paste the old and new values together */
            unsigned int oldlen, newlen;

-            oldlen = strlen(v->value);
-            newlen = strlen(f->name);
-            value = (char *)alloca(oldlen + 1 + newlen + 1);
-            bcopy(v->value, value, oldlen);
+            oldlen = strlen (v->value);
+            newlen = strlen (f->name);
+            value = (char *) alloca (oldlen + 1 + newlen + 1);
+            bcopy (v->value, value, oldlen);
            value[oldlen] = ' ';
-            bcopy(f->name, &value[oldlen + 1], newlen + 1);
+            bcopy (f->name, &value[oldlen + 1], newlen + 1);
          }
-        define_variable("MAKECMDGOALS", 12, value, o_default, 0);
+        define_variable ("MAKECMDGOALS", 12, value, o_default, 0);
      }
    }
 }
@@ -1843,14 +1905,14 @@ print_usage (bad)

  usageto = bad ? stderr : stdout;

-  fprintf (usageto, "Usage: %s [options] [target] ...\n", program);
+  fprintf (usageto, _("Usage: %s [options] [target] ...\n"), program);

-  fputs ("Options:\n", usageto);
+  fputs (_("Options:\n"), usageto);
  for (cs = switches; cs->c != '\0'; ++cs)
    {
      char buf[1024], shortarg[50], longarg[50], *p;

-      if (cs->description[0] == '-')
+      if (!cs->description || cs->description[0] == '-')
 	continue;

      switch (long_options[cs - switches].has_arg)
@@ -1895,8 +1957,9 @@ print_usage (bad)
      {
 	const struct command_switch *ncs = cs;
 	while ((++ncs)->c != '\0')
-	  if (ncs->description[0] == '-' &&
-	      ncs->description[1] == cs->c)
+	  if (ncs->description
+              && ncs->description[0] == '-'
+              && ncs->description[1] == cs->c)
 	    {
 	      /* This is another switch that does the same
 		 one as the one we are processing.  We want
@@ -1990,20 +2053,6 @@ decode_switches (argc, argv, env)
 		    *(int *) cs->value_ptr = cs->type == flag;
 		  break;

-		case int_string:
-		  if (optarg == 0 && argc > optind
-		      && isdigit (argv[optind][0]))
-		    optarg = argv[optind++];
-
-		  if (!doit)
-		    break;
-
-		  if (optarg == 0)
-		    optarg = cs->noarg_value;
-
-		  *(char **)cs->value_ptr = optarg;
-		  break;
-
 		case string:
 		  if (!doit)
 		    break;
@@ -2034,7 +2083,7 @@ decode_switches (argc, argv, env)

 		case positive_int:
 		  if (optarg == 0 && argc > optind
-		      && isdigit (argv[optind][0]))
+		      && ISDIGIT (argv[optind][0]))
 		    optarg = argv[optind++];

 		  if (!doit)
@@ -2046,8 +2095,7 @@ decode_switches (argc, argv, env)
 		      if (i < 1)
 			{
 			  if (doit)
-			    error (NILF, "the `-%c' option requires a \
-positive integral argument",
+			    error (NILF, _("the `-%c' option requires a positive integral argument"),
 				   cs->c);
 			  bad = 1;
 			}
@@ -2062,7 +2110,7 @@ positive integral argument",
 #ifndef NO_FLOAT
 		case floating:
 		  if (optarg == 0 && optind < argc
-		      && (isdigit (argv[optind][0]) || argv[optind][0] == '.'))
+		      && (ISDIGIT (argv[optind][0]) || argv[optind][0] == '.'))
 		    optarg = argv[optind++];

 		  if (doit)
@@ -2089,7 +2137,7 @@ positive integral argument",

  if (!env && (bad || print_usage_flag))
    {
-      print_usage(bad);
+      print_usage (bad);
      die (bad ? 2 : 0);
    }
 }
@@ -2302,22 +2350,6 @@ define_makeflags (all, makefile)
 	  break;
 #endif

-	case int_string:
-	  if (all)
-	    {
-	      char *vp = *(char **)cs->value_ptr;
-
-	      if (cs->default_value != 0
-		  && streq(vp, cs->default_value))
-		break;
-	      if (cs->noarg_value != 0
-		  && streq(vp, cs->noarg_value))
-		ADD_FLAG("", 0); /* Optional value omitted; see below.  */
-	      else
-		ADD_FLAG(vp, strlen(vp));
-	    }
-	  break;
-
 	case string:
 	  if (all)
 	    {
@@ -2486,13 +2518,13 @@ print_version ()
  if (remote_description != 0 && *remote_description != '\0')
    printf ("-%s", remote_description);

-  printf (", by Richard Stallman and Roland McGrath.\n\
+  printf (_(", by Richard Stallman and Roland McGrath.\n\
 %sCopyright (C) 1988, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99\n\
 %s\tFree Software Foundation, Inc.\n\
 %sThis is free software; see the source for copying conditions.\n\
 %sThere is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A\n\
 %sPARTICULAR PURPOSE.\n\n\
-%sReport bugs to <bug-make@gnu.org>.\n\n",
+%sReport bugs to <bug-make@gnu.org>.\n\n"),
 	  precede, precede, precede, precede, precede, precede);

  printed_version = 1;
@@ -2510,7 +2542,7 @@ print_data_base ()
  time_t when;

  when = time ((time_t *) 0);
-  printf ("\n# Make data base, printed on %s", ctime (&when));
+  printf (_("\n# Make data base, printed on %s"), ctime (&when));

  print_variable_data_base ();
  print_dir_data_base ();
@@ -2519,7 +2551,7 @@ print_data_base ()
  print_vpath_data_base ();

  when = time ((time_t *) 0);
-  printf ("\n# Finished Make data base on %s\n", ctime (&when));
+  printf (_("\n# Finished Make data base on %s\n"), ctime (&when));
 }

 /* Exit with STATUS, cleaning up as necessary.  */
@@ -2574,7 +2606,7 @@ log_working_directory (entering)
     int entering;
 {
  static int entered = 0;
-  char *msg = entering ? "Entering" : "Leaving";
+  char *msg = entering ? _("Entering") : _("Leaving");

  /* Print nothing without the flag.  Don't print the entering message
     again if we already have.  Don't print the leaving message if we
@@ -2593,7 +2625,7 @@ log_working_directory (entering)
    printf ("%s[%u]: %s ", program, makelevel, msg);

  if (starting_directory == 0)
-    puts ("an unknown directory");
+    puts (_("an unknown directory"));
  else
-    printf ("directory `%s'\n", starting_directory);
+    printf (_("directory `%s'\n"), starting_directory);
 }
--- a/34
+++ b/34
@@ -11,36 +11,36 @@ globhdr := $(wildcard glob/*.h)
 TEMPLATES = README README.DOS config.ami configh.dos config.h.W32 config.h-vms
 MTEMPLATES = Makefile.DOS SMakefile

-# We need this to ensure that README is created on time to avoid errors
-# by automake.
+# We need this to ensure that README and build.sh.in are created on time to
+# avoid errors by automake.
 #
-Makefile.in: README
+#Makefile.in: README build.sh.in

 # General rule for turning a .template into a regular file.
 #
-$(TEMPLATES) : % : %.template configure.in
+$(TEMPLATES) : % : %.template Makefile
 	rm -f $@
-	sed -e 's@%VERSION%@$(VERSION)@' \
-	    -e 's@%PACKAGE%@$(PACKAGE)@' \
+	sed -e 's@%VERSION%@$(VERSION)@g' \
+	    -e 's@%PACKAGE%@$(PACKAGE)@g' \
 	  $< > $@
 	chmod a-w $@

 # Construct Makefiles by adding on dependencies, etc.
 #
-$(MTEMPLATES) : % : %.template .dep_segment Makefile.am maintMakefile
+$(MTEMPLATES) : % : %.template .dep_segment Makefile
 	rm -f $@
-	sed -e 's@%VERSION%@$(VERSION)@' \
-	    -e 's@%PROGRAMS%@$(bin_PROGRAMS)@' \
-	    -e 's@%SOURCES%@$(filter-out remote-%,$(make_SOURCES)) remote-$$(REMOTE).c@' \
-	    -e 's@%OBJECTS%@$(filter-out remote-%,$(make_OBJECTS)) remote-$$(REMOTE).o@' \
-	    -e 's@%GLOB_SOURCES%@$(globsrc) $(globhdr)@' \
-	    -e 's@%GLOB_OBJECTS%@$(globsrc:glob/%.c=%.o)@' \
+	sed -e 's@%VERSION%@$(VERSION)@g' \
+	    -e 's@%PROGRAMS%@$(bin_PROGRAMS)@g' \
+	    -e 's@%SOURCES%@$(filter-out remote-%,$(make_SOURCES)) remote-$$(REMOTE).c@g' \
+	    -e 's@%OBJECTS%@$(filter-out remote-%,$(make_OBJECTS)) remote-$$(REMOTE).o@g' \
+	    -e 's@%GLOB_SOURCES%@$(globsrc) $(globhdr)@g' \
+	    -e 's@%GLOB_OBJECTS%@$(globsrc:glob/%.c=%.o)@g' \
 	  $< > $@
 	echo >>$@; echo '# --------------- DEPENDENCIES' >>$@; echo '#' >>$@; \
 	  cat $(word 2,$^) >>$@
 	chmod a-w $@

-NMakefile: NMakefile.template .dep_segment Makefile.am maintMakefile
+NMakefile: NMakefile.template .dep_segment Makefile
 	rm -f $@
 	cp $< $@
 	echo >>$@; echo '# --------------- DEPENDENCIES' >>$@; echo '#' >>$@; \
@@ -49,10 +49,10 @@ NMakefile: NMakefile.template .dep_segment Makefile.am maintMakefile

 # Construct build.sh.in
 #
-build.sh.in: build.template Makefile.am maintMakefile
+build.sh.in: build.template Makefile
 	rm -f $@
-	sed -e 's@%objs%@$(filter-out remote-%, $(make_OBJECTS)@' \
-	    -e 's@%globobjs%@$(patsubst %.c,%.o,$(globsrc)))@' \
+	sed -e 's@%objs%@$(filter-out remote-%, $(make_OBJECTS)@g' \
+	    -e 's@%globobjs%@$(patsubst %.c,%.o,$(globsrc)))@g' \
 	  $< > $@
 	chmod a-w+x $@

--- a/make.h
+++ b/make.h
@@ -40,6 +40,13 @@ Boston, MA 02111-1307, USA.  */
 #endif /* C++ or ANSI C.  */


+/* For now, set gettext macro to a no-op.  */
+#undef _
+#undef N_
+#define _(s)    s
+#define N_(s)   s
+
+
 #ifdef  CRAY
 /* This must happen before #include <signal.h> so
   that the declaration therein is changed.  */
@@ -70,6 +77,14 @@ Boston, MA 02111-1307, USA.  */
 extern int errno;
 #endif

+/* A shortcut for EINTR checking.  Note you should never negate this!  That
+   very likely doesn't mean what you want if EINTR is not available.  */
+#ifdef EINTR
+# define EINTR_SET (errno == EINTR)
+#else
+# define EINTR_SET (0)
+#endif
+
 #ifndef isblank
 # define isblank(c)     ((c) == ' ' || (c) == '\t')
 #endif
@@ -284,6 +299,17 @@ extern char *alloca ();
 # endif /* HAVE_ALLOCA_H.  */
 #endif /* GCC.  */

+/* ISDIGIT offers the following features:
+   - Its arg may be any int or unsigned int; it need not be an unsigned char.
+   - It's guaranteed to evaluate its argument exactly once.
+      NOTE!  Make relies on this behavior, don't change it!
+   - It's typically faster.
+   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
+   host does not conform to Posix.  */
+#define ISDIGIT(c) ((unsigned) (c) - '0' <= 9)
+
 #ifndef iAPX286
 # define streq(a, b) \
   ((a) == (b) || \
@@ -464,6 +490,7 @@ extern int batch_mode_shell;

 extern unsigned int job_slots;
 extern int job_fds[2];
+extern int job_rfd;
 #ifndef NO_FLOAT
 extern double max_load_average;
 #else
--- a/make.texinfo
+++ b/make.texinfo
--- a/misc.c
+++ b/misc.c
@@ -304,7 +304,7 @@ fatal (flocp, fmt, va_alist)
  VA_PRINTF (stderr, fmt, args);
  VA_END (args);

-  fputs (".  Stop.\n", stderr);
+  fputs (_(".  Stop.\n"), stderr);

  die (2);
 }
@@ -326,7 +326,7 @@ strerror (errnum)
  if (errno < sys_nerr)
    return sys_errlist[errnum];

-  sprintf (buf, "Unknown error %d", errnum);
+  sprintf (buf, _("Unknown error %d"), errnum);
  return buf;
 }
 #endif
@@ -366,7 +366,7 @@ xmalloc (size)
 {
  char *result = (char *) malloc (size);
  if (result == 0)
-    fatal (NILF, "virtual memory exhausted");
+    fatal (NILF, _("virtual memory exhausted"));
  return result;
 }

@@ -381,7 +381,7 @@ xrealloc (ptr, size)
  /* Some older implementations of realloc() don't conform to ANSI.  */
  result = ptr ? realloc (ptr, size) : malloc (size);
  if (result == 0)
-    fatal (NILF, "virtual memory exhausted");
+    fatal (NILF, _("virtual memory exhausted"));
  return result;
 }

@@ -399,7 +399,7 @@ xstrdup (ptr)
 #endif

  if (result == 0)
-    fatal (NILF, "virtual memory exhausted");
+    fatal (NILF, _("virtual memory exhausted"));

 #ifdef HAVE_STRDUP
  return result;
@@ -650,7 +650,7 @@ log_access (flavor)
     but we write this one to stderr because it might be
     run in a child fork whose stdout is piped.  */

-  fprintf (stderr, "%s access: user %lu (real %lu), group %lu (real %lu)\n",
+  fprintf (stderr, _("%s access: user %lu (real %lu), group %lu (real %lu)\n"),
 	   flavor, (unsigned long) geteuid (), (unsigned long) getuid (),
           (unsigned long) getegid (), (unsigned long) getgid ());
  fflush (stderr);
@@ -671,7 +671,7 @@ init_access ()
  if (user_uid == -1 || user_gid == -1 || make_uid == -1 || make_gid == -1)
    pfatal_with_name ("get{e}[gu]id");

-  log_access ("Initialized");
+  log_access (_("Initialized"));

  current_access = make;
 #endif
--- a/read.c
+++ b/read.c
@@ -17,11 +17,12 @@ along with GNU Make; see the file COPYING.  If not, write to
 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */

+#include "make.h"
+
 #include <assert.h>

 #include <glob.h>

-#include "make.h"
 #include "dep.h"
 #include "filedef.h"
 #include "job.h"
@@ -149,7 +150,7 @@ read_all_makefiles (makefiles)
  unsigned int num_makefiles = 0;

  if (debug_flag)
-    puts ("Reading makefiles...");
+    puts (_("Reading makefiles..."));

  /* If there's a non-null variable MAKEFILES, its value is a list of
     files to read first thing.  But don't let it prevent reading the
@@ -323,15 +324,15 @@ read_makefile (filename, flags)

  if (debug_flag)
    {
-      printf ("Reading makefile `%s'", fileinfo.filenm);
+      printf (_("Reading makefile `%s'"), fileinfo.filenm);
      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 ("...");
    }

@@ -511,7 +512,7 @@ read_makefile (filename, flags)
 	  if (i >= 0)
 	    ignoring = i;
 	  else
-	    fatal (&fileinfo, "invalid syntax in conditional");
+	    fatal (&fileinfo, _("invalid syntax in conditional"));
 	  continue;
 	}

@@ -520,7 +521,7 @@ read_makefile (filename, flags)
 	  if (in_ignored_define)
 	    in_ignored_define = 0;
 	  else
-	    fatal (&fileinfo, "extraneous `endef'");
+	    fatal (&fileinfo, _("extraneous `endef'"));
 	  continue;
 	}

@@ -532,7 +533,7 @@ read_makefile (filename, flags)
 	    {
 	      p2 = next_token (p + 6);
              if (*p2 == '\0')
-                fatal (&fileinfo, "empty variable name");
+                fatal (&fileinfo, _("empty variable name"));

 	      /* Let the variable name be the whole rest of the line,
 		 with trailing blanks stripped (comments have already been
@@ -550,7 +551,7 @@ read_makefile (filename, flags)
        {
 	  p2 = next_token (p + 8);
 	  if (*p2 == '\0')
-	    error (&fileinfo, "empty `override' directive");
+	    error (&fileinfo, _("empty `override' directive"));
 	  if (strneq (p2, "define", 6) && (isblank (p2[6]) || p2[6] == '\0'))
 	    {
 	      if (ignoring)
@@ -559,7 +560,7 @@ read_makefile (filename, flags)
 		{
 		  p2 = next_token (p2 + 6);
                  if (*p2 == '\0')
-                    fatal (&fileinfo, "empty variable name");
+                    fatal (&fileinfo, _("empty variable name"));

 		  /* Let the variable name be the whole rest of the line,
 		     with trailing blanks stripped (comments have already been
@@ -573,7 +574,7 @@ read_makefile (filename, flags)
 	    }
 	  else if (!ignoring
 		   && !try_variable_definition (&fileinfo, p2, o_override))
-	    error (&fileinfo, "invalid `override' directive");
+	    error (&fileinfo, _("invalid `override' directive"));

 	  continue;
 	}
@@ -657,8 +658,7 @@ read_makefile (filename, flags)
 	  if (*p == '\0')
 	    {
 	      error (&fileinfo,
-			      "no file name for `%sinclude'",
-			      noerror ? "-" : "");
+                     _("no file name for `%sinclude'"), noerror ? "-" : "");
 	      continue;
 	    }

@@ -691,8 +691,7 @@ read_makefile (filename, flags)
 	      if (! read_makefile (name, (RM_INCLUDED | RM_NO_TILDE
 					  | (noerror ? RM_DONTCARE : 0)))
 		  && ! noerror)
-		error (&fileinfo,
-				"%s: %s", name, strerror (errno));
+		error (&fileinfo, "%s: %s", name, strerror (errno));
              free(name);
 	    }

@@ -722,7 +721,7 @@ read_makefile (filename, flags)
 	     because there was no preceding target, and the line
 	     might have been usable as a variable definition.
 	     But now it is definitely lossage.  */
-	  fatal(&fileinfo, "commands commence before first target");
+	  fatal(&fileinfo, _("commands commence before first target"));
 	}
      else
 	{
@@ -770,7 +769,7 @@ read_makefile (filename, flags)
            {
            case w_eol:
              if (cmdleft != 0)
-                fatal(&fileinfo, "missing rule before commands");
+                fatal(&fileinfo, _("missing rule before commands"));
              /* This line contained something but turned out to be nothing
                 but whitespace (a comment?).  */
              continue;
@@ -856,9 +855,9 @@ read_makefile (filename, flags)
              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 (&fileinfo, "missing separator%s",
+                fatal (&fileinfo, _("missing separator%s"),
                       !strneq(lb.buffer, "        ", 8) ? ""
-                       : " (did you mean TAB instead of 8 spaces?)");
+                       : _(" (did you mean TAB instead of 8 spaces?)"));
              continue;
            }

@@ -987,14 +986,13 @@ read_makefile (filename, flags)
 	      target = parse_file_seq (&p2, ':', sizeof (struct nameseq), 1);
 	      ++p2;
 	      if (target == 0)
-		fatal (&fileinfo, "missing target pattern");
+		fatal (&fileinfo, _("missing target pattern"));
 	      else if (target->next != 0)
-		fatal (&fileinfo, "multiple target patterns");
+		fatal (&fileinfo, _("multiple target patterns"));
 	      pattern = target->name;
 	      pattern_percent = find_percent (pattern);
 	      if (pattern_percent == 0)
-		fatal (&fileinfo,
-				"target pattern contains no `%%'");
+		fatal (&fileinfo, _("target pattern contains no `%%'"));
              free((char *)target);
 	    }
 	  else
@@ -1035,7 +1033,7 @@ read_makefile (filename, flags)
    }

  if (conditionals->if_cmds)
-    fatal (&fileinfo, "missing `endif'");
+    fatal (&fileinfo, _("missing `endif'"));

  /* At eof, record the last rule.  */
  record_waiting_files ();
@@ -1094,7 +1092,7 @@ do_define (name, namelen, origin, infile, flocp)
 	  p += 5;
 	  remove_comments (p);
 	  if (*next_token (p) != '\0')
-	    error (flocp, "Extraneous text after `endef' directive");
+	    error (flocp, _("Extraneous text after `endef' directive"));
 	  /* Define the variable.  */
 	  if (idx == 0)
 	    definition[0] = '\0';
@@ -1123,7 +1121,7 @@ do_define (name, namelen, origin, infile, flocp)
    }

  /* No `endef'!!  */
-  fatal (flocp, "missing `endef', unterminated `define'");
+  fatal (flocp, _("missing `endef', unterminated `define'"));

  /* NOTREACHED */
  return;
@@ -1177,16 +1175,15 @@ conditional_line (line, flocp)
  if (*cmdname == 'e')
    {
      if (*line != '\0')
-	error (flocp,
-                        "Extraneous text after `%s' directive", cmdname);
+	error (flocp, _("Extraneous text after `%s' directive"), cmdname);
      /* "Else" or "endif".  */
      if (conditionals->if_cmds == 0)
-	fatal (flocp, "extraneous `%s'", cmdname);
+	fatal (flocp, _("extraneous `%s'"), cmdname);
      /* NOTDEF indicates an `endif' command.  */
      if (notdef)
 	--conditionals->if_cmds;
      else if (conditionals->seen_else[conditionals->if_cmds - 1])
-	fatal (flocp, "only one `else' per conditional");
+	fatal (flocp, _("only one `else' per conditional"));
      else
 	{
 	  /* Toggle the state of ignorance.  */
@@ -1334,8 +1331,7 @@ conditional_line (line, flocp)
      *line = '\0';
      line = next_token (++line);
      if (*line != '\0')
-	error (flocp,
-                        "Extraneous text after `%s' directive", cmdname);
+	error (flocp, _("Extraneous text after `%s' directive"), cmdname);

      s2 = variable_expand (s2);
      conditionals->ignoring[conditionals->if_cmds - 1]
@@ -1444,9 +1440,9 @@ record_target_var (filenames, defn, two_colon, origin, flocp)

      /* Make the new variable context current and define the variable.  */
      current_variable_set_list = vlist;
-      v = try_variable_definition(flocp, defn, origin);
+      v = try_variable_definition (flocp, defn, origin);
      if (!v)
-        error (flocp, "Malformed per-target variable definition");
+        error (flocp, _("Malformed per-target variable definition"));
      v->per_target = 1;

      /* If it's not an override, check to see if there was a command-line
@@ -1457,10 +1453,10 @@ record_target_var (filenames, defn, two_colon, origin, flocp)
          int len = strlen(v->name);

          current_variable_set_list = global;
-          gv = lookup_variable(v->name, len);
+          gv = lookup_variable (v->name, len);
          if (gv && (gv->origin == o_env_override || gv->origin == o_command))
-            define_variable_in_set(v->name, len, gv->value, gv->origin,
-                                     gv->recursive, vlist->set);
+            define_variable_in_set (v->name, len, gv->value, gv->origin,
+                                    gv->recursive, vlist->set);
        }

      /* Free name if not needed further.  */
@@ -1528,10 +1524,10 @@ record_files (filenames, pattern, pattern_percent, deps, cmds_started,
      implicit |= implicit_percent != 0;

      if (implicit && pattern != 0)
-	fatal (flocp, "mixed implicit and static pattern rules");
+	fatal (flocp, _("mixed implicit and static pattern rules"));

      if (implicit && implicit_percent == 0)
-	fatal (flocp, "mixed implicit and normal rules");
+	fatal (flocp, _("mixed implicit and normal rules"));

      if (implicit)
 	{
@@ -1572,7 +1568,7 @@ record_files (filenames, pattern, pattern_percent, deps, cmds_started,
 	    {
 	      /* Give a warning if the rule is meaningless.  */
 	      error (flocp,
-		     "target `%s' doesn't match the target pattern", name);
+		     _("target `%s' doesn't match the target pattern"), name);
 	      this = 0;
 	    }
 	  else
@@ -1604,12 +1600,12 @@ record_files (filenames, pattern, pattern_percent, deps, cmds_started,

 	  if (f->double_colon)
 	    fatal (flocp,
-                   "target file `%s' has both : and :: entries", f->name);
+                   _("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.",
+	    error (flocp, _("target `%s' given more than once in the same rule."),
                   f->name);

 	  /* Check for two single-colon entries both with commands.
@@ -1618,9 +1614,9 @@ record_files (filenames, pattern, pattern_percent, deps, cmds_started,
 	  else if (cmds != 0 && f->cmds != 0 && f->is_target)
 	    {
 	      error (&cmds->fileinfo,
-                     "warning: overriding commands for target `%s'", f->name);
+                     _("warning: overriding commands for target `%s'"), f->name);
 	      error (&f->cmds->fileinfo,
-                     "warning: ignoring old commands for target `%s'",
+                     _("warning: ignoring old commands for target `%s'"),
                     f->name);
 	    }

@@ -1702,7 +1698,7 @@ record_files (filenames, pattern, pattern_percent, deps, cmds_started,
 	     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);
+                   _("target file `%s' has both : and :: entries"), f->name);
 	  f = enter_file (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
@@ -2119,7 +2115,7 @@ readline (linebuffer, stream, flocp)
 	     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 (flocp, "warning: NUL character seen; rest of line ignored");
+	  error (flocp, _("warning: NUL character seen; rest of line ignored"));
 	  p[0] = '\n';
 	  len = 1;
 	}
@@ -2674,7 +2670,7 @@ multi_glob (chain, size)
 	  }

 	case GLOB_NOSPACE:
-	  fatal (NILF, "virtual memory exhausted");
+	  fatal (NILF, _("virtual memory exhausted"));
 	  break;

 	default:
--- a/remake.c
+++ b/remake.c
@@ -32,10 +32,6 @@ Boston, MA 02111-1307, USA.  */
 #include <sys/file.h>
 #endif

-#ifdef  __MSDOS__
-#include "variable.h"
-#endif
-
 #ifdef VMS
 #include <starlet.h>
 #endif
@@ -226,8 +222,8 @@ update_goal_chain (goals, makefiles)
 		  /* 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."),
+			     ? _("Nothing to be done for `%s'.")
+			     : _("`%s' is up to date.")),
 			 file->name);

 	      /* This goal is finished.  Remove it from the chain.  */
@@ -274,9 +270,9 @@ no_rule_error(file)
  struct file *file;
 {
  static const char msg_noparent[]
-    = "%sNo rule to make target `%s'%s";
+    = _("%sNo rule to make target `%s'%s");
  static const char msg_parent[]
-    = "%sNo rule to make target `%s', needed by `%s'%s";
+    = _("%sNo rule to make target `%s', needed by `%s'%s");

  if (keep_going_flag || file->dontcare)
    {
@@ -320,19 +316,19 @@ update_file (file, depth)
  register int status = 0;
  register struct file *f;

-  /* Prune the dependency graph: if we've already been here on _this_ pass
-     through the dependency graph, we don't have to go any further.  We won't
-     reap_children until we start the next pass, so no state change is
-     possible below here until then.  */
-  if (file->considered == considered)
-    {
-      DEBUGPR ("Pruning file `%s'.\n");
-      return 0;
-    }
-  file->considered = considered;
-
  for (f = file->double_colon ? file->double_colon : file; f != 0; f = f->prev)
    {
+      /* Prune the dependency graph: if we've already been here on _this_
+         pass through the dependency graph, we don't have to go any further.
+         We won't reap_children until we start the next pass, so no state
+         change is possible below here until then.  */
+      if (f->considered == considered)
+        {
+          DEBUGPR (_("Pruning file `%s'.\n"));
+          continue;
+        }
+      f->considered = considered;
+
      status |= update_file_1 (f, depth);
      check_renamed (f);

@@ -373,18 +369,18 @@ update_file_1 (file, depth)
  register struct dep *d, *lastd;
  int running = 0;

-  DEBUGPR ("Considering target file `%s'.\n");
+  DEBUGPR (_("Considering target file `%s'.\n"));

  if (file->updated)
    {
      if (file->update_status > 0)
 	{
-	  DEBUGPR ("Recently tried and failed to update file `%s'.\n");
+	  DEBUGPR (_("Recently tried and failed to update file `%s'.\n"));
          no_rule_error(file);
 	  return file->update_status;
 	}

-      DEBUGPR ("File `%s' was considered already.\n");
+      DEBUGPR (_("File `%s' was considered already.\n"));
      return 0;
    }

@@ -394,10 +390,10 @@ update_file_1 (file, depth)
    case cs_deps_running:
      break;
    case cs_running:
-      DEBUGPR ("Still updating file `%s'.\n");
+      DEBUGPR (_("Still updating file `%s'.\n"));
      return 0;
    case cs_finished:
-      DEBUGPR ("Finished updating file `%s'.\n");
+      DEBUGPR (_("Finished updating file `%s'.\n"));
      return file->update_status;
    default:
      abort ();
@@ -418,7 +414,7 @@ update_file_1 (file, depth)
  check_renamed (file);
  noexist = this_mtime == (FILE_TIMESTAMP) -1;
  if (noexist)
-    DEBUGPR ("File `%s' does not exist.\n");
+    DEBUGPR (_("File `%s' does not exist.\n"));

  must_make = noexist;

@@ -428,15 +424,15 @@ update_file_1 (file, depth)
  if (!file->phony && file->cmds == 0 && !file->tried_implicit)
    {
      if (try_implicit_rule (file, depth))
-	DEBUGPR ("Found an implicit rule for `%s'.\n");
+	DEBUGPR (_("Found an implicit rule for `%s'.\n"));
      else
-	DEBUGPR ("No implicit rule found for `%s'.\n");
+	DEBUGPR (_("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)
    {
-      DEBUGPR ("Using default commands for `%s'.\n");
+      DEBUGPR (_("Using default commands for `%s'.\n"));
      file->cmds = default_file->cmds;
    }

@@ -456,7 +452,7 @@ update_file_1 (file, depth)

      if (d->file->updating)
 	{
-	  error (NILF, "Circular %s <- %s dependency dropped.",
+	  error (NILF, _("Circular %s <- %s prerequisite 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
@@ -534,13 +530,13 @@ update_file_1 (file, depth)

  file->updating = 0;

-  DEBUGPR ("Finished dependencies of target file `%s'.\n");
+  DEBUGPR (_("Finished prerequisites of target file `%s'.\n"));

  if (running)
    {
      set_command_state (file, cs_deps_running);
      --depth;
-      DEBUGPR ("The dependencies of `%s' are being made.\n");
+      DEBUGPR (_("The prerequisites of `%s' are being made.\n"));
      return 0;
    }

@@ -553,11 +549,11 @@ update_file_1 (file, depth)

      depth--;

-      DEBUGPR ("Giving up on target file `%s'.\n");
+      DEBUGPR (_("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);
+	error (NILF, _("Target `%s' not remade because of errors."), file->name);

      return dep_status;
    }
@@ -602,10 +598,10 @@ update_file_1 (file, depth)
 	{
 	  print_spaces (depth);
 	  if (d_mtime == (FILE_TIMESTAMP) -1)
-	    printf ("Dependency `%s' does not exist.\n", dep_name (d));
+	    printf (_("Prerequisite `%s' does not exist.\n"), dep_name (d));
 	  else
-	    printf ("Dependency `%s' is %s than dependent `%s'.\n",
-		    dep_name (d), d->changed ? "newer" : "older", file->name);
+	    printf (_("Prerequisite `%s' is %s than target `%s'.\n"),
+		    dep_name (d), d->changed ? _("newer") : _("older"), file->name);
 	  fflush (stdout);
 	}
    }
@@ -616,12 +612,12 @@ update_file_1 (file, depth)
  if (file->double_colon && file->deps == 0)
    {
      must_make = 1;
-      DEBUGPR ("Target `%s' is double-colon and has no dependencies.\n");
+      DEBUGPR (_("Target `%s' is double-colon and has no prerequisites.\n"));
    }
  else if (!noexist && file->is_target && !deps_changed && file->cmds == 0)
    {
      must_make = 0;
-      DEBUGPR ("No commands for `%s' and no dependencies actually changed.\n");
+      DEBUGPR (_("No commands for `%s' and no prerequisites actually changed.\n"));
    }

  if (!must_make)
@@ -629,9 +625,9 @@ update_file_1 (file, depth)
      if (debug_flag)
        {
          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);
          printf(".\n");
          fflush(stdout);
        }
@@ -651,7 +647,7 @@ update_file_1 (file, depth)
      return 0;
    }

-  DEBUGPR ("Must remake target `%s'.\n");
+  DEBUGPR (_("Must remake target `%s'.\n"));

  /* It needs to be remade.  If it's VPATH and not reset via GPATH, toss the
     VPATH.  */
@@ -660,7 +656,7 @@ update_file_1 (file, depth)
      if (debug_flag)
        {
          print_spaces (depth);
-          printf("  Ignoring VPATH name `%s'.\n", file->hname);
+          printf(_("  Ignoring VPATH name `%s'.\n"), file->hname);
          fflush(stdout);
        }
      file->ignore_vpath = 1;
@@ -671,20 +667,20 @@ update_file_1 (file, depth)

  if (file->command_state != cs_finished)
    {
-      DEBUGPR ("Commands of `%s' are being run.\n");
+      DEBUGPR (_("Commands of `%s' are being run.\n"));
      return 0;
    }

  switch (file->update_status)
    {
    case 2:
-      DEBUGPR ("Failed to remake target file `%s'.\n");
+      DEBUGPR (_("Failed to remake target file `%s'.\n"));
      break;
    case 0:
-      DEBUGPR ("Successfully remade target file `%s'.\n");
+      DEBUGPR (_("Successfully remade target file `%s'.\n"));
      break;
    case 1:
-      DEBUGPR ("Target file `%s' needs remade under -q.\n");
+      DEBUGPR (_("Target file `%s' needs remade under -q.\n"));
      break;
    default:
      assert (file->update_status >= 0 && file->update_status <= 2);
@@ -823,15 +819,15 @@ check_dep (file, depth, this_mtime, must_make_ptr)
      if (!file->phony && file->cmds == 0 && !file->tried_implicit)
 	{
 	  if (try_implicit_rule (file, depth))
-	    DEBUGPR ("Found an implicit rule for `%s'.\n");
+	    DEBUGPR (_("Found an implicit rule for `%s'.\n"));
 	  else
-	    DEBUGPR ("No implicit rule found for `%s'.\n");
+	    DEBUGPR (_("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)
 	{
-	  DEBUGPR ("Using default commands for `%s'.\n");
+	  DEBUGPR (_("Using default commands for `%s'.\n"));
 	  file->cmds = default_file->cmds;
 	}

@@ -855,7 +851,7 @@ check_dep (file, depth, this_mtime, must_make_ptr)
 	    {
 	      if (d->file->updating)
 		{
-		  error (NILF, "Circular %s <- %s dependency dropped.",
+		  error (NILF, _("Circular %s <- %s prerequisite dropped."),
 			 file->name, d->file->name);
 		  if (lastd == 0)
 		    {
@@ -922,13 +918,10 @@ touch_file (file)
 	  char buf;
 	  int status;

-#ifdef EINTR
 	  do
-#endif
 	    status = fstat (fd, &statbuf);
-#ifdef EINTR
-	  while (status < 0 && errno == EINTR);
-#endif
+	  while (status < 0 && EINTR_SET);
+
 	  if (status < 0)
 	    TOUCH_ERROR ("touch: fstat: ");
 	  /* Rewrite character 0 same as it already is.  */
@@ -1152,7 +1145,7 @@ f_mtime (file, search)

 	    file_timestamp_sprintf (mtimebuf, mtime);
 	    file_timestamp_sprintf (nowbuf, now);
-            error (NILF, "*** Warning: File `%s' has modification time in the future (%s > %s)",
+            error (NILF, _("*** Warning: File `%s' has modification time in the future (%s > %s)"),
                   file->name, mtimebuf, nowbuf);
            clock_skew_detected = 1;
          }
@@ -1266,7 +1259,7 @@ library_search (lib, mtime_ptr)
 	  {
 	    /* Give a warning if there is no pattern, then remove the
 	       pattern so it's ignored next time.  */
-	    error (NILF, ".LIBPATTERNS element `%s' is not a pattern", p);
+	    error (NILF, _(".LIBPATTERNS element `%s' is not a pattern"), p);
 	    for (; len; --len, ++p)
 	      *p = ' ';
 	    *p = c;
--- a/rule.c
+++ b/rule.c
@@ -664,10 +664,10 @@ print_rule_data_base ()
    }

  if (rules == 0)
-    puts ("\n# No implicit rules.");
+    puts (_("\n# No implicit rules."));
  else
    {
-      printf ("\n# %u implicit rules, %u", rules, terminal);
+      printf (_("\n# %u implicit rules, %u"), rules, terminal);
 #ifndef	NO_FLOAT
      printf (" (%.1f%%)", (double) terminal / (double) rules * 100.0);
 #else
@@ -676,7 +676,7 @@ print_rule_data_base ()
 	printf (" (%d.%d%%)", f/10, f%10);
      }
 #endif
-      puts (" terminal.");
+      puts (_(" terminal."));
    }

  if (num_pattern_rules != rules)
@@ -684,11 +684,11 @@ print_rule_data_base ()
      /* This can happen if a fatal error was detected while reading the
         makefiles and thus count_implicit_rule_limits wasn't called yet.  */
      if (num_pattern_rules != 0)
-        fatal (NILF, "BUG: num_pattern_rules wrong!  %u != %u",
+        fatal (NILF, _("BUG: num_pattern_rules wrong!  %u != %u"),
               num_pattern_rules, rules);
    }

-  puts ("\n# Pattern-specific variable values");
+  puts (_("\n# Pattern-specific variable values"));

  {
    struct pattern_var *p;
@@ -703,10 +703,10 @@ print_rule_data_base ()
      }

    if (rules == 0)
-      puts ("\n# No pattern-specific variable values.");
+      puts (_("\n# No pattern-specific variable values."));
    else
      {
-        printf ("\n# %u pattern-specific variable values", rules);
+        printf (_("\n# %u pattern-specific variable values"), rules);
      }
  }
 }
--- a/signame.c
+++ b/signame.c
@@ -17,9 +17,7 @@
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+#include "make.h"

 #include <stdio.h>
 #include <sys/types.h>		/* Some systems need this for <signal.h>.  */
@@ -56,7 +54,7 @@
 /* There is too much variation in Sys V signal numbers and names, so
   we must initialize them at runtime.  */

-static const char undoc[] = "unknown signal";
+static const char *undoc;

 const char *sys_siglist[NSIG];

@@ -109,6 +107,10 @@ signame_init ()
 {
 #ifndef HAVE_SYS_SIGLIST
  int i;
+  char *u = _("unknown signal");
+
+  undoc = xstrdup(u);
+
  /* Initialize signal names.  */
  for (i = 0; i < NSIG; i++)
    sys_siglist[i] = undoc;
@@ -116,135 +118,135 @@ signame_init ()

  /* Initialize signal names.  */
 #if defined (SIGHUP)
-  init_sig (SIGHUP, "HUP", "Hangup");
+  init_sig (SIGHUP, "HUP", _("Hangup"));
 #endif
 #if defined (SIGINT)
-  init_sig (SIGINT, "INT", "Interrupt");
+  init_sig (SIGINT, "INT", _("Interrupt"));
 #endif
 #if defined (SIGQUIT)
-  init_sig (SIGQUIT, "QUIT", "Quit");
+  init_sig (SIGQUIT, "QUIT", _("Quit"));
 #endif
 #if defined (SIGILL)
-  init_sig (SIGILL, "ILL", "Illegal Instruction");
+  init_sig (SIGILL, "ILL", _("Illegal Instruction"));
 #endif
 #if defined (SIGTRAP)
-  init_sig (SIGTRAP, "TRAP", "Trace/breakpoint trap");
+  init_sig (SIGTRAP, "TRAP", _("Trace/breakpoint trap"));
 #endif
  /* If SIGIOT == SIGABRT, we want to print it as SIGABRT because
     SIGABRT is in ANSI and POSIX.1 and SIGIOT isn't.  */
 #if defined (SIGABRT)
-  init_sig (SIGABRT, "ABRT", "Aborted");
+  init_sig (SIGABRT, "ABRT", _("Aborted"));
 #endif
 #if defined (SIGIOT)
-  init_sig (SIGIOT, "IOT", "IOT trap");
+  init_sig (SIGIOT, "IOT", _("IOT trap"));
 #endif
 #if defined (SIGEMT)
-  init_sig (SIGEMT, "EMT", "EMT trap");
+  init_sig (SIGEMT, "EMT", _("EMT trap"));
 #endif
 #if defined (SIGFPE)
-  init_sig (SIGFPE, "FPE", "Floating point exception");
+  init_sig (SIGFPE, "FPE", _("Floating point exception"));
 #endif
 #if defined (SIGKILL)
-  init_sig (SIGKILL, "KILL", "Killed");
+  init_sig (SIGKILL, "KILL", _("Killed"));
 #endif
 #if defined (SIGBUS)
-  init_sig (SIGBUS, "BUS", "Bus error");
+  init_sig (SIGBUS, "BUS", _("Bus error"));
 #endif
 #if defined (SIGSEGV)
-  init_sig (SIGSEGV, "SEGV", "Segmentation fault");
+  init_sig (SIGSEGV, "SEGV", _("Segmentation fault"));
 #endif
 #if defined (SIGSYS)
-  init_sig (SIGSYS, "SYS", "Bad system call");
+  init_sig (SIGSYS, "SYS", _("Bad system call"));
 #endif
 #if defined (SIGPIPE)
-  init_sig (SIGPIPE, "PIPE", "Broken pipe");
+  init_sig (SIGPIPE, "PIPE", _("Broken pipe"));
 #endif
 #if defined (SIGALRM)
-  init_sig (SIGALRM, "ALRM", "Alarm clock");
+  init_sig (SIGALRM, "ALRM", _("Alarm clock"));
 #endif
 #if defined (SIGTERM)
-  init_sig (SIGTERM, "TERM", "Terminated");
+  init_sig (SIGTERM, "TERM", _("Terminated"));
 #endif
 #if defined (SIGUSR1)
-  init_sig (SIGUSR1, "USR1", "User defined signal 1");
+  init_sig (SIGUSR1, "USR1", _("User defined signal 1"));
 #endif
 #if defined (SIGUSR2)
-  init_sig (SIGUSR2, "USR2", "User defined signal 2");
+  init_sig (SIGUSR2, "USR2", _("User defined signal 2"));
 #endif
  /* If SIGCLD == SIGCHLD, we want to print it as SIGCHLD because that
     is what is in POSIX.1.  */
 #if defined (SIGCHLD)
-  init_sig (SIGCHLD, "CHLD", "Child exited");
+  init_sig (SIGCHLD, "CHLD", _("Child exited"));
 #endif
 #if defined (SIGCLD)
-  init_sig (SIGCLD, "CLD", "Child exited");
+  init_sig (SIGCLD, "CLD", _("Child exited"));
 #endif
 #if defined (SIGPWR)
-  init_sig (SIGPWR, "PWR", "Power failure");
+  init_sig (SIGPWR, "PWR", _("Power failure"));
 #endif
 #if defined (SIGTSTP)
-  init_sig (SIGTSTP, "TSTP", "Stopped");
+  init_sig (SIGTSTP, "TSTP", _("Stopped"));
 #endif
 #if defined (SIGTTIN)
-  init_sig (SIGTTIN, "TTIN", "Stopped (tty input)");
+  init_sig (SIGTTIN, "TTIN", _("Stopped (tty input)"));
 #endif
 #if defined (SIGTTOU)
-  init_sig (SIGTTOU, "TTOU", "Stopped (tty output)");
+  init_sig (SIGTTOU, "TTOU", _("Stopped (tty output)"));
 #endif
 #if defined (SIGSTOP)
-  init_sig (SIGSTOP, "STOP", "Stopped (signal)");
+  init_sig (SIGSTOP, "STOP", _("Stopped (signal)"));
 #endif
 #if defined (SIGXCPU)
-  init_sig (SIGXCPU, "XCPU", "CPU time limit exceeded");
+  init_sig (SIGXCPU, "XCPU", _("CPU time limit exceeded"));
 #endif
 #if defined (SIGXFSZ)
-  init_sig (SIGXFSZ, "XFSZ", "File size limit exceeded");
+  init_sig (SIGXFSZ, "XFSZ", _("File size limit exceeded"));
 #endif
 #if defined (SIGVTALRM)
-  init_sig (SIGVTALRM, "VTALRM", "Virtual timer expired");
+  init_sig (SIGVTALRM, "VTALRM", _("Virtual timer expired"));
 #endif
 #if defined (SIGPROF)
-  init_sig (SIGPROF, "PROF", "Profiling timer expired");
+  init_sig (SIGPROF, "PROF", _("Profiling timer expired"));
 #endif
 #if defined (SIGWINCH)
  /* "Window size changed" might be more accurate, but even if that
     is all that it means now, perhaps in the future it will be
     extended to cover other kinds of window changes.  */
-  init_sig (SIGWINCH, "WINCH", "Window changed");
+  init_sig (SIGWINCH, "WINCH", _("Window changed"));
 #endif
 #if defined (SIGCONT)
-  init_sig (SIGCONT, "CONT", "Continued");
+  init_sig (SIGCONT, "CONT", _("Continued"));
 #endif
 #if defined (SIGURG)
-  init_sig (SIGURG, "URG", "Urgent I/O condition");
+  init_sig (SIGURG, "URG", _("Urgent I/O condition"));
 #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.  */
-  init_sig (SIGIO, "IO", "I/O possible");
+  init_sig (SIGIO, "IO", _("I/O possible"));
 #endif
 #if defined (SIGWIND)
-  init_sig (SIGWIND, "WIND", "SIGWIND");
+  init_sig (SIGWIND, "WIND", _("SIGWIND"));
 #endif
 #if defined (SIGPHONE)
-  init_sig (SIGPHONE, "PHONE", "SIGPHONE");
+  init_sig (SIGPHONE, "PHONE", _("SIGPHONE"));
 #endif
 #if defined (SIGPOLL)
-  init_sig (SIGPOLL, "POLL", "I/O possible");
+  init_sig (SIGPOLL, "POLL", _("I/O possible"));
 #endif
 #if defined (SIGLOST)
-  init_sig (SIGLOST, "LOST", "Resource lost");
+  init_sig (SIGLOST, "LOST", _("Resource lost"));
 #endif
 #if defined (SIGDANGER)
-  init_sig (SIGDANGER, "DANGER", "Danger signal");
+  init_sig (SIGDANGER, "DANGER", _("Danger signal"));
 #endif
 #if defined (SIGINFO)
-  init_sig (SIGINFO, "INFO", "Information request");
+  init_sig (SIGINFO, "INFO", _("Information request"));
 #endif
 #if defined (SIGNOFP)
-  init_sig (SIGNOFP, "NOFP", "Floating point co-processor not available");
+  init_sig (SIGNOFP, "NOFP", _("Floating point co-processor not available"));
 #endif
 }

--- a/variable.c
+++ b/variable.c
@@ -768,7 +768,7 @@ try_variable_definition (flocp, line, origin)
  expanded_name = allocated_variable_expand (name);

  if (expanded_name[0] == '\0')
-    fatal (flocp, "empty variable name");
+    fatal (flocp, _("empty variable name"));

  /* Calculate the variable's new value in VALUE.  */

@@ -780,9 +780,9 @@ try_variable_definition (flocp, line, origin)
    case f_simple:
      /* A simple variable definition "var := value".  Expand the value.
         We have to allocate memory since otherwise it'll clobber the
-	 variable buffer, and we still need that.  */
-      alloc_value = allocated_variable_expand (p);
-      value = alloc_value;
+	 variable buffer, and we may still need that if we're looking at a
+         target-specific variable.  */
+      value = alloc_value = allocated_variable_expand (p);
      break;
    case f_conditional:
      /* A conditional variable definition "var ?= value".
@@ -824,8 +824,10 @@ try_variable_definition (flocp, line, origin)
 	  else
 	    /* The previous definition of the variable was simple.
 	       The new value comes from the old value, which was expanded
-	       when it was set; and from the expanded new value.  */
-	    p = variable_expand (p);
+	       when it was set; and from the expanded new value.  Allocate
+               memory for the expansion as we may still need the rest of the
+               buffer if we're looking at a target-specific variable.  */
+	    p = alloc_value = allocated_variable_expand (p);

 	  oldlen = strlen (v->value);
 	  newlen = strlen (p);
@@ -952,7 +954,7 @@ print_variable (v, prefix)
     register struct variable *v;
     char *prefix;
 {
-  char *origin;
+  const char *origin;

  switch (v->origin)
    {
@@ -980,7 +982,6 @@ print_variable (v, prefix)
    case o_invalid:
    default:
      abort ();
-      break;
    }
  printf ("# %s\n", origin);

@@ -1043,21 +1044,21 @@ print_variable_set (set, prefix)
    }

  if (nvariables == 0)
-    puts ("# No variables.");
+    puts (_("# No variables."));
  else
    {
-      printf ("# %u variables in %u hash buckets.\n",
+      printf (_("# %u variables in %u hash buckets.\n"),
 	      nvariables, set->buckets);
 #ifndef	NO_FLOAT
-      printf ("# average of %.1f variables per bucket, \
-max %u in one bucket.\n",
+      printf (_("# average of %.1f variables per bucket, \
+max %u in one bucket.\n"),
 	      (double) nvariables / (double) set->buckets,
 	      per_bucket);
 #else
      {
 	int f = (nvariables * 1000 + 5) / set->buckets;
-	printf ("# average of %d.%d variables per bucket, \
-max %u in one bucket.\n",
+	printf (_("# average of %d.%d variables per bucket, \
+max %u in one bucket.\n"),
 	      f/10, f%10,
 	      per_bucket);
      }
@@ -1071,7 +1072,7 @@ max %u in one bucket.\n",
 void
 print_variable_data_base ()
 {
-  puts ("\n# Variables\n");
+  puts (_("\n# Variables\n"));

  print_variable_set (&global_variable_set, "");
 }
--- a/vpath.c
+++ b/vpath.c
@@ -549,7 +549,7 @@ print_vpath_data_base ()
  register unsigned int nvpaths;
  register struct vpath *v;

-  puts ("\n# VPATH Search Paths\n");
+  puts (_("\n# VPATH Search Paths\n"));

  nvpaths = 0;
  for (v = vpaths; v != 0; v = v->next)
@@ -566,18 +566,18 @@ print_vpath_data_base ()
    }

  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
    {
      register char **path = general_vpath->searchpath;
      register 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],
Author	SHA1	Message	Date
Paul Smith	b134da5505	* A few cleanups, and 3.77.94 release.	1999-08-25 21:39:28 +00:00
Paul Smith	d0b03e9355	* Terminology change in docs and code.	1999-08-24 04:49:39 +00:00
Paul Smith	5dc4b92b60	* Fix jobserver algorithm again. * A couple of nits. * Fix considered pruning for double-colon rules.	1999-08-23 22:15:17 +00:00
Paul Smith	b3fa4b3c7e	* Start rewrite of jobserver to avoid unique tokens for debugging.	1999-08-23 05:35:14 +00:00
Paul Smith	6fa76a7d15	* Various changes.	1999-08-22 17:50:57 +00:00
Paul Smith	4ff6c62456	* Code cleanup.	1999-08-19 04:43:46 +00:00
Paul Smith	cbb9e38d10	* Rework jobserver yet one more time. * Install the $(if ...) function and document it. Still need some examples.	1999-08-13 07:36:26 +00:00
Paul Smith	9e79637ec3	* Some DOS fixes.	1999-08-12 23:16:42 +00:00
Paul Smith	e34540f79b	* Release 3.77.92. * Complete implementation of new jobserver algorithm. * A few minor fixups.	1999-08-01 08:12:06 +00:00
Paul Smith	09f1e4cf83	* Applied some DOS updates. * Started reworking the jobserver algorithm; not complete yet.	1999-08-01 06:05:17 +00:00
Paul Smith	28ef4c4dac	* Add gettext macros to start i18n support.	1999-07-28 06:23:37 +00:00
Paul Smith	3a945a665e	* Update the manual.	1999-07-26 05:06:58 +00:00
Paul Smith	6dbd348522	* Forgot ChangeLog.	1999-07-24 04:56:06 +00:00
Paul Smith	a9166bb7bc	* Some configure fixes.	1999-07-24 04:55:08 +00:00
Paul Smith	4e7ee4fc01	* Bugfix for NT archive support. * Rework how the jobserver stuff works.	1999-07-23 22:46:47 +00:00