代理服务器

开发平台：

Unix_Linux

GNUregex.c：源码内容

/* Pops what PUSH_FAIL_STACK pushes.
*
* We restore into the parameters, all of which should be lvalues:
* STR -- the saved data position.
* PAT -- the saved pattern position.
* LOW_REG, HIGH_REG -- the highest and lowest active registers.
* REGSTART, REGEND -- arrays of string positions.
* REG_INFO -- array of information about each subexpression.
*
* Also assumes the variables `fail_stack' and (if debugging), `bufp',
* `pend', `string1', `size1', `string2', and `size2'. */
#define POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info)
{
DEBUG_STATEMENT (fail_stack_elt_t failure_id;)
int this_reg;
const unsigned char *string_temp;
assert (!FAIL_STACK_EMPTY ());
/* Remove failure points and point to how many regs pushed. */
DEBUG_PRINT1 ("POP_FAILURE_POINT:n");
DEBUG_PRINT2 (" Before pop, next avail: %dn", fail_stack.avail);
DEBUG_PRINT2 (" size: %dn", fail_stack.size);
assert (fail_stack.avail >= NUM_NONREG_ITEMS);
DEBUG_POP (&failure_id);
DEBUG_PRINT2 (" Popping failure id: %un", failure_id);
/* If the saved string location is NULL, it came from an
on_failure_keep_string_jump opcode, and we want to throw away the
saved NULL, thus retaining our current position in the string. */
string_temp = POP_FAILURE_ITEM ();
if (string_temp != NULL)
str = (const char *) string_temp;
DEBUG_PRINT2 (" Popping string 0x%x: `", str);
DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2);
DEBUG_PRINT1 ("'n");
pat = (unsigned char *) POP_FAILURE_ITEM ();
DEBUG_PRINT2 (" Popping pattern 0x%x: ", pat);
DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend);
/* Restore register info. */
high_reg = (unsigned long) POP_FAILURE_ITEM ();
DEBUG_PRINT2 (" Popping high active reg: %dn", high_reg);
low_reg = (unsigned long) POP_FAILURE_ITEM ();
DEBUG_PRINT2 (" Popping low active reg: %dn", low_reg);
for (this_reg = high_reg; this_reg >= low_reg; this_reg--)
{
DEBUG_PRINT2 (" Popping reg: %dn", this_reg);
reg_info[this_reg].word = POP_FAILURE_ITEM ();
DEBUG_PRINT2 (" info: 0x%xn", reg_info[this_reg]);
regend[this_reg] = (const char *) POP_FAILURE_ITEM ();
DEBUG_PRINT2 (" end: 0x%xn", regend[this_reg]);
regstart[this_reg] = (const char *) POP_FAILURE_ITEM ();
DEBUG_PRINT2 (" start: 0x%xn", regstart[this_reg]);
}
DEBUG_STATEMENT (nfailure_points_popped++);
} /* POP_FAILURE_POINT */
/* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in
* BUFP. A fastmap records which of the (1 << BYTEWIDTH) possible
* characters can start a string that matches the pattern. This fastmap
* is used by re_search to skip quickly over impossible starting points.
*
* The caller must supply the address of a (1 << BYTEWIDTH)-byte data
* area as BUFP->fastmap.
*
* We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in
* the pattern buffer.
*
* Returns 0 if we succeed, -2 if an internal error. */
int
re_compile_fastmap(bufp)
struct re_pattern_buffer *bufp;
{
int j, k;
fail_stack_type fail_stack;
#ifndef REGEX_MALLOC
char *destination;
#endif
/* We don't push any register information onto the failure stack. */
unsigned num_regs = 0;
register char *fastmap = bufp->fastmap;
unsigned char *pattern = bufp->buffer;
unsigned long size = bufp->used;
const unsigned char *p = pattern;
register unsigned char *pend = pattern + size;
/* Assume that each path through the pattern can be null until
* proven otherwise. We set this false at the bottom of switch
* statement, to which we get only if a particular path doesn't
* match the empty string. */
boolean path_can_be_null = true;
/* We aren't doing a `succeed_n' to begin with. */
boolean succeed_n_p = false;
assert(fastmap != NULL && p != NULL);
INIT_FAIL_STACK();
memset(fastmap, 0, 1 << BYTEWIDTH); /* Assume nothing's valid. */
bufp->fastmap_accurate = 1; /* It will be when we're done. */
bufp->can_be_null = 0;
while (p != pend || !FAIL_STACK_EMPTY()) {
if (p == pend) {
bufp->can_be_null |= path_can_be_null;
/* Reset for next path. */
path_can_be_null = true;
p = fail_stack.stack[--fail_stack.avail];
}
/* We should never be about to go beyond the end of the pattern. */
assert(p < pend);
#ifdef SWITCH_ENUM_BUG
switch ((int) ((re_opcode_t) * p++))
#else
switch ((re_opcode_t) * p++)
#endif
{
/* I guess the idea here is to simply not bother with a fastmap
* if a backreference is used, since it's too hard to figure out
* the fastmap for the corresponding group. Setting
* `can_be_null' stops `re_search_2' from using the fastmap, so
* that is all we do. */
case duplicate:
bufp->can_be_null = 1;
return 0;
/* Following are the cases which match a character. These end
* with `break'. */
case exactn:
fastmap[p[1]] = 1;
break;
case charset:
for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)
if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH)))
fastmap[j] = 1;
break;
case charset_not:
/* Chars beyond end of map must be allowed. */
for (j = *p * BYTEWIDTH; j < (1 << BYTEWIDTH); j++)
fastmap[j] = 1;
for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)
if (!(p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))))
fastmap[j] = 1;
break;
case wordchar:
for (j = 0; j < (1 << BYTEWIDTH); j++)
if (SYNTAX(j) == Sword)
fastmap[j] = 1;
break;
case notwordchar:
for (j = 0; j < (1 << BYTEWIDTH); j++)
if (SYNTAX(j) != Sword)
fastmap[j] = 1;
break;
case anychar:
/* `.' matches anything ... */
for (j = 0; j < (1 << BYTEWIDTH); j++)
fastmap[j] = 1;
/* ... except perhaps newline. */
if (!(bufp->syntax & RE_DOT_NEWLINE))
fastmap['n'] = 0;
/* Return if we have already set `can_be_null'; if we have,
* then the fastmap is irrelevant. Something's wrong here. */
else if (bufp->can_be_null)
return 0;
/* Otherwise, have to check alternative paths. */
break;
#ifdef emacs
case syntaxspec:
k = *p++;
for (j = 0; j < (1 << BYTEWIDTH); j++)
if (SYNTAX(j) == (enum syntaxcode) k)
fastmap[j] = 1;
break;
case notsyntaxspec:
k = *p++;
for (j = 0; j < (1 << BYTEWIDTH); j++)
if (SYNTAX(j) != (enum syntaxcode) k)
fastmap[j] = 1;
break;
/* All cases after this match the empty string. These end with
* `continue'. */
case before_dot:
case at_dot:
case after_dot:
continue;
#endif /* not emacs */
case no_op:
case begline:
case endline:
case begbuf:
case endbuf:
case wordbound:
case notwordbound:
case wordbeg:
case wordend:
case push_dummy_failure:
continue;
case jump_n:
case pop_failure_jump:
case maybe_pop_jump:
case jump:
case jump_past_alt:
case dummy_failure_jump:
EXTRACT_NUMBER_AND_INCR(j, p);
p += j;
if (j > 0)
continue;
/* Jump backward implies we just went through the body of a
* loop and matched nothing. Opcode jumped to should be
* `on_failure_jump' or `succeed_n'. Just treat it like an
* ordinary jump. For a * loop, it has pushed its failure
* point already; if so, discard that as redundant. */
if ((re_opcode_t) * p != on_failure_jump
&& (re_opcode_t) * p != succeed_n)
continue;
p++;
EXTRACT_NUMBER_AND_INCR(j, p);
p += j;
/* If what's on the stack is where we are now, pop it. */
if (!FAIL_STACK_EMPTY()
&& fail_stack.stack[fail_stack.avail - 1] == p)
fail_stack.avail--;
continue;
case on_failure_jump:
case on_failure_keep_string_jump:
handle_on_failure_jump:
EXTRACT_NUMBER_AND_INCR(j, p);
/* For some patterns, e.g., `(a?)?', `p+j' here points to the
* end of the pattern. We don't want to push such a point,
* since when we restore it above, entering the switch will
* increment `p' past the end of the pattern. We don't need
* to push such a point since we obviously won't find any more
* fastmap entries beyond `pend'. Such a pattern can match
* the null string, though. */
if (p + j < pend) {
if (!PUSH_PATTERN_OP(p + j, fail_stack))
return -2;
} else
bufp->can_be_null = 1;
if (succeed_n_p) {
EXTRACT_NUMBER_AND_INCR(k, p); /* Skip the n. */
succeed_n_p = false;
}
continue;
case succeed_n:
/* Get to the number of times to succeed. */
p += 2;
/* Increment p past the n for when k != 0. */
EXTRACT_NUMBER_AND_INCR(k, p);
if (k == 0) {
p -= 4;
succeed_n_p = true; /* Spaghetti code alert. */
goto handle_on_failure_jump;
}
continue;
case set_number_at:
p += 4;
continue;
case start_memory:
case stop_memory:
p += 2;
continue;
default:
abort(); /* We have listed all the cases. */
} /* switch *p++ */
/* Getting here means we have found the possible starting
* characters for one path of the pattern -- and that the empty
* string does not match. We need not follow this path further.
* Instead, look at the next alternative (remembered on the
* stack), or quit if no more. The test at the top of the loop
* does these things. */
path_can_be_null = false;
p = pend;
} /* while p */
/* Set `can_be_null' for the last path (also the first path, if the
* pattern is empty). */
bufp->can_be_null |= path_can_be_null;
return 0;
} /* re_compile_fastmap */
/* Set REGS to hold NUM_REGS registers, storing them in STARTS and
* ENDS. Subsequent matches using PATTERN_BUFFER and REGS will use
* this memory for recording register information. STARTS and ENDS
* must be allocated using the malloc library routine, and must each
* be at least NUM_REGS * sizeof (regoff_t) bytes long.
*
* If NUM_REGS == 0, then subsequent matches should allocate their own
* register data.
*
* Unless this function is called, the first search or match using
* PATTERN_BUFFER will allocate its own register data, without
* freeing the old data. */
void
re_set_registers(bufp, regs, num_regs, starts, ends)
struct re_pattern_buffer *bufp;
struct re_registers *regs;
unsigned num_regs;
regoff_t *starts, *ends;
{
if (num_regs) {
bufp->regs_allocated = REGS_REALLOCATE;
regs->num_regs = num_regs;
regs->start = starts;
regs->end = ends;
} else {
bufp->regs_allocated = REGS_UNALLOCATED;
regs->num_regs = 0;
regs->start = regs->end = (regoff_t) 0;
}
}
/* Searching routines. */
/* Like re_search_2, below, but only one string is specified, and
* doesn't let you say where to stop matching. */
int
re_search(bufp, string, size, startpos, range, regs)
struct re_pattern_buffer *bufp;
const char *string;
int size, startpos, range;
struct re_registers *regs;
{
return re_search_2(bufp, NULL, 0, string, size, startpos, range,
regs, size);
}
/* Using the compiled pattern in BUFP->buffer, first tries to match the
* virtual concatenation of STRING1 and STRING2, starting first at index
* STARTPOS, then at STARTPOS + 1, and so on.
*
* STRING1 and STRING2 have length SIZE1 and SIZE2, respectively.
*
* RANGE is how far to scan while trying to match. RANGE = 0 means try
* only at STARTPOS; in general, the last start tried is STARTPOS +
* RANGE.
*
* In REGS, return the indices of the virtual concatenation of STRING1
* and STRING2 that matched the entire BUFP->buffer and its contained
* subexpressions.
*
* Do not consider matching one past the index STOP in the virtual
* concatenation of STRING1 and STRING2.
*
* We return either the position in the strings at which the match was
* found, -1 if no match, or -2 if error (such as failure
* stack overflow). */
int
re_search_2(bufp, string1, size1, string2, size2, startpos, range, regs, stop)
struct re_pattern_buffer *bufp;
const char *string1, *string2;
int size1, size2;
int startpos;
int range;
struct re_registers *regs;
int stop;
{
int val;
register char *fastmap = bufp->fastmap;
register char *translate = bufp->translate;
int total_size = size1 + size2;
int endpos = startpos + range;
/* Check for out-of-range STARTPOS. */
if (startpos < 0 || startpos > total_size)
return -1;
/* Fix up RANGE if it might eventually take us outside
* the virtual concatenation of STRING1 and STRING2. */
if (endpos < -1)
range = -1 - startpos;
else if (endpos > total_size)
range = total_size - startpos;
/* If the search isn't to be a backwards one, don't waste time in a
* search for a pattern that must be anchored. */
if (bufp->used > 0 && (re_opcode_t) bufp->buffer[0] == begbuf && range > 0) {
if (startpos > 0)
return -1;
else
range = 1;
}
/* Update the fastmap now if not correct already. */
if (fastmap && !bufp->fastmap_accurate)
if (re_compile_fastmap(bufp) == -2)
return -2;
/* Loop through the string, looking for a place to start matching. */
for (;;) {
/* If a fastmap is supplied, skip quickly over characters that
* cannot be the start of a match. If the pattern can match the
* null string, however, we don't need to skip characters; we want
* the first null string. */
if (fastmap && startpos < total_size && !bufp->can_be_null) {
if (range > 0) { /* Searching forwards. */
register const char *d;
register int lim = 0;
int irange = range;
if (startpos < size1 && startpos + range >= size1)
lim = range - (size1 - startpos);
d = (startpos >= size1 ? string2 - size1 : string1) + startpos;
/* Written out as an if-else to avoid testing `translate'
* inside the loop. */
if (translate)
while (range > lim
&& !fastmap[(unsigned char)
translate[(unsigned char) *d++]])
range--;
else
while (range > lim && !fastmap[(unsigned char) *d++])
range--;
startpos += irange - range;
} else { /* Searching backwards. */
register char c = (size1 == 0 || startpos >= size1
? string2[startpos - size1]
: string1[startpos]);
if (!fastmap[(unsigned char) TRANSLATE(c)])
goto advance;
}
}
/* If can't match the null string, and that's all we have left, fail. */
if (range >= 0 && startpos == total_size && fastmap
&& !bufp->can_be_null)
return -1;
val = re_match_2(bufp, string1, size1, string2, size2,
startpos, regs, stop);
if (val >= 0)
return startpos;
if (val == -2)
return -2;
advance:
if (!range)
break;
else if (range > 0) {
range--;
startpos++;
} else {
range++;
startpos--;
}
}
return -1;
} /* re_search_2 */
/* Declarations and macros for re_match_2. */
static int bcmp_translate();
static boolean alt_match_null_string_p(), common_op_match_null_string_p(),
group_match_null_string_p();
/* Structure for per-register (a.k.a. per-group) information.
* This must not be longer than one word, because we push this value
* onto the failure stack. Other register information, such as the
* starting and ending positions (which are addresses), and the list of
* inner groups (which is a bits list) are maintained in separate
* variables.
*
* We are making a (strictly speaking) nonportable assumption here: that
* the compiler will pack our bit fields into something that fits into
* the type of `word', i.e., is something that fits into one item on the
* failure stack. */
typedef union {
fail_stack_elt_t word;
struct {
/* This field is one if this group can match the empty string,
* zero if not. If not yet determined, `MATCH_NULL_UNSET_VALUE'. */
#define MATCH_NULL_UNSET_VALUE 3
unsigned match_null_string_p:2;
unsigned is_active:1;
unsigned matched_something:1;
unsigned ever_matched_something:1;
} bits;
} register_info_type;
#define REG_MATCH_NULL_STRING_P(R) ((R).bits.match_null_string_p)
#define IS_ACTIVE(R) ((R).bits.is_active)
#define MATCHED_SOMETHING(R) ((R).bits.matched_something)
#define EVER_MATCHED_SOMETHING(R) ((R).bits.ever_matched_something)
/* Call this when have matched a real character; it sets `matched' flags
* for the subexpressions which we are currently inside. Also records
* that those subexprs have matched. */
#define SET_REGS_MATCHED()
do
{
unsigned r;
for (r = lowest_active_reg; r <= highest_active_reg; r++)
{
MATCHED_SOMETHING (reg_info[r])
= EVER_MATCHED_SOMETHING (reg_info[r])
= 1;
}
}
while (0)
/* This converts PTR, a pointer into one of the search strings `string1'
* and `string2' into an offset from the beginning of that string. */
#define POINTER_TO_OFFSET(ptr)
(FIRST_STRING_P (ptr) ? (ptr) - string1 : (ptr) - string2 + size1)
/* Registers are set to a sentinel when they haven't yet matched. */
#define REG_UNSET_VALUE ((char *) -1)
#define REG_UNSET(e) ((e) == REG_UNSET_VALUE)
/* Macros for dealing with the split strings in re_match_2. */
#define MATCHING_IN_FIRST_STRING (dend == end_match_1)
/* Call before fetching a character with *d. This switches over to
* string2 if necessary. */
#define PREFETCH()
while (d == dend)
{
/* End of string2 => fail. */
if (dend == end_match_2)
goto fail;
/* End of string1 => advance to string2. */
d = string2;
dend = end_match_2;
}
/* Test if at very beginning or at very end of the virtual concatenation
* of `string1' and `string2'. If only one string, it's `string2'. */
#define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2)
#define AT_STRINGS_END(d) ((d) == end2)
/* Test if D points to a character which is word-constituent. We have
* two special cases to check for: if past the end of string1, look at
* the first character in string2; and if before the beginning of
* string2, look at the last character in string1. */
#define WORDCHAR_P(d)
(SYNTAX ((d) == end1 ? *string2
: (d) == string2 - 1 ? *(end1 - 1) : *(d))
== Sword)
/* Test if the character before D and the one at D differ with respect
* to being word-constituent. */
#define AT_WORD_BOUNDARY(d)
(AT_STRINGS_BEG (d) || AT_STRINGS_END (d)
|| WORDCHAR_P (d - 1) != WORDCHAR_P (d))
/* Free everything we malloc. */
#ifdef REGEX_MALLOC
#define FREE_VAR(var) if (var) free (var); var = NULL
#define FREE_VARIABLES()
do {
FREE_VAR (fail_stack.stack);
FREE_VAR (regstart);
FREE_VAR (regend);
FREE_VAR (old_regstart);
FREE_VAR (old_regend);
FREE_VAR (best_regstart);
FREE_VAR (best_regend);
FREE_VAR (reg_info);
FREE_VAR (reg_dummy);
FREE_VAR (reg_info_dummy);
} while (0)
#else /* not REGEX_MALLOC */
/* Some MIPS systems (at least) want this to free alloca'd storage. */
#define FREE_VARIABLES() alloca (0)
#endif /* not REGEX_MALLOC */
/* These values must meet several constraints. They must not be valid
* register values; since we have a limit of 255 registers (because
* we use only one byte in the pattern for the register number), we can
* use numbers larger than 255. They must differ by 1, because of
* NUM_FAILURE_ITEMS above. And the value for the lowest register must
* be larger than the value for the highest register, so we do not try
* to actually save any registers when none are active. */
#define NO_HIGHEST_ACTIVE_REG (1 << BYTEWIDTH)
#define NO_LOWEST_ACTIVE_REG (NO_HIGHEST_ACTIVE_REG + 1)
/* Matching routines. */
#ifndef emacs /* Emacs never uses this. */
/* re_match is like re_match_2 except it takes only a single string. */
int
re_match(bufp, string, size, pos, regs)
struct re_pattern_buffer *bufp;
const char *string;
int size, pos;
struct re_registers *regs;
{
return re_match_2(bufp, NULL, 0, string, size, pos, regs, size);
}
#endif /* not emacs */
/* re_match_2 matches the compiled pattern in BUFP against the
* the (virtual) concatenation of STRING1 and STRING2 (of length SIZE1
* and SIZE2, respectively). We start matching at POS, and stop
* matching at STOP.
*
* If REGS is non-null and the `no_sub' field of BUFP is nonzero, we
* store offsets for the substring each group matched in REGS. See the
* documentation for exactly how many groups we fill.
*
* We return -1 if no match, -2 if an internal error (such as the
* failure stack overflowing). Otherwise, we return the length of the
* matched substring. */
int
re_match_2(bufp, string1, size1, string2, size2, pos, regs, stop)
struct re_pattern_buffer *bufp;
const char *string1, *string2;
int size1, size2;
int pos;
struct re_registers *regs;
int stop;
{
/* General temporaries. */
int mcnt;
unsigned char *p1;
/* Just past the end of the corresponding string. */
const char *end1, *end2;
/* Pointers into string1 and string2, just past the last characters in
* each to consider matching. */
const char *end_match_1, *end_match_2;
/* Where we are in the data, and the end of the current string. */
const char *d, *dend;
/* Where we are in the pattern, and the end of the pattern. */
unsigned char *p = bufp->buffer;
register unsigned char *pend = p + bufp->used;
/* We use this to map every character in the string. */
char *translate = bufp->translate;
/* Failure point stack. Each place that can handle a failure further
* down the line pushes a failure point on this stack. It consists of
* restart, regend, and reg_info for all registers corresponding to
* the subexpressions we're currently inside, plus the number of such
* registers, and, finally, two char *'s. The first char * is where
* to resume scanning the pattern; the second one is where to resume
* scanning the strings. If the latter is zero, the failure point is
* a ``dummy''; if a failure happens and the failure point is a dummy,
* it gets discarded and the next next one is tried. */
fail_stack_type fail_stack;
#ifdef DEBUG
static unsigned failure_id = 0;
unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0;
#endif
/* We fill all the registers internally, independent of what we
* return, for use in backreferences. The number here includes
* an element for register zero. */
unsigned num_regs = bufp->re_nsub + 1;
/* The currently active registers. */
unsigned long lowest_active_reg = NO_LOWEST_ACTIVE_REG;
unsigned long highest_active_reg = NO_HIGHEST_ACTIVE_REG;
/* Information on the contents of registers. These are pointers into
* the input strings; they record just what was matched (on this
* attempt) by a subexpression part of the pattern, that is, the
* regnum-th regstart pointer points to where in the pattern we began
* matching and the regnum-th regend points to right after where we
* stopped matching the regnum-th subexpression. (The zeroth register
* keeps track of what the whole pattern matches.) */
const char **regstart = NULL, **regend = NULL;
/* If a group that's operated upon by a repetition operator fails to
* match anything, then the register for its start will need to be
* restored because it will have been set to wherever in the string we
* are when we last see its open-group operator. Similarly for a
* register's end. */
const char **old_regstart = NULL, **old_regend = NULL;
/* The is_active field of reg_info helps us keep track of which (possibly
* nested) subexpressions we are currently in. The matched_something
* field of reg_info[reg_num] helps us tell whether or not we have
* matched any of the pattern so far this time through the reg_num-th
* subexpression. These two fields get reset each time through any
* loop their register is in. */
register_info_type *reg_info = NULL;
/* The following record the register info as found in the above
* variables when we find a match better than any we've seen before.
* This happens as we backtrack through the failure points, which in
* turn happens only if we have not yet matched the entire string. */
unsigned best_regs_set = false;
const char **best_regstart = NULL, **best_regend = NULL;
/* Logically, this is `best_regend[0]'. But we don't want to have to
* allocate space for that if we're not allocating space for anything
* else (see below). Also, we never need info about register 0 for
* any of the other register vectors, and it seems rather a kludge to
* treat `best_regend' differently than the rest. So we keep track of
* the end of the best match so far in a separate variable. We
* initialize this to NULL so that when we backtrack the first time
* and need to test it, it's not garbage. */
const char *match_end = NULL;
/* Used when we pop values we don't care about. */
const char **reg_dummy = NULL;
register_info_type *reg_info_dummy = NULL;
#ifdef DEBUG
/* Counts the total number of registers pushed. */
unsigned num_regs_pushed = 0;
#endif
DEBUG_PRINT1("nnEntering re_match_2.n");
INIT_FAIL_STACK();
/* Do not bother to initialize all the register variables if there are
* no groups in the pattern, as it takes a fair amount of time. If
* there are groups, we include space for register 0 (the whole
* pattern), even though we never use it, since it simplifies the
* array indexing. We should fix this. */
if (bufp->re_nsub) {
regstart = REGEX_TALLOC(num_regs, const char *);
regend = REGEX_TALLOC(num_regs, const char *);
old_regstart = REGEX_TALLOC(num_regs, const char *);
old_regend = REGEX_TALLOC(num_regs, const char *);
best_regstart = REGEX_TALLOC(num_regs, const char *);
best_regend = REGEX_TALLOC(num_regs, const char *);
reg_info = REGEX_TALLOC(num_regs, register_info_type);
reg_dummy = REGEX_TALLOC(num_regs, const char *);
reg_info_dummy = REGEX_TALLOC(num_regs, register_info_type);
if (!(regstart && regend && old_regstart && old_regend && reg_info
&& best_regstart && best_regend && reg_dummy && reg_info_dummy)) {
FREE_VARIABLES();
return -2;
}
}
#ifdef REGEX_MALLOC
else {
/* We must initialize all our variables to NULL, so that
* `FREE_VARIABLES' doesn't try to free them. */
regstart = regend = old_regstart = old_regend = best_regstart
= best_regend = reg_dummy = NULL;
reg_info = reg_info_dummy = (register_info_type *) NULL;
}
#endif /* REGEX_MALLOC */
/* The starting position is bogus. */
if (pos < 0 || pos > size1 + size2) {
FREE_VARIABLES();
return -1;
}
/* Initialize subexpression text positions to -1 to mark ones that no
* start_memory/stop_memory has been seen for. Also initialize the
* register information struct. */
for (mcnt = 1; mcnt < num_regs; mcnt++) {
regstart[mcnt] = regend[mcnt]
= old_regstart[mcnt] = old_regend[mcnt] = REG_UNSET_VALUE;
REG_MATCH_NULL_STRING_P(reg_info[mcnt]) = MATCH_NULL_UNSET_VALUE;
IS_ACTIVE(reg_info[mcnt]) = 0;
MATCHED_SOMETHING(reg_info[mcnt]) = 0;
EVER_MATCHED_SOMETHING(reg_info[mcnt]) = 0;
}
/* We move `string1' into `string2' if the latter's empty -- but not if
* `string1' is null. */
if (size2 == 0 && string1 != NULL) {
string2 = string1;
size2 = size1;
string1 = 0;
size1 = 0;
}
end1 = string1 + size1;
end2 = string2 + size2;
/* Compute where to stop matching, within the two strings. */
if (stop <= size1) {
end_match_1 = string1 + stop;
end_match_2 = string2;
} else {
end_match_1 = end1;
end_match_2 = string2 + stop - size1;
}
/* `p' scans through the pattern as `d' scans through the data.
* `dend' is the end of the input string that `d' points within. `d'
* is advanced into the following input string whenever necessary, but
* this happens before fetching; therefore, at the beginning of the
* loop, `d' can be pointing at the end of a string, but it cannot
* equal `string2'. */
if (size1 > 0 && pos <= size1) {
d = string1 + pos;
dend = end_match_1;
} else {
d = string2 + pos - size1;
dend = end_match_2;
}
DEBUG_PRINT1("The compiled pattern is: ");
DEBUG_PRINT_COMPILED_PATTERN(bufp, p, pend);
DEBUG_PRINT1("The string to match is: `");
DEBUG_PRINT_DOUBLE_STRING(d, string1, size1, string2, size2);
DEBUG_PRINT1("'n");
/* This loops over pattern commands. It exits by returning from the
* function if the match is complete, or it drops through if the match
* fails at this starting point in the input data. */
for (;;) {
DEBUG_PRINT2("n0x%x: ", p);
if (p == pend) { /* End of pattern means we might have succeeded. */
DEBUG_PRINT1("end of pattern ... ");
/* If we haven't matched the entire string, and we want the
* longest match, try backtracking. */
if (d != end_match_2) {
DEBUG_PRINT1("backtracking.n");
if (!FAIL_STACK_EMPTY()) { /* More failure points to try. */
boolean same_str_p = (FIRST_STRING_P(match_end)
== MATCHING_IN_FIRST_STRING);
/* If exceeds best match so far, save it. */
if (!best_regs_set
|| (same_str_p && d > match_end)
|| (!same_str_p && !MATCHING_IN_FIRST_STRING)) {
best_regs_set = true;
match_end = d;
DEBUG_PRINT1("nSAVING match as best so far.n");
for (mcnt = 1; mcnt < num_regs; mcnt++) {
best_regstart[mcnt] = regstart[mcnt];
best_regend[mcnt] = regend[mcnt];
}
}
goto fail;
}
/* If no failure points, don't restore garbage. */
else if (best_regs_set) {
restore_best_regs:
/* Restore best match. It may happen that `dend ==
* end_match_1' while the restored d is in string2.
* For example, the pattern `x.*y.*z' against the
* strings `x-' and `y-z-', if the two strings are
* not consecutive in memory. */
DEBUG_PRINT1("Restoring best registers.n");
d = match_end;
dend = ((d >= string1 && d <= end1)
? end_match_1 : end_match_2);
for (mcnt = 1; mcnt < num_regs; mcnt++) {
regstart[mcnt] = best_regstart[mcnt];
regend[mcnt] = best_regend[mcnt];
}
}
} /* d != end_match_2 */
DEBUG_PRINT1("Accepting match.n");
/* If caller wants register contents data back, do it. */
if (regs && !bufp->no_sub) {
/* Have the register data arrays been allocated? */
if (bufp->regs_allocated == REGS_UNALLOCATED) { /* No. So allocate them with malloc. We need one
* extra element beyond `num_regs' for the `-1' marker
* GNU code uses. */
regs->num_regs = MAX(RE_NREGS, num_regs + 1);
regs->start = TALLOC(regs->num_regs, regoff_t);
regs->end = TALLOC(regs->num_regs, regoff_t);
if (regs->start == NULL || regs->end == NULL)
return -2;
bufp->regs_allocated = REGS_REALLOCATE;
} else if (bufp->regs_allocated == REGS_REALLOCATE) { /* Yes. If we need more elements than were already
* allocated, reallocate them. If we need fewer, just
* leave it alone. */
if (regs->num_regs < num_regs + 1) {
regs->num_regs = num_regs + 1;
RETALLOC(regs->start, regs->num_regs, regoff_t);
RETALLOC(regs->end, regs->num_regs, regoff_t);
if (regs->start == NULL || regs->end == NULL)
return -2;
}
} else
assert(bufp->regs_allocated == REGS_FIXED);
/* Convert the pointer data in `regstart' and `regend' to
* indices. Register zero has to be set differently,
* since we haven't kept track of any info for it. */
if (regs->num_regs > 0) {
regs->start[0] = pos;
regs->end[0] = (MATCHING_IN_FIRST_STRING ? d - string1
: d - string2 + size1);
}
/* Go through the first `min (num_regs, regs->num_regs)'
* registers, since that is all we initialized. */
for (mcnt = 1; mcnt < MIN(num_regs, regs->num_regs); mcnt++) {
if (REG_UNSET(regstart[mcnt]) || REG_UNSET(regend[mcnt]))
regs->start[mcnt] = regs->end[mcnt] = -1;
else {
regs->start[mcnt] = POINTER_TO_OFFSET(regstart[mcnt]);
regs->end[mcnt] = POINTER_TO_OFFSET(regend[mcnt]);
}
}
/* If the regs structure we return has more elements than
* were in the pattern, set the extra elements to -1. If
* we (re)allocated the registers, this is the case,
* because we always allocate enough to have at least one
* -1 at the end. */
for (mcnt = num_regs; mcnt < regs->num_regs; mcnt++)
regs->start[mcnt] = regs->end[mcnt] = -1;
} /* regs && !bufp->no_sub */
FREE_VARIABLES();
DEBUG_PRINT4("%u failure points pushed, %u popped (%u remain).n",
nfailure_points_pushed, nfailure_points_popped,
nfailure_points_pushed - nfailure_points_popped);
DEBUG_PRINT2("%u registers pushed.n", num_regs_pushed);
mcnt = d - pos - (MATCHING_IN_FIRST_STRING
? string1
: string2 - size1);
DEBUG_PRINT2("Returning %d from re_match_2.n", mcnt);
return mcnt;
}
/* Otherwise match next pattern command. */
#ifdef SWITCH_ENUM_BUG
switch ((int) ((re_opcode_t) * p++))
#else
switch ((re_opcode_t) * p++)
#endif
{
/* Ignore these. Used to ignore the n of succeed_n's which
* currently have n == 0. */
case no_op:
DEBUG_PRINT1("EXECUTING no_op.n");
break;
/* Match the next n pattern characters exactly. The following
* byte in the pattern defines n, and the n bytes after that
* are the characters to match. */
case exactn:
mcnt = *p++;
DEBUG_PRINT2("EXECUTING exactn %d.n", mcnt);
/* This is written out as an if-else so we don't waste time
* testing `translate' inside the loop. */
if (translate) {
do {
PREFETCH();
if (translate[(unsigned char) *d++] != (char) *p++)
goto fail;
}
while (--mcnt);
} else {
do {
PREFETCH();
if (*d++ != (char) *p++)
goto fail;
}
while (--mcnt);
}
SET_REGS_MATCHED();
break;
/* Match any character except possibly a newline or a null. */
case anychar:
DEBUG_PRINT1("EXECUTING anychar.n");
PREFETCH();
if ((!(bufp->syntax & RE_DOT_NEWLINE) && TRANSLATE(*d) == 'n')
|| (bufp->syntax & RE_DOT_NOT_NULL && TRANSLATE(*d) == '00'))
goto fail;
SET_REGS_MATCHED();
DEBUG_PRINT2(" Matched `%d'.n", *d);
d++;
break;
case charset:
case charset_not:
{
register unsigned char c;
boolean not = (re_opcode_t) * (p - 1) == charset_not;
DEBUG_PRINT2("EXECUTING charset%s.n", not ? "_not" : "");
PREFETCH();
c = TRANSLATE(*d); /* The character to match. */
/* Cast to `unsigned' instead of `unsigned char' in case the
* bit list is a full 32 bytes long. */
if (c < (unsigned) (*p * BYTEWIDTH)
&& p[1 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))
not = !not;
p += 1 + *p;
if (!not)
goto fail;
SET_REGS_MATCHED();
d++;
break;
}
/* The beginning of a group is represented by start_memory.
* The arguments are the register number in the next byte, and the
* number of groups inner to this one in the next. The text
* matched within the group is recorded (in the internal
* registers data structure) under the register number. */
case start_memory:
DEBUG_PRINT3("EXECUTING start_memory %d (%d):n", *p, p[1]);
/* Find out if this group can match the empty string. */
p1 = p; /* To send to group_match_null_string_p. */
if (REG_MATCH_NULL_STRING_P(reg_info[*p]) == MATCH_NULL_UNSET_VALUE)
REG_MATCH_NULL_STRING_P(reg_info[*p])
= group_match_null_string_p(&p1, pend, reg_info);
/* Save the position in the string where we were the last time
* we were at this open-group operator in case the group is
* operated upon by a repetition operator, e.g., with `(a*)*b'
* against `ab'; then we want to ignore where we are now in
* the string in case this attempt to match fails. */
old_regstart[*p] = REG_MATCH_NULL_STRING_P(reg_info[*p])
? REG_UNSET(regstart[*p]) ? d : regstart[*p]
: regstart[*p];
DEBUG_PRINT2(" old_regstart: %dn",
POINTER_TO_OFFSET(old_regstart[*p]));
regstart[*p] = d;
DEBUG_PRINT2(" regstart: %dn", POINTER_TO_OFFSET(regstart[*p]));
IS_ACTIVE(reg_info[*p]) = 1;
MATCHED_SOMETHING(reg_info[*p]) = 0;
/* This is the new highest active register. */
highest_active_reg = *p;
/* If nothing was active before, this is the new lowest active
* register. */
if (lowest_active_reg == NO_LOWEST_ACTIVE_REG)
lowest_active_reg = *p;
/* Move past the register number and inner group count. */
p += 2;
break;
/* The stop_memory opcode represents the end of a group. Its
* arguments are the same as start_memory's: the register
* number, and the number of inner groups. */
case stop_memory:
DEBUG_PRINT3("EXECUTING stop_memory %d (%d):n", *p, p[1]);
/* We need to save the string position the last time we were at
* this close-group operator in case the group is operated
* upon by a repetition operator, e.g., with `((a*)*(b*)*)*'
* against `aba'; then we want to ignore where we are now in
* the string in case this attempt to match fails. */
old_regend[*p] = REG_MATCH_NULL_STRING_P(reg_info[*p])
? REG_UNSET(regend[*p]) ? d : regend[*p]
: regend[*p];
DEBUG_PRINT2(" old_regend: %dn",
POINTER_TO_OFFSET(old_regend[*p]));
regend[*p] = d;
DEBUG_PRINT2(" regend: %dn", POINTER_TO_OFFSET(regend[*p]));
/* This register isn't active anymore. */
IS_ACTIVE(reg_info[*p]) = 0;
/* If this was the only register active, nothing is active
* anymore. */
if (lowest_active_reg == highest_active_reg) {
lowest_active_reg = NO_LOWEST_ACTIVE_REG;
highest_active_reg = NO_HIGHEST_ACTIVE_REG;
} else { /* We must scan for the new highest active register, since
* it isn't necessarily one less than now: consider
* (a(b)c(d(e)f)g). When group 3 ends, after the f), the
* new highest active register is 1. */
unsigned char r = *p - 1;
while (r > 0 && !IS_ACTIVE(reg_info[r]))
r--;
/* If we end up at register zero, that means that we saved
* the registers as the result of an `on_failure_jump', not
* a `start_memory', and we jumped to past the innermost
* `stop_memory'. For example, in ((.)*) we save
* registers 1 and 2 as a result of the *, but when we pop
* back to the second ), we are at the stop_memory 1.
* Thus, nothing is active. */
if (r == 0) {
lowest_active_reg = NO_LOWEST_ACTIVE_REG;
highest_active_reg = NO_HIGHEST_ACTIVE_REG;
} else
highest_active_reg = r;
}
/* If just failed to match something this time around with a
* group that's operated on by a repetition operator, try to
* force exit from the ``loop'', and restore the register
* information for this group that we had before trying this
* last match. */
if ((!MATCHED_SOMETHING(reg_info[*p])
|| (re_opcode_t) p[-3] == start_memory)
&& (p + 2) < pend) {
boolean is_a_jump_n = false;
p1 = p + 2;
mcnt = 0;
switch ((re_opcode_t) * p1++) {
case jump_n:
is_a_jump_n = true;
case pop_failure_jump:
case maybe_pop_jump:
case jump:
case dummy_failure_jump:
EXTRACT_NUMBER_AND_INCR(mcnt, p1);
if (is_a_jump_n)
p1 += 2;
break;
default:
/* do nothing */ ;
}
p1 += mcnt;
/* If the next operation is a jump backwards in the pattern
* to an on_failure_jump right before the start_memory
* corresponding to this stop_memory, exit from the loop
* by forcing a failure after pushing on the stack the
* on_failure_jump's jump in the pattern, and d. */
if (mcnt < 0 && (re_opcode_t) * p1 == on_failure_jump
&& (re_opcode_t) p1[3] == start_memory && p1[4] == *p) {
/* If this group ever matched anything, then restore
* what its registers were before trying this last
* failed match, e.g., with `(a*)*b' against `ab' for
* regstart[1], and, e.g., with `((a*)*(b*)*)*'
* against `aba' for regend[3].
*
* Also restore the registers for inner groups for,
* e.g., `((a*)(b*))*' against `aba' (register 3 would
* otherwise get trashed). */
if (EVER_MATCHED_SOMETHING(reg_info[*p])) {
unsigned r;
EVER_MATCHED_SOMETHING(reg_info[*p]) = 0;
/* Restore this and inner groups' (if any) registers. */
for (r = *p; r < *p + *(p + 1); r++) {
regstart[r] = old_regstart[r];
/* xx why this test? */
if ((long) old_regend[r] >= (long) regstart[r])
regend[r] = old_regend[r];
}
}
p1++;
EXTRACT_NUMBER_AND_INCR(mcnt, p1);
PUSH_FAILURE_POINT(p1 + mcnt, d, -2);
goto fail;
}
}
/* Move past the register number and the inner group count. */
p += 2;
break;
/* <digit> has been turned into a `duplicate' command which is
* followed by the numeric value of <digit> as the register number. */
case duplicate:
{
register const char *d2, *dend2;
int regno = *p++; /* Get which register to match against. */
DEBUG_PRINT2("EXECUTING duplicate %d.n", regno);
/* Can't back reference a group which we've never matched. */
if (REG_UNSET(regstart[regno]) || REG_UNSET(regend[regno]))
goto fail;
/* Where in input to try to start matching. */
d2 = regstart[regno];
/* Where to stop matching; if both the place to start and
* the place to stop matching are in the same string, then
* set to the place to stop, otherwise, for now have to use
* the end of the first string. */
dend2 = ((FIRST_STRING_P(regstart[regno])
== FIRST_STRING_P(regend[regno]))
? regend[regno] : end_match_1);
for (;;) {
/* If necessary, advance to next segment in register
* contents. */
while (d2 == dend2) {
if (dend2 == end_match_2)
break;
if (dend2 == regend[regno])
break;
/* End of string1 => advance to string2. */
d2 = string2;
dend2 = regend[regno];
}
/* At end of register contents => success */
if (d2 == dend2)
break;
/* If necessary, advance to next segment in data. */
PREFETCH();
/* How many characters left in this segment to match. */
mcnt = dend - d;
/* Want how many consecutive characters we can match in
* one shot, so, if necessary, adjust the count. */
if (mcnt > dend2 - d2)
mcnt = dend2 - d2;
/* Compare that many; failure if mismatch, else move
* past them. */
if (translate
? bcmp_translate(d, d2, mcnt, translate)
: memcmp(d, d2, mcnt))
goto fail;
d += mcnt, d2 += mcnt;
}
}
break;
/* begline matches the empty string at the beginning of the string
* (unless `not_bol' is set in `bufp'), and, if
* `newline_anchor' is set, after newlines. */
case begline:
DEBUG_PRINT1("EXECUTING begline.n");
if (AT_STRINGS_BEG(d)) {
if (!bufp->not_bol)
break;
} else if (d[-1] == 'n' && bufp->newline_anchor) {
break;
}
/* In all other cases, we fail. */
goto fail;
/* endline is the dual of begline. */
case endline:
DEBUG_PRINT1("EXECUTING endline.n");
if (AT_STRINGS_END(d)) {
if (!bufp->not_eol)
break;
}
/* We have to ``prefetch'' the next character. */
else if ((d == end1 ? *string2 : *d) == 'n'
&& bufp->newline_anchor) {
break;
}
goto fail;
/* Match at the very beginning of the data. */
case begbuf:
DEBUG_PRINT1("EXECUTING begbuf.n");
if (AT_STRINGS_BEG(d))
break;
goto fail;
/* Match at the very end of the data. */
case endbuf:
DEBUG_PRINT1("EXECUTING endbuf.n");
if (AT_STRINGS_END(d))
break;
goto fail;
/* on_failure_keep_string_jump is used to optimize `.*n'. It
* pushes NULL as the value for the string on the stack. Then
* `pop_failure_point' will keep the current value for the
* string, instead of restoring it. To see why, consider
* matching `foonbar' against `.*n'. The .* matches the foo;
* then the . fails against the n. But the next thing we want
* to do is match the n against the n; if we restored the
* string value, we would be back at the foo.
*
* Because this is used only in specific cases, we don't need to
* check all the things that `on_failure_jump' does, to make
* sure the right things get saved on the stack. Hence we don't
* share its code. The only reason to push anything on the
* stack at all is that otherwise we would have to change
* `anychar's code to do something besides goto fail in this
* case; that seems worse than this. */
case on_failure_keep_string_jump:
DEBUG_PRINT1("EXECUTING on_failure_keep_string_jump");
EXTRACT_NUMBER_AND_INCR(mcnt, p);
DEBUG_PRINT3(" %d (to 0x%x):n", mcnt, p + mcnt);
PUSH_FAILURE_POINT(p + mcnt, NULL, -2);
break;
/* Uses of on_failure_jump:
*
* Each alternative starts with an on_failure_jump that points
* to the beginning of the next alternative. Each alternative
* except the last ends with a jump that in effect jumps past
* the rest of the alternatives. (They really jump to the
* ending jump of the following alternative, because tensioning
* these jumps is a hassle.)
*
* Repeats start with an on_failure_jump that points past both
* the repetition text and either the following jump or
* pop_failure_jump back to this on_failure_jump. */
case on_failure_jump:
on_failure:
DEBUG_PRINT1("EXECUTING on_failure_jump");
EXTRACT_NUMBER_AND_INCR(mcnt, p);
DEBUG_PRINT3(" %d (to 0x%x)", mcnt, p + mcnt);
/* If this on_failure_jump comes right before a group (i.e.,
* the original * applied to a group), save the information
* for that group and all inner ones, so that if we fail back
* to this point, the group's information will be correct.
* For example, in (a*)*1, we need the preceding group,
* and in ((a*)b*)2, we need the inner group. */
/* We can't use `p' to check ahead because we push
* a failure point to `p + mcnt' after we do this. */
p1 = p;
/* We need to skip no_op's before we look for the
* start_memory in case this on_failure_jump is happening as
* the result of a completed succeed_n, as in (a){1,3}b1
* against aba. */
while (p1 < pend && (re_opcode_t) * p1 == no_op)
p1++;
if (p1 < pend && (re_opcode_t) * p1 == start_memory) {
/* We have a new highest active register now. This will
* get reset at the start_memory we are about to get to,
* but we will have saved all the registers relevant to
* this repetition op, as described above. */
highest_active_reg = *(p1 + 1) + *(p1 + 2);
if (lowest_active_reg == NO_LOWEST_ACTIVE_REG)
lowest_active_reg = *(p1 + 1);
}
DEBUG_PRINT1(":n");
PUSH_FAILURE_POINT(p + mcnt, d, -2);
break;
/* A smart repeat ends with `maybe_pop_jump'.
* We change it to either `pop_failure_jump' or `jump'. */
case maybe_pop_jump:
EXTRACT_NUMBER_AND_INCR(mcnt, p);
DEBUG_PRINT2("EXECUTING maybe_pop_jump %d.n", mcnt);
{
register unsigned char *p2 = p;
/* Compare the beginning of the repeat with what in the
* pattern follows its end. If we can establish that there
* is nothing that they would both match, i.e., that we
* would have to backtrack because of (as in, e.g., `a*a')
* then we can change to pop_failure_jump, because we'll
* never have to backtrack.
*
* This is not true in the case of alternatives: in
* `(a|ab)*' we do need to backtrack to the `ab' alternative
* (e.g., if the string was `ab'). But instead of trying to
* detect that here, the alternative has put on a dummy
* failure point which is what we will end up popping. */
/* Skip over open/close-group commands. */
while (p2 + 2 < pend
&& ((re_opcode_t) * p2 == stop_memory
|| (re_opcode_t) * p2 == start_memory))
p2 += 3; /* Skip over args, too. */
/* If we're at the end of the pattern, we can change. */
if (p2 == pend) {
/* Consider what happens when matching ":(.*)"
* against ":/". I don't really understand this code
* yet. */
p[-3] = (unsigned char) pop_failure_jump;
DEBUG_PRINT1
(" End of pattern: change to `pop_failure_jump'.n");
} else if ((re_opcode_t) * p2 == exactn
|| (bufp->newline_anchor && (re_opcode_t) * p2 == endline)) {
register unsigned char c
= *p2 == (unsigned char) endline ? 'n' : p2[2];
p1 = p + mcnt;
/* p1[0] ... p1[2] are the `on_failure_jump' corresponding
* to the `maybe_finalize_jump' of this case. Examine what
* follows. */
if ((re_opcode_t) p1[3] == exactn && p1[5] != c) {
p[-3] = (unsigned char) pop_failure_jump;
DEBUG_PRINT3(" %c != %c => pop_failure_jump.n",
c, p1[5]);
} else if ((re_opcode_t) p1[3] == charset
|| (re_opcode_t) p1[3] == charset_not) {
int not = (re_opcode_t) p1[3] == charset_not;
if (c < (unsigned char) (p1[4] * BYTEWIDTH)
&& p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))
not = !not;
/* `not' is equal to 1 if c would match, which means
* that we can't change to pop_failure_jump. */
if (!not) {
p[-3] = (unsigned char) pop_failure_jump;
DEBUG_PRINT1(" No match => pop_failure_jump.n");
}
}
}
}
p -= 2; /* Point at relative address again. */
if ((re_opcode_t) p[-1] != pop_failure_jump) {
p[-1] = (unsigned char) jump;
DEBUG_PRINT1(" Match => jump.n");
goto unconditional_jump;
}
/* Note fall through. */
/* The end of a simple repeat has a pop_failure_jump back to
* its matching on_failure_jump, where the latter will push a
* failure point. The pop_failure_jump takes off failure
* points put on by this pop_failure_jump's matching
* on_failure_jump; we got through the pattern to here from the
* matching on_failure_jump, so didn't fail. */
case pop_failure_jump:
{
/* We need to pass separate storage for the lowest and
* highest registers, even though we don't care about the
* actual values. Otherwise, we will restore only one
* register from the stack, since lowest will == highest in
* `pop_failure_point'. */
unsigned long dummy_low_reg, dummy_high_reg;
unsigned char *pdummy;
const char *sdummy;
DEBUG_PRINT1("EXECUTING pop_failure_jump.n");
POP_FAILURE_POINT(sdummy, pdummy,
dummy_low_reg, dummy_high_reg,
reg_dummy, reg_dummy, reg_info_dummy);
}
/* Note fall through. */
/* Unconditionally jump (without popping any failure points). */
case jump:
unconditional_jump:
EXTRACT_NUMBER_AND_INCR(mcnt, p); /* Get the amount to jump. */
DEBUG_PRINT2("EXECUTING jump %d ", mcnt);
p += mcnt; /* Do the jump. */
DEBUG_PRINT2("(to 0x%x).n", p);
break;
/* We need this opcode so we can detect where alternatives end
* in `group_match_null_string_p' et al. */
case jump_past_alt:
DEBUG_PRINT1("EXECUTING jump_past_alt.n");
goto unconditional_jump;
/* Normally, the on_failure_jump pushes a failure point, which
* then gets popped at pop_failure_jump. We will end up at
* pop_failure_jump, also, and with a pattern of, say, `a+', we
* are skipping over the on_failure_jump, so we have to push
* something meaningless for pop_failure_jump to pop. */
case dummy_failure_jump:
DEBUG_PRINT1("EXECUTING dummy_failure_jump.n");
/* It doesn't matter what we push for the string here. What
* the code at `fail' tests is the value for the pattern. */
PUSH_FAILURE_POINT(0, 0, -2);
goto unconditional_jump;
/* At the end of an alternative, we need to push a dummy failure
* point in case we are followed by a `pop_failure_jump', because
* we don't want the failure point for the alternative to be
* popped. For example, matching `(a|ab)*' against `aab'
* requires that we match the `ab' alternative. */
case push_dummy_failure:
DEBUG_PRINT1("EXECUTING push_dummy_failure.n");
/* See comments just above at `dummy_failure_jump' about the
* two zeroes. */
PUSH_FAILURE_POINT(0, 0, -2);
break;
/* Have to succeed matching what follows at least n times.
* After that, handle like `on_failure_jump'. */
case succeed_n:
EXTRACT_NUMBER(mcnt, p + 2);
DEBUG_PRINT2("EXECUTING succeed_n %d.n", mcnt);
assert(mcnt >= 0);
/* Originally, this is how many times we HAVE to succeed. */
if (mcnt > 0) {
mcnt--;
p += 2;
STORE_NUMBER_AND_INCR(p, mcnt);
DEBUG_PRINT3(" Setting 0x%x to %d.n", p, mcnt);
} else if (mcnt == 0) {
DEBUG_PRINT2(" Setting two bytes from 0x%x to no_op.n", p + 2);
p[2] = (unsigned char) no_op;
p[3] = (unsigned char) no_op;
goto on_failure;
}
break;
case jump_n:
EXTRACT_NUMBER(mcnt, p + 2);
DEBUG_PRINT2("EXECUTING jump_n %d.n", mcnt);
/* Originally, this is how many times we CAN jump. */
if (mcnt) {
mcnt--;
STORE_NUMBER(p + 2, mcnt);
goto unconditional_jump;
}
/* If don't have to jump any more, skip over the rest of command. */
else
p += 4;
break;
case set_number_at:
{
DEBUG_PRINT1("EXECUTING set_number_at.n");
EXTRACT_NUMBER_AND_INCR(mcnt, p);
p1 = p + mcnt;
EXTRACT_NUMBER_AND_INCR(mcnt, p);
DEBUG_PRINT3(" Setting 0x%x to %d.n", p1, mcnt);
STORE_NUMBER(p1, mcnt);
break;
}
case wordbound:
DEBUG_PRINT1("EXECUTING wordbound.n");
if (AT_WORD_BOUNDARY(d))
break;
goto fail;
case notwordbound:
DEBUG_PRINT1("EXECUTING notwordbound.n");
if (AT_WORD_BOUNDARY(d))
goto fail;
break;
case wordbeg:
DEBUG_PRINT1("EXECUTING wordbeg.n");
if (WORDCHAR_P(d) && (AT_STRINGS_BEG(d) || !WORDCHAR_P(d - 1)))
break;
goto fail;
case wordend:
DEBUG_PRINT1("EXECUTING wordend.n");
if (!AT_STRINGS_BEG(d) && WORDCHAR_P(d - 1)
&& (!WORDCHAR_P(d) || AT_STRINGS_END(d)))
break;
goto fail;
#ifdef emacs
#ifdef emacs19
case before_dot:
DEBUG_PRINT1("EXECUTING before_dot.n");
if (PTR_CHAR_POS((unsigned char *) d) >= point)
goto fail;
break;
case at_dot:
DEBUG_PRINT1("EXECUTING at_dot.n");
if (PTR_CHAR_POS((unsigned char *) d) != point)
goto fail;
break;
case after_dot:
DEBUG_PRINT1("EXECUTING after_dot.n");
if (PTR_CHAR_POS((unsigned char *) d) <= point)
goto fail;
break;
#else /* not emacs19 */
case at_dot:
DEBUG_PRINT1("EXECUTING at_dot.n");
if (PTR_CHAR_POS((unsigned char *) d) + 1 != point)
goto fail;
break;
#endif /* not emacs19 */
case syntaxspec:
DEBUG_PRINT2("EXECUTING syntaxspec %d.n", mcnt);
mcnt = *p++;
goto matchsyntax;
case wordchar:
DEBUG_PRINT1("EXECUTING Emacs wordchar.n");
mcnt = (int) Sword;
matchsyntax:
PREFETCH();
if (SYNTAX(*d++) != (enum syntaxcode) mcnt)
goto fail;
SET_REGS_MATCHED();
break;
case notsyntaxspec:
DEBUG_PRINT2("EXECUTING notsyntaxspec %d.n", mcnt);
mcnt = *p++;
goto matchnotsyntax;
case notwordchar:
DEBUG_PRINT1("EXECUTING Emacs notwordchar.n");
mcnt = (int) Sword;
matchnotsyntax:
PREFETCH();
if (SYNTAX(*d++) == (enum syntaxcode) mcnt)
goto fail;
SET_REGS_MATCHED();
break;
#else /* not emacs */
case wordchar:
DEBUG_PRINT1("EXECUTING non-Emacs wordchar.n");
PREFETCH();
if (!WORDCHAR_P(d))
goto fail;
SET_REGS_MATCHED();
d++;
break;
case notwordchar:
DEBUG_PRINT1("EXECUTING non-Emacs notwordchar.n");
PREFETCH();
if (WORDCHAR_P(d))
goto fail;
SET_REGS_MATCHED();
d++;
break;
#endif /* not emacs */
default:
abort();
}
continue; /* Successfully executed one pattern command; keep going. */
/* We goto here if a matching operation fails. */
fail:
if (!FAIL_STACK_EMPTY()) { /* A restart point is known. Restore to that state. */
DEBUG_PRINT1("nFAIL:n");
POP_FAILURE_POINT(d, p,
lowest_active_reg, highest_active_reg,
regstart, regend, reg_info);
/* If this failure point is a dummy, try the next one. */
if (!p)
goto fail;
/* If we failed to the end of the pattern, don't examine *p. */
assert(p <= pend);
if (p < pend) {
boolean is_a_jump_n = false;
/* If failed to a backwards jump that's part of a repetition
* loop, need to pop this failure point and use the next one. */
switch ((re_opcode_t) * p) {
case jump_n:
is_a_jump_n = true;
case maybe_pop_jump:
case pop_failure_jump:
case jump:
p1 = p + 1;
EXTRACT_NUMBER_AND_INCR(mcnt, p1);
p1 += mcnt;
if ((is_a_jump_n && (re_opcode_t) * p1 == succeed_n)
|| (!is_a_jump_n
&& (re_opcode_t) * p1 == on_failure_jump))
goto fail;
break;
default:
/* do nothing */ ;
}
}
if (d >= string1 && d <= end1)
dend = end_match_1;
} else
break; /* Matching at this starting point really fails. */
} /* for (;;) */
if (best_regs_set)
goto restore_best_regs;
FREE_VARIABLES();
return -1; /* Failure to match. */
} /* re_match_2 */
/* Subroutine definitions for re_match_2. */
/* We are passed P pointing to a register number after a start_memory.
*
* Return true if the pattern up to the corresponding stop_memory can
* match the empty string, and false otherwise.
*
* If we find the matching stop_memory, sets P to point to one past its number.
* Otherwise, sets P to an undefined byte less than or equal to END.
*
* We don't handle duplicates properly (yet). */
static boolean
group_match_null_string_p(p, end, reg_info)
unsigned char **p, *end;
register_info_type *reg_info;
{
int mcnt;
/* Point to after the args to the start_memory. */
unsigned char *p1 = *p + 2;
while (p1 < end) {
/* Skip over opcodes that can match nothing, and return true or
* false, as appropriate, when we get to one that can't, or to the
* matching stop_memory. */
switch ((re_opcode_t) * p1) {
/* Could be either a loop or a series of alternatives. */
case on_failure_jump:
p1++;
EXTRACT_NUMBER_AND_INCR(mcnt, p1);
/* If the next operation is not a jump backwards in the
* pattern. */
if (mcnt >= 0) {
/* Go through the on_failure_jumps of the alternatives,
* seeing if any of the alternatives cannot match nothing.
* The last alternative starts with only a jump,
* whereas the rest start with on_failure_jump and end
* with a jump, e.g., here is the pattern for `a|b|c':
*
* /on_failure_jump/0/6/exactn/1/a/jump_past_alt/0/6
* /on_failure_jump/0/6/exactn/1/b/jump_past_alt/0/3
* /exactn/1/c
*
* So, we have to first go through the first (n-1)
* alternatives and then deal with the last one separately. */
/* Deal with the first (n-1) alternatives, which start
* with an on_failure_jump (see above) that jumps to right
* past a jump_past_alt. */
while ((re_opcode_t) p1[mcnt - 3] == jump_past_alt) {
/* `mcnt' holds how many bytes long the alternative
* is, including the ending `jump_past_alt' and
* its number. */
if (!alt_match_null_string_p(p1, p1 + mcnt - 3,
reg_info))
return false;
/* Move to right after this alternative, including the
* jump_past_alt. */
p1 += mcnt;
/* Break if it's the beginning of an n-th alternative
* that doesn't begin with an on_failure_jump. */
if ((re_opcode_t) * p1 != on_failure_jump)
break;
/* Still have to check that it's not an n-th
* alternative that starts with an on_failure_jump. */
p1++;
EXTRACT_NUMBER_AND_INCR(mcnt, p1);
if ((re_opcode_t) p1[mcnt - 3] != jump_past_alt) {
/* Get to the beginning of the n-th alternative. */
p1 -= 3;
break;
}
}
/* Deal with the last alternative: go back and get number
* of the `jump_past_alt' just before it. `mcnt' contains
* the length of the alternative. */
EXTRACT_NUMBER(mcnt, p1 - 2);
if (!alt_match_null_string_p(p1, p1 + mcnt, reg_info))
return false;
p1 += mcnt; /* Get past the n-th alternative. */
} /* if mcnt > 0 */
break;
case stop_memory:
assert(p1[1] == **p);
*p = p1 + 2;
return true;
default:
if (!common_op_match_null_string_p(&p1, end, reg_info))
return false;
}
} /* while p1 < end */
return false;
} /* group_match_null_string_p */
/* Similar to group_match_null_string_p, but doesn't deal with alternatives:
* It expects P to be the first byte of a single alternative and END one
* byte past the last. The alternative can contain groups. */
static boolean
alt_match_null_string_p(p, end, reg_info)
unsigned char *p, *end;
register_info_type *reg_info;
{
int mcnt;
unsigned char *p1 = p;
while (p1 < end) {
/* Skip over opcodes that can match nothing, and break when we get
* to one that can't. */
switch ((re_opcode_t) * p1) {
/* It's a loop. */
case on_failure_jump:
p1++;
EXTRACT_NUMBER_AND_INCR(mcnt, p1);
p1 += mcnt;
break;
default:
if (!common_op_match_null_string_p(&p1, end, reg_info))
return false;
}
} /* while p1 < end */
return true;
} /* alt_match_null_string_p */
/* Deals with the ops common to group_match_null_string_p and
* alt_match_null_string_p.
*
* Sets P to one after the op and its arguments, if any. */
static boolean
common_op_match_null_string_p(p, end, reg_info)
unsigned char **p, *end;
register_info_type *reg_info;
{
int mcnt;
boolean ret;
int reg_no;
unsigned char *p1 = *p;
switch ((re_opcode_t) * p1++) {
case no_op:
case begline:
case endline:
case begbuf:
case endbuf:
case wordbeg:
case wordend:
case wordbound:
case notwordbound:
#ifdef emacs
case before_dot:
case at_dot:
case after_dot:
#endif
break;
case start_memory:
reg_no = *p1;
assert(reg_no > 0 && reg_no <= MAX_REGNUM);
ret = group_match_null_string_p(&p1, end, reg_info);
/* Have to set this here in case we're checking a group which
* contains a group and a back reference to it. */
if (REG_MATCH_NULL_STRING_P(reg_info[reg_no]) == MATCH_NULL_UNSET_VALUE)
REG_MATCH_NULL_STRING_P(reg_info[reg_no]) = ret;
if (!ret)
return false;
break;
/* If this is an optimized succeed_n for zero times, make the jump. */
case jump:
EXTRACT_NUMBER_AND_INCR(mcnt, p1);
if (mcnt >= 0)
p1 += mcnt;
else
return false;
break;
case succeed_n:
/* Get to the number of times to succeed. */
p1 += 2;
EXTRACT_NUMBER_AND_INCR(mcnt, p1);
if (mcnt == 0) {
p1 -= 4;
EXTRACT_NUMBER_AND_INCR(mcnt, p1);
p1 += mcnt;
} else
return false;
break;
case duplicate:
if (!REG_MATCH_NULL_STRING_P(reg_info[*p1]))
return false;
break;
case set_number_at:
p1 += 4;
default:
/* All other opcodes mean we cannot match the empty string. */
return false;
}
*p = p1;
return true;
} /* common_op_match_null_string_p */
/* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN
* bytes; nonzero otherwise. */
static int
bcmp_translate(s1, s2, len, translate)
unsigned char *s1, *s2;
register int len;
char *translate;
{
register unsigned char *p1 = s1, *p2 = s2;
while (len) {
if (translate[*p1++] != translate[*p2++])
return 1;
len--;
}
return 0;
}
/* Entry points for GNU code. */
/* re_compile_pattern is the GNU regular expression compiler: it
* compiles PATTERN (of length SIZE) and puts the result in BUFP.
* Returns 0 if the pattern was valid, otherwise an error string.
*
* Assumes the `allocated' (and perhaps `buffer') and `translate' fields
* are set in BUFP on entry.
*
* We call regex_compile to do the actual compilation. */
const char *
re_compile_pattern(pattern, length, bufp)
const char *pattern;
int length;
struct re_pattern_buffer *bufp;
{
reg_errcode_t ret;
/* GNU code is written to assume at least RE_NREGS registers will be set
* (and at least one extra will be -1). */
bufp->regs_allocated = REGS_UNALLOCATED;
/* And GNU code determines whether or not to get register information
* by passing null for the REGS argument to re_match, etc., not by
* setting no_sub. */
bufp->no_sub = 0;
/* Match anchors at newline. */
bufp->newline_anchor = 1;
ret = regex_compile(pattern, length, re_syntax_options, bufp);
return re_error_msg[(int) ret];
}
/* Entry points compatible with 4.2 BSD regex library. We don't define
* them if this is an Emacs or POSIX compilation. */
#if !defined (emacs) && !defined (_POSIX_SOURCE)
/* BSD has one and only one pattern buffer. */
static struct re_pattern_buffer re_comp_buf;
char *
re_comp(s)
const char *s;
{
reg_errcode_t ret;
if (!s) {
if (!re_comp_buf.buffer)
return "No previous regular expression";
return 0;
}
if (!re_comp_buf.buffer) {
re_comp_buf.buffer = (unsigned char *) malloc(200);
if (re_comp_buf.buffer == NULL)
return "Memory exhausted";
re_comp_buf.allocated = 200;
re_comp_buf.fastmap = (char *) malloc(1 << BYTEWIDTH);
if (re_comp_buf.fastmap == NULL)
return "Memory exhausted";
}
/* Since `re_exec' always passes NULL for the `regs' argument, we
* don't need to initialize the pattern buffer fields which affect it. */
/* Match anchors at newlines. */
re_comp_buf.newline_anchor = 1;
ret = regex_compile(s, strlen(s), re_syntax_options, &re_comp_buf);
/* Yes, we're discarding `const' here. */
return (char *) re_error_msg[(int) ret];
}
int
re_exec(s)
const char *s;
{
const int len = strlen(s);
return
0 <= re_search(&re_comp_buf, s, len, 0, len, (struct re_registers *) 0);
}
#endif /* not emacs and not _POSIX_SOURCE */
/* POSIX.2 functions. Don't define these for Emacs. */
#ifndef emacs
/* regcomp takes a regular expression as a string and compiles it.
*
* PREG is a regex_t *. We do not expect any fields to be initialized,
* since POSIX says we shouldn't. Thus, we set
*
* `buffer' to the compiled pattern;
* `used' to the length of the compiled pattern;
* `syntax' to RE_SYNTAX_POSIX_EXTENDED if the
* REG_EXTENDED bit in CFLAGS is set; otherwise, to
* RE_SYNTAX_POSIX_BASIC;
* `newline_anchor' to REG_NEWLINE being set in CFLAGS;
* `fastmap' and `fastmap_accurate' to zero;
* `re_nsub' to the number of subexpressions in PATTERN.
*
* PATTERN is the address of the pattern string.
*
* CFLAGS is a series of bits which affect compilation.
*
* If REG_EXTENDED is set, we use POSIX extended syntax; otherwise, we
* use POSIX basic syntax.
*
* If REG_NEWLINE is set, then . and [^...] don't match newline.
* Also, regexec will try a match beginning after every newline.
*
* If REG_ICASE is set, then we considers upper- and lowercase
* versions of letters to be equivalent when matching.
*
* If REG_NOSUB is set, then when PREG is passed to regexec, that
* routine will report only success or failure, and nothing about the
* registers.
*
* It returns 0 if it succeeds, nonzero if it doesn't. (See regex.h for
* the return codes and their meanings.) */
int
regcomp(preg, pattern, cflags)
regex_t *preg;
const char *pattern;
int cflags;
{
reg_errcode_t ret;
unsigned syntax
= (cflags & REG_EXTENDED) ?
RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC;
/* regex_compile will allocate the space for the compiled pattern. */
preg->buffer = 0;
preg->allocated = 0;
/* Don't bother to use a fastmap when searching. This simplifies the
* REG_NEWLINE case: if we used a fastmap, we'd have to put all the
* characters after newlines into the fastmap. This way, we just try
* every character. */
preg->fastmap = 0;
if (cflags & REG_ICASE) {
unsigned i;
preg->translate = (char *) malloc(CHAR_SET_SIZE);
if (preg->translate == NULL)
return (int) REG_ESPACE;
/* Map uppercase characters to corresponding lowercase ones. */
for (i = 0; i < CHAR_SET_SIZE; i++)
preg->translate[i] = ISUPPER(i) ? tolower(i) : i;
} else
preg->translate = NULL;
/* If REG_NEWLINE is set, newlines are treated differently. */
if (cflags & REG_NEWLINE) { /* REG_NEWLINE implies neither . nor [^...] match newline. */
syntax &= ~RE_DOT_NEWLINE;
syntax |= RE_HAT_LISTS_NOT_NEWLINE;
/* It also changes the matching behavior. */
preg->newline_anchor = 1;
} else
preg->newline_anchor = 0;
preg->no_sub = !!(cflags & REG_NOSUB);
/* POSIX says a null character in the pattern terminates it, so we
* can use strlen here in compiling the pattern. */
ret = regex_compile(pattern, strlen(pattern), syntax, preg);
/* POSIX doesn't distinguish between an unmatched open-group and an
* unmatched close-group: both are REG_EPAREN. */
if (ret == REG_ERPAREN)
ret = REG_EPAREN;
return (int) ret;
}
/* regexec searches for a given pattern, specified by PREG, in the
* string STRING.
*
* If NMATCH is zero or REG_NOSUB was set in the cflags argument to
* `regcomp', we ignore PMATCH. Otherwise, we assume PMATCH has at
* least NMATCH elements, and we set them to the offsets of the
* corresponding matched substrings.
*
* EFLAGS specifies `execution flags' which affect matching: if
* REG_NOTBOL is set, then ^ does not match at the beginning of the
* string; if REG_NOTEOL is set, then $ does not match at the end.
*
* We return 0 if we find a match and REG_NOMATCH if not. */
int
regexec(preg, string, nmatch, pmatch, eflags)
const regex_t *preg;
const char *string;
size_t nmatch;
regmatch_t pmatch[];
int eflags;
{
int ret;
struct re_registers regs;
regex_t private_preg;
int len = strlen(string);
boolean want_reg_info = !preg->no_sub && nmatch > 0;
private_preg = *preg;
private_preg.not_bol = !!(eflags & REG_NOTBOL);
private_preg.not_eol = !!(eflags & REG_NOTEOL);
/* The user has told us exactly how many registers to return
* information about, via `nmatch'. We have to pass that on to the
* matching routines. */
private_preg.regs_allocated = REGS_FIXED;
if (want_reg_info) {
regs.num_regs = nmatch;
regs.start = TALLOC(nmatch, regoff_t);
regs.end = TALLOC(nmatch, regoff_t);
if (regs.start == NULL || regs.end == NULL)
return (int) REG_NOMATCH;
}
/* Perform the searching operation. */
ret = re_search(&private_preg, string, len,
/* start: */ 0, /* range: */ len,
want_reg_info ? &regs : (struct re_registers *) 0);
/* Copy the register information to the POSIX structure. */
if (want_reg_info) {
if (ret >= 0) {
unsigned r;
for (r = 0; r < nmatch; r++) {
pmatch[r].rm_so = regs.start[r];
pmatch[r].rm_eo = regs.end[r];
}
}
/* If we needed the temporary register info, free the space now. */
free(regs.start);
free(regs.end);
}
/* We want zero return to mean success, unlike `re_search'. */
return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH;
}
/* Returns a message corresponding to an error code, ERRCODE, returned
* from either regcomp or regexec. We don't use PREG here. */
size_t
regerror(errcode, preg, errbuf, errbuf_size)
int errcode;
const regex_t *preg;
char *errbuf;
size_t errbuf_size;
{
const char *msg;
size_t msg_size;
if (errcode < 0
|| errcode >= (sizeof(re_error_msg) / sizeof(re_error_msg[0])))
/* Only error codes returned by the rest of the code should be passed
* to this routine. If we are given anything else, or if other regex
* code generates an invalid error code, then the program has a bug.
* Dump core so we can fix it. */
abort();
msg = re_error_msg[errcode];
/* POSIX doesn't require that we do anything in this case, but why
* not be nice. */
if (!msg)
msg = "Success";
msg_size = strlen(msg) + 1; /* Includes the null. */
if (errbuf_size != 0) {
if (msg_size > errbuf_size) {
strncpy(errbuf, msg, errbuf_size - 1);
errbuf[errbuf_size - 1] = 0;
} else
strcpy(errbuf, msg);
}
return msg_size;
}
/* Free dynamically allocated space used by PREG. */
void
regfree(preg)
regex_t *preg;
{
if (preg->buffer != NULL)
free(preg->buffer);
preg->buffer = NULL;
preg->allocated = 0;
preg->used = 0;
if (preg->fastmap != NULL)
free(preg->fastmap);
preg->fastmap = NULL;
preg->fastmap_accurate = 0;
if (preg->translate != NULL)
free(preg->translate);
preg->translate = NULL;
}
#endif /* not emacs */
/*
* Local variables:
* make-backup-files: t
* version-control: t
* trim-versions-without-asking: nil
* End:
*/