~vcs-imports/make/master

/* Argument parsing and main program of GNU Make.

Copyright (C) 1988-2022 Free Software Foundation, Inc.

This file is part of GNU Make.

GNU Make is free software; you can redistribute it and/or modify it under the

terms of the GNU General Public License as published by the Free Software

Foundation; either version 3 of the License, or (at your option) any later

version.

GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR

A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with

this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "makeint.h"

#include "os.h"

#include "filedef.h"

#include "dep.h"

#include "variable.h"

#include "job.h"

#include "commands.h"

#include "rule.h"

#include "debug.h"

#include "getopt.h"

#include <assert.h>

#ifdef _AMIGA

# include <dos/dos.h>

# include <proto/dos.h>

#endif

#ifdef WINDOWS32

# include <windows.h>

# include <io.h>

#ifdef HAVE_STRINGS_H

# include <strings.h> /* for strcasecmp */

#endif

# include "pathstuff.h"

# include "sub_proc.h"

# include "w32err.h"

#endif

#ifdef __EMX__

# include <sys/types.h>

# include <sys/wait.h>

#endif

#ifdef HAVE_FCNTL_H

# include <fcntl.h>

#endif

#ifdef _AMIGA

int __stack = 20000; /* Make sure we have 20K of stack space */

#endif

#ifdef VMS

int vms_use_mcr_command = 0;

int vms_always_use_cmd_file = 0;

int vms_gnv_shell = 0;

int vms_legacy_behavior = 0;

int vms_comma_separator = 0;

int vms_unix_simulation = 0;

int vms_report_unix_paths = 0;

/* Evaluates if a VMS environment option is set, only look at first character */

static int

get_vms_env_flag (const char *name, int default_value)

{

char * value;

char x;

  value = getenv (name);

  if (value == NULL)

    return default_value;

  x = toupper (value[0]);

  switch (x)

    {

    case '1':

    case 'T':

    case 'E':

      return 1;

      break;

    case '0':

    case 'F':

    case 'D':

      return 0;

    }

}

#endif

#if defined HAVE_WAITPID || defined HAVE_WAIT3

# define HAVE_WAIT_NOHANG

#endif

#ifndef HAVE_UNISTD_H

int chdir ();

#endif

#ifndef STDC_HEADERS

# ifndef sun                    /* Sun has an incorrect decl in a header.  */

void exit (int) NORETURN;

# endif

double atof ();

#endif

static void clean_jobserver (int status);

static void print_data_base (void);

static void print_version (void);

static void decode_switches (int argc, const char **argv, int env);

static struct variable *define_makeflags (int all, int makefile);

static char *quote_for_env (char *out, const char *in);

static void initialize_global_hash_tables (void);

/* True if C is a switch value that corresponds to a short option.  */

#define short_option(c) ((c) <= CHAR_MAX)

/* The structure used to hold the list of strings given

   in command switches of a type that takes strlist arguments.  */

struct stringlist

  {

    const char **list;  /* Nil-terminated list of strings.  */

    unsigned int idx;   /* Index into above.  */

    unsigned int max;   /* Number of pointers allocated.  */

  };

/* The recognized command switches.  */

/* Nonzero means do extra verification (that may slow things down).  */

int verify_flag;

/* Nonzero means do not print commands to be executed (-s).  */

static int silent_flag;

static const int default_silent_flag = 0;

/* Nonzero means either -s was given, or .SILENT-with-no-deps was seen.  */

int run_silent = 0;

/* Nonzero means just touch the files

   that would appear to need remaking (-t)  */

int touch_flag;

/* Nonzero means just print what commands would need to be executed,

   don't actually execute them (-n).  */

int just_print_flag;

/* Print debugging info (--debug).  */

static struct stringlist *db_flags = 0;

static int debug_flag = 0;

int db_level = 0;

/* Synchronize output (--output-sync).  */

char *output_sync_option = 0;

/* Environment variables override makefile definitions.  */

int env_overrides = 0;

/* Nonzero means ignore status codes returned by commands

   executed to remake files.  Just treat them all as successful (-i).  */

int ignore_errors_flag = 0;

/* Nonzero means don't remake anything, just print the data base

   that results from reading the makefile (-p).  */

int print_data_base_flag = 0;

/* Nonzero means don't remake anything; just return a nonzero status

   if the specified targets are not up to date (-q).  */

int question_flag = 0;

/* Nonzero means do not use any of the builtin rules (-r) / variables (-R).  */

int no_builtin_rules_flag = 0;

int no_builtin_variables_flag = 0;

/* Nonzero means keep going even if remaking some file fails (-k).  */

int keep_going_flag;

static const int default_keep_going_flag = 0;

/* Nonzero means check symlink mtimes.  */

int check_symlink_flag = 0;

/* Nonzero means print directory before starting and when done (-w).  */

int print_directory;

static int print_directory_flag = -1;

static const int default_print_directory_flag = -1;

/* Nonzero means print version information.  */

int print_version_flag = 0;

/* List of makefiles given with -f switches.  */

static struct stringlist *makefiles = 0;

/* Size of the stack when we started.  */

#ifdef SET_STACK_SIZE

struct rlimit stack_limit;

#endif

/* Number of job slots for parallelism.  */

unsigned int job_slots;

#define INVALID_JOB_SLOTS (-1)

static unsigned int master_job_slots = 0;

static int arg_job_slots = INVALID_JOB_SLOTS;

static const int default_job_slots = INVALID_JOB_SLOTS;

/* Value of job_slots that means no limit.  */

static const int inf_jobs = 0;

/* Authorization for the jobserver.  */

static char *jobserver_auth = NULL;

/* Handle for the mutex used on Windows to synchronize output of our

   children under -O.  */

char *sync_mutex = NULL;

/* Maximum load average at which multiple jobs will be run.

   Negative values mean unlimited, while zero means limit to

   zero load (which could be useful to start infinite jobs remotely

   but one at a time locally).  */

double max_load_average = -1.0;

double default_load_average = -1.0;

/* List of directories given with -C switches.  */

static struct stringlist *directories = 0;

/* List of include directories given with -I switches.  */

static struct stringlist *include_dirs = 0;

/* List of files given with -o switches.  */

static struct stringlist *old_files = 0;

/* List of files given with -W switches.  */

static struct stringlist *new_files = 0;

/* List of strings to be eval'd.  */

static struct stringlist *eval_strings = 0;

/* If nonzero, we should just print usage and exit.  */

static int print_usage_flag = 0;

/* If nonzero, we should print a warning message

   for each reference to an undefined variable.  */

int warn_undefined_variables_flag;

/* If nonzero, always build all targets, regardless of whether

   they appear out of date or not.  */

static int always_make_set = 0;

int always_make_flag = 0;

/* If nonzero, we're in the "try to rebuild makefiles" phase.  */

int rebuilding_makefiles = 0;

/* Remember the original value of the SHELL variable, from the environment.  */

struct variable shell_var;

/* This character introduces a command: it's the first char on the line.  */

char cmd_prefix = '\t';

/* Count the number of commands we've invoked, that might change something in

   the filesystem.  Start with 1 so calloc'd memory never matches.  */

unsigned long command_count = 1;

/* Remember the location of the name of the batch file from stdin.  */

static int stdin_offset = -1;

/* The usage output.  We write it this way to make life easier for the

   translators, especially those trying to translate to right-to-left

   languages like Hebrew.  */

static const char *const usage[] =

  {

    N_("Options:\n"),

    N_("\

  -b, -m                      Ignored for compatibility.\n"),

    N_("\

  -B, --always-make           Unconditionally make all targets.\n"),

    N_("\

  -C DIRECTORY, --directory=DIRECTORY\n\

                              Change to DIRECTORY before doing anything.\n"),

    N_("\

  -d                          Print lots of debugging information.\n"),

    N_("\

  --debug[=FLAGS]             Print various types of debugging information.\n"),

    N_("\

  -e, --environment-overrides\n\

                              Environment variables override makefiles.\n"),

    N_("\

  -E STRING, --eval=STRING    Evaluate STRING as a makefile statement.\n"),

    N_("\

  -f FILE, --file=FILE, --makefile=FILE\n\

                              Read FILE as a makefile.\n"),

    N_("\

  -h, --help                  Print this message and exit.\n"),

    N_("\

  -i, --ignore-errors         Ignore errors from recipes.\n"),

    N_("\

  -I DIRECTORY, --include-dir=DIRECTORY\n\

                              Search DIRECTORY for included makefiles.\n"),

    N_("\

  -j [N], --jobs[=N]          Allow N jobs at once; infinite jobs with no arg.\n"),

    N_("\

  -k, --keep-going            Keep going when some targets can't be made.\n"),

    N_("\

  -l [N], --load-average[=N], --max-load[=N]\n\

                              Don't start multiple jobs unless load is below N.\n"),

    N_("\

  -L, --check-symlink-times   Use the latest mtime between symlinks and target.\n"),

    N_("\

  -n, --just-print, --dry-run, --recon\n\

                              Don't actually run any recipe; just print them.\n"),

    N_("\

  -o FILE, --old-file=FILE, --assume-old=FILE\n\

                              Consider FILE to be very old and don't remake it.\n"),

    N_("\

  -O[TYPE], --output-sync[=TYPE]\n\

                              Synchronize output of parallel jobs by TYPE.\n"),

    N_("\

  -p, --print-data-base       Print make's internal database.\n"),

    N_("\

  -q, --question              Run no recipe; exit status says if up to date.\n"),

    N_("\

  -r, --no-builtin-rules      Disable the built-in implicit rules.\n"),

    N_("\

  -R, --no-builtin-variables  Disable the built-in variable settings.\n"),

    N_("\

  -s, --silent, --quiet       Don't echo recipes.\n"),

    N_("\

  --no-silent                 Echo recipes (disable --silent mode).\n"),

    N_("\

  -S, --no-keep-going, --stop\n\

                              Turns off -k.\n"),

    N_("\

  -t, --touch                 Touch targets instead of remaking them.\n"),

    N_("\

  --trace                     Print tracing information.\n"),

    N_("\

  -v, --version               Print the version number of make and exit.\n"),

    N_("\

  -w, --print-directory       Print the current directory.\n"),

    N_("\

  --no-print-directory        Turn off -w, even if it was turned on implicitly.\n"),

    N_("\

  -W FILE, --what-if=FILE, --new-file=FILE, --assume-new=FILE\n\

                              Consider FILE to be infinitely new.\n"),

    N_("\

  --warn-undefined-variables  Warn when an undefined variable is referenced.\n"),

    NULL

  };

/* Nonzero if the "--trace" option was given.  */

static int trace_flag = 0;

/* The structure that describes an accepted command switch.  */

struct command_switch

  {

    int c;                      /* The switch character.  */

    enum                        /* Type of the value.  */

      {

        flag,                   /* Turn int flag on.  */

        flag_off,               /* Turn int flag off.  */

        string,                 /* One string per invocation.  */

        strlist,                /* One string per switch.  */

        filename,               /* A string containing a file name.  */

        positive_int,           /* A positive integer.  */

        floating,               /* A floating-point number (double).  */

        ignore                  /* Ignored.  */

      } type;

    void *value_ptr;    /* Pointer to the value-holding variable.  */

    unsigned int env:1;         /* Can come from MAKEFLAGS.  */

    unsigned int toenv:1;       /* Should be put in MAKEFLAGS.  */

    unsigned int no_makefile:1; /* Don't propagate when remaking makefiles.  */

    const void *noarg_value;    /* Pointer to value used if no arg given.  */

    const void *default_value;  /* Pointer to default value.  */

    const char *long_name;      /* Long option name.  */

  };

/* The table of command switches.

   Order matters here: this is the order MAKEFLAGS will be constructed.

   So be sure all simple flags (single char, no argument) come first.  */

#define TEMP_STDIN_OPT (CHAR_MAX+10)

static const struct command_switch switches[] =

  {

    { 'b', ignore, 0, 0, 0, 0, 0, 0, 0 },

    { 'B', flag, &always_make_set, 1, 1, 0, 0, 0, "always-make" },

    { 'd', flag, &debug_flag, 1, 1, 0, 0, 0, 0 },

    { 'e', flag, &env_overrides, 1, 1, 0, 0, 0, "environment-overrides", },

    { 'E', strlist, &eval_strings, 1, 0, 0, 0, 0, "eval" },

    { 'h', flag, &print_usage_flag, 0, 0, 0, 0, 0, "help" },

    { 'i', flag, &ignore_errors_flag, 1, 1, 0, 0, 0, "ignore-errors" },

    { 'k', flag, &keep_going_flag, 1, 1, 0, 0, &default_keep_going_flag,

      "keep-going" },

    { 'L', flag, &check_symlink_flag, 1, 1, 0, 0, 0, "check-symlink-times" },

    { 'm', ignore, 0, 0, 0, 0, 0, 0, 0 },

    { 'n', flag, &just_print_flag, 1, 1, 1, 0, 0, "just-print" },

    { 'p', flag, &print_data_base_flag, 1, 1, 0, 0, 0, "print-data-base" },

    { 'q', flag, &question_flag, 1, 1, 1, 0, 0, "question" },

    { 'r', flag, &no_builtin_rules_flag, 1, 1, 0, 0, 0, "no-builtin-rules" },

    { 'R', flag, &no_builtin_variables_flag, 1, 1, 0, 0, 0,

      "no-builtin-variables" },

    { 's', flag, &silent_flag, 1, 1, 0, 0, &default_silent_flag, "silent" },

    { 'S', flag_off, &keep_going_flag, 1, 1, 0, 0, &default_keep_going_flag,

      "no-keep-going" },

    { 't', flag, &touch_flag, 1, 1, 1, 0, 0, "touch" },

    { 'v', flag, &print_version_flag, 1, 1, 0, 0, 0, "version" },

    { 'w', flag, &print_directory_flag, 1, 1, 0, 0,

      &default_print_directory_flag, "print-directory" },

    /* These options take arguments.  */

    { 'C', filename, &directories, 0, 0, 0, 0, 0, "directory" },

    { 'f', filename, &makefiles, 0, 0, 0, 0, 0, "file" },

    { 'I', filename, &include_dirs, 1, 1, 0, 0, 0,

      "include-dir" },

    { 'j', positive_int, &arg_job_slots, 1, 1, 0, &inf_jobs, &default_job_slots,

      "jobs" },

    { 'l', floating, &max_load_average, 1, 1, 0, &default_load_average,

      &default_load_average, "load-average" },

    { 'o', filename, &old_files, 0, 0, 0, 0, 0, "old-file" },

    { 'O', string, &output_sync_option, 1, 1, 0, "target", 0, "output-sync" },

    { 'W', filename, &new_files, 0, 0, 0, 0, 0, "what-if" },

    /* These are long-style options.  */

    { CHAR_MAX+1, strlist, &db_flags, 1, 1, 0, "basic", 0, "debug" },

    { CHAR_MAX+2, string, &jobserver_auth, 1, 1, 0, 0, 0, "jobserver-auth" },

    { CHAR_MAX+3, flag, &trace_flag, 1, 1, 0, 0, 0, "trace" },

    { CHAR_MAX+4, flag_off, &print_directory_flag, 1, 1, 0, 0,

      &default_print_directory_flag, "no-print-directory" },

    { CHAR_MAX+5, flag, &warn_undefined_variables_flag, 1, 1, 0, 0, 0,

      "warn-undefined-variables" },

    { CHAR_MAX+7, string, &sync_mutex, 1, 1, 0, 0, 0, "sync-mutex" },

    { CHAR_MAX+8, flag_off, &silent_flag, 1, 1, 0, 0, &default_silent_flag,

      "no-silent" },

    { CHAR_MAX+9, string, &jobserver_auth, 1, 0, 0, 0, 0, "jobserver-fds" },

    /* There is special-case handling for this in decode_switches() as well.  */

    { TEMP_STDIN_OPT, filename, &makefiles, 0, 0, 0, 0, 0, "temp-stdin" },

    { 0, 0, 0, 0, 0, 0, 0, 0, 0 }

  };

/* Secondary long names for options.  */

static struct option long_option_aliases[] =

  {

    { "quiet",          no_argument,            0, 's' },

    { "stop",           no_argument,            0, 'S' },

    { "new-file",       required_argument,      0, 'W' },

    { "assume-new",     required_argument,      0, 'W' },

    { "assume-old",     required_argument,      0, 'o' },

    { "max-load",       optional_argument,      0, 'l' },

    { "dry-run",        no_argument,            0, 'n' },

    { "recon",          no_argument,            0, 'n' },

    { "makefile",       required_argument,      0, 'f' },

  };

/* List of goal targets.  */

static struct goaldep *goals, *lastgoal;

/* List of variables which were defined on the command line

   (or, equivalently, in MAKEFLAGS).  */

struct command_variable

  {

    struct command_variable *next;

    struct variable *variable;

  };

static struct command_variable *command_variables;

/* The name we were invoked with.  */

const char *program;

/* Our current directory before processing any -C options.  */

char *directory_before_chdir;

/* Our current directory after processing all -C options.  */

char *starting_directory;

/* Value of the MAKELEVEL variable at startup (or 0).  */

unsigned int makelevel;

/* Pointer to the value of the .DEFAULT_GOAL special variable.

   The value will be the name of the goal to remake if the command line

   does not override it.  It can be set by the makefile, or else it's

   the first target defined in the makefile whose name does not start

   with '.'.  */

struct variable * default_goal_var;

/* Pointer to structure for the file .DEFAULT

   whose commands are used for any file that has none of its own.

   This is zero if the makefiles do not define .DEFAULT.  */

struct file *default_file;

/* Nonzero if we have seen the magic '.POSIX' target.

   This turns on pedantic compliance with POSIX.2.  */

int posix_pedantic;

/* Nonzero if we have seen the '.SECONDEXPANSION' target.

   This turns on secondary expansion of prerequisites.  */

int second_expansion;

/* Nonzero if we have seen the '.ONESHELL' target.

   This causes the entire recipe to be handed to SHELL

   as a single string, potentially containing newlines.  */

int one_shell;

/* One of OUTPUT_SYNC_* if the "--output-sync" option was given.  This

   attempts to synchronize the output of parallel jobs such that the results

   of each job stay together.  */

int output_sync = OUTPUT_SYNC_NONE;

/* Nonzero if we have seen the '.NOTPARALLEL' target.

   This turns off parallel builds for this invocation of make.  */

int not_parallel;

/* Nonzero if some rule detected clock skew; we keep track so (a) we only

   print one warning about it during the run, and (b) we can print a final

   warning at the end of the run. */

int clock_skew_detected;

/* Map of possible stop characters for searching strings.  */

#ifndef UCHAR_MAX

# define UCHAR_MAX 255

#endif

unsigned short stopchar_map[UCHAR_MAX + 1] = {0};

/* If output-sync is enabled we'll collect all the output generated due to

   options, while reading makefiles, etc.  */

struct output make_sync;

/* Mask of signals that are being caught with fatal_error_signal.  */

#if defined(POSIX)

sigset_t fatal_signal_set;

#elif defined(HAVE_SIGSETMASK)

int fatal_signal_mask;

#endif

#if !HAVE_DECL_BSD_SIGNAL && !defined bsd_signal

# if !defined HAVE_SIGACTION

#  define bsd_signal signal

# else

typedef RETSIGTYPE (*bsd_signal_ret_t) (int);

static bsd_signal_ret_t

bsd_signal (int sig, bsd_signal_ret_t func)

{

  struct sigaction act, oact;

  act.sa_handler = func;

  act.sa_flags = SA_RESTART;

  sigemptyset (&act.sa_mask);

  sigaddset (&act.sa_mask, sig);

  if (sigaction (sig, &act, &oact) != 0)

    return SIG_ERR;

  return oact.sa_handler;

}

# endif

#endif

static void

initialize_global_hash_tables (void)

{

  init_hash_global_variable_set ();

  strcache_init ();

  init_hash_files ();

  hash_init_directories ();

  hash_init_function_table ();

}

/* This character map locate stop chars when parsing GNU makefiles.

   Each element is true if we should stop parsing on that character.  */

static void

initialize_stopchar_map (void)

{

  int i;

  stopchar_map[(int)'\0'] = MAP_NUL;

  stopchar_map[(int)'#'] = MAP_COMMENT;

  stopchar_map[(int)';'] = MAP_SEMI;

  stopchar_map[(int)'='] = MAP_EQUALS;

  stopchar_map[(int)':'] = MAP_COLON;

  stopchar_map[(int)'|'] = MAP_PIPE;

  stopchar_map[(int)'.'] = MAP_DOT | MAP_USERFUNC;

  stopchar_map[(int)','] = MAP_COMMA;

  stopchar_map[(int)'('] = MAP_VARSEP;

  stopchar_map[(int)'{'] = MAP_VARSEP;

  stopchar_map[(int)'}'] = MAP_VARSEP;

  stopchar_map[(int)')'] = MAP_VARSEP;

  stopchar_map[(int)'$'] = MAP_VARIABLE;

  stopchar_map[(int)'-'] = MAP_USERFUNC;

  stopchar_map[(int)'_'] = MAP_USERFUNC;

  stopchar_map[(int)' '] = MAP_BLANK;

  stopchar_map[(int)'\t'] = MAP_BLANK;

  stopchar_map[(int)'/'] = MAP_DIRSEP;

#if defined(VMS)

  stopchar_map[(int)':'] |= MAP_DIRSEP;

  stopchar_map[(int)']'] |= MAP_DIRSEP;

  stopchar_map[(int)'>'] |= MAP_DIRSEP;

#elif defined(HAVE_DOS_PATHS)

  stopchar_map[(int)'\\'] |= MAP_DIRSEP;

#endif

  for (i = 1; i <= UCHAR_MAX; ++i)

    {

      if (isspace (i) && NONE_SET (stopchar_map[i], MAP_BLANK))

        /* Don't mark blank characters as newline characters.  */

        stopchar_map[i] |= MAP_NEWLINE;

      else if (isalnum (i))

        stopchar_map[i] |= MAP_USERFUNC;

    }

}

static const char *

expand_command_line_file (const char *name)

{

  const char *cp;

  char *expanded = 0;

  if (name[0] == '\0')

    O (fatal, NILF, _("empty string invalid as file name"));

  if (name[0] == '~')

    {

      expanded = tilde_expand (name);

      if (expanded && expanded[0] != '\0')

        name = expanded;

    }

  /* This is also done in parse_file_seq, so this is redundant

     for names read from makefiles.  It is here for names passed

     on the command line.  */

  while (name[0] == '.' && name[1] == '/')

    {

      name += 2;

      while (name[0] == '/')

        /* Skip following slashes: ".//foo" is "foo", not "/foo".  */

        ++name;

    }

  if (name[0] == '\0')

    {

      /* Nothing else but one or more "./", maybe plus slashes!  */

      name = "./";

    }

  cp = strcache_add (name);

  free (expanded);

  return cp;

}

/* Toggle -d on receipt of SIGUSR1.  */

#ifdef SIGUSR1

static RETSIGTYPE

debug_signal_handler (int sig UNUSED)

{

  db_level = db_level ? DB_NONE : DB_BASIC;

}

#endif

static void

decode_debug_flags (void)

{

  const char **pp;

  if (debug_flag)

    db_level = DB_ALL;

  if (trace_flag)

    db_level |= DB_PRINT | DB_WHY;

  if (db_flags)

    for (pp=db_flags->list; *pp; ++pp)

      {

        const char *p = *pp;

        while (1)

          {

            switch (tolower (p[0]))

              {

              case 'a':

                db_level |= DB_ALL;

                break;

              case 'b':

                db_level |= DB_BASIC;

                break;

              case 'i':

                db_level |= DB_BASIC | DB_IMPLICIT;

                break;

              case 'j':

                db_level |= DB_JOBS;

                break;

              case 'm':

                db_level |= DB_BASIC | DB_MAKEFILES;

                break;

              case 'n':

                db_level = 0;

                break;

              case 'p':

                db_level |= DB_PRINT;

                break;

              case 'v':

                db_level |= DB_BASIC | DB_VERBOSE;

                break;

              case 'w':

                db_level |= DB_WHY;

                break;

              default:

                OS (fatal, NILF,

                    _("unknown debug level specification '%s'"), p);

              }

            while (*(++p) != '\0')

              if (*p == ',' || *p == ' ')

                {

                  ++p;

                  break;

                }

            if (*p == '\0')

              break;

          }

      }

  if (db_level)

    verify_flag = 1;

  if (! db_level)

    debug_flag = 0;

}

static void

decode_output_sync_flags (void)

{

#ifdef NO_OUTPUT_SYNC

  output_sync = OUTPUT_SYNC_NONE;

#else

  if (output_sync_option)

    {

      if (streq (output_sync_option, "none"))

        output_sync = OUTPUT_SYNC_NONE;

      else if (streq (output_sync_option, "line"))

        output_sync = OUTPUT_SYNC_LINE;

      else if (streq (output_sync_option, "target"))

        output_sync = OUTPUT_SYNC_TARGET;

      else if (streq (output_sync_option, "recurse"))

        output_sync = OUTPUT_SYNC_RECURSE;

      else

        OS (fatal, NILF,

            _("unknown output-sync type '%s'"), output_sync_option);

    }