rn-update 1.0.0

package/cpp/update_flow_core/flow_json.cpp

@@ -0,0 +1,660 @@
+/**
+ * [INPUT]: 依赖 flow_json.h 的有序值模型与严格 JSON/JavaScript 序列化约定
+ * [OUTPUT]: 实现对象访问、JS truthiness/严格相等、受深度限制的解析与规范化序列化
+ * [POS]: flow_json 的确定性实现，为网络响应解析和 TS/C++ golden 对拍提供共同数据语义
+ */
+#include "flow_json.h"
+
+#include <cmath>
+#include <cstdint>
+#include <cstdio>
+
+namespace flowjson {
+
+namespace {
+const Value kUndefined;
+}  // namespace
+
+bool Value::Truthy() const {
+  switch (kind_) {
+    case Kind::Undefined:
+    case Kind::Null:
+      return false;
+    case Kind::Bool:
+      return bool_;
+    case Kind::Number:
+      return number_ != 0 && !std::isnan(number_);
+    case Kind::String:
+      return !string_.empty();
+    case Kind::Array:
+    case Kind::Object:
+      return true;
+  }
+  return false;
+}
+
+const Value& Value::At(size_t i) const {
+  if (kind_ != Kind::Array || i >= elements_.size()) {
+    return kUndefined;
+  }
+  return elements_[i];
+}
+
+const Value& Value::Get(const std::string& key) const {
+  if (kind_ == Kind::Object) {
+    for (const auto& member : members_) {
+      if (member.first == key) {
+        return member.second;
+      }
+    }
+  }
+  return kUndefined;
+}
+
+void Value::Set(const std::string& key, Value v) {
+  for (auto& member : members_) {
+    if (member.first == key) {
+      member.second = std::move(v);
+      return;
+    }
+  }
+  members_.emplace_back(key, std::move(v));
+}
+
+void Value::Remove(const std::string& key) {
+  for (auto it = members_.begin(); it != members_.end(); ++it) {
+    if (it->first == key) {
+      members_.erase(it);
+      return;
+    }
+  }
+}
+
+bool Value::StrictEquals(const Value& a, const Value& b) {
+  if (a.kind_ != b.kind_) {
+    return false;
+  }
+  switch (a.kind_) {
+    case Kind::Undefined:
+    case Kind::Null:
+      return true;
+    case Kind::Bool:
+      return a.bool_ == b.bool_;
+    case Kind::Number:
+      return a.number_ == b.number_;
+    case Kind::String:
+      return a.string_ == b.string_;
+    case Kind::Array:
+    case Kind::Object:
+      return false;
+  }
+  return false;
+}
+
+namespace {
+
+void AppendEscaped(const std::string& s, std::string* out) {
+  out->push_back('"');
+  for (unsigned char c : s) {
+    switch (c) {
+      case '"':
+        out->append("\\\"");
+        break;
+      case '\\':
+        out->append("\\\\");
+        break;
+      case '\b':
+        out->append("\\b");
+        break;
+      case '\f':
+        out->append("\\f");
+        break;
+      case '\n':
+        out->append("\\n");
+        break;
+      case '\r':
+        out->append("\\r");
+        break;
+      case '\t':
+        out->append("\\t");
+        break;
+      default:
+        if (c < 0x20) {
+          char buf[8];
+          std::snprintf(buf, sizeof(buf), "\\u%04x", c);
+          out->append(buf);
+        } else {
+          out->push_back(static_cast<char>(c));
+        }
+    }
+  }
+  out->push_back('"');
+}
+
+void AppendNumber(double n, std::string* out) {
+  // JSON.stringify prints non-finite numbers as null.
+  if (!std::isfinite(n)) {
+    out->append("null");
+    return;
+  }
+  // The decision layer only ever emits integral numbers (hashes, counters,
+  // rollout percentages); print them the way JSON.stringify does. The %.17g
+  // fallback exists so an unexpected fractional value surfaces as a vector
+  // mismatch instead of silent truncation.
+  if (n == std::floor(n) && std::fabs(n) <= 9007199254740992.0) {
+    char buf[32];
+    std::snprintf(buf, sizeof(buf), "%lld", static_cast<long long>(n));
+    out->append(buf);
+    return;
+  }
+  char buf[40];
+  const int len = std::snprintf(buf, sizeof(buf), "%.17g", n);
+  if (len <= 0) {
+    out->append("null");
+    return;
+  }
+  // %g writes the LC_NUMERIC decimal point ("," — or a multibyte sequence in
+  // some locales). Everything else it can produce for a finite value is
+  // [0-9eE+-], so normalize whatever else appears back to '.' instead of
+  // depending on the process locale.
+  bool point_written = false;
+  for (int i = 0; i < len && i < static_cast<int>(sizeof(buf)); i++) {
+    const char c = buf[i];
+    if ((c >= '0' && c <= '9') || c == '-' || c == '+' || c == 'e' ||
+        c == 'E') {
+      out->push_back(c);
+    } else if (!point_written) {
+      out->push_back('.');
+      point_written = true;
+    }
+  }
+}
+
+void AppendValue(const Value& v, std::string* out) {
+  switch (v.kind()) {
+    case Value::Kind::Undefined:  // only reachable inside arrays
+    case Value::Kind::Null:
+      out->append("null");
+      break;
+    case Value::Kind::Bool:
+      out->append(v.AsBool() ? "true" : "false");
+      break;
+    case Value::Kind::Number:
+      AppendNumber(v.AsNumber(), out);
+      break;
+    case Value::Kind::String:
+      AppendEscaped(v.AsString(), out);
+      break;
+    case Value::Kind::Array: {
+      out->push_back('[');
+      bool first = true;
+      for (const auto& element : v.elements()) {
+        if (!first) {
+          out->push_back(',');
+        }
+        first = false;
+        AppendValue(element, out);
+      }
+      out->push_back(']');
+      break;
+    }
+    case Value::Kind::Object: {
+      out->push_back('{');
+      bool first = true;
+      for (const auto& member : v.members()) {
+        if (member.second.IsUndefined()) {
+          continue;  // JSON.stringify drops undefined-valued members
+        }
+        if (!first) {
+          out->push_back(',');
+        }
+        first = false;
+        AppendEscaped(member.first, out);
+        out->push_back(':');
+        AppendValue(member.second, out);
+      }
+      out->push_back('}');
+      break;
+    }
+  }
+}
+
+}  // namespace
+
+std::string Stringify(const Value& v) {
+  if (v.IsUndefined()) {
+    return "undefined";
+  }
+  std::string out;
+  AppendValue(v, &out);
+  return out;
+}
+
+namespace {
+
+// The parser also consumes server checkUpdate responses, so hostile input
+// must fail cleanly: nesting is capped to keep recursive descent off the
+// stack limit (size and node count are capped in flow_json.h). Real
+// responses nest ~4 levels.
+constexpr int kMaxDepth = 64;
+
+// Locale-independent decimal -> double. strtod() honours LC_NUMERIC, so a
+// host process that called setlocale() into a comma-decimal locale would stop
+// at the '.' of every fractional literal and reject the whole response. The
+// token has already been validated against the JSON number grammar.
+// Correctly rounded whenever the significand fits in 53 bits and the decimal
+// exponent is within +-22 (exact double powers of ten) or the value is an
+// integer below 2^53 x 10^15 — which covers everything the decision layer
+// handles (hashes, counters, rollout percentages, timestamps). Anything more
+// exotic is computed as significand x 10^exponent in double arithmetic and
+// may differ from JSON.parse by an ulp; extreme exponents saturate to
+// infinity / zero like JS.
+double DecimalToDouble(const std::string& token) {
+  size_t i = 0;
+  bool negative = false;
+  if (i < token.size() && token[i] == '-') {
+    negative = true;
+    i++;
+  }
+  uint64_t significand = 0;
+  int digits = 0;    // significant digits folded into `significand`
+  int exponent = 0;  // decimal exponent applied to `significand`
+  bool fraction = false;
+  for (; i < token.size(); i++) {
+    const char c = token[i];
+    if (c == '.') {
+      fraction = true;
+      continue;
+    }
+    if (c == 'e' || c == 'E') {
+      break;
+    }
+    const int digit = c - '0';
+    if (significand == 0 && digit == 0) {
+      if (fraction) {
+        exponent--;  // leading zeros after the point only shift the scale
+      }
+      continue;
+    }
+    if (digits < 19) {
+      significand = significand * 10 + static_cast<uint64_t>(digit);
+      digits++;
+      if (fraction) {
+        exponent--;
+      }
+    } else if (!fraction) {
+      exponent++;  // beyond 19 digits: keep the magnitude, drop precision
+    }
+  }
+  if (i < token.size()) {  // exponent part
+    i++;
+    bool exp_negative = false;
+    if (i < token.size() && (token[i] == '+' || token[i] == '-')) {
+      exp_negative = token[i] == '-';
+      i++;
+    }
+    int exp_value = 0;
+    for (; i < token.size(); i++) {
+      if (exp_value < 100000) {  // saturate: the result is inf/0 anyway
+        exp_value = exp_value * 10 + (token[i] - '0');
+      }
+    }
+    exponent += exp_negative ? -exp_value : exp_value;
+  }
+
+  double result = 0.0;
+  if (significand != 0) {
+    static const double kPow10[] = {
+        1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
+        1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
+    static const uint64_t kPow10Int[] = {
+        1ull,           10ull,           100ull,           1000ull,
+        10000ull,       100000ull,       1000000ull,       10000000ull,
+        100000000ull,   1000000000ull,   10000000000ull,   100000000000ull,
+        1000000000000ull, 10000000000000ull, 100000000000000ull,
+        1000000000000000ull};
+    const uint64_t kExact = 1ull << 53;
+    if (significand <= kExact && exponent >= -22 && exponent <= 22) {
+      result = exponent >= 0
+                   ? static_cast<double>(significand) * kPow10[exponent]
+                   : static_cast<double>(significand) / kPow10[-exponent];
+    } else if (significand <= kExact && exponent > 22 && exponent <= 22 + 15 &&
+               significand <= kExact / kPow10Int[exponent - 22]) {
+      result = static_cast<double>(significand * kPow10Int[exponent - 22]) *
+               kPow10[22];
+    } else {
+      result = static_cast<double>(significand) *
+               std::pow(10.0, static_cast<double>(exponent));
+    }
+  }
+  return negative ? -result : result;
+}
+
+class Parser {
+ public:
+  Parser(const std::string& text) : text_(text) {}
+
+  Value Run(bool* ok) {
+    Value v = ParseValue();
+    SkipWs();
+    *ok = ok_ && pos_ == text_.size();
+    return *ok ? v : Value::Undefined();
+  }
+
+ private:
+  void SkipWs() {
+    while (pos_ < text_.size()) {
+      char c = text_[pos_];
+      if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
+        pos_++;
+      } else {
+        break;
+      }
+    }
+  }
+
+  bool Consume(char expected) {
+    if (pos_ < text_.size() && text_[pos_] == expected) {
+      pos_++;
+      return true;
+    }
+    ok_ = false;
+    return false;
+  }
+
+  bool ConsumeLiteral(const char* literal) {
+    size_t len = 0;
+    while (literal[len]) {
+      len++;
+    }
+    if (text_.compare(pos_, len, literal) == 0) {
+      pos_ += len;
+      return true;
+    }
+    ok_ = false;
+    return false;
+  }
+
+  Value ParseValue() {
+    SkipWs();
+    if (pos_ >= text_.size()) {
+      ok_ = false;
+      return Value::Undefined();
+    }
+    if (++nodes_ > kMaxNodes) {
+      ok_ = false;
+      return Value::Undefined();
+    }
+    char c = text_[pos_];
+    switch (c) {
+      case '{':
+      case '[': {
+        if (depth_ >= kMaxDepth) {
+          ok_ = false;
+          return Value::Undefined();
+        }
+        depth_++;
+        Value v = c == '{' ? ParseObject() : ParseArray();
+        depth_--;
+        return v;
+      }
+      case '"':
+        return Value::String(ParseString());
+      case 't':
+        ConsumeLiteral("true");
+        return Value::Bool(true);
+      case 'f':
+        ConsumeLiteral("false");
+        return Value::Bool(false);
+      case 'n':
+        ConsumeLiteral("null");
+        return Value::Null();
+      default:
+        return ParseNumber();
+    }
+  }
+
+  Value ParseObject() {
+    Value obj = Value::Object();
+    Consume('{');
+    SkipWs();
+    if (pos_ < text_.size() && text_[pos_] == '}') {
+      pos_++;
+      return obj;
+    }
+    while (ok_) {
+      SkipWs();
+      std::string key = ParseString();
+      SkipWs();
+      Consume(':');
+      obj.Set(key, ParseValue());
+      SkipWs();
+      if (pos_ < text_.size() && text_[pos_] == ',') {
+        pos_++;
+        continue;
+      }
+      Consume('}');
+      break;
+    }
+    return obj;
+  }
+
+  Value ParseArray() {
+    Value arr = Value::Array();
+    Consume('[');
+    SkipWs();
+    if (pos_ < text_.size() && text_[pos_] == ']') {
+      pos_++;
+      return arr;
+    }
+    while (ok_) {
+      arr.Push(ParseValue());
+      SkipWs();
+      if (pos_ < text_.size() && text_[pos_] == ',') {
+        pos_++;
+        continue;
+      }
+      Consume(']');
+      break;
+    }
+    return arr;
+  }
+
+  std::string ParseString() {
+    std::string out;
+    if (!Consume('"')) {
+      return out;
+    }
+    while (pos_ < text_.size()) {
+      char c = text_[pos_++];
+      if (c == '"') {
+        return out;
+      }
+      if (c != '\\') {
+        out.push_back(c);
+        continue;
+      }
+      if (pos_ >= text_.size()) {
+        break;
+      }
+      char esc = text_[pos_++];
+      switch (esc) {
+        case '"':
+        case '\\':
+        case '/':
+          out.push_back(esc);
+          break;
+        case 'b':
+          out.push_back('\b');
+          break;
+        case 'f':
+          out.push_back('\f');
+          break;
+        case 'n':
+          out.push_back('\n');
+          break;
+        case 'r':
+          out.push_back('\r');
+          break;
+        case 't':
+          out.push_back('\t');
+          break;
+        case 'u': {
+          unsigned code = ParseHex4();
+          if (!ok_) {
+            return out;
+          }
+          // A high surrogate combines with an immediately following low
+          // surrogate escape into one supplementary code point.
+          if (code >= 0xd800 && code <= 0xdbff &&
+              text_.compare(pos_, 2, "\\u") == 0) {
+            const size_t escape_start = pos_;
+            pos_ += 2;
+            unsigned low = ParseHex4();
+            if (!ok_) {
+              return out;
+            }
+            if (low >= 0xdc00 && low <= 0xdfff) {
+              code = 0x10000 + ((code - 0xd800) << 10) + (low - 0xdc00);
+            } else {
+              pos_ = escape_start;  // the loop re-reads that escape on its own
+            }
+          }
+          // JSON.parse accepts a lone surrogate, but it has no UTF-8 form:
+          // emitting one byte-encoded (ED A0 80..) would push invalid UTF-8
+          // into napi_create_string_utf8 / NewString. Decode it to U+FFFD,
+          // the way TextEncoder serializes such a JS string.
+          if (code >= 0xd800 && code <= 0xdfff) {
+            code = 0xfffd;
+          }
+          AppendUtf8(code, &out);
+          break;
+        }
+        default:
+          ok_ = false;
+          return out;
+      }
+    }
+    ok_ = false;
+    return out;
+  }
+
+  unsigned ParseHex4() {
+    unsigned code = 0;
+    for (int i = 0; i < 4; i++) {
+      if (pos_ >= text_.size()) {
+        ok_ = false;
+        return 0;
+      }
+      char c = text_[pos_++];
+      code <<= 4;
+      if (c >= '0' && c <= '9') {
+        code |= static_cast<unsigned>(c - '0');
+      } else if (c >= 'a' && c <= 'f') {
+        code |= static_cast<unsigned>(c - 'a' + 10);
+      } else if (c >= 'A' && c <= 'F') {
+        code |= static_cast<unsigned>(c - 'A' + 10);
+      } else {
+        ok_ = false;
+        return 0;
+      }
+    }
+    return code;
+  }
+
+  static void AppendUtf8(unsigned code, std::string* out) {
+    if (code < 0x80) {
+      out->push_back(static_cast<char>(code));
+    } else if (code < 0x800) {
+      out->push_back(static_cast<char>(0xc0 | (code >> 6)));
+      out->push_back(static_cast<char>(0x80 | (code & 0x3f)));
+    } else if (code < 0x10000) {
+      out->push_back(static_cast<char>(0xe0 | (code >> 12)));
+      out->push_back(static_cast<char>(0x80 | ((code >> 6) & 0x3f)));
+      out->push_back(static_cast<char>(0x80 | (code & 0x3f)));
+    } else {
+      out->push_back(static_cast<char>(0xf0 | (code >> 18)));
+      out->push_back(static_cast<char>(0x80 | ((code >> 12) & 0x3f)));
+      out->push_back(static_cast<char>(0x80 | ((code >> 6) & 0x3f)));
+      out->push_back(static_cast<char>(0x80 | (code & 0x3f)));
+    }
+  }
+
+  Value ParseNumber() {
+    size_t start = pos_;
+    if (pos_ < text_.size() && text_[pos_] == '-') {
+      pos_++;
+    }
+
+    if (pos_ >= text_.size()) {
+      ok_ = false;
+      return Value::Undefined();
+    }
+    if (text_[pos_] == '0') {
+      pos_++;
+      // RFC 8259 forbids leading zeroes (except the number zero itself).
+      if (pos_ < text_.size() && text_[pos_] >= '0' && text_[pos_] <= '9') {
+        ok_ = false;
+        return Value::Undefined();
+      }
+    } else if (text_[pos_] >= '1' && text_[pos_] <= '9') {
+      while (pos_ < text_.size() && text_[pos_] >= '0' &&
+             text_[pos_] <= '9') {
+        pos_++;
+      }
+    } else {
+      ok_ = false;
+      return Value::Undefined();
+    }
+
+    if (pos_ < text_.size() && text_[pos_] == '.') {
+      pos_++;
+      if (pos_ >= text_.size() || text_[pos_] < '0' || text_[pos_] > '9') {
+        ok_ = false;
+        return Value::Undefined();
+      }
+      while (pos_ < text_.size() && text_[pos_] >= '0' &&
+             text_[pos_] <= '9') {
+        pos_++;
+      }
+    }
+
+    if (pos_ < text_.size() &&
+        (text_[pos_] == 'e' || text_[pos_] == 'E')) {
+      pos_++;
+      if (pos_ < text_.size() &&
+          (text_[pos_] == '+' || text_[pos_] == '-')) {
+        pos_++;
+      }
+      if (pos_ >= text_.size() || text_[pos_] < '0' || text_[pos_] > '9') {
+        ok_ = false;
+        return Value::Undefined();
+      }
+      while (pos_ < text_.size() && text_[pos_] >= '0' &&
+             text_[pos_] <= '9') {
+        pos_++;
+      }
+    }
+
+    return Value::Number(DecimalToDouble(text_.substr(start, pos_ - start)));
+  }
+
+  const std::string& text_;
+  size_t pos_ = 0;
+  int depth_ = 0;
+  size_t nodes_ = 0;
+  bool ok_ = true;
+};
+
+}  // namespace
+
+Value Parse(const std::string& text, bool* ok) {
+  if (text.size() > kMaxInputBytes) {
+    *ok = false;
+    return Value::Undefined();
+  }
+  Parser parser(text);
+  return parser.Run(ok);
+}
+
+}  // namespace flowjson