fix preg_replace function

Author: Shamzik

.idea/encodings.xml

@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <array>
+#include <concepts>
 #include <cstddef>
 #include <cstdint>
 #include <functional>
@@ -71,6 +72,10 @@ struct RegexInfo final {
         replacement(replacement_) {}
 };
 
+struct backref {
+  std::string_view digits;
+};
+
 template<typename... Args>
 requires((std::is_same_v<Args, int64_t> && ...) && sizeof...(Args) > 0)
 bool valid_regex_flags(int64_t flags, Args... supported_flags) noexcept {
@@ -102,6 +107,118 @@ int64_t skip_utf8_subsequent_bytes(int64_t offset, const std::string_view subjec
   return offset;
 }
 
+std::optional<backref> try_get_backref(std::string_view preg_replacement) noexcept {
+  if (preg_replacement.empty() || preg_replacement[0] < '0' || preg_replacement[0] > '9') {
+    return std::nullopt;
+  }
+
+  if (preg_replacement.size() == 1 || preg_replacement[1] < '0' || preg_replacement[1] > '9') {
+    return backref{preg_replacement.substr(0, 1)};
+  }
+
+  return backref{preg_replacement.substr(0, 2)};
+}
+
+template<typename T, typename F>
+requires std::convertible_to<std::invoke_result_t<F>, T>
+auto value_or_else(std::optional<T>&& opt, F&& alternative_func) noexcept -> T {
+  if (opt.has_value()) {
+    return std::move(*std::move(opt));
+  } else {
+    return std::forward<F>(alternative_func)();
+  }
+}
+
+using replacement_term = std::variant<char, backref>;
+
+class preg_replacement_unescaper {
+  std::string_view preg_replacement;
+
+public:
+  preg_replacement_unescaper(std::string_view preg_replacement)
+      : preg_replacement{preg_replacement} {}
+
+  bool has_next() const noexcept {
+    return !preg_replacement.empty();
+  }
+
+  replacement_term unescape_term() noexcept {
+    auto first_char{preg_replacement.front()};
+    preg_replacement = preg_replacement.substr(1);
+    if (preg_replacement.empty()) {
+      return first_char;
+    }
+    switch (first_char) {
+    case '$':
+      if (preg_replacement.front() == '{') {
+        return try_get_backref(preg_replacement.substr(1))
+            .and_then([this](auto value) noexcept -> std::optional<replacement_term> {
+              auto digits_end_pos = 1 + value.digits.size();
+              if (digits_end_pos < preg_replacement.size() && preg_replacement[digits_end_pos] == '}') {
+                preg_replacement = preg_replacement.substr(1 + value.digits.size() + 1);
+                return value;
+              }
+
+              return std::nullopt;
+            })
+            .value_or('$');
+      }
+
+      return try_get_backref(preg_replacement)
+          .transform([this](auto value) noexcept -> replacement_term {
+            auto digits_end_pos = value.digits.size();
+            preg_replacement = preg_replacement.substr(digits_end_pos);
+            return value;
+          })
+          .value_or('$');
+
+    case '\\':
+      return value_or_else(try_get_backref(preg_replacement).transform([this](auto value) noexcept -> replacement_term {
+        auto digits_end_pos = value.digits.size();
+        preg_replacement = preg_replacement.substr(digits_end_pos);
+        return value;
+      }),
+                           [this] noexcept {
+                             auto res{preg_replacement.front()};
+                             if (res == '$' || res == '\\') {
+                               preg_replacement = preg_replacement.substr(1);
+                               return res;
+                             }
+                             return '\\';
+                           });
+    default:
+      return first_char;
+    }
+  }
+};
+
+class pcre2_replacement_escaper {
+  kphp::stl::string<kphp::memory::script_allocator> pcre2_replacement{};
+
+public:
+  void operator()(char c) noexcept {
+    pcre2_replacement.push_back(c);
+    if (c == '$') {
+      pcre2_replacement.push_back('$');
+    }
+  }
+
+  void operator()(backref backreference) noexcept {
+    pcre2_replacement.reserve(pcre2_replacement.size() + backreference.digits.size() + 3);
+    pcre2_replacement.append("${");
+    pcre2_replacement.append(backreference.digits);
+    pcre2_replacement.append("}");
+  }
+
+  void escape_term(const replacement_term& term) noexcept {
+    std::visit(*this, term);
+  }
+
+  kphp::stl::string<kphp::memory::script_allocator>& result() noexcept {
+    return pcre2_replacement;
+  }
+};
+
 bool parse_regex(RegexInfo& regex_info) noexcept {
   if (regex_info.regex.empty()) {
     kphp::log::warning("empty regex");
@@ -591,21 +708,13 @@ Optional<string> f$preg_replace(const string& pattern, const string& replacement
     return {};
   }
 
-  string pcre2_replacement{replacement};
-  { // we need to replace PHP's back references with PCRE2 ones
-    static constexpr std::string_view backreference_pattern = R"(/\\(\d)/)";
-    static constexpr std::string_view backreference_replacement = "$$$1";
-
-    RegexInfo regex_info{backreference_pattern, {replacement.c_str(), replacement.size()}, backreference_replacement};
-    bool success{parse_regex(regex_info)};
-    success &= compile_regex(regex_info);
-    success &= replace_regex(regex_info, std::numeric_limits<uint64_t>::max());
-    if (!success) [[unlikely]] {
-      kphp::log::warning("can't replace PHP back references with PCRE2 ones");
-      return {};
-    }
-    pcre2_replacement = regex_info.opt_replace_result.has_value() ? *std::move(regex_info.opt_replace_result) : replacement;
+  // we need to replace PHP's back references with PCRE2 ones
+  auto unescaper{preg_replacement_unescaper{{replacement.c_str(), replacement.size()}}};
+  pcre2_replacement_escaper escaper{};
+  while (unescaper.has_next()) {
+    escaper.escape_term(unescaper.unescape_term());
   }
+  auto& pcre2_replacement{escaper.result()};
 
   RegexInfo regex_info{{pattern.c_str(), pattern.size()}, {subject.c_str(), subject.size()}, {pcre2_replacement.c_str(), pcre2_replacement.size()}};
 

runtime-light/stdlib/string/regex-functions.cpp

@@ -0,0 +1,82 @@
+@ok callback benchmark k2_skip
+<?php
+
+define('RE_URL_PATTERN', '(?<![A-Za-z\$0-9À-ßà-ÿ¸¨\-\_])(https?:\/\/)?((?:[A-Za-z\$0-9À-ßà-ÿ¸¨](?:[A-Za-z\$0-9\-\_À-ßà-ÿ¸¨]*[A-Za-z\$0-9À-ßà-ÿ¸¨])?\.){1,5}[A-Za-z\$ðôóêÐÔÓÊ\-\d]{2,22}(?::\d{2,5})?)((?:\/(?:(?:\&amp;|\&#33;|,[_%]|[A-Za-z0-9\xa8\xb8\xc0-\xffºª¥´¯¿²³\-\_#%?+\/\$.~=;:]+|\[[A-Za-z0-9\xa8\xb8\xc0-\xffºª¥´¯¿²³\-\_#%?+\/\$.,~=;:]*\]|\([A-Za-z0-9\xa8\xb8\xc0-\xffºª¥´¯¿²³\-\_#%?+\/\$.,~=;:]*\))*(?:,[_%]|[A-Za-z0-9\xa8\xb8\xc0-\xffºª¥´¯¿\-\_#%?+\/\$.~=;:]*[A-Za-z0-9\xa8\xb8\xc0-\xffºª¥´¯¿²³\_#%?+\/\$~=]|\[[A-Za-z0-9\xa8\xb8\xc0-\xffºª¥´¯¿²³\-\_#%?+\/\$.,~=;:]*\]|\([A-Za-z0-9\xa8\xb8\xc0-\xffºª¥´¯¿²³\-\_#%?+\/\$.,~=;:]*\)))?)?)');
+
+$text = 'ß ñëûøàë, ÷òî â iOS 7 ïîÿâèëèñü ëîêàëüíûå ïóø-óâåäîìëåíèÿ. Íî òóò http://blog.derand.net/2010/08/local-notifications-ios-40.html óòâåðæäàåòñÿ, ÷òî åùå â ÷åòâåðòîé.';
+$text = preg_replace_callback('/'.RE_URL_PATTERN.'/', 'prcConvertHyperref', $text);
+
+/**
+ * @kphp-required
+ * @param string[] $matches
+ * @return string
+ */
+function prcConvertHyperref($matches) {
+  return (string)preg_match('/\.([a-zA-ZðôóêÐÔÓÊ\-0-9]+)$/', $matches[2], $match);
+}
+
+
+/**
+ * @kphp-required
+ * @param string[] $param
+ * @return string
+ */
+function cb($param) {
+  var_dump($param);
+  return "yes!";
+}
+
+
+$input = "plain [indent] deep [indent] [abcd]deeper[/abcd] [/indent] deep [/indent] plain";
+
+/**
+ * @param mixed $input
+ * @return string
+ */
+function parseTagsRecursive($input)
+{
+	global $count;
+    $regex = '#\[indent]((?:[^[]|\[(?!/?indent])|(?R))+)\[/indent]#';
+    var_dump ($input);
+
+    if (is_array($input)) {
+        $input = '<div style="margin-left: 10px">'.$input[1].'</div>';
+    }
+
+
+    $res = preg_replace_callback($regex, 'parseTagsRecursive', $input, -1, $count);
+    var_dump ($count);
+    return (string)$res;
+
+}
+
+$output = parseTagsRecursive($input);
+
+echo $output, "\n";
+
+
+/**
+ * @kphp-required
+ * @param string[] $x
+ * @return string
+ */
+function g($x) {
+	return "'{$x[0]}'";
+}
+
+var_dump(preg_replace_callback('@\b\w{1,2}\b@', 'g', array('a b3 bcd', 'v' => 'aksfjk', 12 => 'aa bb')));
+
+@var_dump(preg_replace_callback('~\A.~', 'g', array(array('xyz'))));
+
+/**
+ * @kphp-required
+ * @param string[] $m
+ * @return string
+ */
+function tmp($m) {
+  return strtolower($m[0]);
+}
+
+var_dump(preg_replace_callback('~\A.~', 'tmp', 'ABC'));
+
+var_dump(preg_replace_callback("/(ab)(cd)(e)/", "cb", 'abcde'));