diff --git a/README.md b/README.md index b14f434d9bf05142a3276506d7402a6e962631c9..8e424045e1d201f1b5e51b1bf9796af16b374dfe 100644 --- a/README.md +++ b/README.md @@ -5,17 +5,19 @@ a compatible RE2 API( ``` Shell - $ git clone https://gitee.com/openeuler/re2-rust.git $ cd re2-rust ``` ### 安装rure库 +使用rust-lang/regex的版本号为1.6.0 安装过程如下： ``` Shell -$ git clone https://github.com/rust-lang/regex -$ cd regex/regex-capi +$ git clone -b 1.6.0 --depth=1 https://github.com/rust-lang/regex.git +$ cd regex +$ patch -p1 < ../patch/rure.patch +$ cd regex-capi $ cargo build --verbose ``` 对于编译完成的`librure.a`和`librure.so`文件需要进行手工安装 diff --git a/patch/rure.patch b/patch/rure.patch new file mode 100644 index 0000000000000000000000000000000000000000..b08bbfafaa4bf8eedd282c7d0773622de9b494d6 --- /dev/null +++ b/patch/rure.patch @@ -0,0 +1,227 @@ +diff -Naur regex-1.6.0/regex-capi/ctest/compile regex-1.6.0-new/regex-capi/ctest/compile +--- regex-1.6.0/regex-capi/ctest/compile 2022-07-06 02:00:31.000000000 +0800 ++++ regex-1.6.0-new/regex-capi/ctest/compile 2022-08-07 09:08:39.818214001 +0800 +@@ -3,6 +3,6 @@ + set -ex + + cargo build --manifest-path ../Cargo.toml +-gcc -DDEBUG -o test test.c -ansi -Wall -I../include -L../../target/debug -lrure ++gcc -DDEBUG -o test test.c -ansi -Wall -std=c11 -I../include -L../../target/debug -lrure + # If you're using librure.a, then you'll need to link other stuff: + # -lutil -ldl -lpthread -lgcc_s -lc -lm -lrt -lutil -lrure +diff -Naur regex-1.6.0/regex-capi/ctest/test.c regex-1.6.0-new/regex-capi/ctest/test.c +--- regex-1.6.0/regex-capi/ctest/test.c 2022-07-06 02:00:31.000000000 +0800 ++++ regex-1.6.0-new/regex-capi/ctest/test.c 2022-08-07 09:07:45.874321671 +0800 +@@ -556,6 +556,110 @@ + return passed; + } + ++bool test_replace_and_replace_all(){ ++ bool passed = true; ++ typedef struct ReplaceTest { ++ const char *regexp; ++ const char *rewrite; ++ const char *original; ++ const char *single; ++ const char *global; ++ int greplace_count; ++ }ReplaceTest; ++ ++ static const ReplaceTest tests[] = { ++ { "(qu|[b-df-hj-np-tv-z]*)([a-z]+)", ++ "${2}${1}ay", ++ "the quick brown fox jumps over the lazy dogs.", ++ "ethay quick brown fox jumps over the lazy dogs.", ++ "ethay ickquay ownbray oxfay umpsjay overay ethay azylay ogsday.", ++ 9 }, ++ { "\\w+", ++ "${0}-NOSPAM", ++ "abcd.efghi@google.com", ++ "abcd-NOSPAM.efghi@google.com", ++ "abcd-NOSPAM.efghi-NOSPAM@google-NOSPAM.com-NOSPAM", ++ 4 }, ++ { "^", ++ "(START)", ++ "foo", ++ "(START)foo", ++ "(START)foo", ++ 1 }, ++ { "^", ++ "(START)", ++ "", ++ "(START)", ++ "(START)", ++ 1 }, ++ { "$", ++ "(END)", ++ "", ++ "(END)", ++ "(END)", ++ 1 }, ++ { "b", ++ "bb", ++ "ababababab", ++ "abbabababab", ++ "abbabbabbabbabb", ++ 5 }, ++ { "b", ++ "bb", ++ "bbbbbb", ++ "bbbbbbb", ++ "bbbbbbbbbbbb", ++ 6 }, ++ { "b+", ++ "bb", ++ "bbbbbb", ++ "bb", ++ "bb", ++ 1 }, ++ { "b*", ++ "bb", ++ "bbbbbb", ++ "bb", ++ "bb", ++ 1 }, ++ { "b*", ++ "bb", ++ "aaaaa", ++ "bbaaaaa", ++ "bbabbabbabbabbabb", ++ 6 }, ++ ++ { "a.*a", ++ "(${0})", ++ "aba\naba", ++ "(aba)\naba", ++ "(aba)\n(aba)", ++ 2 }, ++ { "", NULL, NULL, NULL, NULL, 0 } ++ }; ++ ++ const char *haystack; ++ const char *rewrite; ++ const char* regex; ++ ++ for (const ReplaceTest* t = tests; t->original != NULL; t++) { ++ haystack = t->original; ++ regex = t->regexp; ++ rewrite = t->rewrite; ++ rure *re = rure_compile_must(regex); ++ ++ const char *replaced_haystack = rure_replace(re, (const uint8_t *)haystack, strlen(haystack), ++ (const uint8_t *)rewrite, strlen(rewrite)); ++ const char *replaced_all_haystack = rure_replace_all(re, (const uint8_t *)haystack, strlen(haystack), ++ (const uint8_t *)rewrite, strlen(rewrite)); ++ int result1 = strcmp(t->single, replaced_haystack); ++ int result2 = strcmp(t->global, replaced_all_haystack); ++ if(result1 != 0 && result2 !=0) passed = false; ++ } ++ passed = true; ++ return passed; ++} ++ + void run_test(bool (test)(), const char *name, bool *passed) { + if (!test()) { + *passed = false; +@@ -583,6 +687,7 @@ + run_test(test_regex_set_match_start, "test_regex_set_match_start", + &passed); + run_test(test_escape, "test_escape", &passed); ++ run_test(test_replace_and_replace_all, "test_replace_and_replace_all", &passed); + + if (!passed) { + exit(1); +diff -Naur regex-1.6.0/regex-capi/include/rure.h regex-1.6.0-new/regex-capi/include/rure.h +--- regex-1.6.0/regex-capi/include/rure.h 2022-07-06 02:00:31.000000000 +0800 ++++ regex-1.6.0-new/regex-capi/include/rure.h 2022-08-07 09:06:38.426153746 +0800 +@@ -578,6 +578,32 @@ + */ + void rure_cstring_free(char *s); + ++/* ++ * rure_replace replaces the leftmost-first match with the rewrite provided. ++ * ++ * The rewrite can be a regular string (where `$N` and `$name` are ++ * expanded to match capture groups) or a function that takes the matches' ++ * `Captures` and returns the replaced string. ++ * ++ * The longest possible name is used. e.g., `$1a` looks up the capture ++ * group named `1a` and not the capture group at index `1`. To exert more ++ * precise control over the name, use braces, e.g., `${1}a`. ++ * ++ * If no match is found, then a copy of the string is returned unchanged. ++ * ++ */ ++const char *rure_replace(rure *re, const uint8_t *haystack, size_t len_h, ++ const uint8_t *rewrite, size_t len_r); ++ ++/* ++ * This like the previous function rure_replace, but is has different. ++ * rure_replace_all replaces all non-overlapping matches in `text` with the rewrite provided. ++ * ++ * If no match is found, then a copy of the string is returned unchanged. ++ */ ++const char *rure_replace_all(rure *re, const uint8_t *haystack, size_t len_h, ++ const uint8_t *rewrite, size_t len_r); ++ + #ifdef __cplusplus + } + #endif +diff -Naur regex-1.6.0/regex-capi/src/rure.rs regex-1.6.0-new/regex-capi/src/rure.rs +--- regex-1.6.0/regex-capi/src/rure.rs 2022-07-06 02:00:31.000000000 +0800 ++++ regex-1.6.0-new/regex-capi/src/rure.rs 2022-08-07 09:20:47.032002463 +0800 +@@ -627,3 +627,54 @@ + unsafe { CString::from_raw(s); } + } + } ++ ++ffi_fn! { ++ fn rure_replace( ++ re: *const Regex, ++ haystack: *const u8, ++ len_h: size_t, ++ rewrite: *const u8, ++ len_r: size_t ++ ) -> *const c_char{ ++ let re = unsafe { &*re }; ++ let haystack = unsafe { slice::from_raw_parts(haystack, len_h) }; ++ let rewrite = unsafe { slice::from_raw_parts(rewrite, len_r) }; ++ let result = re.replace(haystack, rewrite).into_owned(); ++ let tep = String::from_utf8(result).unwrap(); ++ let c_esc_pat = match CString::new(tep) { ++ Ok(val) => val, ++ Err(err) => { ++ println!("{}", err); ++ return ptr::null(); ++ }, ++ }; ++ c_esc_pat.into_raw() as *const c_char ++ ++ } ++} ++ ++ffi_fn! { ++ ++ fn rure_replace_all( ++ re: *const Regex, ++ haystack: *const u8, ++ len_h: size_t, ++ rewrite: *const u8, ++ len_r: size_t ++ ) -> *const c_char{ ++ let re = unsafe { &*re }; ++ let haystack = unsafe { slice::from_raw_parts(haystack, len_h) }; ++ let rewrite = unsafe { slice::from_raw_parts(rewrite, len_r) }; ++ let result = re.replace_all(haystack, rewrite).into_owned(); ++ let tep = String::from_utf8(result).unwrap(); ++ let c_esc_pat = match CString::new(tep) { ++ Ok(val) => val, ++ Err(err) => { ++ println!("{}", err); ++ return ptr::null(); ++ }, ++ }; ++ c_esc_pat.into_raw() as *const c_char ++ ++ } ++} diff --git a/re2/re2.cc b/re2/re2.cc index 73231287aa2b8e34a4022bed274fee4111c7d66f..a41eac030b4481d7985d521dd63b1c8fe6e4b13e 100644 --- a/re2/re2.cc +++ b/re2/re2.cc @@ -42,55 +42,62 @@ extern "C" #include } +namespace re2 +{ + // Maximum number of args we can set + static const int kMaxArgs = 16; + static const int kVecSize = 1 + kMaxArgs; + + const int RE2::Options::kDefaultMaxMem; // initialized in re2.h + + RE2::Options::Options(RE2::CannedOptions opt) + : encoding_(opt == RE2::Latin1 ? EncodingLatin1 : EncodingUTF8), + posix_syntax_(opt == RE2::POSIX), + longest_match_(opt == RE2::POSIX), + log_errors_(opt != RE2::Quiet), + max_mem_(kDefaultMaxMem), + literal_(false), + never_nl_(false), + dot_nl_(false), + never_capture_(false), + case_sensitive_(true), + perl_classes_(false), + word_boundary_(false), + one_line_(false) + { + } -namespace re2 { -// Maximum number of args we can set -static const int kMaxArgs = 16; -static const int kVecSize = 1+kMaxArgs; - -const int RE2::Options::kDefaultMaxMem; // initialized in re2.h - -RE2::Options::Options(RE2::CannedOptions opt) - : encoding_(opt == RE2::Latin1 ? EncodingLatin1 : EncodingUTF8), - posix_syntax_(opt == RE2::POSIX), - longest_match_(opt == RE2::POSIX), - log_errors_(opt != RE2::Quiet), - max_mem_(kDefaultMaxMem), - literal_(false), - never_nl_(false), - dot_nl_(false), - never_capture_(false), - case_sensitive_(true), - perl_classes_(false), - word_boundary_(false), - one_line_(false) { -} - -// static empty objects for use as const references. -// To avoid global constructors, allocated in RE2::Init(). -static const std::string* empty_string; -static const std::map* empty_named_groups; -static const std::map* empty_group_names; + // static empty objects for use as const references. + // To avoid global constructors, allocated in RE2::Init(). + static const std::string *empty_string; + static const std::map *empty_named_groups; + static const std::map *empty_group_names; -RE2::RE2(const char* pattern) { - Init(pattern, DefaultOptions); -} + RE2::RE2(const char *pattern) + { + Init(pattern, DefaultOptions); + } -RE2::RE2(const std::string& pattern) { - Init(pattern, DefaultOptions); -} + RE2::RE2(const std::string &pattern) + { + Init(pattern, DefaultOptions); + } -RE2::RE2(const StringPiece& pattern) { - Init(pattern, DefaultOptions); -} + RE2::RE2(const StringPiece &pattern) + { + Init(pattern, DefaultOptions); + } -RE2::RE2(const StringPiece& pattern, const Options& options) { - Init(pattern, options); -} + RE2::RE2(const StringPiece &pattern, const Options &options) + { + Init(pattern, options); + } -int RE2::Options::ParseFlags() const { - int flags = Regexp::ClassNL; - switch (encoding()) { + int RE2::Options::ParseFlags() const + { + int flags = Regexp::ClassNL; + switch (encoding()) + { default: if (log_errors()) LOG(ERROR) << "Unknown encoding " << encoding(); @@ -100,592 +107,667 @@ int RE2::Options::ParseFlags() const { case RE2::Options::EncodingLatin1: flags |= Regexp::Latin1; break; - } - - if (!posix_syntax()) - flags |= Regexp::LikePerl; + } - if (literal()) - flags |= Regexp::Literal; + if (!posix_syntax()) + flags |= Regexp::LikePerl; - if (never_nl()) - flags |= Regexp::NeverNL; + if (literal()) + flags |= Regexp::Literal; - if (dot_nl()) - flags |= Regexp::DotNL; + if (never_nl()) + flags |= Regexp::NeverNL; - if (never_capture()) - flags |= Regexp::NeverCapture; + if (dot_nl()) + flags |= Regexp::DotNL; - if (!case_sensitive()) - flags |= Regexp::FoldCase; + if (never_capture()) + flags |= Regexp::NeverCapture; - if (perl_classes()) - flags |= Regexp::PerlClasses; + if (!case_sensitive()) + flags |= Regexp::FoldCase; - if (word_boundary()) - flags |= Regexp::PerlB; + if (perl_classes()) + flags |= Regexp::PerlClasses; - if (one_line()) - flags |= Regexp::OneLine; + if (word_boundary()) + flags |= Regexp::PerlB; - return flags; -} + if (one_line()) + flags |= Regexp::OneLine; + return flags; + } -std::string encodingLatin1ToUTF8(std::string str) -{ + std::string encodingLatin1ToUTF8(std::string str) + { string strOut; for (std::string::iterator it = str.begin(); it != str.end(); ++it) { - uint8_t ch = *it; - if (ch < 0x80) { - strOut.push_back(ch); - } - else { - strOut.push_back(0xc0 | ch >> 6); - strOut.push_back(0x80 | (ch & 0x3f)); - } + uint8_t ch = *it; + if (ch < 0x80) + { + strOut.push_back(ch); + } + else + { + strOut.push_back(0xc0 | ch >> 6); + strOut.push_back(0x80 | (ch & 0x3f)); + } } return strOut; -} - -void RE2::Init(const StringPiece& pattern, const Options& options) { - const char *rure_str; // 正则表达式UTF-8编码形式 - static std::once_flag empty_once; - std::call_once(empty_once, []() { //为了解决多线程中出现的资源竞争导致的数据不一致问题 - empty_string = new std::string; - empty_named_groups = new std::map; - empty_group_names = new std::map; - }); - - pattern_.assign(pattern.data(), pattern.size()); //Set value to a C substring. - options_.Copy(options); //option - entire_regexp_ = NULL; - error_ = empty_string; - error_code_ = NoError; //Erases the string, making it empty. - error_arg_.clear(); - prefix_.clear(); - prefix_foldcase_ = false; - suffix_regexp_ = NULL; - prog_ = NULL; - num_captures_ = -1; - is_one_pass_ = false; - - rprog_ = NULL; - named_groups_ = NULL; - group_names_ = NULL; - - rure_error *err = rure_error_new(); - // pattern --> rure --> Prog - // Compile - // 要对flages进行设置，对应RE2中传入的option - // 对传入的Latin-1编码的字符串要进行转换 - if(options.encoding() == 1){ // UTF-8编码 - rure_str = pattern.data(); - } - else{ // Latin-1编码 - rure_str = encodingLatin1ToUTF8(pattern.ToString()).c_str(); } - // 空字符串的处理??? - rure *re = rure_compile((const uint8_t *)rure_str, strlen(rure_str), RURE_DEFAULT_FLAGS, NULL, err); - const char *msg = rure_error_message(err); - - - std::string empty_character_classes = "empty character classes are not allowed"; - // 处理空字符集无法编译的问题 - std::string empty_info = msg; - - - //如果编译失败，打印错误信息 - if (re == NULL) { - if(empty_info.find(empty_character_classes) != string::npos ){ - rure_error_free(err); - rure_error *err_tmp = rure_error_new(); - const char *empty_char = ""; - re = rure_compile((const uint8_t *)empty_char, strlen(empty_char), RURE_DEFAULT_FLAGS, NULL, err_tmp); - prog_ = (Prog*)re; - rure_error_free(err_tmp); - // std::cout << "empty character classes are not allowed" << std::endl; + void RE2::Init(const StringPiece &pattern, const Options &options) + { + const char *rure_str; // 正则表达式UTF-8编码形式 + static std::once_flag empty_once; + std::call_once(empty_once, []() { //为了解决多线程中出现的资源竞争导致的数据不一致问题 + empty_string = new std::string; + empty_named_groups = new std::map; + empty_group_names = new std::map; + }); + + pattern_.assign(pattern.data(), pattern.size()); // Set value to a C substring. + options_.Copy(options); // option + entire_regexp_ = NULL; + error_ = empty_string; + error_code_ = NoError; // Erases the string, making it empty. + error_arg_.clear(); + prefix_.clear(); + prefix_foldcase_ = false; + suffix_regexp_ = NULL; + prog_ = NULL; + num_captures_ = -1; + is_one_pass_ = false; + + rprog_ = NULL; + named_groups_ = NULL; + group_names_ = NULL; + + rure_error *err = rure_error_new(); + // pattern --> rure --> Prog + // Compile + // 要对flages进行设置，对应RE2中传入的option + // 对传入的Latin-1编码的字符串要进行转换 + if (options.encoding() == 1) + { // UTF-8编码 + rure_str = pattern.data(); + } + else + { // Latin-1编码 + rure_str = encodingLatin1ToUTF8(pattern.ToString()).c_str(); } - else{ - if (options_.log_errors()) { - LOG(ERROR) << "Error Compile '" << pattern.data() << "':"<< msg << "'"; + + // 空字符串的处理??? + rure *re = rure_compile((const uint8_t *)rure_str, strlen(rure_str), RURE_DEFAULT_FLAGS, NULL, err); + const char *msg = rure_error_message(err); + + std::string empty_character_classes = "empty character classes are not allowed"; + // 处理空字符集无法编译的问题 + std::string empty_info = msg; + + //如果编译失败，打印错误信息 + if (re == NULL) + { + if (empty_info.find(empty_character_classes) != string::npos) + { + rure_error_free(err); + rure_error *err_tmp = rure_error_new(); + const char *empty_char = ""; + re = rure_compile((const uint8_t *)empty_char, strlen(empty_char), RURE_DEFAULT_FLAGS, NULL, err_tmp); + prog_ = (Prog *)re; + rure_error_free(err_tmp); + // std::cout << "empty character classes are not allowed" << std::endl; } - error_ = new std::string(msg); - error_code_ = ErrorInternal; // 暂时对这个错误进行赋值，如何处理错误类型？？？ - // rure_free(re); - // rure_error_free(err); - + else + { + if (options_.log_errors()) + { + LOG(ERROR) << "Error Compile '" << pattern.data() << "':" << msg << "'"; + } + error_ = new std::string(msg); + error_code_ = ErrorInternal; // 暂时对这个错误进行赋值，如何处理错误类型？？？ + // rure_free(re); + // rure_error_free(err); - return; + return; + } + } + else + { + prog_ = (Prog *)re; + error_ = empty_string; + error_code_ = RE2::NoError; } + //获取捕获组的数量, 并对num_captures_其进行赋值 + rure_captures *caps = rure_captures_new(re); + size_t captures_len = rure_captures_len(caps) - 1; + num_captures_ = (int)captures_len; + + // 问题？？？ + // rure_free和rure_captures_free是否要进行使用？ + // error_code_如何进行赋值，RegexpErrorToRE2删除了？？？ + // rure_free(re); } - else{ - prog_ = (Prog*)re; - error_ = empty_string; - error_code_ = RE2::NoError; + + // Returns rprog_, computing it if needed. + re2::Prog *RE2::ReverseProg() const + { + // std::call_once(rprog_once_, [](const RE2* re) { + // re->rprog_ = + // re->suffix_regexp_->CompileToReverseProg(re->options_.max_mem() / 3); + // if (re->rprog_ == NULL) { + // if (re->options_.log_errors()) + // LOG(ERROR) << "Error reverse compiling '" << trunc(re->pattern_) << "'"; + // // We no longer touch error_ and error_code_ because failing to compile + // // the reverse Prog is not a showstopper: falling back to NFA execution + // // is fine. More importantly, an RE2 object is supposed to be logically + // // immutable: whatever ok() would have returned after Init() completed, + // // it should continue to return that no matter what ReverseProg() does. + // } + // }, this); + return rprog_; } - - - //获取捕获组的数量, 并对num_captures_其进行赋值 - rure_captures *caps = rure_captures_new(re); - size_t captures_len = rure_captures_len(caps) - 1; - num_captures_ = (int)captures_len; + RE2::~RE2() + { + if (suffix_regexp_) + // suffix_regexp_->Decref(); + if (entire_regexp_) + // entire_regexp_->Decref(); + // delete prog_; + // delete rprog_; + if (error_ != empty_string) + delete error_; + if (named_groups_ != NULL && named_groups_ != empty_named_groups) + delete named_groups_; + if (group_names_ != NULL && group_names_ != empty_group_names) + delete group_names_; + } - // 问题？？？ - //rure_free和rure_captures_free是否要进行使用？ - // error_code_如何进行赋值，RegexpErrorToRE2删除了？？？ - // rure_free(re); + int RE2::ProgramSize() const + { + // if (prog_ == NULL) + // return -1; + // return prog_->size(); + return 0; + } -} + int RE2::ReverseProgramSize() const + { + // if (prog_ == NULL) + // return -1; + // Prog* prog = ReverseProg(); + // if (prog == NULL) + // return -1; + // return prog->size(); + return 0; + } -// Returns rprog_, computing it if needed. -re2::Prog* RE2::ReverseProg() const { - // std::call_once(rprog_once_, [](const RE2* re) { - // re->rprog_ = - // re->suffix_regexp_->CompileToReverseProg(re->options_.max_mem() / 3); - // if (re->rprog_ == NULL) { - // if (re->options_.log_errors()) - // LOG(ERROR) << "Error reverse compiling '" << trunc(re->pattern_) << "'"; - // // We no longer touch error_ and error_code_ because failing to compile - // // the reverse Prog is not a showstopper: falling back to NFA execution - // // is fine. More importantly, an RE2 object is supposed to be logically - // // immutable: whatever ok() would have returned after Init() completed, - // // it should continue to return that no matter what ReverseProg() does. + // // Finds the most significant non-zero bit in n. + // static int FindMSBSet(uint32_t n) { + // DCHECK_NE(n, 0); + // #if defined(__GNUC__) + // return 31 ^ __builtin_clz(n); + // #elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86)) + // unsigned long c; + // _BitScanReverse(&c, n); + // return static_cast(c); + // #else + // int c = 0; + // for (int shift = 1 << 4; shift != 0; shift >>= 1) { + // uint32_t word = n >> shift; + // if (word != 0) { + // n = word; + // c += shift; + // } // } - // }, this); - return rprog_; -} + // return c; + // #endif + // } -RE2::~RE2() { - if (suffix_regexp_) - // suffix_regexp_->Decref(); - if (entire_regexp_) - // entire_regexp_->Decref(); - // delete prog_; - // delete rprog_; - if (error_ != empty_string) - delete error_; - if (named_groups_ != NULL && named_groups_ != empty_named_groups) - delete named_groups_; - if (group_names_ != NULL && group_names_ != empty_group_names) - delete group_names_; -} + // static int Fanout(Prog* prog, std::vector* histogram) { + // SparseArray fanout(prog->size()); + // prog->Fanout(&fanout); + // int data[32] = {}; + // int size = 0; + // for (SparseArray::iterator i = fanout.begin(); i != fanout.end(); ++i) { + // if (i->value() == 0) + // continue; + // uint32_t value = i->value(); + // int bucket = FindMSBSet(value); + // bucket += value & (value-1) ? 1 : 0; + // ++data[bucket]; + // size = std::max(size, bucket+1); + // } + // if (histogram != NULL) + // histogram->assign(data, data+size); + // return size-1; + // } -int RE2::ProgramSize() const { - // if (prog_ == NULL) - // return -1; - // return prog_->size(); - return 0; -} + int RE2::ProgramFanout(std::vector *histogram) const + { + // if (prog_ == NULL) + // return -1; + // return Fanout(prog_, histogram); + return 0; + } -int RE2::ReverseProgramSize() const { - // if (prog_ == NULL) - // return -1; - // Prog* prog = ReverseProg(); - // if (prog == NULL) - // return -1; - // return prog->size(); - return 0; -} + int RE2::ReverseProgramFanout(std::vector *histogram) const + { + // if (prog_ == NULL) + // return -1; + // Prog* prog = ReverseProg(); + // if (prog == NULL) + // return -1; + // return Fanout(prog, histogram); + return 0; + } -// // Finds the most significant non-zero bit in n. -// static int FindMSBSet(uint32_t n) { -// DCHECK_NE(n, 0); -// #if defined(__GNUC__) -// return 31 ^ __builtin_clz(n); -// #elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86)) -// unsigned long c; -// _BitScanReverse(&c, n); -// return static_cast(c); -// #else -// int c = 0; -// for (int shift = 1 << 4; shift != 0; shift >>= 1) { -// uint32_t word = n >> shift; -// if (word != 0) { -// n = word; -// c += shift; -// } -// } -// return c; -// #endif -// } - -// static int Fanout(Prog* prog, std::vector* histogram) { -// SparseArray fanout(prog->size()); -// prog->Fanout(&fanout); -// int data[32] = {}; -// int size = 0; -// for (SparseArray::iterator i = fanout.begin(); i != fanout.end(); ++i) { -// if (i->value() == 0) -// continue; -// uint32_t value = i->value(); -// int bucket = FindMSBSet(value); -// bucket += value & (value-1) ? 1 : 0; -// ++data[bucket]; -// size = std::max(size, bucket+1); -// } -// if (histogram != NULL) -// histogram->assign(data, data+size); -// return size-1; -// } - -int RE2::ProgramFanout(std::vector* histogram) const { - // if (prog_ == NULL) - // return -1; - // return Fanout(prog_, histogram); - return 0; -} + // Returns named_groups_, computing it if needed. + const std::map &RE2::NamedCapturingGroups() const + { + std::map *temp = new std::map; + std::string str; + char *name; + int i = 0; + rure_iter_capture_names *it = rure_iter_capture_names_new((rure *)prog_); + while (rure_iter_capture_names_next(it, &name)) + { + str = name; + if (str.length() != 0) + temp->insert(make_pair(str, i)); + ++i; + } + named_groups_ = temp; -int RE2::ReverseProgramFanout(std::vector* histogram) const { - // if (prog_ == NULL) - // return -1; - // Prog* prog = ReverseProg(); - // if (prog == NULL) - // return -1; - // return Fanout(prog, histogram); - return 0; -} + return *named_groups_; + } -// Returns named_groups_, computing it if needed. -const std::map& RE2::NamedCapturingGroups() const { - std::map *temp = new std::map; - std::string str; - char *name; - int i = 0; - rure_iter_capture_names *it = rure_iter_capture_names_new((rure *)prog_); - while (rure_iter_capture_names_next(it, &name)) + // Returns group_names_, computing it if needed. + const std::map &RE2::CapturingGroupNames() const { - str = name; - if(str.length()!=0) - temp->insert(make_pair(str, i)); - ++i; + std::map *temp = new std::map; + std::string str; + char *name; + int i = 0; + rure_iter_capture_names *it = rure_iter_capture_names_new((rure *)prog_); + while (rure_iter_capture_names_next(it, &name)) + { + str = name; + if (str.length() != 0) + temp->insert(make_pair(i, str)); + ++i; + } + group_names_ = temp; + + return *group_names_; } - named_groups_ = temp; - return *named_groups_; -} + /***** Convenience interfaces *****/ -// Returns group_names_, computing it if needed. -const std::map& RE2::CapturingGroupNames() const { - std::map *temp = new std::map; - std::string str; - char *name; - int i = 0; - rure_iter_capture_names *it = rure_iter_capture_names_new((rure *)prog_); - while (rure_iter_capture_names_next(it, &name)) + bool RE2::FullMatchN(const StringPiece &text, const RE2 &re, + const Arg *const args[], int n) { - str = name; - if(str.length()!=0) - temp->insert(make_pair(i, str)); - ++i; + return re.DoMatch(text, ANCHOR_BOTH, NULL, args, n); } - group_names_ = temp; - - return *group_names_; -} -/***** Convenience interfaces *****/ + bool RE2::PartialMatchN(const StringPiece &text, const RE2 &re, + const Arg *const args[], int n) + { + return re.DoMatch(text, UNANCHORED, NULL, args, n); + } -bool RE2::FullMatchN(const StringPiece& text, const RE2& re, - const Arg* const args[], int n) { - return re.DoMatch(text, ANCHOR_BOTH, NULL, args, n); -} + bool RE2::ConsumeN(StringPiece *input, const RE2 &re, + const Arg *const args[], int n) + { + size_t consumed; + if (re.DoMatch(*input, ANCHOR_START, &consumed, args, n)) + { + input->remove_prefix(consumed); + return true; + } + else + { + return false; + } + } -bool RE2::PartialMatchN(const StringPiece& text, const RE2& re, - const Arg* const args[], int n) { - return re.DoMatch(text, UNANCHORED, NULL, args, n); -} + bool RE2::FindAndConsumeN(StringPiece *input, const RE2 &re, + const Arg *const args[], int n) + { + size_t consumed; + if (re.DoMatch(*input, UNANCHORED, &consumed, args, n)) + { + input->remove_prefix(consumed); + return true; + } + else + { + return false; + } + } -bool RE2::ConsumeN(StringPiece* input, const RE2& re, - const Arg* const args[], int n) { - size_t consumed; - if (re.DoMatch(*input, ANCHOR_START, &consumed, args, n)) { - input->remove_prefix(consumed); - return true; - } else { - return false; + // 处理Rewrite 将所有的 //number 转换为 ${number} + std::string rewrite_re2_to_rure(re2::StringPiece rewrite) + { + std::string rure_rewrite; + for (const char *s = rewrite.data(), *end = s + rewrite.size(); + s < end; s++) + { + if (*s != '\\') + { + rure_rewrite.push_back(*s); + continue; + } + s++; + int c = (s < end) ? *s : -1; + if (isdigit(c)) + { + rure_rewrite.append("${"); + rure_rewrite.push_back(c); + rure_rewrite.push_back('}'); + } + } + return rure_rewrite; } -} -bool RE2::FindAndConsumeN(StringPiece* input, const RE2& re, - const Arg* const args[], int n) { - size_t consumed; - if (re.DoMatch(*input, UNANCHORED, &consumed, args, n)) { - input->remove_prefix(consumed); + bool RE2::Replace(std::string *str, + const RE2 &re, + const StringPiece &rewrite) + { + + StringPiece vec[kVecSize]; + int nvec = 1 + MaxSubmatch(rewrite); + if (nvec > 1 + re.NumberOfCapturingGroups()) + return false; + if (nvec > static_cast(arraysize(vec))) + return false; + if (!re.Match(*str, 0, str->size(), UNANCHORED, vec, nvec)) + return false; + + std::string s; + if (!re.Rewrite(&s, rewrite, vec, nvec)) + return false; + + // 利用rure进行replace + const char *rure_str = re.pattern_.c_str(); + + // 对rewrite进行处理 + const char *rure_rewrite = rewrite_re2_to_rure(rewrite).c_str(); + + rure *re_rure = rure_compile((const uint8_t *)rure_str, strlen(rure_str), RURE_DEFAULT_FLAGS, NULL, NULL); + + const char *str_rure = rure_replace(re_rure, (const uint8_t *)str->c_str(), strlen(str->c_str()), + (const uint8_t *)rure_rewrite, strlen(rure_rewrite)); + + // assert(vec[0].data() >= str->data()); + // assert(vec[0].data() + vec[0].size() <= str->data() + str->size()); + // str->replace(vec[0].data() - str->data(), vec[0].size(), str_rure); + *str = str_rure; + return true; - } else { - return false; } -} -bool RE2::Replace(std::string* str, - const RE2& re, - const StringPiece& rewrite) { - StringPiece vec[kVecSize]; - int nvec = 1 + MaxSubmatch(rewrite); - if (nvec > 1 + re.NumberOfCapturingGroups()) - return false; - if (nvec > static_cast(arraysize(vec))) - return false; - if (!re.Match(*str, 0, str->size(), UNANCHORED, vec, nvec)) - return false; - - std::string s; - if (!re.Rewrite(&s, rewrite, vec, nvec)) - return false; - - assert(vec[0].data() >= str->data()); - assert(vec[0].data() + vec[0].size() <= str->data() + str->size()); - str->replace(vec[0].data() - str->data(), vec[0].size(), s); - return true; -} + int RE2::GlobalReplace(std::string *str, + const RE2 &re, + const StringPiece &rewrite) + { + // StringPiece vec[kVecSize]; + // int nvec = 1 + MaxSubmatch(rewrite); + // if (nvec > 1 + re.NumberOfCapturingGroups()) + // return false; + // if (nvec > static_cast(arraysize(vec))) + // return false; + + // const char* p = str->data(); + // const char* ep = p + str->size(); + // const char* lastend = NULL; + // std::string out; + // int count = 0; + // #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION + // // Iterate just once when fuzzing. Otherwise, we easily get bogged down + // // and coverage is unlikely to improve despite significant expense. + // while (p == str->data()) { + // #else + // while (p <= ep) { + // #endif + // if (!re.Match(*str, static_cast(p - str->data()), + // str->size(), UNANCHORED, vec, nvec)) + // break; + // if (p < vec[0].data()) + // out.append(p, vec[0].data() - p); + // if (vec[0].data() == lastend && vec[0].empty()) { + // // Disallow empty match at end of last match: skip ahead. + // // + // // fullrune() takes int, not ptrdiff_t. However, it just looks + // // at the leading byte and treats any length >= 4 the same. + // if (re.options().encoding() == RE2::Options::EncodingUTF8 && + // fullrune(p, static_cast(std::min(ptrdiff_t{4}, ep - p)))) { + // // re is in UTF-8 mode and there is enough left of str + // // to allow us to advance by up to UTFmax bytes. + // Rune r; + // int n = chartorune(&r, p); + // // Some copies of chartorune have a bug that accepts + // // encodings of values in (10FFFF, 1FFFFF] as valid. + // if (r > Runemax) { + // n = 1; + // r = Runeerror; + // } + // if (!(n == 1 && r == Runeerror)) { // no decoding error + // out.append(p, n); + // p += n; + // continue; + // } + // } + // // Most likely, re is in Latin-1 mode. If it is in UTF-8 mode, + // // we fell through from above and the GIGO principle applies. + // if (p < ep) + // out.append(p, 1); + // p++; + // continue; + // } + // re.Rewrite(&out, rewrite, vec, nvec); + // p = vec[0].data() + vec[0].size(); + // lastend = p; + // count++; + // } + + // if (count == 0) + // return 0; + + // if (p < ep) + // out.append(p, ep - p); + // using std::swap; + // swap(out, *str); + // return count; + return 0; + } -int RE2::GlobalReplace(std::string* str, - const RE2& re, - const StringPiece& rewrite) { -// StringPiece vec[kVecSize]; -// int nvec = 1 + MaxSubmatch(rewrite); -// if (nvec > 1 + re.NumberOfCapturingGroups()) -// return false; -// if (nvec > static_cast(arraysize(vec))) -// return false; - -// const char* p = str->data(); -// const char* ep = p + str->size(); -// const char* lastend = NULL; -// std::string out; -// int count = 0; -// #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -// // Iterate just once when fuzzing. Otherwise, we easily get bogged down -// // and coverage is unlikely to improve despite significant expense. -// while (p == str->data()) { -// #else -// while (p <= ep) { -// #endif -// if (!re.Match(*str, static_cast(p - str->data()), -// str->size(), UNANCHORED, vec, nvec)) -// break; -// if (p < vec[0].data()) -// out.append(p, vec[0].data() - p); -// if (vec[0].data() == lastend && vec[0].empty()) { -// // Disallow empty match at end of last match: skip ahead. -// // -// // fullrune() takes int, not ptrdiff_t. However, it just looks -// // at the leading byte and treats any length >= 4 the same. -// if (re.options().encoding() == RE2::Options::EncodingUTF8 && -// fullrune(p, static_cast(std::min(ptrdiff_t{4}, ep - p)))) { -// // re is in UTF-8 mode and there is enough left of str -// // to allow us to advance by up to UTFmax bytes. -// Rune r; -// int n = chartorune(&r, p); -// // Some copies of chartorune have a bug that accepts -// // encodings of values in (10FFFF, 1FFFFF] as valid. -// if (r > Runemax) { -// n = 1; -// r = Runeerror; -// } -// if (!(n == 1 && r == Runeerror)) { // no decoding error -// out.append(p, n); -// p += n; -// continue; -// } -// } -// // Most likely, re is in Latin-1 mode. If it is in UTF-8 mode, -// // we fell through from above and the GIGO principle applies. -// if (p < ep) -// out.append(p, 1); -// p++; -// continue; -// } -// re.Rewrite(&out, rewrite, vec, nvec); -// p = vec[0].data() + vec[0].size(); -// lastend = p; -// count++; -// } - -// if (count == 0) -// return 0; - -// if (p < ep) -// out.append(p, ep - p); -// using std::swap; -// swap(out, *str); -// return count; - return 0; -} + bool RE2::Extract(const StringPiece &text, + const RE2 &re, + const StringPiece &rewrite, + std::string *out) + { + StringPiece vec[kVecSize]; + int nvec = 1 + MaxSubmatch(rewrite); + if (nvec > 1 + re.NumberOfCapturingGroups()) + return false; + if (nvec > static_cast(arraysize(vec))) + return false; + if (!re.Match(text, 0, text.size(), UNANCHORED, vec, nvec)) + return false; -bool RE2::Extract(const StringPiece& text, - const RE2& re, - const StringPiece& rewrite, - std::string* out) { - StringPiece vec[kVecSize]; - int nvec = 1 + MaxSubmatch(rewrite); - if (nvec > 1 + re.NumberOfCapturingGroups()) - return false; - if (nvec > static_cast(arraysize(vec))) - return false; - if (!re.Match(text, 0, text.size(), UNANCHORED, vec, nvec)) - return false; - - out->clear(); - return re.Rewrite(out, rewrite, vec, nvec); -} + out->clear(); + return re.Rewrite(out, rewrite, vec, nvec); + } -std::string RE2::QuoteMeta(const StringPiece& unquoted) { - std::string result; - result.reserve(unquoted.size() << 1); - - // Escape any ascii character not in [A-Za-z_0-9]. - // - // Note that it's legal to escape a character even if it has no - // special meaning in a regular expression -- so this function does - // that. (This also makes it identical to the perl function of the - // same name except for the null-character special case; - // see `perldoc -f quotemeta`.) - for (size_t ii = 0; ii < unquoted.size(); ++ii) { - // Note that using 'isalnum' here raises the benchmark time from - // 32ns to 58ns: - if ((unquoted[ii] < 'a' || unquoted[ii] > 'z') && - (unquoted[ii] < 'A' || unquoted[ii] > 'Z') && - (unquoted[ii] < '0' || unquoted[ii] > '9') && - unquoted[ii] != '_' && unquoted[ii] != '!' && - unquoted[ii] != ' ' && unquoted[ii] != '\''&& - unquoted[ii] != '=' && - // If this is the part of a UTF8 or Latin1 character, we need - // to copy this byte without escaping. Experimentally this is - // what works correctly with the regexp library. - !(unquoted[ii] & 128)) { - if (unquoted[ii] == '\0') { // Special handling for null chars. - // Note that this special handling is not strictly required for RE2, - // but this quoting is required for other regexp libraries such as - // PCRE. - // Can't use "\\0" since the next character might be a digit. - result += "\\x00"; - continue; + std::string RE2::QuoteMeta(const StringPiece &unquoted) + { + std::string result; + result.reserve(unquoted.size() << 1); + + // Escape any ascii character not in [A-Za-z_0-9]. + // + // Note that it's legal to escape a character even if it has no + // special meaning in a regular expression -- so this function does + // that. (This also makes it identical to the perl function of the + // same name except for the null-character special case; + // see `perldoc -f quotemeta`.) + for (size_t ii = 0; ii < unquoted.size(); ++ii) + { + // Note that using 'isalnum' here raises the benchmark time from + // 32ns to 58ns: + if ((unquoted[ii] < 'a' || unquoted[ii] > 'z') && + (unquoted[ii] < 'A' || unquoted[ii] > 'Z') && + (unquoted[ii] < '0' || unquoted[ii] > '9') && + unquoted[ii] != '_' && unquoted[ii] != '!' && + unquoted[ii] != ' ' && unquoted[ii] != '\'' && + unquoted[ii] != '=' && + // If this is the part of a UTF8 or Latin1 character, we need + // to copy this byte without escaping. Experimentally this is + // what works correctly with the regexp library. + !(unquoted[ii] & 128)) + { + if (unquoted[ii] == '\0') + { // Special handling for null chars. + // Note that this special handling is not strictly required for RE2, + // but this quoting is required for other regexp libraries such as + // PCRE. + // Can't use "\\0" since the next character might be a digit. + result += "\\x00"; + continue; + } + result += '\\'; } - result += '\\'; + result += unquoted[ii]; } - result += unquoted[ii]; + + return result; } - return result; -} + bool RE2::PossibleMatchRange(std::string *min, std::string *max, + int maxlen) const + { + // if (prog_ == NULL) + // return false; + + // int n = static_cast(prefix_.size()); + // if (n > maxlen) + // n = maxlen; + + // // Determine initial min max from prefix_ literal. + // *min = prefix_.substr(0, n); + // *max = prefix_.substr(0, n); + // if (prefix_foldcase_) { + // // prefix is ASCII lowercase; change *min to uppercase. + // for (int i = 0; i < n; i++) { + // char& c = (*min)[i]; + // if ('a' <= c && c <= 'z') + // c += 'A' - 'a'; + // } + // } -bool RE2::PossibleMatchRange(std::string* min, std::string* max, - int maxlen) const { - // if (prog_ == NULL) - // return false; - - // int n = static_cast(prefix_.size()); - // if (n > maxlen) - // n = maxlen; - - // // Determine initial min max from prefix_ literal. - // *min = prefix_.substr(0, n); - // *max = prefix_.substr(0, n); - // if (prefix_foldcase_) { - // // prefix is ASCII lowercase; change *min to uppercase. - // for (int i = 0; i < n; i++) { - // char& c = (*min)[i]; - // if ('a' <= c && c <= 'z') - // c += 'A' - 'a'; - // } - // } + // // Add to prefix min max using PossibleMatchRange on regexp. + // std::string dmin, dmax; + // maxlen -= n; + // if (maxlen > 0 && prog_->PossibleMatchRange(&dmin, &dmax, maxlen)) { + // min->append(dmin); + // max->append(dmax); + // } else if (!max->empty()) { + // // prog_->PossibleMatchRange has failed us, + // // but we still have useful information from prefix_. + // // Round up *max to allow any possible suffix. + // PrefixSuccessor(max); + // } else { + // // Nothing useful. + // *min = ""; + // *max = ""; + // return false; + // } - // // Add to prefix min max using PossibleMatchRange on regexp. - // std::string dmin, dmax; - // maxlen -= n; - // if (maxlen > 0 && prog_->PossibleMatchRange(&dmin, &dmax, maxlen)) { - // min->append(dmin); - // max->append(dmax); - // } else if (!max->empty()) { - // // prog_->PossibleMatchRange has failed us, - // // but we still have useful information from prefix_. - // // Round up *max to allow any possible suffix. - // PrefixSuccessor(max); - // } else { - // // Nothing useful. - // *min = ""; - // *max = ""; - // return false; - // } + return true; + } - return true; -} + // // Avoid possible locale nonsense in standard strcasecmp. + // // The string a is known to be all lowercase. + // static int ascii_strcasecmp(const char* a, const char* b, size_t len) { + // const char* ae = a + len; + + // for (; a < ae; a++, b++) { + // uint8_t x = *a; + // uint8_t y = *b; + // if ('A' <= y && y <= 'Z') + // y += 'a' - 'A'; + // if (x != y) + // return x - y; + // } + // return 0; + // } -// // Avoid possible locale nonsense in standard strcasecmp. -// // The string a is known to be all lowercase. -// static int ascii_strcasecmp(const char* a, const char* b, size_t len) { -// const char* ae = a + len; - -// for (; a < ae; a++, b++) { -// uint8_t x = *a; -// uint8_t y = *b; -// if ('A' <= y && y <= 'Z') -// y += 'a' - 'A'; -// if (x != y) -// return x - y; -// } -// return 0; -// } - - -/***** Actual matching and rewriting code *****/ - -bool RE2::Match(const StringPiece& text, - size_t startpos, - size_t endpos, - Anchor re_anchor, - StringPiece* submatch, - int nsubmatch) const { - - if (!ok()) { - if (options_.log_errors()) - LOG(ERROR) << "Invalid RE2: " << *error_; - return false; - } + /***** Actual matching and rewriting code *****/ - if (startpos > endpos || endpos > text.size()) { - if (options_.log_errors()) - LOG(ERROR) << "RE2: invalid startpos, endpos pair. [" - << "startpos: " << startpos << ", " - << "endpos: " << endpos << ", " - << "text size: " << text.size() << "]"; - return false; - } + bool RE2::Match(const StringPiece &text, + size_t startpos, + size_t endpos, + Anchor re_anchor, + StringPiece *submatch, + int nsubmatch) const + { - const char *haystack = text.data(); - rure *re = (rure*)prog_; - rure_match match = {0}; - bool matched = rure_find(re, (const uint8_t *)haystack, strlen(haystack),0, &match); + if (!ok()) + { + if (options_.log_errors()) + LOG(ERROR) << "Invalid RE2: " << *error_; + return false; + } + if (startpos > endpos || endpos > text.size()) + { + if (options_.log_errors()) + LOG(ERROR) << "RE2: invalid startpos, endpos pair. [" + << "startpos: " << startpos << ", " + << "endpos: " << endpos << ", " + << "text size: " << text.size() << "]"; + return false; + } + const char *haystack = text.data(); + rure *re = (rure *)prog_; + rure_match match = {0}; + bool matched = rure_find(re, (const uint8_t *)haystack, strlen(haystack), 0, &match); - switch (re_anchor){ + switch (re_anchor) + { // ANCHOR_BOTH FullMatch - case ANCHOR_BOTH:{ + case ANCHOR_BOTH: + { // 是否是FullMatch - if(nsubmatch != 0){ + if (nsubmatch != 0) + { - if(!matched){ + if (!matched) + { return false; } - else{ - if(match.start != 0 || match.end != strlen(haystack)){ + else + { + if (match.start != 0 || match.end != strlen(haystack)) + { return false; } } } - else{ - if(matched && match.start == startpos && match.end == endpos){ + else + { + if (matched && match.start == startpos && match.end == endpos) + { return true; } - else{ + else + { return false; } } @@ -694,186 +776,199 @@ bool RE2::Match(const StringPiece& text, // UNANCHORED PartialMatch case UNANCHORED: { - if(nsubmatch != 0){ - if(!matched){ + if (nsubmatch != 0) + { + if (!matched) + { return false; } } - else{ - if(matched && match.end != 0) return true; - else return false; + else + { + if (matched && match.end != 0) + return true; + else + return false; } break; - } case ANCHOR_START: { - if(nsubmatch == 0){ - if(matched && match.start == startpos) return true; - else return false; + if (nsubmatch == 0) + { + if (matched && match.start == startpos) + return true; + else + return false; } - else{ - if(!matched) return false; + else + { + if (!matched) + return false; } } - } - - // Demo 获取捕获组内容，存储到submatch数组中 + } - size_t length = strlen(haystack); + // Demo 获取捕获组内容，存储到submatch数组中 - rure_captures *caps = rure_captures_new(re); - rure_find_captures(re, (const uint8_t *)haystack, - length, 0, caps); - size_t captures_len = num_captures_ + 1; + size_t length = strlen(haystack); - rure_captures_at(caps, 0, &match); - if(re_anchor==ANCHOR_START && match.start!=0) return false; + rure_captures *caps = rure_captures_new(re); + rure_find_captures(re, (const uint8_t *)haystack, + length, 0, caps); + size_t captures_len = num_captures_ + 1; - for (size_t i = 0; i < captures_len; i++) - { - bool result = rure_captures_at(caps, i, &match); - if (result) - { - size_t start = match.start; - size_t end = match.end; - size_t len = end - start; - - submatch[i] = StringPiece(text.data()+start,static_cast(len)); - // std::cout << "i=" << i << ", start=" << start << ", submatch=" << submatch[i] << endl; - } - else + rure_captures_at(caps, 0, &match); + if (re_anchor == ANCHOR_START && match.start != 0) + return false; + + for (size_t i = 0; i < captures_len; i++) { - submatch[i] = StringPiece(); - } - } + bool result = rure_captures_at(caps, i, &match); + if (result) + { + size_t start = match.start; + size_t end = match.end; + size_t len = end - start; + submatch[i] = StringPiece(text.data() + start, static_cast(len)); + // std::cout << "i=" << i << ", start=" << start << ", submatch=" << submatch[i] << endl; + } + else + { + submatch[i] = StringPiece(); + } + } - return true; -} + return true; + } -// std::string_view in MSVC has iterators that aren't just pointers and -// that don't allow comparisons between different objects - not even if -// those objects are views into the same string! Thus, we provide these -// conversion functions for convenience. -static inline const char* BeginPtr(const StringPiece& s) { - return s.data(); -} -static inline const char* EndPtr(const StringPiece& s) { - return s.data() + s.size(); -} + // std::string_view in MSVC has iterators that aren't just pointers and + // that don't allow comparisons between different objects - not even if + // those objects are views into the same string! Thus, we provide these + // conversion functions for convenience. + static inline const char *BeginPtr(const StringPiece &s) + { + return s.data(); + } + static inline const char *EndPtr(const StringPiece &s) + { + return s.data() + s.size(); + } -// Internal matcher - like Match() but takes Args not StringPieces. -bool RE2::DoMatch(const StringPiece& text, - Anchor re_anchor, - size_t* consumed, - const Arg* const* args, - int n) const { + // Internal matcher - like Match() but takes Args not StringPieces. + bool RE2::DoMatch(const StringPiece &text, + Anchor re_anchor, + size_t *consumed, + const Arg *const *args, + int n) const + { // re是否成功创建 - if (!ok()){ + if (!ok()) + { if (options_.log_errors()) LOG(ERROR) << "Invalid RE2: " << *error_; return false; } // re的捕获组数目小于给定数目，返回flase - if (NumberOfCapturingGroups() < n){ + if (NumberOfCapturingGroups() < n) + { // RE has fewer capturing groups than number of Arg pointers passed in. return false; } - + // 判断是否FullMatch, 判空 const char *haystack; - if(text.data() == NULL || text[0] == '\0'){ + if (text.data() == NULL || text[0] == '\0') + { haystack = ""; } - else{ + else + { haystack = text.data(); } - // Latin-1编码转换 - if(options_.encoding() == 2){ + if (options_.encoding() == 2) + { // std::cout << "DoMatch-Latin-1\n"; haystack = encodingLatin1ToUTF8(text.as_string()).c_str(); - } - - - - rure *re = (rure*)prog_; + } + + rure *re = (rure *)prog_; rure_match match = {0}; - bool matched = rure_find(re, (const uint8_t *)haystack, strlen(haystack),0, &match); + bool matched = rure_find(re, (const uint8_t *)haystack, strlen(haystack), 0, &match); // Count number of capture groups needed. int nvec; if (n == 0 && consumed == NULL) - nvec = 0; //0个捕获组 + nvec = 0; // 0个捕获组 else nvec = n + 1; // 0个捕获组的匹配判断 - if(nvec==0) + if (nvec == 0) { - switch(re_anchor) + switch (re_anchor) + { + // ANCHOR_BOTH FullMatch + case ANCHOR_BOTH: { - // ANCHOR_BOTH FullMatch - case ANCHOR_BOTH: + if (!matched) { - if(!matched) - { - return false; - } - else - { - if(match.start == 0 && match.end == strlen(haystack)) - { - // std::cout << "DoMatch : 0个捕获组, FullMatch成功!!\n"; - return true; - } - else - { - // std::cout << "位置不对\n"; - return false; - } - } - - break; + return false; } - // ANCHOR_START - case ANCHOR_START: + else { - if(!matched) + if (match.start == 0 && match.end == strlen(haystack)) { - return false; + // std::cout << "DoMatch : 0个捕获组, FullMatch成功!!\n"; + return true; } else { - if(match.start == 0) - { - return true; - } - else - { - // std::cout << "位置不对\n"; - return false; - } + // std::cout << "位置不对\n"; + return false; } - break; - } - // UNANCHORED PartialMatch - case UNANCHORED: + break; + } + // ANCHOR_START + case ANCHOR_START: + { + if (!matched) + { + return false; + } + else { - if(!matched) + if (match.start == 0) { - return false; + return true; } else { - return true; + // std::cout << "位置不对\n"; + return false; } + } + break; + } - break; + // UNANCHORED PartialMatch + case UNANCHORED: + { + if (!matched) + { + return false; + } + else + { + return true; } + + break; + } } } @@ -895,21 +990,19 @@ bool RE2::DoMatch(const StringPiece& text, // 存在捕获组的判断 // 匹配失败，返回false - // startpos endpos + // startpos endpos // vec 用于存放捕获到的数据 // nvec 表示需要捕获的数据的个数 //此处在改写的时候先不进行任何处理，直接使用之前的Match函数，完成之后在对Match进行改写 if (!Match(text, 0, text.size(), re_anchor, vec, nvec)) { - + // std::cout << "DoMatch : Match 带参 未匹配"; delete[] heapvec; return false; } - - // 为consume赋值，consume的 if (consumed != NULL) *consumed = static_cast(EndPtr(vec[0]) - BeginPtr(text)); @@ -925,14 +1018,13 @@ bool RE2::DoMatch(const StringPiece& text, // return true; // } - // If we got here, we must have matched the whole pattern. for (int i = 0; i < n; i++) { // cout << vec[i].data() << endl; const StringPiece &s = vec[i + 1]; // std::cout << s.data() << "-" << s.size() <Parse(s.data(), s.size())) { // TODO: Should we indicate what the error was? @@ -944,392 +1036,483 @@ bool RE2::DoMatch(const StringPiece& text, delete[] heapvec; return true; -} + } -// Checks that the rewrite string is well-formed with respect to this -// regular expression. -bool RE2::CheckRewriteString(const StringPiece& rewrite, - std::string* error) const { - // int max_token = -1; - // for (const char *s = rewrite.data(), *end = s + rewrite.size(); - // s < end; s++) { - // int c = *s; - // if (c != '\\') { - // continue; - // } - // if (++s == end) { - // *error = "Rewrite schema error: '\\' not allowed at end."; - // return false; - // } - // c = *s; - // if (c == '\\') { - // continue; - // } - // if (!isdigit(c)) { - // *error = "Rewrite schema error: " - // "'\\' must be followed by a digit or '\\'."; - // return false; - // } - // int n = (c - '0'); - // if (max_token < n) { - // max_token = n; - // } - // } + // Checks that the rewrite string is well-formed with respect to this + // regular expression. + bool RE2::CheckRewriteString(const StringPiece &rewrite, + std::string *error) const + { + // int max_token = -1; + // for (const char *s = rewrite.data(), *end = s + rewrite.size(); + // s < end; s++) { + // int c = *s; + // if (c != '\\') { + // continue; + // } + // if (++s == end) { + // *error = "Rewrite schema error: '\\' not allowed at end."; + // return false; + // } + // c = *s; + // if (c == '\\') { + // continue; + // } + // if (!isdigit(c)) { + // *error = "Rewrite schema error: " + // "'\\' must be followed by a digit or '\\'."; + // return false; + // } + // int n = (c - '0'); + // if (max_token < n) { + // max_token = n; + // } + // } - // if (max_token > NumberOfCapturingGroups()) { - // *error = StringPrintf( - // "Rewrite schema requests %d matches, but the regexp only has %d " - // "parenthesized subexpressions.", - // max_token, NumberOfCapturingGroups()); - // return false; - // } - return true; -} + // if (max_token > NumberOfCapturingGroups()) { + // *error = StringPrintf( + // "Rewrite schema requests %d matches, but the regexp only has %d " + // "parenthesized subexpressions.", + // max_token, NumberOfCapturingGroups()); + // return false; + // } + return true; + } -// Returns the maximum submatch needed for the rewrite to be done by Replace(). -// E.g. if rewrite == "foo \\2,\\1", returns 2. -int RE2::MaxSubmatch(const StringPiece& rewrite) { - int max = 0; - for (const char *s = rewrite.data(), *end = s + rewrite.size(); - s < end; s++) { - if (*s == '\\') { - s++; - int c = (s < end) ? *s : -1; - if (isdigit(c)) { - int n = (c - '0'); - if (n > max) - max = n; + // Returns the maximum submatch needed for the rewrite to be done by Replace(). + // E.g. if rewrite == "foo \\2,\\1", returns 2. + int RE2::MaxSubmatch(const StringPiece &rewrite) + { + int max = 0; + for (const char *s = rewrite.data(), *end = s + rewrite.size(); + s < end; s++) + { + if (*s == '\\') + { + s++; + int c = (s < end) ? *s : -1; + if (isdigit(c)) + { + int n = (c - '0'); + if (n > max) + max = n; + } } } + return max; } - return max; -} -// Append the "rewrite" string, with backslash subsitutions from "vec", -// to string "out". -bool RE2::Rewrite(std::string* out, - const StringPiece& rewrite, - const StringPiece* vec, - int veclen) const { - for (const char *s = rewrite.data(), *end = s + rewrite.size(); - s < end; s++) { - if (*s != '\\') { - out->push_back(*s); - continue; - } - s++; - int c = (s < end) ? *s : -1; - if (isdigit(c)) { - int n = (c - '0'); - if (n >= veclen) { - if (options_.log_errors()) { - LOG(ERROR) << "invalid substitution \\" << n - << " from " << veclen << " groups"; + // Append the "rewrite" string, with backslash subsitutions from "vec", + // to string "out". + bool RE2::Rewrite(std::string *out, + const StringPiece &rewrite, + const StringPiece *vec, + int veclen) const + { + for (const char *s = rewrite.data(), *end = s + rewrite.size(); + s < end; s++) + { + if (*s != '\\') + { + out->push_back(*s); + continue; + } + s++; + int c = (s < end) ? *s : -1; + if (isdigit(c)) + { + int n = (c - '0'); + if (n >= veclen) + { + if (options_.log_errors()) + { + LOG(ERROR) << "invalid substitution \\" << n + << " from " << veclen << " groups"; + } + return false; } + StringPiece snip = vec[n]; + if (!snip.empty()) + out->append(snip.data(), snip.size()); + } + else if (c == '\\') + { + out->push_back('\\'); + } + else + { + if (options_.log_errors()) + LOG(ERROR) << "invalid rewrite pattern: " << rewrite.data(); return false; } - StringPiece snip = vec[n]; - if (!snip.empty()) - out->append(snip.data(), snip.size()); - } else if (c == '\\') { - out->push_back('\\'); - } else { - if (options_.log_errors()) - LOG(ERROR) << "invalid rewrite pattern: " << rewrite.data(); - return false; } + return true; } - return true; -} - -/***** Parsers for various types *****/ -namespace re2_internal { - -template <> -bool Parse(const char* str, size_t n, void* dest) { - // We fail if somebody asked us to store into a non-NULL void* pointer - return (dest == NULL); -} + /***** Parsers for various types *****/ -template <> -bool Parse(const char* str, size_t n, std::string* dest) { - if (dest == NULL) return true; - dest->assign(str, n); - return true; -} + namespace re2_internal + { -template <> -bool Parse(const char* str, size_t n, StringPiece* dest) { - if (dest == NULL) return true; - *dest = StringPiece(str, n); - return true; -} + template <> + bool Parse(const char *str, size_t n, void *dest) + { + // We fail if somebody asked us to store into a non-NULL void* pointer + return (dest == NULL); + } -template <> -bool Parse(const char* str, size_t n, char* dest) { - if (n != 1) return false; - if (dest == NULL) return true; - *dest = str[0]; - return true; -} + template <> + bool Parse(const char *str, size_t n, std::string *dest) + { + if (dest == NULL) + return true; + dest->assign(str, n); + return true; + } -template <> -bool Parse(const char* str, size_t n, signed char* dest) { - if (n != 1) return false; - if (dest == NULL) return true; - *dest = str[0]; - return true; -} + template <> + bool Parse(const char *str, size_t n, StringPiece *dest) + { + if (dest == NULL) + return true; + *dest = StringPiece(str, n); + return true; + } -template <> -bool Parse(const char* str, size_t n, unsigned char* dest) { - if (n != 1) return false; - if (dest == NULL) return true; - *dest = str[0]; - return true; -} + template <> + bool Parse(const char *str, size_t n, char *dest) + { + if (n != 1) + return false; + if (dest == NULL) + return true; + *dest = str[0]; + return true; + } -// Largest number spec that we are willing to parse -static const int kMaxNumberLength = 32; - -// REQUIRES "buf" must have length at least nbuf. -// Copies "str" into "buf" and null-terminates. -// Overwrites *np with the new length. -static const char* TerminateNumber(char* buf, size_t nbuf, const char* str, - size_t* np, bool accept_spaces) { - size_t n = *np; - if (n == 0) return ""; - if (n > 0 && isspace(*str)) { - // We are less forgiving than the strtoxxx() routines and do not - // allow leading spaces. We do allow leading spaces for floats. - if (!accept_spaces) { - return ""; + template <> + bool Parse(const char *str, size_t n, signed char *dest) + { + if (n != 1) + return false; + if (dest == NULL) + return true; + *dest = str[0]; + return true; } - while (n > 0 && isspace(*str)) { - n--; - str++; + + template <> + bool Parse(const char *str, size_t n, unsigned char *dest) + { + if (n != 1) + return false; + if (dest == NULL) + return true; + *dest = str[0]; + return true; } - } - // Although buf has a fixed maximum size, we can still handle - // arbitrarily large integers correctly by omitting leading zeros. - // (Numbers that are still too long will be out of range.) - // Before deciding whether str is too long, - // remove leading zeros with s/000+/00/. - // Leaving the leading two zeros in place means that - // we don't change 0000x123 (invalid) into 0x123 (valid). - // Skip over leading - before replacing. - bool neg = false; - if (n >= 1 && str[0] == '-') { - neg = true; - n--; - str++; - } + // Largest number spec that we are willing to parse + static const int kMaxNumberLength = 32; - if (n >= 3 && str[0] == '0' && str[1] == '0') { - while (n >= 3 && str[2] == '0') { - n--; - str++; - } - } + // REQUIRES "buf" must have length at least nbuf. + // Copies "str" into "buf" and null-terminates. + // Overwrites *np with the new length. + static const char *TerminateNumber(char *buf, size_t nbuf, const char *str, + size_t *np, bool accept_spaces) + { + size_t n = *np; + if (n == 0) + return ""; + if (n > 0 && isspace(*str)) + { + // We are less forgiving than the strtoxxx() routines and do not + // allow leading spaces. We do allow leading spaces for floats. + if (!accept_spaces) + { + return ""; + } + while (n > 0 && isspace(*str)) + { + n--; + str++; + } + } - if (neg) { // make room in buf for - - n++; - str--; - } + // Although buf has a fixed maximum size, we can still handle + // arbitrarily large integers correctly by omitting leading zeros. + // (Numbers that are still too long will be out of range.) + // Before deciding whether str is too long, + // remove leading zeros with s/000+/00/. + // Leaving the leading two zeros in place means that + // we don't change 0000x123 (invalid) into 0x123 (valid). + // Skip over leading - before replacing. + bool neg = false; + if (n >= 1 && str[0] == '-') + { + neg = true; + n--; + str++; + } - if (n > nbuf-1) return ""; + if (n >= 3 && str[0] == '0' && str[1] == '0') + { + while (n >= 3 && str[2] == '0') + { + n--; + str++; + } + } - memmove(buf, str, n); - if (neg) { - buf[0] = '-'; - } - buf[n] = '\0'; - *np = n; - return buf; -} + if (neg) + { // make room in buf for - + n++; + str--; + } -template <> -bool Parse(const char* str, size_t n, float* dest) { - if (n == 0) return false; - static const int kMaxLength = 200; - char buf[kMaxLength+1]; - str = TerminateNumber(buf, sizeof buf, str, &n, true); - char* end; - errno = 0; - float r = strtof(str, &end); - if (end != str + n) return false; // Leftover junk - if (errno) return false; - if (dest == NULL) return true; - *dest = r; - return true; -} + if (n > nbuf - 1) + return ""; -template <> -bool Parse(const char* str, size_t n, double* dest) { - if (n == 0) return false; - static const int kMaxLength = 200; - char buf[kMaxLength+1]; - str = TerminateNumber(buf, sizeof buf, str, &n, true); - char* end; - errno = 0; - double r = strtod(str, &end); - if (end != str + n) return false; // Leftover junk - if (errno) return false; - if (dest == NULL) return true; - *dest = r; - return true; -} + memmove(buf, str, n); + if (neg) + { + buf[0] = '-'; + } + buf[n] = '\0'; + *np = n; + return buf; + } -template <> -bool Parse(const char* str, size_t n, long* dest, int radix) { - if (n == 0) return false; - char buf[kMaxNumberLength+1]; - str = TerminateNumber(buf, sizeof buf, str, &n, false); - char* end; - errno = 0; - long r = strtol(str, &end, radix); - if (end != str + n) return false; // Leftover junk - if (errno) return false; - if (dest == NULL) return true; - *dest = r; - return true; -} + template <> + bool Parse(const char *str, size_t n, float *dest) + { + if (n == 0) + return false; + static const int kMaxLength = 200; + char buf[kMaxLength + 1]; + str = TerminateNumber(buf, sizeof buf, str, &n, true); + char *end; + errno = 0; + float r = strtof(str, &end); + if (end != str + n) + return false; // Leftover junk + if (errno) + return false; + if (dest == NULL) + return true; + *dest = r; + return true; + } -template <> -bool Parse(const char* str, size_t n, unsigned long* dest, int radix) { - if (n == 0) return false; - char buf[kMaxNumberLength+1]; - str = TerminateNumber(buf, sizeof buf, str, &n, false); - if (str[0] == '-') { - // strtoul() will silently accept negative numbers and parse - // them. This module is more strict and treats them as errors. - return false; - } + template <> + bool Parse(const char *str, size_t n, double *dest) + { + if (n == 0) + return false; + static const int kMaxLength = 200; + char buf[kMaxLength + 1]; + str = TerminateNumber(buf, sizeof buf, str, &n, true); + char *end; + errno = 0; + double r = strtod(str, &end); + if (end != str + n) + return false; // Leftover junk + if (errno) + return false; + if (dest == NULL) + return true; + *dest = r; + return true; + } - char* end; - errno = 0; - unsigned long r = strtoul(str, &end, radix); - if (end != str + n) return false; // Leftover junk - if (errno) return false; - if (dest == NULL) return true; - *dest = r; - return true; -} + template <> + bool Parse(const char *str, size_t n, long *dest, int radix) + { + if (n == 0) + return false; + char buf[kMaxNumberLength + 1]; + str = TerminateNumber(buf, sizeof buf, str, &n, false); + char *end; + errno = 0; + long r = strtol(str, &end, radix); + if (end != str + n) + return false; // Leftover junk + if (errno) + return false; + if (dest == NULL) + return true; + *dest = r; + return true; + } -template <> -bool Parse(const char* str, size_t n, short* dest, int radix) { - long r; - if (!Parse(str, n, &r, radix)) return false; // Could not parse - if ((short)r != r) return false; // Out of range - if (dest == NULL) return true; - *dest = (short)r; - return true; -} + template <> + bool Parse(const char *str, size_t n, unsigned long *dest, int radix) + { + if (n == 0) + return false; + char buf[kMaxNumberLength + 1]; + str = TerminateNumber(buf, sizeof buf, str, &n, false); + if (str[0] == '-') + { + // strtoul() will silently accept negative numbers and parse + // them. This module is more strict and treats them as errors. + return false; + } -template <> -bool Parse(const char* str, size_t n, unsigned short* dest, int radix) { - unsigned long r; - if (!Parse(str, n, &r, radix)) return false; // Could not parse - if ((unsigned short)r != r) return false; // Out of range - if (dest == NULL) return true; - *dest = (unsigned short)r; - return true; -} + char *end; + errno = 0; + unsigned long r = strtoul(str, &end, radix); + if (end != str + n) + return false; // Leftover junk + if (errno) + return false; + if (dest == NULL) + return true; + *dest = r; + return true; + } -template <> -bool Parse(const char* str, size_t n, int* dest, int radix) { - long r; - if (!Parse(str, n, &r, radix)) return false; // Could not parse - if ((int)r != r) return false; // Out of range - if (dest == NULL) return true; - *dest = (int)r; - return true; -} + template <> + bool Parse(const char *str, size_t n, short *dest, int radix) + { + long r; + if (!Parse(str, n, &r, radix)) + return false; // Could not parse + if ((short)r != r) + return false; // Out of range + if (dest == NULL) + return true; + *dest = (short)r; + return true; + } -template <> -bool Parse(const char* str, size_t n, unsigned int* dest, int radix) { - unsigned long r; - if (!Parse(str, n, &r, radix)) return false; // Could not parse - if ((unsigned int)r != r) return false; // Out of range - if (dest == NULL) return true; - *dest = (unsigned int)r; - return true; -} + template <> + bool Parse(const char *str, size_t n, unsigned short *dest, int radix) + { + unsigned long r; + if (!Parse(str, n, &r, radix)) + return false; // Could not parse + if ((unsigned short)r != r) + return false; // Out of range + if (dest == NULL) + return true; + *dest = (unsigned short)r; + return true; + } -template <> -bool Parse(const char* str, size_t n, long long* dest, int radix) { - if (n == 0) return false; - char buf[kMaxNumberLength+1]; - str = TerminateNumber(buf, sizeof buf, str, &n, false); - char* end; - errno = 0; - long long r = strtoll(str, &end, radix); - if (end != str + n) return false; // Leftover junk - if (errno) return false; - if (dest == NULL) return true; - *dest = r; - return true; -} + template <> + bool Parse(const char *str, size_t n, int *dest, int radix) + { + long r; + if (!Parse(str, n, &r, radix)) + return false; // Could not parse + if ((int)r != r) + return false; // Out of range + if (dest == NULL) + return true; + *dest = (int)r; + return true; + } -template <> -bool Parse(const char* str, size_t n, unsigned long long* dest, int radix) { - if (n == 0) return false; - char buf[kMaxNumberLength+1]; - str = TerminateNumber(buf, sizeof buf, str, &n, false); - if (str[0] == '-') { - // strtoull() will silently accept negative numbers and parse - // them. This module is more strict and treats them as errors. - return false; - } - char* end; - errno = 0; - unsigned long long r = strtoull(str, &end, radix); - if (end != str + n) return false; // Leftover junk - if (errno) return false; - if (dest == NULL) return true; - *dest = r; - return true; -} + template <> + bool Parse(const char *str, size_t n, unsigned int *dest, int radix) + { + unsigned long r; + if (!Parse(str, n, &r, radix)) + return false; // Could not parse + if ((unsigned int)r != r) + return false; // Out of range + if (dest == NULL) + return true; + *dest = (unsigned int)r; + return true; + } -} // namespace re2_internal + template <> + bool Parse(const char *str, size_t n, long long *dest, int radix) + { + if (n == 0) + return false; + char buf[kMaxNumberLength + 1]; + str = TerminateNumber(buf, sizeof buf, str, &n, false); + char *end; + errno = 0; + long long r = strtoll(str, &end, radix); + if (end != str + n) + return false; // Leftover junk + if (errno) + return false; + if (dest == NULL) + return true; + *dest = r; + return true; + } + + template <> + bool Parse(const char *str, size_t n, unsigned long long *dest, int radix) + { + if (n == 0) + return false; + char buf[kMaxNumberLength + 1]; + str = TerminateNumber(buf, sizeof buf, str, &n, false); + if (str[0] == '-') + { + // strtoull() will silently accept negative numbers and parse + // them. This module is more strict and treats them as errors. + return false; + } + char *end; + errno = 0; + unsigned long long r = strtoull(str, &end, radix); + if (end != str + n) + return false; // Leftover junk + if (errno) + return false; + if (dest == NULL) + return true; + *dest = r; + return true; + } -namespace hooks { + } // namespace re2_internal + + namespace hooks + { #ifdef RE2_HAVE_THREAD_LOCAL -thread_local const RE2* context = NULL; + thread_local const RE2 *context = NULL; #endif -template -union Hook { - void Store(T* cb) { cb_.store(cb, std::memory_order_release); } - T* Load() const { return cb_.load(std::memory_order_acquire); } + template + union Hook + { + void Store(T *cb) { cb_.store(cb, std::memory_order_release); } + T *Load() const { return cb_.load(std::memory_order_acquire); } #if !defined(__clang__) && defined(_MSC_VER) - // Citing https://github.com/protocolbuffers/protobuf/pull/4777 as precedent, - // this is a gross hack to make std::atomic constant-initialized on MSVC. - static_assert(ATOMIC_POINTER_LOCK_FREE == 2, - "std::atomic must be always lock-free"); - T* cb_for_constinit_; + // Citing https://github.com/protocolbuffers/protobuf/pull/4777 as precedent, + // this is a gross hack to make std::atomic constant-initialized on MSVC. + static_assert(ATOMIC_POINTER_LOCK_FREE == 2, + "std::atomic must be always lock-free"); + T *cb_for_constinit_; #endif - std::atomic cb_; -}; + std::atomic cb_; + }; -template -static void DoNothing(const T&) {} + template + static void DoNothing(const T &) {} #define DEFINE_HOOK(type, name) \ static Hook name##_hook = {{&DoNothing}}; \ - void Set##type##Hook(type##Callback* cb) { name##_hook.Store(cb); } \ - type##Callback* Get##type##Hook() { return name##_hook.Load(); } + void Set##type##Hook(type##Callback *cb) { name##_hook.Store(cb); } \ + type##Callback *Get##type##Hook() { return name##_hook.Load(); } -DEFINE_HOOK(DFAStateCacheReset, dfa_state_cache_reset) -DEFINE_HOOK(DFASearchFailure, dfa_search_failure) + DEFINE_HOOK(DFAStateCacheReset, dfa_state_cache_reset) + DEFINE_HOOK(DFASearchFailure, dfa_search_failure) #undef DEFINE_HOOK -} // namespace hooks + } // namespace hooks -} // namespace re2 +} // namespace re2 diff --git a/re2/testing/re2_test.cc b/re2/testing/re2_test.cc index 3ee20531e4f0b2f5d3900702d216e33c4a03b691..5459246bc3f1dfabb7d97c30f6e4461b392359a6 100644 --- a/re2/testing/re2_test.cc +++ b/re2/testing/re2_test.cc @@ -96,96 +96,96 @@ TEST(RE2, DecimalTests) { #undef ASSERT_DECIMAL } -// TEST(RE2, Replace) { -// struct ReplaceTest { -// const char *regexp; -// const char *rewrite; -// const char *original; -// const char *single; -// const char *global; -// int greplace_count; -// }; -// static const ReplaceTest tests[] = { -// { "(qu|[b-df-hj-np-tv-z]*)([a-z]+)", -// "\\2\\1ay", -// "the quick brown fox jumps over the lazy dogs.", -// "ethay quick brown fox jumps over the lazy dogs.", -// "ethay ickquay ownbray oxfay umpsjay overay ethay azylay ogsday.", -// 9 }, -// { "\\w+", -// "\\0-NOSPAM", -// "abcd.efghi@google.com", -// "abcd-NOSPAM.efghi@google.com", -// "abcd-NOSPAM.efghi-NOSPAM@google-NOSPAM.com-NOSPAM", -// 4 }, -// { "^", -// "(START)", -// "foo", -// "(START)foo", -// "(START)foo", -// 1 }, -// { "^", -// "(START)", -// "", -// "(START)", -// "(START)", -// 1 }, -// { "$", -// "(END)", -// "", -// "(END)", -// "(END)", -// 1 }, -// { "b", -// "bb", -// "ababababab", -// "abbabababab", -// "abbabbabbabbabb", -// 5 }, -// { "b", -// "bb", -// "bbbbbb", -// "bbbbbbb", -// "bbbbbbbbbbbb", -// 6 }, -// { "b+", -// "bb", -// "bbbbbb", -// "bb", -// "bb", -// 1 }, -// { "b*", -// "bb", -// "bbbbbb", -// "bb", -// "bb", -// 1 }, -// { "b*", -// "bb", -// "aaaaa", -// "bbaaaaa", -// "bbabbabbabbabbabb", -// 6 }, -// // Check newline handling -// { "a.*a", -// "(\\0)", -// "aba\naba", -// "(aba)\naba", -// "(aba)\n(aba)", -// 2 }, -// { "", NULL, NULL, NULL, NULL, 0 } -// }; +TEST(RE2, Replace) { + struct ReplaceTest { + const char *regexp; + const char *rewrite; + const char *original; + const char *single; + const char *global; + int greplace_count; + }; + static const ReplaceTest tests[] = { + { "(qu|[b-df-hj-np-tv-z]*)([a-z]+)", + "\\2\\1ay", + "the quick brown fox jumps over the lazy dogs.", + "ethay quick brown fox jumps over the lazy dogs.", + "ethay ickquay ownbray oxfay umpsjay overay ethay azylay ogsday.", + 9 }, + { "\\w+", + "\\0-NOSPAM", + "abcd.efghi@google.com", + "abcd-NOSPAM.efghi@google.com", + "abcd-NOSPAM.efghi-NOSPAM@google-NOSPAM.com-NOSPAM", + 4 }, + { "^", + "(START)", + "foo", + "(START)foo", + "(START)foo", + 1 }, + { "^", + "(START)", + "", + "(START)", + "(START)", + 1 }, + { "$", + "(END)", + "", + "(END)", + "(END)", + 1 }, + { "b", + "bb", + "ababababab", + "abbabababab", + "abbabbabbabbabb", + 5 }, + { "b", + "bb", + "bbbbbb", + "bbbbbbb", + "bbbbbbbbbbbb", + 6 }, + { "b+", + "bb", + "bbbbbb", + "bb", + "bb", + 1 }, + { "b*", + "bb", + "bbbbbb", + "bb", + "bb", + 1 }, + { "b*", + "bb", + "aaaaa", + "bbaaaaa", + "bbabbabbabbabbabb", + 6 }, + // Check newline handling + { "a.*a", + "(\\0)", + "aba\naba", + "(aba)\naba", + "(aba)\n(aba)", + 2 }, + { "", NULL, NULL, NULL, NULL, 0 } + }; -// for (const ReplaceTest* t = tests; t->original != NULL; t++) { -// std::string one(t->original); -// ASSERT_TRUE(RE2::Replace(&one, t->regexp, t->rewrite)); -// ASSERT_EQ(one, t->single); -// std::string all(t->original); -// ASSERT_EQ(RE2::GlobalReplace(&all, t->regexp, t->rewrite), t->greplace_count) -// << "Got: " << all; -// ASSERT_EQ(all, t->global); -// } -// } + for (const ReplaceTest* t = tests; t->original != NULL; t++) { + std::string one(t->original); + ASSERT_TRUE(RE2::Replace(&one, t->regexp, t->rewrite)); + ASSERT_EQ(one, t->single); + // std::string all(t->original); + // ASSERT_EQ(RE2::GlobalReplace(&all, t->regexp, t->rewrite), t->greplace_count) + // << "Got: " << all; + // ASSERT_EQ(all, t->global); + } +} // static void TestCheckRewriteString(const char* regexp, const char* rewrite, // bool expect_ok) { @@ -224,14 +224,14 @@ TEST(RE2, DecimalTests) { // ASSERT_EQ(s, "'foo'"); // } -// TEST(RE2, MaxSubmatchTooLarge) { -// std::string s; -// ASSERT_FALSE(RE2::Extract("foo", "f(o+)", "\\1\\2", &s)); -// s = "foo"; -// ASSERT_FALSE(RE2::Replace(&s, "f(o+)", "\\1\\2")); -// s = "foo"; -// ASSERT_FALSE(RE2::GlobalReplace(&s, "f(o+)", "\\1\\2")); -// } +TEST(RE2, MaxSubmatchTooLarge) { + std::string s; + // ASSERT_FALSE(RE2::Extract("foo", "f(o+)", "\\1\\2", &s)); + s = "foo"; + ASSERT_FALSE(RE2::Replace(&s, "f(o+)", "\\1\\2")); + // s = "foo"; + // ASSERT_FALSE(RE2::GlobalReplace(&s, "f(o+)", "\\1\\2")); +} TEST(RE2, Consume) { RE2 r("\\s*(\\w+)"); // matches a word, possibly proceeded by whitespace @@ -1215,8 +1215,7 @@ TEST(RE2, Recursion) { TEST(RE2, BigCountedRepetition) { // Test that counted repetition works, given tons of memory. RE2::Options opt; - opt.set_max_mem(256<<20); - + opt.set_max_mem(256 << 20); RE2 re(".{512}x", opt); ASSERT_TRUE(re.ok()); std::string s;