src/m4.c

   1 /* GNU m4 -- A simple macro processor
   2
   3    Copyright (C) 1989-1994, 2004-2014, 2016-2017, 2020-2021 Free
   4    Software Foundation, Inc.
   5
   6    This file is part of GNU M4.
   7
   8    GNU M4 is free software: you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation, either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    GNU M4 is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <https://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "m4.h"
  23
  24 #include <getopt.h>
  25 #include <limits.h>
  26 #include <signal.h>
  27
  28 #include "c-stack.h"
  29 #include "configmake.h"
  30 #include "ignore-value.h"
  31 #include "progname.h"
  32 #include "propername.h"
  33 #include "version-etc.h"
  34
  35 #ifdef DEBUG_STKOVF
  36 # include "assert.h"
  37 #endif
  38
  39 /* TRANSLATORS: This is a non-ASCII name: The first name is (with
  40    Unicode escapes) "Ren\u00e9" or (with HTML entities) "Ren&eacute;".  */
  41 #define AUTHORS proper_name_utf8 ("Rene' Seindal", "Ren\xC3\xA9 Seindal")
  42
  43 static _Noreturn void usage (int);
  44
  45 /* Enable sync output for /lib/cpp (-s).  */
  46 int sync_output = 0;
  47
  48 /* Debug (-d[flags]).  */
  49 int debug_level = 0;
  50
  51 /* Hash table size (should be a prime) (-Hsize).  */
  52 size_t hash_table_size = HASHMAX;
  53
  54 /* Disable GNU extensions (-G).  */
  55 int no_gnu_extensions = 0;
  56
  57 /* Prefix all builtin functions by `m4_'.  */
  58 int prefix_all_builtins = 0;
  59
  60 /* Max length of arguments in trace output (-lsize).  */
  61 int max_debug_argument_length = 0;
  62
  63 /* Suppress warnings about missing arguments.  */
  64 int suppress_warnings = 0;
  65
  66 /* If true, then warnings affect exit status.  */
  67 static bool fatal_warnings = false;
  68
  69 /* If not zero, then value of exit status for warning diagnostics.  */
  70 int warning_status = 0;
  71
  72 /* Artificial limit for expansion_level in macro.c.  */
  73 int nesting_limit = 1024;
  74
  75 #ifdef ENABLE_CHANGEWORD
  76 /* User provided regexp for describing m4 words.  */
  77 const char *user_word_regexp = "";
  78 #endif
  79
  80 /* Global catchall for any errors that should affect final error status, but
  81    where we try to continue execution in the meantime.  */
  82 int retcode;
  83
  84 struct macro_definition
  85 {
  86   struct macro_definition *next;
  87   int code; /* D, U, s, t, '\1', or DEBUGFILE_OPTION.  */
  88   const char *arg;
  89 };
  90 typedef struct macro_definition macro_definition;
  91 \f
  92 /* Error handling functions.  */
  93
  94 /*-----------------------.
  95 | Wrapper around error.  |
  96 `-----------------------*/
  97
  98 void
  99 m4_error (int status, int errnum, const char *format, ...)
 100 {
 101   va_list args;
 102   va_start (args, format);
 103   verror_at_line (status, errnum, current_line ? current_file : NULL,
 104                   current_line, format, args);
 105   if (fatal_warnings && ! retcode)
 106     retcode = EXIT_FAILURE;
 107   va_end (args);
 108 }
 109
 110 void
 111 m4_failure (int errnum, const char *format, ...)
 112 {
 113   va_list args;
 114   va_start (args, format);
 115   verror_at_line (EXIT_FAILURE, errnum, current_line ? current_file : NULL,
 116                   current_line, format, args);
 117   assume (false);
 118 }
 119
 120 /*-------------------------------.
 121 | Wrapper around error_at_line.  |
 122 `-------------------------------*/
 123
 124 void
 125 m4_error_at_line (int status, int errnum, const char *file, int line,
 126                   const char *format, ...)
 127 {
 128   va_list args;
 129   va_start (args, format);
 130   verror_at_line (status, errnum, line ? file : NULL, line, format, args);
 131   if (fatal_warnings && ! retcode)
 132     retcode = EXIT_FAILURE;
 133   va_end (args);
 134 }
 135
 136 void
 137 m4_failure_at_line (int errnum, const char *file, int line,
 138                     const char *format, ...)
 139 {
 140   va_list args;
 141   va_start (args, format);
 142   verror_at_line (EXIT_FAILURE, errnum, line ? file : NULL,
 143                   line, format, args);
 144   assume (false);
 145 }
 146
 147 #ifndef SIGBUS
 148 # define SIGBUS SIGILL
 149 #endif
 150
 151 #ifndef NSIG
 152 # ifndef MAX
 153 #  define MAX(a,b) ((a) < (b) ? (b) : (a))
 154 # endif
 155 # define NSIG (MAX (SIGABRT, MAX (SIGILL, MAX (SIGFPE,  \
 156                                                MAX (SIGSEGV, SIGBUS)))) + 1)
 157 #endif
 158
 159 /* Pre-translated messages for program errors.  Do not translate in
 160    the signal handler, since gettext and strsignal are not
 161    async-signal-safe.  */
 162 static const char * volatile program_error_message;
 163 static const char * volatile signal_message[NSIG];
 164
 165 /* Print a nicer message about any programmer errors, then exit.  This
 166    must be aysnc-signal safe, since it is executed as a signal
 167    handler.  If SIGNO is zero, this represents a stack overflow; in
 168    that case, we return to allow c_stack_action to handle things.  */
 169 static void
 170 fault_handler (int signo)
 171 {
 172   if (signo)
 173     {
 174       /* POSIX states that reading static memory is, in general, not
 175          async-safe.  However, the static variables that we read are
 176          never modified once this handler is installed, so this
 177          particular usage is safe.  And it seems an oversight that
 178          POSIX claims strlen is not async-safe.  Ignore write
 179          failures, since we will exit with non-zero status anyway.  */
 180 #define WRITE(f, b, l) ignore_value (write (f, b, l))
 181       WRITE (STDERR_FILENO, program_name, strlen (program_name));
 182       WRITE (STDERR_FILENO, ": ", 2);
 183       WRITE (STDERR_FILENO, program_error_message,
 184              strlen (program_error_message));
 185       if (signal_message[signo])
 186         {
 187           WRITE (STDERR_FILENO, ": ", 2);
 188           WRITE (STDERR_FILENO, signal_message[signo],
 189                  strlen (signal_message[signo]));
 190         }
 191       WRITE (STDERR_FILENO, "\n", 1);
 192 #undef WRITE
 193       _exit (EXIT_INTERNAL_ERROR);
 194     }
 195 }
 196 \f
 197
 198 /*---------------------------------------------.
 199 | Print a usage message and exit with STATUS.  |
 200 `---------------------------------------------*/
 201
 202 static void
 203 usage (int status)
 204 {
 205   if (status != EXIT_SUCCESS)
 206     {
 207       xfprintf (stderr, _("Try `%s --help' for more information."),
 208                 program_name);
 209       fputs ("\n", stderr);
 210     }
 211   else
 212     {
 213       xprintf (_("Usage: %s [OPTION]... [FILE]...\n"), program_name);
 214       fputs (_("\
 215 Process macros in FILEs.  If no FILE or if FILE is `-', standard input\n\
 216 is read.\n\
 217 "), stdout);
 218       puts ("");
 219       fputs (_("\
 220 Mandatory or optional arguments to long options are mandatory or optional\n\
 221 for short options too.\n\
 222 "), stdout);
 223       puts ("");
 224       fputs (_("\
 225 Operation modes:\n\
 226       --help                   display this help and exit\n\
 227       --version                output version information and exit\n\
 228 "), stdout);
 229       fputs (_("\
 230   -E, --fatal-warnings         once: warnings become errors, twice: stop\n\
 231                                  execution at first error\n\
 232   -i, --interactive            unbuffer output, ignore interrupts\n\
 233   -P, --prefix-builtins        force a `m4_' prefix to all builtins\n\
 234   -Q, --quiet, --silent        suppress some warnings for builtins\n\
 235 "), stdout);
 236       xprintf (_("\
 237       --warn-macro-sequence[=REGEXP]\n\
 238                                warn if macro definition matches REGEXP,\n\
 239                                  default %s\n\
 240 "), DEFAULT_MACRO_SEQUENCE);
 241 #ifdef ENABLE_CHANGEWORD
 242       fputs (_("\
 243   -W, --word-regexp=REGEXP     use REGEXP for macro name syntax\n\
 244 "), stdout);
 245 #endif
 246       puts ("");
 247       fputs (_("\
 248 Preprocessor features:\n\
 249   -D, --define=NAME[=VALUE]    define NAME as having VALUE, or empty\n\
 250   -I, --include=DIRECTORY      append DIRECTORY to include path\n\
 251   -s, --synclines              generate `#line NUM \"FILE\"' lines\n\
 252   -U, --undefine=NAME          undefine NAME\n\
 253 "), stdout);
 254       puts ("");
 255       xprintf (_("\
 256 Limits control:\n\
 257   -g, --gnu                    override -G to re-enable GNU extensions\n\
 258   -G, --traditional            suppress all GNU extensions\n\
 259   -H, --hashsize=PRIME         set symbol lookup hash table size [509]\n\
 260   -L, --nesting-limit=NUMBER   change nesting limit, 0 for unlimited [%d]\n\
 261 "), nesting_limit);
 262       puts ("");
 263       fputs (_("\
 264 Frozen state files:\n\
 265   -F, --freeze-state=FILE      produce a frozen state on FILE at end\n\
 266   -R, --reload-state=FILE      reload a frozen state from FILE at start\n\
 267 "), stdout);
 268       puts ("");
 269       fputs (_("\
 270 Debugging:\n\
 271   -d, --debug[=FLAGS]          set debug level (no FLAGS implies `aeq')\n\
 272       --debugfile[=FILE]       redirect debug and trace output to FILE\n\
 273                                  (default stderr, discard if empty string)\n\
 274   -l, --arglength=NUM          restrict macro tracing size\n\
 275   -t, --trace=NAME             trace NAME when it is defined\n\
 276 "), stdout);
 277       puts ("");
 278       fputs (_("\
 279 FLAGS is any of:\n\
 280   a   show actual arguments\n\
 281   c   show before collect, after collect and after call\n\
 282   e   show expansion\n\
 283   f   say current input file name\n\
 284   i   show changes in input files\n\
 285 "), stdout);
 286       fputs (_("\
 287   l   say current input line number\n\
 288   p   show results of path searches\n\
 289   q   quote values as necessary, with a or e flag\n\
 290   t   trace for all macro calls, not only traceon'ed\n\
 291   x   add a unique macro call id, useful with c flag\n\
 292   V   shorthand for all of the above flags\n\
 293 "), stdout);
 294       puts ("");
 295       fputs (_("\
 296 If defined, the environment variable `M4PATH' is a colon-separated list\n\
 297 of directories included after any specified by `-I'.\n\
 298 "), stdout);
 299       puts ("");
 300       fputs (_("\
 301 Exit status is 0 for success, 1 for failure, 63 for frozen file version\n\
 302 mismatch, or whatever value was passed to the m4exit macro.\n\
 303 "), stdout);
 304       emit_bug_reporting_address ();
 305     }
 306   exit (status);
 307 }
 308
 309 /*--------------------------------------.
 310 | Decode options and launch execution.  |
 311 `--------------------------------------*/
 312
 313 /* For long options that have no equivalent short option, use a
 314    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
 315 enum
 316 {
 317   DEBUGFILE_OPTION = CHAR_MAX + 1,      /* no short opt */
 318   DIVERSIONS_OPTION,                    /* not quite -N, because of message */
 319   WARN_MACRO_SEQUENCE_OPTION,           /* no short opt */
 320
 321   HELP_OPTION,                          /* no short opt */
 322   VERSION_OPTION                        /* no short opt */
 323 };
 324
 325 static const struct option long_options[] =
 326 {
 327   {"arglength", required_argument, NULL, 'l'},
 328   {"debug", optional_argument, NULL, 'd'},
 329   {"define", required_argument, NULL, 'D'},
 330   {"error-output", required_argument, NULL, 'o'}, /* FIXME: deprecate in 2.0 */
 331   {"fatal-warnings", no_argument, NULL, 'E'},
 332   {"freeze-state", required_argument, NULL, 'F'},
 333   {"gnu", no_argument, NULL, 'g'},
 334   {"hashsize", required_argument, NULL, 'H'},
 335   {"include", required_argument, NULL, 'I'},
 336   {"interactive", no_argument, NULL, 'i'},
 337   {"nesting-limit", required_argument, NULL, 'L'},
 338   {"prefix-builtins", no_argument, NULL, 'P'},
 339   {"quiet", no_argument, NULL, 'Q'},
 340   {"reload-state", required_argument, NULL, 'R'},
 341   {"silent", no_argument, NULL, 'Q'},
 342   {"synclines", no_argument, NULL, 's'},
 343   {"trace", required_argument, NULL, 't'},
 344   {"traditional", no_argument, NULL, 'G'},
 345   {"undefine", required_argument, NULL, 'U'},
 346 #ifdef ENABLE_CHANGEWORD
 347   {"word-regexp", required_argument, NULL, 'W'},
 348 #endif
 349
 350   {"debugfile", optional_argument, NULL, DEBUGFILE_OPTION},
 351   {"diversions", required_argument, NULL, DIVERSIONS_OPTION},
 352   {"warn-macro-sequence", optional_argument, NULL, WARN_MACRO_SEQUENCE_OPTION},
 353
 354   {"help", no_argument, NULL, HELP_OPTION},
 355   {"version", no_argument, NULL, VERSION_OPTION},
 356
 357   { NULL, 0, NULL, 0 },
 358 };
 359
 360 /* Process a command line file NAME, and return true only if it was
 361    stdin.  */
 362 static void
 363 process_file (const char *name)
 364 {
 365   if (STREQ (name, "-"))
 366     {
 367       /* If stdin is a terminal, we want to allow 'm4 - file -'
 368          to read input from stdin twice, like GNU cat.  Besides,
 369          there is no point closing stdin before wrapped text, to
 370          minimize bugs in syscmd called from wrapped text.  */
 371       push_file (stdin, "stdin", false);
 372     }
 373   else
 374     {
 375       char *full_name;
 376       FILE *fp = m4_path_search (name, &full_name);
 377       if (fp == NULL)
 378         {
 379           error (0, errno, _("cannot open `%s'"), name);
 380           /* Set the status to EXIT_FAILURE, even though we
 381              continue to process files after a missing file.  */
 382           retcode = EXIT_FAILURE;
 383           return;
 384         }
 385       push_file (fp, full_name, true);
 386       free (full_name);
 387     }
 388   expand_input ();
 389 }
 390
 391 /* POSIX requires only -D, -U, and -s; and says that the first two
 392    must be recognized when interspersed with file names.  Traditional
 393    behavior also handles -s between files.  Starting OPTSTRING with
 394    '-' forces getopt_long to hand back file names as arguments to opt
 395    '\1', rather than reordering the command line.  */
 396 #ifdef ENABLE_CHANGEWORD
 397 #define OPTSTRING "-B:D:EF:GH:I:L:N:PQR:S:T:U:W:d::egil:o:st:"
 398 #else
 399 #define OPTSTRING "-B:D:EF:GH:I:L:N:PQR:S:T:U:d::egil:o:st:"
 400 #endif
 401
 402 int
 403 main (int argc, char *const *argv)
 404 {
 405   struct sigaction act;
 406   macro_definition *head;       /* head of deferred argument list */
 407   macro_definition *tail;
 408   macro_definition *defn;
 409   int optchar;                  /* option character */
 410
 411   macro_definition *defines;
 412   bool interactive = false;
 413   bool seen_file = false;
 414   const char *debugfile = NULL;
 415   const char *frozen_file_to_read = NULL;
 416   const char *frozen_file_to_write = NULL;
 417   const char *macro_sequence = "";
 418
 419   set_program_name (argv[0]);
 420   retcode = EXIT_SUCCESS;
 421   setlocale (LC_ALL, "");
 422   bindtextdomain (PACKAGE, LOCALEDIR);
 423   textdomain (PACKAGE);
 424   atexit (close_stdin);
 425
 426   include_init ();
 427   debug_init ();
 428
 429   /* Stack overflow and program error handling.  Ignore failure to
 430      install a handler, since this is merely for improved output on
 431      crash, and we should never crash ;).  We install SIGBUS and
 432      SIGSEGV handlers prior to using the c-stack module; depending on
 433      the platform, c-stack will then override none, SIGSEGV, or both
 434      handlers.  */
 435   program_error_message
 436     = xasprintf (_("internal error detected; please report this bug to <%s>"),
 437                  PACKAGE_BUGREPORT);
 438   signal_message[SIGSEGV] = xstrdup (strsignal (SIGSEGV));
 439   signal_message[SIGABRT] = xstrdup (strsignal (SIGABRT));
 440   signal_message[SIGILL] = xstrdup (strsignal (SIGILL));
 441   signal_message[SIGFPE] = xstrdup (strsignal (SIGFPE));
 442   if (SIGBUS != SIGILL && SIGBUS != SIGSEGV)
 443     signal_message[SIGBUS] = xstrdup (strsignal (SIGBUS));
 444   sigemptyset (&act.sa_mask);
 445   /* One-shot - if we fault while handling a fault, we want to revert
 446      to default signal behavior.  */
 447   act.sa_flags = SA_NODEFER | SA_RESETHAND;
 448   act.sa_handler = fault_handler;
 449   sigaction (SIGSEGV, &act, NULL);
 450   sigaction (SIGABRT, &act, NULL);
 451   sigaction (SIGILL, &act, NULL);
 452   sigaction (SIGFPE, &act, NULL);
 453   sigaction (SIGBUS, &act, NULL);
 454   if (c_stack_action (fault_handler) == 0)
 455     nesting_limit = 0;
 456
 457 #ifdef DEBUG_STKOVF
 458   /* Make it easier to test our fault handlers.  Exporting M4_CRASH=0
 459      attempts a SIGSEGV, exporting it as 1 attempts an assertion
 460      failure with a fallback to abort.  */
 461   {
 462     char *crash = getenv ("M4_CRASH");
 463     if (crash)
 464       {
 465         if (!strtol (crash, NULL, 10))
 466           ++*(int *) 8;
 467         assert (false);
 468         abort ();
 469       }
 470   }
 471 #endif /* DEBUG_STKOVF */
 472
 473   /* First, we decode the arguments, to size up tables and stuff.  */
 474   head = tail = NULL;
 475
 476   while ((optchar = getopt_long (argc, (char **) argv, OPTSTRING,
 477                                  long_options, NULL)) != -1)
 478     switch (optchar)
 479       {
 480       default:
 481         usage (EXIT_FAILURE);
 482
 483       case 'B':
 484       case 'S':
 485       case 'T':
 486         /* Compatibility junk: options that other implementations
 487            support, but which we ignore as no-ops and don't list in
 488            --help.  */
 489         error (0, 0, _("warning: `m4 -%c' may be removed in a future release"),
 490                optchar);
 491         break;
 492
 493       case 'N':
 494       case DIVERSIONS_OPTION:
 495         /* -N became an obsolete no-op in 1.4.x.  */
 496         error (0, 0, _("warning: `m4 %s' is deprecated"),
 497                optchar == 'N' ? "-N" : "--diversions");
 498         break;
 499
 500       case 'D':
 501       case 'U':
 502       case 's':
 503       case 't':
 504       case '\1':
 505       case DEBUGFILE_OPTION:
 506         /* Arguments that cannot be handled until later are accumulated.  */
 507
 508         defn = (macro_definition *) xmalloc (sizeof (macro_definition));
 509         defn->code = optchar;
 510         defn->arg = optarg;
 511         defn->next = NULL;
 512
 513         if (head == NULL)
 514           head = defn;
 515         else
 516           tail->next = defn;
 517         tail = defn;
 518
 519         break;
 520
 521       case 'E':
 522         if (! fatal_warnings)
 523           fatal_warnings = true;
 524         else
 525           warning_status = EXIT_FAILURE;
 526         break;
 527
 528       case 'F':
 529         frozen_file_to_write = optarg;
 530         break;
 531
 532       case 'G':
 533         no_gnu_extensions = 1;
 534         break;
 535
 536       case 'H':
 537         hash_table_size = strtol (optarg, NULL, 10);
 538         if (hash_table_size == 0)
 539           hash_table_size = HASHMAX;
 540         break;
 541
 542       case 'I':
 543         add_include_directory (optarg);
 544         break;
 545
 546       case 'L':
 547         nesting_limit = strtol (optarg, NULL, 10);
 548         break;
 549
 550       case 'P':
 551         prefix_all_builtins = 1;
 552         break;
 553
 554       case 'Q':
 555         suppress_warnings = 1;
 556         break;
 557
 558       case 'R':
 559         frozen_file_to_read = optarg;
 560         break;
 561
 562 #ifdef ENABLE_CHANGEWORD
 563       case 'W':
 564         user_word_regexp = optarg;
 565         break;
 566 #endif
 567
 568       case 'd':
 569         debug_level = debug_decode (optarg);
 570         if (debug_level < 0)
 571           {
 572             error (0, 0, _("bad debug flags: `%s'"), optarg);
 573             debug_level = 0;
 574           }
 575         break;
 576
 577       case 'e':
 578         error (0, 0, _("warning: `m4 -e' is deprecated, use `-i' instead"));
 579         FALLTHROUGH;
 580       case 'i':
 581         interactive = true;
 582         break;
 583
 584       case 'g':
 585         no_gnu_extensions = 0;
 586         break;
 587
 588       case 'l':
 589         max_debug_argument_length = strtol (optarg, NULL, 10);
 590         if (max_debug_argument_length <= 0)
 591           max_debug_argument_length = 0;
 592         break;
 593
 594       case 'o':
 595         /* -o/--error-output are deprecated synonyms of --debugfile,
 596            but don't issue a deprecation warning until autoconf 2.61
 597            or later is more widely established, as such a warning
 598            would interfere with all earlier versions of autoconf.  */
 599         /* Don't call debug_set_output here, as it has side effects.  */
 600         debugfile = optarg;
 601         break;
 602
 603       case WARN_MACRO_SEQUENCE_OPTION:
 604          /* Don't call set_macro_sequence here, as it can exit.
 605             --warn-macro-sequence sets optarg to NULL (which uses the
 606             default regexp); --warn-macro-sequence= sets optarg to ""
 607             (which disables these warnings).  */
 608         macro_sequence = optarg;
 609         break;
 610
 611       case VERSION_OPTION:
 612         version_etc (stdout, PACKAGE, PACKAGE_NAME, VERSION, AUTHORS, NULL);
 613         exit (EXIT_SUCCESS);
 614         break;
 615
 616       case HELP_OPTION:
 617         usage (EXIT_SUCCESS);
 618         break;
 619       }
 620
 621   defines = head;
 622
 623   /* Do the basic initializations.  */
 624   if (debugfile && !debug_set_output (debugfile))
 625     M4ERROR ((warning_status, errno, _("cannot set debug file `%s'"),
 626               debugfile));
 627
 628   input_init ();
 629   output_init ();
 630   symtab_init ();
 631   set_macro_sequence (macro_sequence);
 632   include_env_init ();
 633
 634   if (frozen_file_to_read)
 635     reload_frozen_state (frozen_file_to_read);
 636   else
 637     builtin_init ();
 638
 639   /* Interactive mode means unbuffered output, and interrupts ignored.  */
 640
 641   if (interactive)
 642     {
 643       signal (SIGINT, SIG_IGN);
 644       setbuf (stdout, (char *) NULL);
 645     }
 646
 647   /* Handle deferred command line macro definitions.  Must come after
 648      initialization of the symbol table.  */
 649
 650   while (defines != NULL)
 651     {
 652       macro_definition *next;
 653       symbol *sym;
 654
 655       switch (defines->code)
 656         {
 657         case 'D':
 658           {
 659             /* defines->arg is read-only, so we need a copy.  */
 660             char *macro_name = xstrdup (defines->arg);
 661             char *macro_value = strchr (macro_name, '=');
 662             if (macro_value)
 663               *macro_value++ = '\0';
 664             define_user_macro (macro_name, macro_value, SYMBOL_INSERT);
 665             free (macro_name);
 666           }
 667           break;
 668
 669         case 'U':
 670           lookup_symbol (defines->arg, SYMBOL_DELETE);
 671           break;
 672
 673         case 't':
 674           sym = lookup_symbol (defines->arg, SYMBOL_INSERT);
 675           SYMBOL_TRACED (sym) = true;
 676           break;
 677
 678         case 's':
 679           sync_output = 1;
 680           break;
 681
 682         case '\1':
 683           seen_file = true;
 684           process_file (defines->arg);
 685           break;
 686
 687         case DEBUGFILE_OPTION:
 688           if (!debug_set_output (defines->arg))
 689             M4ERROR ((warning_status, errno, _("cannot set debug file `%s'"),
 690                       debugfile ? debugfile : _("stderr")));
 691           break;
 692
 693         default:
 694           M4ERROR ((0, 0, "INTERNAL ERROR: bad code in deferred arguments"));
 695           abort ();
 696         }
 697
 698       next = defines->next;
 699       free (defines);
 700       defines = next;
 701     }
 702
 703   /* Handle remaining input files.  Each file is pushed on the input,
 704      and the input read.  Wrapup text is handled separately later.  */
 705
 706   if (optind == argc && !seen_file)
 707     process_file ("-");
 708   else
 709     for (; optind < argc; optind++)
 710       process_file (argv[optind]);
 711
 712   /* Now handle wrapup text.  */
 713
 714   while (pop_wrapup ())
 715     expand_input ();
 716
 717   /* Change debug stream back to stderr, to force flushing the debug
 718      stream and detect any errors it might have encountered.  The
 719      three standard streams are closed by close_stdin.  */
 720   debug_set_output (NULL);
 721
 722   if (frozen_file_to_write)
 723     produce_frozen_state (frozen_file_to_write);
 724   else
 725     {
 726       make_diversion (0);
 727       undivert_all ();
 728     }
 729   output_exit ();
 730   free_macro_sequence ();
 731   exit (retcode);
 732 }