diff options
Diffstat (limited to 'roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample')
17 files changed, 1849 insertions, 0 deletions
diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/CMakeLists.txt b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/CMakeLists.txt new file mode 100644 index 000000000..c0bd05728 --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/CMakeLists.txt @@ -0,0 +1,35 @@ +cmake_minimum_required(VERSION 2.8) +project(oniguruma_sample C) + +add_executable(crnl crnl.c) +target_link_libraries(crnl onig) + +add_executable(callout callout.c) +target_link_libraries(callout onig) + +add_executable(echo echo.c) +target_link_libraries(echo onig) + +add_executable(count count.c) +target_link_libraries(count onig) + +add_executable(encode encode.c) +target_link_libraries(encode onig) + +add_executable(listcap listcap.c) +target_link_libraries(listcap onig) + +add_executable(names names.c) +target_link_libraries(names onig) + +add_executable(posix posix.c) +target_link_libraries(posix onig) + +add_executable(simple simple.c) +target_link_libraries(simple onig) + +add_executable(sql sql.c) +target_link_libraries(sql onig) + +add_executable(syntax syntax.c) +target_link_libraries(syntax onig) diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/Makefile.am b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/Makefile.am new file mode 100644 index 000000000..2bf469711 --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/Makefile.am @@ -0,0 +1,49 @@ +#noinst_PROGRAMS = encode listcap names posix simple sql syntax crnl + +lib_onig = ../src/libonig.la +LDADD = $(lib_onig) + +AM_CFLAGS = -Wall +AM_LDFLAGS = -L$(prefix)/lib +AM_CPPFLAGS = -I$(top_srcdir)/src + +if ENABLE_POSIX_API +TESTS = encode listcap names posix simple sql syntax user_property callout echo count bug_fix regset +else +TESTS = encode listcap names simple sql syntax user_property callout echo count bug_fix regset +endif + +check_PROGRAMS = $(TESTS) + +encode_SOURCES = encode.c +listcap_SOURCES = listcap.c +names_SOURCES = names.c +posix_SOURCES = posix.c +simple_SOURCES = simple.c +sql_SOURCES = sql.c +syntax_SOURCES = syntax.c +user_property_SOURCES = user_property.c +callout_SOURCES = callout.c +echo_SOURCES = echo.c +count_SOURCES = count.c +bug_fix = bug_fix.c +regset_SOURCES = regset.c + +sampledir = . + +test: $(TESTS) + $(sampledir)/encode + $(sampledir)/listcap + $(sampledir)/names +if ENABLE_POSIX_API + $(sampledir)/posix +endif + $(sampledir)/simple + $(sampledir)/sql + $(sampledir)/syntax + $(sampledir)/user_property + $(sampledir)/callout + $(sampledir)/echo + $(sampledir)/count + $(sampledir)/bug_fix + $(sampledir)/regset diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/bug_fix.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/bug_fix.c new file mode 100644 index 000000000..f295bfde8 --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/bug_fix.c @@ -0,0 +1,93 @@ +/* + * bug_fix.c + */ +#include <stdio.h> +#include "oniguruma.h" + +static int +search(regex_t* reg, unsigned char* str, unsigned char* end) +{ + int r; + unsigned char *start, *range; + OnigRegion *region; + + region = onig_region_new(); + + start = str; + range = end; + r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE); + if (r >= 0) { + int i; + + fprintf(stderr, "match at %d (%s)\n", r, + ONIGENC_NAME(onig_get_encoding(reg))); + for (i = 0; i < region->num_regs; i++) { + fprintf(stderr, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]); + } + } + else if (r == ONIG_MISMATCH) { + fprintf(stderr, "search fail (%s)\n", + ONIGENC_NAME(onig_get_encoding(reg))); + } + else { /* error */ + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r); + fprintf(stderr, "ERROR: %s\n", s); + fprintf(stderr, " (%s)\n", ONIGENC_NAME(onig_get_encoding(reg))); + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + return -1; + } + + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + return 0; +} + +static int +exec(OnigEncoding enc, OnigOptionType options, char* apattern, char* astr) +{ + int r; + unsigned char *end; + regex_t* reg; + OnigErrorInfo einfo; + UChar* pattern = (UChar* )apattern; + UChar* str = (UChar* )astr; + + r = onig_new(®, pattern, + pattern + onigenc_str_bytelen_null(enc, pattern), + options, enc, ONIG_SYNTAX_DEFAULT, &einfo); + if (r != ONIG_NORMAL) { + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r, &einfo); + fprintf(stderr, "ERROR: %s\n", s); + return -1; + } + + end = str + onigenc_str_bytelen_null(enc, str); + r = search(reg, str, end); + + onig_free(reg); + return 0; +} + + + +extern int main(int argc, char* argv[]) +{ + OnigEncoding use_encs[1]; + + use_encs[0] = ONIG_ENCODING_UTF8; + onig_initialize(use_encs, 1); + + /* fix ignore case in look-behind + commit: 3340ec2cc5627172665303fe248c9793354d2251 */ + exec(ONIG_ENCODING_UTF8, ONIG_OPTION_IGNORECASE, + "\305\211a", "\312\274na"); /* \u{0149}a \u{02bc}na */ + + exec(ONIG_ENCODING_UTF8, ONIG_OPTION_NONE, "(\\2)(\\1)", "aa"); /* fail. */ + + exec(ONIG_ENCODING_UTF8, ONIG_OPTION_FIND_LONGEST, + "a*", "aa aaa aaaa aaaaa "); /* match 12-17 */ + + onig_end(); + return 0; +} diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/callout.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/callout.c new file mode 100644 index 000000000..b5e3d91ba --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/callout.c @@ -0,0 +1,268 @@ +/* + * callout.c + */ +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include "oniguruma.h" + +static int +callout_body(OnigCalloutArgs* args, void* user_data) +{ + int r; + int i; + int n; + int begin, end; + int used_num; + int used_bytes; + OnigCalloutIn in; + int name_id; + const UChar* contents; + const UChar* start; + const UChar* current; + regex_t* regex; + + in = onig_get_callout_in_by_callout_args(args); + name_id = onig_get_name_id_by_callout_args(args); + start = onig_get_start_by_callout_args(args); + current = onig_get_current_by_callout_args(args); + regex = onig_get_regex_by_callout_args(args); + + contents = onig_get_contents_by_callout_args(args); + + if (name_id != ONIG_NON_NAME_ID) { + UChar* name = onig_get_callout_name_by_name_id(name_id); + fprintf(stdout, "name: %s\n", name); + } + fprintf(stdout, + "%s %s: contents: \"%s\", start: \"%s\", current: \"%s\"\n", + contents != 0 ? "CONTENTS" : "NAME", + in == ONIG_CALLOUT_IN_PROGRESS ? "PROGRESS" : "RETRACTION", + contents, start, current); + + fprintf(stdout, "user_data: %s\n", (char* )user_data); + + (void )onig_get_used_stack_size_in_callout(args, &used_num, &used_bytes); + fprintf(stdout, "stack: used_num: %d, used_bytes: %d\n", used_num, used_bytes); + + n = onig_number_of_captures(regex); + for (i = 1; i <= n; i++) { + r = onig_get_capture_range_in_callout(args, i, &begin, &end); + if (r != ONIG_NORMAL) return r; + + fprintf(stdout, "capture %d: (%d-%d)\n", i, begin, end); + } + + fflush(stdout); + return ONIG_CALLOUT_SUCCESS; +} + +static int +progress_callout_func(OnigCalloutArgs* args, void* user_data) +{ + return callout_body(args, user_data); +} + +static int +retraction_callout_func(OnigCalloutArgs* args, void* user_data) +{ + return callout_body(args, user_data); +} + +static int +foo(OnigCalloutArgs* args, void* user_data) +{ + return callout_body(args, user_data); +} + +static int +bar(OnigCalloutArgs* args, void* user_data) +{ + int r; + int i; + int n; + OnigType type; + OnigValue val; + + fprintf(stdout, "bar called.\n"); + + n = onig_get_args_num_by_callout_args(args); + if (n < 0) { + fprintf(stderr, "FAIL: onig_get_args_num_by_callout_args(): %d\n", n); + return n; + } + + for (i = 0; i < n; i++) { + r = onig_get_arg_by_callout_args(args, i, &type, &val); + if (r != 0) { + fprintf(stderr, "FAIL: onig_get_arg_by_callout_args(): %d\n", r); + return r; + } + + fprintf(stdout, "arg[%d]: ", i); + switch (type) { + case ONIG_TYPE_LONG: + fprintf(stdout, "%ld\n", val.l); + break; + case ONIG_TYPE_CHAR: + fprintf(stdout, "0x%06x\n", val.c); + break; + case ONIG_TYPE_STRING: + fprintf(stdout, "'%s'\n", val.s.start); + break; + default: + /* Never come here. But escape warning. */ + break; + }; + } + + return ONIG_CALLOUT_SUCCESS; +} + +static int +test(OnigEncoding enc, OnigMatchParam* mp, char* in_pattern, char* in_str) +{ + int r; + unsigned char *start, *range, *end; + regex_t* reg; + OnigErrorInfo einfo; + OnigRegion *region; + UChar* pattern; + UChar* str; + + pattern = (UChar* )in_pattern; + str = (UChar* )in_str; + + r = onig_new(®, pattern, pattern + strlen((char* )pattern), + ONIG_OPTION_DEFAULT, enc, ONIG_SYNTAX_DEFAULT, &einfo); + if (r != ONIG_NORMAL) { + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r, &einfo); + fprintf(stderr, "COMPILE ERROR: %d: %s\n", r, s); + return -1; + } + + region = onig_region_new(); + + end = str + strlen((char* )str); + start = str; + range = end; + r = onig_search_with_param(reg, str, end, start, range, region, + ONIG_OPTION_NONE, mp); + if (r >= 0) { + int i; + + fprintf(stderr, "match at %d\n", r); + for (i = 0; i < region->num_regs; i++) { + fprintf(stderr, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]); + } + } + else if (r == ONIG_MISMATCH) { + fprintf(stderr, "search fail\n"); + } + else { /* error */ + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r); + fprintf(stderr, "SEARCH ERROR: %d: %s\n", r, s); + } + + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + return r; +} + +extern int main(int argc, char* argv[]) +{ + int r; + int id; + void* user_data; + UChar* name; + OnigEncoding use_encs[1]; + unsigned int arg_types[4]; + OnigValue opt_defaults[4]; + OnigEncoding enc; + OnigMatchParam* mp; + + enc = ONIG_ENCODING_UTF8; + use_encs[0] = enc; + + r = onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0])); + if (r != ONIG_NORMAL) return -1; + + /* monitor on */ + r = onig_setup_builtin_monitors_by_ascii_encoded_name(stdout); + if (r != ONIG_NORMAL) return -1; + + name = (UChar* )"foo"; + id = onig_set_callout_of_name(enc, ONIG_CALLOUT_TYPE_SINGLE, + name, name + strlen((char* )name), + ONIG_CALLOUT_IN_BOTH, foo, 0, 0, 0, 0, 0); + if (id < 0) { + fprintf(stderr, "ERROR: fail to set callout of name: %s\n", name); + //return -1; + } + + name = (UChar* )"bar"; + arg_types[0] = ONIG_TYPE_LONG; + arg_types[1] = ONIG_TYPE_STRING; + arg_types[2] = ONIG_TYPE_CHAR; + opt_defaults[0].s.start = (UChar* )"I am a option argument's default value."; + opt_defaults[0].s.end = opt_defaults[0].s.start + + strlen((char* )opt_defaults[0].s.start); + opt_defaults[1].c = 0x4422; + + id = onig_set_callout_of_name(enc, ONIG_CALLOUT_TYPE_SINGLE, + name, name + strlen((char* )name), + ONIG_CALLOUT_IN_PROGRESS, bar, 0, + 3, arg_types, 2, opt_defaults); + if (id < 0) { + fprintf(stderr, "ERROR: fail to set callout of name: %s\n", name); + //return -1; + } + + (void)onig_set_progress_callout(progress_callout_func); + (void)onig_set_retraction_callout(retraction_callout_func); + + mp = onig_new_match_param(); + + user_data = (void* )"something data"; + r = onig_set_callout_user_data_of_match_param(mp, user_data); + if (r != ONIG_NORMAL) { + fprintf(stderr, "ERROR: fail onig_set_callout_user_data_of_match_param(): %d\n", r); + } + + /* callout of contents */ + test(enc, mp, "a+(?{foo bar baz...}X)$", "aaab"); + test(enc, mp, "(?{{!{}#$%&'()=-~^|[_]`@*:+;<>?/.\\,}}[symbols])c", "abc"); + test(enc, mp, "\\A(...)(?{{{booooooooooooo{{ooo}}ooooooooooz}}}<)", "aaab"); + test(enc, mp, "\\A(?!a(?{in prec-read-not}[xxx]X)b)", "ac"); + test(enc, mp, "(?<!a(?{in look-behind-not}X)c)c", "abc"); + + // callout of name + test(enc, mp, "\\A(*foo)abc", "abc"); + test(enc, mp, "abc(?:(*FAIL)|$)", "abcabc"); + test(enc, mp, "abc(?:$|(*MISMATCH)|abc$)", "abcabc"); + test(enc, mp, "abc(?:(*ERROR)|$)", "abcabc"); + test(enc, mp, "ab(*foo{})(*FAIL)", "abc"); + test(enc, mp, "abc(d|(*ERROR{-999}))", "abc"); + test(enc, mp, "ab(*bar{372,I am a bar's argument,あ})c(*FAIL)", "abc"); + test(enc, mp, "ab(*bar{1234567890})", "abc"); + test(enc, mp, "(?:a(*MAX{2})|b)*", "abbabbabbabb"); + test(enc, mp, "(?:(*MAX{2})a|b)*", "abbabbabbabb"); + test(enc, mp, "(?:(*MAX{1})a|b)*", "bbbbbabbbbbabbbbb"); + test(enc, mp, "(?:(*MAX{3})a|(*MAX{4})b)*", "bbbaabbab"); + test(enc, mp, "(?:(*MAX[A]{3})a|(*MAX[B]{5})b)*(*CMP{A,<,B})", "abababc"); + test(enc, mp, "(?:(*MAX[A]{7})a|(*MAX[B]{5})b)*(*CMP{A,>=,4})", "abababcabababaa"); + test(enc, mp, "(?:(*MAX[T]{3})a)*(?:(*MAX{T})c)*", "aaccc"); + + /* callouts in condition */ + test(enc, mp, "\\A(?(?{in condition})then|else)\\z", "then"); + test(enc, mp, "\\A(?(*FAIL)then|else)\\z", "else"); + + /* monitor test */ + test(enc, mp, "(?:(*MON{X})(*FAIL)|.{,3}(*MON[FOO])k)", "abcdefghijk"); + + onig_free_match_param(mp); + onig_end(); + return 0; +} diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/count.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/count.c new file mode 100644 index 000000000..2b67db746 --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/count.c @@ -0,0 +1,125 @@ +/* + * count.c + */ +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include "oniguruma.h" + +#define ulen(enc, p) onigenc_str_bytelen_null(enc, (UChar* )p) + +static int +test(OnigEncoding enc, OnigMatchParam* mp, char* in_pattern, char* in_str) +{ + int r; + unsigned char *start, *range, *end; + regex_t* reg; + OnigErrorInfo einfo; + OnigRegion *region; + UChar* pattern; + UChar* str; + + pattern = (UChar* )in_pattern; + str = (UChar* )in_str; + + r = onig_new(®, pattern, pattern + ulen(enc, pattern), + ONIG_OPTION_DEFAULT, enc, ONIG_SYNTAX_DEFAULT, &einfo); + if (r != ONIG_NORMAL) { + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r, &einfo); + fprintf(stderr, "COMPILE ERROR: %d: %s\n", r, s); + return -1; + } + + region = onig_region_new(); + + end = str + ulen(enc, str); + start = str; + range = end; + r = onig_search_with_param(reg, str, end, start, range, region, + ONIG_OPTION_NONE, mp); + if (r >= 0) { + int slot; + OnigValue val; + char* tag; + int tag_len; + + fprintf(stdout, "match at %d\n", r); + + show_count: + if (enc == ONIG_ENCODING_UTF16_BE) { + tag = "\000x\000\000"; + } + else if (enc == ONIG_ENCODING_UTF16_LE) { + tag = "x\000\000\000"; + } + else { + tag = "x"; + } + tag_len = ulen(enc, tag); + + slot = 0; + r = onig_get_callout_data_by_tag(reg, mp, (UChar* )tag, (UChar* )tag + tag_len, + slot, 0, &val); + if (r < ONIG_NORMAL) goto err; + else if (r > ONIG_NORMAL) { + fprintf(stdout, "COUNT[x]: NO DATA\n"); + } + else { + fprintf(stdout, "COUNT[x]: %ld\n", val.l); + } + } + else if (r == ONIG_MISMATCH) { + fprintf(stdout, "search fail\n"); + goto show_count; + } + else { /* error */ + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + err: + onig_error_code_to_str((UChar* )s, r); + fprintf(stdout, "SEARCH ERROR: %d: %s\n", r, s); + } + + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + return r; +} + +extern int main(int argc, char* argv[]) +{ + int r; + OnigMatchParam* mp; + OnigEncoding encs[3]; + + encs[0] = ONIG_ENCODING_UTF8; + encs[1] = ONIG_ENCODING_UTF16_BE; + encs[2] = ONIG_ENCODING_UTF16_LE; + + r = onig_initialize(encs, sizeof(encs)/sizeof(encs[0])); + if (r != ONIG_NORMAL) { + fprintf(stderr, "FAIL: onig_initialize(): %d\n", r); + return -1; + } + + mp = onig_new_match_param(); + + test(encs[0], mp, "abc(.(*COUNT[x]))*(*FAIL)", "abcdefg"); + test(encs[0], mp, "abc(.(*COUNT[_any_]))*(.(*COUNT[x]))*d", "abcdefg"); + /* fail count */ + test(encs[0], mp, "abc(.(*COUNT[x]{<}))*f", "abcdefg"); + /* success count */ + test(encs[0], mp, "abc(.(*COUNT[x]{X}))*f", "abcdefg"); + /* passed count */ + test(encs[0], mp, "abc(.(*COUNT[x]))*f", "abcdefg"); + test(encs[0], mp, "a(.(*COUNT[x]))*z", "abcd\nabcdz"); + /* total count */ + test(encs[0], mp, "a(.(*TOTAL_COUNT[x]))*z", "abcd\nabcdz"); + + test(encs[1], mp, "\000a\000b\000c\000(\000.\000(\000*\000C\000O\000U\000N\000T\000[\000x\000]\000)\000)\000*\000(\000*\000F\000A\000I\000L\000)\000\000", "\000a\000b\000c\000d\000e\000f\000g\000\000"); + + test(encs[2], mp, "a\000b\000c\000(\000.\000(\000*\000C\000O\000U\000N\000T\000[\000x\000]\000)\000)\000*\000(\000*\000F\000A\000I\000L\000)\000\000\000", "a\000b\000c\000d\000e\000f\000g\000\000\000"); + + onig_free_match_param(mp); + onig_end(); + return 0; +} diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/crnl.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/crnl.c new file mode 100644 index 000000000..bfa563eb7 --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/crnl.c @@ -0,0 +1,129 @@ +/* + * crnl.c 2007/05/30 K.Kosako + * + * !!! You should enable USE_CRNL_AS_LINE_TERMINATOR. !!! + * + * USE_CRNL_AS_LINE_TERMINATOR config test program. + */ +#include <stdio.h> +#include <string.h> +#include "oniguruma.h" + +static int nfail = 0; + +static void result(int no, int from, int to, + int expected_from, int expected_to) +{ + fprintf(stderr, "%3d: ", no); + if (from == expected_from && to == expected_to) { + fprintf(stderr, "Success\n"); + } + else { + fprintf(stderr, "Fail: expected: (%d-%d), result: (%d-%d)\n", + expected_from, expected_to, from, to); + + nfail++; + } +} + +static int +x(int no, char* pattern_arg, char* str_arg, + int expected_from, int expected_to) +{ + int r; + unsigned char *start, *range, *end; + regex_t* reg; + OnigErrorInfo einfo; + OnigRegion *region; + UChar *pattern, *str; + + pattern = (UChar* )pattern_arg; + str = (UChar* )str_arg; + + r = onig_new(®, pattern, pattern + strlen((char* )pattern), + ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, ONIG_SYNTAX_DEFAULT, &einfo); + if (r != ONIG_NORMAL) { + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str(s, r, &einfo); + fprintf(stderr, "ERROR: %s\n", s); + return -1; + } + + region = onig_region_new(); + + end = str + strlen((char* )str); + start = str; + range = end; + r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE); + if (r >= 0 || r == ONIG_MISMATCH) { + result(no, region->beg[0], region->end[0], expected_from, expected_to); + } + else if (r == ONIG_MISMATCH) { + result(no, r, -1, expected_from, expected_to); + } + else { /* error */ + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str(s, r); + fprintf(stderr, "ERROR: %s\n", s); + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + return -1; + } + + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + return 0; +} + +static int +f(int no, char* pattern_arg, char* str_arg) +{ + return x(no, pattern_arg, str_arg, -1, -1); +} + +extern int main(int argc, char* argv[]) +{ + x( 1, "", "\r\n", 0, 0); + x( 2, ".", "\r\n", 0, 1); + f( 3, "..", "\r\n"); + x( 4, "^", "\r\n", 0, 0); + x( 5, "\\n^", "\r\nf", 1, 2); + x( 6, "\\n^a", "\r\na", 1, 3); + x( 7, "$", "\r\n", 0, 0); + x( 8, "T$", "T\r\n", 0, 1); + x( 9, "T$", "T\raT\r\n", 3, 4); + x(10, "\\z", "\r\n", 2, 2); + f(11, "a\\z", "a\r\n"); + x(12, "\\Z", "\r\n", 0, 0); + x(13, "\\Z", "\r\na", 3, 3); + x(14, "\\Z", "\r\n\r\n\n", 4, 4); + x(15, "\\Z", "\r\n\r\nX", 5, 5); + x(16, "a\\Z", "a\r\n", 0, 1); + x(17, "aaaaaaaaaaaaaaa\\Z", "aaaaaaaaaaaaaaa\r\n", 0, 15); + x(18, "a|$", "b\r\n", 1, 1); + x(19, "$|b", "\rb", 1, 2); + x(20, "a$|ab$", "\r\nab\r\n", 2, 4); + + x(21, "a|\\Z", "b\r\n", 1, 1); + x(22, "\\Z|b", "\rb", 1, 2); + x(23, "a\\Z|ab\\Z", "\r\nab\r\n", 2, 4); + x(24, "(?=a$).", "a\r\n", 0, 1); + f(25, "(?=a$).", "a\r"); + x(26, "(?!a$)..", "a\r", 0, 2); + x(27, "(?<=a$).\\n", "a\r\n", 1, 3); + f(28, "(?<!a$).\\n", "a\r\n"); + x(29, "(?=a\\Z).", "a\r\n", 0, 1); + f(30, "(?=a\\Z).", "a\r"); + x(31, "(?!a\\Z)..", "a\r", 0, 2); + + onig_end(); + + if (nfail > 0) { + fprintf(stderr, "\n"); + fprintf(stderr, "!!! You have to enable USE_CRNL_AS_LINE_TERMINATOR\n"); + fprintf(stderr, "!!! in regenc.h for this test program.\n"); + fprintf(stderr, "\n"); + } + + return 0; +} diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/echo.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/echo.c new file mode 100644 index 000000000..76df20770 --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/echo.c @@ -0,0 +1,136 @@ +/* + * echo.c + */ +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include "oniguruma.h" + +static int +echo(OnigCalloutArgs* args, void* user_data) +{ + int r; + OnigCalloutIn in; + OnigType type; + OnigValue val; + FILE* fp; + + fp = stdout; + + in = onig_get_callout_in_by_callout_args(args); + + r = onig_get_arg_by_callout_args(args, 1, &type, &val); + if (r != ONIG_NORMAL) return r; + + if (in == ONIG_CALLOUT_IN_PROGRESS) { + if (val.c == '<') + return ONIG_CALLOUT_SUCCESS; + } + else { + if (val.c != 'X' && val.c != '<') + return ONIG_CALLOUT_SUCCESS; + } + + r = onig_get_arg_by_callout_args(args, 0, &type, &val); + if (r != ONIG_NORMAL) return r; + + + fprintf(fp, "%s %s\n", + (in == ONIG_CALLOUT_IN_PROGRESS ? "=>" : "<="), + val.s.start); + fflush(fp); + + return ONIG_CALLOUT_SUCCESS; +} + + +static int +test(OnigEncoding enc, char* in_pattern, char* in_str) +{ + int r; + unsigned char *start, *range, *end; + regex_t* reg; + OnigErrorInfo einfo; + OnigRegion *region; + UChar* pattern; + UChar* str; + + pattern = (UChar* )in_pattern; + str = (UChar* )in_str; + + r = onig_new(®, pattern, pattern + strlen((char* )pattern), + ONIG_OPTION_DEFAULT, enc, ONIG_SYNTAX_DEFAULT, &einfo); + if (r != ONIG_NORMAL) { + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r, &einfo); + fprintf(stderr, "COMPILE ERROR: %d: %s\n", r, s); + return -1; + } + + region = onig_region_new(); + + end = str + strlen((char* )str); + start = str; + range = end; + r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE); + if (r >= 0) { + int i; + + fprintf(stderr, "match at %d\n", r); + for (i = 0; i < region->num_regs; i++) { + fprintf(stderr, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]); + } + } + else if (r == ONIG_MISMATCH) { + fprintf(stderr, "search fail\n"); + } + else { /* error */ + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r); + fprintf(stderr, "SEARCH ERROR: %d: %s\n", r, s); + } + + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + return r; +} + +extern int main(int argc, char* argv[]) +{ + int r; + int id; + UChar* name; + OnigEncoding use_encs[1]; + OnigType arg_types[4]; + OnigValue opt_defaults[4]; + OnigEncoding enc; + + enc = ONIG_ENCODING_UTF8; + use_encs[0] = enc; + + r = onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0])); + if (r != ONIG_NORMAL) return -1; + + name = (UChar* )"echo"; + arg_types[0] = ONIG_TYPE_STRING; + arg_types[1] = ONIG_TYPE_CHAR; + opt_defaults[0].s.start = (UChar* )"echo"; + opt_defaults[0].s.end = opt_defaults[0].s.start + + strlen((char* )opt_defaults[0].s.start); + opt_defaults[1].c = '>'; + + id = onig_set_callout_of_name(enc, ONIG_CALLOUT_TYPE_SINGLE, + name, name + strlen((char* )name), + ONIG_CALLOUT_IN_BOTH, echo, 0, + 2, arg_types, 2, opt_defaults); + if (id < 0) { + fprintf(stderr, "ERROR: fail to set callout of name: %s\n", name); + return -1; + } + + test(enc, "(?:(*echo{abc!!!})a|b)*", "abba"); + test(enc, "(?:(*echo{xyz,X})a|b)*", "abba"); + + onig_end(); + return 0; +} diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/encode.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/encode.c new file mode 100644 index 000000000..c5d4771b3 --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/encode.c @@ -0,0 +1,212 @@ +/* + * encode.c + */ +#include <stdio.h> +#include "oniguruma.h" + +static int +search(regex_t* reg, unsigned char* str, unsigned char* end) +{ + int r; + unsigned char *start, *range; + OnigRegion *region; + + region = onig_region_new(); + + start = str; + range = end; + r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE); + if (r >= 0) { + int i; + + fprintf(stderr, "match at %d (%s)\n", r, + ONIGENC_NAME(onig_get_encoding(reg))); + for (i = 0; i < region->num_regs; i++) { + fprintf(stderr, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]); + } + } + else if (r == ONIG_MISMATCH) { + fprintf(stderr, "search fail (%s)\n", + ONIGENC_NAME(onig_get_encoding(reg))); + } + else { /* error */ + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r); + fprintf(stderr, "ERROR: %s\n", s); + fprintf(stderr, " (%s)\n", ONIGENC_NAME(onig_get_encoding(reg))); + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + return -1; + } + + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + return 0; +} + +static int +exec(OnigEncoding enc, OnigOptionType options, + char* apattern, char* astr) +{ + int r; + unsigned char *end; + regex_t* reg; + OnigErrorInfo einfo; + UChar* pattern = (UChar* )apattern; + UChar* str = (UChar* )astr; + + onig_initialize(&enc, 1); + + r = onig_new(®, pattern, + pattern + onigenc_str_bytelen_null(enc, pattern), + options, enc, ONIG_SYNTAX_DEFAULT, &einfo); + if (r != ONIG_NORMAL) { + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r, &einfo); + fprintf(stderr, "ERROR: %s\n", s); + return -1; + } + + end = str + onigenc_str_bytelen_null(enc, str); + r = search(reg, str, end); + + onig_free(reg); + onig_end(); + return 0; +} + +extern int main(int argc, char* argv[]) +{ + int r; + /* ISO 8859-1 test */ + static unsigned char str[] = { 0xc7, 0xd6, 0xfe, 0xea, 0xe0, 0xe2, 0x00 }; + static unsigned char pattern[] = { 0xe7, 0xf6, 0xde, '\\', 'w', '+', 0x00 }; + + r = exec(ONIG_ENCODING_SJIS, ONIG_OPTION_NONE, + "^a\\p{Hiragana}c$", "a\202\274c"); + + r = exec(ONIG_ENCODING_EUC_JP, ONIG_OPTION_NONE, + "^a\\p{Hiragana}c$", "a\244\276c"); + + r = exec(ONIG_ENCODING_CP1251, ONIG_OPTION_IGNORECASE, + "aBc", " AbC"); + + r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE, + " [a-c\337z] ", " SS "); + r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE, + " [\330-\341] ", " SS "); + + r = exec(ONIG_ENCODING_ISO_8859_2, ONIG_OPTION_IGNORECASE, + "\337 ", " Ss "); + r = exec(ONIG_ENCODING_ISO_8859_2, ONIG_OPTION_IGNORECASE, + "SS ", " \337 "); + r = exec(ONIG_ENCODING_ISO_8859_2, ONIG_OPTION_IGNORECASE, + "\\A\\S\\z", "ss"); + + r = exec(ONIG_ENCODING_ISO_8859_2, ONIG_OPTION_IGNORECASE, + "[ac]+", "bbbaAaCCC"); + + r = exec(ONIG_ENCODING_ISO_8859_3, ONIG_OPTION_IGNORECASE, + "[ac]+", "bbbaAaCCC"); + r = exec(ONIG_ENCODING_ISO_8859_4, ONIG_OPTION_IGNORECASE, + "[ac]+", "bbbaAaCCC"); + r = exec(ONIG_ENCODING_ISO_8859_5, ONIG_OPTION_IGNORECASE, + "[ac]+", "bbbaAaCCC"); + r = exec(ONIG_ENCODING_ISO_8859_6, ONIG_OPTION_IGNORECASE, + "[ac]+", "bbbaAaCCC"); + r = exec(ONIG_ENCODING_ISO_8859_7, ONIG_OPTION_IGNORECASE, + "[ac]+", "bbbaAaCCC"); + r = exec(ONIG_ENCODING_ISO_8859_8, ONIG_OPTION_IGNORECASE, + "[ac]+", "bbbaAaCCC"); + r = exec(ONIG_ENCODING_ISO_8859_9, ONIG_OPTION_IGNORECASE, + "[ac]+", "bbbaAaCCC"); + r = exec(ONIG_ENCODING_ISO_8859_10, ONIG_OPTION_IGNORECASE, + "[ac]+", "bbbaAaCCC"); + r = exec(ONIG_ENCODING_ISO_8859_11, ONIG_OPTION_IGNORECASE, + "[ac]+", "bbbaAaCCC"); + r = exec(ONIG_ENCODING_ISO_8859_13, ONIG_OPTION_IGNORECASE, + "[ac]+", "bbbaAaCCC"); + r = exec(ONIG_ENCODING_ISO_8859_14, ONIG_OPTION_IGNORECASE, + "[ac]+", "bbbaAaCCC"); + r = exec(ONIG_ENCODING_ISO_8859_15, ONIG_OPTION_IGNORECASE, + (char* )pattern, (char* )str); + r = exec(ONIG_ENCODING_ISO_8859_16, ONIG_OPTION_IGNORECASE, + (char* )pattern, (char* )str); + + r = exec(ONIG_ENCODING_KOI8_R, ONIG_OPTION_NONE, "a+", "bbbaaaccc"); + r = exec(ONIG_ENCODING_EUC_TW, ONIG_OPTION_NONE, "b*a+?c+", "bbbaaaccc"); + r = exec(ONIG_ENCODING_EUC_KR, ONIG_OPTION_NONE, "a+", "bbbaaaccc"); + r = exec(ONIG_ENCODING_EUC_CN, ONIG_OPTION_NONE, "c+", "bbbaaaccc"); + r = exec(ONIG_ENCODING_BIG5, ONIG_OPTION_NONE, "a+", "bbbaaaccc"); + + r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE, + "\337", "SS"); + r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE, + "SS", "\337"); + r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE, + "SSb\337ssc", "a\337bSS\337cd"); + r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE, + "[a\337]{0,2}", "aSS"); + r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE, + "is", "iss"); + + r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_NONE, + "\000[\000[\000:\000a\000l\000n\000u\000m\000:\000]\000]\000+\000\000", + "\000#\002\120\000a\000Z\012\077\012\076\012\075\000\000"); + /* 0x0a3d == \012\075 : is not alnum */ + /* 0x0a3e == \012\076 : is alnum */ + + r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_NONE, + "\000\\\000d\000+\000\000", + "\0003\0001\377\020\377\031\377\032\000\000"); + + r = exec(ONIG_ENCODING_GB18030, ONIG_OPTION_IGNORECASE, + "(Aa\\d)+", "BaA5Aa0234"); + + r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE, + "\000[\000\337\000]\000\000", "\000S\000S\000\000"); + + r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE, + "\000[\000\337\000]\000\000", "\000s\000S\000\000"); + + r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE, + "\000^\000[\000\001\000-\377\375\000]\000$\000\000", + "\000s\000S\000\000"); + + r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE, + "\000S\000S\000\000", + "\000S\000T\000\337\000\000"); + + r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE, + "\000S\000T\000S\000S\000\000", + "\000S\000t\000s\000S\000\000"); + + { + UChar pat[] = { 0x1f, 0xfc, 0x00, 0x00 }; + UChar str1[] = { 0x21, 0x26, 0x1f, 0xbe, 0x00, 0x00 }; + UChar str2[] = { 0x1f, 0xf3, 0x00, 0x00 }; + + r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE, + (char* )pat, (char* )str1); + + r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE, + (char* )pat, (char* )str2); + } + +#if 0 + /* You should define USE_UNICODE_CASE_FOLD_TURKISH_AZERI in regenc.h. */ + + set_case_fold(ONIGENC_CASE_FOLD_TURKISH_AZERI); + + r = exec(ONIG_ENCODING_UTF8, ONIG_ENCODING_UTF8, ONIG_OPTION_IGNORECASE, + "Ii", "\304\261\304\260"); + + r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE, + "\000I\000i\000\000", "\001\061\001\060\000\000"); + + r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE, + "\001\061\001\060\000\000", "\000I\000i\000\000"); + + set_case_fold(ONIGENC_CASE_FOLD_MIN); +#endif + + return r; +} diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/listcap.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/listcap.c new file mode 100644 index 000000000..c0d3014d6 --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/listcap.c @@ -0,0 +1,118 @@ +/* + * listcap.c + * + * capture history (?@...) sample. + */ +#include <stdio.h> +#include <string.h> +#include "oniguruma.h" + +static int +node_callback(int group, int beg, int end, int level, int at, void* arg) +{ + int i; + + if (at != ONIG_TRAVERSE_CALLBACK_AT_FIRST) + return -1; /* error */ + + /* indent */ + for (i = 0; i < level * 2; i++) + fputc(' ', stderr); + + fprintf(stderr, "%d: (%d-%d)\n", group, beg, end); + return 0; +} + +extern int ex(unsigned char* str, unsigned char* pattern, + OnigSyntaxType* syntax, OnigOptionType options) +{ + int r; + unsigned char *start, *range, *end; + regex_t* reg; + OnigErrorInfo einfo; + OnigRegion *region; + + r = onig_new(®, pattern, pattern + strlen((char* )pattern), + options, ONIG_ENCODING_ASCII, syntax, &einfo); + if (r != ONIG_NORMAL) { + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r, &einfo); + fprintf(stderr, "ERROR: %s\n", s); + return -1; + } + + fprintf(stderr, "number of captures: %d\n", onig_number_of_captures(reg)); + fprintf(stderr, "number of capture histories: %d\n", + onig_number_of_capture_histories(reg)); + + region = onig_region_new(); + + end = str + strlen((char* )str); + start = str; + range = end; + r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE); + if (r >= 0) { + int i; + + fprintf(stderr, "match at %d\n", r); + for (i = 0; i < region->num_regs; i++) { + fprintf(stderr, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]); + } + fprintf(stderr, "\n"); + + r = onig_capture_tree_traverse(region, ONIG_TRAVERSE_CALLBACK_AT_FIRST, + node_callback, (void* )0); + } + else if (r == ONIG_MISMATCH) { + fprintf(stderr, "search fail\n"); + } + else { /* error */ + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r); + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + return -1; + } + + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + return 0; +} + + +extern int main(int argc, char* argv[]) +{ + int r; + OnigSyntaxType syn; + OnigEncoding use_encs[1]; + + static UChar* str1 = (UChar* )"((())())"; + static UChar* pattern1 + = (UChar* )"\\g<p>(?@<p>\\(\\g<s>\\)){0}(?@<s>(?:\\g<p>)*|){0}"; + + static UChar* str2 = (UChar* )"x00x00x00"; + static UChar* pattern2 = (UChar* )"(?@x(?@\\d+))+"; + + static UChar* str3 = (UChar* )"0123"; + static UChar* pattern3 = (UChar* )"(?@.)(?@.)(?@.)(?@.)"; + + static UChar* str4 = (UChar* )"(((a))(a)) ((((a))(a)))"; + static UChar* pattern4 + = (UChar* )"\\g<p>(?@<p>\\(\\g<s>\\)){0}(?@<s>(?:\\g<p>)*|a){0}"; + + use_encs[0] = ONIG_ENCODING_ASCII; + onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0])); + + /* enable capture hostory */ + onig_copy_syntax(&syn, ONIG_SYNTAX_DEFAULT); + onig_set_syntax_op2(&syn, + onig_get_syntax_op2(&syn) | ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY); + + r = ex(str1, pattern1, &syn, ONIG_OPTION_NONE); + r = ex(str2, pattern2, &syn, ONIG_OPTION_NONE); + r = ex(str3, pattern3, &syn, ONIG_OPTION_NONE); + r = ex(str4, pattern4, &syn, ONIG_OPTION_FIND_LONGEST); + + onig_end(); + return r; +} diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/names.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/names.c new file mode 100644 index 000000000..bf47f6346 --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/names.c @@ -0,0 +1,79 @@ +/* + * names.c -- example of group name callback. + */ +#include <stdio.h> +#include <string.h> +#include "oniguruma.h" + +static int +name_callback(const UChar* name, const UChar* name_end, + int ngroup_num, int* group_nums, + regex_t* reg, void* arg) +{ + int i, gn, ref; + char* s; + OnigRegion *region = (OnigRegion* )arg; + + for (i = 0; i < ngroup_num; i++) { + gn = group_nums[i]; + ref = onig_name_to_backref_number(reg, name, name_end, region); + s = (ref == gn ? "*" : ""); + fprintf(stderr, "%s (%d): ", name, gn); + fprintf(stderr, "(%d-%d) %s\n", region->beg[gn], region->end[gn], s); + } + return 0; /* 0: continue */ +} + +extern int main(int argc, char* argv[]) +{ + int r; + unsigned char *start, *range, *end; + regex_t* reg; + OnigErrorInfo einfo; + OnigRegion *region; + OnigEncoding use_encs[1]; + + static UChar* pattern = (UChar* )"(?<foo>a*)(?<bar>b*)(?<foo>c*)"; + static UChar* str = (UChar* )"aaabbbbcc"; + + use_encs[0] = ONIG_ENCODING_ASCII; + onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0])); + + r = onig_new(®, pattern, pattern + strlen((char* )pattern), + ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, ONIG_SYNTAX_DEFAULT, &einfo); + if (r != ONIG_NORMAL) { + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r, &einfo); + fprintf(stderr, "ERROR: %s\n", s); + return -1; + } + + fprintf(stderr, "number of names: %d\n", onig_number_of_names(reg)); + + region = onig_region_new(); + + end = str + strlen((char* )str); + start = str; + range = end; + r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE); + if (r >= 0) { + fprintf(stderr, "match at %d\n\n", r); + r = onig_foreach_name(reg, name_callback, (void* )region); + } + else if (r == ONIG_MISMATCH) { + fprintf(stderr, "search fail\n"); + } + else { /* error */ + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r); + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + onig_end(); + return -1; + } + + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + onig_end(); + return 0; +} diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/posix.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/posix.c new file mode 100644 index 000000000..c5559362e --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/posix.c @@ -0,0 +1,107 @@ +/* + * posix.c + */ +#include <stdio.h> +#include "onigposix.h" + +typedef unsigned char UChar; + +static int x(regex_t* reg, unsigned char* pattern, unsigned char* str) +{ + int r, i; + char buf[200]; + regmatch_t pmatch[20]; + + r = regexec(reg, (char* )str, reg->re_nsub + 1, pmatch, 0); + if (r != 0 && r != REG_NOMATCH) { + regerror(r, reg, buf, sizeof(buf)); + fprintf(stderr, "ERROR: %s\n", buf); + regfree(reg); + return -1; + } + + if (r == REG_NOMATCH) { + fprintf(stderr, "FAIL: /%s/ '%s'\n", pattern, str); + } + else { + fprintf(stderr, "OK: /%s/ '%s'\n", pattern, str); + for (i = 0; i <= (int )reg->re_nsub; i++) { + fprintf(stderr, "%d: %d-%d\n", i, pmatch[i].rm_so, pmatch[i].rm_eo); + } + } + regfree(reg); + return 0; +} + +extern int main(int argc, char* argv[]) +{ + int r; + char buf[200]; + regex_t reg; + UChar* pattern; + + reg_set_encoding(REG_POSIX_ENCODING_ASCII); + + /* default syntax (ONIG_SYNTAX_ONIGURUMA) */ + pattern = (UChar* )"^a+b{2,7}[c-f]?$|uuu"; + r = regcomp(®, (char* )pattern, REG_EXTENDED); + if (r) { + regerror(r, ®, buf, sizeof(buf)); + fprintf(stderr, "ERROR: %s\n", buf); + regfree(®); + onig_end(); + return -1; + } + x(®, pattern, (UChar* )"aaabbbbd"); + + /* POSIX Basic RE (REG_EXTENDED is not specified.) */ + pattern = (UChar* )"^a+b{2,7}[c-f]?|uuu"; + r = regcomp(®, (char* )pattern, 0); + if (r) { + regerror(r, ®, buf, sizeof(buf)); + fprintf(stderr, "ERROR: %s\n", buf); + regfree(®); + onig_end(); + return -1; + } + x(®, pattern, (UChar* )"a+b{2,7}d?|uuu"); + + /* POSIX Basic RE (REG_EXTENDED is not specified.) */ + pattern = (UChar* )"^a*b\\{2,7\\}\\([c-f]\\)$"; + r = regcomp(®, (char* )pattern, 0); + if (r) { + regerror(r, ®, buf, sizeof(buf)); + fprintf(stderr, "ERROR: %s\n", buf); + regfree(®); + onig_end(); + return -1; + } + x(®, pattern, (UChar* )"aaaabbbbbbd"); + + /* POSIX Extended RE */ + onig_set_default_syntax(ONIG_SYNTAX_POSIX_EXTENDED); + pattern = (UChar* )"^a+b{2,7}[c-f]?)$|uuu"; + r = regcomp(®, (char* )pattern, REG_EXTENDED); + if (r) { + regerror(r, ®, buf, sizeof(buf)); + fprintf(stderr, "ERROR: %s\n", buf); + regfree(®); + onig_end(); + return -1; + } + x(®, pattern, (UChar* )"aaabbbbd)"); + + pattern = (UChar* )"^b."; + r = regcomp(®, (char* )pattern, REG_EXTENDED | REG_NEWLINE); + if (r) { + regerror(r, ®, buf, sizeof(buf)); + fprintf(stderr, "ERROR: %s\n", buf); + regfree(®); + onig_end(); + return -1; + } + x(®, pattern, (UChar* )"a\nb\n"); + + onig_end(); + return 0; +} diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/regset.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/regset.c new file mode 100644 index 000000000..6be511a6e --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/regset.c @@ -0,0 +1,95 @@ +/* + * regset.c + */ +#include <stdio.h> +#include <string.h> +#include "oniguruma.h" + +extern int main(int argc, char* argv[]) +{ + int r; + int i, n; + int match_pos; + unsigned char *start, *range, *end; + OnigRegSet* set; + OnigRegSetLead lead; + regex_t* reg; + OnigErrorInfo einfo; + char ebuf[ONIG_MAX_ERROR_MESSAGE_LEN]; + OnigEncoding use_encs[1]; + + static UChar* str = (UChar* )"aaaaaaaaaaaaaaaaaaaaaaca"; + + static char* pat[] = { + "a(.*)b|a(.)c", + "^(abc)", + "a(.....)c" + }; + + use_encs[0] = ONIG_ENCODING_UTF8; + onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0])); + + r = onig_regset_new(&set, 0, NULL); + if (r != ONIG_NORMAL) { + onig_error_code_to_str((UChar* )ebuf, r); + fprintf(stderr, "ERROR: %s\n", ebuf); + onig_end(); + return -1; + } + + n = sizeof(pat) / sizeof(pat[0]); + + for (i = 0; i < n; i++) { + r = onig_new(®, (UChar* )pat[i], (UChar* )(pat[i] + strlen(pat[i])), + ONIG_OPTION_DEFAULT, ONIG_ENCODING_UTF8, ONIG_SYNTAX_DEFAULT, + &einfo); + if (r != ONIG_NORMAL) { + onig_error_code_to_str((UChar* )ebuf, r, &einfo); + fprintf(stderr, "ERROR: %s\n", ebuf); + onig_regset_free(set); + onig_end(); + return -1; + } + + r = onig_regset_add(set, reg); + if (r != ONIG_NORMAL) { + onig_free(reg); + onig_regset_free(set); + onig_end(); + return -1; + } + } + + end = str + strlen((char* )str); + start = str; + range = end; + lead = ONIG_REGSET_POSITION_LEAD; + //lead = ONIG_REGSET_PRIORITY_TO_REGEX_ORDER; + r = onig_regset_search(set, str, end, start, range, lead, ONIG_OPTION_NONE, + &match_pos); + if (r >= 0) { + OnigRegion *region; + + fprintf(stderr, "match regex index: %d\n", r); + fprintf(stderr, "match position: %d\n", match_pos); + + region = onig_regset_get_region(set, r); + for (i = 0; i < region->num_regs; i++) { + fprintf(stderr, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]); + } + } + else if (r == ONIG_MISMATCH) { + fprintf(stderr, "search fail\n"); + } + else { /* error */ + onig_error_code_to_str((UChar* )ebuf, r); + fprintf(stderr, "ERROR: %s\n", ebuf); + onig_regset_free(set); + onig_end(); + return -1; + } + + onig_regset_free(set); + onig_end(); + return 0; +} diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/scan.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/scan.c new file mode 100644 index 000000000..4039e46db --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/scan.c @@ -0,0 +1,90 @@ +/* + * scan.c + */ +#include <stdio.h> +#include <stdlib.h> +#include "oniguruma.h" + +static int +scan_callback(int n, int r, OnigRegion* region, void* arg) +{ + int i; + + fprintf(stdout, "scan: %d\n", n); + + fprintf(stdout, "match at %d\n", r); + for (i = 0; i < region->num_regs; i++) { + fprintf(stdout, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]); + } + + return 0; +} + +static int +scan(regex_t* reg, unsigned char* str, unsigned char* end) +{ + int r; + OnigRegion *region; + + region = onig_region_new(); + + r = onig_scan(reg, str, end, region, ONIG_OPTION_NONE, scan_callback, NULL); + if (r >= 0) { + fprintf(stdout, "total: %d match\n", r); + } + else { /* error */ + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((OnigUChar* )s, r); + fprintf(stderr, "ERROR: %s\n", s); + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + return -1; + } + + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + return 0; +} + +static int +exec(OnigEncoding enc, OnigOptionType options, char* apattern, char* astr) +{ + int r; + unsigned char *end; + regex_t* reg; + OnigErrorInfo einfo; + UChar* pattern_end; + UChar* pattern = (UChar* )apattern; + UChar* str = (UChar* )astr; + + onig_initialize(&enc, 1); + + pattern_end = pattern + onigenc_str_bytelen_null(enc, pattern); + + r = onig_new(®, pattern, pattern_end, options, enc, ONIG_SYNTAX_DEFAULT, &einfo); + if (r != ONIG_NORMAL) { + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((OnigUChar* )s, r, &einfo); + fprintf(stderr, "ERROR: %s\n", s); + onig_end(); + return -1; + } + + end = str + onigenc_str_bytelen_null(enc, str); + r = scan(reg, str, end); + + onig_free(reg); + onig_end(); + return 0; +} + + +extern int main(int argc, char* argv[]) +{ + exec(ONIG_ENCODING_UTF8, ONIG_OPTION_NONE, + "\\Ga+\\s*", "a aa aaa baaa"); + + fprintf(stdout, "\n"); + exec(ONIG_ENCODING_UTF8, ONIG_OPTION_NONE, + "a+\\s*", "a aa aaa baaa"); + + return 0; +} diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/simple.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/simple.c new file mode 100644 index 000000000..a08ea86d3 --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/simple.c @@ -0,0 +1,63 @@ +/* + * simple.c + */ +#include <stdio.h> +#include <string.h> +#include "oniguruma.h" + +extern int main(int argc, char* argv[]) +{ + int r; + unsigned char *start, *range, *end; + regex_t* reg; + OnigErrorInfo einfo; + OnigRegion *region; + OnigEncoding use_encs[1]; + + static UChar* pattern = (UChar* )"a(.*)b|[e-f]+"; + static UChar* str = (UChar* )"zzzzaffffffffb"; + + use_encs[0] = ONIG_ENCODING_ASCII; + onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0])); + + r = onig_new(®, pattern, pattern + strlen((char* )pattern), + ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, ONIG_SYNTAX_DEFAULT, &einfo); + if (r != ONIG_NORMAL) { + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r, &einfo); + fprintf(stderr, "ERROR: %s\n", s); + return -1; + } + + region = onig_region_new(); + + end = str + strlen((char* )str); + start = str; + range = end; + r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE); + if (r >= 0) { + int i; + + fprintf(stderr, "match at %d\n", r); + for (i = 0; i < region->num_regs; i++) { + fprintf(stderr, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]); + } + } + else if (r == ONIG_MISMATCH) { + fprintf(stderr, "search fail\n"); + } + else { /* error */ + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r); + fprintf(stderr, "ERROR: %s\n", s); + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + onig_end(); + return -1; + } + + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + onig_end(); + return 0; +} diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/sql.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/sql.c new file mode 100644 index 000000000..21147aa13 --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/sql.c @@ -0,0 +1,81 @@ +/* + * sql.c + */ +#include <stdio.h> +#include <string.h> +#include "oniguruma.h" + +extern int main(int argc, char* argv[]) +{ + static OnigSyntaxType SQLSyntax; + + int r; + unsigned char *start, *range, *end; + regex_t* reg; + OnigErrorInfo einfo; + OnigRegion *region; + OnigEncoding use_encs[1]; + + static UChar* pattern = (UChar* )"\\_%\\\\__zz"; + static UChar* str = (UChar* )"a_abcabcabc\\ppzz"; + + use_encs[0] = ONIG_ENCODING_ASCII; + onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0])); + + onig_set_syntax_op (&SQLSyntax, ONIG_SYN_OP_VARIABLE_META_CHARACTERS); + onig_set_syntax_op2 (&SQLSyntax, 0); + onig_set_syntax_behavior(&SQLSyntax, 0); + onig_set_syntax_options (&SQLSyntax, ONIG_OPTION_MULTILINE); + onig_set_meta_char(&SQLSyntax, ONIG_META_CHAR_ESCAPE, (OnigCodePoint )'\\'); + onig_set_meta_char(&SQLSyntax, ONIG_META_CHAR_ANYCHAR, (OnigCodePoint )'_'); + onig_set_meta_char(&SQLSyntax, ONIG_META_CHAR_ANYTIME, + ONIG_INEFFECTIVE_META_CHAR); + onig_set_meta_char(&SQLSyntax, ONIG_META_CHAR_ZERO_OR_ONE_TIME, + ONIG_INEFFECTIVE_META_CHAR); + onig_set_meta_char(&SQLSyntax, ONIG_META_CHAR_ONE_OR_MORE_TIME, + ONIG_INEFFECTIVE_META_CHAR); + onig_set_meta_char(&SQLSyntax, ONIG_META_CHAR_ANYCHAR_ANYTIME, + (OnigCodePoint )'%'); + + r = onig_new(®, pattern, pattern + strlen((char* )pattern), + ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, &SQLSyntax, &einfo); + if (r != ONIG_NORMAL) { + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r, &einfo); + fprintf(stderr, "ERROR: %s\n", s); + onig_end(); + return -1; + } + + region = onig_region_new(); + + end = str + strlen((char* )str); + start = str; + range = end; + r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE); + if (r >= 0) { + int i; + + fprintf(stderr, "match at %d\n", r); + for (i = 0; i < region->num_regs; i++) { + fprintf(stderr, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]); + } + } + else if (r == ONIG_MISMATCH) { + fprintf(stderr, "search fail\n"); + } + else { /* error */ + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r); + fprintf(stderr, "ERROR: %s\n", s); + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + onig_end(); + return -1; + } + + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + onig_end(); + return 0; +} diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/syntax.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/syntax.c new file mode 100644 index 000000000..3a5a7cf13 --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/syntax.c @@ -0,0 +1,77 @@ +/* + * syntax.c + */ +#include <stdio.h> +#include <string.h> +#include "oniguruma.h" + +extern int exec(OnigSyntaxType* syntax, char* apattern, char* astr) +{ + int r; + unsigned char *start, *range, *end; + regex_t* reg; + OnigErrorInfo einfo; + OnigRegion *region; + UChar* pattern = (UChar* )apattern; + UChar* str = (UChar* )astr; + + r = onig_new(®, pattern, pattern + strlen((char* )pattern), + ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, syntax, &einfo); + if (r != ONIG_NORMAL) { + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r, &einfo); + fprintf(stderr, "ERROR: %s\n", s); + return -1; + } + + region = onig_region_new(); + + end = str + strlen((char* )str); + start = str; + range = end; + r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE); + if (r >= 0) { + int i; + + fprintf(stderr, "match at %d\n", r); + for (i = 0; i < region->num_regs; i++) { + fprintf(stderr, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]); + } + } + else if (r == ONIG_MISMATCH) { + fprintf(stderr, "search fail\n"); + } + else { /* error */ + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r); + fprintf(stderr, "ERROR: %s\n", s); + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + return -1; + } + + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + return 0; +} + +extern int main(int argc, char* argv[]) +{ + int r; + OnigEncoding use_encs[1]; + + use_encs[0] = ONIG_ENCODING_ASCII; + onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0])); + + r = exec(ONIG_SYNTAX_PERL, + "\\p{XDigit}\\P{XDigit}\\p{^XDigit}\\P{^XDigit}\\p{XDigit}", + "bgh3a"); + + r = exec(ONIG_SYNTAX_JAVA, "\\p{XDigit}\\P{XDigit}[a-c&&b-g]", "bgc"); + + r = exec(ONIG_SYNTAX_ASIS, + "abc def* e+ g?ddd[a-rvvv] (vv){3,7}hv\\dvv(?:aczui ss)\\W\\w$", + "abc def* e+ g?ddd[a-rvvv] (vv){3,7}hv\\dvv(?:aczui ss)\\W\\w$"); + onig_end(); + return r; +} diff --git a/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/user_property.c b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/user_property.c new file mode 100644 index 000000000..ecb842c15 --- /dev/null +++ b/roms/edk2/MdeModulePkg/Universal/RegularExpressionDxe/oniguruma/sample/user_property.c @@ -0,0 +1,92 @@ +/* + * user_property.c + */ +#include <stdio.h> +#include <string.h> +#include "oniguruma.h" + +extern int +main(int argc, char* argv[]) +{ + int r; + unsigned char *start, *range, *end; + regex_t* reg; + OnigErrorInfo einfo; + OnigRegion *region; + OnigEncoding use_encs[1]; + + static OnigCodePoint handakuon_hiragana[] = { + 5, /* number of ranges */ + 0x3071, 0x3071, /* PA */ + 0x3074, 0x3074, /* PI */ + 0x3077, 0x3077, /* PU */ + 0x307a, 0x307a, /* PE */ + 0x307d, 0x307d /* PO */ + }; + + static UChar* pattern = (UChar* )"\\A(\\p{HandakuonHiragana}{5})\\p{^HandakuonHiragana}\\z"; + //static UChar* pattern = (UChar* )"\\p{Handakuon_Hiragana}{5}\\P{Handakuon Hiragana}"; + + /* "PA PI PU PE PO a" */ + static UChar* str = (UChar* )"\343\201\261\343\201\264\343\201\267\343\201\272\343\201\275a"; + + use_encs[0] = ONIG_ENCODING_UTF8; + onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0])); + + r = onig_unicode_define_user_property("HandakuonHiragana", handakuon_hiragana); + if (r == ONIG_NORMAL) { + fprintf(stdout, "define HandakuonHiragana\n"); + } + else { + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r); + fprintf(stderr, "ERROR: %s\n", s); + onig_end(); + return -1; + } + + r = onig_new(®, pattern, pattern + strlen((char* )pattern), + ONIG_OPTION_DEFAULT, ONIG_ENCODING_UTF8, ONIG_SYNTAX_DEFAULT, &einfo); + if (r == ONIG_NORMAL) { + fprintf(stdout, "onig_new: success.\n"); + } + else { + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r, &einfo); + fprintf(stderr, "onig_new: ERROR: %s\n", s); + onig_end(); + return -1; + } + + region = onig_region_new(); + + end = str + strlen((char* )str); + start = str; + range = end; + r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE); + if (r >= 0) { + int i; + + fprintf(stderr, "match at %d\n", r); + for (i = 0; i < region->num_regs; i++) { + fprintf(stderr, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]); + } + } + else if (r == ONIG_MISMATCH) { + fprintf(stderr, "search fail\n"); + } + else { /* error */ + char s[ONIG_MAX_ERROR_MESSAGE_LEN]; + onig_error_code_to_str((UChar* )s, r); + fprintf(stderr, "ERROR: %s\n", s); + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + onig_end(); + return -1; + } + + onig_region_free(region, 1 /* 1:free self, 0:free contents only */); + onig_free(reg); + onig_end(); + return 0; +} |