src/debug.c

   1 /* GNU m4 -- A simple macro processor
   2
   3    Copyright (C) 1991, 1992, 1993, 1994, 2004, 2006, 2007 Free Software
   4    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 <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "m4.h"
  23
  24 #include <stdarg.h>
  25 #include <sys/stat.h>
  26
  27 /* File for debugging output.  */
  28 FILE *debug = NULL;
  29
  30 /* Obstack for trace messages.  */
  31 static struct obstack trace;
  32
  33 extern int expansion_level;
  34
  35 static void debug_set_file (FILE *);
  36
  37 /*----------------------------------.
  38 | Initialise the debugging module.  |
  39 `----------------------------------*/
  40
  41 void
  42 debug_init (void)
  43 {
  44   debug_set_file (stderr);
  45   obstack_init (&trace);
  46 }
  47 \f
  48 /*-----------------------------------------------------------------.
  49 | Function to decode the debugging flags OPTS.  Used by main while |
  50 | processing option -d, and by the builtin debugmode ().           |
  51 `-----------------------------------------------------------------*/
  52
  53 int
  54 debug_decode (const char *opts)
  55 {
  56   int level;
  57
  58   if (opts == NULL || *opts == '\0')
  59     level = DEBUG_TRACE_DEFAULT;
  60   else
  61     {
  62       for (level = 0; *opts; opts++)
  63         {
  64           switch (*opts)
  65             {
  66             case 'a':
  67               level |= DEBUG_TRACE_ARGS;
  68               break;
  69
  70             case 'e':
  71               level |= DEBUG_TRACE_EXPANSION;
  72               break;
  73
  74             case 'q':
  75               level |= DEBUG_TRACE_QUOTE;
  76               break;
  77
  78             case 't':
  79               level |= DEBUG_TRACE_ALL;
  80               break;
  81
  82             case 'l':
  83               level |= DEBUG_TRACE_LINE;
  84               break;
  85
  86             case 'f':
  87               level |= DEBUG_TRACE_FILE;
  88               break;
  89
  90             case 'p':
  91               level |= DEBUG_TRACE_PATH;
  92               break;
  93
  94             case 'c':
  95               level |= DEBUG_TRACE_CALL;
  96               break;
  97
  98             case 'i':
  99               level |= DEBUG_TRACE_INPUT;
 100               break;
 101
 102             case 'x':
 103               level |= DEBUG_TRACE_CALLID;
 104               break;
 105
 106             case 'V':
 107               level |= DEBUG_TRACE_VERBOSE;
 108               break;
 109
 110             default:
 111               return -1;
 112             }
 113         }
 114     }
 115
 116   /* This is to avoid screwing up the trace output due to changes in the
 117      debug_level.  */
 118
 119   obstack_free (&trace, obstack_finish (&trace));
 120
 121   return level;
 122 }
 123
 124 /*------------------------------------------------------------------------.
 125 | Change the debug output stream to FP.  If the underlying file is the    |
 126 | same as stdout, use stdout instead so that debug messages appear in the |
 127 | correct relative position.                                              |
 128 `------------------------------------------------------------------------*/
 129
 130 static void
 131 debug_set_file (FILE *fp)
 132 {
 133   struct stat stdout_stat, debug_stat;
 134
 135   if (debug != NULL && debug != stderr && debug != stdout
 136       && close_stream (debug) != 0)
 137     {
 138       M4ERROR ((warning_status, errno, "error writing to debug stream"));
 139       retcode = EXIT_FAILURE;
 140     }
 141   debug = fp;
 142
 143   if (debug != NULL && debug != stdout)
 144     {
 145       if (fstat (STDOUT_FILENO, &stdout_stat) < 0)
 146         return;
 147       if (fstat (fileno (debug), &debug_stat) < 0)
 148         return;
 149
 150       /* mingw has a bug where fstat on a regular file reports st_ino
 151          of 0.  On normal system, st_ino should never be 0.  */
 152       if (stdout_stat.st_ino == debug_stat.st_ino
 153           && stdout_stat.st_dev == debug_stat.st_dev
 154           && stdout_stat.st_ino != 0)
 155         {
 156           if (debug != stderr && close_stream (debug) != 0)
 157             {
 158               M4ERROR ((warning_status, errno,
 159                         "error writing to debug stream"));
 160               retcode = EXIT_FAILURE;
 161             }
 162           debug = stdout;
 163         }
 164     }
 165 }
 166
 167 /*-----------------------------------------------------------.
 168 | Serialize files.  Used before executing a system command.  |
 169 `-----------------------------------------------------------*/
 170
 171 void
 172 debug_flush_files (void)
 173 {
 174   fflush (stdout);
 175   fflush (stderr);
 176   if (debug != NULL && debug != stdout && debug != stderr)
 177     fflush (debug);
 178   /* POSIX requires that if m4 doesn't consume all input, but stdin is
 179      opened on a seekable file, that the file pointer be left at the
 180      next character on exit (but places no restrictions on the file
 181      pointer location on a non-seekable file).  It also requires that
 182      fflush() followed by fseeko() on an input file set the underlying
 183      file pointer, and gnulib guarantees these semantics.  However,
 184      fflush() on a non-seekable file can lose buffered data, which we
 185      might otherwise want to process after syscmd.  Hence, we must
 186      check whether stdin is seekable.  We must also be tolerant of
 187      operating with stdin closed, so we don't report any failures in
 188      this attempt.  The stdio-safer module and friends are essential,
 189      so that if stdin was closed, this lseek is not on some other file
 190      that we have since opened.  */
 191   if (lseek (STDIN_FILENO, 0, SEEK_CUR) >= 0
 192       && fflush (stdin) == 0)
 193     {
 194       fseeko (stdin, 0, SEEK_CUR);
 195     }
 196 }
 197
 198 /*-------------------------------------------------------------------------.
 199 | Change the debug output to file NAME.  If NAME is NULL, debug output is  |
 200 | reverted to stderr, and if empty debug output is discarded.  Return true |
 201 | iff the output stream was changed.                                       |
 202 `-------------------------------------------------------------------------*/
 203
 204 bool
 205 debug_set_output (const char *name)
 206 {
 207   FILE *fp;
 208
 209   if (name == NULL)
 210     debug_set_file (stderr);
 211   else if (*name == '\0')
 212     debug_set_file (NULL);
 213   else
 214     {
 215       fp = fopen (name, "a");
 216       if (fp == NULL)
 217         return false;
 218
 219       if (set_cloexec_flag (fileno (fp), true) != 0)
 220         M4ERROR ((warning_status, errno,
 221                   "Warning: cannot protect debug file across forks"));
 222       debug_set_file (fp);
 223     }
 224   return true;
 225 }
 226
 227 /*-----------------------------------------------------------------------.
 228 | Print the header of a one-line debug message, starting by "m4 debug".  |
 229 `-----------------------------------------------------------------------*/
 230
 231 void
 232 debug_message_prefix (void)
 233 {
 234   fprintf (debug, "m4debug:");
 235   if (current_line)
 236   {
 237     if (debug_level & DEBUG_TRACE_FILE)
 238       fprintf (debug, "%s:", current_file);
 239     if (debug_level & DEBUG_TRACE_LINE)
 240       fprintf (debug, "%d:", current_line);
 241   }
 242   putc (' ', debug);
 243 }
 244 \f
 245 /* The rest of this file contains the functions for macro tracing output.
 246    All tracing output for a macro call is collected on an obstack TRACE,
 247    and printed whenever the line is complete.  This prevents tracing
 248    output from interfering with other debug messages generated by the
 249    various builtins.  */
 250
 251 /*---------------------------------------------------------------------.
 252 | Tracing output is formatted here, by a simplified printf-to-obstack  |
 253 | function trace_format ().  Understands only %S, %s, %d, %l (optional |
 254 | left quote) and %r (optional right quote).                           |
 255 `---------------------------------------------------------------------*/
 256
 257 static void
 258 trace_format (const char *fmt, ...)
 259 {
 260   va_list args;
 261   char ch;
 262
 263   int d;
 264   char nbuf[32];
 265   const char *s;
 266   int slen;
 267   int maxlen;
 268
 269   va_start (args, fmt);
 270
 271   while (true)
 272     {
 273       while ((ch = *fmt++) != '\0' && ch != '%')
 274         obstack_1grow (&trace, ch);
 275
 276       if (ch == '\0')
 277         break;
 278
 279       maxlen = 0;
 280       switch (*fmt++)
 281         {
 282         case 'S':
 283           maxlen = max_debug_argument_length;
 284           /* fall through */
 285
 286         case 's':
 287           s = va_arg (args, const char *);
 288           break;
 289
 290         case 'l':
 291           s = (debug_level & DEBUG_TRACE_QUOTE) ? lquote.string : "";
 292           break;
 293
 294         case 'r':
 295           s = (debug_level & DEBUG_TRACE_QUOTE) ? rquote.string : "";
 296           break;
 297
 298         case 'd':
 299           d = va_arg (args, int);
 300           sprintf (nbuf, "%d", d);
 301           s = nbuf;
 302           break;
 303
 304         default:
 305           s = "";
 306           break;
 307         }
 308
 309       slen = strlen (s);
 310       if (maxlen == 0 || maxlen > slen)
 311         obstack_grow (&trace, s, slen);
 312       else
 313         {
 314           obstack_grow (&trace, s, maxlen);
 315           obstack_grow (&trace, "...", 3);
 316         }
 317     }
 318
 319   va_end (args);
 320 }
 321
 322 /*------------------------------------------------------------------.
 323 | Format the standard header attached to all tracing output lines.  |
 324 `------------------------------------------------------------------*/
 325
 326 static void
 327 trace_header (int id)
 328 {
 329   trace_format ("m4trace:");
 330   if (current_line)
 331     {
 332       if (debug_level & DEBUG_TRACE_FILE)
 333         trace_format ("%s:", current_file);
 334       if (debug_level & DEBUG_TRACE_LINE)
 335         trace_format ("%d:", current_line);
 336     }
 337   trace_format (" -%d- ", expansion_level);
 338   if (debug_level & DEBUG_TRACE_CALLID)
 339     trace_format ("id %d: ", id);
 340 }
 341
 342 /*----------------------------------------------------.
 343 | Print current tracing line, and clear the obstack.  |
 344 `----------------------------------------------------*/
 345
 346 static void
 347 trace_flush (void)
 348 {
 349   char *line;
 350
 351   obstack_1grow (&trace, '\0');
 352   line = (char *) obstack_finish (&trace);
 353   DEBUG_PRINT1 ("%s\n", line);
 354   obstack_free (&trace, line);
 355 }
 356
 357 /*-------------------------------------------------------------.
 358 | Do pre-argument-collction tracing for macro NAME.  Used from |
 359 | expand_macro ().                                             |
 360 `-------------------------------------------------------------*/
 361
 362 void
 363 trace_prepre (const char *name, int id)
 364 {
 365   trace_header (id);
 366   trace_format ("%s ...", name);
 367   trace_flush ();
 368 }
 369
 370 /*-----------------------------------------------------------------------.
 371 | Format the parts of a trace line, that can be made before the macro is |
 372 | actually expanded.  Used from expand_macro ().                         |
 373 `-----------------------------------------------------------------------*/
 374
 375 void
 376 trace_pre (const char *name, int id, int argc, token_data **argv)
 377 {
 378   int i;
 379   const builtin *bp;
 380
 381   trace_header (id);
 382   trace_format ("%s", name);
 383
 384   if (argc > 1 && (debug_level & DEBUG_TRACE_ARGS))
 385     {
 386       trace_format ("(");
 387
 388       for (i = 1; i < argc; i++)
 389         {
 390           if (i != 1)
 391             trace_format (", ");
 392
 393           switch (TOKEN_DATA_TYPE (argv[i]))
 394             {
 395             case TOKEN_TEXT:
 396               trace_format ("%l%S%r", TOKEN_DATA_TEXT (argv[i]));
 397               break;
 398
 399             case TOKEN_FUNC:
 400               bp = find_builtin_by_addr (TOKEN_DATA_FUNC (argv[i]));
 401               if (bp == NULL)
 402                 {
 403                   M4ERROR ((warning_status, 0, "\
 404 INTERNAL ERROR: builtin not found in builtin table! (trace_pre ())"));
 405                   abort ();
 406                 }
 407               trace_format ("<%s>", bp->name);
 408               break;
 409
 410             default:
 411               M4ERROR ((warning_status, 0,
 412                         "INTERNAL ERROR: bad token data type (trace_pre ())"));
 413               abort ();
 414             }
 415
 416         }
 417       trace_format (")");
 418     }
 419
 420   if (debug_level & DEBUG_TRACE_CALL)
 421     {
 422       trace_format (" -> ???");
 423       trace_flush ();
 424     }
 425 }
 426
 427 /*-------------------------------------------------------------------.
 428 | Format the final part of a trace line and print it all.  Used from |
 429 | expand_macro ().                                                   |
 430 `-------------------------------------------------------------------*/
 431
 432 void
 433 trace_post (const char *name, int id, int argc, token_data **argv,
 434             const char *expanded)
 435 {
 436   if (debug_level & DEBUG_TRACE_CALL)
 437     {
 438       trace_header (id);
 439       trace_format ("%s%s", name, (argc > 1) ? "(...)" : "");
 440     }
 441
 442   if (expanded && (debug_level & DEBUG_TRACE_EXPANSION))
 443     trace_format (" -> %l%S%r", expanded);
 444   trace_flush ();
 445 }