path: root/m4/macro.c

/* GNU m4 -- A simple macro processor
   Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994, 2001, 2006, 2007,
   2008 Free Software Foundation, Inc.

   This file is part of GNU M4.

   GNU M4 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 M4 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/>.
*/

/* This file contains the functions that perform the basic argument
   parsing and macro expansion.  */

#include <config.h>

#include "m4private.h"

#include "intprops.h"

/* Define this to 1 see runtime debug info.  Implied by DEBUG.  */
/*#define DEBUG_INPUT 1 */
#ifndef DEBUG_MACRO
# define DEBUG_MACRO 0
#endif /* DEBUG_MACRO */

/* A note on argument memory lifetimes: We use an internal struct
   (m4__macro_args_stacks) to maintain list of argument obstacks.
   Within a recursion level, consecutive macros can share a stack, but
   distinct recursion levels need different stacks since the nested
   macro is interrupting the argument collection of the outer level.
   Note that a reference can live as long as the expansion containing
   the reference can participate as an argument in a future macro
   call.

   Therefore, we implement a reference counter for each expansion
   level, tracking how many references exist into the obstack, as well
   as associate a level with each reference.  Of course, expand_macro
   is actively using argv, so it increments the refcount on entry and
   decrements it on exit.  Additionally, any time the input engine is
   handed a reference that it does not inline, it increases the
   refcount in push_token, then decreases it in pop_input once the
   reference has been rescanned.  Finally, when the input engine hands
   a reference back to expand_argument, the refcount increases, which
   is then cleaned up at the end of expand_macro.

   For a running example, consider this input:

     define(a,A)define(b,`a(`$1')')define(c,$*)dnl
     define(x,`a(1)`'c($@')define(y,`$@)')dnl
     x(a(`b')``a'')y(`b')(`a')
     => AAaA

   Assuming all arguments are large enough to exceed the inlining
   thresholds of the input engine, the interesting sequence of events
   is as follows:

				     stacks[0]             refs stacks[1] refs
     after second dnl ends:          `'                    0    `'        0
     expand_macro for x, level 0:    `'                    1    `'        0
     expand_macro for a, level 1:    `'                    1    `'        1
     after collect_arguments for a:  `'                    1    `b'       1
     push `A' to input stack:        `'                    1    `b'       1
     exit expand_macro for a:        `'                    1    `'        0
     after collect_arguments for x:  `A`a''                1    `'        0
     push `a(1)`'c(' to input stack: `A`a''                1    `'        0
     push_token saves $@(x) ref:     `A`a''                2    `'        0
     exit expand_macro for x:        `A`a''                1    `'        0
     expand_macro for a, level 0:    `A`a''                2    `'        0
     after collect_arguments for a:  `A`a''`1'             2    `'        0
     push `A' to input stack:        `A`a''`1'             2    `'        0
     exit expand_macro for a:        `A`a''                1    `'        0
     output `A':                     `A`a''                1    `'        0
     expand_macro for c, level 0:    `A`a''                2    `'        0
     expand_argument gets $@(x) ref: `A`a''`$@(x)'         3    `'        0
     pop_input ends $@(x) ref:       `A`a''`$@(x)'         2    `'        0
     expand_macro for y, level 1:    `A`a''`$@(x)'         2    `'        1
     after collect_arguments for y:  `A`a''`$@(x)'         2    `b'       1
     push_token saves $@(y) ref:     `A`a''`$@(x)'         2    `b'       2
     push `)' to input stack:        `A`a''`$@(x)'         2    `b'       2
     exit expand_macro for y:        `A`a''`$@(x)'         2    `b'       1
     expand_argument gets $@(y) ref: `A`a''`$@(x)$@(y)'    2    `b'       2
     pop_input ends $@(y) ref:       `A`a''`$@(x)$@(y)'    2    `b'       1
     after collect_arguments for c:  `A`a''`$@(x)$@(y)'    2    `b'       1
     push_token saves $*(c) ref:     `A`a''`$@(x)$@(y)'    3    `b'       2
     expand_macro frees $@(x) ref:   `A`a''`$@(x)$@(y)'    2    `b'       2
     expand_macro frees $@(y) ref:   `A`a''`$@(x)$@(y)'    2    `b'       1
     exit expand_macro for c:        `A`a''`$@(x)$@(y)'    1    `b'       1
     output `Aa':                    `A`a''`$@(x)$@(y)'    0    `b'       1
     pop_input ends $*(c)$@(x) ref:  `'                    0    `b'       1
     expand_macro for b, level 0:    `'                    1    `b'       1
     pop_input ends $*(c)$@(y) ref:  `'                    1    `'        0
     after collect_arguments for b:  `a'                   1    `'        0
     push `a(`' to input stack:      `a'                   1    `'        0
     push_token saves $1(b) ref:     `a'                   2    `'        0
     push `')' to input stack:       `a'                   2    `'        0
     exit expand_macro for b:        `a'                   1    `'        0
     expand_macro for a, level 0 :   `a'                   2    `'        0
     expand_argument gets $1(b) ref: `a'`$1(b)'            3    `'        0
     pop_input ends $1(b) ref:       `a'`$1(b)'            2    `'        0
     after collect_arguments for a:  `a'`$1(b)'            2    `'        0
     push `A' to input stack:        `a'`$1(b)'            2    `'        0
     expand_macro frees $1(b) ref:   `a'`$1(b)'            1    `'        0
     exit expand_macro for a:        `'                    0    `'        0
     output `A':                     `'                    0    `'        0

   An obstack is only completely cleared when its refcount reaches
   zero.  However, as an optimization, expand_macro also frees
   anything that it added to the obstack if no additional references
   were added at the current expansion level, to reduce the amount of
   memory left on the obstack while waiting for refcounts to drop.
*/

static m4_macro_args *collect_arguments (m4 *, m4_call_info *, m4_symbol *,
					 m4_obstack *, m4_obstack *);
static void    expand_macro      (m4 *, const char *, size_t, m4_symbol *);
static bool    expand_token      (m4 *, m4_obstack *, m4__token_type,
				  m4_symbol_value *, int, bool);
static bool    expand_argument   (m4 *, m4_obstack *, m4_symbol_value *,
				  const m4_call_info *);
static void    process_macro	 (m4 *, m4_symbol_value *, m4_obstack *, int,
				  m4_macro_args *);

static unsigned int trace_pre	 (m4 *, m4_macro_args *);
static void    trace_post	 (m4 *, unsigned int, const m4_call_info *);
static unsigned int trace_header (m4 *, const m4_call_info *);
static void    trace_flush	 (m4 *, unsigned int);


/* The number of the current call of expand_macro ().  */
static size_t macro_call_id = 0;

/* A placeholder symbol value representing the empty string, used to
   optimize checks for emptiness.  */
static m4_symbol_value empty_symbol;

#if DEBUG_MACRO
/* True if significant changes to stacks should be printed to the
   trace stream.  Primarily useful for debugging $@ ref memory leaks,
   and controlled by M4_DEBUG_MACRO environment variable.  */
static int debug_macro_level;
#else
# define debug_macro_level 0
#endif /* !DEBUG_MACRO */
#define PRINT_ARGCOUNT_CHANGES	1	/* Any change to argcount > 1.  */
#define PRINT_REFCOUNT_INCREASE	2	/* Any increase to refcount.  */
#define PRINT_REFCOUNT_DECREASE	4	/* Any decrease to refcount.  */



/* This function reads all input, and expands each token, one at a time.  */
void
m4_macro_expand_input (m4 *context)
{
  m4__token_type type;
  m4_symbol_value token;
  int line;

#if DEBUG_MACRO
  const char *s = getenv ("M4_DEBUG_MACRO");
  if (s)
    debug_macro_level = strtol (s, NULL, 0);
#endif /* DEBUG_MACRO */

  m4_set_symbol_value_text (&empty_symbol, "", 0, 0);
  VALUE_MAX_ARGS (&empty_symbol) = -1;

  while ((type = m4__next_token (context, &token, &line, NULL, false, NULL))
	 != M4_TOKEN_EOF)
    expand_token (context, NULL, type, &token, line, true);
}


/* Expand one token onto OBS, according to its type.  If OBS is NULL,
   output the expansion to the current diversion.  TYPE determines the
   contents of TOKEN.  Potential macro names (a TYPE of M4_TOKEN_WORD)
   are looked up in the symbol table, to see if they have a macro
   definition.  If they have, they are expanded as macros, otherwise
   the text are just copied to the output.  LINE determines where
   TOKEN began.  FIRST is true if there is no prior content in the
   current macro argument.  Return true if the result is guranteed to
   give the same parse on rescan in a quoted context with the same
   quote age.  Returning false is always safe, although it may lead to
   slower performance.  */
static bool
expand_token (m4 *context, m4_obstack *obs, m4__token_type type,
	      m4_symbol_value *token, int line, bool first)
{
  m4_symbol *symbol;
  bool result;
  const char *text = (m4_is_symbol_value_text (token)
		      ? m4_get_symbol_value_text (token) : NULL);

  switch (type)
    {				/* TOKSW */
    case M4_TOKEN_EOF:
    case M4_TOKEN_MACDEF:
      /* Always safe, since there is no text to rescan.  */
      return true;

    case M4_TOKEN_STRING:
      /* Tokens and comments are safe in isolation (since quote_age
	 detects any change in delimiters).  This is also returned for
	 sequences of benign characters, such as digits.  But if other
	 text is already present, multi-character delimiters could be
	 formed by concatenation, so use a conservative heuristic.  If
	 obstack was provided, the string was already expanded into it
	 during m4__next_token.  */
      result = first || m4__safe_quotes (M4SYNTAX);
      if (obs)
	return result;
      break;

    case M4_TOKEN_OPEN:
    case M4_TOKEN_COMMA:
    case M4_TOKEN_CLOSE:
    case M4_TOKEN_SPACE:
      /* Conservative heuristic, thanks to multi-character delimiter
	 concatenation.  */
      result = m4__safe_quotes (M4SYNTAX);
      break;

    case M4_TOKEN_SIMPLE:
      /* No guarantees here.  */
      assert (m4_get_symbol_value_len (token) == 1);
      result = false;
      break;

    case M4_TOKEN_WORD:
      {
	const char *textp = text;
	size_t len = m4_get_symbol_value_len (token);
	size_t len2 = len;

	if (m4_has_syntax (M4SYNTAX, *textp, M4_SYNTAX_ESCAPE))
	  {
	    textp++;
	    len2--;
	  }

	symbol = m4_symbol_lookup (M4SYMTAB, textp, len2);
	assert (!symbol || !m4_is_symbol_void (symbol));
	if (symbol == NULL
	    || (symbol->value->type == M4_SYMBOL_FUNC
		&& BIT_TEST (SYMBOL_FLAGS (symbol), VALUE_BLIND_ARGS_BIT)
		&& !m4__next_token_is_open (context)))
	  {
	    m4_divert_text (context, obs, text, len, line);
	    /* The word just output is unquoted, but we can trust the
	       heuristics of safe_quote.  */
	    return m4__safe_quotes (M4SYNTAX);
	  }
	expand_macro (context, textp, len2, symbol);
	/* Expanding a macro may create new tokens to scan, and those
	   tokens may generate unsafe text, but we did not append any
	   text now.  */
	return true;
      }

    default:
      assert (!"INTERNAL ERROR: bad token type in expand_token ()");
      abort ();
    }
  m4_divert_text (context, obs, text, m4_get_symbol_value_len (token), line);
  return result;
}


/* This function parses one argument to a macro call.  It expects the
   first left parenthesis or the separating comma to have been read by
   the caller.  It skips leading whitespace, then reads and expands
   tokens, until it finds a comma or a right parenthesis at the same
   level of parentheses.  It returns a flag indicating whether the
   argument read is the last for the active macro call.  The arguments
   are built on the obstack OBS, indirectly through expand_token ().
   Report errors on behalf of CALLER.  */
static bool
expand_argument (m4 *context, m4_obstack *obs, m4_symbol_value *argp,
		 const m4_call_info *caller)
{
  m4__token_type type;
  m4_symbol_value token;
  int paren_level = 0;
  int line = m4_get_current_line (context);
  size_t len;
  unsigned int age = m4__quote_age (M4SYNTAX);
  bool first = true;

  memset (argp, '\0', sizeof *argp);
  VALUE_MAX_ARGS (argp) = -1;

  /* Skip leading white space.  */
  do
    {
      type = m4__next_token (context, &token, NULL, obs, true, caller);
    }
  while (type == M4_TOKEN_SPACE);

  while (1)
    {
      if (VALUE_MIN_ARGS (argp) < VALUE_MIN_ARGS (&token))
	VALUE_MIN_ARGS (argp) = VALUE_MIN_ARGS (&token);
      if (VALUE_MAX_ARGS (&token) < VALUE_MAX_ARGS (argp))
	VALUE_MAX_ARGS (argp) = VALUE_MAX_ARGS (&token);
      switch (type)
	{			/* TOKSW */
	case M4_TOKEN_COMMA:
	case M4_TOKEN_CLOSE:
	  if (paren_level == 0)
	    {
	      assert (argp->type != M4_SYMBOL_FUNC);
	      if (argp->type != M4_SYMBOL_COMP)
		{
		  len = obstack_object_size (obs);
		  VALUE_MODULE (argp) = NULL;
		  if (len)
		    {
		      obstack_1grow (obs, '\0');
		      m4_set_symbol_value_text (argp, obstack_finish (obs),
						len, age);
		    }
		  else
		    m4_set_symbol_value_text (argp, "", len, 0);
		}
	      else
		{
		  m4__make_text_link (obs, NULL, &argp->u.u_c.end);
		  if (argp->u.u_c.chain == argp->u.u_c.end
		      && argp->u.u_c.chain->type == M4__CHAIN_FUNC)
		    {
		      const m4__builtin *func = argp->u.u_c.chain->u.builtin;
		      argp->type = M4_SYMBOL_FUNC;
		      argp->u.builtin = func;
		    }
		}
	      return type == M4_TOKEN_COMMA;
	    }
	  /* fallthru */
	case M4_TOKEN_OPEN:
	case M4_TOKEN_SIMPLE:
	  if (type == M4_TOKEN_OPEN)
	    paren_level++;
	  else if (type == M4_TOKEN_CLOSE)
	    paren_level--;
	  if (!expand_token (context, obs, type, &token, line, first))
	    age = 0;
	  break;

	case M4_TOKEN_EOF:
	  m4_error (context, EXIT_FAILURE, 0, caller,
		    _("end of file in argument list"));
	  break;

	case M4_TOKEN_WORD:
	case M4_TOKEN_SPACE:
	case M4_TOKEN_STRING:
	case M4_TOKEN_MACDEF:
	  if (!expand_token (context, obs, type, &token, line, first))
	    age = 0;
	  if (token.type == M4_SYMBOL_COMP)
	    {
	      if (argp->type != M4_SYMBOL_COMP)
		{
		  argp->type = M4_SYMBOL_COMP;
		  argp->u.u_c.chain = token.u.u_c.chain;
		  argp->u.u_c.wrapper = argp->u.u_c.has_func = false;
		}
	      else
		{
		  assert (argp->u.u_c.end);
		  argp->u.u_c.end->next = token.u.u_c.chain;
		}
	      argp->u.u_c.end = token.u.u_c.end;
	      if (token.u.u_c.has_func)
		argp->u.u_c.has_func = true;
	    }
	  break;

	case M4_TOKEN_ARGV:
	  assert (paren_level == 0 && argp->type == M4_SYMBOL_VOID
		  && obstack_object_size (obs) == 0
		  && token.u.u_c.chain == token.u.u_c.end
		  && token.u.u_c.chain->quote_age == age
		  && token.u.u_c.chain->type == M4__CHAIN_ARGV);
	  argp->type = M4_SYMBOL_COMP;
	  argp->u.u_c.chain = argp->u.u_c.end = token.u.u_c.chain;
	  argp->u.u_c.wrapper = true;
	  argp->u.u_c.has_func = token.u.u_c.has_func;
	  type = m4__next_token (context, &token, NULL, NULL, false, caller);
	  if (argp->u.u_c.chain->u.u_a.skip_last)
	    assert (type == M4_TOKEN_COMMA);
	  else
	    assert (type == M4_TOKEN_COMMA || type == M4_TOKEN_CLOSE);
	  return type == M4_TOKEN_COMMA;

	default:
	  assert (!"expand_argument");
	  abort ();
	}

      if (argp->type != M4_SYMBOL_VOID || obstack_object_size (obs))
	first = false;
      type = m4__next_token (context, &token, NULL, obs, first, caller);
    }
}


/* The macro expansion is handled by expand_macro ().  It parses the
   arguments, using collect_arguments (), and builds a table of pointers to
   the arguments.  The arguments themselves are stored on a local obstack.
   Expand_macro () uses m4_macro_call () to do the call of the macro.

   Expand_macro () is potentially recursive, since it calls expand_argument
   (), which might call expand_token (), which might call expand_macro ().

   NAME points to storage on the token stack, so it is only valid
   until a call to collect_arguments parses more tokens.  SYMBOL is
   the result of the symbol table lookup on NAME.  */
static void
expand_macro (m4 *context, const char *name, size_t len, m4_symbol *symbol)
{
  void *args_base;		/* Base of stack->args on entry.  */
  void *args_scratch;		/* Base of scratch space for m4_macro_call.  */
  void *argv_base;		/* Base of stack->argv on entry.  */
  m4_macro_args *argv;		/* Arguments to the called macro.  */
  m4_obstack *expansion;	/* Collects the macro's expansion.  */
  m4_symbol_value *value;	/* Original value of this macro.  */
  size_t level;			/* Expansion level of this macro.  */
  m4__macro_arg_stacks *stack;	/* Storage for this macro.  */
  m4_call_info info;		/* Context of this macro call.  */

  /* Obstack preparation.  */
  level = context->expansion_level;
  if (context->stacks_count <= level)
    {
      size_t count = context->stacks_count;
      context->arg_stacks
	= (m4__macro_arg_stacks *) x2nrealloc (context->arg_stacks,
					       &context->stacks_count,
					       sizeof *context->arg_stacks);
      memset (&context->arg_stacks[count], 0,
	      sizeof *context->arg_stacks * (context->stacks_count - count));
    }
  stack = &context->arg_stacks[level];
  if (!stack->args)
    {
      assert (!stack->refcount);
      stack->args = (m4_obstack *) xmalloc (sizeof *stack->args);
      stack->argv = (m4_obstack *) xmalloc (sizeof *stack->argv);
      obstack_init (stack->args);
      obstack_init (stack->argv);
      stack->args_base = obstack_finish (stack->args);
      stack->argv_base = obstack_finish (stack->argv);
    }
  assert (obstack_object_size (stack->args) == 0
	  && obstack_object_size (stack->argv) == 0);
  args_base = obstack_finish (stack->args);
  argv_base = obstack_finish (stack->argv);
  m4__adjust_refcount (context, level, true);
  stack->argcount++;

  /* Grab the current value of this macro, because it may change while
     collecting arguments.  Likewise, grab any state needed during
     tracing.  */
  value = m4_get_symbol_value (symbol);
  info.file = m4_get_current_file (context);
  info.line = m4_get_current_line (context);
  info.call_id = ++macro_call_id;
  info.trace = (m4_is_debug_bit (context, M4_DEBUG_TRACE_ALL)
		|| m4_get_symbol_traced (symbol));
  info.debug_level = m4_get_debug_level_opt (context);
  info.name = name;
  info.name_len = len;

  /* Prepare for macro expansion.  */
  VALUE_PENDING (value)++;
  if (m4_get_nesting_limit_opt (context) < ++context->expansion_level)
    m4_error (context, EXIT_FAILURE, 0, NULL, _("\
recursion limit of %zu exceeded, use -L<N> to change it"),
	      m4_get_nesting_limit_opt (context));

  m4_trace_prepare (context, &info, value);
  argv = collect_arguments (context, &info, symbol, stack->args, stack->argv);
  /* Since collect_arguments can invalidate stack by reallocating
     context->arg_stacks during a recursive expand_macro call, we must
     reset it here.  */
  stack = &context->arg_stacks[level];
  args_scratch = obstack_finish (stack->args);

  /* The actual macro call.  */
  expansion = m4_push_string_init (context, info.file, info.line);
  m4_macro_call (context, value, expansion, argv);
  m4_push_string_finish ();

  /* Cleanup.  */
  argv->info = NULL;

  --context->expansion_level;
  --VALUE_PENDING (value);
  if (BIT_TEST (VALUE_FLAGS (value), VALUE_DELETED_BIT))
    m4_symbol_value_delete (value);

  /* We no longer need argv, so reduce the refcount.  Additionally, if
     no other references to argv were created, we can free our portion
     of the obstack, although we must leave earlier content alone.  A
     refcount of 0 implies that adjust_refcount already freed the
     entire stack.  */
  m4__arg_adjust_refcount (context, argv, false);
  if (stack->refcount)
    {
      if (argv->inuse)
	{
	  obstack_free (stack->args, args_scratch);
	  if (debug_macro_level & PRINT_ARGCOUNT_CHANGES)
	    xfprintf (stderr, "m4debug: -%zu- `%s' in use, level=%zu, "
		      "refcount=%zu, argcount=%zu\n", info.call_id,
		      argv->info->name, level, stack->refcount,
		      stack->argcount);
	}
      else
	{
	  obstack_free (stack->args, args_base);
	  obstack_free (stack->argv, argv_base);
	  stack->argcount--;
	}
    }
}

/* Collect all the arguments to a call of the macro SYMBOL, with call
   context INFO.  The arguments are stored on the obstack ARGUMENTS
   and a table of pointers to the arguments on ARGV_STACK.  Return the
   object describing all of the macro arguments.  */
static m4_macro_args *
collect_arguments (m4 *context, m4_call_info *info, m4_symbol *symbol,
		   m4_obstack *arguments, m4_obstack *argv_stack)
{
  m4_symbol_value token;
  m4_symbol_value *tokenp;
  bool more_args;
  m4_macro_args args;
  m4_macro_args *argv;

  args.argc = 1;
  args.inuse = false;
  args.wrapper = false;
  args.has_ref = false;
  args.flatten = m4_symbol_flatten_args (symbol);
  args.has_func = false;
  /* Must copy here, since we are consuming tokens, and since symbol
     table can be changed during argument collection.  */
  info->name = (char *) obstack_copy0 (arguments, info->name, info->name_len);
  args.quote_age = m4__quote_age (M4SYNTAX);
  args.info = info;
  args.level = context->expansion_level - 1;
  args.arraylen = 0;
  obstack_grow (argv_stack, &args, offsetof (m4_macro_args, array));

  if (m4__next_token_is_open (context))
    {
      /* Gobble parenthesis, then collect arguments.  */
      m4__next_token (context, &token, NULL, NULL, false, info);
      do
	{
	  tokenp = (m4_symbol_value *) obstack_alloc (arguments,
						      sizeof *tokenp);
	  more_args = expand_argument (context, arguments, tokenp, info);

	  if ((m4_is_symbol_value_text (tokenp)
	       && !m4_get_symbol_value_len (tokenp))
	      || (args.flatten && m4_is_symbol_value_func (tokenp)))
	    {
	      obstack_free (arguments, tokenp);
	      tokenp = &empty_symbol;
	    }
	  obstack_ptr_grow (argv_stack, tokenp);
	  args.arraylen++;
	  args.argc++;
	  switch (tokenp->type)
	    {
	    case M4_SYMBOL_TEXT:
	      /* Be conservative - any change in quoting while
		 collecting arguments, or any unsafe argument, will
		 require a rescan if $@ is reused.  */
	      if (m4_get_symbol_value_len (tokenp)
		  && m4_get_symbol_value_quote_age (tokenp) != args.quote_age)
		args.quote_age = 0;
	      break;
	    case M4_SYMBOL_FUNC:
	      args.has_func = true;
	      break;
	    case M4_SYMBOL_COMP:
	      args.has_ref = true;
	      if (tokenp->u.u_c.wrapper)
		{
		  assert (tokenp->u.u_c.chain->type == M4__CHAIN_ARGV
			  && !tokenp->u.u_c.chain->next);
		  args.argc += (tokenp->u.u_c.chain->u.u_a.argv->argc
				- tokenp->u.u_c.chain->u.u_a.index
				- tokenp->u.u_c.chain->u.u_a.skip_last - 1);
		  args.wrapper = true;
		}
	      if (tokenp->u.u_c.has_func)
		args.has_func = true;
	      break;
	    default:
	      assert (!"expand_argument");
	      abort ();
	    }
	}
      while (more_args);
    }
  argv = (m4_macro_args *) obstack_finish (argv_stack);
  argv->argc = args.argc;
  argv->wrapper = args.wrapper;
  argv->has_ref = args.has_ref;
  argv->has_func = args.has_func;
  if (args.quote_age != m4__quote_age (M4SYNTAX))
    argv->quote_age = 0;
  argv->arraylen = args.arraylen;
  return argv;
}


/* The actual call of a macro is handled by m4_macro_call ().
   m4_macro_call () is passed a symbol VALUE, whose type is used to
   call either a builtin function, or the user macro expansion
   function process_macro ().  The arguments are provided by the ARGV
   table.  The expansion is left on the obstack EXPANSION.  Macro
   tracing is also handled here.  */
void
m4_macro_call (m4 *context, m4_symbol_value *value, m4_obstack *expansion,
	       m4_macro_args *argv)
{
  unsigned int trace_start = 0;

  if (argv->info->trace)
    trace_start = trace_pre (context, argv);
  if (!m4_bad_argc (context, argv->argc, argv->info,
		    VALUE_MIN_ARGS (value), VALUE_MAX_ARGS (value),
		    BIT_TEST (VALUE_FLAGS (value),
			      VALUE_SIDE_EFFECT_ARGS_BIT)))
    {
      if (m4_is_symbol_value_text (value))
	process_macro (context, value, expansion, argv->argc, argv);
      else if (m4_is_symbol_value_func (value))
	m4_get_symbol_value_func (value) (context, expansion, argv->argc,
					  argv);
      else if (m4_is_symbol_value_placeholder (value))
	m4_warn (context, 0, argv->info,
		 _("builtin `%s' requested by frozen file not found"),
		 m4_get_symbol_value_placeholder (value));
      else
	{
	  assert (!"m4_macro_call");
	  abort ();
	}
    }
  if (argv->info->trace)
    trace_post (context, trace_start, argv->info);
}

/* This function handles all expansion of user defined and predefined
   macros.  It is called with an obstack OBS, where the macros expansion
   will be placed, as an unfinished object.  SYMBOL points to the macro
   definition, giving the expansion text.  ARGC and ARGV are the arguments,
   as usual.  */
static void
process_macro (m4 *context, m4_symbol_value *value, m4_obstack *obs,
	       int argc, m4_macro_args *argv)
{
  const char *text = m4_get_symbol_value_text (value);
  size_t len = m4_get_symbol_value_len (value);
  int i;

  while (len--)
    {
      char ch;

      if (!m4_has_syntax (M4SYNTAX, *text, M4_SYNTAX_DOLLAR) || !len)
	{
	  obstack_1grow (obs, *text);
	  text++;
	  continue;
	}
      ch = *text++;
      switch (*text)
	{
	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9':
	  /* FIXME - multidigit arguments should convert over to ${10}
	     syntax instead of $10; see
	     http://lists.gnu.org/archive/html/m4-discuss/2006-08/msg00028.html
	     for more discussion.  */
	  if (m4_get_posixly_correct_opt (context) || !isdigit(text[1]))
	    {
	      i = *text++ - '0';
	      len--;
	    }
	  else
	    {
	      char *endp;
	      i = (int) strtol (text, &endp, 10);
	      len -= endp - text;
	      text = endp;
	    }
	  if (i < argc)
	    m4_push_arg (context, obs, argv, i);
	  break;

	case '#':		/* number of arguments */
	  m4_shipout_int (obs, argc - 1);
	  text++;
	  len--;
	  break;

	case '*':		/* all arguments */
	case '@':		/* ... same, but quoted */
	  m4_push_args (context, obs, argv, false, *text == '@');
	  text++;
	  len--;
	  break;

	default:
	  if (m4_get_posixly_correct_opt (context)
	      || !VALUE_ARG_SIGNATURE (value))
	    {
	      obstack_1grow (obs, ch);
	    }
	  else
	    {
	      size_t len1 = 0;
	      const char *endp;
	      char *key;

	      for (endp = ++text;
		   len1 < len && m4_has_syntax (M4SYNTAX, *endp,
						(M4_SYNTAX_OTHER
						 | M4_SYNTAX_ALPHA
						 | M4_SYNTAX_NUM));
		   ++endp)
		{
		  ++len1;
		}
	      key = xstrndup (text, len1);

	      if (*endp)
		{
		  struct m4_symbol_arg **arg
		    = (struct m4_symbol_arg **)
		      m4_hash_lookup (VALUE_ARG_SIGNATURE (value), key);

		  if (arg)
		    {
		      i = SYMBOL_ARG_INDEX (*arg);
		      assert (i < argc);
		      m4_shipout_string (context, obs, M4ARG (i), M4ARGLEN (i),
					 false);
		    }
		}
	      else
		{
		  m4_error (context, 0, 0, argv->info,
			    _("unterminated parameter reference: %s"), key);
		}

	      len -= endp - text;
	      text = endp;

	      free (key);
	      break;
	    }
	  break;
	}
    }
}



/* The next portion of this file contains the functions for macro
   tracing output.  All tracing output for a macro call is collected
   on an obstack TRACE, and printed whenever the line is complete.
   This prevents tracing output from interfering with other debug
   messages generated by the various builtins.  */

/* Format the standard header attached to all tracing output lines,
   using the context in INFO as appropriate.  Return the offset into
   the trace obstack where this particular trace begins.  */
static unsigned int
trace_header (m4 *context, const m4_call_info *info)
{
  m4_obstack *trace = &context->trace_messages;
  unsigned int result = obstack_object_size (trace);
  obstack_grow (trace, "m4trace:", 8);
  if (info->debug_level & M4_DEBUG_TRACE_FILE)
    obstack_printf (trace, "%s:", info->file);
  if (info->debug_level & M4_DEBUG_TRACE_LINE)
    obstack_printf (trace, "%d:", info->line);
  obstack_printf (trace, " -%zu- ", context->expansion_level);
  if (info->debug_level & M4_DEBUG_TRACE_CALLID)
    obstack_printf (trace, "id %zu: ", info->call_id);
  return result;
}

/* Print current tracing line starting at offset START, as returned
   from an earlier trace_header(), then clear the obstack.  */
static void
trace_flush (m4 *context, unsigned int start)
{
  char *str;
  size_t len = obstack_object_size (&context->trace_messages);
  FILE *file = m4_get_debug_file (context);

  if (file)
    {
      /* TODO - quote nonprintable characters if debug is tty?  */
      str = (char *) obstack_base (&context->trace_messages);
      fwrite (&str[start], 1, len - start, file);
      fputc ('\n', file);
    }
  obstack_blank (&context->trace_messages, start - len);
}

/* Do pre-argument-collection tracing for the macro described in INFO.
   Should be called prior to m4_macro_call().  */
void
m4_trace_prepare (m4 *context, const m4_call_info *info,
		  m4_symbol_value *value)
{
  const m4_string_pair *quotes = NULL;
  size_t arg_length = m4_get_max_debug_arg_length_opt (context);
  bool module = (info->debug_level & M4_DEBUG_TRACE_MODULE) != 0;

  if (info->debug_level & M4_DEBUG_TRACE_QUOTE)
    quotes = m4_get_syntax_quotes (M4SYNTAX);
  if (info->trace && (info->debug_level & M4_DEBUG_TRACE_CALL))
    {
      unsigned int start = trace_header (context, info);
      obstack_grow (&context->trace_messages, info->name, info->name_len);
      obstack_grow (&context->trace_messages, " ... = ", 7);
      m4__symbol_value_print (context, value, &context->trace_messages, quotes,
			      false, NULL, &arg_length, module);
      trace_flush (context, start);
    }
}

/* Format the parts of a trace line that are known via ARGV before the
   macro is actually expanded.  Used from m4_macro_call().  Return the
   start of the current trace, in case other traces are printed before
   this trace completes trace_post.  */
static unsigned int
trace_pre (m4 *context, m4_macro_args *argv)
{
  int trace_level = argv->info->debug_level;
  unsigned int start = trace_header (context, argv->info);
  m4_obstack *trace = &context->trace_messages;

  assert (argv->info->trace);
  obstack_grow (trace, argv->info->name, argv->info->name_len);

  if (1 < m4_arg_argc (argv) && (trace_level & M4_DEBUG_TRACE_ARGS))
    {
      const m4_string_pair *quotes = NULL;
      size_t arg_length = m4_get_max_debug_arg_length_opt (context);
      bool module = (trace_level & M4_DEBUG_TRACE_MODULE) != 0;

      if (trace_level & M4_DEBUG_TRACE_QUOTE)
	quotes = m4_get_syntax_quotes (M4SYNTAX);
      obstack_1grow (trace, '(');
      m4__arg_print (context, trace, argv, 1, quotes, false, NULL, ", ",
		     &arg_length, true, module);
      obstack_1grow (trace, ')');
    }
  return start;
}

/* If requested by the trace state in INFO, format the final part of a
   trace line.  Then print all collected information from START,
   returned from a prior trace_pre().  Used from m4_macro_call ().  */
static void
trace_post (m4 *context, unsigned int start, const m4_call_info *info)
{
  assert (info->trace);
  if (info->debug_level & M4_DEBUG_TRACE_EXPANSION)
    {
      obstack_grow (&context->trace_messages, " -> ", 4);
      m4_input_print (context, &context->trace_messages, info->debug_level);
    }
  trace_flush (context, start);
}


/* Accessors into m4_macro_args.  */

/* Adjust the refcount of argument stack LEVEL.  If INCREASE, then
   increase the count, otherwise decrease the count and clear the
   entire stack if the new count is zero.  Return the new
   refcount.  */
size_t
m4__adjust_refcount (m4 *context, size_t level, bool increase)
{
  m4__macro_arg_stacks *stack = &context->arg_stacks[level];
  assert (level < context->stacks_count && stack->args
	  && (increase || stack->refcount));
  if (increase)
    stack->refcount++;
  else if (--stack->refcount == 0)
    {
      obstack_free (stack->args, stack->args_base);
      obstack_free (stack->argv, stack->argv_base);
      if ((debug_macro_level & PRINT_ARGCOUNT_CHANGES) && 1 < stack->argcount)
	xfprintf (stderr, "m4debug: -%zu- freeing %zu args, level=%zu\n",
		  macro_call_id, stack->argcount, level);
      stack->argcount = 0;
    }
  if (debug_macro_level
      & (increase ? PRINT_REFCOUNT_INCREASE : PRINT_REFCOUNT_DECREASE))
    xfprintf (stderr, "m4debug: level %zu refcount=%zu\n", level,
	      stack->refcount);
  return stack->refcount;
}

/* Given ARGV, adjust the refcount of every reference it contains in
   the direction decided by INCREASE.  Return true if increasing
   references to ARGV implies the first use of ARGV.  */
bool
m4__arg_adjust_refcount (m4 *context, m4_macro_args *argv, bool increase)
{
  size_t i;
  m4__symbol_chain *chain;
  bool result = !argv->inuse;

  if (argv->has_ref)
    for (i = 0; i < argv->arraylen; i++)
      if (argv->array[i]->type == M4_SYMBOL_COMP)
	{
	  chain = argv->array[i]->u.u_c.chain;
	  while (chain)
	    {
	      switch (chain->type)
		{
		case M4__CHAIN_STR:
		  if (chain->u.u_s.level < SIZE_MAX)
		    m4__adjust_refcount (context, chain->u.u_s.level,
					 increase);
		  break;
		case M4__CHAIN_FUNC:
		  break;
		case M4__CHAIN_ARGV:
		  assert (chain->u.u_a.argv->inuse);
		  m4__arg_adjust_refcount (context, chain->u.u_a.argv,
					   increase);
		  break;
		default:
		  assert (!"m4__arg_adjust_refcount");
		  abort ();
		}
	      chain = chain->next;
	    }
	}
  m4__adjust_refcount (context, argv->level, increase);
  return result;
}

/* Mark ARGV as being in use, along with any $@ references that it
   wraps.  */
static void
arg_mark (m4_macro_args *argv)
{
  size_t i;
  m4__symbol_chain *chain;

  if (argv->inuse)
    return;
  argv->inuse = true;
  if (argv->wrapper)
    {
      for (i = 0; i < argv->arraylen; i++)
	if (argv->array[i]->type == M4_SYMBOL_COMP
	    && argv->array[i]->u.u_c.wrapper)
	  {
	    chain = argv->array[i]->u.u_c.chain;
	    assert (!chain->next && chain->type == M4__CHAIN_ARGV);
	    if (!chain->u.u_a.argv->inuse)
	      arg_mark (chain->u.u_a.argv);
	  }
    }
}

/* Populate the newly-allocated VALUE as a wrapper around ARGV,
   starting with argument ARG.  Allocate any data on OBS, owned by a
   given expansion LEVEL.  FLATTEN determines whether to allow
   builtins, and QUOTES determines whether all arguments are quoted.
   Return TOKEN when successful, NULL when wrapping ARGV is trivially
   empty.  */
static m4_symbol_value *
make_argv_ref (m4 *context, m4_symbol_value *value, m4_obstack *obs,
	       size_t level, m4_macro_args *argv, size_t arg, bool flatten,
	       const m4_string_pair *quotes)
{
  m4__symbol_chain *chain;

  if (argv->argc <= arg)
    return NULL;
  value->type = M4_SYMBOL_COMP;
  value->u.u_c.chain = value->u.u_c.end = NULL;

  /* Cater to the common idiom of $0(`$1',shift(shift($@))), by
     inlining the first few arguments and reusing the original $@ ref,
     rather than creating another layer of wrappers.  */
  while (argv->wrapper)
    {
      size_t i;
      for (i = 0; i < argv->arraylen; i++)
	{
	  if ((argv->array[i]->type == M4_SYMBOL_COMP
	       && argv->array[i]->u.u_c.wrapper)
	      || level < SIZE_MAX)
	    break;
	  if (arg == 1)
	    {
	      m4__push_arg_quote (context, obs, argv, i + 1, quotes);
	      /* TODO support M4_SYNTAX_COMMA.  */
	      obstack_1grow (obs, ',');
	    }
	  else
	    arg--;
	}
      assert (i < argv->arraylen);
      if (i + 1 == argv->arraylen)
	{
	  assert (argv->array[i]->type == M4_SYMBOL_COMP
		  && argv->array[i]->u.u_c.wrapper);
	  chain = argv->array[i]->u.u_c.chain;
	  assert (!chain->next && chain->type == M4__CHAIN_ARGV
		  && !chain->u.u_a.skip_last);
	  argv = chain->u.u_a.argv;
	  arg += chain->u.u_a.index - 1;
	}
      else
	{
	  arg += i;
	  break;
	}
    }

  m4__make_text_link (obs, &value->u.u_c.chain, &value->u.u_c.end);
  chain = (m4__symbol_chain *) obstack_alloc (obs, sizeof *chain);
  if (value->u.u_c.end)
    value->u.u_c.end->next = chain;
  else
    value->u.u_c.chain = chain;
  value->u.u_c.end = chain;
  value->u.u_c.wrapper = true;
  value->u.u_c.has_func = argv->has_func;
  chain->next = NULL;
  chain->type = M4__CHAIN_ARGV;
  chain->quote_age = argv->quote_age;
  chain->u.u_a.argv = argv;
  chain->u.u_a.index = arg;
  chain->u.u_a.flatten = flatten;
  chain->u.u_a.has_func = argv->has_func;
  chain->u.u_a.comma = false;
  chain->u.u_a.skip_last = false;
  chain->u.u_a.quotes = m4__quote_cache (M4SYNTAX, obs, chain->quote_age,
					 quotes);
  return value;
}

/* Given ARGV, return the symbol value at the specified ARG, which
   must be non-zero.  *LEVEL is set to the obstack level that contains
   the symbol (which is not necessarily the level of ARGV).  If
   FLATTEN, avoid returning a builtin token.  */
static m4_symbol_value *
arg_symbol (m4_macro_args *argv, size_t arg, size_t *level, bool flatten)
{
  size_t i;
  m4_symbol_value *value;

  assert (arg);
  if (level)
    *level = argv->level;
  flatten |= argv->flatten;
  if (argv->argc <= arg)
    return &empty_symbol;
  if (!argv->wrapper)
    {
      value = argv->array[arg - 1];
      if (flatten && m4_is_symbol_value_func (value))
	value = &empty_symbol;
      return value;
    }

  /* Must cycle through all array slots until we find arg, since
     wrappers can contain multiple arguments.  */
  for (i = 0; i < argv->arraylen; i++)
    {
      value = argv->array[i];
      if (value->type == M4_SYMBOL_COMP && value->u.u_c.wrapper)
	{
	  m4__symbol_chain *chain = value->u.u_c.chain;
	  assert (!chain->next && chain->type == M4__CHAIN_ARGV);
	  if (arg <= (chain->u.u_a.argv->argc - chain->u.u_a.index
			- chain->u.u_a.skip_last))
	    {
	      value = arg_symbol (chain->u.u_a.argv,
				  chain->u.u_a.index - 1 + arg, level,
				  flatten || chain->u.u_a.flatten);
	      break;
	    }
	  arg -= (chain->u.u_a.argv->argc - chain->u.u_a.index
		    - chain->u.u_a.skip_last);
	}
      else if (--arg == 0)
	break;
    }
  return value;
}

/* Given ARGV, return the symbol value at the specified ARG, which
   must be non-zero.  */
m4_symbol_value *
m4_arg_symbol (m4_macro_args *argv, size_t arg)
{
  return arg_symbol (argv, arg, NULL, false);
}

/* Given ARGV, return true if argument ARG is text.  Arg 0 is always
   text, as are indices beyond argc.  */
bool
m4_is_arg_text (m4_macro_args *argv, size_t arg)
{
  m4_symbol_value *value;
  if (arg == 0 || argv->argc <= arg || argv->flatten || !argv->has_func)
    return true;
  value = m4_arg_symbol (argv, arg);
  if (m4_is_symbol_value_text (value)
      || (value->type == M4_SYMBOL_COMP && !value->u.u_c.has_func))
    return true;
  return false;
}

/* Given ARGV, return true if argument ARG is a single builtin
   function.  Only non-zero indices less than argc can return
   true.  */
bool
m4_is_arg_func (m4_macro_args *argv, size_t arg)
{
  if (arg == 0 || argv->argc <= arg || argv->flatten || !argv->has_func)
    return false;
  return m4_is_symbol_value_func (m4_arg_symbol (argv, arg));
}

/* Given ARGV, return true if argument ARG contains a builtin token
   concatenated with anything else.  Only non-zero indices less than
   argc can return true.  */
bool
m4_is_arg_composite (m4_macro_args *argv, size_t arg)
{
  m4_symbol_value *value;
  if (arg == 0 || argv->argc <= arg || argv->flatten || !argv->has_func)
    return false;
  value = m4_arg_symbol (argv, arg);
  if (value->type == M4_SYMBOL_COMP && value->u.u_c.has_func)
    return true;
  return false;
}

/* Given ARGV, return the text at argument ARG.  Abort if the argument
   is not text.  Arg 0 is always text, and indices beyond argc return
   the empty string.  If FLATTEN, builtins are ignored.  The result is
   always NUL-terminated, even if it includes embedded NUL
   characters.  */
const char *
m4_arg_text (m4 *context, m4_macro_args *argv, size_t arg, bool flatten)
{
  m4_symbol_value *value;
  m4__symbol_chain *chain;
  m4_obstack *obs;

  if (arg == 0)
    {
      assert (argv->info);
      return argv->info->name;
    }
  if (argv->argc <= arg)
    return "";
  value = arg_symbol (argv, arg, NULL, flatten);
  if (m4_is_symbol_value_text (value))
    return m4_get_symbol_value_text (value);
  assert (value->type == M4_SYMBOL_COMP);
  chain = value->u.u_c.chain;
  obs = m4_arg_scratch (context);
  while (chain)
    {
      switch (chain->type)
	{
	case M4__CHAIN_STR:
	  obstack_grow (obs, chain->u.u_s.str, chain->u.u_s.len);
	  break;
	case M4__CHAIN_FUNC:
	  if (flatten)
	    break;
	  assert (!"m4_arg_text");
	  abort ();
	case M4__CHAIN_ARGV:
	  assert (!chain->u.u_a.has_func || flatten || argv->flatten);
	  m4__arg_print (context, obs, chain->u.u_a.argv, chain->u.u_a.index,
			 m4__quote_cache (M4SYNTAX, NULL, chain->quote_age,
					  chain->u.u_a.quotes),
			 flatten || argv->flatten || chain->u.u_a.flatten,
			 NULL, NULL, NULL, false, false);
	  break;
	default:
	  assert (!"m4_arg_text");
	  abort ();
	}
      chain = chain->next;
    }
  obstack_1grow (obs, '\0');
  return (char *) obstack_finish (obs);
}

/* Given ARGV, compare text arguments INDEXA and INDEXB for equality.
   Both indices must be non-zero.  Return true if the arguments
   contain the same contents; often more efficient than
   !strcmp (m4_arg_text (context, argv, indexa),
	    m4_arg_text (context, argv, indexb)).  */
bool
m4_arg_equal (m4 *context, m4_macro_args *argv, size_t indexa, size_t indexb)
{
  m4_symbol_value *sa = m4_arg_symbol (argv, indexa);
  m4_symbol_value *sb = m4_arg_symbol (argv, indexb);
  m4__symbol_chain tmpa;
  m4__symbol_chain tmpb;
  m4__symbol_chain *ca = &tmpa;
  m4__symbol_chain *cb = &tmpb;
  m4__symbol_chain *chain;
  m4_obstack *obs = m4_arg_scratch (context);

  /* Quick tests.  */
  if (sa == &empty_symbol || sb == &empty_symbol)
    return sa == sb;
  if (m4_is_symbol_value_text (sa) && m4_is_symbol_value_text (sb))
    return (m4_get_symbol_value_len (sa) == m4_get_symbol_value_len (sb)
	    && memcmp (m4_get_symbol_value_text (sa),
		       m4_get_symbol_value_text (sb),
		       m4_get_symbol_value_len (sa)) == 0);

  /* Convert both arguments to chains, if not one already.  */
  switch (sa->type)
    {
    case M4_SYMBOL_TEXT:
      tmpa.next = NULL;
      tmpa.type = M4__CHAIN_STR;
      tmpa.u.u_s.str = m4_get_symbol_value_text (sa);
      tmpa.u.u_s.len = m4_get_symbol_value_len (sa);
      break;
    case M4_SYMBOL_FUNC:
      tmpa.next = NULL;
      tmpa.type = M4__CHAIN_FUNC;
      tmpa.u.builtin = sa->u.builtin;
      break;
    case M4_SYMBOL_COMP:
      ca = sa->u.u_c.chain;
      break;
    default:
      assert (!"m4_arg_equal");
      abort ();
    }
  switch (sb->type)
    {
    case M4_SYMBOL_TEXT:
      tmpb.next = NULL;
      tmpb.type = M4__CHAIN_STR;
      tmpb.u.u_s.str = m4_get_symbol_value_text (sb);
      tmpb.u.u_s.len = m4_get_symbol_value_len (sb);
      break;
    case M4_SYMBOL_FUNC:
      tmpb.next = NULL;
      tmpb.type = M4__CHAIN_FUNC;
      tmpb.u.builtin = sb->u.builtin;
      break;
    case M4_SYMBOL_COMP:
      cb = sb->u.u_c.chain;
      break;
    default:
      assert (!"m4_arg_equal");
      abort ();
    }

  /* Compare each link of the chain.  */
  while (ca && cb)
    {
      if (ca->type == M4__CHAIN_ARGV)
	{
	  tmpa.next = NULL;
	  tmpa.type = M4__CHAIN_STR;
	  tmpa.u.u_s.str = NULL;
	  tmpa.u.u_s.len = 0;
	  chain = &tmpa;
	  m4__arg_print (context, obs, ca->u.u_a.argv, ca->u.u_a.index,
			 m4__quote_cache (M4SYNTAX, NULL, ca->quote_age,
					  ca->u.u_a.quotes),
			 argv->flatten || ca->u.u_a.flatten, &chain, NULL,
			 NULL, false, false);
	  assert (obstack_object_size (obs) == 0 && chain != &tmpa);
	  chain->next = ca->next;
	  ca = tmpa.next;
	  continue;
	}
      if (cb->type == M4__CHAIN_ARGV)
	{
	  tmpb.next = NULL;
	  tmpb.type = M4__CHAIN_STR;
	  tmpb.u.u_s.str = NULL;
	  tmpb.u.u_s.len = 0;
	  chain = &tmpb;
	  m4__arg_print (context, obs, cb->u.u_a.argv, cb->u.u_a.index,
			 m4__quote_cache (M4SYNTAX, NULL, cb->quote_age,
					  cb->u.u_a.quotes),
			 argv->flatten || cb->u.u_a.flatten, &chain, NULL,
			 NULL, false, false);
	  assert (obstack_object_size (obs) == 0 && chain != &tmpb);
	  chain->next = cb->next;
	  cb = tmpb.next;
	  continue;
	}
      if (ca->type == M4__CHAIN_FUNC)
	{
	  if (cb->type != M4__CHAIN_FUNC || ca->u.builtin != cb->u.builtin)
	    return false;
	  ca = ca->next;
	  cb = cb->next;
	  continue;
	}
      assert (ca->type == M4__CHAIN_STR && cb->type == M4__CHAIN_STR);
      if (ca->u.u_s.len == cb->u.u_s.len)
	{
	  if (memcmp (ca->u.u_s.str, cb->u.u_s.str, ca->u.u_s.len) != 0)
	    return false;
	  ca = ca->next;
	  cb = cb->next;
	}
      else if (ca->u.u_s.len < cb->u.u_s.len)
	{
	  if (memcmp (ca->u.u_s.str, cb->u.u_s.str, ca->u.u_s.len) != 0)
	    return false;
	  tmpb.next = cb->next;
	  tmpb.u.u_s.str = cb->u.u_s.str + ca->u.u_s.len;
	  tmpb.u.u_s.len = cb->u.u_s.len - ca->u.u_s.len;
	  ca = ca->next;
	  cb = &tmpb;
	}
      else
	{
	  assert (cb->u.u_s.len < ca->u.u_s.len);
	  if (memcmp (ca->u.u_s.str, cb->u.u_s.str, cb->u.u_s.len) != 0)
	    return false;
	  tmpa.next = ca->next;
	  tmpa.u.u_s.str = ca->u.u_s.str + cb->u.u_s.len;
	  tmpa.u.u_s.len = ca->u.u_s.len - cb->u.u_s.len;
	  ca = &tmpa;
	  cb = cb->next;
	}
    }

  /* If we get this far, the two arguments are equal only if both
     chains are exhausted.  */
  assert (ca != cb || !ca);
  return ca == cb;
}

/* Given ARGV, return true if argument ARG is the empty string.  This
   gives the same result as comparing m4_arg_len against 0, but is
   often faster.  */
bool
m4_arg_empty (m4_macro_args *argv, size_t arg)
{
  if (!arg)
    {
      assert (argv->info);
      return !argv->info->name_len;
    }
  return m4_arg_symbol (argv, arg) == &empty_symbol;
}

/* Given ARGV, return the length of argument ARG.  Abort if the
   argument is not text.  Indices beyond argc return 0.  */
size_t
m4_arg_len (m4 *context, m4_macro_args *argv, size_t arg)
{
  m4_symbol_value *value;
  m4__symbol_chain *chain;
  size_t len;

  if (arg == 0)
    {
      assert (argv->info);
      return argv->info->name_len;
    }
  if (argv->argc <= arg)
    return 0;
  value = m4_arg_symbol (argv, arg);
  if (m4_is_symbol_value_text (value))
    return m4_get_symbol_value_len (value);
  assert (value->type == M4_SYMBOL_COMP);
  chain = value->u.u_c.chain;
  len = 0;
  while (chain)
    {
      size_t i;
      size_t limit;
      const m4_string_pair *quotes;
      switch (chain->type)
	{
	case M4__CHAIN_STR:
	  len += chain->u.u_s.len;
	  break;
	case M4__CHAIN_ARGV:
	  i = chain->u.u_a.index;
	  limit = chain->u.u_a.argv->argc - i - chain->u.u_a.skip_last;
	  quotes = m4__quote_cache (M4SYNTAX, NULL, chain->quote_age,
				    chain->u.u_a.quotes);
	  assert (limit);
	  if (quotes)
	    len += (quotes->len1 + quotes->len2) * limit;
	  len += limit - 1;
	  while (limit--)
	    {
	      /* TODO handle concatenation of builtins.  */
	      if (m4_is_symbol_value_func (m4_arg_symbol (chain->u.u_a.argv,
							  i)))
		assert (argv->flatten);
	      else
		len += m4_arg_len (context, chain->u.u_a.argv, i);
	      i++;
	    }
	  break;
	default:
	  assert (!"m4_arg_len");
	  abort ();
	}
      chain = chain->next;
    }
  assert (len);
  return len;
}

/* Given ARGV, return the builtin function referenced by argument ARG.
   Abort if it is not a single builtin.  */
m4_builtin_func *
m4_arg_func (m4_macro_args *argv, size_t arg)
{
  return m4_get_symbol_value_func (m4_arg_symbol (argv, arg));
}

/* Dump a representation of ARGV to the obstack OBS, starting with
   argument ARG.  If QUOTES is non-NULL, each argument is displayed
   with those quotes.  If FLATTEN, builtins are converted to empty
   quotes; if CHAINP, *CHAINP is updated with macro tokens; otherwise,
   builtins are represented by their name.  Separate arguments with
   SEP, which defaults to a comma.  If MAX_LEN is non-NULL, truncate
   the output after *MAX_LEN bytes are output and return true;
   otherwise, return false, and reduce *MAX_LEN by the number of bytes
   output.  If QUOTE_EACH, the truncation length is reset for each
   argument, quotes do not count against length, and all arguments are
   printed; otherwise, quotes count against the length and trailing
   arguments may be discarded.  If MODULE, print any details about
   originating modules; modules do not count against truncation
   length.  MAX_LEN and CHAINP may not both be specified.  */
bool
m4__arg_print (m4 *context, m4_obstack *obs, m4_macro_args *argv, size_t arg,
	       const m4_string_pair *quotes, bool flatten,
	       m4__symbol_chain **chainp, const char *sep, size_t *max_len,
	       bool quote_each, bool module)
{
  size_t len = max_len ? *max_len : SIZE_MAX;
  size_t i;
  bool use_sep = false;
  size_t sep_len;
  size_t *plen = quote_each ? NULL : &len;

  flatten |= argv->flatten;
  if (chainp)
    assert (!max_len && *chainp);
  if (!sep)
    sep = ",";
  sep_len = strlen (sep);
  for (i = arg; i < argv->argc; i++)
    {
      if (quote_each && max_len)
	len = *max_len;
      if (use_sep && m4_shipout_string_trunc (obs, sep, sep_len, NULL, plen))
	return true;
      use_sep = true;
      if (quotes && !quote_each
	  && m4_shipout_string_trunc (obs, quotes->str1, quotes->len1, NULL,
				      plen))
	return true;
      if (m4__symbol_value_print (context, arg_symbol (argv, i, NULL, flatten),
				  obs, quote_each ? quotes : NULL, flatten,
				  chainp, &len, module))
	return true;
      if (quotes && !quote_each
	  && m4_shipout_string_trunc (obs, quotes->str2, quotes->len2, NULL,
				      plen))
	return true;
    }
  if (max_len)
    *max_len = len;
  else if (chainp)
    m4__make_text_link (obs, NULL, chainp);
  return false;
}

/* Create a new argument object using the same obstack as ARGV; thus,
   the new object will automatically be freed when the original is
   freed.  Explicitly set the macro name (argv[0]) from ARGV0 with
   length ARGV0_LEN, and discard argv[1] of the wrapped ARGV.  If
   FLATTEN, any builtins in ARGV are flattened to an empty string when
   referenced through the new object.  If TRACE, then trace the macro
   regardless of global trace state.  */
m4_macro_args *
m4_make_argv_ref (m4 *context, m4_macro_args *argv, const char *argv0,
		  size_t argv0_len, bool flatten, bool trace)
{
  m4_macro_args *new_argv;
  m4_symbol_value *value;
  m4_symbol_value *new_value;
  m4_obstack *obs = m4_arg_scratch (context);
  m4_call_info *info;

  info = (m4_call_info *) obstack_copy (obs, argv->info, sizeof *info);
  new_value = (m4_symbol_value *) obstack_alloc (obs, sizeof *value);
  value = make_argv_ref (context, new_value, obs, context->expansion_level - 1,
			 argv, 2, flatten, NULL);
  if (!value)
    {
      obstack_free (obs, new_value);
      new_argv = (m4_macro_args *) obstack_alloc (obs, offsetof (m4_macro_args,
								 array));
      new_argv->arraylen = 0;
      new_argv->wrapper = false;
      new_argv->has_ref = false;
      new_argv->flatten = false;
      new_argv->has_func = false;
    }
  else
    {
      new_argv = (m4_macro_args *) obstack_alloc (obs, (offsetof (m4_macro_args,
								  array)
							+ sizeof value));
      new_argv->arraylen = 1;
      new_argv->array[0] = value;
      new_argv->wrapper = true;
      new_argv->has_ref = argv->has_ref;
      new_argv->flatten = flatten;
      new_argv->has_func = argv->has_func;
    }
  new_argv->argc = argv->argc - 1;
  new_argv->inuse = false;
  new_argv->quote_age = argv->quote_age;
  new_argv->info = info;
  info->trace = (argv->info->debug_level & M4_DEBUG_TRACE_ALL) || trace;
  info->name = argv0;
  info->name_len = argv0_len;
  new_argv->level = argv->level;
  return new_argv;
}

/* Push argument ARG from ARGV, which must be a text token, onto the
   expansion stack OBS for rescanning.  */
void
m4_push_arg (m4 *context, m4_obstack *obs, m4_macro_args *argv, size_t arg)
{
  m4_symbol_value value;

  if (arg == 0)
    {
      assert (argv->info);
      m4_set_symbol_value_text (&value, argv->info->name, argv->info->name_len,
				0);
      if (m4__push_symbol (context, &value, context->expansion_level - 1,
			   argv->inuse))
	arg_mark (argv);
    }
  else
    m4__push_arg_quote (context, obs, argv, arg, NULL);
}

/* Push argument ARG from ARGV onto the expansion stack OBS for
   rescanning.  ARG must be non-zero.  QUOTES determines any quote
   delimiters that were in effect when the reference was created.  */
void
m4__push_arg_quote (m4 *context, m4_obstack *obs, m4_macro_args *argv,
		    size_t arg, const m4_string_pair *quotes)
{
  size_t level;
  m4_symbol_value *value = arg_symbol (argv, arg, &level, false);

  if (quotes)
    obstack_grow (obs, quotes->str1, quotes->len1);
  if (value != &empty_symbol
      && m4__push_symbol (context, value, level, argv->inuse))
    arg_mark (argv);
  if (quotes)
    obstack_grow (obs, quotes->str2, quotes->len2);
}

/* Push series of comma-separated arguments from ARGV onto the
   expansion stack OBS for rescanning.  If SKIP, then don't push the
   first argument.  If QUOTE, also push quoting around each arg.  */
void
m4_push_args (m4 *context, m4_obstack *obs, m4_macro_args *argv, bool skip,
	      bool quote)
{
  m4_symbol_value tmp;
  m4_symbol_value *value;
  size_t i = skip ? 2 : 1;
  const m4_string_pair *quotes = m4_get_syntax_quotes (M4SYNTAX);

  if (argv->argc <= i)
    return;

  if (argv->argc == i + 1)
    {
      m4__push_arg_quote (context, obs, argv, i, quote ? quotes : NULL);
      return;
    }

  value = make_argv_ref (context, &tmp, obs, -1, argv, i, argv->flatten,
			 quote ? quotes : NULL);
  assert (value == &tmp);
  if (m4__push_symbol (context, value, -1, argv->inuse))
    arg_mark (argv);
}

/* Push arguments from ARGV onto the wrap stack for later rescanning.
   If GNU extensions are disabled, only the first argument is pushed;
   otherwise, all arguments are pushed and separated with a space.  */
void
m4_wrap_args (m4 *context, m4_macro_args *argv)
{
  size_t i;
  m4_obstack *obs;
  m4_symbol_value *value;
  m4__symbol_chain *chain;
  m4__symbol_chain **end;
  size_t limit = m4_get_posixly_correct_opt (context) ? 2 : argv->argc;

  if (limit == 2 && m4_arg_empty (argv, 1))
    return;

  obs = m4__push_wrapup_init (context, argv->info, &end);
  for (i = 1; i < limit; i++)
    {
      if (i != 1)
	obstack_1grow (obs, ' ');
      value = m4_arg_symbol (argv, i);
      switch (value->type)
	{
	case M4_SYMBOL_TEXT:
	  obstack_grow (obs, m4_get_symbol_value_text (value),
			m4_get_symbol_value_len (value));
	  break;
	case M4_SYMBOL_FUNC:
	  m4__append_builtin (obs, value->u.builtin, NULL, end);
	  break;
	case M4_SYMBOL_COMP:
	  chain = value->u.u_c.chain;
	  while (chain)
	    {
	      switch (chain->type)
		{
		case M4__CHAIN_STR:
		  obstack_grow (obs, chain->u.u_s.str, chain->u.u_s.len);
		  break;
		case M4__CHAIN_FUNC:
		  m4__append_builtin (obs, chain->u.builtin, NULL, end);
		  break;
		case M4__CHAIN_ARGV:
		  m4__arg_print (context, obs, chain->u.u_a.argv,
				 chain->u.u_a.index,
				 m4__quote_cache (M4SYNTAX, NULL,
						  chain->quote_age,
						  chain->u.u_a.quotes),
				 chain->u.u_a.flatten, end, NULL, NULL, false,
				 false);
		  break;
		default:
		  assert (!"m4_wrap_args");
		  abort ();
		}
	      chain = chain->next;
	    }
	  break;
	default:
	  assert (!"m4_wrap_args");
	  abort ();
	}
    }
  m4__push_wrapup_finish ();
}


/* Define these last, so that earlier uses can benefit from the macros
   in m4private.h.  */

/* Given ARGV, return one greater than the number of arguments it
   describes.  */
#undef m4_arg_argc
size_t
m4_arg_argc (m4_macro_args *argv)
{
  return argv->argc;
}

/* Given ARGV, return the call context in effect when argument
   collection began.  Only safe to call while the macro is being
   expanded.  */
#undef m4_arg_info
const m4_call_info *
m4_arg_info (m4_macro_args *argv)
{
  assert (argv->info);
  return argv->info;
}

/* Return an obstack useful for scratch calculations, and which will
   not interfere with macro expansion.  The obstack will be reset when
   expand_macro completes.  */
#undef m4_arg_scratch
m4_obstack *
m4_arg_scratch (m4 *context)
{
  m4__macro_arg_stacks *stack
    = &context->arg_stacks[context->expansion_level - 1];
  assert (obstack_object_size (stack->args) == 0);
  return stack->args;
}