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   xfprintf (debug, "m4debug:");
 235   if (current_line)
 236   {
 237     if (debug_level & DEBUG_TRACE_FILE)
 238       xfprintf (debug, "%s:", current_file);
 239     if (debug_level & DEBUG_TRACE_LINE)
 240       xfprintf (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   const char *s;
 265   int slen;
 266   int maxlen;
 267
 268   va_start (args, fmt);
 269
 270   while (true)
 271     {
 272       while ((ch = *fmt++) != '\0' && ch != '%')
 273         obstack_1grow (&trace, ch);
 274
 275       if (ch == '\0')
 276         break;
 277
 278       maxlen = 0;
 279       switch (*fmt++)
 280         {
 281         case 'S':
 282           maxlen = max_debug_argument_length;
 283           /* fall through */
 284
 285         case 's':
 286           s = va_arg (args, const char *);
 287           break;
 288
 289         case 'l':
 290           s = (debug_level & DEBUG_TRACE_QUOTE) ? lquote.string : "";
 291           break;
 292
 293         case 'r':
 294           s = (debug_level & DEBUG_TRACE_QUOTE) ? rquote.string : "";
 295           break;
 296
 297         case 'd':
 298           d = va_arg (args, int);
 299           s = ntoa (d, 10);
 300           break;
 301
 302         default:
 303           s = "";
 304           break;
 305         }
 306
 307       slen = strlen (s);
 308       if (maxlen == 0 || maxlen > slen)
 309         obstack_grow (&trace, s, slen);
 310       else
 311         {
 312           obstack_grow (&trace, s, maxlen);
 313           obstack_grow (&trace, "...", 3);
 314         }
 315     }
 316
 317   va_end (args);
 318 }
 319
 320 /*------------------------------------------------------------------.
 321 | Format the standard header attached to all tracing output lines.  |
 322 `------------------------------------------------------------------*/
 323
 324 static void
 325 trace_header (int id)
 326 {
 327   trace_format ("m4trace:");
 328   if (current_line)
 329     {
 330       if (debug_level & DEBUG_TRACE_FILE)
 331         trace_format ("%s:", current_file);
 332       if (debug_level & DEBUG_TRACE_LINE)
 333         trace_format ("%d:", current_line);
 334     }
 335   trace_format (" -%d- ", expansion_level);
 336   if (debug_level & DEBUG_TRACE_CALLID)
 337     trace_format ("id %d: ", id);
 338 }
 339
 340 /*----------------------------------------------------.
 341 | Print current tracing line, and clear the obstack.  |
 342 `----------------------------------------------------*/
 343
 344 static void
 345 trace_flush (void)
 346 {
 347   char *line;
 348
 349   obstack_1grow (&trace, '\0');
 350   line = (char *) obstack_finish (&trace);
 351   DEBUG_PRINT1 ("%s\n", line);
 352   obstack_free (&trace, line);
 353 }
 354
 355 /*-------------------------------------------------------------.
 356 | Do pre-argument-collction tracing for macro NAME.  Used from |
 357 | expand_macro ().                                             |
 358 `-------------------------------------------------------------*/
 359
 360 void
 361 trace_prepre (const char *name, int id)
 362 {
 363   trace_header (id);
 364   trace_format ("%s ...", name);
 365   trace_flush ();
 366 }
 367
 368 /*-----------------------------------------------------------------------.
 369 | Format the parts of a trace line, that can be made before the macro is |
 370 | actually expanded.  Used from expand_macro ().                         |
 371 `-----------------------------------------------------------------------*/
 372
 373 void
 374 trace_pre (const char *name, int id, int argc, token_data **argv)
 375 {
 376   int i;
 377   const builtin *bp;
 378
 379   trace_header (id);
 380   trace_format ("%s", name);
 381
 382   if (argc > 1 && (debug_level & DEBUG_TRACE_ARGS))
 383     {
 384       trace_format ("(");
 385
 386       for (i = 1; i < argc; i++)
 387         {
 388           if (i != 1)
 389             trace_format (", ");
 390
 391           switch (TOKEN_DATA_TYPE (argv[i]))
 392             {
 393             case TOKEN_TEXT:
 394               trace_format ("%l%S%r", TOKEN_DATA_TEXT (argv[i]));
 395               break;
 396
 397             case TOKEN_FUNC:
 398               bp = find_builtin_by_addr (TOKEN_DATA_FUNC (argv[i]));
 399               if (bp == NULL)
 400                 {
 401                   M4ERROR ((warning_status, 0, "\
 402 INTERNAL ERROR: builtin not found in builtin table! (trace_pre ())"));
 403                   abort ();
 404                 }
 405               trace_format ("<%s>", bp->name);
 406               break;
 407
 408             default:
 409               M4ERROR ((warning_status, 0,
 410                         "INTERNAL ERROR: bad token data type (trace_pre ())"));
 411               abort ();
 412             }
 413
 414         }
 415       trace_format (")");
 416     }
 417
 418   if (debug_level & DEBUG_TRACE_CALL)
 419     {
 420       trace_format (" -> ???");
 421       trace_flush ();
 422     }
 423 }
 424
 425 /*-------------------------------------------------------------------.
 426 | Format the final part of a trace line and print it all.  Used from |
 427 | expand_macro ().                                                   |
 428 `-------------------------------------------------------------------*/
 429
 430 void
 431 trace_post (const char *name, int id, int argc, token_data **argv,
 432             const char *expanded)
 433 {
 434   if (debug_level & DEBUG_TRACE_CALL)
 435     {
 436       trace_header (id);
 437       trace_format ("%s%s", name, (argc > 1) ? "(...)" : "");
 438     }
 439
 440   if (expanded && (debug_level & DEBUG_TRACE_EXPANSION))
 441     trace_format (" -> %l%S%r", expanded);
 442   trace_flush ();
 443 }