/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* IMPORTANT NOTE:
*
* regex() WORKS **ONLY** WITH THE ASCII AND THE Solaris EUC CHARACTER SETS.
* IT IS **NOT** CHARACTER SET INDEPENDENT.
*
*/
#include "lint.h"
/* CONSTANTS SHARED WITH regcmp() */
#include "regex.h"
#include "mtlib.h"
#include <limits.h>
#include <stdarg.h>
#include <stdlib.h>
#include <thread.h>
#include <widec.h>
#include "tsd.h"
/* PRIVATE CONSTANTS */
/* PRIVATE TYPE DEFINITIONS */
typedef enum {
NOT_IN_CLASS = 0,
typedef enum {
TESTING_CHAR = 0,
/* PRIVATE GLOBAL VARIABLES */
static const char **stringp_stackp;
/* DECLARATIONS OF PRIVATE FUNCTIONS */
static int
const char *stringp);
static void
get_match_counts(int *nmust_matchp,
int *nextra_matches_allowedp,
const char *count_stringp);
static boolean_t
static const char *
pop_stringp(void);
static const char *
previous_charp(const char *current_charp);
static const char *
push_stringp(const char *stringp);
static char_test_result_t
const char *classp,
static char_test_result_t
const char *classp,
/* FOR COMPATIBILITY WITH PREVIOUS ASCII VERSIONS OF regcmp() */
static char_test_result_t
const char *classp,
static const char *
test_repeated_ascii_char(const char *repeat_startp,
const char *stringp,
const char *regexp);
static const char *
test_repeated_multibyte_char(const char *repeat_startp,
const char *stringp,
const char *regexp);
static const char *
test_repeated_group(const char *repeat_startp,
const char *stringp,
const char *regexp);
static const char *
test_string(const char *stringp,
const char *regexp);
/* DEFINITIONS OF PUBLIC VARIABLES */
char *__loc1;
/*
* reserve thread-specific storage for __loc1
*/
char **
____loc1(void)
{
if (thr_main())
return (&__loc1);
}
/* DEFINITION OF regex() */
extern char *
{
int char_size;
const char *end_of_matchp;
char *returned_substringp;
int substringn;
const char *substringp;
if (____loc1() == (char **)0) {
return ((char *)0);
} else {
__loc1 = (char *)0;
}
return ((char *)0);
}
/* INITIALIZE SUBSTRINGS THAT MIGHT BE RETURNED IN VARARGS */
substringn = 0;
while (substringn < NSUBSTRINGS) {
substring_startp[substringn] = (char *)0;
substringn++;
}
/* TEST THE STRING AGAINST THE REGULAR EXPRESSION */
end_of_matchp = (char *)0;
if ((int)*regexp == (int)START_OF_STRING_MARK) {
/*
* the match must start at the beginning of the string
*/
regexp++;
} else if ((int)*regexp == (int)ASCII_CHAR) {
/*
* test a string against a regular expression
* that starts with a single ASCII character:
*
* move to each character in the string that matches
* the first character in the regular expression
* and test the remaining string
*/
stringp++;
}
if (end_of_matchp != (char *)0) {
} else {
stringp++;
stringp++;
}
}
}
} else if (!multibyte) {
/*
* if the value of the "multibyte" macro defined in <euc.h>
* is false, regex() is running in an ASCII locale;
* test an ASCII string against an ASCII regular expression
* that doesn't start with a single ASCII character:
*
* move forward in the string one byte at a time, testing
* the remaining string against the regular expression
*/
stringp++;
}
if (end_of_matchp != (char *)0) {
}
} else if ((int)*regexp == (int)MULTIBYTE_CHAR) {
/*
* test a multibyte string against a multibyte regular expression
* that starts with a single multibyte character:
*
* move to each character in the string that matches
* the first character in the regular expression
* and test the remaining string
*/
}
while ((end_of_matchp == (char *)0) && (char_size > 0)) {
if (end_of_matchp != (char *)0) {
} else {
}
}
}
} else {
/*
* test a multibyte string against a multibyte regular expression
* that doesn't start with a single multibyte character
*
* move forward in the string one multibyte character at a time,
* testing the remaining string against the regular expression
*/
while ((end_of_matchp == (char *)0) && (char_size > 0)) {
}
if (end_of_matchp != (char *)0) {
}
}
/*
* Return substrings that matched subexpressions for which
* matching substrings are to be returned.
*
* NOTE:
*
* According to manual page regcmp(3G), regex() returns substrings
* that match subexpressions even when no substring matches the
* entire regular expression.
*/
substringn = 0;
while (substringn < NSUBSTRINGS) {
if ((substringp != (char *)0) &&
(return_arg_number[substringn] >= 0)) {
if (returned_substringp != (char *)0) {
*returned_substringp = (char)*substringp;
substringp++;
}
*returned_substringp = '\0';
}
}
substringn++;
}
return ((char *)end_of_matchp);
} /* regex() */
/* DEFINITIONS OF PRIVATE FUNCTIONS */
static int
const char *stringp)
{
int char_size;
if (stringp == (char *)0) {
char_size = 0;
} else if (*stringp == '\0') {
char_size = 0;
} else if ((unsigned char)*stringp <= (unsigned char)0x7f) {
char_size = 1;
} else {
}
return (char_size);
}
static void
int *nextra_matches_allowedp,
const char *count_stringp)
{
int minimum_match_count;
int maximum_match_count;
(int)((unsigned int)*count_stringp & SINGLE_BYTE_MASK);
(int)((unsigned int)*count_stringp & SINGLE_BYTE_MASK);
if (maximum_match_count == (int)UNLIMITED) {
*nextra_matches_allowedp = (int)UNLIMITED;
} else {
}
return;
} /* get_match_counts() */
static boolean_t
{
} /* in_wchar_range() */
static const char *
pop_stringp(void)
{
const char *stringp;
return ((char *)0);
} else {
return (stringp);
}
}
static const char *
{
/*
* returns the pointer to the previous character in
* a string of multibyte characters
*/
const char *prev_charp;
if ((unsigned char)*prev_cs0 <= 0x7f) {
} else {
}
return (prev_charp);
} /* previous_charp() */
static const char *
{
if (stringp_stackp <= &stringp_stack[0]) {
return ((char *)0);
} else {
return (stringp);
}
}
static char_test_result_t
const char *classp,
{
/*
* tests a character for membership in an ASCII character class compiled
* by the internationalized version of regcmp();
*
* NOTE: The internationalized version of regcmp() compiles
* the range a-z in an ASCII character class to aTHRUz.
*/
int nbytes_to_check;
nbytes_to_check = (int)*classp;
classp++;
while (nbytes_to_check > 0) {
if (test_condition == IN_CLASS)
return (CONDITION_TRUE);
else
return (CONDITION_FALSE);
if (test_condition == IN_CLASS)
return (CONDITION_TRUE);
else
return (CONDITION_FALSE);
} else {
classp += 2;
nbytes_to_check -= 2;
}
} else {
classp++;
}
}
if (test_condition == NOT_IN_CLASS) {
return (CONDITION_TRUE);
} else {
return (CONDITION_FALSE);
}
} /* test_char_against_ascii_class() */
static char_test_result_t
const char *classp,
{
/*
* tests a character for membership in a multibyte character class;
*
* NOTE: The range a-z in a multibyte character class compiles to
* aTHRUz.
*/
int char_size;
int nbytes_to_check;
nbytes_to_check = (int)*classp;
classp++;
if (char_size <= 0) {
return (CHAR_TEST_ERROR);
} else if (test_char == current_char) {
if (test_condition == IN_CLASS) {
return (CONDITION_TRUE);
} else {
return (CONDITION_FALSE);
}
} else {
}
while (nbytes_to_check > 0) {
if (char_size <= 0) {
return (CHAR_TEST_ERROR);
} else if (test_char == current_char) {
if (test_condition == IN_CLASS) {
return (CONDITION_TRUE);
} else {
return (CONDITION_FALSE);
}
} else if (current_char == THRU) {
if (char_size <= 0) {
return (CHAR_TEST_ERROR);
current_char)) {
if (test_condition == IN_CLASS) {
return (CONDITION_TRUE);
} else {
return (CONDITION_FALSE);
}
} else {
}
} else {
}
}
if (test_condition == NOT_IN_CLASS) {
return (CONDITION_TRUE);
} else {
return (CONDITION_FALSE);
}
} /* test_char_against_multibyte_class() */
/* FOR COMPATIBILITY WITH PREVIOUS ASCII VERSIONS OF regcmp() */
static char_test_result_t
const char *classp,
{
/*
* tests a character for membership in an ASCII character class compiled
* by the ASCII version of regcmp();
*
* NOTE: ASCII versions of regcmp() compile the range a-z in an
* ASCII character class to THRUaz. The internationalized
* version compiles the same range to aTHRUz.
*/
int nbytes_to_check;
nbytes_to_check = (int)*classp;
classp++;
while (nbytes_to_check > 0) {
if (test_condition == IN_CLASS) {
return (CONDITION_TRUE);
} else {
return (CONDITION_FALSE);
}
if (test_condition == IN_CLASS) {
return (CONDITION_TRUE);
} else {
return (CONDITION_FALSE);
}
} else {
classp += 3;
nbytes_to_check -= 3;
}
} else {
classp++;
}
}
if (test_condition == NOT_IN_CLASS) {
return (CONDITION_TRUE);
} else {
return (CONDITION_FALSE);
}
} /* test_char_against_old_ascii_class() */
static const char *
const char *stringp,
const char *regexp)
{
const char *end_of_matchp;
while ((end_of_matchp == (char *)0) &&
(stringp > repeat_startp)) {
stringp--;
}
return (end_of_matchp);
}
static const char *
const char *stringp,
const char *regexp)
{
const char *end_of_matchp;
while ((end_of_matchp == (char *)0) &&
(stringp > repeat_startp)) {
}
return (end_of_matchp);
}
static const char *
const char *stringp,
const char *regexp)
{
const char *end_of_matchp;
while ((end_of_matchp == (char *)0) &&
(stringp > repeat_startp)) {
stringp = pop_stringp();
if (stringp == (char *)0) {
return ((char *)0);
}
}
return (end_of_matchp);
}
static const char *
const char *regexp)
{
/*
* returns a pointer to the first character following the first
* substring of the string addressed by stringp that matches
* the compiled regular expression addressed by regexp
*/
unsigned int group_length;
int nmust_match;
int regex_char_size;
const char *repeat_startp;
unsigned int return_argn;
int string_char_size;
unsigned int substringn;
const char *test_stringp;
for (;;) {
/*
* Exit the loop via a return whenever there's a match
* or it's clear that there can be no match.
*/
switch ((int)*regexp) {
/*
* No fall-through.
* Each case ends with either a return or with stringp
* addressing the next character to be tested and regexp
* addressing the next compiled regular expression
*
* NOTE: The comments for each case give the meaning
* of the compiled regular expression decoded by the case
* and the character string that the compiled regular
* expression uses to encode the case. Each single
* character encoded in the compiled regular expression
* is shown enclosed in angle brackets (<>). Each
* compiled regular expression begins with a marker
* character which is shown as a named constant
* (e.g. <ASCII_CHAR>). Character constants are shown
* enclosed in single quotes (e.g. <'$'>). All other
* single characters encoded in the compiled regular
* expression are shown as lower case variable names
* (e.g. <ascii_char> or <multibyte_char>). Multicharacter
* strings encoded in the compiled regular expression
* are shown as variable names followed by elipses
* (e.g. <compiled_regex...>).
*/
case ASCII_CHAR: /* single ASCII char */
/* encoded as <ASCII_CHAR><ascii_char> */
regexp++;
regexp++;
stringp++;
} else {
return ((char *)0);
}
break; /* end case ASCII_CHAR */
case MULTIBYTE_CHAR: /* single multibyte char */
/* encoded as <MULTIBYTE_CHAR><multibyte_char> */
regexp++;
return ((char *)0);
} else {
}
break; /* end case MULTIBYTE_CHAR */
case ANY_CHAR: /* any single ASCII or multibyte char */
/* encoded as <ANY_CHAR> */
if (!multibyte) {
if (*stringp == '\0') {
return ((char *)0);
} else {
regexp++;
stringp++;
}
} else {
if (string_char_size <= 0) {
return ((char *)0);
} else {
regexp++;
}
}
break; /* end case ANY_CHAR */
case IN_ASCII_CHAR_CLASS: /* [.....] */
case NOT_IN_ASCII_CHAR_CLASS:
/*
* encoded as <IN_ASCII_CHAR_CLASS><class_length><class...>
* or <NOT_IN_ASCII_CHAR_CLASS><class_length><class...>
*
* NOTE: <class_length> includes the <class_length> byte
*/
if ((int)*regexp == (int)IN_ASCII_CHAR_CLASS) {
} else {
}
regexp++; /* point to the <class_length> byte */
if ((*stringp != '\0') &&
test_condition) == CONDITION_TRUE)) {
stringp++;
} else {
return ((char *)0);
}
break; /* end case IN_ASCII_CHAR_CLASS */
case IN_MULTIBYTE_CHAR_CLASS: /* [....] */
/*
* encoded as <IN_MULTIBYTE_CHAR_CLASS><class_length><class...>
* or <NOT_IN_MULTIBYTE_CHAR_CLASS><class_length><class...>
*
* NOTE: <class_length> includes the <class_length> byte
*/
if ((int)*regexp == (int)IN_MULTIBYTE_CHAR_CLASS) {
} else {
}
regexp++; /* point to the <class_length> byte */
if ((string_char_size > 0) &&
test_condition) == CONDITION_TRUE)) {
} else {
return ((char *)0);
}
break; /* end case IN_MULTIBYTE_CHAR_CLASS */
case IN_OLD_ASCII_CHAR_CLASS: /* [...] */
/*
* encoded as <IN_OLD_ASCII_CHAR_CLASS><class_length><class...>
* or <NOT_IN_OLD_ASCII_CHAR_CLASS><class_length><class...>
*
* NOTE: <class_length> includes the <class_length> byte
*/
if ((int)*regexp == (int)IN_OLD_ASCII_CHAR_CLASS) {
} else {
}
regexp++; /* point to the <class_length> byte */
if ((*stringp != '\0') &&
test_condition) == CONDITION_TRUE)) {
stringp++;
} else {
return ((char *)0);
}
break; /* end case [NOT_]IN_OLD_ASCII_CHAR_CLASS */
case SIMPLE_GROUP: /* (.....) */
/* encoded as <SIMPLE_GROUP><group_length> */
regexp += 2;
break; /* end case SIMPLE_GROUP */
case END_GROUP: /* (.....) */
/* encoded as <END_GROUP><groupn> */
regexp += 2;
break; /* end case END_GROUP */
case SAVED_GROUP: /* (.....)$0-9 */
/* encoded as <SAVED_GROUP><substringn> */
regexp++;
substringn = (unsigned int)*regexp;
if (substringn >= NSUBSTRINGS)
return ((char *)0);
regexp++;
break; /* end case SAVED_GROUP */
case END_SAVED_GROUP: /* (.....)$0-9 */
/*
* encoded as <END_SAVED_GROUP><substringn>\
* <return_arg_number[substringn]>
*/
regexp++;
substringn = (unsigned int)*regexp;
if (substringn >= NSUBSTRINGS)
return ((char *)0);
regexp++;
return_argn = (unsigned int)*regexp;
if (return_argn >= NSUBSTRINGS)
return ((char *)0);
regexp++;
break; /* end case END_SAVED_GROUP */
/* encoded as <ASCII_CHAR|ZERO_OR_MORE><ascii_char> */
regexp++;
stringp++;
}
regexp++;
return (test_repeated_ascii_char(repeat_startp,
/* end case ASCII_CHAR|ZERO_OR_MORE */
/* encoded as <ASCII_CHAR|ONE_OR_MORE><ascii_char> */
regexp++;
return ((char *)0);
} else {
stringp++;
stringp++;
}
regexp++;
regexp));
}
/* end case ASCII_CHAR|ONE_OR_MORE */
/*
* encoded as <ASCII_CHAR|COUNT><ascii_char>\
* <minimum_match_count><maximum_match_count>
*/
regexp++;
regexp + 1);
nmust_match--;
stringp++;
}
if (nmust_match > 0) {
return ((char *)0);
} else if (nextra_matches_allowed == UNLIMITED) {
stringp++;
}
regexp += 3;
regexp));
} else {
(nextra_matches_allowed > 0)) {
stringp++;
}
regexp += 3;
regexp));
}
/* end case ASCII_CHAR|COUNT */
/* encoded as <MULTIBYTE_CHAR|ZERO_OR_MORE><multibyte_char> */
regexp++;
while ((string_char_size > 0) &&
(string_wchar == regex_wchar)) {
}
regexp));
/* end case MULTIBYTE_CHAR|ZERO_OR_MORE */
/* encoded as <MULTIBYTE_CHAR|ONE_OR_MORE><multibyte_char> */
regexp++;
return ((char *)0);
} else {
while ((string_char_size > 0) &&
(string_wchar == regex_wchar)) {
}
regexp));
}
/* end case MULTIBYTE_CHAR|ONE_OR_MORE */
/*
* encoded as <MULTIBYTE_CHAR|COUNT><multibyte_char>\
* <minimum_match_count><maximum_match_count>
*/
regexp++;
while ((string_char_size > 0) &&
(string_wchar == regex_wchar) &&
(nmust_match > 0)) {
nmust_match--;
}
if (nmust_match > 0) {
return ((char *)0);
} else if (nextra_matches_allowed == UNLIMITED) {
while ((string_char_size > 0) &&
(string_wchar == regex_wchar)) {
}
regexp));
} else {
while ((string_char_size > 0) &&
(string_wchar == regex_wchar) &&
(nextra_matches_allowed > 0)) {
}
regexp));
}
/* end case MULTIBYTE_CHAR|COUNT */
/* encoded as <ANY_CHAR|ZERO_OR_MORE> */
if (!multibyte) {
while (*stringp != '\0') {
stringp++;
}
regexp++;
regexp));
} else {
while (string_char_size > 0) {
}
regexp++;
regexp));
}
/* end case <ANY_CHAR|ZERO_OR_MORE> */
/* encoded as <ANY_CHAR|ONE_OR_MORE> */
if (!multibyte) {
if (*stringp == '\0') {
return ((char *)0);
} else {
stringp++;
while (*stringp != '\0') {
stringp++;
}
regexp++;
regexp));
}
} else {
if (string_char_size <= 0) {
return ((char *)0);
} else {
while (string_char_size > 0) {
}
regexp++;
}
}
/* end case <ANY_CHAR|ONE_OR_MORE> */
/*
* encoded as <ANY_CHAR|COUNT>\
* <minimum_match_count><maximum_match_count>
*/
regexp + 1);
if (!multibyte) {
nmust_match--;
stringp++;
}
if (nmust_match > 0) {
return ((char *)0);
} else if (nextra_matches_allowed == UNLIMITED) {
while (*stringp != '\0') {
stringp++;
}
regexp += 3;
regexp));
} else {
while ((*stringp != '\0') &&
(nextra_matches_allowed > 0)) {
stringp++;
}
regexp += 3;
regexp));
}
} else { /* multibyte character */
while ((string_char_size > 0) && (nmust_match > 0)) {
nmust_match--;
}
if (nmust_match > 0) {
return ((char *)0);
} else if (nextra_matches_allowed == UNLIMITED) {
while (string_char_size > 0) {
}
regexp += 3;
} else {
while ((string_char_size > 0) &&
(nextra_matches_allowed > 0)) {
}
regexp += 3;
}
} /* end case ANY_CHAR|COUNT */
/*
* encoded as <IN_ASCII_CHAR_CLASS|ZERO_OR_MORE>\
* <class_length><class ...>
* or <NOT_IN_ASCII_CHAR_CLASS|ZERO_OR_MORE>\
* <class_length><class ...>
*
* NOTE: <class_length> includes the <class_length> byte
*/
} else {
}
regexp++; /* point to the <class_length> byte */
while ((*stringp != '\0') &&
test_condition) == CONDITION_TRUE)) {
stringp++;
}
regexp));
/* end case IN_ASCII_CHAR_CLASS|ZERO_OR_MORE */
/*
* encoded as <IN_ASCII_CHAR_CLASS|ONE_OR_MORE>\
* <class_length><class ...>
* or <NOT_IN_ASCII_CHAR_CLASS|ONE_OR_MORE>\
* <class_length><class ...>
*
* NOTE: <class_length> includes the <class_length> byte
*/
} else {
}
regexp++; /* point to the <class_length> byte */
if ((*stringp == '\0') ||
test_condition) != CONDITION_TRUE)) {
return ((char *)0);
} else {
stringp++;
while ((*stringp != '\0') &&
test_condition) == CONDITION_TRUE)) {
stringp++;
}
regexp));
}
/* end case IN_ASCII_CHAR_CLASS|ONE_OR_MORE */
case NOT_IN_ASCII_CHAR_CLASS | COUNT:
/*
* endoded as <IN_ASCII_CHAR_CLASS|COUNT><class_length>\
* <class ...><minimum_match_count>\
* <maximum_match_count>
* or <NOT_IN_ASCII_CHAR_CLASS|COUNT><class_length>\
* <class ...><minimum_match_count>\
* <maximum_match_count>
*
* NOTE: <class_length> includes the <class_length> byte,
* but not the <minimum_match_count> or
* <maximum_match_count> bytes
*/
} else {
}
regexp++; /* point to the <class_length> byte */
while ((*stringp != '\0') &&
test_condition) == CONDITION_TRUE) &&
(nmust_match > 0)) {
nmust_match--;
stringp++;
}
if (nmust_match > 0) {
return ((char *)0);
} else if (nextra_matches_allowed == UNLIMITED) {
while ((*stringp != '\0') &&
test_condition) == CONDITION_TRUE)) {
stringp++;
}
regexp));
} else {
while ((*stringp != '\0') &&
test_condition) == CONDITION_TRUE) &&
(nextra_matches_allowed > 0)) {
stringp++;
}
regexp));
}
/* end case IN_ASCII_CHAR_CLASS|COUNT */
/*
* encoded as <IN_MULTIBYTE_CHAR_CLASS|ZERO_OR_MORE>\
* <class_length><class ...>
* or <NOT_IN_MULTIBYTE_CHAR_CLASS|ZERO_OR_MORE>\
* <class_length><class ...>
*
* NOTE: <class_length> includes the <class_length> byte
*/
if ((int)*regexp ==
(int)(IN_MULTIBYTE_CHAR_CLASS|ZERO_OR_MORE)) {
} else {
}
regexp++; /* point to the <class_length> byte */
while ((string_char_size > 0) &&
test_condition) == CONDITION_TRUE)) {
}
regexp));
/* end case IN_MULTIBYTE_CHAR_CLASS|ZERO_OR_MORE */
/*
* encoded as <IN_MULTIBYTE_CHAR_CLASS|ONE_OR_MORE>\
* <class_length><class ...>
* or <NOT_IN_MULTIBYTE_CHAR_CLASS|ONE_OR_MORE>\
* <class_length><class ...>
*
* NOTE: <class_length> includes the <class_length> byte
*/
if ((int)*regexp ==
(int)(IN_MULTIBYTE_CHAR_CLASS|ONE_OR_MORE)) {
} else {
}
regexp++; /* point to the <class_length> byte */
if ((string_char_size <= 0) ||
test_condition) != CONDITION_TRUE)) {
return ((char *)0);
} else {
while ((string_char_size > 0) &&
}
regexp));
}
/* end case IN_MULTIBYTE_CHAR_CLASS|ONE_OR_MORE */
/*
* encoded as <IN_MULTIBYTE_CHAR_CLASS|COUNT>\
* <class_length><class ...><min_count><max_count>
* or <NOT_IN_MULTIBYTE_CHAR_CLASS|COUNT>\
* <class_length><class ...><min_count><max_count>
*
* NOTE: <class_length> includes the <class_length> byte
* but not the <minimum_match_count> or
* <maximum_match_count> bytes
*/
} else {
}
regexp++; /* point to the <class_length> byte */
while ((string_char_size > 0) &&
test_condition) == CONDITION_TRUE) &&
(nmust_match > 0)) {
nmust_match--;
}
if (nmust_match > 0) {
return ((char *)0);
} else if (nextra_matches_allowed == UNLIMITED) {
while ((string_char_size > 0) &&
}
regexp));
} else {
while ((string_char_size > 0) &&
(nextra_matches_allowed > 0)) {
}
regexp));
}
/* end case IN_MULTIBYTE_CHAR_CLASS|COUNT */
/*
* encoded as <IN_OLD_ASCII_CHAR_CLASS|ZERO_OR_MORE>\
* <class_length><class ...>
* or <NOT_IN_OLD_ASCII_CHAR_CLASS|ZERO_OR_MORE>\
* <class_length><class ...>
*
* NOTE: <class_length> includes the <class_length> byte
*/
if ((int)*regexp ==
(int)(IN_OLD_ASCII_CHAR_CLASS|ZERO_OR_MORE)) {
} else {
}
regexp++; /* point to the <class_length> byte */
while ((*stringp != '\0') &&
test_condition) == CONDITION_TRUE)) {
stringp++;
}
regexp));
/* end case IN_OLD_ASCII_CHAR_CLASS|ZERO_OR_MORE */
/*
* encoded as <IN_OLD_ASCII_CHAR_CLASS|ONE_OR_MORE>\
* <class_length><class ...>
* or <NOT_IN_OLD_ASCII_CHAR_CLASS|ONE_OR_MORE>\
* <class_length><class ...>
*
* NOTE: <class length> includes the <class_length> byte
*/
if ((int)*regexp ==
(int)(IN_OLD_ASCII_CHAR_CLASS|ONE_OR_MORE)) {
} else {
}
regexp++; /* point to the <class_length> byte */
if ((*stringp == '\0') ||
test_condition) != CONDITION_TRUE)) {
return ((char *)0);
} else {
stringp++;
while ((*stringp != '\0') &&
test_condition) == CONDITION_TRUE)) {
stringp++;
}
regexp));
}
/* end case IN_OLD_ASCII_CHAR_CLASS | ONE_OR_MORE */
/*
* encoded as <IN_OLD_ASCII_CHAR_CLASS|COUNT><class_length>\
* <class ...><minimum_match_count>\
* <maximum_match_count>
* or <NOT_IN_OLD_ASCII_CHAR_CLASS|COUNT>\
* <class_length><class ...><minimum_match_count>\
* <maximum_match_count>
*
* NOTE: <class_length> includes the <class_length> byte
* but not the <minimum_match_count> or
* <maximum_match_count> bytes
*/
} else {
}
regexp++; /* point to the <class_length> byte */
while ((*stringp != '\0') &&
test_condition) == CONDITION_TRUE) &&
(nmust_match > 0)) {
nmust_match--;
stringp++;
}
if (nmust_match > 0) {
return ((char *)0);
} else if (nextra_matches_allowed == UNLIMITED) {
while ((*stringp != '\0') &&
test_condition) == CONDITION_TRUE)) {
stringp++;
}
regexp));
} else {
while ((*stringp != '\0') &&
test_condition) == CONDITION_TRUE) &&
(nextra_matches_allowed > 0)) {
stringp++;
}
regexp));
}
/* end case IN_OLD_ASCII_CHAR_CLASS|COUNT */
case ZERO_OR_MORE_GROUP: /* (.....)* */
/*
* encoded as <ZERO_OR_MORE_GROUP|ADDED_LENGTH_BITS>\
* <group_length><compiled_regex...>\
* <END_GROUP|ZERO_OR_MORE><groupn>
*
* NOTE:
*
* group_length + (256 * ADDED_LENGTH_BITS) ==
* length_of(<compiled_regex...><END_GROUP|ZERO_OR_MORE>\
* <groupn>)
*
*/
(((unsigned int)*regexp & ADDED_LENGTH_BITS) <<
regexp++;
group_length += (unsigned int)*regexp;
regexp++;
while (test_stringp != (char *)0) {
if (push_stringp(stringp) == (char *)0)
return ((char *)0);
}
regexp += group_length;
/* end case ZERO_OR_MORE_GROUP */
/* encoded as <END_GROUP|ZERO_OR_MORE> */
/* return from recursive call to test_string() */
return ((char *)stringp);
/* end case END_GROUP|ZERO_OR_MORE */
case ONE_OR_MORE_GROUP: /* (.....)+ */
/*
* encoded as <ONE_OR_MORE_GROUP|ADDED_LENGTH_BITS>\
* <group_length><compiled_regex...>\
* <END_GROUP|ONE_OR_MORE><groupn>
*
* NOTE:
*
* group_length + (256 * ADDED_LENGTH_BITS) ==
* length_of(<compiled_regex...><END_GROUP|ONE_OR_MORE>\
* <groupn>)
*/
(((unsigned int)*regexp & ADDED_LENGTH_BITS) <<
regexp++;
group_length += (unsigned int)*regexp;
regexp++;
if (stringp == (char *)0)
return ((char *)0);
while (test_stringp != (char *)0) {
if (push_stringp(stringp) == (char *)0)
return ((char *)0);
}
regexp += group_length;
/* end case ONE_OR_MORE_GROUP */
/* encoded as <END_GROUP|ONE_OR_MORE><groupn> */
/* return from recursive call to test_string() */
return ((char *)stringp);
/* end case END_GROUP|ONE_OR_MORE */
case COUNTED_GROUP: /* (.....){max_count,min_count} */
/*
* encoded as <COUNTED_GROUP|ADDED_LENGTH_BITS><group_length>\
* <compiled_regex...>\<END_GROUP|COUNT><groupn>\
* <minimum_match_count><maximum_match_count>
*
* NOTE:
*
* group_length + (256 * ADDED_LENGTH_BITS) ==
* length_of(<compiled_regex...><END_GROUP|COUNT><groupn>)
*
* but does not include the <minimum_match_count> or
* <maximum_match_count> bytes
*/
(((unsigned int)*regexp & ADDED_LENGTH_BITS) <<
regexp++;
group_length += (unsigned int)*regexp;
regexp++;
regexp + group_length);
while ((test_stringp != (char *)0) && (nmust_match > 0)) {
nmust_match--;
}
if (nmust_match > 0) {
return ((char *)0);
} else if (nextra_matches_allowed == UNLIMITED) {
while (test_stringp != (char *)0) {
if (push_stringp(stringp) == (char *)0)
return ((char *)0);
}
regexp));
} else {
while ((test_stringp != (char *)0) &&
(nextra_matches_allowed > 0)) {
if (push_stringp(stringp) == (char *)0)
return ((char *)0);
}
regexp));
}
/* end case COUNTED_GROUP */
/* encoded as <END_GROUP|COUNT> */
/* return from recursive call to test_string() */
return (stringp);
/* end case END_GROUP|COUNT */
case END_OF_STRING_MARK:
/* encoded as <END_OF_STRING_MARK><END_REGEX> */
if (*stringp == '\0') {
regexp++;
} else {
return ((char *)0);
}
break; /* end case END_OF_STRING_MARK */
case END_REGEX: /* end of the compiled regular expression */
/* encoded as <END_REGEX> */
return (stringp);
/* end case END_REGEX */
default:
return ((char *)0);
} /* end switch (*regexp) */
} /* end for (;;) */
} /* test_string() */