topjohnwu/ndk-busybox
1
0
Fork 0
mirror of https://github.com/topjohnwu/ndk-busybox.git synced 2024-11-30 07:00:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
84d8568071
ndk-busybox/regexp.c
Eric Andersen 50d6360771 Stuff
1999-11-09 01:47:36 +00:00

860 lines
18 KiB
C
Raw Blame History

/* regexp.c */
#include "internal.h"
#include "regexp.h"
#include <setjmp.h>
#include <stdio.h>
#include <ctype.h>
#if ( defined BB_GREP || defined BB_FIND || defined BB_SED)
/* This also tries to find a needle in a haystack, but uses
* real regular expressions.... The fake regular expression
* version of find_match lives in utility.c. Using this version
* will add 3.9k to busybox...
* -Erik Andersen
*/
extern int find_match(char *haystack, char *needle, int ignoreCase)
{
int status;
struct regexp* re;
re = regcomp( needle);
status = regexec(re, haystack, FALSE, ignoreCase);
free( re);
return( status);
}
#if defined BB_SED
/* This performs substitutions after a regexp match has been found.
* The new string is returned. It is malloc'ed, and do must be freed. */
extern int replace_match(char *haystack, char *needle, char *newNeedle, int ignoreCase)
{
int status;
struct regexp* re;
char *s, buf[BUF_SIZE], *d = buf;
re = regcomp( needle);
status = regexec(re, haystack, FALSE, ignoreCase);
if (status==TRUE) {
s=haystack;
do {
/* copy stuff from before the match */
while (s < re->startp[0])
*d++ = *s++;
/* substitute for the matched part */
regsub(re, newNeedle, d);
s = re->endp[0];
d += strlen(d);
} while (regexec(re, s, FALSE, ignoreCase) == TRUE);
/* copy stuff from after the match */
while ( (*d++ = *s++) ) {}
d[0] = '\0';
strcpy(haystack, buf);
}
free( re);
return( status);
}
#endif
/* code swiped from elvis-tiny 1.4 (a clone of vi) and adjusted to
* suit the needs of busybox by Erik Andersen.
*
* From the README:
* "Elvis is freely redistributable, in either source form or executable form.
* There are no restrictions on how you may use it".
* Elvis was written by Steve Kirkendall <kirkenda@cs.pdx.edu>
*
*
* This file contains the code that compiles regular expressions and executes
* them. It supports the same syntax and features as vi's regular expression
* code. Specifically, the meta characters are:
* ^ matches the beginning of a line
* $ matches the end of a line
* \< matches the beginning of a word
* \> matches the end of a word
* . matches any single character
* [] matches any character in a character class
* \( delimits the start of a subexpression
* \) delimits the end of a subexpression
* * repeats the preceding 0 or more times
* NOTE: You cannot follow a \) with a *.
*
* The physical structure of a compiled RE is as follows:
* - First, there is a one-byte value that says how many character classes
* are used in this regular expression
* - Next, each character class is stored as a bitmap that is 256 bits
* (32 bytes) long.
* - A mixture of literal characters and compiled meta characters follows.
* This begins with M_BEGIN(0) and ends with M_END(0). All meta chars
* are stored as a \n followed by a one-byte code, so they take up two
* bytes apiece. Literal characters take up one byte apiece. \n can't
* be used as a literal character.
*
*/
static char *previous; /* the previous regexp, used when null regexp is given */
static char *previous1; /* a copy of the text from the previous substitution for regsub()*/
/* These are used to classify or recognize meta-characters */
#define META '\0'
#define BASE_META(m) ((m) - 256)
#define INT_META(c) ((c) + 256)
#define IS_META(m) ((m) >= 256)
#define IS_CLASS(m) ((m) >= M_CLASS(0) && (m) <= M_CLASS(9))
#define IS_START(m) ((m) >= M_START(0) && (m) <= M_START(9))
#define IS_END(m) ((m) >= M_END(0) && (m) <= M_END(9))
#define IS_CLOSURE(m) ((m) >= M_SPLAT && (m) <= M_QMARK)
#define ADD_META(s,m) (*(s)++ = META, *(s)++ = BASE_META(m))
#define GET_META(s) (*(s) == META ? INT_META(*++(s)) : *s)
/* These are the internal codes used for each type of meta-character */
#define M_BEGLINE 256 /* internal code for ^ */
#define M_ENDLINE 257 /* internal code for $ */
#define M_BEGWORD 258 /* internal code for \< */
#define M_ENDWORD 259 /* internal code for \> */
#define M_ANY 260 /* internal code for . */
#define M_SPLAT 261 /* internal code for * */
#define M_PLUS 262 /* internal code for \+ */
#define M_QMARK 263 /* internal code for \? */
#define M_CLASS(n) (264+(n)) /* internal code for [] */
#define M_START(n) (274+(n)) /* internal code for \( */
#define M_END(n) (284+(n)) /* internal code for \) */
/* These are used during compilation */
static int class_cnt; /* used to assign class IDs */
static int start_cnt; /* used to assign start IDs */
static int end_stk[NSUBEXP];/* used to assign end IDs */
static int end_sp;
static char *retext; /* points to the text being compiled */
/* error-handling stuff */
jmp_buf errorhandler;
#define FAIL(why) fprintf(stderr, why); longjmp(errorhandler, 1)
/* This function builds a bitmap for a particular class */
/* text -- start of the class */
/* bmap -- the bitmap */
static char *makeclass(char* text, char* bmap)
{
int i;
int complement = 0;
/* zero the bitmap */
for (i = 0; bmap && i < 32; i++)
{
bmap[i] = 0;
}
/* see if we're going to complement this class */
if (*text == '^')
{
text++;
complement = 1;
}
/* add in the characters */
while (*text && *text != ']')
{
/* is this a span of characters? */
if (text[1] == '-' && text[2])
{
/* spans can't be backwards */
if (text[0] > text[2])
{
FAIL("Backwards span in []");
}
/* add each character in the span to the bitmap */
for (i = text[0]; bmap && i <= text[2]; i++)
{
bmap[i >> 3] |= (1 << (i & 7));
}
/* move past this span */
text += 3;
}
else
{
/* add this single character to the span */
i = *text++;
if (bmap)
{
bmap[i >> 3] |= (1 << (i & 7));
}
}
}
/* make sure the closing ] is missing */
if (*text++ != ']')
{
FAIL("] missing");
}
/* if we're supposed to complement this class, then do so */
if (complement && bmap)
{
for (i = 0; i < 32; i++)
{
bmap[i] = ~bmap[i];
}
}
return text;
}
/* This function gets the next character or meta character from a string.
* The pointer is incremented by 1, or by 2 for \-quoted characters. For [],
* a bitmap is generated via makeclass() (if re is given), and the
* character-class text is skipped.
*/
static int gettoken(sptr, re)
char **sptr;
regexp *re;
{
int c;
c = **sptr;
++*sptr;
if (c == '\\')
{
c = **sptr;
++*sptr;
switch (c)
{
case '<':
return M_BEGWORD;
case '>':
return M_ENDWORD;
case '(':
if (start_cnt >= NSUBEXP)
{
FAIL("Too many \\(s");
}
end_stk[end_sp++] = start_cnt;
return M_START(start_cnt++);
case ')':
if (end_sp <= 0)
{
FAIL("Mismatched \\)");
}
return M_END(end_stk[--end_sp]);
case '*':
return M_SPLAT;
case '.':
return M_ANY;
case '+':
return M_PLUS;
case '?':
return M_QMARK;
default:
return c;
}
}
else {
switch (c)
{
case '^':
if (*sptr == retext + 1)
{
return M_BEGLINE;
}
return c;
case '$':
if (!**sptr)
{
return M_ENDLINE;
}
return c;
case '.':
return M_ANY;
case '*':
return M_SPLAT;
case '[':
/* make sure we don't have too many classes */
if (class_cnt >= 10)
{
FAIL("Too many []s");
}
/* process the character list for this class */
if (re)
{
/* generate the bitmap for this class */
*sptr = makeclass(*sptr, re->program + 1 + 32 * class_cnt);
}
else
{
/* skip to end of the class */
*sptr = makeclass(*sptr, (char *)0);
}
return M_CLASS(class_cnt++);
default:
return c;
}
}
/*NOTREACHED*/
}
/* This function calculates the number of bytes that will be needed for a
* compiled RE. Its argument is the uncompiled version. It is not clever
* about catching syntax errors; that is done in a later pass.
*/
static unsigned calcsize(text)
char *text;
{
unsigned size;
int token;
retext = text;
class_cnt = 0;
start_cnt = 1;
end_sp = 0;
size = 5;
while ((token = gettoken(&text, (regexp *)0)) != 0)
{
if (IS_CLASS(token))
{
size += 34;
}
else if (IS_META(token))
{
size += 2;
}
else
{
size++;
}
}
return size;
}
/*---------------------------------------------------------------------------*/
/* This function checks for a match between a character and a token which is
* known to represent a single character. It returns 0 if they match, or
* 1 if they don't.
*/
static int match1(regexp* re, char ch, int token, int ignoreCase)
{
if (!ch)
{
/* the end of a line can't match any RE of width 1 */
return 1;
}
if (token == M_ANY)
{
return 0;
}
else if (IS_CLASS(token))
{
if (re->program[1 + 32 * (token - M_CLASS(0)) + (ch >> 3)] & (1 << (ch & 7)))
return 0;
}
else if (ch == token
|| (ignoreCase==TRUE && isupper(ch) && tolower(ch) == token))
{
return 0;
}
return 1;
}
/* This function checks characters up to and including the next closure, at
* which point it does a recursive call to check the rest of it. This function
* returns 0 if everything matches, or 1 if something doesn't match.
*/
/* re -- the regular expression */
/* str -- the string */
/* prog -- a portion of re->program, an compiled RE */
/* here -- a portion of str, the string to compare it to */
static int match(regexp* re, char* str, char* prog, char* here, int ignoreCase)
{
int token;
int nmatched;
int closure;
for (token = GET_META(prog); !IS_CLOSURE(token); prog++, token = GET_META(prog))
{
switch (token)
{
/*case M_BEGLINE: can't happen; re->bol is used instead */
case M_ENDLINE:
if (*here)
return 1;
break;
case M_BEGWORD:
if (here != str &&
(here[-1] == '_' ||
(isascii(here[-1]) && isalnum(here[-1]))))
return 1;
break;
case M_ENDWORD:
if ((here[0] == '_' || isascii(here[0])) && isalnum(here[0]))
return 1;
break;
case M_START(0):
case M_START(1):
case M_START(2):
case M_START(3):
case M_START(4):
case M_START(5):
case M_START(6):
case M_START(7):
case M_START(8):
case M_START(9):
re->startp[token - M_START(0)] = (char *)here;
break;
case M_END(0):
case M_END(1):
case M_END(2):
case M_END(3):
case M_END(4):
case M_END(5):
case M_END(6):
case M_END(7):
case M_END(8):
case M_END(9):
re->endp[token - M_END(0)] = (char *)here;
if (token == M_END(0))
{
return 0;
}
break;
default: /* literal, M_CLASS(n), or M_ANY */
if (match1(re, *here, token, ignoreCase) != 0)
return 1;
here++;
}
}
/* C L O S U R E */
/* step 1: see what we have to match against, and move "prog" to point
* the the remainder of the compiled RE.
*/
closure = token;
prog++, token = GET_META(prog);
prog++;
/* step 2: see how many times we can match that token against the string */
for (nmatched = 0;
(closure != M_QMARK || nmatched < 1) && *here && match1(re, *here, token, ignoreCase) == 0;
nmatched++, here++)
{
}
/* step 3: try to match the remainder, and back off if it doesn't */
while (nmatched >= 0 && match(re, str, prog, here, ignoreCase) != 0)
{
nmatched--;
here--;
}
/* so how did it work out? */
if (nmatched >= ((closure == M_PLUS) ? 1 : 0))
return 0;
return 1;
}
/* This function compiles a regexp. */
extern regexp *regcomp(char* text)
{
int needfirst;
unsigned size;
int token;
int peek;
char *build;
regexp *re;
/* prepare for error handling */
re = (regexp *)0;
if (setjmp(errorhandler))
{
if (re)
{
free(re);
}
return (regexp *)0;
}
/* if an empty regexp string was given, use the previous one */
if (*text == 0)
{
if (!previous)
{
FAIL("No previous RE");
}
text = previous;
}
else /* non-empty regexp given, so remember it */
{
if (previous)
free(previous);
previous = (char *)malloc((unsigned)(strlen(text) + 1));
if (previous)
strcpy(previous, text);
}
/* allocate memory */
class_cnt = 0;
start_cnt = 1;
end_sp = 0;
retext = text;
size = calcsize(text) + sizeof(regexp);
re = (regexp *)malloc((unsigned)size);
if (!re)
{
FAIL("Not enough memory for this RE");
}
/* compile it */
build = &re->program[1 + 32 * class_cnt];
re->program[0] = class_cnt;
for (token = 0; token < NSUBEXP; token++)
{
re->startp[token] = re->endp[token] = (char *)0;
}
re->first = 0;
re->bol = 0;
re->minlen = 0;
needfirst = 1;
class_cnt = 0;
start_cnt = 1;
end_sp = 0;
retext = text;
for (token = M_START(0), peek = gettoken(&text, re);
token;
token = peek, peek = gettoken(&text, re))
{
/* special processing for the closure operator */
if (IS_CLOSURE(peek))
{
/* detect misuse of closure operator */
if (IS_START(token))
{
FAIL("* or \\+ or \\? follows nothing");
}
else if (IS_META(token) && token != M_ANY && !IS_CLASS(token))
{
FAIL("* or \\+ or \\? can only follow a normal character or . or []");
}
/* it is okay -- make it prefix instead of postfix */
ADD_META(build, peek);
/* take care of "needfirst" - is this the first char? */
if (needfirst && peek == M_PLUS && !IS_META(token))
{
re->first = token;
}
needfirst = 0;
/* we used "peek" -- need to refill it */
peek = gettoken(&text, re);
if (IS_CLOSURE(peek))
{
FAIL("* or \\+ or \\? doubled up");
}
}
else if (!IS_META(token))
{
/* normal char is NOT argument of closure */
if (needfirst)
{
re->first = token;
needfirst = 0;
}
re->minlen++;
}
else if (token == M_ANY || IS_CLASS(token))
{
/* . or [] is NOT argument of closure */
needfirst = 0;
re->minlen++;
}
/* the "token" character is not closure -- process it normally */
if (token == M_BEGLINE)
{
/* set the BOL flag instead of storing M_BEGLINE */
re->bol = 1;
}
else if (IS_META(token))
{
ADD_META(build, token);
}
else
{
*build++ = token;
}
}
/* end it with a \) which MUST MATCH the opening \( */
ADD_META(build, M_END(0));
if (end_sp > 0)
{
FAIL("Not enough \\)s");
}
return re;
}
/* This function searches through a string for text that matches an RE. */
/* re -- the compiled regexp to search for */
/* str -- the string to search through */
/* bol -- does str start at the beginning of a line? (boolean) */
/* ignoreCase -- ignoreCase or not */
extern int regexec(struct regexp* re, char* str, int bol, int ignoreCase)
{
char *prog; /* the entry point of re->program */
int len; /* length of the string */
char *here;
/* if must start at the beginning of a line, and this isn't, then fail */
if (re->bol && bol==TRUE)
{
return FALSE;
}
len = strlen(str);
prog = re->program + 1 + 32 * re->program[0];
/* search for the RE in the string */
if (re->bol)
{
/* must occur at BOL */
if ((re->first
&& match1(re, *(char *)str, re->first, ignoreCase))/* wrong first letter? */
|| len < re->minlen /* not long enough? */
|| match(re, (char *)str, prog, str, ignoreCase)) /* doesn't match? */
return FALSE; /* THEN FAIL! */
}
else if (ignoreCase == FALSE)
{
/* can occur anywhere in the line, noignorecase */
for (here = (char *)str;
(re->first && re->first != *here)
|| match(re, (char *)str, prog, here, ignoreCase);
here++, len--)
{
if (len < re->minlen)
return FALSE;
}
}
else
{
/* can occur anywhere in the line, ignorecase */
for (here = (char *)str;
(re->first && match1(re, *here, (int)re->first, ignoreCase))
|| match(re, (char *)str, prog, here, ignoreCase);
here++, len--)
{
if (len < re->minlen)
return FALSE;
}
}
/* if we didn't fail, then we must have succeeded */
return TRUE;
}
#if defined BB_SED
/* This performs substitutions after a regexp match has been found. */
extern void regsub(regexp* re, char* src, char* dst)
{
char *cpy;
char *end;
char c;
char *start;
int mod;
mod = 0;
start = src;
while ((c = *src++) != '\0')
{
/* recognize any meta characters */
if (c == '&')
{
cpy = re->startp[0];
end = re->endp[0];
}
else if (c == '~')
{
cpy = previous1;
if (cpy)
end = cpy + strlen(cpy);
}
else
if (c == '\\')
{
c = *src++;
switch (c)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
/* \0 thru \9 mean "copy subexpression" */
c -= '0';
cpy = re->startp[(int)c];
end = re->endp[(int)c];
break;
case 'U':
case 'u':
case 'L':
case 'l':
/* \U and \L mean "convert to upper/lowercase" */
mod = c;
continue;
case 'E':
case 'e':
/* \E ends the \U or \L */
mod = 0;
continue;
case '&':
/* "\&" means "original text" */
*dst++ = c;
continue;
case '~':
/* "\~" means "previous text, if any" */
*dst++ = c;
continue;
default:
/* ordinary char preceded by backslash */
*dst++ = c;
continue;
}
}
else
{
/* ordinary character, so just copy it */
*dst++ = c;
continue;
}
/* Note: to reach this point in the code, we must have evaded
* all "continue" statements. To do that, we must have hit
* a metacharacter that involves copying.
*/
/* if there is nothing to copy, loop */
if (!cpy)
continue;
/* copy over a portion of the original */
while (cpy < end)
{
switch (mod)
{
case 'U':
case 'u':
/* convert to uppercase */
if (isascii(*cpy) && islower(*cpy))
{
*dst++ = toupper(*cpy);
cpy++;
}
else
{
*dst++ = *cpy++;
}
break;
case 'L':
case 'l':
/* convert to lowercase */
if (isascii(*cpy) && isupper(*cpy))
{
*dst++ = tolower(*cpy);
cpy++;
}
else
{
*dst++ = *cpy++;
}
break;
default:
/* copy without any conversion */
*dst++ = *cpy++;
}
/* \u and \l end automatically after the first char */
if (mod && (mod == 'u' || mod == 'l'))
{
mod = 0;
}
}
}
*dst = '\0';
/* remember what text we inserted this time */
if (previous1)
free(previous1);
previous1 = (char *)malloc((unsigned)(strlen(start) + 1));
if (previous1)
strcpy(previous1, start);
}
#endif
#endif /* BB_REGEXP */
Reference in New Issue View Git Blame Copy Permalink