Fix js interface because of c++ updated.

Author: hzhangxyz

examples/main.js

@@ -31,18 +31,18 @@ const axiom3 = new rule_t(
 
 const premise = new rule_t("(! (! X))");
 const target = new rule_t("X");
-const target_hash = target.data_string();
+const target_hash = target.key();
 
 function main() {
     let rules = {};
     let facts = {};
 
     let cycle = -1;
-    rules[mp.data_string()] = [mp, cycle];
-    facts[axiom1.data_string()] = [axiom1, cycle];
-    facts[axiom2.data_string()] = [axiom2, cycle];
-    facts[axiom3.data_string()] = [axiom3, cycle];
-    facts[premise.data_string()] = [premise, cycle];
+    rules[mp.key()] = [mp, cycle];
+    facts[axiom1.key()] = [axiom1, cycle];
+    facts[axiom2.key()] = [axiom2, cycle];
+    facts[axiom3.key()] = [axiom3, cycle];
+    facts[premise.key()] = [premise, cycle];
 
     while (true) {
         let temp_rules = {};
@@ -59,7 +59,7 @@ function main() {
                 if (candidate === null) {
                     continue;
                 }
-                const candidate_hash = candidate.data_string();
+                const candidate_hash = candidate.key();
                 if (candidate.length() != 0) {
                     // rule
                     if (candidate_hash in rules || candidate_hash in temp_rules) {
@@ -84,11 +84,11 @@ function main() {
         cycle++;
         for (let r_hash in temp_rules) {
             const rule = temp_rules[r_hash];
-            rules[rule.data_string()] = [rule, cycle];
+            rules[rule.key()] = [rule, cycle];
         }
         for (let f_hash in temp_facts) {
             const fact = temp_facts[f_hash];
-            facts[fact.data_string()] = [fact, cycle];
+            facts[fact.key()] = [fact, cycle];
         }
     }
 }

jsds/ds.cc

@@ -1,13 +1,16 @@
 #include <ds/ds.hh>
 #include <emscripten/bind.h>
+#include <vector>
 
 namespace em = emscripten;
 
+// 由于embind的限制，这里无法使用string_view。
+// 为了保持一致性，一律使用复制。
 template<typename T>
-auto from_string(const std::string& text, int buffer_size) -> std::unique_ptr<T> {
+auto from_string(const std::string& string, int buffer_size) -> std::unique_ptr<T> {
     auto result = reinterpret_cast<T*>(operator new(buffer_size));
-    auto scan_result = result->scan(text.c_str(), reinterpret_cast<std::byte*>(result) + buffer_size);
-    if (scan_result == nullptr) {
+    auto scan_result = result->scan(string.data(), reinterpret_cast<std::byte*>(result) + buffer_size);
+    if (scan_result == nullptr) [[unlikely]] {
         operator delete(result);
         return std::unique_ptr<T>(nullptr);
     }
@@ -18,7 +21,7 @@ template<typename T>
 auto to_string(T* value, int buffer_size) -> std::string {
     auto result = reinterpret_cast<char*>(operator new(buffer_size));
     auto print_result = value->print(result, reinterpret_cast<char*>(result) + buffer_size);
-    if (print_result == nullptr || print_result - result == buffer_size) {
+    if (print_result == nullptr || print_result - result == buffer_size) [[unlikely]] {
         operator delete(result);
         return std::string();
     }
@@ -29,15 +32,18 @@ auto to_string(T* value, int buffer_size) -> std::string {
 }
 
 template<typename T>
-auto from_binary(const std::string& text) -> std::unique_ptr<T> {
-    auto dst = std::unique_ptr<T>(reinterpret_cast<T*>(operator new(text.size())));
-    memcpy(dst.get(), text.data(), text.size());
+auto from_binary(const std::vector<std::uint8_t>& binary) -> std::unique_ptr<T> {
+    auto dst = std::unique_ptr<T>(reinterpret_cast<T*>(operator new(binary.size())));
+    memcpy(dst.get(), binary.data(), binary.size());
     return dst;
 }
 
 template<typename T>
-auto to_binary(T* value) -> em::val {
-    return em::val(em::typed_memory_view(value->data_size(), reinterpret_cast<unsigned char*>(value)));
+auto to_binary(T* value) -> std::vector<std::uint8_t> {
+    std::vector<std::uint8_t> result;
+    result.resize(value->data_size());
+    memcpy(result.data(), value, value->data_size());
+    return result;
 }
 
 template<typename T>
@@ -57,23 +63,23 @@ auto common_declaration(em::class_<T>& t) {
     t.class_function("from_string", from_string<T>);
     t.class_function("to_string", to_string<T>, em::allow_raw_pointers());
     t.class_function("from_binary", from_binary<T>);
-    t.class_function("to_binary", to_binary<T>, em::return_value_policy::reference());
+    t.class_function("to_binary", to_binary<T>, em::allow_raw_pointers());
     t.function("clone", clone<T>, em::allow_raw_pointers());
     t.function("data_size", data_size<T>, em::allow_raw_pointers());
 }
 
-auto term_ground(ds::term_t* term, ds::term_t* dictionary, int length) -> std::unique_ptr<ds::term_t> {
+auto term_ground(ds::term_t* term, ds::term_t* dictionary, const char* scope, int length) -> std::unique_ptr<ds::term_t> {
     auto result = reinterpret_cast<ds::term_t*>(operator new(length));
-    if (result->ground(term, dictionary, reinterpret_cast<std::byte*>(result) + length) == nullptr) {
+    if (result->ground(term, dictionary, scope, reinterpret_cast<std::byte*>(result) + length) == nullptr) [[unlikely]] {
         operator delete(result);
         return std::unique_ptr<ds::term_t>(nullptr);
     }
     return std::unique_ptr<ds::term_t>(result);
 }
 
-auto rule_ground(ds::rule_t* rule, ds::rule_t* dictionary, int length) -> std::unique_ptr<ds::rule_t> {
+auto rule_ground(ds::rule_t* rule, ds::rule_t* dictionary, const char* scope, int length) -> std::unique_ptr<ds::rule_t> {
     ds::rule_t* result = reinterpret_cast<ds::rule_t*>(operator new(length));
-    if (result->ground(rule, dictionary, reinterpret_cast<std::byte*>(result) + length) == nullptr) {
+    if (result->ground(rule, dictionary, scope, reinterpret_cast<std::byte*>(result) + length) == nullptr) [[unlikely]] {
         operator delete(result);
         return std::unique_ptr<ds::rule_t>(nullptr);
     }
@@ -82,14 +88,16 @@ auto rule_ground(ds::rule_t* rule, ds::rule_t* dictionary, int length) -> std::u
 
 auto rule_match(ds::rule_t* rule_1, ds::rule_t* rule_2, int length) -> std::unique_ptr<ds::rule_t> {
     ds::rule_t* result = reinterpret_cast<ds::rule_t*>(operator new(length));
-    if (result->match(rule_1, rule_2, reinterpret_cast<std::byte*>(result) + length) == nullptr) {
+    if (result->match(rule_1, rule_2, reinterpret_cast<std::byte*>(result) + length) == nullptr) [[unlikely]] {
         operator delete(result);
         return std::unique_ptr<ds::rule_t>(nullptr);
     }
     return std::unique_ptr<ds::rule_t>(result);
 }
 
 EMSCRIPTEN_BINDINGS(ds) {
+    em::register_vector<std::uint8_t>("Buffer");
+
     auto string_t = em::class_<ds::string_t>("String");
     auto item_t = em::class_<ds::item_t>("Item");
     auto variable_t = em::class_<ds::variable_t>("Variable");

jsds/jsds.mjs

@@ -26,7 +26,7 @@ class _common_t {
         } else if (value instanceof this.type) {
             this.value = value;
             this.capacity = size;
-        } else if (value instanceof Uint8Array) {
+        } else if (value instanceof ds.Buffer) {
             this.value = this.type.from_binary(value);
             this.capacity = this.size();
             if (size != 0) {
@@ -55,18 +55,17 @@ class _common_t {
         return this.type.to_binary(this.value);
     }
 
-    data_string() {
-        const decoder = new TextDecoder("utf-8");
-        return decoder.decode(this.data());
-    }
-
     size() {
         return this.value.data_size();
     }
 
     copy() {
         return new this.constructor(this.value.clone(), this.size());
     }
+
+    key() {
+        return this.toString();
+    }
 }
 
 export class string_t extends _common_t {
@@ -127,9 +126,9 @@ export class term_t extends _common_t {
         }
     }
 
-    ground(other) {
+    ground(other, scope = null) {
         const capacity = buffer_size();
-        const term = this.type.ground(this.value, other.value, capacity);
+        const term = this.type.ground(this.value, other.value, scope, capacity);
         if (term == null) {
             return null;
         }
@@ -154,9 +153,9 @@ export class rule_t extends _common_t {
         return new term_t(this.value.conclusion());
     }
 
-    ground(other) {
+    ground(other, scope = null) {
         const capacity = buffer_size();
-        const rule = this.type.ground(this.value, other.value, capacity);
+        const rule = this.type.ground(this.value, other.value, scope, capacity);
         if (rule == null) {
             return null;
         }