m4/m4module.h

   1 /* GNU m4 -- A simple macro processor
   2    Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994, 1999, 2000, 2003,
   3    2004, 2005, 2006, 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 #ifndef M4MODULE_H
  22 #define M4MODULE_H 1
  23
  24 #include <m4/hash.h>
  25 #include <m4/system.h>
  26
  27 BEGIN_C_DECLS
  28
  29
  30 \f
  31 /* --- MODULE AUTHOR DECLARATIONS --- */
  32
  33 typedef struct m4               m4;
  34 typedef struct m4_builtin       m4_builtin;
  35 typedef struct m4_call_info     m4_call_info;
  36 typedef struct m4_macro         m4_macro;
  37 typedef struct m4_macro_args    m4_macro_args;
  38 typedef struct m4_module        m4_module;
  39 typedef struct obstack          m4_obstack;
  40 typedef struct m4_string_pair   m4_string_pair;
  41 typedef struct m4_symbol        m4_symbol;
  42 typedef struct m4_symbol_value  m4_symbol_value;
  43
  44 typedef void   m4_builtin_func  (m4 *, m4_obstack *, size_t, m4_macro_args *);
  45
  46 /* The value of m4_builtin flags is built from these:  */
  47 enum {
  48   /* Set if macro flattens non-text tokens, such as builtin macro
  49      tokens, to the empty string prior to invoking the builtin; if
  50      clear, non-text tokens must be transparently handled by the
  51      builtin.  May only be set if max_args is nonzero.  */
  52   M4_BUILTIN_FLATTEN_ARGS       = (1 << 0),
  53   /* Set if macro should only be recognized with arguments; may only
  54      be set if min_args is nonzero.  */
  55   M4_BUILTIN_BLIND              = (1 << 1),
  56   /* Set if macro has side effects even when there are too few
  57      arguments; may only be set if min_args is nonzero.  */
  58   M4_BUILTIN_SIDE_EFFECT        = (1 << 2),
  59
  60   /* Mask of valid flag bits.  Any other bits must be set to 0.  */
  61   M4_BUILTIN_FLAGS_MASK         = (1 << 3) - 1
  62 };
  63
  64 struct m4_builtin
  65 {
  66   m4_builtin_func * func;       /* implementation of the builtin */
  67   const char *      name;       /* name found by builtin, printed by dumpdef */
  68   int               flags;      /* bitwise OR of M4_BUILTIN_* bits */
  69   size_t            min_args;   /* 0-based minimum number of arguments */
  70   /* max arguments, SIZE_MAX if unlimited; must be >= min_args */
  71   size_t            max_args;
  72 };
  73
  74 struct m4_macro
  75 {
  76   const char *name;
  77   const char *value;
  78   size_t      min_args; /* 0-based minimum number of arguments */
  79   /* max arguments, SIZE_MAX if unlimited; must be >= min_args */
  80   size_t      max_args;
  81 };
  82
  83 /* Describe a pair of strings, such as begin and end quotes.  */
  84 struct m4_string_pair
  85 {
  86   char *str1;           /* First string.  */
  87   size_t len1;          /* First length.  */
  88   char *str2;           /* Second string.  */
  89   size_t len2;          /* Second length.  */
  90 };
  91
  92 /* Declare a prototype for the function "builtin_<NAME>".  Note that
  93    the function name includes any macro expansion of NAME.  */
  94 #define M4BUILTIN(name)                                                 \
  95   static void CONC (builtin_, name)                                     \
  96     (m4 *, m4_obstack *, size_t, m4_macro_args *);
  97
  98 /* Begin the implementation of the function "builtin_<NAME>",
  99    declaring parameter names that can be used by other helper macros
 100    in this file.  Note that the function name includes any macro
 101    expansion of NAME.  */
 102 #define M4BUILTIN_HANDLER(name)                                         \
 103   static void CONC (builtin_, name)                                     \
 104     (m4 *context, m4_obstack *obs, size_t argc, m4_macro_args *argv)
 105
 106 /* Declare a prototype, then begin the implementation of the function
 107    "<NAME>_LTX_m4_init_module", which will automatically be registered
 108    as the initialization function for module NAME.  Note that NAME is
 109    intentionally used literally, rather than subjected to macro
 110    expansion.  */
 111 #define M4INIT_HANDLER(name)                                            \
 112   void name ## _LTX_m4_init_module                                      \
 113     (m4 *, m4_module *, m4_obstack *);                                  \
 114   void name ## _LTX_m4_init_module                                      \
 115     (m4 *context, m4_module *module, m4_obstack *obs)
 116
 117 /* Declare a prototype, then begin the implementation of the function
 118    "<NAME>_LTX_m4_init_module", which will automatically be registered
 119    as the cleanup function for module NAME.  Note that NAME is
 120    intentionally used literally, rather than subjected to macro
 121    expansion.  */
 122 #define M4FINISH_HANDLER(name)                                          \
 123   void name ## _LTX_m4_finish_module                                    \
 124     (m4 *, m4_module *, m4_obstack *);                                  \
 125   void name ## _LTX_m4_finish_module                                    \
 126     (m4 *context, m4_module *module, m4_obstack *obs)
 127
 128 /* Declare a variable S of type "<S>_func" to be a pointer to the
 129    function named S imported from the module M, or NULL if the import
 130    fails.  Note that M and S are intentionally used literally rather
 131    than subjected to macro expansion, in all but the variable name.  */
 132 #define M4_MODULE_IMPORT(M, S)                                          \
 133   S ## _func *S = (S ## _func *) m4_module_import (context, #M, #S, obs)
 134
 135 /* Build an entry in a builtin table, for the builtin N implemented by
 136    the function "builtin_<N>" with name NAME.  Build the flags from
 137    the appropriate combination of M4_BUILTIN_FLAG_* based on M if the
 138    builtin transparently supports macro tokens, B if it is blind, and
 139    S if it has side effects.  Specify that the builtin takes MIN and
 140    MAX arguments.  Note that N is subject to macro expansion, and that
 141    NAME is generally used as #N to avoid clashes with builtins named
 142    after a standard function that is defined as a macro.  */
 143 #define M4BUILTIN_ENTRY(N, NAME, M, B, S, MIN, MAX)     \
 144   {                                                     \
 145     CONC (builtin_, N), NAME,                           \
 146     (((!(M) && (MAX)) ? M4_BUILTIN_FLATTEN_ARGS : 0)    \
 147      | (((B) && (MIN)) ? M4_BUILTIN_BLIND : 0)          \
 148      | (((S) && (MIN)) ? M4_BUILTIN_SIDE_EFFECT : 0)),  \
 149     MIN, MAX                                            \
 150   },
 151
 152 /* Grab the text contents of argument I, or abort if the argument is
 153    not text.  Assumes that `m4 *context' and `m4_macro_args *argv' are
 154    in scope.  */
 155 #define M4ARG(i) m4_arg_text (context, argv, i, false)
 156
 157 /* Grab the length of the text contents of argument I, or abort if the
 158    argument is not text.  Assumes that `m4 *context' and
 159    `m4_macro_args *argv' are in scope.  */
 160 #define M4ARGLEN(i) m4_arg_len (context, argv, i)
 161
 162 extern bool     m4_bad_argc        (m4 *, int, const char *, size_t, size_t,
 163                                     bool);
 164 extern bool     m4_numeric_arg     (m4 *, const char *, const char *, int *);
 165 extern bool     m4_parse_truth_arg (m4 *, const char *, const char *, bool);
 166 extern m4_symbol *m4_symbol_value_lookup (m4 *, const char *,
 167                                           m4_macro_args *, size_t, bool);
 168
 169 /* Error handling.  */
 170 extern void m4_error (m4 *, int, int, const char *, const char *, ...)
 171   M4_GNUC_PRINTF (5, 6);
 172 extern void m4_error_at_line (m4 *, int, int, const char *, int,
 173                               const char *, const char *, ...)
 174   M4_GNUC_PRINTF (7, 8);
 175 extern void m4_warn  (m4 *, int, const char *, const char *, ...)
 176   M4_GNUC_PRINTF (4, 5);
 177 extern void m4_warn_at_line  (m4 *, int, const char *, int, const char *,
 178                               const char *, ...)
 179   M4_GNUC_PRINTF (6, 7);
 180
 181 extern const char *     m4_get_program_name (void);
 182 extern void             m4_set_program_name (const char *);
 183 extern void             m4_set_exit_failure (int);
 184
 185 \f
 186 /* --- CONTEXT MANAGEMENT --- */
 187
 188 typedef struct m4_syntax_table  m4_syntax_table;
 189 typedef struct m4_symbol_table  m4_symbol_table;
 190
 191 extern m4 *             m4_create       (void);
 192 extern void             m4_delete       (m4 *);
 193
 194 #define m4_context_field_table                                          \
 195         M4FIELD(m4_symbol_table *, symbol_table,   symtab)              \
 196         M4FIELD(m4_syntax_table *, syntax_table,   syntax)              \
 197         M4FIELD(const char *,      current_file,   current_file)        \
 198         M4FIELD(int,               current_line,   current_line)        \
 199         M4FIELD(int,               output_line,    output_line)         \
 200         M4FIELD(FILE *,            debug_file,     debug_file)          \
 201         M4FIELD(m4_obstack,        trace_messages, trace_messages)      \
 202         M4FIELD(int,               exit_status,    exit_status)         \
 203         M4FIELD(int,    current_diversion,         current_diversion)   \
 204         M4FIELD(size_t, nesting_limit_opt,         nesting_limit)       \
 205         M4FIELD(int,    debug_level_opt,           debug_level)         \
 206         M4FIELD(size_t, max_debug_arg_length_opt,  max_debug_arg_length)\
 207         M4FIELD(int,    regexp_syntax_opt,         regexp_syntax)       \
 208
 209
 210 #define m4_context_opt_bit_table                                        \
 211         M4OPT_BIT(M4_OPT_PREFIX_BUILTINS_BIT,   prefix_builtins_opt)    \
 212         M4OPT_BIT(M4_OPT_SUPPRESS_WARN_BIT,     suppress_warnings_opt)  \
 213         M4OPT_BIT(M4_OPT_DISCARD_COMMENTS_BIT,  discard_comments_opt)   \
 214         M4OPT_BIT(M4_OPT_INTERACTIVE_BIT,       interactive_opt)        \
 215         M4OPT_BIT(M4_OPT_SYNCOUTPUT_BIT,        syncoutput_opt)         \
 216         M4OPT_BIT(M4_OPT_POSIXLY_CORRECT_BIT,   posixly_correct_opt)    \
 217         M4OPT_BIT(M4_OPT_FATAL_WARN_BIT,        fatal_warnings_opt)     \
 218         M4OPT_BIT(M4_OPT_WARN_EXIT_BIT,         warnings_exit_opt)      \
 219         M4OPT_BIT(M4_OPT_SAFER_BIT,             safer_opt)              \
 220
 221
 222 #define M4FIELD(type, base, field)                                      \
 223         extern type CONC (m4_get_, base) (m4 *context);                 \
 224         extern type CONC (m4_set_, base) (m4 *context, type value);
 225 m4_context_field_table
 226 #undef M4FIELD
 227
 228 #define M4OPT_BIT(bit, base)                                            \
 229   extern bool CONC (m4_get_, base) (m4 *context);                       \
 230   extern bool CONC (m4_set_, base) (m4 *context, bool value);
 231 m4_context_opt_bit_table
 232 #undef M4OPT_BIT
 233
 234 #define M4SYMTAB        (m4_get_symbol_table (context))
 235 #define M4SYNTAX        (m4_get_syntax_table (context))
 236
 237
 238 \f
 239 /* --- MODULE MANAGEMENT --- */
 240
 241 typedef void m4_module_init_func   (m4 *, m4_module *, m4_obstack *);
 242 typedef void m4_module_finish_func (m4 *, m4_module *, m4_obstack *);
 243
 244 extern m4_module *  m4_module_load     (m4 *, const char*, m4_obstack*);
 245 extern const char * m4_module_makeresident (m4_module *);
 246 extern int          m4_module_refcount (const m4_module *);
 247 extern void         m4_module_unload   (m4 *, const char*, m4_obstack*);
 248 extern void *       m4_module_import   (m4 *, const char*, const char*,
 249                                         m4_obstack*);
 250
 251 extern const char * m4_get_module_name (const m4_module *);
 252 extern void         m4__module_exit    (m4 *);
 253
 254
 255 \f
 256 /* --- SYMBOL TABLE MANAGEMENT --- */
 257
 258
 259 typedef void *m4_symtab_apply_func (m4_symbol_table *, const char *,
 260                                     m4_symbol *, void *);
 261
 262 extern m4_symbol_table *m4_symtab_create  (size_t);
 263 extern void       m4_symtab_delete  (m4_symbol_table*);
 264 extern void *     m4_symtab_apply   (m4_symbol_table*, bool,
 265                                      m4_symtab_apply_func*, void*);
 266
 267 extern m4_symbol *m4_symbol_lookup  (m4_symbol_table*, const char *);
 268 extern m4_symbol *m4_symbol_pushdef (m4_symbol_table*,
 269                                      const char *, m4_symbol_value *);
 270 extern m4_symbol *m4_symbol_define  (m4_symbol_table*,
 271                                      const char *, m4_symbol_value *);
 272 extern void       m4_symbol_popdef  (m4_symbol_table*, const char *);
 273 extern m4_symbol *m4_symbol_rename  (m4_symbol_table*, const char *,
 274                                      const char *);
 275
 276 extern void       m4_symbol_delete  (m4_symbol_table*, const char *);
 277
 278 #define m4_symbol_delete(symtab, name)                  M4_STMT_START { \
 279         while (m4_symbol_lookup ((symtab), (name)))                     \
 280             m4_symbol_popdef ((symtab), (name));        } M4_STMT_END
 281
 282 extern m4_symbol_value *m4_get_symbol_value       (m4_symbol*);
 283 extern bool             m4_get_symbol_traced      (m4_symbol*);
 284 extern bool             m4_set_symbol_name_traced (m4_symbol_table*,
 285                                                    const char *, bool);
 286 extern void     m4_symbol_print         (m4 *, m4_symbol *, m4_obstack *,
 287                                          const m4_string_pair *, bool, size_t,
 288                                          bool);
 289 extern bool     m4_symbol_value_flatten_args (m4_symbol_value *);
 290
 291 #define m4_is_symbol_void(symbol)                                       \
 292         (m4_is_symbol_value_void (m4_get_symbol_value (symbol)))
 293 #define m4_is_symbol_text(symbol)                                       \
 294         (m4_is_symbol_value_text (m4_get_symbol_value (symbol)))
 295 #define m4_is_symbol_func(symbol)                                       \
 296         (m4_is_symbol_value_func (m4_get_symbol_value (symbol)))
 297 #define m4_is_symbol_placeholder(symbol)                                \
 298         (m4_is_symbol_value_placeholder (m4_get_symbol_value (symbol)))
 299 #define m4_get_symbol_text(symbol)                                      \
 300         (m4_get_symbol_value_text (m4_get_symbol_value (symbol)))
 301 #define m4_get_symbol_len(symbol)                                       \
 302         (m4_get_symbol_value_len (m4_get_symbol_value (symbol)))
 303 #define m4_get_symbol_func(symbol)                                      \
 304         (m4_get_symbol_value_func (m4_get_symbol_value (symbol)))
 305 #define m4_get_symbol_builtin(symbol)                                   \
 306         (m4_get_symbol_value_builtin (m4_get_symbol_value (symbol)))
 307 #define m4_get_symbol_placeholder(symbol)                               \
 308         (m4_get_symbol_value_placeholder (m4_get_symbol_value (symbol)))
 309 #define m4_symbol_flatten_args(symbol)                                  \
 310         (m4_symbol_value_flatten_args (m4_get_symbol_value (symbol)))
 311
 312 extern m4_symbol_value *m4_symbol_value_create    (void);
 313 extern void             m4_symbol_value_delete    (m4_symbol_value *);
 314 extern bool             m4_symbol_value_copy      (m4 *, m4_symbol_value *,
 315                                                    m4_symbol_value *);
 316 extern bool             m4_is_symbol_value_text   (m4_symbol_value *);
 317 extern bool             m4_is_symbol_value_func   (m4_symbol_value *);
 318 extern bool             m4_is_symbol_value_placeholder  (m4_symbol_value *);
 319 extern bool             m4_is_symbol_value_void   (m4_symbol_value *);
 320
 321 extern const char *     m4_get_symbol_value_text  (m4_symbol_value *);
 322 extern size_t           m4_get_symbol_value_len   (m4_symbol_value *);
 323 extern unsigned int     m4_get_symbol_value_quote_age   (m4_symbol_value *);
 324
 325 extern m4_builtin_func *m4_get_symbol_value_func  (m4_symbol_value *);
 326 extern const m4_builtin *m4_get_symbol_value_builtin    (m4_symbol_value *);
 327 extern const char *     m4_get_symbol_value_placeholder (m4_symbol_value *);
 328
 329 extern void             m4_set_symbol_value_text  (m4_symbol_value *,
 330                                                    const char *, size_t,
 331                                                    unsigned int);
 332 extern void             m4_set_symbol_value_placeholder (m4_symbol_value *,
 333                                                          const char *);
 334
 335
 336 \f
 337 /* --- BUILTIN MANAGEMENT --- */
 338
 339 extern m4_symbol_value  *m4_builtin_find_by_name (m4_module *, const char *);
 340 extern m4_symbol_value  *m4_builtin_find_by_func (m4_module *,
 341                                                   m4_builtin_func *);
 342
 343
 344 \f
 345 /* --- MACRO MANAGEMENT --- */
 346
 347 extern void     m4_macro_expand_input   (m4 *);
 348 extern void     m4_macro_call           (m4 *, m4_symbol_value *, m4_obstack *,
 349                                          m4_macro_args *);
 350 extern size_t   m4_arg_argc             (m4_macro_args *);
 351 extern const m4_call_info *m4_arg_info  (m4_macro_args *);
 352 extern m4_symbol_value *m4_arg_symbol   (m4_macro_args *, size_t);
 353 extern bool     m4_is_arg_text          (m4_macro_args *, size_t);
 354 extern bool     m4_is_arg_func          (m4_macro_args *, size_t);
 355 extern bool     m4_is_arg_composite     (m4_macro_args *, size_t);
 356 extern const char *m4_arg_text          (m4 *, m4_macro_args *, size_t, bool);
 357 extern bool     m4_arg_equal            (m4 *, m4_macro_args *, size_t,
 358                                          size_t);
 359 extern bool     m4_arg_empty            (m4_macro_args *, size_t);
 360 extern size_t   m4_arg_len              (m4 *, m4_macro_args *, size_t);
 361 extern m4_builtin_func *m4_arg_func     (m4_macro_args *, size_t);
 362 extern m4_obstack *m4_arg_scratch       (m4 *);
 363 extern m4_macro_args *m4_make_argv_ref  (m4 *, m4_macro_args *, const char *,
 364                                          size_t, bool, bool);
 365 extern void     m4_push_arg             (m4 *, m4_obstack *, m4_macro_args *,
 366                                          size_t);
 367 extern void     m4_push_args            (m4 *, m4_obstack *, m4_macro_args *,
 368                                          bool, bool);
 369 extern void     m4_wrap_args            (m4 *, m4_macro_args *);
 370
 371 \f
 372 /* --- RUNTIME DEBUGGING --- */
 373
 374 /* The value of debug_level is a bitmask of the following:  */
 375 enum {
 376   /* a: show arglist in trace output */
 377   M4_DEBUG_TRACE_ARGS           = (1 << 0),
 378   /* e: show expansion in trace output */
 379   M4_DEBUG_TRACE_EXPANSION      = (1 << 1),
 380   /* q: quote args and expansion in trace output */
 381   M4_DEBUG_TRACE_QUOTE          = (1 << 2),
 382   /* t: trace all macros -- overrides trace{on,off} */
 383   M4_DEBUG_TRACE_ALL            = (1 << 3),
 384   /* l: add line numbers to trace output */
 385   M4_DEBUG_TRACE_LINE           = (1 << 4),
 386   /* f: add file name to trace output */
 387   M4_DEBUG_TRACE_FILE           = (1 << 5),
 388   /* p: trace path search of include files */
 389   M4_DEBUG_TRACE_PATH           = (1 << 6),
 390   /* c: show macro call before args collection */
 391   M4_DEBUG_TRACE_CALL           = (1 << 7),
 392   /* i: trace changes of input files */
 393   M4_DEBUG_TRACE_INPUT          = (1 << 8),
 394   /* x: add call id to trace output */
 395   M4_DEBUG_TRACE_CALLID         = (1 << 9),
 396   /* m: trace module actions */
 397   M4_DEBUG_TRACE_MODULE         = (1 << 10),
 398   /* s: trace pushdef stacks */
 399   M4_DEBUG_TRACE_STACK          = (1 << 11),
 400
 401   /* V: very verbose --  print everything */
 402   M4_DEBUG_TRACE_VERBOSE        = ((1 << 12) - 1)
 403 };
 404
 405 /* default flags -- equiv: aeq */
 406 #define M4_DEBUG_TRACE_DEFAULT          \
 407         (M4_DEBUG_TRACE_ARGS | M4_DEBUG_TRACE_EXPANSION | M4_DEBUG_TRACE_QUOTE)
 408
 409 #define m4_is_debug_bit(C,B)    ((m4_get_debug_level_opt (C) & (B)) != 0)
 410
 411 extern int      m4_debug_decode         (m4 *, int, const char *);
 412 extern bool     m4_debug_set_output     (m4 *, const char *, const char *);
 413 extern void     m4_debug_message_prefix (m4 *);
 414 extern void     m4_debug_message        (m4 *, int, const char *, ...)
 415   M4_GNUC_PRINTF (3, 4);
 416
 417 extern void     m4_trace_prepare        (m4 *, const m4_call_info *,
 418                                          m4_symbol_value *);
 419
 420 \f
 421 /* --- REGEXP SYNTAX --- */
 422
 423 extern const char *     m4_regexp_syntax_decode (int);
 424 extern int              m4_regexp_syntax_encode (const char *);
 425
 426
 427 \f
 428 /* --- SYNTAX TABLE DEFINITIONS --- */
 429
 430 extern  m4_syntax_table *m4_syntax_create       (void);
 431 extern  void             m4_syntax_delete       (m4_syntax_table *syntax);
 432 extern  int              m4_syntax_code         (char ch);
 433
 434 extern  const char *     m4_get_syntax_lquote   (m4_syntax_table *syntax);
 435 extern  const char *     m4_get_syntax_rquote   (m4_syntax_table *syntax);
 436 extern  const char *     m4_get_syntax_bcomm    (m4_syntax_table *syntax);
 437 extern  const char *     m4_get_syntax_ecomm    (m4_syntax_table *syntax);
 438 extern  const m4_string_pair *m4_get_syntax_quotes      (m4_syntax_table *);
 439 extern  const m4_string_pair *m4_get_syntax_comments    (m4_syntax_table *);
 440
 441 extern  bool             m4_is_syntax_single_quotes     (m4_syntax_table *);
 442 extern  bool             m4_is_syntax_single_comments   (m4_syntax_table *);
 443 extern  bool             m4_is_syntax_macro_escaped     (m4_syntax_table *);
 444
 445 /* These are values to be assigned to syntax table entries.  Although
 446    they are bit masks for fast categorization in m4__next_token(),
 447    only one value per syntax table entry is allowed.  The enumeration
 448    is currently sorted in order of parsing precedence.  */
 449 enum {
 450   M4_SYNTAX_IGNORE              = 0,
 451   M4_SYNTAX_ESCAPE              = 1 << 0,
 452   M4_SYNTAX_ALPHA               = 1 << 1,
 453   M4_SYNTAX_LQUOTE              = 1 << 2,
 454   M4_SYNTAX_BCOMM               = 1 << 3,
 455   M4_SYNTAX_OTHER               = 1 << 4,
 456   M4_SYNTAX_NUM                 = 1 << 5,
 457   M4_SYNTAX_DOLLAR              = 1 << 6,
 458   M4_SYNTAX_LBRACE              = 1 << 7,
 459   M4_SYNTAX_RBRACE              = 1 << 8,
 460   M4_SYNTAX_SPACE               = 1 << 9,
 461   M4_SYNTAX_ACTIVE              = 1 << 10,
 462   M4_SYNTAX_OPEN                = 1 << 11,
 463   M4_SYNTAX_CLOSE               = 1 << 12,
 464   M4_SYNTAX_COMMA               = 1 << 13,
 465
 466   /* These values are bit masks to OR with categories above, a syntax entry
 467      may have any number of these in addition to a maximum of one of the
 468      values above.  */
 469   M4_SYNTAX_RQUOTE              = 1 << 14,
 470   M4_SYNTAX_ECOMM               = 1 << 15
 471 };
 472
 473 #define M4_SYNTAX_MASKS         (M4_SYNTAX_RQUOTE | M4_SYNTAX_ECOMM)
 474 #define M4_SYNTAX_VALUE         (~(M4_SYNTAX_RQUOTE | M4_SYNTAX_ECOMM))
 475
 476 #define m4_syntab(S, C)         ((S)->table[(C)])
 477 /* Determine if character C matches any of the bitwise-or'd syntax
 478    categories T for the given syntax table S.  C can be either an
 479    unsigned int (including special values such as CHAR_BUILTIN) or a
 480    char which will be interpreted as an unsigned char.  */
 481 #define m4_has_syntax(S, C, T)                                          \
 482   ((m4_syntab ((S), sizeof (C) == 1 ? to_uchar (C) : (C)) & (T)) > 0)
 483
 484 extern void     m4_set_quotes   (m4_syntax_table*, const char*, const char*);
 485 extern void     m4_set_comment  (m4_syntax_table*, const char*, const char*);
 486 extern int      m4_set_syntax   (m4_syntax_table*, char, char, const char*);
 487
 488
 489 \f
 490 /* --- INPUT TOKENIZATION --- */
 491
 492 extern  void    m4_input_init   (m4 *context);
 493 extern  void    m4_input_exit   (void);
 494 extern  void    m4_skip_line    (m4 *context, const char *);
 495
 496 /* push back input */
 497
 498 extern  void    m4_push_file    (m4 *, FILE *, const char *, bool);
 499 extern  void    m4_push_builtin (m4 *, m4_obstack *, m4_symbol_value *);
 500 extern  m4_obstack      *m4_push_string_init    (m4 *);
 501 extern  void    m4_push_string_finish   (void);
 502 extern  bool    m4_pop_wrapup   (m4 *);
 503 extern  void    m4_input_print  (m4 *, m4_obstack *, int);
 504
 505
 506 \f
 507 /* --- OUTPUT MANAGEMENT --- */
 508
 509 extern void     m4_output_init          (m4 *);
 510 extern void     m4_output_exit          (void);
 511 extern void     m4_output_text          (m4 *, const char *, size_t);
 512 extern void     m4_divert_text          (m4 *, m4_obstack *, const char *,
 513                                          size_t, int);
 514 extern void     m4_shipout_int          (m4_obstack *, int);
 515 extern void     m4_shipout_string       (m4 *, m4_obstack *, const char *,
 516                                          size_t, bool);
 517 extern bool     m4_shipout_string_trunc (m4_obstack *, const char *, size_t,
 518                                          const m4_string_pair *, size_t *);
 519
 520 extern void     m4_make_diversion    (m4 *, int);
 521 extern void     m4_insert_diversion  (m4 *, int);
 522 extern void     m4_insert_file       (m4 *, FILE *);
 523 extern void     m4_freeze_diversions (m4 *, FILE *);
 524 extern void     m4_undivert_all      (m4 *);
 525
 526
 527 \f
 528 /* --- PATH MANAGEMENT --- */
 529
 530 extern void     m4_include_env_init      (m4 *);
 531 extern void     m4_add_include_directory (m4 *, const char *, bool);
 532 extern FILE *   m4_path_search           (m4 *, const char *, char **);
 533
 534
 535 \f
 536 #define obstack_chunk_alloc     xmalloc
 537 #define obstack_chunk_free      free
 538
 539 \f
 540 /* Convert a possibly-signed character to an unsigned character.  This is
 541    a bit safer than casting to unsigned char, since it catches some type
 542    errors that the cast doesn't.  */
 543 #if HAVE_INLINE
 544 static inline unsigned char to_uchar (char ch) { return ch; }
 545 #else
 546 # define to_uchar(C) ((unsigned char) (C))
 547 #endif
 548
 549 END_C_DECLS
 550
 551 #endif /* !M4MODULE_H */