m4/m4.c

   1 /* GNU m4 -- A simple macro processor
   2    Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994, 2001, 2004, 2006,
   3    2007, 2008 Free Software Foundation, Inc.
   4
   5    This file is part of GNU M4.
   6
   7    GNU M4 is free software: you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation, either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    GNU M4 is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include <config.h>
  22
  23 #include "m4private.h"
  24
  25 #define DEFAULT_NESTING_LIMIT   1024
  26
  27
  28 m4 *
  29 m4_create (void)
  30 {
  31   m4 *context = (m4 *) xzalloc (sizeof *context);
  32
  33   context->symtab = m4_symtab_create (0);
  34   context->syntax = m4_syntax_create ();
  35
  36   context->debug_file    = stderr;
  37   obstack_init (&context->trace_messages);
  38
  39   context->nesting_limit = DEFAULT_NESTING_LIMIT;
  40   context->debug_level = M4_DEBUG_TRACE_INITIAL;
  41   context->max_debug_arg_length = SIZE_MAX;
  42
  43   context->search_path =
  44     (m4__search_path_info *) xzalloc (sizeof *context->search_path);
  45   m4__include_init (context);
  46
  47   return context;
  48 }
  49
  50 void
  51 m4_delete (m4 *context)
  52 {
  53   size_t i;
  54   assert (context);
  55
  56   if (context->symtab)
  57     m4_symtab_delete (context->symtab);
  58
  59   if (context->syntax)
  60     m4_syntax_delete (context->syntax);
  61
  62   /* debug_file should have been reset to stdout or stderr, both of
  63      which are closed later.  */
  64   assert (context->debug_file == stderr || context->debug_file == stdout);
  65
  66   obstack_free (&context->trace_messages, NULL);
  67
  68   if (context->search_path)
  69     {
  70       m4__search_path *path = context->search_path->list;
  71
  72       while (path)
  73         {
  74           m4__search_path *stale = path;
  75           path = path->next;
  76
  77           free ((void*) stale->dir);
  78           free (stale);
  79         }
  80       free (context->search_path);
  81     }
  82
  83   for (i = 0; i < context->stacks_count; i++)
  84     {
  85       assert (context->arg_stacks[i].refcount == 0
  86               && context->arg_stacks[i].argcount == 0);
  87       if (context->arg_stacks[i].args)
  88         {
  89           obstack_free (context->arg_stacks[i].args, NULL);
  90           free (context->arg_stacks[i].args);
  91           obstack_free (context->arg_stacks[i].argv, NULL);
  92           free (context->arg_stacks[i].argv);
  93         }
  94     }
  95   free (context->arg_stacks);
  96
  97   free (context);
  98 }
  99
 100
 101 \f
 102 /* Use the preprocessor to generate the repetitive bit twiddling functions
 103    for us.  Note the additional paretheses around the expanded function
 104    name to protect against macro expansion from the fast macros used to
 105    replace these functions when NDEBUG is defined.  */
 106 #define M4FIELD(type, base, field)                                      \
 107         type (CONC(m4_get_, base)) (m4 *context)                        \
 108         {                                                               \
 109           assert (context);                                             \
 110           return context->field;                                        \
 111         }
 112 m4_context_field_table
 113 #undef M4FIELD
 114
 115 #define M4FIELD(type, base, field)                                      \
 116         type (CONC(m4_set_, base)) (m4 *context, type value)            \
 117         {                                                               \
 118           assert (context);                                             \
 119           return context->field = value;                                \
 120         }
 121 m4_context_field_table
 122 #undef M4FIELD
 123
 124 #define M4OPT_BIT(bit, base)                                            \
 125         bool (CONC(m4_get_, base)) (m4 *context)                        \
 126         {                                                               \
 127           assert (context);                                             \
 128           return BIT_TEST (context->opt_flags, (bit));                  \
 129         }
 130 m4_context_opt_bit_table
 131 #undef M4OPT_BIT
 132
 133 #define M4OPT_BIT(bit, base)                                            \
 134         bool (CONC(m4_set_, base)) (m4 *context, bool value)            \
 135         {                                                               \
 136           assert (context);                                             \
 137           if (value)                                                    \
 138              BIT_SET   (context->opt_flags, (bit));                     \
 139           else                                                          \
 140              BIT_RESET (context->opt_flags, (bit));                     \
 141           return value;                                                 \
 142         }
 143 m4_context_opt_bit_table
 144 #undef M4OPT_BIT