kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Windows: remove fnmatch and regex in Evil and use the ones in regex DLL installed by ewpi

Browse Source 
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
devs/felipealmeida/eo_ownership_optimization_test
Vincent Torri 4 years ago committed by Mike Blumenkrantz
parent e65c49b422
commit ecce595b24
24 changed files with 37 additions and 3829 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 14
      configure.ac
  2. 19
      header_checks/meson.build
  3. 32
      src/Makefile_Evil.am
  4. 231
      src/lib/evil/evil_fnmatch.c
  5. 77
      src/lib/evil/evil_fnmatch_list_of_states.c
  6. 24
      src/lib/evil/evil_fnmatch_private.h
  7. 57
      src/lib/evil/fnmatch.h
  8. 15
      src/lib/evil/meson.build
  9. 31
      src/lib/evil/regex/cclass.h
  10. 102
      src/lib/evil/regex/cname.h
  11. 1019
      src/lib/evil/regex/engine.c
  12. 35
      src/lib/evil/regex/engine.ih
  13. 10
      src/lib/evil/regex/meson.build
  14. 1604
      src/lib/evil/regex/regcomp.c
  15. 51
      src/lib/evil/regex/regcomp.ih
  16. 122
      src/lib/evil/regex/regerror.c
  17. 12
      src/lib/evil/regex/regerror.ih
  18. 78
      src/lib/evil/regex/regex.h
  19. 134
      src/lib/evil/regex/regex2.h
  20. 138
      src/lib/evil/regex/regexec.c
  21. 37
      src/lib/evil/regex/regfree.c
  22. 22
      src/lib/evil/regex/utils.h
  23. 1
      src/tests/evil/evil_suite.c
  24. 1
      src/tests/evil/evil_suite.h

14
configure.ac
Unescape View File

@ -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])

19
header_checks/meson.build
Unescape View File

@ -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

32
src/Makefile_Evil.am
Unescape View File

@ -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

231
src/lib/evil/evil_fnmatch.c
Unescape View File

@ -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;
}

77
src/lib/evil/evil_fnmatch_list_of_states.c
Unescape View File

@ -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));
}

24
src/lib/evil/evil_fnmatch_private.h
Unescape View File

@ -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__ */

57
src/lib/evil/fnmatch.h
Unescape View File

@ -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__ */

15
src/lib/evil/meson.build
Unescape View File

@ -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

31
src/lib/evil/regex/cclass.h
Unescape View File

@ -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, ""
};

102
src/lib/evil/regex/cname.h
Unescape View File

@ -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,
};

1019
src/lib/evil/regex/engine.c
View File

File diff suppressed because it is too large Load Diff

35
src/lib/evil/regex/engine.ih
Unescape View File

@ -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 ========= */

10
src/lib/evil/regex/meson.build
Unescape View File

@ -1,10 +0,0 @@
evil_src += files([
'regcomp.c',
'regerror.c',
'regexec.c',
'regfree.c',
'cclass.h',
'cname.h',
'regex2.h',
'utils.h'
])

1604
src/lib/evil/regex/regcomp.c
View File

File diff suppressed because it is too large Load Diff

51
src/lib/evil/regex/regcomp.ih
Unescape View File

@ -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 ========= */

122
src/lib/evil/regex/regerror.c
Unescape View File

@ -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&REG_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);
}

12
src/lib/evil/regex/regerror.ih
Unescape View File

@ -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 ========= */

78
src/lib/evil/regex/regex.h
Unescape View File

@ -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

134
src/lib/evil/regex/regex2.h
Unescape View File

@ -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) == '_')

138
src/lib/evil/regex/regexec.c
Unescape View File

@ -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&REG_LARGE))
return(smatcher(g, (char *)string, nmatch, pmatch, eflags));
else
return(lmatcher(g, (char *)string, nmatch, pmatch, eflags));
}

37
src/lib/evil/regex/regfree.c
Unescape View File

@ -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);
}

22
src/lib/evil/regex/utils.h
Unescape View File

@ -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

1
src/tests/evil/evil_suite.c
Unescape View File

@ -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 },