src/macro.c

   1 /* GNU m4 -- A simple macro processor
   2
   3    Copyright (C) 1989-1994, 2006-2007, 2009-2011 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 /* This file contains the functions, that performs the basic argument
  23    parsing and macro expansion.  */
  24
  25 #include "m4.h"
  26
  27 static void expand_macro (symbol *);
  28 static void expand_token (struct obstack *, token_type, token_data *, int);
  29
  30 /* Current recursion level in expand_macro ().  */
  31 int expansion_level = 0;
  32
  33 /* The number of the current call of expand_macro ().  */
  34 static int macro_call_id = 0;
  35
  36 /* The shared stack of collected arguments for macro calls; as each
  37    argument is collected, it is finished and its location stored in
  38    argv_stack.  Normally, this stack can be used simultaneously by
  39    multiple macro calls; the exception is when an outer macro has
  40    generated some text, then calls a nested macro, in which case the
  41    nested macro must use a local stack to leave the unfinished text
  42    alone.  Too bad obstack.h does not provide an easy way to reopen a
  43    finished object for further growth, but in practice this does not
  44    hurt us too much.  */
  45 static struct obstack argc_stack;
  46
  47 /* The shared stack of pointers to collected arguments for macro
  48    calls.  This object is never finished; we exploit the fact that
  49    obstack_blank is documented to take a negative size to reduce the
  50    size again.  */
  51 static struct obstack argv_stack;
  52
  53 /*----------------------------------------------------------------------.
  54 | This function read all input, and expands each token, one at a time.  |
  55 `----------------------------------------------------------------------*/
  56
  57 void
  58 expand_input (void)
  59 {
  60   token_type t;
  61   token_data td;
  62   int line;
  63
  64   obstack_init (&argc_stack);
  65   obstack_init (&argv_stack);
  66
  67   while ((t = next_token (&td, &line)) != TOKEN_EOF)
  68     expand_token ((struct obstack *) NULL, t, &td, line);
  69
  70   obstack_free (&argc_stack, NULL);
  71   obstack_free (&argv_stack, NULL);
  72 }
  73 \f
  74
  75 /*----------------------------------------------------------------.
  76 | Expand one token, according to its type.  Potential macro names |
  77 | (TOKEN_WORD) are looked up in the symbol table, to see if they  |
  78 | have a macro definition.  If they have, they are expanded as    |
  79 | macros, otherwise the text is just copied to the output.        |
  80 `----------------------------------------------------------------*/
  81
  82 static void
  83 expand_token (struct obstack *obs, token_type t, token_data *td, int line)
  84 {
  85   symbol *sym;
  86
  87   switch (t)
  88     { /* TOKSW */
  89     case TOKEN_EOF:
  90     case TOKEN_MACDEF:
  91       break;
  92
  93     case TOKEN_OPEN:
  94     case TOKEN_COMMA:
  95     case TOKEN_CLOSE:
  96     case TOKEN_SIMPLE:
  97     case TOKEN_STRING:
  98       shipout_text (obs, TOKEN_DATA_TEXT (td), strlen (TOKEN_DATA_TEXT (td)),
  99                     line);
 100       break;
 101
 102     case TOKEN_WORD:
 103       sym = lookup_symbol (TOKEN_DATA_TEXT (td), SYMBOL_LOOKUP);
 104       if (sym == NULL || SYMBOL_TYPE (sym) == TOKEN_VOID
 105           || (SYMBOL_TYPE (sym) == TOKEN_FUNC
 106               && SYMBOL_BLIND_NO_ARGS (sym)
 107               && peek_token () != TOKEN_OPEN))
 108         {
 109 #ifdef ENABLE_CHANGEWORD
 110           shipout_text (obs, TOKEN_DATA_ORIG_TEXT (td),
 111                         strlen (TOKEN_DATA_ORIG_TEXT (td)), line);
 112 #else
 113           shipout_text (obs, TOKEN_DATA_TEXT (td),
 114                         strlen (TOKEN_DATA_TEXT (td)), line);
 115 #endif
 116         }
 117       else
 118         expand_macro (sym);
 119       break;
 120
 121     default:
 122       M4ERROR ((warning_status, 0,
 123                 "INTERNAL ERROR: bad token type in expand_token ()"));
 124       abort ();
 125     }
 126 }
 127 \f
 128
 129 /*-------------------------------------------------------------------.
 130 | This function parses one argument to a macro call.  It expects the |
 131 | first left parenthesis, or the separating comma, to have been read |
 132 | by the caller.  It skips leading whitespace, and reads and expands |
 133 | tokens, until it finds a comma or an right parenthesis at the same |
 134 | level of parentheses.  It returns a flag indicating whether the    |
 135 | argument read is the last for the active macro call.  The argument |
 136 | is built on the obstack OBS, indirectly through expand_token ().   |
 137 `-------------------------------------------------------------------*/
 138
 139 static bool
 140 expand_argument (struct obstack *obs, token_data *argp)
 141 {
 142   token_type t;
 143   token_data td;
 144   char *text;
 145   int paren_level;
 146   const char *file = current_file;
 147   int line = current_line;
 148
 149   TOKEN_DATA_TYPE (argp) = TOKEN_VOID;
 150
 151   /* Skip leading white space.  */
 152   do
 153     {
 154       t = next_token (&td, NULL);
 155     }
 156   while (t == TOKEN_SIMPLE && isspace (to_uchar (*TOKEN_DATA_TEXT (&td))));
 157
 158   paren_level = 0;
 159
 160   while (1)
 161     {
 162
 163       switch (t)
 164         { /* TOKSW */
 165         case TOKEN_COMMA:
 166         case TOKEN_CLOSE:
 167           if (paren_level == 0)
 168             {
 169               /* The argument MUST be finished, whether we want it or not.  */
 170               obstack_1grow (obs, '\0');
 171               text = (char *) obstack_finish (obs);
 172
 173               if (TOKEN_DATA_TYPE (argp) == TOKEN_VOID)
 174                 {
 175                   TOKEN_DATA_TYPE (argp) = TOKEN_TEXT;
 176                   TOKEN_DATA_TEXT (argp) = text;
 177                 }
 178               return t == TOKEN_COMMA;
 179             }
 180           /* fallthru */
 181         case TOKEN_OPEN:
 182         case TOKEN_SIMPLE:
 183           text = TOKEN_DATA_TEXT (&td);
 184
 185           if (*text == '(')
 186             paren_level++;
 187           else if (*text == ')')
 188             paren_level--;
 189           expand_token (obs, t, &td, line);
 190           break;
 191
 192         case TOKEN_EOF:
 193           /* current_file changed to "" if we see TOKEN_EOF, use the
 194              previous value we stored earlier.  */
 195           M4ERROR_AT_LINE ((EXIT_FAILURE, 0, file, line,
 196                             "ERROR: end of file in argument list"));
 197           break;
 198
 199         case TOKEN_WORD:
 200         case TOKEN_STRING:
 201           expand_token (obs, t, &td, line);
 202           break;
 203
 204         case TOKEN_MACDEF:
 205           if (obstack_object_size (obs) == 0)
 206             {
 207               TOKEN_DATA_TYPE (argp) = TOKEN_FUNC;
 208               TOKEN_DATA_FUNC (argp) = TOKEN_DATA_FUNC (&td);
 209             }
 210           break;
 211
 212         default:
 213           M4ERROR ((warning_status, 0,
 214                     "INTERNAL ERROR: bad token type in expand_argument ()"));
 215           abort ();
 216         }
 217
 218       t = next_token (&td, NULL);
 219     }
 220 }
 221
 222 /*-------------------------------------------------------------.
 223 | Collect all the arguments to a call of the macro SYM.  The   |
 224 | arguments are stored on the obstack ARGUMENTS and a table of |
 225 | pointers to the arguments on the obstack ARGPTR.             |
 226 `-------------------------------------------------------------*/
 227
 228 static void
 229 collect_arguments (symbol *sym, struct obstack *argptr,
 230                    struct obstack *arguments)
 231 {
 232   token_data td;
 233   token_data *tdp;
 234   bool more_args;
 235   bool groks_macro_args = SYMBOL_MACRO_ARGS (sym);
 236
 237   TOKEN_DATA_TYPE (&td) = TOKEN_TEXT;
 238   TOKEN_DATA_TEXT (&td) = SYMBOL_NAME (sym);
 239   tdp = (token_data *) obstack_copy (arguments, &td, sizeof td);
 240   obstack_ptr_grow (argptr, tdp);
 241
 242   if (peek_token () == TOKEN_OPEN)
 243     {
 244       next_token (&td, NULL); /* gobble parenthesis */
 245       do
 246         {
 247           more_args = expand_argument (arguments, &td);
 248
 249           if (!groks_macro_args && TOKEN_DATA_TYPE (&td) == TOKEN_FUNC)
 250             {
 251               TOKEN_DATA_TYPE (&td) = TOKEN_TEXT;
 252               TOKEN_DATA_TEXT (&td) = (char *) "";
 253             }
 254           tdp = (token_data *) obstack_copy (arguments, &td, sizeof td);
 255           obstack_ptr_grow (argptr, tdp);
 256         }
 257       while (more_args);
 258     }
 259 }
 260 \f
 261
 262 /*-------------------------------------------------------------------.
 263 | The actual call of a macro is handled by call_macro ().            |
 264 | call_macro () is passed a symbol SYM, whose type is used to call   |
 265 | either a builtin function, or the user macro expansion function    |
 266 | expand_user_macro () (lives in builtin.c).  There are ARGC         |
 267 | arguments to the call, stored in the ARGV table.  The expansion is |
 268 | left on the obstack EXPANSION.  Macro tracing is also handled      |
 269 | here.                                                              |
 270 `-------------------------------------------------------------------*/
 271
 272 void
 273 call_macro (symbol *sym, int argc, token_data **argv,
 274                  struct obstack *expansion)
 275 {
 276   switch (SYMBOL_TYPE (sym))
 277     {
 278     case TOKEN_FUNC:
 279       (*SYMBOL_FUNC (sym)) (expansion, argc, argv);
 280       break;
 281
 282     case TOKEN_TEXT:
 283       expand_user_macro (expansion, sym, argc, argv);
 284       break;
 285
 286     case TOKEN_VOID:
 287     default:
 288       M4ERROR ((warning_status, 0,
 289                 "INTERNAL ERROR: bad symbol type in call_macro ()"));
 290       abort ();
 291     }
 292 }
 293
 294 /*-------------------------------------------------------------------.
 295 | The macro expansion is handled by expand_macro ().  It parses the  |
 296 | arguments, using collect_arguments (), and builds a table of       |
 297 | pointers to the arguments.  The arguments themselves are stored on |
 298 | a local obstack.  Expand_macro () uses call_macro () to do the     |
 299 | call of the macro.                                                 |
 300 |                                                                    |
 301 | Expand_macro () is potentially recursive, since it calls           |
 302 | expand_argument (), which might call expand_token (), which might  |
 303 | call expand_macro ().                                              |
 304 `-------------------------------------------------------------------*/
 305
 306 static void
 307 expand_macro (symbol *sym)
 308 {
 309   struct obstack arguments;     /* Alternate obstack if argc_stack is busy.  */
 310   unsigned argv_base;           /* Size of argv_stack on entry.  */
 311   bool use_argc_stack = true;   /* Whether argc_stack is safe.  */
 312   token_data **argv;
 313   int argc;
 314   struct obstack *expansion;
 315   const char *expanded;
 316   bool traced;
 317   int my_call_id;
 318
 319   /* Report errors at the location where the open parenthesis (if any)
 320      was found, but after expansion, restore global state back to the
 321      location of the close parenthesis.  This is safe since we
 322      guarantee that macro expansion does not alter the state of
 323      current_file/current_line (dnl, include, and sinclude are special
 324      cased in the input engine to ensure this fact).  */
 325   const char *loc_open_file = current_file;
 326   int loc_open_line = current_line;
 327   const char *loc_close_file;
 328   int loc_close_line;
 329
 330   SYMBOL_PENDING_EXPANSIONS (sym)++;
 331   expansion_level++;
 332   if (nesting_limit > 0 && expansion_level > nesting_limit)
 333     M4ERROR ((EXIT_FAILURE, 0,
 334               "recursion limit of %d exceeded, use -L<N> to change it",
 335               nesting_limit));
 336
 337   macro_call_id++;
 338   my_call_id = macro_call_id;
 339
 340   traced = (debug_level & DEBUG_TRACE_ALL) || SYMBOL_TRACED (sym);
 341
 342   argv_base = obstack_object_size (&argv_stack);
 343   if (obstack_object_size (&argc_stack) > 0)
 344     {
 345       /* We cannot use argc_stack if this is a nested invocation, and an
 346          outer invocation has an unfinished argument being
 347          collected.  */
 348       obstack_init (&arguments);
 349       use_argc_stack = false;
 350     }
 351
 352   if (traced && (debug_level & DEBUG_TRACE_CALL))
 353     trace_prepre (SYMBOL_NAME (sym), my_call_id);
 354
 355   collect_arguments (sym, &argv_stack,
 356                      use_argc_stack ? &argc_stack : &arguments);
 357
 358   argc = ((obstack_object_size (&argv_stack) - argv_base)
 359           / sizeof (token_data *));
 360   argv = (token_data **) ((char *) obstack_base (&argv_stack) + argv_base);
 361
 362   loc_close_file = current_file;
 363   loc_close_line = current_line;
 364   current_file = loc_open_file;
 365   current_line = loc_open_line;
 366
 367   if (traced)
 368     trace_pre (SYMBOL_NAME (sym), my_call_id, argc, argv);
 369
 370   expansion = push_string_init ();
 371   call_macro (sym, argc, argv, expansion);
 372   expanded = push_string_finish ();
 373
 374   if (traced)
 375     trace_post (SYMBOL_NAME (sym), my_call_id, argc, expanded);
 376
 377   current_file = loc_close_file;
 378   current_line = loc_close_line;
 379
 380   --expansion_level;
 381   --SYMBOL_PENDING_EXPANSIONS (sym);
 382
 383   if (SYMBOL_DELETED (sym))
 384     free_symbol (sym);
 385
 386   if (use_argc_stack)
 387     obstack_free (&argc_stack, argv[0]);
 388   else
 389     obstack_free (&arguments, NULL);
 390   obstack_blank (&argv_stack, -argc * sizeof (token_data *));
 391 }