ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

avoid namespace clash in mini-regex library

Browse Source
This commit is contained in:
Axel Kohlmeyer
2021-09-08 20:39:41 -04:00
parent bc7dfbed3c
commit 6bad470dd5
1 changed files with 61 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
src/utils.cpp
View File

@ -1468,26 +1468,26 @@ static int re_matchp(const char *text, re_t pattern, int *matchlen);
#define MAX_CHAR_CLASS_LEN 40 /* Max length of character-class buffer in. */ #define MAX_CHAR_CLASS_LEN 40 /* Max length of character-class buffer in. */
enum { enum {
UNUSED, RX_UNUSED,
DOT, RX_DOT,
BEGIN, RX_BEGIN,
END, RX_END,
QUESTIONMARK, RX_QUESTIONMARK,
STAR, RX_STAR,
PLUS, RX_PLUS,
CHAR, RX_CHAR,
CHAR_CLASS, RX_CHAR_CLASS,
INV_CHAR_CLASS, RX_INV_CHAR_CLASS,
DIGIT, RX_DIGIT,
NOT_DIGIT, RX_NOT_DIGIT,
INTEGER, RX_INTEGER,
NOT_INTEGER, RX_NOT_INTEGER,
FLOAT, RX_FLOAT,
NOT_FLOAT, RX_NOT_FLOAT,
ALPHA, RX_ALPHA,
NOT_ALPHA, RX_NOT_ALPHA,
WHITESPACE, RX_WHITESPACE,
NOT_WHITESPACE /*, BRANCH */ RX_NOT_WHITESPACE /*, BRANCH */
}; };
typedef struct regex_t { typedef struct regex_t {
@ -1539,7 +1539,7 @@ int re_matchp(const char *text, re_t pattern, int *matchlen)
{ {
*matchlen = 0; *matchlen = 0;
if (pattern != 0) { if (pattern != 0) {
if (pattern[0].type == BEGIN) { if (pattern[0].type == RX_BEGIN) {
return ((matchpattern(&pattern[1], text, matchlen)) ? 0 : -1); return ((matchpattern(&pattern[1], text, matchlen)) ? 0 : -1);
} else { } else {
int idx = -1; int idx = -1;
@ -1574,22 +1574,22 @@ re_t re_compile(re_ctx_t context, const char *pattern)
switch (c) { switch (c) {
/* Meta-characters: */ /* Meta-characters: */
case '^': { case '^': {
re_compiled[j].type = BEGIN; re_compiled[j].type = RX_BEGIN;
} break; } break;
case '$': { case '$': {
re_compiled[j].type = END; re_compiled[j].type = RX_END;
} break; } break;
case '.': { case '.': {
re_compiled[j].type = DOT; re_compiled[j].type = RX_DOT;
} break; } break;
case '*': { case '*': {
re_compiled[j].type = STAR; re_compiled[j].type = RX_STAR;
} break; } break;
case '+': { case '+': {
re_compiled[j].type = PLUS; re_compiled[j].type = RX_PLUS;
} break; } break;
case '?': { case '?': {
re_compiled[j].type = QUESTIONMARK; re_compiled[j].type = RX_QUESTIONMARK;
} break; } break;
/* Escaped character-classes (\s \w ...): */ /* Escaped character-classes (\s \w ...): */
@ -1601,39 +1601,39 @@ re_t re_compile(re_ctx_t context, const char *pattern)
switch (pattern[i]) { switch (pattern[i]) {
/* Meta-character: */ /* Meta-character: */
case 'd': { case 'd': {
re_compiled[j].type = DIGIT; re_compiled[j].type = RX_DIGIT;
} break; } break;
case 'D': { case 'D': {
re_compiled[j].type = NOT_DIGIT; re_compiled[j].type = RX_NOT_DIGIT;
} break; } break;
case 'i': { case 'i': {
re_compiled[j].type = INTEGER; re_compiled[j].type = RX_INTEGER;
} break; } break;
case 'I': { case 'I': {
re_compiled[j].type = NOT_INTEGER; re_compiled[j].type = RX_NOT_INTEGER;
} break; } break;
case 'f': { case 'f': {
re_compiled[j].type = FLOAT; re_compiled[j].type = RX_FLOAT;
} break; } break;
case 'F': { case 'F': {
re_compiled[j].type = NOT_FLOAT; re_compiled[j].type = RX_NOT_FLOAT;
} break; } break;
case 'w': { case 'w': {
re_compiled[j].type = ALPHA; re_compiled[j].type = RX_ALPHA;
} break; } break;
case 'W': { case 'W': {
re_compiled[j].type = NOT_ALPHA; re_compiled[j].type = RX_NOT_ALPHA;
} break; } break;
case 's': { case 's': {
re_compiled[j].type = WHITESPACE; re_compiled[j].type = RX_WHITESPACE;
} break; } break;
case 'S': { case 'S': {
re_compiled[j].type = NOT_WHITESPACE; re_compiled[j].type = RX_NOT_WHITESPACE;
} break; } break;
/* Escaped character, e.g. '.' or '$' */ /* Escaped character, e.g. '.' or '$' */
default: { default: {
re_compiled[j].type = CHAR; re_compiled[j].type = RX_CHAR;
re_compiled[j].u.ch = pattern[i]; re_compiled[j].u.ch = pattern[i];
} break; } break;
} }
@ -1648,14 +1648,14 @@ re_t re_compile(re_ctx_t context, const char *pattern)
/* Look-ahead to determine if negated */ /* Look-ahead to determine if negated */
if (pattern[i + 1] == '^') { if (pattern[i + 1] == '^') {
re_compiled[j].type = INV_CHAR_CLASS; re_compiled[j].type = RX_INV_CHAR_CLASS;
i += 1; /* Increment i to avoid including '^' in the char-buffer */ i += 1; /* Increment i to avoid including '^' in the char-buffer */
if (pattern[i + 1] == 0) /* incomplete pattern, missing non-zero char after '^' */ if (pattern[i + 1] == 0) /* incomplete pattern, missing non-zero char after '^' */
{ {
return 0; return 0;
} }
} else { } else {
re_compiled[j].type = CHAR_CLASS; re_compiled[j].type = RX_CHAR_CLASS;
} }
/* Copy characters inside [..] to buffer */ /* Copy characters inside [..] to buffer */
@ -1684,7 +1684,7 @@ re_t re_compile(re_ctx_t context, const char *pattern)
/* Other characters: */ /* Other characters: */
default: { default: {
re_compiled[j].type = CHAR; re_compiled[j].type = RX_CHAR;
re_compiled[j].u.ch = c; re_compiled[j].u.ch = c;
} break; } break;
} }
@ -1695,8 +1695,8 @@ re_t re_compile(re_ctx_t context, const char *pattern)
i += 1; i += 1;
j += 1; j += 1;
} }
/* 'UNUSED' is a sentinel used to indicate end-of-pattern */ /* 'RX_UNUSED' is a sentinel used to indicate end-of-pattern */
re_compiled[j].type = UNUSED; re_compiled[j].type = RX_UNUSED;
return (re_t) re_compiled; return (re_t) re_compiled;
} }
@ -1809,31 +1809,31 @@ static int matchcharclass(char c, const char *str)
static int matchone(regex_t p, char c) static int matchone(regex_t p, char c)
{ {
switch (p.type) { switch (p.type) {
case DOT: case RX_DOT:
return matchdot(c); return matchdot(c);
case CHAR_CLASS: case RX_CHAR_CLASS:
return matchcharclass(c, (const char *) p.u.ccl); return matchcharclass(c, (const char *) p.u.ccl);
case INV_CHAR_CLASS: case RX_INV_CHAR_CLASS:
return !matchcharclass(c, (const char *) p.u.ccl); return !matchcharclass(c, (const char *) p.u.ccl);
case DIGIT: case RX_DIGIT:
return matchdigit(c); return matchdigit(c);
case NOT_DIGIT: case RX_NOT_DIGIT:
return !matchdigit(c); return !matchdigit(c);
case INTEGER: case RX_INTEGER:
return matchint(c); return matchint(c);
case NOT_INTEGER: case RX_NOT_INTEGER:
return !matchint(c); return !matchint(c);
case FLOAT: case RX_FLOAT:
return matchfloat(c); return matchfloat(c);
case NOT_FLOAT: case RX_NOT_FLOAT:
return !matchfloat(c); return !matchfloat(c);
case ALPHA: case RX_ALPHA:
return matchalphanum(c); return matchalphanum(c);
case NOT_ALPHA: case RX_NOT_ALPHA:
return !matchalphanum(c); return !matchalphanum(c);
case WHITESPACE: case RX_WHITESPACE:
return matchwhitespace(c); return matchwhitespace(c);
case NOT_WHITESPACE: case RX_NOT_WHITESPACE:
return !matchwhitespace(c); return !matchwhitespace(c);
default: default:
return (p.u.ch == c); return (p.u.ch == c);
@ -1873,7 +1873,7 @@ static int matchplus(regex_t p, regex_t *pattern, const char *text, int *matchle
static int matchquestion(regex_t p, regex_t *pattern, const char *text, int *matchlen) static int matchquestion(regex_t p, regex_t *pattern, const char *text, int *matchlen)
{ {
if (p.type == UNUSED) return 1; if (p.type == RX_UNUSED) return 1;
if (matchpattern(pattern, text, matchlen)) return 1; if (matchpattern(pattern, text, matchlen)) return 1;
if (*text && matchone(p, *text++)) { if (*text && matchone(p, *text++)) {
if (matchpattern(pattern, text, matchlen)) { if (matchpattern(pattern, text, matchlen)) {
@ -1889,13 +1889,13 @@ static int matchpattern(regex_t *pattern, const char *text, int *matchlen)
{ {
int pre = *matchlen; int pre = *matchlen;
do { do {
if ((pattern[0].type == UNUSED) || (pattern[1].type == QUESTIONMARK)) { if ((pattern[0].type == RX_UNUSED) || (pattern[1].type == RX_QUESTIONMARK)) {
return matchquestion(pattern[0], &pattern[2], text, matchlen); return matchquestion(pattern[0], &pattern[2], text, matchlen);
} else if (pattern[1].type == STAR) { } else if (pattern[1].type == RX_STAR) {
return matchstar(pattern[0], &pattern[2], text, matchlen); return matchstar(pattern[0], &pattern[2], text, matchlen);
} else if (pattern[1].type == PLUS) { } else if (pattern[1].type == RX_PLUS) {
return matchplus(pattern[0], &pattern[2], text, matchlen); return matchplus(pattern[0], &pattern[2], text, matchlen);
} else if ((pattern[0].type == END) && pattern[1].type == UNUSED) { } else if ((pattern[0].type == RX_END) && pattern[1].type == RX_UNUSED) {
return (text[0] == '\0'); return (text[0] == '\0');
} }
(*matchlen)++; (*matchlen)++;