change json_decode so that it accepts string_view instead of KPHP string (#1398)

Author: apolyakov

runtime-common/stdlib/serialization/from-json-processor.h

@@ -204,12 +204,14 @@ ClassName f$JsonEncoder$$from_json_impl(Tag /*tag*/, const string& json_string,
   auto& msg = SerializationLibContext::get().last_json_processor_error;
   msg = {};
 
-  auto [json, success] = json_decode(json_string, FromJsonVisitor<Tag>::get_json_obj_magic_key());
+  auto opt_json = json_decode({json_string.c_str(), json_string.size()}, {FromJsonVisitor<Tag>::get_json_obj_magic_key()});
 
-  if (!success) {
+  if (!opt_json.has_value()) {
     msg.append(json_string.empty() ? "provided empty json string" : "failed to parse json string");
     return {};
   }
+
+  auto json = *std::move(opt_json);
   if constexpr (!impl_::IsJsonFlattenClass<typename ClassName::ClassType>::value) {
     if (!json.is_array() || json.as_array().is_vector()) {
       msg.append("root element of json string must be an object type, got ");

runtime-common/stdlib/serialization/json-functions.cpp

@@ -4,6 +4,10 @@
 
 #include "runtime-common/stdlib/serialization/json-functions.h"
 
+#include <cstddef>
+#include <optional>
+#include <string_view>
+
 #include "common/algorithms/find.h"
 #include "runtime-common/core/runtime-core.h"
 #include "runtime-common/stdlib/string/string-functions.h"
@@ -316,17 +320,17 @@ bool JsonEncoder::encode(const mixed& v, string_buffer& sb) noexcept {
 
 namespace {
 
-void json_skip_blanks(const char* s, int& i) noexcept {
+void json_skip_blanks(const char* s, size_t& i) noexcept {
   while (vk::any_of_equal(s[i], ' ', '\t', '\r', '\n')) {
     i++;
   }
 }
 
-bool do_json_decode(const char* s, int s_len, int& i, mixed& v, const char* json_obj_magic_key) noexcept {
+bool do_json_decode(std::string_view s, size_t& i, mixed& v, std::string_view json_obj_magic_key) noexcept {
   if (!v.is_null()) {
     v.destroy();
   }
-  json_skip_blanks(s, i);
+  json_skip_blanks(s.data(), i);
   switch (s[i]) {
   case 'n':
     if (s[i + 1] == 'u' && s[i + 2] == 'l' && s[i + 3] == 'l') {
@@ -351,14 +355,14 @@ bool do_json_decode(const char* s, int s_len, int& i, mixed& v, const char* json
   case '"': {
     int j = i + 1;
     int slashes = 0;
-    while (j < s_len && s[j] != '"') {
+    while (j < s.size() && s[j] != '"') {
       if (s[j] == '\\') {
         slashes++;
         j++;
       }
       j++;
     }
-    if (j < s_len) {
+    if (j < s.size()) {
       int len = j - i - 1 - slashes;
 
       string value(len, false);
@@ -469,15 +473,15 @@ bool do_json_decode(const char* s, int s_len, int& i, mixed& v, const char* json
   case '[': {
     array<mixed> res;
     i++;
-    json_skip_blanks(s, i);
+    json_skip_blanks(s.data(), i);
     if (s[i] != ']') {
       do {
         mixed value;
-        if (!do_json_decode(s, s_len, i, value, json_obj_magic_key)) {
+        if (!do_json_decode(s, i, value, json_obj_magic_key)) {
           return false;
         }
         res.push_back(value);
-        json_skip_blanks(s, i);
+        json_skip_blanks(s.data(), i);
       } while (s[i++] == ',');
 
       if (s[i - 1] != ']') {
@@ -493,22 +497,22 @@ bool do_json_decode(const char* s, int s_len, int& i, mixed& v, const char* json
   case '{': {
     array<mixed> res;
     i++;
-    json_skip_blanks(s, i);
+    json_skip_blanks(s.data(), i);
     if (s[i] != '}') {
       do {
         mixed key;
-        if (!do_json_decode(s, s_len, i, key, json_obj_magic_key) || !key.is_string()) {
+        if (!do_json_decode(s, i, key, json_obj_magic_key) || !key.is_string()) {
           return false;
         }
-        json_skip_blanks(s, i);
+        json_skip_blanks(s.data(), i);
         if (s[i++] != ':') {
           return false;
         }
 
-        if (!do_json_decode(s, s_len, i, res[key], json_obj_magic_key)) {
+        if (!do_json_decode(s, i, res[key], json_obj_magic_key)) {
           return false;
         }
-        json_skip_blanks(s, i);
+        json_skip_blanks(s.data(), i);
       } while (s[i++] == ',');
 
       if (s[i - 1] != '}') {
@@ -520,8 +524,8 @@ bool do_json_decode(const char* s, int s_len, int& i, mixed& v, const char* json
 
     // it's impossible to distinguish whether empty php array was an json array or json object;
     // to overcome it we add dummy key to php array that make array::is_vector() returning false, so we have difference
-    if (json_obj_magic_key && res.empty()) {
-      res[string{json_obj_magic_key}] = true;
+    if (!json_obj_magic_key.empty() && res.empty()) {
+      res[string{json_obj_magic_key.data(), static_cast<string::size_type>(json_obj_magic_key.size())}] = true;
     }
 
     new (&v) mixed(res);
@@ -534,15 +538,15 @@ bool do_json_decode(const char* s, int s_len, int& i, mixed& v, const char* json
     }
     if (j > i) {
       int64_t intval = 0;
-      if (php_try_to_int(s + i, j - i, &intval)) {
+      if (php_try_to_int(s.data() + i, j - i, &intval)) {
         i = j;
         new (&v) mixed(intval);
         return true;
       }
 
       char* end_ptr;
-      double floatval = strtod(s + i, &end_ptr);
-      if (end_ptr == s + j) {
+      double floatval = strtod(s.data() + i, &end_ptr);
+      if (end_ptr == s.data() + j) {
         i = j;
         new (&v) mixed(floatval);
         return true;
@@ -557,22 +561,20 @@ bool do_json_decode(const char* s, int s_len, int& i, mixed& v, const char* json
 
 } // namespace
 
-std::pair<mixed, bool> json_decode(const string& v, const char* json_obj_magic_key) noexcept {
-  mixed result;
-  int i = 0;
-  if (do_json_decode(v.c_str(), v.size(), i, result, json_obj_magic_key)) {
-    json_skip_blanks(v.c_str(), i);
-    if (i == static_cast<int>(v.size())) {
-      bool success = true;
-      return {result, success};
+std::optional<mixed> json_decode(std::string_view v, std::string_view json_obj_magic_key) noexcept {
+  mixed result{};
+  size_t i{};
+  if (do_json_decode(v, i, result, json_obj_magic_key)) {
+    json_skip_blanks(v.data(), i);
+    if (i == v.size()) {
+      return result;
     }
   }
-
   return {};
 }
 
 mixed f$json_decode(const string& v, bool assoc) noexcept {
   // TODO It was a warning before (in case if assoc is false), but then it was disabled, should we enable it again?
   static_cast<void>(assoc);
-  return json_decode(v).first;
+  return json_decode({v.c_str(), v.size()}, {}).value_or(mixed{});
 }

runtime-common/stdlib/serialization/json-functions.h

@@ -5,6 +5,8 @@
 #pragma once
 
 #include <array>
+#include <optional>
+#include <string_view>
 
 #include "common/mixin/not_copyable.h"
 #include "runtime-common/core/runtime-core.h"
@@ -174,5 +176,6 @@ inline Optional<string> f$vk_json_encode(const T& v) noexcept {
   return f$json_encode(v, 0, true);
 }
 
-std::pair<mixed, bool> json_decode(const string& v, const char* json_obj_magic_key = nullptr) noexcept;
+std::optional<mixed> json_decode(std::string_view v, std::string_view json_obj_magic_key = {}) noexcept;
+
 mixed f$json_decode(const string& v, bool assoc = false) noexcept;

runtime-light/state/component-state.cpp

@@ -45,9 +45,8 @@ void ComponentState::parse_ini_arg(std::string_view key_view, std::string_view v
 }
 
 void ComponentState::parse_runtime_config_arg(std::string_view value_view) noexcept {
-  // FIXME: actually no need to allocate string here
-  if (auto [config, ok]{json_decode(string{value_view.data(), static_cast<string::size_type>(value_view.size())})}; ok) [[likely]] {
-    runtime_config = std::move(config);
+  if (auto opt_config{json_decode(value_view)}; opt_config) [[likely]] {
+    runtime_config = *std::move(opt_config);
   } else {
     kphp::log::warning("runtime config isn't a valid JSON");
   }

runtime-light/stdlib/confdata/confdata-functions.cpp

@@ -36,7 +36,7 @@ mixed extract_confdata_value(const tl::confdataValue& confdata_value) noexcept {
   if (confdata_value.is_php_serialized.value) {
     return unserialize_raw(confdata_value.value.value.data(), static_cast<string::size_type>(confdata_value.value.value.size()));
   } else if (confdata_value.is_json_serialized.value) {
-    return f$json_decode(string{confdata_value.value.value.data(), static_cast<string::size_type>(confdata_value.value.value.size())});
+    return json_decode(confdata_value.value.value).value_or(mixed{});
   } else {
     return string{confdata_value.value.value.data(), static_cast<string::size_type>(confdata_value.value.value.size())};
   }

runtime/memcache.cpp

@@ -4,6 +4,8 @@
 
 #include "runtime/memcache.h"
 
+#include <cstddef>
+
 #include "runtime-common/core/utils/kphp-assert-core.h"
 #include "runtime-common/stdlib/serialization/json-functions.h"
 #include "runtime-common/stdlib/serialization/serialize-functions.h"
@@ -163,7 +165,7 @@ mixed mc_get_value(const char* result_str, int32_t result_str_len, int64_t flags
     result = unserialize_raw(result_str, result_str_len);
   } else if (flags & MEMCACHE_JSON_SERIALIZED) {
     flags ^= MEMCACHE_JSON_SERIALIZED;
-    result = json_decode({result_str, static_cast<string::size_type>(result_str_len)}).first;
+    result = json_decode({result_str, static_cast<size_t>(result_str_len)}).value_or(mixed{});
   } else {
     result = string(result_str, result_str_len);
   }

server/php-engine.cpp

@@ -2187,12 +2187,12 @@ int main_args_handler(int i, const char *long_option) {
       }
       std::stringstream stringstream;
       stringstream << file.rdbuf();
-      auto [config, success] = json_decode(string(stringstream.str().c_str()));
-      if (!success) {
+      auto opt_config = json_decode(stringstream.str());
+      if (!opt_config.has_value()) {
         kprintf("--%s option : file is not JSON\n", long_option);
         return -1;
       }
-      runtime_config = std::move(config);
+      runtime_config = *std::move(opt_config);
       return 0;
     }
     case 2033: {