/* GNU m4 -- A simple macro processor
   Copyright (C) 1989-1994, 1999-2000, 2003-2010, 2013 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/>.
*/

#ifndef M4MODULE_H
#define M4MODULE_H 1

#include <m4/hash.h>
#include <m4/system.h>

BEGIN_C_DECLS



/* --- MODULE AUTHOR DECLARATIONS --- */

typedef struct m4               m4;
typedef struct m4_builtin       m4_builtin;
typedef struct m4_call_info     m4_call_info;
typedef struct m4_macro         m4_macro;
typedef struct m4_macro_args    m4_macro_args;
typedef struct m4_module        m4_module;
typedef struct obstack          m4_obstack;
typedef struct m4_string        m4_string;
typedef struct m4_string_pair   m4_string_pair;
typedef struct m4_symbol        m4_symbol;
typedef struct m4_symbol_value  m4_symbol_value;

typedef void   m4_builtin_func  (m4 *, m4_obstack *, size_t, m4_macro_args *);

/* The value of m4_builtin flags is built from these:  */
enum {
  /* Set if macro flattens non-text tokens, such as builtin macro
     tokens, to the empty string prior to invoking the builtin; if
     clear, non-text tokens must be transparently handled by the
     builtin.  May only be set if max_args is nonzero.  */
  M4_BUILTIN_FLATTEN_ARGS       = (1 << 0),
  /* Set if macro should only be recognized with arguments; may only
     be set if min_args is nonzero.  */
  M4_BUILTIN_BLIND              = (1 << 1),
  /* Set if macro has side effects even when there are too few
     arguments; may only be set if min_args is nonzero.  */
  M4_BUILTIN_SIDE_EFFECT        = (1 << 2),

  /* Mask of valid flag bits.  Any other bits must be set to 0.  */
  M4_BUILTIN_FLAGS_MASK         = (1 << 3) - 1
};

struct m4_builtin
{
  m4_builtin_func * func;       /* implementation of the builtin */
  const char *      name;       /* name found by builtin, printed by dumpdef */
  int               flags;      /* bitwise OR of M4_BUILTIN_* bits */
  size_t            min_args;   /* 0-based minimum number of arguments */
  /* max arguments, SIZE_MAX if unlimited; must be >= min_args */
  size_t            max_args;
};

struct m4_macro
{
  const char *name;
  const char *value;
  size_t      min_args; /* 0-based minimum number of arguments */
  /* max arguments, SIZE_MAX if unlimited; must be >= min_args */
  size_t      max_args;
};

/* Describe a single string, such as a macro name.  */
struct m4_string
{
  char *str;            /* Array of characters, possibly including NUL.  */
  size_t len;           /* Length of string.  */
};

/* Describe a pair of strings, such as begin and end quotes.  */
struct m4_string_pair
{
  char *str1;           /* First string.  */
  size_t len1;          /* First length.  */
  char *str2;           /* Second string.  */
  size_t len2;          /* Second length.  */
};

/* Declare a prototype for the function "builtin_<NAME>".  Note that
   the function name includes any macro expansion of NAME.  */
#define M4BUILTIN(name)                                                 \
  static void CONC (builtin_, name)                                     \
    (m4 *, m4_obstack *, size_t, m4_macro_args *);

/* Begin the implementation of the function "builtin_<NAME>",
   declaring parameter names that can be used by other helper macros
   in this file.  Note that the function name includes any macro
   expansion of NAME.  */
#define M4BUILTIN_HANDLER(name)                                         \
  static void CONC (builtin_, name)                                     \
    (m4 *context, m4_obstack *obs, size_t argc, m4_macro_args *argv)

/* Declare a variable S of type "<S>_func" to be a pointer to the
   function named S imported from the module M, or NULL if the import
   fails.  Note that M and S are intentionally used literally rather
   than subjected to macro expansion, in all but the variable name.  */
#define M4_MODULE_IMPORT(M, S)                                          \
  S ## _func *S = (S ## _func *) m4_module_import (context, #M, #S, obs)

/* Build an entry in a builtin table, for the builtin N implemented by
   the function "builtin_<N>" with name NAME.  Build the flags from
   the appropriate combination of M4_BUILTIN_FLAG_* based on M if the
   builtin transparently supports macro tokens, B if it is blind, and
   S if it has side effects.  Specify that the builtin takes MIN and
   MAX arguments.  Note that N is subject to macro expansion, and that
   NAME is generally used as #N to avoid clashes with builtins named
   after a standard function that is defined as a macro.  */
#define M4BUILTIN_ENTRY(N, NAME, M, B, S, MIN, MAX)     \
  {                                                     \
    CONC (builtin_, N), NAME,                           \
    (((!(M) && (MAX)) ? M4_BUILTIN_FLATTEN_ARGS : 0)    \
     | (((B) && (MIN)) ? M4_BUILTIN_BLIND : 0)          \
     | (((S) && (MIN)) ? M4_BUILTIN_SIDE_EFFECT : 0)),  \
    MIN, MAX                                            \
  },

/* Grab the text contents of argument I, or abort if the argument is
   not text.  Assumes that `m4 *context' and `m4_macro_args *argv' are
   in scope.  */
#define M4ARG(i) m4_arg_text (context, argv, i, false)

/* Grab the length of the text contents of argument I, or abort if the
   argument is not text.  Assumes that `m4 *context' and
   `m4_macro_args *argv' are in scope.  */
#define M4ARGLEN(i) m4_arg_len (context, argv, i, false)

extern bool     m4_bad_argc        (m4 *, size_t, const m4_call_info *, size_t,
                                    size_t, bool);
extern bool     m4_numeric_arg     (m4 *, const m4_call_info *, const char *,
                                    size_t, int *);
extern bool     m4_parse_truth_arg (m4 *, const m4_call_info *, const char *,
                                    size_t, bool);
extern m4_symbol *m4_symbol_value_lookup (m4 *, m4_macro_args *, size_t, bool);
extern const char *m4_info_name    (const m4_call_info *);

/* Error handling.  */
extern void m4_error (m4 *, int, int, const m4_call_info *, const char *, ...)
  M4_GNUC_PRINTF (5, 6);
extern void m4_warn  (m4 *, int, const m4_call_info *, const char *, ...)
  M4_GNUC_PRINTF (4, 5);

extern const char *     m4_get_program_name (void);
extern void             m4_set_program_name (const char *);
extern void             m4_set_exit_failure (int);


/* --- CONTEXT MANAGEMENT --- */

typedef struct m4_syntax_table  m4_syntax_table;
typedef struct m4_symbol_table  m4_symbol_table;

extern m4 *             m4_create       (void);
extern void             m4_delete       (m4 *);

#define m4_context_field_table                                          \
        M4FIELD(m4_symbol_table *, symbol_table,   symtab)              \
        M4FIELD(m4_syntax_table *, syntax_table,   syntax)              \
        M4FIELD(const char *,      current_file,   current_file)        \
        M4FIELD(int,               current_line,   current_line)        \
        M4FIELD(int,               output_line,    output_line)         \
        M4FIELD(FILE *,            debug_file,     debug_file)          \
        M4FIELD(m4_obstack,        trace_messages, trace_messages)      \
        M4FIELD(int,               exit_status,    exit_status)         \
        M4FIELD(int,    current_diversion,         current_diversion)   \
        M4FIELD(size_t, nesting_limit_opt,         nesting_limit)       \
        M4FIELD(int,    debug_level_opt,           debug_level)         \
        M4FIELD(size_t, max_debug_arg_length_opt,  max_debug_arg_length)\
        M4FIELD(int,    regexp_syntax_opt,         regexp_syntax)       \


#define m4_context_opt_bit_table                                        \
        M4OPT_BIT(M4_OPT_PREFIX_BUILTINS_BIT,   prefix_builtins_opt)    \
        M4OPT_BIT(M4_OPT_SUPPRESS_WARN_BIT,     suppress_warnings_opt)  \
        M4OPT_BIT(M4_OPT_DISCARD_COMMENTS_BIT,  discard_comments_opt)   \
        M4OPT_BIT(M4_OPT_INTERACTIVE_BIT,       interactive_opt)        \
        M4OPT_BIT(M4_OPT_SYNCOUTPUT_BIT,        syncoutput_opt)         \
        M4OPT_BIT(M4_OPT_POSIXLY_CORRECT_BIT,   posixly_correct_opt)    \
        M4OPT_BIT(M4_OPT_FATAL_WARN_BIT,        fatal_warnings_opt)     \
        M4OPT_BIT(M4_OPT_WARN_EXIT_BIT,         warnings_exit_opt)      \
        M4OPT_BIT(M4_OPT_SAFER_BIT,             safer_opt)              \


#define M4FIELD(type, base, field)                                      \
        extern type CONC (m4_get_, base) (m4 *context);                 \
        extern type CONC (m4_set_, base) (m4 *context, type value);
m4_context_field_table
#undef M4FIELD

#define M4OPT_BIT(bit, base)                                            \
  extern bool CONC (m4_get_, base) (m4 *context);                       \
  extern bool CONC (m4_set_, base) (m4 *context, bool value);
m4_context_opt_bit_table
#undef M4OPT_BIT

#define M4SYMTAB        (m4_get_symbol_table (context))
#define M4SYNTAX        (m4_get_syntax_table (context))



/* --- MODULE MANAGEMENT --- */

typedef void m4_module_init_func   (m4 *, m4_module *, m4_obstack *);

extern m4_module *  m4_module_load     (m4 *, const char *, m4_obstack *);
extern void *       m4_module_import   (m4 *, const char *, const char *,
                                        m4_obstack *);

extern void         m4_install_builtins (m4*, m4_module *, const m4_builtin*);
extern void         m4_install_macros   (m4*, m4_module *, const m4_macro*);

extern const char * m4_get_module_name (const m4_module *);
extern m4_module *  m4_module_next     (m4*, m4_module *);



/* --- SYMBOL TABLE MANAGEMENT --- */


typedef void *m4_symtab_apply_func (m4_symbol_table *, const char *, size_t,
                                    m4_symbol *, void *);

extern m4_symbol_table *m4_symtab_create  (size_t);
extern void       m4_symtab_delete  (m4_symbol_table *);
extern void *     m4_symtab_apply   (m4_symbol_table *, bool,
                                     m4_symtab_apply_func *, void *);

extern m4_symbol *m4_symbol_lookup  (m4_symbol_table *, const char *, size_t);
extern m4_symbol *m4_symbol_pushdef (m4_symbol_table *, const char *, size_t,
                                     m4_symbol_value *);
extern m4_symbol *m4_symbol_define  (m4_symbol_table *, const char *, size_t,
                                     m4_symbol_value *);
extern void       m4_symbol_popdef  (m4_symbol_table *, const char *, size_t);
extern m4_symbol *m4_symbol_rename  (m4_symbol_table *, const char *, size_t,
                                     const char *, size_t);

extern void       m4_symbol_delete  (m4_symbol_table *, const char *, size_t);

#define m4_symbol_delete(symtab, name, len)             M4_STMT_START   \
  {                                                                     \
    while (m4_symbol_lookup (symtab, name, len))                        \
      m4_symbol_popdef (symtab, name, len);                             \
  } M4_STMT_END

extern m4_symbol_value *m4_get_symbol_value       (m4_symbol *);
extern bool             m4_get_symbol_traced      (m4_symbol *);
extern bool             m4_set_symbol_name_traced (m4_symbol_table *,
                                                   const char *, size_t, bool);
extern void     m4_symbol_print         (m4 *, m4_symbol *, m4_obstack *,
                                         const m4_string_pair *, bool, size_t,
                                         bool);
extern bool     m4_symbol_value_flatten_args (m4_symbol_value *);

#define m4_is_symbol_void(symbol)                                       \
        (m4_is_symbol_value_void (m4_get_symbol_value (symbol)))
#define m4_is_symbol_text(symbol)                                       \
        (m4_is_symbol_value_text (m4_get_symbol_value (symbol)))
#define m4_is_symbol_func(symbol)                                       \
        (m4_is_symbol_value_func (m4_get_symbol_value (symbol)))
#define m4_is_symbol_placeholder(symbol)                                \
        (m4_is_symbol_value_placeholder (m4_get_symbol_value (symbol)))
#define m4_get_symbol_text(symbol)                                      \
        (m4_get_symbol_value_text (m4_get_symbol_value (symbol)))
#define m4_get_symbol_len(symbol)                                       \
        (m4_get_symbol_value_len (m4_get_symbol_value (symbol)))
#define m4_get_symbol_func(symbol)                                      \
        (m4_get_symbol_value_func (m4_get_symbol_value (symbol)))
#define m4_get_symbol_builtin(symbol)                                   \
        (m4_get_symbol_value_builtin (m4_get_symbol_value (symbol)))
#define m4_get_symbol_placeholder(symbol)                               \
        (m4_get_symbol_value_placeholder (m4_get_symbol_value (symbol)))
#define m4_symbol_flatten_args(symbol)                                  \
        (m4_symbol_value_flatten_args (m4_get_symbol_value (symbol)))

extern m4_symbol_value *m4_symbol_value_create    (void);
extern void             m4_symbol_value_delete    (m4_symbol_value *);
extern bool             m4_symbol_value_copy      (m4 *, m4_symbol_value *,
                                                   m4_symbol_value *);
extern bool             m4_is_symbol_value_text   (m4_symbol_value *);
extern bool             m4_is_symbol_value_func   (m4_symbol_value *);
extern bool             m4_is_symbol_value_placeholder  (m4_symbol_value *);
extern bool             m4_is_symbol_value_void   (m4_symbol_value *);

extern const char *     m4_get_symbol_value_text  (m4_symbol_value *);
extern size_t           m4_get_symbol_value_len   (m4_symbol_value *);
extern unsigned int     m4_get_symbol_value_quote_age   (m4_symbol_value *);

extern m4_builtin_func *m4_get_symbol_value_func  (m4_symbol_value *);
extern const m4_builtin *m4_get_symbol_value_builtin    (m4_symbol_value *);
extern const char *     m4_get_symbol_value_placeholder (m4_symbol_value *);

extern void             m4_set_symbol_value_text  (m4_symbol_value *,
                                                   const char *, size_t,
                                                   unsigned int);
extern void             m4_set_symbol_value_placeholder (m4_symbol_value *,
                                                         const char *);



/* --- BUILTIN MANAGEMENT --- */

extern m4_symbol_value  *m4_builtin_find_by_name (m4 *, m4_module *, const char *);
extern m4_symbol_value  *m4_builtin_find_by_func (m4 *, m4_module *,
                                                  m4_builtin_func *);



/* --- MACRO MANAGEMENT --- */

extern void     m4_macro_expand_input   (m4 *);
extern void     m4_macro_call           (m4 *, m4_symbol_value *, m4_obstack *,
                                         m4_macro_args *);
extern size_t   m4_arg_argc             (m4_macro_args *);
extern const m4_call_info *m4_arg_info  (m4_macro_args *);
extern m4_symbol_value *m4_arg_symbol   (m4_macro_args *, size_t);
extern bool     m4_is_arg_text          (m4_macro_args *, size_t);
extern bool     m4_is_arg_func          (m4_macro_args *, size_t);
extern bool     m4_is_arg_composite     (m4_macro_args *, size_t);
extern const char *m4_arg_text          (m4 *, m4_macro_args *, size_t, bool);
extern bool     m4_arg_equal            (m4 *, m4_macro_args *, size_t,
                                         size_t);
extern bool     m4_arg_empty            (m4_macro_args *, size_t);
extern size_t   m4_arg_len              (m4 *, m4_macro_args *, size_t, bool);
extern m4_builtin_func *m4_arg_func     (m4_macro_args *, size_t);
extern m4_obstack *m4_arg_scratch       (m4 *);
extern m4_macro_args *m4_make_argv_ref  (m4 *, m4_macro_args *, const char *,
                                         size_t, bool, bool);
extern void     m4_push_arg             (m4 *, m4_obstack *, m4_macro_args *,
                                         size_t);
extern void     m4_push_args            (m4 *, m4_obstack *, m4_macro_args *,
                                         bool, bool);
extern void     m4_wrap_args            (m4 *, m4_macro_args *);


/* --- RUNTIME DEBUGGING --- */

/* The value of debug_level is a bitmask of the following:  */
enum {
  /* a: show arglist in trace output */
  M4_DEBUG_TRACE_ARGS           = (1 << 0),
  /* e: show expansion in trace output */
  M4_DEBUG_TRACE_EXPANSION      = (1 << 1),
  /* q: quote args and expansion in trace output */
  M4_DEBUG_TRACE_QUOTE          = (1 << 2),
  /* t: trace all macros -- overrides trace{on,off} */
  M4_DEBUG_TRACE_ALL            = (1 << 3),
  /* l: add line numbers to trace output */
  M4_DEBUG_TRACE_LINE           = (1 << 4),
  /* f: add file name to trace output */
  M4_DEBUG_TRACE_FILE           = (1 << 5),
  /* p: trace path search of include files */
  M4_DEBUG_TRACE_PATH           = (1 << 6),
  /* c: show macro call before args collection */
  M4_DEBUG_TRACE_CALL           = (1 << 7),
  /* i: trace changes of input files */
  M4_DEBUG_TRACE_INPUT          = (1 << 8),
  /* x: add call id to trace output */
  M4_DEBUG_TRACE_CALLID         = (1 << 9),
  /* m: trace module actions */
  M4_DEBUG_TRACE_MODULE         = (1 << 10),
  /* s: trace pushdef stacks */
  M4_DEBUG_TRACE_STACK          = (1 << 11),
  /* d: warn if dereferencing undefined macro */
  M4_DEBUG_TRACE_DEREF          = (1 << 12),
  /* o: output dumpdef to stderr, not debug file */
  M4_DEBUG_TRACE_OUTPUT_DUMPDEF = (1 << 13),

  /* V: very verbose --  print everything */
  M4_DEBUG_TRACE_VERBOSE        = ((1 << 14) - 1)
};

/* initial flags, used if no -d or -E -- equiv: d */
#define M4_DEBUG_TRACE_INITIAL M4_DEBUG_TRACE_DEREF

/* default flags, used by debugmode() -- equiv: +adeq */
#define M4_DEBUG_TRACE_DEFAULT                          \
        (M4_DEBUG_TRACE_ARGS | M4_DEBUG_TRACE_EXPANSION \
         | M4_DEBUG_TRACE_QUOTE | M4_DEBUG_TRACE_DEREF)

#define m4_is_debug_bit(C,B)    ((m4_get_debug_level_opt (C) & (B)) != 0)

extern int      m4_debug_decode         (m4 *, const char *, size_t);
extern bool     m4_debug_set_output     (m4 *, const m4_call_info *,
                                         const char *);
extern void     m4_debug_message_prefix (m4 *);
extern void     m4_debug_message        (m4 *, int, const char *, ...)
  M4_GNUC_PRINTF (3, 4);

extern void     m4_trace_prepare        (m4 *, const m4_call_info *,
                                         m4_symbol_value *);


/* --- REGEXP SYNTAX --- */

extern const char *     m4_regexp_syntax_decode (int);
extern int              m4_regexp_syntax_encode (const char *);



/* --- SYNTAX TABLE DEFINITIONS --- */

extern  m4_syntax_table *m4_syntax_create       (void);
extern  void             m4_syntax_delete       (m4_syntax_table *syntax);
extern  int              m4_syntax_code         (char ch);

extern  const char *     m4_get_syntax_lquote   (m4_syntax_table *syntax);
extern  const char *     m4_get_syntax_rquote   (m4_syntax_table *syntax);
extern  const char *     m4_get_syntax_bcomm    (m4_syntax_table *syntax);
extern  const char *     m4_get_syntax_ecomm    (m4_syntax_table *syntax);
extern  const m4_string_pair *m4_get_syntax_quotes      (m4_syntax_table *);
extern  const m4_string_pair *m4_get_syntax_comments    (m4_syntax_table *);

extern  bool             m4_is_syntax_single_quotes     (m4_syntax_table *);
extern  bool             m4_is_syntax_single_comments   (m4_syntax_table *);
extern  bool             m4_is_syntax_single_dollar     (m4_syntax_table *);
extern  bool             m4_is_syntax_macro_escaped     (m4_syntax_table *);

/* These are values to be assigned to syntax table entries.  Although
   they are bit masks for fast categorization in m4__next_token(),
   only one value per syntax table entry is allowed.  The enumeration
   is currently sorted in order of parsing precedence.  */
enum {
  M4_SYNTAX_IGNORE              = 0,
  M4_SYNTAX_ESCAPE              = 1 << 0,
  M4_SYNTAX_ALPHA               = 1 << 1,
  M4_SYNTAX_LQUOTE              = 1 << 2,
  M4_SYNTAX_BCOMM               = 1 << 3,
  M4_SYNTAX_ACTIVE              = 1 << 4,
  M4_SYNTAX_NUM                 = 1 << 5,
  M4_SYNTAX_SPACE               = 1 << 6,
  M4_SYNTAX_OPEN                = 1 << 7,
  M4_SYNTAX_CLOSE               = 1 << 8,
  M4_SYNTAX_COMMA               = 1 << 9,
  M4_SYNTAX_OTHER               = 1 << 10,

  /* These values are bit masks to OR with categories above, a syntax entry
     may have any number of these in addition to a maximum of one of the
     values above.  */
  M4_SYNTAX_DOLLAR              = 1 << 11,
  M4_SYNTAX_LBRACE              = 1 << 12,
  M4_SYNTAX_RBRACE              = 1 << 13,
  M4_SYNTAX_RQUOTE              = 1 << 14,
  M4_SYNTAX_ECOMM               = 1 << 15
};

/* Mask of attribute syntax categories.  */
#define M4_SYNTAX_MASKS         (M4_SYNTAX_RQUOTE | M4_SYNTAX_ECOMM     \
                                 | M4_SYNTAX_DOLLAR | M4_SYNTAX_LBRACE  \
                                 | M4_SYNTAX_RBRACE)
/* Mask of basic syntax categories where any change requires a
   recomputation of the overall syntax characteristics.  */
#define M4_SYNTAX_SUSPECT       (M4_SYNTAX_LQUOTE | M4_SYNTAX_BCOMM     \
                                 | M4_SYNTAX_ESCAPE)

#define m4_syntab(S, C)         ((S)->table[(C)])
/* Determine if character C matches any of the bitwise-or'd syntax
   categories T for the given syntax table S.  C can be either an
   unsigned int (including special values such as CHAR_BUILTIN) or a
   char which will be interpreted as an unsigned char.  */
#define m4_has_syntax(S, C, T)                                          \
  ((m4_syntab ((S), sizeof (C) == 1 ? to_uchar (C) : (C)) & (T)) > 0)

extern void     m4_set_quotes   (m4_syntax_table *, const char *, size_t,
                                 const char *, size_t);
extern void     m4_set_comment  (m4_syntax_table *, const char *, size_t,
                                 const char *, size_t);
extern int      m4_set_syntax   (m4_syntax_table *, char, char, const char *,
                                 size_t);
extern void     m4_reset_syntax (m4_syntax_table *);



/* --- INPUT TOKENIZATION --- */

extern  void    m4_input_init   (m4 *context);
extern  void    m4_input_exit   (void);
extern  void    m4_skip_line    (m4 *context, const m4_call_info *);

/* push back input */

extern  void    m4_push_file    (m4 *, FILE *, const char *, bool);
extern  void    m4_push_builtin (m4 *, m4_obstack *, m4_symbol_value *);
extern  m4_obstack      *m4_push_string_init    (m4 *, const char *, int);
extern  void    m4_push_string_finish   (void);
extern  bool    m4_pop_wrapup   (m4 *);
extern  void    m4_input_print  (m4 *, m4_obstack *, int);



/* --- OUTPUT MANAGEMENT --- */

extern void     m4_output_init          (m4 *);
extern void     m4_output_exit          (void);
extern void     m4_output_text          (m4 *, const char *, size_t);
extern void     m4_divert_text          (m4 *, m4_obstack *, const char *,
                                         size_t, int);
extern void     m4_shipout_int          (m4_obstack *, int);
extern void     m4_shipout_string       (m4 *, m4_obstack *, const char *,
                                         size_t, bool);
extern bool     m4_shipout_string_trunc (m4_obstack *, const char *, size_t,
                                         const m4_string_pair *, size_t *);

extern void     m4_make_diversion    (m4 *, int);
extern void     m4_insert_diversion  (m4 *, int);
extern void     m4_insert_file       (m4 *, FILE *);
extern void     m4_freeze_diversions (m4 *, FILE *);
extern void     m4_undivert_all      (m4 *);



/* --- PATH MANAGEMENT --- */

extern void	m4_add_include_directory (m4 *, const char *, bool);
extern bool	m4_load_filename	 (m4 *, const m4_call_info *,
					  const char *, m4_obstack *, bool);
extern char *   m4_path_search		 (m4 *, const char *, const char **);
extern FILE *	m4_fopen		 (m4 *, const char *, const char *);



#define obstack_chunk_alloc     xmalloc
#define obstack_chunk_free      free


/* Convert a possibly-signed character to an unsigned character.  This is
   a bit safer than casting to unsigned char, since it catches some type
   errors that the cast doesn't.  */
#if HAVE_INLINE
static inline unsigned char to_uchar (char ch) { return ch; }
#else
# define to_uchar(C) ((unsigned char) (C))
#endif

END_C_DECLS

#endif /* !M4MODULE_H */