Google Git
Sign in
gnu / m4 / d69fa5284851b2b7aac25ffac638b6b379994db5 / . / modules / gnu.c
blob: 334ab67dcb24936fddf35aa8574a8ae38a50d824 [file] [log] [blame]
/* GNU m4 -- A simple macro processor
Copyright (C) 2000, 2004-2010, 2013-2014, 2017 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/>.
*/
#include <config.h>
/* Build using only the exported interfaces, unles NDEBUG is set, in
which case use private symbols to speed things up as much as possible. */
#ifndef NDEBUG
# include <m4/m4module.h>
#else
# include "m4private.h"
#endif
#include "modules/m4.h"
#include "quotearg.h"
#include "spawn-pipe.h"
#include "wait-process.h"
/* Maintain each of the builtins implemented in this modules along
with their details in a single table for easy maintenance.
function macros blind side minargs maxargs */
#define builtin_functions \
BUILTIN (__file__, false, false, false, 0, 0 ) \
BUILTIN (__line__, false, false, false, 0, 0 ) \
BUILTIN (__program__, false, false, false, 0, 0 ) \
BUILTIN (builtin, true, true, false, 1, -1 ) \
BUILTIN (changeresyntax,false,true, false, 1, 1 ) \
BUILTIN (changesyntax,false, true, false, 1, -1 ) \
BUILTIN (debugfile, false, false, false, 0, 1 ) \
BUILTIN (debuglen, false, true, false, 1, 1 ) \
BUILTIN (debugmode, false, false, false, 0, 1 ) \
BUILTIN (esyscmd, false, true, true, 1, 1 ) \
BUILTIN (format, false, true, false, 1, -1 ) \
BUILTIN (indir, true, true, false, 1, -1 ) \
BUILTIN (mkdtemp, false, true, false, 1, 1 ) \
BUILTIN (patsubst, false, true, true, 2, 4 ) \
BUILTIN (regexp, false, true, true, 2, 4 ) \
BUILTIN (renamesyms, false, true, false, 2, 3 ) \
BUILTIN (m4modules, false, false, false, 0, 0 ) \
BUILTIN (m4symbols, true, false, false, 0, -1 ) \
BUILTIN (syncoutput, false, true, false, 1, 1 ) \
/* Generate prototypes for each builtin handler function. */
#define BUILTIN(handler, macros, blind, side, min, max) M4BUILTIN (handler)
builtin_functions
#undef BUILTIN
/* Generate a table for mapping m4 symbol names to handler functions. */
static const m4_builtin m4_builtin_table[] =
{
#define BUILTIN(handler, macros, blind, side, min, max) \
M4BUILTIN_ENTRY (handler, #handler, macros, blind, side, min, max)
builtin_functions
#undef BUILTIN
{ NULL, NULL, 0, 0, 0 },
};
/* A table for mapping m4 symbol names to simple expansion text. */
static const m4_macro m4_macro_table[] =
{
/* name text min max */
#if UNIX
{ "__unix__", "", 0, 0 },
#endif
#if W32_NATIVE
{ "__windows__", "", 0, 0 },
#endif
#if OS2
{ "__os2__", "", 0, 0 },
#endif
{ "__gnu__", "", 0, 0 },
{ "__m4_version__", VERSION,0, 0 },
{ NULL, NULL, 0, 0 },
};
void
include_gnu (m4 *context, m4_module *module, m4_obstack *obs)
{
m4_install_builtins (context, module, m4_builtin_table);
m4_install_macros (context, module, m4_macro_table);
}
/* Regular expressions. Reuse re_registers among multiple
re_pattern_buffer allocations to reduce malloc usage. */
/* Maybe this is worth making runtime tunable. Too small, and nothing
gets cached because the working set of active regex is larger than
the cache, and we are always swapping out entries. Too large, and
the time spent searching the cache for a match overtakes the time
saved by caching. For now, this size proved reasonable for the
typical working set of Autoconf 2.62. */
#define REGEX_CACHE_SIZE 16
/* Structure for using a compiled regex, as well as making it easier
to cache frequently used expressions. */
typedef struct {
unsigned count; /* usage counter */
int resyntax; /* flavor of regex */
size_t len; /* length of string */
char *str; /* copy of compiled string */
struct re_pattern_buffer *pat; /* compiled regex, allocated */
struct re_registers regs; /* match registers, reused */
} m4_pattern_buffer;
/* Storage for the cache of regular expressions. */
static m4_pattern_buffer regex_cache[REGEX_CACHE_SIZE];
/* Compile a REGEXP of length LEN using the RESYNTAX flavor, and
return the buffer. On error, report the problem on behalf of
CALLER, and return NULL. */
static m4_pattern_buffer *
regexp_compile (m4 *context, const m4_call_info *caller, const char *regexp,
size_t len, int resyntax)
{
/* regex_cache is guaranteed to start life 0-initialized, which
works in the algorithm below.
FIXME - this method is not reentrant, since re_compile_pattern
mallocs memory, depends on the global variable re_syntax_options
for its syntax (but at least the compiled regex remembers its
syntax even if the global variable changes later), and since we
use a static variable. To be reentrant, we would need a mutex in
this method, and move the storage for regex_cache into context. */
const char *msg; /* error message from re_compile_pattern */
int i; /* iterator */
m4_pattern_buffer *victim; /* cache slot to replace */
unsigned victim_count; /* track which victim to replace */
struct re_pattern_buffer *pat;/* newly compiled regex */
/* First, check if REGEXP is already cached with the given RESYNTAX.
If so, increase its use count and return it. */
for (i = 0; i < REGEX_CACHE_SIZE; i++)
if (len == regex_cache[i].len && resyntax == regex_cache[i].resyntax
&& regex_cache[i].str && memcmp (regexp, regex_cache[i].str, len) == 0)
{
regex_cache[i].count++;
return &regex_cache[i];
}
/* Next, check if REGEXP can be compiled. */
pat = (struct re_pattern_buffer *) xzalloc (sizeof *pat);
re_set_syntax (resyntax);
msg = re_compile_pattern (regexp, len, pat);
if (msg != NULL)
{
m4_warn (context, 0, caller, _("bad regular expression %s: %s"),
quotearg_style_mem (locale_quoting_style, regexp, len), msg);
regfree (pat);
free (pat);
return NULL;
}
/* Use a fastmap for speed; it is freed by regfree. */
pat->fastmap = xcharalloc (UCHAR_MAX + 1);
/* Now, find a victim slot. Decrease the count of all entries, then
prime the count of the victim slot at REGEX_CACHE_SIZE. This
way, frequently used entries and newly created entries are least
likely to be victims next time we have a cache miss. */
victim = regex_cache;
victim_count = victim->count;
if (victim_count)
victim->count--;
for (i = 1; i < REGEX_CACHE_SIZE; i++)
{
if (regex_cache[i].count < victim_count)
{
victim_count = regex_cache[i].count;
victim = &regex_cache[i];
}
if (regex_cache[i].count)
regex_cache[i].count--;
}
victim->count = REGEX_CACHE_SIZE;
victim->resyntax = resyntax;
victim->len = len;
if (victim->str)
{
free (victim->str);
regfree (victim->pat);
free (victim->pat);
}
victim->str = xstrdup (regexp);
victim->pat = pat;
re_set_registers (pat, &victim->regs, victim->regs.num_regs,
victim->regs.start, victim->regs.end);
return victim;
}
/* Wrap up GNU Regex re_search call to work with an m4_pattern_buffer.
If NO_SUB, then storing matches in buf->regs is not necessary. */
static regoff_t
regexp_search (m4_pattern_buffer *buf, const char *string, const int size,
const int start, const int range, bool no_sub)
{
return re_search (buf->pat, string, size, start, range,
no_sub ? NULL : &buf->regs);
}
/* Function to perform substitution by regular expressions. Used by
the builtins regexp, patsubst and renamesyms. The changed text is
placed on the obstack OBS. The substitution is REPL of length
REPL_LEN, with \& substituted by this part of VICTIM matched by the
last whole regular expression, and \N substituted by the text
matched by the Nth parenthesized sub-expression in BUF. Any
warnings are issued on behalf of CALLER. BUF may be NULL for the
empty regex. */
static void
substitute (m4 *context, m4_obstack *obs, const m4_call_info *caller,
const char *victim, const char *repl, size_t repl_len,
m4_pattern_buffer *buf)
{
int ch;
while (1)
{
const char *backslash = (char *) memchr (repl, '\\', repl_len);
if (!backslash)
{
obstack_grow (obs, repl, repl_len);
return;
}
obstack_grow (obs, repl, backslash - repl);
repl_len -= backslash - repl + 1;
if (!repl_len)
{
m4_warn (context, 0, caller,
_("trailing \\ ignored in replacement"));
return;
}
repl = backslash + 1;
ch = *repl++;
repl_len--;
switch (ch)
{
case '&':
if (buf)
obstack_grow (obs, victim + buf->regs.start[0],
buf->regs.end[0] - buf->regs.start[0]);
break;
case '1': case '2': case '3': case '4': case '5': case '6':
case '7': case '8': case '9':
ch -= '0';
if (!buf || buf->pat->re_nsub < ch)
m4_warn (context, 0, caller, _("sub-expression %d not present"),
ch);
else if (buf->regs.end[ch] > 0)
obstack_grow (obs, victim + buf->regs.start[ch],
buf->regs.end[ch] - buf->regs.start[ch]);
break;
default:
obstack_1grow (obs, ch);
break;
}
}
}
/* For each match against REGEXP of length REGEXP_LEN (precompiled in
BUF as returned by regexp_compile) in VICTIM of length LEN,
substitute REPLACE of length REPL_LEN. Non-matching characters are
copied verbatim, and the result copied to the obstack. Errors are
reported on behalf of CALLER. Return true if a substitution was
made. If OPTIMIZE is set, don't worry about copying the input if
no changes are made. */
static bool
regexp_substitute (m4 *context, m4_obstack *obs, const m4_call_info *caller,
const char *victim, size_t len, const char *regexp,
size_t regexp_len, m4_pattern_buffer *buf,
const char *replace, size_t repl_len, bool optimize)
{
regoff_t matchpos = 0; /* start position of match */
size_t offset = 0; /* current match offset */
bool subst = !optimize; /* if a substitution has been made */
while (offset <= len)
{
matchpos = regexp_search (buf, victim, len, offset, len - offset,
false);
if (matchpos < 0)
{
/* Match failed -- either error or there is no match in the
rest of the string, in which case the rest of the string is
copied verbatim. */
if (matchpos == -2)
m4_error (context, 0, 0, caller,
_("problem matching regular expression %s"),
quotearg_style_mem (locale_quoting_style, regexp,
regexp_len));
else if (offset < len && subst)
obstack_grow (obs, victim + offset, len - offset);
break;
}
/* Copy the part of the string that was skipped by re_search (). */
if (matchpos > offset)
obstack_grow (obs, victim + offset, matchpos - offset);
/* Handle the part of the string that was covered by the match. */
substitute (context, obs, caller, victim, replace, repl_len, buf);
subst = true;
/* Update the offset to the end of the match. If the regexp
matched a null string, advance offset one more, to avoid
infinite loops. */
offset = buf->regs.end[0];
if (buf->regs.start[0] == buf->regs.end[0])
{
if (offset < len)
obstack_1grow (obs, victim[offset]);
offset++;
}
}
return subst;
}
/**
* __file__
**/
M4BUILTIN_HANDLER (__file__)
{
m4_shipout_string (context, obs, m4_get_current_file (context), SIZE_MAX,
true);
}
/**
* __line__
**/
M4BUILTIN_HANDLER (__line__)
{
m4_shipout_int (obs, m4_get_current_line (context));
}
/**
* __program__
**/
M4BUILTIN_HANDLER (__program__)
{
m4_shipout_string (context, obs, m4_get_program_name (), SIZE_MAX, true);
}
/* The builtin "builtin" allows calls to builtin macros, even if their
definition has been overridden or shadowed. It is thus possible to
redefine builtins, and still access their original definition. A
special form allows one to retrieve the special token that defn
would normally return, even if that builtin is not currently
defined and hence can't be passed to defn. */
/**
* builtin(MACRO, [...])
* builtin(defn(`builtin'), MACRO)
**/
M4BUILTIN_HANDLER (builtin)
{
const m4_call_info *me = m4_arg_info (argv);
const char *name;
size_t len;
m4_symbol_value *value = NULL;
if (!m4_is_arg_text (argv, 1))
{
assert (m4_is_arg_func (argv, 1));
if (m4_arg_func (argv, 1) == builtin_builtin)
{
if (m4_bad_argc (context, argc, me, 2, 2, false))
return;
if (!m4_is_arg_text (argv, 2))
{
m4_warn (context, 0, me, _("invalid macro name ignored"));
return;
}
name = M4ARG (2);
len = M4ARGLEN (2);
if (len == strlen (name))
value = m4_builtin_find_by_name (context, NULL, name);
if (value)
{
m4_push_builtin (context, obs, value);
free (value);
}
else if (m4_is_debug_bit (context, M4_DEBUG_TRACE_DEREF))
m4_warn (context, 0, me, _("undefined builtin %s"),
quotearg_style_mem (locale_quoting_style, name, len));
}
else
m4_warn (context, 0, me, _("invalid macro name ignored"));
}
else
{
name = M4ARG (1);
len = M4ARGLEN (1);
if (len == strlen (name))
value = m4_builtin_find_by_name (context, NULL, name);
if (value == NULL)
{
if (m4_is_debug_bit (context, M4_DEBUG_TRACE_DEREF))
m4_warn (context, 0, me, _("undefined builtin %s"),
quotearg_style_mem (locale_quoting_style, name, len));
}
else
{
const m4_builtin *bp = m4_get_symbol_value_builtin (value);
m4_macro_args *new_argv;
bool flatten = (bp->flags & M4_BUILTIN_FLATTEN_ARGS) != 0;
new_argv = m4_make_argv_ref (context, argv, name, len, flatten,
false);
if (!m4_bad_argc (context, argc - 1, m4_arg_info (new_argv),
bp->min_args, bp->max_args,
(bp->flags & M4_BUILTIN_SIDE_EFFECT) != 0))
bp->func (context, obs, argc - 1, new_argv);
free (value);
}
}
}
/* Change the current regexp syntax to SPEC of length LEN, or report
failure on behalf of CALLER. Currently this affects the builtins:
`patsubst', `regexp' and `renamesyms'. */
static int
m4_resyntax_encode_safe (m4 *context, const m4_call_info *caller,
const char *spec, size_t len)
{
int resyntax;
if (strlen (spec) < len)
resyntax = -1;
else
resyntax = m4_regexp_syntax_encode (spec);
if (resyntax < 0)
m4_warn (context, 0, caller, _("bad syntax-spec: %s"),
quotearg_style_mem (locale_quoting_style, spec, len));
return resyntax;
}
/**
* changeresyntax(RESYNTAX-SPEC)
**/
M4BUILTIN_HANDLER (changeresyntax)
{
int resyntax = m4_resyntax_encode_safe (context, m4_arg_info (argv),
M4ARG (1), M4ARGLEN (1));
if (resyntax >= 0)
m4_set_regexp_syntax_opt (context, resyntax);
}
/* Change the current input syntax. The function m4_set_syntax ()
lives in syntax.c. Any changes to comment delimiters and quotes
made here will be overridden by a call to `changecom' or
`changequote'. */
/**
* changesyntax(SYNTAX-SPEC, ...)
**/
M4BUILTIN_HANDLER (changesyntax)
{
const m4_call_info *me = m4_arg_info (argv);
M4_MODULE_IMPORT (m4, m4_expand_ranges);
if (m4_expand_ranges)
{
size_t i;
for (i = 1; i < argc; i++)
{
size_t len = M4ARGLEN (i);
const char *spec;
char key;
char action;
if (!len)
{
m4_reset_syntax (M4SYNTAX);
continue;
}
spec = M4ARG (i);
key = *spec++;
len--;
action = len ? *spec : '\0';
switch (action)
{
case '-':
case '+':
case '=':
spec++;
len--;
break;
case '\0':
if (!len)
break;
/* fall through */
default:
action = '=';
break;
}
if (len)
spec = m4_expand_ranges (spec, &len, m4_arg_scratch (context));
if (m4_set_syntax (M4SYNTAX, key, action, spec, len) < 0)
m4_warn (context, 0, me, _("undefined syntax code: %s"),
quotearg_style_mem (locale_quoting_style, &key, 1));
}
}
else
assert (!"Unable to import from m4 module");
}
/* Specify the destination of the debugging output. With one argument, the
argument is taken as a file name, with no arguments, revert to stderr. */
/**
* debugfile([FILENAME])
**/
M4BUILTIN_HANDLER (debugfile)
{
const m4_call_info *me = m4_arg_info (argv);
if (argc == 1)
m4_debug_set_output (context, me, NULL);
else if (m4_get_safer_opt (context) && !m4_arg_empty (argv, 1))
m4_error (context, 0, 0, me, _("disabled by --safer"));
else
{
const char *str = M4ARG (1);
size_t len = M4ARGLEN (1);
if (strlen (str) < len)
m4_warn (context, 0, me, _("argument %s truncated"),
quotearg_style_mem (locale_quoting_style, str, len));
if (!m4_debug_set_output (context, me, str))
m4_warn (context, errno, me, _("cannot set debug file %s"),
quotearg_style (locale_quoting_style, str));
}
}
/* On-the-fly control of debug length. It takes one integer
argument. */
/**
* debuglen(LEN)
**/
M4BUILTIN_HANDLER (debuglen)
{
int i;
size_t s;
if (!m4_numeric_arg (context, m4_arg_info (argv), M4ARG (1), M4ARGLEN (1),
&i))
return;
/* FIXME - make m4_numeric_arg more powerful - we want to accept
suffixes, and limit the result to size_t. */
s = i <= 0 ? SIZE_MAX : i;
m4_set_max_debug_arg_length_opt (context, s);
}
/* On-the-fly control of the format of the tracing output. It takes one
argument, which is a character string like given to the -d option, or
none in which case the debug_level is zeroed. */
/**
* debugmode([FLAGS])
**/
M4BUILTIN_HANDLER (debugmode)
{
const char* mode = M4ARG (1);
size_t len = M4ARGLEN (1);
if (argc == 1)
m4_set_debug_level_opt (context, 0);
else if (m4_debug_decode (context, mode, len) < 0)
m4_warn (context, 0, m4_arg_info (argv),
_("bad debug flags: %s"),
quotearg_style_mem (locale_quoting_style, mode, len));
}
/* Same as the sysymd builtin from m4.c module, but expand to the
output of SHELL-COMMAND. */
/**
* esyscmd(SHELL-COMMAND)
**/
M4BUILTIN_HANDLER (esyscmd)
{
const m4_call_info *me = m4_arg_info (argv);
const char *cmd = M4ARG (1);
size_t len = M4ARGLEN (1);
M4_MODULE_IMPORT (m4, m4_set_sysval);
M4_MODULE_IMPORT (m4, m4_sysval_flush);
if (m4_set_sysval && m4_sysval_flush)
{
pid_t child;
int fd;
FILE *pin;
int status;
int sig_status;
const char *prog_args[4] = { "sh", "-c" };
const char *caller;
if (m4_get_safer_opt (context))
{
m4_error (context, 0, 0, me, _("disabled by --safer"));
return;
}
if (strlen (cmd) != len)
m4_warn (context, 0, me, _("argument %s truncated"),
quotearg_style_mem (locale_quoting_style, cmd, len));
/* Optimize the empty command. */
if (!*cmd)
{
m4_set_sysval (0);
return;
}
m4_sysval_flush (context, false);
#if W32_NATIVE
if (strstr (M4_SYSCMD_SHELL, "cmd"))
{
prog_args[0] = "cmd";
prog_args[1] = "/c";
}
#endif
prog_args[2] = cmd;
caller = m4_info_name (me);
errno = 0;
child = create_pipe_in (caller, M4_SYSCMD_SHELL, (char **) prog_args,
NULL, false, true, false, &fd);
if (child == -1)
{
m4_error (context, 0, errno, me, _("cannot run command %s"),
quotearg_style (locale_quoting_style, cmd));
m4_set_sysval (127);
return;
}
#if OS2
/* On OS/2 kLIBC, fdopen() creates a stream in a mode of a file
descriptor. So incldue "t" to open stream in a text mode explicitly. */
pin = fdopen (fd, "rt");
#else
pin = fdopen (fd, "r");
#endif
if (!pin)
{
m4_error (context, 0, errno, me, _("cannot run command %s"),
quotearg_style (locale_quoting_style, cmd));
m4_set_sysval (127);
close (fd);
return;
}
while (1)
{
size_t avail = obstack_room (obs);
if (!avail)
{
int ch = getc (pin);
if (ch == EOF)
break;
obstack_1grow (obs, ch);
}
else
{
size_t len = fread (obstack_next_free (obs), 1, avail, pin);
if (len <= 0)
break;
obstack_blank_fast (obs, len);
}
}
if (ferror (pin) || fclose (pin))
m4_error (context, EXIT_FAILURE, errno, me,
_("cannot read pipe to command %s"),
quotearg_style (locale_quoting_style, cmd));
errno = 0;
status = wait_subprocess (child, caller, false, true, true, false,
&sig_status);
if (sig_status)
{
assert (status == 127);
m4_set_sysval (sig_status << 8);
}
else
{
if (status == 127 && errno)
m4_error (context, 0, errno, me, _("cannot run command %s"),
quotearg_style (locale_quoting_style, cmd));
m4_set_sysval (status);
}
}
else
assert (!"Unable to import from m4 module");
}
/* Frontend for printf like formatting. The function format () lives in
the file format.c. */
#include "format.c"
/**
* format(FORMAT-STRING, [...])
**/
M4BUILTIN_HANDLER (format)
{
format (context, obs, argc, argv);
}
/* The builtin "indir" allows indirect calls to macros, even if their name
is not a proper macro name. It is thus possible to define macros with
ill-formed names for internal use in larger macro packages. */
/**
* indir(MACRO, [...])
**/
M4BUILTIN_HANDLER (indir)
{
const m4_call_info *me = m4_arg_info (argv);
if (!m4_is_arg_text (argv, 1))
m4_warn (context, 0, me, _("invalid macro name ignored"));
else
{
const char *name = M4ARG (1);
size_t len = M4ARGLEN (1);
m4_symbol *symbol = m4_symbol_lookup (M4SYMTAB, name, len);
if (symbol == NULL)
{
if (m4_is_debug_bit (context, M4_DEBUG_TRACE_DEREF))
m4_warn (context, 0, me, _("undefined macro %s"),
quotearg_style_mem (locale_quoting_style, name, len));
}
else
{
m4_macro_args *new_argv;
m4_symbol_value *value = m4_get_symbol_value (symbol);
new_argv = m4_make_argv_ref (context, argv, name, len,
m4_symbol_flatten_args (symbol),
m4_get_symbol_traced (symbol));
m4_trace_prepare (context, m4_arg_info (new_argv), value);
m4_macro_call (context, value, obs, new_argv);
}
}
}
/* The builtin "mkdtemp" allows creation of temporary directories. */
/**
* mkdtemp(TEMPLATE)
**/
M4BUILTIN_HANDLER (mkdtemp)
{
M4_MODULE_IMPORT (m4, m4_make_temp);
if (m4_make_temp)
m4_make_temp (context, obs, m4_arg_info (argv), M4ARG (1), M4ARGLEN (1),
true);
else
assert (!"Unable to import from m4 module");
}
/* Substitute all matches of a regexp occurring in a string. Each
match of the second argument (a regexp) in the first argument is
changed to the optional third argument, with \& substituted by the
matched text, and \N substituted by the text matched by the Nth
parenthesized sub-expression. The optional fourth argument changes
the regex flavor. */
/**
* patsubst(VICTIM, REGEXP, [REPLACEMENT], [RESYNTAX])
**/
M4BUILTIN_HANDLER (patsubst)
{
const m4_call_info *me = m4_arg_info (argv);
const char *pattern; /* regular expression */
const char *replace; /* replacement */
m4_pattern_buffer *buf; /* compiled regular expression */
int resyntax;
resyntax = m4_get_regexp_syntax_opt (context);
if (argc >= 5) /* additional args ignored */
{
resyntax = m4_resyntax_encode_safe (context, me, M4ARG (4),
M4ARGLEN (4));
if (resyntax < 0)
return;
}
/* The empty regex matches everywhere, but if there is no
replacement, we need not waste time with it. */
if (m4_arg_empty (argv, 2) && m4_arg_empty (argv, 3))
{
m4_push_arg (context, obs, argv, 1);
return;
}
pattern = M4ARG (2);
replace = M4ARG (3);
buf = regexp_compile (context, me, pattern, M4ARGLEN (2), resyntax);
if (!buf)
return;
regexp_substitute (context, obs, me, M4ARG (1), M4ARGLEN (1), pattern,
M4ARGLEN (2), buf, replace, M4ARGLEN (3), false);
}
/* Regular expression version of index. Given two arguments, expand
to the index of the first match of the second argument (a regexp)
in the first. Expand to -1 if there is no match. Given a third
argument, a match is substituted according to this argument. The
optional fourth argument changes the regex flavor. */
/**
* regexp(VICTIM, REGEXP, RESYNTAX)
* regexp(VICTIM, REGEXP, [REPLACEMENT], [RESYNTAX])
**/
M4BUILTIN_HANDLER (regexp)
{
const m4_call_info *me = m4_arg_info (argv);
const char *victim; /* string to search */
const char *pattern; /* regular expression */
const char *replace; /* optional replacement string */
m4_pattern_buffer *buf; /* compiled regular expression */
regoff_t startpos; /* start position of match */
size_t len; /* length of first argument */
int resyntax;
pattern = M4ARG (2);
replace = M4ARG (3);
resyntax = m4_get_regexp_syntax_opt (context);
if (argc == 4)
{
resyntax = m4_regexp_syntax_encode (replace);
/* The first case is the most difficult, because the empty string
is a valid RESYNTAX, yet we want `regexp(aab, a*, )' to return
an empty string as per M4 1.4.x. */
if (m4_arg_empty (argv, 3) || (resyntax < 0))
/* regexp(VICTIM, REGEXP, REPLACEMENT) */
resyntax = m4_get_regexp_syntax_opt (context);
else
/* regexp(VICTIM, REGEXP, RESYNTAX) */
replace = NULL;
}
else if (argc >= 5)
{
/* regexp(VICTIM, REGEXP, REPLACEMENT, RESYNTAX) */
resyntax = m4_resyntax_encode_safe (context, me, M4ARG (4),
M4ARGLEN (4));
if (resyntax < 0)
return;
}
else
/* regexp(VICTIM, REGEXP) */
replace = NULL;
if (m4_arg_empty (argv, 2))
{
/* The empty regex matches everything. */
if (replace)
substitute (context, obs, me, M4ARG (1), replace, M4ARGLEN (3), NULL);
else
m4_shipout_int (obs, 0);
return;
}
buf = regexp_compile (context, me, pattern, M4ARGLEN (2), resyntax);
if (!buf)
return;
victim = M4ARG (1);
len = M4ARGLEN (1);
startpos = regexp_search (buf, victim, len, 0, len, replace == NULL);
if (startpos == -2)
{
m4_error (context, 0, 0, me, _("problem matching regular expression %s"),
quotearg_style_mem (locale_quoting_style, pattern,
M4ARGLEN (2)));
return;
}
if (replace == NULL)
m4_shipout_int (obs, startpos);
else if (startpos >= 0)
substitute (context, obs, me, victim, replace, M4ARGLEN (3), buf);
}
/* Rename all current symbols that match REGEXP according to the
REPLACEMENT specification. */
/**
* renamesyms(REGEXP, REPLACEMENT, [RESYNTAX])
**/
M4BUILTIN_HANDLER (renamesyms)
{
M4_MODULE_IMPORT (m4, m4_dump_symbols);
if (m4_dump_symbols)
{
const m4_call_info *me = m4_arg_info (argv);
const char *regexp; /* regular expression string */
size_t regexp_len;
const char *replace; /* replacement expression string */
size_t replace_len;
m4_pattern_buffer *buf; /* compiled regular expression */
m4_dump_symbol_data data;
int resyntax;
regexp = M4ARG (1);
regexp_len = M4ARGLEN (1);
replace = M4ARG (2);
replace_len = M4ARGLEN (2);
resyntax = m4_get_regexp_syntax_opt (context);
if (argc >= 4)
{
resyntax = m4_resyntax_encode_safe (context, me, M4ARG (3),
M4ARGLEN (3));
if (resyntax < 0)
return;
}
buf = regexp_compile (context, me, regexp, regexp_len, resyntax);
if (!buf)
return;
data.obs = m4_arg_scratch (context);
m4_dump_symbols (context, &data, 1, argv, false);
for (; data.size > 0; --data.size, data.base++)
{
const m4_string *key = &data.base[0];
if (regexp_substitute (context, data.obs, me, key->str, key->len,
regexp, regexp_len, buf, replace, replace_len,
true))
{
size_t newlen = obstack_object_size (data.obs);
m4_symbol_rename (M4SYMTAB, key->str, key->len,
(char *) obstack_finish (data.obs), newlen);
}
}
}
else
assert (!"Unable to import from m4 module");
}
/**
* m4modules()
**/
M4BUILTIN_HANDLER (m4modules)
{
/* The expansion of this builtin is a comma separated list of
loaded modules. */
m4_module *module = m4_module_next (context, NULL);
if (module)
do
{
m4_shipout_string (context, obs, m4_get_module_name (module), SIZE_MAX,
true);
if ((module = m4_module_next (context, module)))
obstack_1grow (obs, ',');
}
while (module);
}
/* Implementation of "m4symbols". It builds up a table of pointers to
symbols, sorts it and ships out the symbol names. */
/**
* m4symbols([...])
**/
M4BUILTIN_HANDLER (m4symbols)
{
M4_MODULE_IMPORT (m4, m4_dump_symbols);
if (m4_dump_symbols)
{
m4_dump_symbol_data data;
data.obs = m4_arg_scratch (context);
m4_dump_symbols (context, &data, argc, argv, false);
for (; data.size > 0; --data.size, data.base++)
{
m4_shipout_string (context, obs, data.base->str, data.base->len,
true);
if (data.size > 1)
obstack_1grow (obs, ',');
}
}
else
assert (!"Unable to import from m4 module");
}
/* This contains macro which implements syncoutput() which takes one arg
1, on, yes - turn on sync lines
0, off, no, blank - turn off sync lines
everything else is silently ignored */
/**
* syncoutput(TRUTH)
**/
M4BUILTIN_HANDLER (syncoutput)
{
bool value = m4_get_syncoutput_opt (context);
value = m4_parse_truth_arg (context, m4_arg_info (argv), M4ARG (1),
M4ARGLEN (1), value);
m4_set_syncoutput_opt (context, value);
}