@lucent-lang/lucent 0.0.4

package/runtime/cpp/lucent/json.cpp

@@ -0,0 +1,243 @@
+#include "json_parse.h"
+
+#include "jserror.h"
+#include "number.h"
+
+namespace lucent {
+
+namespace {
+
+constexpr int kMaxDepth = 1000;
+
+class Parser {
+ public:
+  explicit Parser(const String& s) : s_(s), n_(s.length()) {}
+
+  JsonValue parse() {
+    ws();
+    JsonValue v = value(0);
+    ws();
+    if (i_ < n_) unexpected();
+    return v;
+  }
+
+ private:
+  char16_t at(size_t i) const { return s_.unit(i); }
+
+  [[noreturn]] void fail(const std::string& what) {
+    throwError(String::fromLatin1("SyntaxError"), String::fromUtf8("JSON Parse error: " + what));
+  }
+  [[noreturn]] void unexpected() {
+    if (i_ >= n_) fail("Unexpected end of input");
+    char16_t c = at(i_);
+    std::string tok = c < 0x80 ? std::string(1, static_cast<char>(c)) : "\\u" + std::to_string(c);
+    fail("Unexpected token: " + tok);
+  }
+
+  void ws() {
+    while (i_ < n_) {
+      char16_t c = at(i_);
+      if (c != ' ' && c != '\t' && c != '\n' && c != '\r') break;
+      i_++;
+    }
+  }
+  bool eat(char16_t c) {
+    if (i_ < n_ && at(i_) == c) {
+      i_++;
+      return true;
+    }
+    return false;
+  }
+  void literal(const char* word) {
+    for (const char* w = word; *w; w++) {
+      if (!eat(static_cast<char16_t>(*w))) unexpected();
+    }
+  }
+
+  JsonValue value(int depth) {
+    if (depth > kMaxDepth) throwRangeError("JSON nesting is too deep");
+    if (i_ >= n_) unexpected();
+    JsonValue v;
+    switch (at(i_)) {
+      case '{': {
+        i_++;
+        v.kind = JsonValue::Kind::Object;
+        ws();
+        if (eat('}')) return v;
+        for (;;) {
+          ws();
+          if (i_ >= n_ || at(i_) != '"') unexpected();
+          String key = string();
+          ws();
+          if (!eat(':')) unexpected();
+          ws();
+          v.members.push_back(JsonMember{std::move(key), value(depth + 1)});
+          ws();
+          if (eat('}')) return v;
+          if (!eat(',')) unexpected();
+        }
+      }
+      case '[': {
+        i_++;
+        v.kind = JsonValue::Kind::Array;
+        ws();
+        if (eat(']')) return v;
+        for (;;) {
+          ws();
+          v.items.push_back(value(depth + 1));
+          ws();
+          if (eat(']')) return v;
+          if (!eat(',')) unexpected();
+        }
+      }
+      case '"':
+        v.kind = JsonValue::Kind::String;
+        v.string = string();
+        return v;
+      case 't':
+        literal("true");
+        v.kind = JsonValue::Kind::Bool;
+        v.boolean = true;
+        return v;
+      case 'f':
+        literal("false");
+        v.kind = JsonValue::Kind::Bool;
+        return v;
+      case 'n':
+        literal("null");
+        return v;
+      default:
+        v.kind = JsonValue::Kind::Number;
+        v.number = number();
+        return v;
+    }
+  }
+
+  bool digit() const { return i_ < n_ && at(i_) >= '0' && at(i_) <= '9'; }
+
+  double number() {
+    size_t start = i_;
+    eat('-');
+    if (eat('0')) {
+      // No leading zeros.
+    } else if (digit()) {
+      while (digit()) i_++;
+    } else {
+      unexpected();
+    }
+    if (eat('.')) {
+      if (!digit()) unexpected();
+      while (digit()) i_++;
+    }
+    if (eat('e') || eat('E')) {
+      if (!eat('+')) eat('-');
+      if (!digit()) unexpected();
+      while (digit()) i_++;
+    }
+    return stringToNumber(s_.substring(static_cast<double>(start), static_cast<double>(i_)));
+  }
+
+  int hex(char16_t c) {
+    if (c >= '0' && c <= '9') return c - '0';
+    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+    return -1;
+  }
+
+  String string() {
+    i_++;  // opening quote
+    std::u16string out;
+    for (;;) {
+      if (i_ >= n_) fail("Unterminated string");
+      char16_t c = at(i_++);
+      if (c == '"') break;
+      if (c < 0x20) {
+        i_--;
+        unexpected();
+      }
+      if (c != '\\') {
+        out.push_back(c);
+        continue;
+      }
+      if (i_ >= n_) fail("Unterminated string");
+      char16_t e = at(i_++);
+      switch (e) {
+        case '"':
+        case '\\':
+        case '/':
+          out.push_back(e);
+          break;
+        case 'b':
+          out.push_back(u'\b');
+          break;
+        case 'f':
+          out.push_back(u'\f');
+          break;
+        case 'n':
+          out.push_back(u'\n');
+          break;
+        case 'r':
+          out.push_back(u'\r');
+          break;
+        case 't':
+          out.push_back(u'\t');
+          break;
+        case 'u': {
+          int code = 0;
+          for (int k = 0; k < 4; k++) {
+            int h = i_ < n_ ? hex(at(i_)) : -1;
+            if (h < 0) fail("Invalid unicode escape");
+            code = code * 16 + h;
+            i_++;
+          }
+          out.push_back(static_cast<char16_t>(code));
+          break;
+        }
+        default:
+          i_ -= 2;
+          fail("Invalid escape sequence");
+      }
+    }
+    return String::fromUtf16(out);
+  }
+
+  const String& s_;
+  size_t n_;
+  size_t i_ = 0;
+};
+
+}  // namespace
+
+const JsonValue* JsonValue::find(const String& key) const {
+  for (auto it = members.rbegin(); it != members.rend(); ++it) {
+    if (it->key == key) return &it->value;
+  }
+  return nullptr;
+}
+
+const char* JsonValue::describe() const {
+  switch (kind) {
+    case Kind::Null:
+      return "null";
+    case Kind::Bool:
+      return "a boolean";
+    case Kind::Number:
+      return "a number";
+    case Kind::String:
+      return "a string";
+    case Kind::Array:
+      return "an array";
+    case Kind::Object:
+      return "an object";
+  }
+  return "a value";
+}
+
+JsonValue jsonParseTree(const String& text) { return Parser(text).parse(); }
+
+void jsonShapeError(const std::string& path, const char* expected, const char* got) {
+  std::string where = path.empty() ? "" : " at " + path;
+  throwTypeError(("JSON.parse: expected " + std::string(expected) + where + ", got " + got).c_str());
+}
+
+}  // namespace lucent

package/runtime/cpp/lucent/json.h

@@ -0,0 +1,164 @@
+// Lucent runtime — JSON.stringify for Lucent values. Generated code adds
+// `jsonWrite` overloads for each struct and class (found by ADL).
+#pragma once
+
+#include <cmath>
+#include <string>
+#include <tuple>
+#include <variant>
+
+#include "array.h"
+#include "bytes.h"
+#include "date.h"
+#include "regexp.h"
+#include "core.h"
+#include "jserror.h"
+#include "function.h"
+#include "map.h"
+#include "number.h"
+#include "jsstring.h"
+
+namespace lucent {
+
+struct JsonWriter {
+  std::u16string out;
+  void raw(const char* s) {
+    while (*s) out.push_back(static_cast<unsigned char>(*s++));
+  }
+  void quote(const String& s);
+};
+
+/// Whether a value is omitted from objects (undefined, functions).
+template <class T>
+bool jsonOmitted(const T&) {
+  return false;
+}
+inline bool jsonOmitted(Undefined) { return true; }
+template <class T>
+bool jsonOmitted(const Opt<T>& v) {
+  return v.isUndefined();
+}
+template <class Sig>
+bool jsonOmitted(const Fn<Sig>&) {
+  return true;
+}
+
+inline void jsonWrite(JsonWriter& w, double v) {
+  if (std::isfinite(v)) {
+    w.out.append(numberToString(v).toUtf16());
+  } else {
+    w.raw("null");
+  }
+}
+inline void jsonWrite(JsonWriter& w, bool v) { w.raw(v ? "true" : "false"); }
+inline void jsonWrite(JsonWriter& w, const String& s) { w.quote(s); }
+inline void jsonWrite(JsonWriter& w, Undefined) { w.raw("null"); }
+inline void jsonWrite(JsonWriter& w, Null) { w.raw("null"); }
+inline void jsonWrite(JsonWriter& w, const Error&) { w.raw("{}"); }
+template <class Sig>
+void jsonWrite(JsonWriter& w, const Fn<Sig>&) {
+  w.raw("null");
+}
+template <class T>
+void jsonWrite(JsonWriter& w, const Opt<T>& v) {
+  if (v.has()) jsonWrite(w, v.get());
+  else w.raw("null");
+}
+template <class... Ts>
+void jsonWrite(JsonWriter& w, const std::variant<Ts...>& v) {
+  std::visit([&](const auto& x) { jsonWrite(w, x); }, v);
+}
+template <class T>
+void jsonWrite(JsonWriter& w, const Array<T>& a) {
+  w.raw("[");
+  for (size_t i = 0; i < a.size(); i++) {
+    if (i) w.raw(",");
+    T v = a.at(i);
+    if (jsonOmitted(v)) w.raw("null");
+    else jsonWrite(w, v);
+  }
+  w.raw("]");
+}
+template <class... Ts>
+void jsonWrite(JsonWriter& w, const std::tuple<Ts...>& t) {
+  w.raw("[");
+  size_t i = 0;
+  std::apply(
+      [&](const auto&... x) {
+        ((w.raw(i++ ? "," : ""), jsonOmitted(x) ? w.raw("null") : jsonWrite(w, x)), ...);
+      },
+      t);
+  w.raw("]");
+}
+template <class V>
+void jsonWrite(JsonWriter& w, const Dict<V>& d) {
+  w.raw("{");
+  bool first = true;
+  Array<String> ks = d.keys();
+  for (const auto& k : ks.items()) {
+    V v = d.get(k).get();
+    if (jsonOmitted(v)) continue;
+    if (!first) w.raw(",");
+    first = false;
+    w.quote(k);
+    w.raw(":");
+    jsonWrite(w, v);
+  }
+  w.raw("}");
+}
+template <class K, class V>
+void jsonWrite(JsonWriter& w, const Map<K, V>&) {
+  w.raw("{}");
+}
+template <class T>
+void jsonWrite(JsonWriter& w, const Set<T>&) {
+  w.raw("{}");
+}
+/// RegExp objects have no enumerable own properties; match results are arrays.
+inline void jsonWrite(JsonWriter& w, const RegExp&) { w.raw("{}"); }
+inline void jsonWrite(JsonWriter& w, const RegExpMatch& m) { jsonWrite(w, m->items); }
+
+/// Date.prototype.toJSON: the ISO string, or null for an invalid date.
+inline void jsonWrite(JsonWriter& w, const Date& d) {
+  if (std::isnan(d->getTime())) w.raw("null");
+  else w.quote(d->toISOString());
+}
+inline void jsonWrite(JsonWriter& w, const Bytes& b) {
+  w.raw("{");
+  for (size_t i = 0; i < b.size(); i++) {
+    if (i) w.raw(",");
+    w.quote(numberToString(static_cast<double>(i)));
+    w.raw(":");
+    jsonWrite(w, b.at(i));
+  }
+  w.raw("}");
+}
+/// Helper for generated struct writers: one `"name":value` member.
+template <class T>
+void jsonField(JsonWriter& w, bool& first, const char* name, const T& v) {
+  if (jsonOmitted(v)) return;
+  if (!first) w.raw(",");
+  first = false;
+  w.quote(String::fromUtf8(name));
+  w.raw(":");
+  jsonWrite(w, v);
+}
+
+namespace json {
+template <class T>
+Opt<String> stringifyOpt(const T& v) {
+  if (jsonOmitted(v)) return undefined;
+  JsonWriter w;
+  jsonWrite(w, v);
+  return String::fromUtf16(w.out);
+}
+template <class T>
+String stringify(const T& v) {
+  JsonWriter w;
+  if (jsonOmitted(v)) return String::fromLatin1("undefined");
+  jsonWrite(w, v);
+  return String::fromUtf16(w.out);
+}
+}  // namespace json
+
+}  // namespace lucent

package/runtime/cpp/lucent/json_parse.h

@@ -0,0 +1,138 @@
+// Lucent runtime — JSON.parse into typed values.
+//
+// The text is parsed into a JsonValue tree (SyntaxError on invalid JSON),
+// then JsonRead<T> builds the typed value, throwing a TypeError that names
+// the path when the shape does not match the type. The compiler generates
+// JsonRead specializations for object types and unions.
+#pragma once
+
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+#include "array.h"
+#include "core.h"
+#include "jsstring.h"
+#include "map.h"
+
+namespace lucent {
+
+struct JsonMember;
+
+struct JsonValue {
+  enum class Kind : uint8_t { Null, Bool, Number, String, Array, Object };
+  Kind kind = Kind::Null;
+  bool boolean = false;
+  double number = 0;
+  String string;
+  std::vector<JsonValue> items;
+  // A named struct, not std::pair: pair needs JsonValue complete here.
+  std::vector<JsonMember> members;
+
+  /// The member named `key`; the last one wins when a key repeats.
+  const JsonValue* find(const String& key) const;
+  /// "a number", "an object", … for error messages.
+  const char* describe() const;
+};
+
+struct JsonMember {
+  String key;
+  JsonValue value;
+};
+
+/// Parses JSON text; throws SyntaxError.
+JsonValue jsonParseTree(const String& text);
+
+/// TypeError: `JSON.parse: expected <expected> at <path>, got <what>`.
+[[noreturn]] void jsonShapeError(const std::string& path, const char* expected, const char* got);
+
+template <class T>
+struct JsonRead;
+
+template <>
+struct JsonRead<double> {
+  static double read(const JsonValue& v, const std::string& p) {
+    if (v.kind != JsonValue::Kind::Number) jsonShapeError(p, "a number", v.describe());
+    return v.number;
+  }
+};
+template <>
+struct JsonRead<bool> {
+  static bool read(const JsonValue& v, const std::string& p) {
+    if (v.kind != JsonValue::Kind::Bool) jsonShapeError(p, "a boolean", v.describe());
+    return v.boolean;
+  }
+};
+template <>
+struct JsonRead<String> {
+  static String read(const JsonValue& v, const std::string& p) {
+    if (v.kind != JsonValue::Kind::String) jsonShapeError(p, "a string", v.describe());
+    return v.string;
+  }
+};
+template <>
+struct JsonRead<Null> {
+  static Null read(const JsonValue& v, const std::string& p) {
+    if (v.kind != JsonValue::Kind::Null) jsonShapeError(p, "null", v.describe());
+    return null;
+  }
+};
+template <class T>
+struct JsonRead<Opt<T>> {
+  static Opt<T> read(const JsonValue& v, const std::string& p) {
+    if (v.kind == JsonValue::Kind::Null) return Opt<T>(null);
+    return Opt<T>(JsonRead<T>::read(v, p));
+  }
+};
+template <class T>
+struct JsonRead<Array<T>> {
+  static Array<T> read(const JsonValue& v, const std::string& p) {
+    if (v.kind != JsonValue::Kind::Array) jsonShapeError(p, "an array", v.describe());
+    Array<T> out;
+    for (size_t i = 0; i < v.items.size(); i++) out.push(JsonRead<T>::read(v.items[i], p + "[" + std::to_string(i) + "]"));
+    return out;
+  }
+};
+template <class V>
+struct JsonRead<Dict<V>> {
+  static Dict<V> read(const JsonValue& v, const std::string& p) {
+    if (v.kind != JsonValue::Kind::Object) jsonShapeError(p, "an object", v.describe());
+    Dict<V> out;
+    for (const auto& [k, m] : v.members) out.set(k, JsonRead<V>::read(m, p + "." + k.toUtf8()));
+    return out;
+  }
+};
+template <class... Ts>
+struct JsonRead<std::tuple<Ts...>> {
+  static std::tuple<Ts...> read(const JsonValue& v, const std::string& p) {
+    if (v.kind != JsonValue::Kind::Array || v.items.size() < sizeof...(Ts)) jsonShapeError(p, "a longer array", v.describe());
+    return build(v, p, std::index_sequence_for<Ts...>{});
+  }
+  template <size_t... I>
+  static std::tuple<Ts...> build(const JsonValue& v, const std::string& p, std::index_sequence<I...>) {
+    return std::tuple<Ts...>{JsonRead<Ts>::read(v.items[I], p + "[" + std::to_string(I) + "]")...};
+  }
+};
+
+/// One member of an object type (used by generated readers). A missing
+/// member is undefined for optional types and an error otherwise.
+template <class T>
+T jsonMember(const JsonValue& obj, const char* key, const std::string& path) {
+  const JsonValue* m = obj.find(String::fromUtf8(key));
+  std::string at = path + "." + key;
+  if (!m) {
+    if constexpr (IsOpt<T>::value) return T(undefined);
+    else jsonShapeError(at, "a value", "undefined");
+  }
+  return JsonRead<T>::read(*m, at);
+}
+
+/// `JSON.parse(text) as T`.
+template <class T>
+T jsonParse(const String& text) {
+  JsonValue v = jsonParseTree(text);
+  return JsonRead<T>::read(v, "");
+}
+
+}  // namespace lucent