forked from enlightenment/efl
Windows: remove fnmatch and regex in Evil and use the ones in regex DLL installed by ewpi
Test Plan: compilation with autotools and meson (at least as far as it can go) Reviewers: zmike, raster Reviewed By: zmike Subscribers: cedric, #reviewers, #committers Tags: #efl Differential Revision: https://phab.enlightenment.org/D8646
This commit is contained in:
Mike Blumenkrantz
parent
e65c49b422
commit
ecce595b24
14
configure.ac
14
configure.ac
|
|
@ -810,10 +810,14 @@ EFL_SELECT_WINDOWS_VERSION
|
|||
|
||||
### Checks for libraries
|
||||
|
||||
EFL_ADD_LIBS([EVIL], [-lpsapi -lole32 -lws2_32 -lsecur32 -luuid])
|
||||
EFL_ADD_LIBS([EVIL], [-lpsapi -lole32 -lws2_32 -lsecur32 -luuid -lregex])
|
||||
|
||||
### Checks for header files
|
||||
|
||||
AC_CHECK_HEADERS([regex.h fnmatch.h],
|
||||
[],
|
||||
[AC_MSG_ERROR([regex.h or fnmatch.h can not be found])])
|
||||
|
||||
### Checks for types
|
||||
|
||||
### Checks for structures
|
||||
|
|
@ -839,6 +843,14 @@ AC_SUBST([EVIL_CXXFLAGS])
|
|||
|
||||
### Checks for library functions
|
||||
|
||||
AC_SEARCH_LIBS([regcomp], [regex],
|
||||
[],
|
||||
[AC_MSG_ERROR([regcomp() can not be found in libregex])])
|
||||
|
||||
AC_SEARCH_LIBS([fnmatch], [regex],
|
||||
[],
|
||||
[AC_MSG_ERROR([fnmatch() can not be found in libregex])])
|
||||
|
||||
EFL_LIB_END_OPTIONAL([Evil])
|
||||
|
||||
AC_SUBST([USE_EVIL_CFLAGS])
|
||||
|
|
|
|||
|
|
@ -189,12 +189,29 @@ if (cc.has_header('sys/mman.h'))
|
|||
config_h.set10('HAVE_MMAN_H', true)
|
||||
endif
|
||||
|
||||
regexp = []
|
||||
if sys_windows == true
|
||||
regexp = cc.find_library('regex',
|
||||
has_headers: ['regex.h', 'fnmatch.h'],
|
||||
required: true)
|
||||
if regexp.found() == false
|
||||
error('regex can not be found')
|
||||
endif
|
||||
else
|
||||
if cc.has_header_symbol('fnmatch.h', 'fnmatch') == false
|
||||
error('fnmatch can not be found')
|
||||
endif
|
||||
if cc.has_header_symbol('regex.h', 'regcomp') == false
|
||||
error('regcomp can not be found')
|
||||
endif
|
||||
endif
|
||||
|
||||
config_h.set('VMAJ', version_major)
|
||||
config_h.set('VMIN', version_minor)
|
||||
config_h.set('VMIC', version_micro)
|
||||
config_h.set('VREV', '0')
|
||||
|
||||
#jpeg detection ... life is a bit more complex there
|
||||
#jpeg detection ... life is a bit more complex there
|
||||
|
||||
jpeg = dependency('libjpeg', required: false)
|
||||
if jpeg.found() == false
|
||||
|
|
|
|||
|
|
@ -21,7 +21,6 @@ lib/evil/evil_string.h \
|
|||
lib/evil/evil_time.h \
|
||||
lib/evil/evil_unistd.h \
|
||||
lib/evil/evil_util.h \
|
||||
lib/evil/fnmatch.h \
|
||||
lib/evil/pwd.h
|
||||
|
||||
evilmmanheadersdir = $(includedir)/evil-@VMAJ@/sys
|
||||
|
|
@ -31,8 +30,6 @@ lib/evil/sys/mman.h
|
|||
lib_evil_libevil_la_SOURCES = \
|
||||
lib/evil/evil_dlfcn.c \
|
||||
lib/evil/evil_fcntl.c \
|
||||
lib/evil/evil_fnmatch.c \
|
||||
lib/evil/evil_fnmatch_list_of_states.c \
|
||||
lib/evil/evil_langinfo.c \
|
||||
lib/evil/evil_locale.c \
|
||||
lib/evil/evil_main.c \
|
||||
|
|
@ -44,33 +41,14 @@ lib/evil/evil_string.c \
|
|||
lib/evil/evil_time.c \
|
||||
lib/evil/evil_unistd.c \
|
||||
lib/evil/evil_util.c \
|
||||
lib/evil/evil_private.h \
|
||||
lib/evil/evil_fnmatch_private.h
|
||||
lib/evil/evil_private.h
|
||||
|
||||
lib_evil_libevil_la_CPPFLAGS = @EVIL_CPPFLAGS@ -DEFL_BUILD
|
||||
lib_evil_libevil_la_CFLAGS = @EVIL_CFLAGS@ @EVIL_CFLAGS_WRN@ -D__USE_MINGW_ANSI_STDIO
|
||||
lib_evil_libevil_la_LIBADD = @EVIL_LIBS@
|
||||
lib_evil_libevil_la_LDFLAGS = @EFL_LTLIBRARY_FLAGS@
|
||||
|
||||
# regex
|
||||
|
||||
dist_install_evilheaders_DATA += \
|
||||
lib/evil/regex/regex.h
|
||||
|
||||
lib_evil_libevil_la_SOURCES += \
|
||||
lib/evil/regex/regcomp.c \
|
||||
lib/evil/regex/regerror.c \
|
||||
lib/evil/regex/regexec.c \
|
||||
lib/evil/regex/regfree.c \
|
||||
lib/evil/regex/cclass.h \
|
||||
lib/evil/regex/cname.h \
|
||||
lib/evil/regex/regex2.h \
|
||||
lib/evil/regex/utils.h
|
||||
|
||||
lib_evil_libevil_la_CPPFLAGS += \
|
||||
-I$(top_srcdir)/src/lib/evil \
|
||||
-I$(top_srcdir)/src/lib/evil/regex \
|
||||
-DPOSIX_MISTAKE
|
||||
lib_evil_libevil_la_CPPFLAGS += -I$(top_srcdir)/src/lib/evil
|
||||
|
||||
### Unit tests
|
||||
|
||||
|
|
@ -103,9 +81,3 @@ tests_evil_evil_suite_DEPENDENCIES = @USE_EVIL_INTERNAL_LIBS@
|
|||
endif
|
||||
|
||||
endif
|
||||
|
||||
EXTRA_DIST2 += \
|
||||
lib/evil/regex/regerror.ih \
|
||||
lib/evil/regex/engine.ih \
|
||||
lib/evil/regex/regcomp.ih \
|
||||
lib/evil/regex/engine.c
|
||||
|
|
|
|||
|
|
@ -1,231 +0,0 @@
|
|||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
#endif /* HAVE_CONFIG_H */
|
||||
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "fnmatch.h"
|
||||
#include "evil_fnmatch_private.h"
|
||||
|
||||
enum fnmatch_status
|
||||
{
|
||||
fnmatch_not_found = 0,
|
||||
fnmatch_found = 1,
|
||||
fnmatch_syntax_error = 2
|
||||
};
|
||||
|
||||
static
|
||||
size_t
|
||||
fnmatch_match_class_token(enum fnmatch_status *status,
|
||||
const char *class_token,
|
||||
char c)
|
||||
{
|
||||
if (! *class_token)
|
||||
{
|
||||
*status = fnmatch_syntax_error;
|
||||
return 0;
|
||||
}
|
||||
else if (class_token[1] == '-' && class_token[2] != ']')
|
||||
{
|
||||
if (class_token[0] <= c && c <= class_token[2])
|
||||
*status = fnmatch_found;
|
||||
return 3;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (c == *class_token)
|
||||
*status = fnmatch_found;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
static
|
||||
size_t
|
||||
fnmatch_complement_class(const char *class_token)
|
||||
{
|
||||
switch (*class_token)
|
||||
{
|
||||
case 0:
|
||||
return FNM_SYNTAXERR;
|
||||
|
||||
case '!':
|
||||
return 1;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static
|
||||
size_t
|
||||
fnmatch_match_class(const char *class,
|
||||
char c)
|
||||
{
|
||||
const size_t complement = fnmatch_complement_class(class + 1);
|
||||
enum fnmatch_status status;
|
||||
size_t pos;
|
||||
|
||||
if (complement == FNM_SYNTAXERR)
|
||||
return FNM_SYNTAXERR;
|
||||
|
||||
status = fnmatch_not_found;
|
||||
pos = 1 + complement;
|
||||
|
||||
do
|
||||
pos += fnmatch_match_class_token(&status, class + pos, c);
|
||||
while (class[pos] && class[pos] != ']');
|
||||
|
||||
if (status == fnmatch_syntax_error || ! class[pos])
|
||||
return FNM_SYNTAXERR;
|
||||
|
||||
if (status == fnmatch_found)
|
||||
return complement ? 0 : pos + 1;
|
||||
else
|
||||
return complement ? pos + 1 : 0;
|
||||
}
|
||||
|
||||
static
|
||||
size_t
|
||||
fnmatch_chrcasecmp(char a,
|
||||
char b)
|
||||
{
|
||||
if ('A' <= a && a <= 'Z')
|
||||
a += 'a' - 'A';
|
||||
if ('A' <= b && b <= 'Z')
|
||||
b += 'a' - 'A';
|
||||
return a == b;
|
||||
}
|
||||
|
||||
static
|
||||
size_t
|
||||
fnmatch_match_token(const char *token,
|
||||
char c,
|
||||
e_bool leading,
|
||||
int flags)
|
||||
{
|
||||
if (*token == '\\' && !(flags & FNM_NOESCAPE))
|
||||
return token[1] ? (token[1] == c ? 2 : 0) : FNM_SYNTAXERR;
|
||||
|
||||
if (c == '/' && (flags & FNM_PATHNAME))
|
||||
return *token == '/';
|
||||
|
||||
if (c == '.' && leading && (flags & FNM_PERIOD))
|
||||
return *token == '.';
|
||||
|
||||
switch (*token)
|
||||
{
|
||||
case '?':
|
||||
return 1;
|
||||
|
||||
case '[':
|
||||
return fnmatch_match_class(token, c);
|
||||
|
||||
default:
|
||||
if (flags & FNM_CASEFOLD)
|
||||
return fnmatch_chrcasecmp(*token, c);
|
||||
return *token == c ? 1 : 0;
|
||||
}
|
||||
}
|
||||
|
||||
static
|
||||
void
|
||||
fnmatch_init_states(struct list_of_states *states)
|
||||
{
|
||||
states->size = 1;
|
||||
states->states[0] = 0;
|
||||
memset(states->has, 0, states->reserved * sizeof (*states->has));
|
||||
states->has[0] = 1;
|
||||
}
|
||||
|
||||
static
|
||||
size_t
|
||||
fnmatch_check_finals(const char *pattern,
|
||||
const struct list_of_states *states)
|
||||
{
|
||||
size_t i, j;
|
||||
for (i = 0; i < states->size; ++i)
|
||||
{
|
||||
e_bool match = 1;
|
||||
|
||||
for (j = states->states[i]; pattern[j]; ++j)
|
||||
if (pattern[j] != '*')
|
||||
{
|
||||
match = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
if (match)
|
||||
return 0;
|
||||
}
|
||||
return FNM_NOMATCH;
|
||||
}
|
||||
|
||||
int
|
||||
fnmatch(const char *pattern,
|
||||
const char *string,
|
||||
int flags)
|
||||
{
|
||||
struct list_of_states *states;
|
||||
struct list_of_states *new_states;
|
||||
e_bool leading = 1;
|
||||
char *c;
|
||||
size_t r;
|
||||
|
||||
assert(pattern);
|
||||
assert(string);
|
||||
|
||||
states = fnmatch_list_of_states_alloc(2, strlen(pattern));
|
||||
new_states = states + 1;
|
||||
|
||||
if (! states)
|
||||
return FNM_NOMEM;
|
||||
fnmatch_init_states(states);
|
||||
|
||||
|
||||
for (c = (char *)string; *c && states->size; ++c)
|
||||
{
|
||||
size_t i;
|
||||
fnmatch_list_of_states_clear(new_states);
|
||||
|
||||
for (i = 0; i < states->size; ++i)
|
||||
{
|
||||
const size_t pos = states->states[i];
|
||||
|
||||
if (! pattern[pos])
|
||||
{
|
||||
if (*c == '/' && (flags & FNM_LEADING_DIR))
|
||||
return 0;
|
||||
continue;
|
||||
}
|
||||
else if (pattern[pos] == '*')
|
||||
{
|
||||
fnmatch_list_of_states_insert(states, pos + 1);
|
||||
if ((*c != '/' || !(flags & FNM_PATHNAME)) &&
|
||||
(*c != '.' || !leading || !(flags & FNM_PERIOD)))
|
||||
fnmatch_list_of_states_insert(new_states, pos);
|
||||
}
|
||||
else
|
||||
{
|
||||
const size_t m = fnmatch_match_token(pattern + pos, *c,
|
||||
leading, flags);
|
||||
|
||||
if (m == FNM_SYNTAXERR)
|
||||
return FNM_SYNTAXERR;
|
||||
else if (m)
|
||||
fnmatch_list_of_states_insert(new_states, pos + m);
|
||||
}
|
||||
}
|
||||
{
|
||||
struct list_of_states *tmp = states;
|
||||
|
||||
states = new_states;
|
||||
new_states = tmp;
|
||||
}
|
||||
leading = *c == '/' && (flags & FNM_PATHNAME);
|
||||
}
|
||||
|
||||
r = fnmatch_check_finals(pattern, states);
|
||||
fnmatch_list_of_states_free(states < new_states ? states : new_states, 2);
|
||||
return (int)r;
|
||||
}
|
||||
|
|
@ -1,77 +0,0 @@
|
|||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
#endif /* HAVE_CONFIG_H */
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "evil_fnmatch_private.h"
|
||||
|
||||
struct list_of_states*
|
||||
fnmatch_list_of_states_alloc(size_t n,
|
||||
size_t pattern_len)
|
||||
{
|
||||
struct list_of_states *l;
|
||||
|
||||
const size_t reserved = pattern_len + 1;
|
||||
const size_t states_size = sizeof (*l->states) * reserved;
|
||||
const size_t has_size = sizeof (*l->has) * reserved;
|
||||
const size_t states_has_size = states_size + has_size;
|
||||
const size_t struct_size = sizeof (*l) + states_has_size;
|
||||
|
||||
unsigned char *states;
|
||||
unsigned char *has;
|
||||
size_t i;
|
||||
|
||||
l = malloc(n * struct_size);
|
||||
if (!l)
|
||||
return 0;
|
||||
|
||||
states = (unsigned char *) (l + n);
|
||||
has = states + states_size;
|
||||
|
||||
for (i = 0; i < n; ++i)
|
||||
{
|
||||
l[i].reserved = reserved;
|
||||
l[i].states = (size_t *) states;
|
||||
l[i].has = (e_bool *) has;
|
||||
states += states_has_size;
|
||||
has += states_has_size;
|
||||
}
|
||||
|
||||
return l;
|
||||
}
|
||||
|
||||
void
|
||||
fnmatch_list_of_states_free(struct list_of_states *lists,
|
||||
size_t n)
|
||||
{
|
||||
assert(lists);
|
||||
|
||||
(void) n;
|
||||
free(lists);
|
||||
}
|
||||
|
||||
void
|
||||
fnmatch_list_of_states_insert(struct list_of_states *list,
|
||||
size_t state)
|
||||
{
|
||||
assert(list);
|
||||
assert(state < list->reserved);
|
||||
|
||||
if (list->has[state])
|
||||
return;
|
||||
|
||||
list->states[list->size++] = state;
|
||||
list->has[state] = 1;
|
||||
}
|
||||
|
||||
void
|
||||
fnmatch_list_of_states_clear(struct list_of_states *list)
|
||||
{
|
||||
assert(list);
|
||||
|
||||
list->size = 0;
|
||||
memset(list->has, 0, list->reserved * sizeof (*list->has));
|
||||
}
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
#ifndef __EVIL_FNMATCH_PRIVATE_H__
|
||||
#define __EVIL_FNMATCH_PRIVATE_H__
|
||||
|
||||
|
||||
typedef int e_bool;
|
||||
|
||||
struct list_of_states
|
||||
{
|
||||
size_t reserved;
|
||||
size_t size;
|
||||
size_t *states;
|
||||
e_bool *has;
|
||||
};
|
||||
|
||||
struct list_of_states *fnmatch_list_of_states_alloc(size_t n, size_t pattern_len);
|
||||
|
||||
void fnmatch_list_of_states_free(struct list_of_states *lists, size_t n);
|
||||
|
||||
void fnmatch_list_of_states_insert(struct list_of_states *list, size_t state);
|
||||
|
||||
void fnmatch_list_of_states_clear(struct list_of_states *list);
|
||||
|
||||
|
||||
#endif /* __EVIL_FNMATCH_PRIVATE_H__ */
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
#ifndef __EVIL_FNMATCH_H__
|
||||
#define __EVIL_FNMATCH_H__
|
||||
|
||||
#ifdef EAPI
|
||||
# undef EAPI
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
# ifdef EFL_BUILD
|
||||
# ifdef DLL_EXPORT
|
||||
# define EAPI __declspec(dllexport)
|
||||
# else
|
||||
# define EAPI
|
||||
# endif
|
||||
# else
|
||||
# define EAPI __declspec(dllimport)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* We #undef these before defining them because some losing systems
|
||||
(HP-UX A.08.07 for example) define these in <unistd.h>. */
|
||||
#undef FNM_PATHNAME
|
||||
#undef FNM_NOESCAPE
|
||||
#undef FNM_PERIOD
|
||||
|
||||
/* Bits set in the FLAGS argument to `fnmatch'. */
|
||||
#define FNM_PATHNAME (1 << 0) /* No wildcard can ever match `/'. */
|
||||
#define FNM_NOESCAPE (1 << 1) /* Backslashes don't quote special chars. */
|
||||
#define FNM_PERIOD (1 << 2) /* Leading `.' is matched only explicitly. */
|
||||
|
||||
#if !defined (_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 2 || defined (_GNU_SOURCE)
|
||||
#define FNM_FILE_NAME FNM_PATHNAME /* Preferred GNU name. */
|
||||
#define FNM_LEADING_DIR (1 << 3) /* Ignore `/...' after a match. */
|
||||
#define FNM_CASEFOLD (1 << 4) /* Compare without regard to case. */
|
||||
#endif
|
||||
|
||||
/* Value returned by `fnmatch' if STRING does not match PATTERN. */
|
||||
#define FNM_NOMATCH 1
|
||||
#define FNM_SYNTAXERR 2
|
||||
#define FNM_NOMEM 3
|
||||
|
||||
/* Match STRING against the filename pattern PATTERN,
|
||||
returning zero if it matches, FNM_NOMATCH if not. */
|
||||
EAPI int fnmatch(const char *__pattern, const char *__string, int __flags);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#undef EAPI
|
||||
#define EAPI
|
||||
|
||||
#endif /* __EVIL_FNMATCH_H__ */
|
||||
|
|
@ -18,17 +18,13 @@ if target_machine.system() == 'windows'
|
|||
'evil_unistd.h',
|
||||
'evil_util.h',
|
||||
'dirent.h',
|
||||
'fnmatch.h',
|
||||
'pwd.h',
|
||||
'regex/regex.h'
|
||||
]
|
||||
evil_header_sys_src = [join_paths('sys','mman.h')]
|
||||
|
||||
evil_src = [
|
||||
'evil_dlfcn.c',
|
||||
'evil_fcntl.c',
|
||||
'evil_fnmatch.c',
|
||||
'evil_fnmatch_list_of_states.c',
|
||||
'evil_langinfo.c',
|
||||
'evil_locale.c',
|
||||
'evil_main.c',
|
||||
|
|
@ -41,11 +37,8 @@ if target_machine.system() == 'windows'
|
|||
'evil_unistd.c',
|
||||
'evil_util.c',
|
||||
'evil_private.h',
|
||||
'evil_fnmatch_private.h',
|
||||
]
|
||||
|
||||
subdir('regex')
|
||||
|
||||
psapi = cc.find_library('psapi')
|
||||
ole32 = cc.find_library('ole32')
|
||||
ws2_32 = cc.find_library('ws2_32')
|
||||
|
|
@ -53,13 +46,13 @@ if target_machine.system() == 'windows'
|
|||
uuid = cc.find_library('uuid')
|
||||
|
||||
evil_lib = library('evil', evil_src,
|
||||
dependencies : [psapi, ole32, ws2_32, secur32, uuid],
|
||||
include_directories : [config_dir, include_directories('regex')],
|
||||
dependencies : [psapi, ole32, ws2_32, secur32, uuid, regexp],
|
||||
include_directories : [config_dir],
|
||||
)
|
||||
|
||||
evil = declare_dependency(
|
||||
include_directories: [config_dir, include_directories('regex'), include_directories('.')],
|
||||
dependencies : [psapi, ole32, ws2_32, secur32, uuid],
|
||||
include_directories: [include_directories('.')],
|
||||
dependencies : [psapi, ole32, ws2_32, secur32, uuid, regexp],
|
||||
link_with: evil_lib,
|
||||
)
|
||||
else
|
||||
|
|
|
|||
|
|
@ -1,31 +0,0 @@
|
|||
/* character-class table */
|
||||
static struct cclass {
|
||||
char *name;
|
||||
char *chars;
|
||||
char *multis;
|
||||
} cclasses[] = {
|
||||
"alnum", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
|
||||
0123456789", "",
|
||||
"alpha", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
|
||||
"",
|
||||
"blank", " \t", "",
|
||||
"cntrl", "\007\b\t\n\v\f\r\1\2\3\4\5\6\16\17\20\21\22\23\24\
|
||||
\25\26\27\30\31\32\33\34\35\36\37\177", "",
|
||||
"digit", "0123456789", "",
|
||||
"graph", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
|
||||
0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
|
||||
"",
|
||||
"lower", "abcdefghijklmnopqrstuvwxyz",
|
||||
"",
|
||||
"print", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\
|
||||
0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~ ",
|
||||
"",
|
||||
"punct", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
|
||||
"",
|
||||
"space", "\t\n\v\f\r ", "",
|
||||
"upper", "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
|
||||
"",
|
||||
"xdigit", "0123456789ABCDEFabcdef",
|
||||
"",
|
||||
NULL, 0, ""
|
||||
};
|
||||
|
|
@ -1,102 +0,0 @@
|
|||
/* character-name table */
|
||||
static struct cname {
|
||||
char *name;
|
||||
char code;
|
||||
} cnames[] = {
|
||||
"NUL", '\0',
|
||||
"SOH", '\001',
|
||||
"STX", '\002',
|
||||
"ETX", '\003',
|
||||
"EOT", '\004',
|
||||
"ENQ", '\005',
|
||||
"ACK", '\006',
|
||||
"BEL", '\007',
|
||||
"alert", '\007',
|
||||
"BS", '\010',
|
||||
"backspace", '\b',
|
||||
"HT", '\011',
|
||||
"tab", '\t',
|
||||
"LF", '\012',
|
||||
"newline", '\n',
|
||||
"VT", '\013',
|
||||
"vertical-tab", '\v',
|
||||
"FF", '\014',
|
||||
"form-feed", '\f',
|
||||
"CR", '\015',
|
||||
"carriage-return", '\r',
|
||||
"SO", '\016',
|
||||
"SI", '\017',
|
||||
"DLE", '\020',
|
||||
"DC1", '\021',
|
||||
"DC2", '\022',
|
||||
"DC3", '\023',
|
||||
"DC4", '\024',
|
||||
"NAK", '\025',
|
||||
"SYN", '\026',
|
||||
"ETB", '\027',
|
||||
"CAN", '\030',
|
||||
"EM", '\031',
|
||||
"SUB", '\032',
|
||||
"ESC", '\033',
|
||||
"IS4", '\034',
|
||||
"FS", '\034',
|
||||
"IS3", '\035',
|
||||
"GS", '\035',
|
||||
"IS2", '\036',
|
||||
"RS", '\036',
|
||||
"IS1", '\037',
|
||||
"US", '\037',
|
||||
"space", ' ',
|
||||
"exclamation-mark", '!',
|
||||
"quotation-mark", '"',
|
||||
"number-sign", '#',
|
||||
"dollar-sign", '$',
|
||||
"percent-sign", '%',
|
||||
"ampersand", '&',
|
||||
"apostrophe", '\'',
|
||||
"left-parenthesis", '(',
|
||||
"right-parenthesis", ')',
|
||||
"asterisk", '*',
|
||||
"plus-sign", '+',
|
||||
"comma", ',',
|
||||
"hyphen", '-',
|
||||
"hyphen-minus", '-',
|
||||
"period", '.',
|
||||
"full-stop", '.',
|
||||
"slash", '/',
|
||||
"solidus", '/',
|
||||
"zero", '0',
|
||||
"one", '1',
|
||||
"two", '2',
|
||||
"three", '3',
|
||||
"four", '4',
|
||||
"five", '5',
|
||||
"six", '6',
|
||||
"seven", '7',
|
||||
"eight", '8',
|
||||
"nine", '9',
|
||||
"colon", ':',
|
||||
"semicolon", ';',
|
||||
"less-than-sign", '<',
|
||||
"equals-sign", '=',
|
||||
"greater-than-sign", '>',
|
||||
"question-mark", '?',
|
||||
"commercial-at", '@',
|
||||
"left-square-bracket", '[',
|
||||
"backslash", '\\',
|
||||
"reverse-solidus", '\\',
|
||||
"right-square-bracket", ']',
|
||||
"circumflex", '^',
|
||||
"circumflex-accent", '^',
|
||||
"underscore", '_',
|
||||
"low-line", '_',
|
||||
"grave-accent", '`',
|
||||
"left-brace", '{',
|
||||
"left-curly-bracket", '{',
|
||||
"vertical-line", '|',
|
||||
"right-brace", '}',
|
||||
"right-curly-bracket", '}',
|
||||
"tilde", '~',
|
||||
"DEL", '\177',
|
||||
NULL, 0,
|
||||
};
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,35 +0,0 @@
|
|||
/* ========= begin header generated by ../src/lib/evil/regex/mkh.sh ========= */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* === lib/evil/regex/engine.c === */
|
||||
static int matcher(register struct re_guts *g, char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
|
||||
static char *dissect(register struct match *m, char *start, char *stop, sopno startst, sopno stopst);
|
||||
static char *backref(register struct match *m, char *start, char *stop, sopno startst, sopno stopst, sopno lev);
|
||||
static char *fast(register struct match *m, char *start, char *stop, sopno startst, sopno stopst);
|
||||
static char *slow(register struct match *m, char *start, char *stop, sopno startst, sopno stopst);
|
||||
static states step(register struct re_guts *g, sopno start, sopno stop, register states bef, int ch, register states aft);
|
||||
#define BOL (OUT+1)
|
||||
#define EOL (BOL+1)
|
||||
#define BOLEOL (BOL+2)
|
||||
#define NOTHING (BOL+3)
|
||||
#define BOW (BOL+4)
|
||||
#define EOW (BOL+5)
|
||||
#define CODEMAX (BOL+5) /* highest code used */
|
||||
#define NONCHAR(c) ((c) > CHAR_MAX)
|
||||
#define NNONCHAR (CODEMAX-CHAR_MAX)
|
||||
#ifdef REDEBUG
|
||||
static void print(struct match *m, char *caption, states st, int ch, FILE *d);
|
||||
#endif
|
||||
#ifdef REDEBUG
|
||||
static void at(struct match *m, char *title, char *start, char *stop, sopno startst, sopno stopst);
|
||||
#endif
|
||||
#ifdef REDEBUG
|
||||
static char *pchar(int ch);
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* ========= end header generated by ../src/lib/evil/regex/mkh.sh ========= */
|
||||
|
|
@ -1,10 +0,0 @@
|
|||
evil_src += files([
|
||||
'regcomp.c',
|
||||
'regerror.c',
|
||||
'regexec.c',
|
||||
'regfree.c',
|
||||
'cclass.h',
|
||||
'cname.h',
|
||||
'regex2.h',
|
||||
'utils.h'
|
||||
])
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,51 +0,0 @@
|
|||
/* ========= begin header generated by ../src/lib/evil/regex/mkh.sh ========= */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* === lib/evil/regex/regcomp.c === */
|
||||
static void p_ere(register struct parse *p, int stop);
|
||||
static void p_ere_exp(register struct parse *p);
|
||||
static void p_str(register struct parse *p);
|
||||
static void p_bre(register struct parse *p, register int end1, register int end2);
|
||||
static int p_simp_re(register struct parse *p, int starordinary);
|
||||
static int p_count(register struct parse *p);
|
||||
static void p_bracket(register struct parse *p);
|
||||
static void p_b_term(register struct parse *p, register cset *cs);
|
||||
static void p_b_cclass(register struct parse *p, register cset *cs);
|
||||
static void p_b_eclass(register struct parse *p, register cset *cs);
|
||||
static char p_b_symbol(register struct parse *p);
|
||||
static char p_b_coll_elem(register struct parse *p, int endc);
|
||||
static char othercase(int ch);
|
||||
static void bothcases(register struct parse *p, int ch);
|
||||
static void ordinary(register struct parse *p, register int ch);
|
||||
static void nonnewline(register struct parse *p);
|
||||
static void repeat(register struct parse *p, sopno start, int from, int to);
|
||||
static int seterr(register struct parse *p, int e);
|
||||
static cset *allocset(register struct parse *p);
|
||||
static void freeset(register struct parse *p, register cset *cs);
|
||||
static int freezeset(register struct parse *p, register cset *cs);
|
||||
static int firstch(register struct parse *p, register cset *cs);
|
||||
static int nch(register struct parse *p, register cset *cs);
|
||||
static void mcadd(register struct parse *p, register cset *cs, register char *cp);
|
||||
static void mcsub(register cset *cs, register char *cp);
|
||||
static int mcin(register cset *cs, register char *cp);
|
||||
static char *mcfind(register cset *cs, register char *cp);
|
||||
static void mcinvert(register struct parse *p, register cset *cs);
|
||||
static void mccase(register struct parse *p, register cset *cs);
|
||||
static int isinsets(register struct re_guts *g, int c);
|
||||
static int samesets(register struct re_guts *g, int c1, int c2);
|
||||
static void categorize(struct parse *p, register struct re_guts *g);
|
||||
static sopno dupl(register struct parse *p, sopno start, sopno finish);
|
||||
static void doemit(register struct parse *p, sop op, size_t opnd);
|
||||
static void doinsert(register struct parse *p, sop op, size_t opnd, sopno pos);
|
||||
static void dofwd(register struct parse *p, sopno pos, sop value);
|
||||
static void enlarge(register struct parse *p, sopno size);
|
||||
static void stripsnug(register struct parse *p, register struct re_guts *g);
|
||||
static void findmust(register struct parse *p, register struct re_guts *g);
|
||||
static sopno pluscount(register struct parse *p, register struct re_guts *g);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* ========= end header generated by ../src/lib/evil/regex/mkh.sh ========= */
|
||||
|
|
@ -1,122 +0,0 @@
|
|||
#include <sys/types.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <limits.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "regex.h"
|
||||
#include "utils.h"
|
||||
#include "regerror.ih"
|
||||
|
||||
/*
|
||||
= #define REG_OKAY 0
|
||||
= #define REG_NOMATCH 1
|
||||
= #define REG_BADPAT 2
|
||||
= #define REG_ECOLLATE 3
|
||||
= #define REG_ECTYPE 4
|
||||
= #define REG_EESCAPE 5
|
||||
= #define REG_ESUBREG 6
|
||||
= #define REG_EBRACK 7
|
||||
= #define REG_EPAREN 8
|
||||
= #define REG_EBRACE 9
|
||||
= #define REG_BADBR 10
|
||||
= #define REG_ERANGE 11
|
||||
= #define REG_ESPACE 12
|
||||
= #define REG_BADRPT 13
|
||||
= #define REG_EMPTY 14
|
||||
= #define REG_ASSERT 15
|
||||
= #define REG_INVARG 16
|
||||
= #define REG_ATOI 255 // convert name to number (!)
|
||||
= #define REG_ITOA 0400 // convert number to name (!)
|
||||
*/
|
||||
static struct rerr {
|
||||
int code;
|
||||
char *name;
|
||||
char *explain;
|
||||
} rerrs[] = {
|
||||
REG_OKAY, "REG_OKAY", "no errors detected",
|
||||
REG_NOMATCH, "REG_NOMATCH", "regexec() failed to match",
|
||||
REG_BADPAT, "REG_BADPAT", "invalid regular expression",
|
||||
REG_ECOLLATE, "REG_ECOLLATE", "invalid collating element",
|
||||
REG_ECTYPE, "REG_ECTYPE", "invalid character class",
|
||||
REG_EESCAPE, "REG_EESCAPE", "trailing backslash (\\)",
|
||||
REG_ESUBREG, "REG_ESUBREG", "invalid backreference number",
|
||||
REG_EBRACK, "REG_EBRACK", "brackets ([ ]) not balanced",
|
||||
REG_EPAREN, "REG_EPAREN", "parentheses not balanced",
|
||||
REG_EBRACE, "REG_EBRACE", "braces not balanced",
|
||||
REG_BADBR, "REG_BADBR", "invalid repetition count(s)",
|
||||
REG_ERANGE, "REG_ERANGE", "invalid character range",
|
||||
REG_ESPACE, "REG_ESPACE", "out of memory",
|
||||
REG_BADRPT, "REG_BADRPT", "repetition-operator operand invalid",
|
||||
REG_EMPTY, "REG_EMPTY", "empty (sub)expression",
|
||||
REG_ASSERT, "REG_ASSERT", "\"can't happen\" -- you found a bug",
|
||||
REG_INVARG, "REG_INVARG", "invalid argument to regex routine",
|
||||
-1, "", "*** unknown regexp error code ***",
|
||||
};
|
||||
|
||||
/*
|
||||
- regerror - the interface to error numbers
|
||||
= extern size_t regerror(int, const regex_t *, char *, size_t);
|
||||
*/
|
||||
/* ARGSUSED */
|
||||
EAPI size_t
|
||||
regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
|
||||
{
|
||||
register struct rerr *r;
|
||||
register size_t len;
|
||||
register int target = errcode &~ REG_ITOA;
|
||||
register char *s;
|
||||
char convbuf[50];
|
||||
|
||||
if (errcode == REG_ATOI)
|
||||
s = regatoi(preg, convbuf);
|
||||
else {
|
||||
for (r = rerrs; r->code >= 0; r++)
|
||||
if (r->code == target)
|
||||
break;
|
||||
|
||||
if (errcode®_ITOA) {
|
||||
if (r->code >= 0)
|
||||
(void) strcpy(convbuf, r->name);
|
||||
else
|
||||
sprintf(convbuf, "REG_0x%x", target);
|
||||
assert(strlen(convbuf) < sizeof(convbuf));
|
||||
s = convbuf;
|
||||
} else
|
||||
s = r->explain;
|
||||
}
|
||||
|
||||
len = strlen(s) + 1;
|
||||
if (errbuf_size > 0) {
|
||||
if (errbuf_size > len)
|
||||
(void) strcpy(errbuf, s);
|
||||
else {
|
||||
(void) strncpy(errbuf, s, errbuf_size-1);
|
||||
errbuf[errbuf_size-1] = '\0';
|
||||
}
|
||||
}
|
||||
|
||||
return(len);
|
||||
}
|
||||
|
||||
/*
|
||||
- regatoi - internal routine to implement REG_ATOI
|
||||
== static char *regatoi(const regex_t *preg, char *localbuf);
|
||||
*/
|
||||
static char *
|
||||
regatoi(preg, localbuf)
|
||||
const regex_t *preg;
|
||||
char *localbuf;
|
||||
{
|
||||
register struct rerr *r;
|
||||
|
||||
for (r = rerrs; r->code >= 0; r++)
|
||||
if (strcmp(r->name, preg->re_endp) == 0)
|
||||
break;
|
||||
if (r->code < 0)
|
||||
return("0");
|
||||
|
||||
sprintf(localbuf, "%d", r->code);
|
||||
return(localbuf);
|
||||
}
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
/* ========= begin header generated by ../src/lib/evil/regex/mkh.sh ========= */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* === lib/evil/regex/regerror.c === */
|
||||
static char *regatoi(const regex_t *preg, char *localbuf);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* ========= end header generated by ../src/lib/evil/regex/mkh.sh ========= */
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
#ifndef _REGEX_H_
|
||||
#define _REGEX_H_ /* never again */
|
||||
|
||||
#include <evil_macro.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
/* ========= begin header generated by ../src/lib/evil/regex/mkh.sh ========= */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* === lib/evil/regex/regex2.h === */
|
||||
typedef off_t regoff_t;
|
||||
typedef struct {
|
||||
int re_magic;
|
||||
size_t re_nsub; /* number of parenthesized subexpressions */
|
||||
const char *re_endp; /* end pointer for REG_PEND */
|
||||
struct re_guts *re_g; /* none of your business :-) */
|
||||
} regex_t;
|
||||
typedef struct {
|
||||
regoff_t rm_so; /* start of match */
|
||||
regoff_t rm_eo; /* end of match */
|
||||
} regmatch_t;
|
||||
|
||||
|
||||
/* === lib/evil/regex/regcomp.c === */
|
||||
EAPI int regcomp(regex_t *, const char *, int);
|
||||
#define REG_BASIC 0000
|
||||
#define REG_EXTENDED 0001
|
||||
#define REG_ICASE 0002
|
||||
#define REG_NOSUB 0004
|
||||
#define REG_NEWLINE 0010
|
||||
#define REG_NOSPEC 0020
|
||||
#define REG_PEND 0040
|
||||
#define REG_DUMP 0200
|
||||
|
||||
|
||||
/* === lib/evil/regex/regerror.c === */
|
||||
#define REG_OKAY 0
|
||||
#define REG_NOMATCH 1
|
||||
#define REG_BADPAT 2
|
||||
#define REG_ECOLLATE 3
|
||||
#define REG_ECTYPE 4
|
||||
#define REG_EESCAPE 5
|
||||
#define REG_ESUBREG 6
|
||||
#define REG_EBRACK 7
|
||||
#define REG_EPAREN 8
|
||||
#define REG_EBRACE 9
|
||||
#define REG_BADBR 10
|
||||
#define REG_ERANGE 11
|
||||
#define REG_ESPACE 12
|
||||
#define REG_BADRPT 13
|
||||
#define REG_EMPTY 14
|
||||
#define REG_ASSERT 15
|
||||
#define REG_INVARG 16
|
||||
#define REG_ATOI 255 /* convert name to number (!) */
|
||||
#define REG_ITOA 0400 /* convert number to name (!) */
|
||||
EAPI size_t regerror(int, const regex_t *, char *, size_t);
|
||||
|
||||
|
||||
/* === lib/evil/regex/regexec.c === */
|
||||
EAPI int regexec(const regex_t *, const char *, size_t, regmatch_t [], int);
|
||||
#define REG_NOTBOL 00001
|
||||
#define REG_NOTEOL 00002
|
||||
#define REG_STARTEND 00004
|
||||
#define REG_TRACE 00400 /* tracing of execution */
|
||||
#define REG_LARGE 01000 /* force large representation */
|
||||
#define REG_BACKR 02000 /* force use of backref code */
|
||||
|
||||
|
||||
/* === lib/evil/regex/regfree.c === */
|
||||
EAPI void regfree(regex_t *);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* ========= end header generated by ../src/lib/evil/regex/mkh.sh ========= */
|
||||
#endif
|
||||
|
|
@ -1,134 +0,0 @@
|
|||
/*
|
||||
* First, the stuff that ends up in the outside-world include file
|
||||
= typedef off_t regoff_t;
|
||||
= typedef struct {
|
||||
= int re_magic;
|
||||
= size_t re_nsub; // number of parenthesized subexpressions
|
||||
= const char *re_endp; // end pointer for REG_PEND
|
||||
= struct re_guts *re_g; // none of your business :-)
|
||||
= } regex_t;
|
||||
= typedef struct {
|
||||
= regoff_t rm_so; // start of match
|
||||
= regoff_t rm_eo; // end of match
|
||||
= } regmatch_t;
|
||||
*/
|
||||
/*
|
||||
* internals of regex_t
|
||||
*/
|
||||
#define MAGIC1 ((('r'^0200)<<8) | 'e')
|
||||
|
||||
/*
|
||||
* The internal representation is a *strip*, a sequence of
|
||||
* operators ending with an endmarker. (Some terminology etc. is a
|
||||
* historical relic of earlier versions which used multiple strips.)
|
||||
* Certain oddities in the representation are there to permit running
|
||||
* the machinery backwards; in particular, any deviation from sequential
|
||||
* flow must be marked at both its source and its destination. Some
|
||||
* fine points:
|
||||
*
|
||||
* - OPLUS_ and O_PLUS are *inside* the loop they create.
|
||||
* - OQUEST_ and O_QUEST are *outside* the bypass they create.
|
||||
* - OCH_ and O_CH are *outside* the multi-way branch they create, while
|
||||
* OOR1 and OOR2 are respectively the end and the beginning of one of
|
||||
* the branches. Note that there is an implicit OOR2 following OCH_
|
||||
* and an implicit OOR1 preceding O_CH.
|
||||
*
|
||||
* In state representations, an operator's bit is on to signify a state
|
||||
* immediately *preceding* "execution" of that operator.
|
||||
*/
|
||||
typedef long sop; /* strip operator */
|
||||
typedef long sopno;
|
||||
#define OPRMASK 0x7c000000
|
||||
#define OPDMASK 0x03ffffff
|
||||
#define OPSHIFT (26)
|
||||
#define OP(n) ((n)&OPRMASK)
|
||||
#define OPND(n) ((n)&OPDMASK)
|
||||
#define SOP(op, opnd) ((op)|(opnd))
|
||||
/* operators meaning operand */
|
||||
/* (back, fwd are offsets) */
|
||||
#define OEND (1<<OPSHIFT) /* endmarker - */
|
||||
#define OCHAR (2<<OPSHIFT) /* character unsigned char */
|
||||
#define OBOL (3<<OPSHIFT) /* left anchor - */
|
||||
#define OEOL (4<<OPSHIFT) /* right anchor - */
|
||||
#define OANY (5<<OPSHIFT) /* . - */
|
||||
#define OANYOF (6<<OPSHIFT) /* [...] set number */
|
||||
#define OBACK_ (7<<OPSHIFT) /* begin \d paren number */
|
||||
#define O_BACK (8<<OPSHIFT) /* end \d paren number */
|
||||
#define OPLUS_ (9<<OPSHIFT) /* + prefix fwd to suffix */
|
||||
#define O_PLUS (10<<OPSHIFT) /* + suffix back to prefix */
|
||||
#define OQUEST_ (11<<OPSHIFT) /* ? prefix fwd to suffix */
|
||||
#define O_QUEST (12<<OPSHIFT) /* ? suffix back to prefix */
|
||||
#define OLPAREN (13<<OPSHIFT) /* ( fwd to ) */
|
||||
#define ORPAREN (14<<OPSHIFT) /* ) back to ( */
|
||||
#define OCH_ (15<<OPSHIFT) /* begin choice fwd to OOR2 */
|
||||
#define OOR1 (16<<OPSHIFT) /* | pt. 1 back to OOR1 or OCH_ */
|
||||
#define OOR2 (17<<OPSHIFT) /* | pt. 2 fwd to OOR2 or O_CH */
|
||||
#define O_CH (18<<OPSHIFT) /* end choice back to OOR1 */
|
||||
#define OBOW (19<<OPSHIFT) /* begin word - */
|
||||
#define OEOW (20<<OPSHIFT) /* end word - */
|
||||
|
||||
/*
|
||||
* Structure for [] character-set representation. Character sets are
|
||||
* done as bit vectors, grouped 8 to a byte vector for compactness.
|
||||
* The individual set therefore has both a pointer to the byte vector
|
||||
* and a mask to pick out the relevant bit of each byte. A hash code
|
||||
* simplifies testing whether two sets could be identical.
|
||||
*
|
||||
* This will get trickier for multicharacter collating elements. As
|
||||
* preliminary hooks for dealing with such things, we also carry along
|
||||
* a string of multi-character elements, and decide the size of the
|
||||
* vectors at run time.
|
||||
*/
|
||||
typedef struct {
|
||||
uch *ptr; /* -> uch [csetsize] */
|
||||
uch mask; /* bit within array */
|
||||
uch hash; /* hash code */
|
||||
size_t smultis;
|
||||
char *multis; /* -> char[smulti] ab\0cd\0ef\0\0 */
|
||||
} cset;
|
||||
/* note that CHadd and CHsub are unsafe, and CHIN doesn't yield 0/1 */
|
||||
#define CHadd(cs, c) ((cs)->ptr[(uch)(c)] |= (cs)->mask, (cs)->hash += (c))
|
||||
#define CHsub(cs, c) ((cs)->ptr[(uch)(c)] &= ~(cs)->mask, (cs)->hash -= (c))
|
||||
#define CHIN(cs, c) ((cs)->ptr[(uch)(c)] & (cs)->mask)
|
||||
#define MCadd(p, cs, cp) mcadd(p, cs, cp) /* regcomp() internal fns */
|
||||
#define MCsub(p, cs, cp) mcsub(p, cs, cp)
|
||||
#define MCin(p, cs, cp) mcin(p, cs, cp)
|
||||
|
||||
/* stuff for character categories */
|
||||
typedef unsigned char cat_t;
|
||||
|
||||
/*
|
||||
* main compiled-expression structure
|
||||
*/
|
||||
struct re_guts {
|
||||
int magic;
|
||||
# define MAGIC2 ((('R'^0200)<<8)|'E')
|
||||
sop *strip; /* malloced area for strip */
|
||||
int csetsize; /* number of bits in a cset vector */
|
||||
int ncsets; /* number of csets in use */
|
||||
cset *sets; /* -> cset [ncsets] */
|
||||
uch *setbits; /* -> uch[csetsize][ncsets/CHAR_BIT] */
|
||||
int cflags; /* copy of regcomp() cflags argument */
|
||||
sopno nstates; /* = number of sops */
|
||||
sopno firststate; /* the initial OEND (normally 0) */
|
||||
sopno laststate; /* the final OEND */
|
||||
int iflags; /* internal flags */
|
||||
# define USEBOL 01 /* used ^ */
|
||||
# define USEEOL 02 /* used $ */
|
||||
# define BAD 04 /* something wrong */
|
||||
int nbol; /* number of ^ used */
|
||||
int neol; /* number of $ used */
|
||||
int ncategories; /* how many character categories */
|
||||
cat_t *categories; /* ->catspace[-CHAR_MIN] */
|
||||
char *must; /* match must contain this string */
|
||||
int mlen; /* length of must */
|
||||
size_t nsub; /* copy of re_nsub */
|
||||
int backrefs; /* does it use back references? */
|
||||
sopno nplus; /* how deep does it nest +s? */
|
||||
/* catspace must be last */
|
||||
cat_t catspace[1]; /* actually [NC] */
|
||||
};
|
||||
|
||||
/* misc utilities */
|
||||
#define OUT (CHAR_MAX+1) /* a non-character value */
|
||||
#define ISWORD(c) (isalnum(c) || (c) == '_')
|
||||
|
|
@ -1,138 +0,0 @@
|
|||
/*
|
||||
* the outer shell of regexec()
|
||||
*
|
||||
* This file includes engine.c *twice*, after muchos fiddling with the
|
||||
* macros that code uses. This lets the same code operate on two different
|
||||
* representations for state sets.
|
||||
*/
|
||||
#include <sys/types.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <limits.h>
|
||||
#include <ctype.h>
|
||||
#include <regex.h>
|
||||
|
||||
#include "utils.h"
|
||||
#include "regex2.h"
|
||||
|
||||
static int nope = 0; /* for use in asserts; shuts lint up */
|
||||
|
||||
/* macros for manipulating states, small version */
|
||||
#define states unsigned
|
||||
#define states1 unsigned /* for later use in regexec() decision */
|
||||
#define CLEAR(v) ((v) = 0)
|
||||
#define SET0(v, n) ((v) &= ~((unsigned)1 << (n)))
|
||||
#define SET1(v, n) ((v) |= (unsigned)1 << (n))
|
||||
#define ISSET(v, n) ((v) & ((unsigned)1 << (n)))
|
||||
#define ASSIGN(d, s) ((d) = (s))
|
||||
#define EQ(a, b) ((a) == (b))
|
||||
#define STATEVARS int dummy /* dummy version */
|
||||
#define STATESETUP(m, n) /* nothing */
|
||||
#define STATETEARDOWN(m) /* nothing */
|
||||
#define SETUP(v) ((v) = 0)
|
||||
#define onestate unsigned
|
||||
#define INIT(o, n) ((o) = (unsigned)1 << (n))
|
||||
#define INC(o) ((o) <<= 1)
|
||||
#define ISSTATEIN(v, o) ((v) & (o))
|
||||
/* some abbreviations; note that some of these know variable names! */
|
||||
/* do "if I'm here, I can also be there" etc without branches */
|
||||
#define FWD(dst, src, n) ((dst) |= ((unsigned)(src)&(here)) << (n))
|
||||
#define BACK(dst, src, n) ((dst) |= ((unsigned)(src)&(here)) >> (n))
|
||||
#define ISSETBACK(v, n) ((v) & ((unsigned)here >> (n)))
|
||||
/* function names */
|
||||
#define SNAMES /* engine.c looks after details */
|
||||
|
||||
#include "engine.c"
|
||||
|
||||
/* now undo things */
|
||||
#undef states
|
||||
#undef CLEAR
|
||||
#undef SET0
|
||||
#undef SET1
|
||||
#undef ISSET
|
||||
#undef ASSIGN
|
||||
#undef EQ
|
||||
#undef STATEVARS
|
||||
#undef STATESETUP
|
||||
#undef STATETEARDOWN
|
||||
#undef SETUP
|
||||
#undef onestate
|
||||
#undef INIT
|
||||
#undef INC
|
||||
#undef ISSTATEIN
|
||||
#undef FWD
|
||||
#undef BACK
|
||||
#undef ISSETBACK
|
||||
#undef SNAMES
|
||||
|
||||
/* macros for manipulating states, large version */
|
||||
#define states char *
|
||||
#define CLEAR(v) memset(v, 0, m->g->nstates)
|
||||
#define SET0(v, n) ((v)[n] = 0)
|
||||
#define SET1(v, n) ((v)[n] = 1)
|
||||
#define ISSET(v, n) ((v)[n])
|
||||
#define ASSIGN(d, s) memcpy(d, s, m->g->nstates)
|
||||
#define EQ(a, b) (memcmp(a, b, m->g->nstates) == 0)
|
||||
#define STATEVARS int vn; char *space
|
||||
#define STATESETUP(m, nv) { (m)->space = malloc((nv)*(m)->g->nstates); \
|
||||
if ((m)->space == NULL) return(REG_ESPACE); \
|
||||
(m)->vn = 0; }
|
||||
#define STATETEARDOWN(m) { free((m)->space); }
|
||||
#define SETUP(v) ((v) = &m->space[m->vn++ * m->g->nstates])
|
||||
#define onestate int
|
||||
#define INIT(o, n) ((o) = (n))
|
||||
#define INC(o) ((o)++)
|
||||
#define ISSTATEIN(v, o) ((v)[o])
|
||||
/* some abbreviations; note that some of these know variable names! */
|
||||
/* do "if I'm here, I can also be there" etc without branches */
|
||||
#define FWD(dst, src, n) ((dst)[here+(n)] |= (src)[here])
|
||||
#define BACK(dst, src, n) ((dst)[here-(n)] |= (src)[here])
|
||||
#define ISSETBACK(v, n) ((v)[here - (n)])
|
||||
/* function names */
|
||||
#define LNAMES /* flag */
|
||||
|
||||
#include "engine.c"
|
||||
|
||||
/*
|
||||
- regexec - interface for matching
|
||||
= extern int regexec(const regex_t *, const char *, size_t, \
|
||||
= regmatch_t [], int);
|
||||
= #define REG_NOTBOL 00001
|
||||
= #define REG_NOTEOL 00002
|
||||
= #define REG_STARTEND 00004
|
||||
= #define REG_TRACE 00400 // tracing of execution
|
||||
= #define REG_LARGE 01000 // force large representation
|
||||
= #define REG_BACKR 02000 // force use of backref code
|
||||
*
|
||||
* We put this here so we can exploit knowledge of the state representation
|
||||
* when choosing which matcher to call. Also, by this point the matchers
|
||||
* have been prototyped.
|
||||
*/
|
||||
EAPI int /* 0 success, REG_NOMATCH failure */
|
||||
regexec(preg, string, nmatch, pmatch, eflags)
|
||||
const regex_t *preg;
|
||||
const char *string;
|
||||
size_t nmatch;
|
||||
regmatch_t pmatch[];
|
||||
int eflags;
|
||||
{
|
||||
register struct re_guts *g = preg->re_g;
|
||||
#ifdef REDEBUG
|
||||
# define GOODFLAGS(f) (f)
|
||||
#else
|
||||
# define GOODFLAGS(f) ((f)&(REG_NOTBOL|REG_NOTEOL|REG_STARTEND))
|
||||
#endif
|
||||
|
||||
if (preg->re_magic != MAGIC1 || g->magic != MAGIC2)
|
||||
return(REG_BADPAT);
|
||||
assert(!(g->iflags&BAD));
|
||||
if (g->iflags&BAD) /* backstop for no-debug case */
|
||||
return(REG_BADPAT);
|
||||
eflags = GOODFLAGS(eflags);
|
||||
|
||||
if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags®_LARGE))
|
||||
return(smatcher(g, (char *)string, nmatch, pmatch, eflags));
|
||||
else
|
||||
return(lmatcher(g, (char *)string, nmatch, pmatch, eflags));
|
||||
}
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
#include <sys/types.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <regex.h>
|
||||
|
||||
#include "utils.h"
|
||||
#include "regex2.h"
|
||||
|
||||
/*
|
||||
- regfree - free everything
|
||||
= extern void regfree(regex_t *);
|
||||
*/
|
||||
EAPI void
|
||||
regfree(preg)
|
||||
regex_t *preg;
|
||||
{
|
||||
register struct re_guts *g;
|
||||
|
||||
if (preg->re_magic != MAGIC1) /* oops */
|
||||
return; /* nice to complain, but hard */
|
||||
|
||||
g = preg->re_g;
|
||||
if (g == NULL || g->magic != MAGIC2) /* oops again */
|
||||
return;
|
||||
preg->re_magic = 0; /* mark it invalid */
|
||||
g->magic = 0; /* mark it invalid */
|
||||
|
||||
if (g->strip != NULL)
|
||||
free((char *)g->strip);
|
||||
if (g->sets != NULL)
|
||||
free((char *)g->sets);
|
||||
if (g->setbits != NULL)
|
||||
free((char *)g->setbits);
|
||||
if (g->must != NULL)
|
||||
free(g->must);
|
||||
free((char *)g);
|
||||
}
|
||||
|
|
@ -1,22 +0,0 @@
|
|||
/* utility definitions */
|
||||
#ifdef _POSIX2_RE_DUP_MAX
|
||||
#define DUPMAX _POSIX2_RE_DUP_MAX
|
||||
#else
|
||||
#define DUPMAX 255
|
||||
#endif
|
||||
#define INFINITY (DUPMAX + 1)
|
||||
#define NC (CHAR_MAX - CHAR_MIN + 1)
|
||||
typedef unsigned char uch;
|
||||
|
||||
/* switch off assertions (if not already off) if no REDEBUG */
|
||||
#ifndef REDEBUG
|
||||
#ifndef NDEBUG
|
||||
#define NDEBUG /* no assertions please */
|
||||
#endif
|
||||
#endif
|
||||
#include <assert.h>
|
||||
|
||||
/* for old systems with bcopy() but no memmove() */
|
||||
#ifdef USEBCOPY
|
||||
#define memmove(d, s, c) bcopy(s, d, c)
|
||||
#endif
|
||||
|
|
@ -30,7 +30,6 @@
|
|||
static const Efl_Test_Case etc[] = {
|
||||
{ "Dlfcn", evil_test_dlfcn },
|
||||
/* { "Fcntl", evil_test_fcntl }, */
|
||||
/* { "Fnmatch", evil_test_fnmatch }, */
|
||||
/* { "Langinfo", evil_test_langinfo }, */
|
||||
{ "Libgen", evil_test_libgen },
|
||||
{ "Main", evil_test_main },
|
||||
|
|
|
|||
|
|
@ -23,7 +23,6 @@
|
|||
#include "../efl_check.h"
|
||||
void evil_test_dlfcn(TCase *tc);
|
||||
/* void evil_test_fcntl(TCase *tc); */
|
||||
/* void evil_test_fnmatch(TCase *tc); */
|
||||
/* void evil_test_langinfo(TCase *tc); */
|
||||
void evil_test_libgen(TCase *tc);
|
||||
void evil_test_main(TCase *tc);
|
||||
|
|
|
|||
Loading…
Reference in New Issue