Commit 5c2d4bc629f1082890c692a3b2fea4ed84b54b06

Thomas de Grivel 2025-01-02T19:49:43

deserialize

diff --git a/.ikc3_history b/.ikc3_history
index 0c6d479..4e0874a 100644
--- a/.ikc3_history
+++ b/.ikc3_history
@@ -1,16 +1,3 @@
-type(F128)
-:F128
-type(:F128)
-:F128 == F128
-F128.cos
-(F128) 0.1 + (F128) 0.1
-(F128) 0.01 + (F128) 0.01
-(F64) 0.01 + (F64) 0.01
-(F64) 0.001 + (F64) 0.001
-(F64) 0.0001 + (F64) 0.0001
-(F64) 0.00001 + (F64) 0.00001
-(F64) 0.000001 + (F64) 0.000001
-(F64) 0.000002 + (F64) 0.000002
 (F64) 0.0000002 + (F64) 0.0000002
 (F64) 0.0000001 + (F64) 0.0000001
 (F64) 0.000001 + (F64) 0.000003
@@ -97,3 +84,17 @@ Metric.get("/plop")
 Metric.get("/plop") + 1
 Metric.get("/plop")
 Metric.hit("/plop")
+s = Serialize.new()
+Serialize.tag(s, 123)
+Serialize.to_str(s)
+s = Serialize.new()
+Serialize.tag(s, 123)
+Serialize.to_str(s)
+s = Serialize.new()
+s = Serialize.tag_to_str(12)
+Deserialize.str_to_tag(s)
+s = Serialize.tag_to_str(12)
+Deserialize.str_to_tag(s)
+s = Serialize.tag_to_str(12)
+Deserialize.str_to_tag(s)
+
diff --git a/lib/kc3/0.1/deserialize.kc3 b/lib/kc3/0.1/deserialize.kc3
index 35c42fa..82dc84c 100644
--- a/lib/kc3/0.1/deserialize.kc3
+++ b/lib/kc3/0.1/deserialize.kc3
@@ -1,5 +1,19 @@
 defmodule Deserialize do
 
-  def tag = cfn Tag "kc3_deserialize_tag" (Buf, Result)
+  def delete = cfn Void "kc3_deserialize_delete" (Ptr)
+
+  def from_str = cfn Bool "kc3_deserialize_from_str" (Ptr, Str)
+
+  def new = cfn Ptr "kc3_deserialize_new" (Result)
+
+  def str_to_tag = fn (str) {
+    ds = Deserialize.new()
+    Deserialize.from_str(ds, str)
+    tag = Deserialize.tag(ds)
+    Deserialize.delete(ds)
+    tag
+  }
+
+  def tag = cfn Tag "kc3_deserialize_tag" (Ptr, Result)
 
 end
diff --git a/lib/kc3/0.1/serialize.kc3 b/lib/kc3/0.1/serialize.kc3
index 28633cd..d47df0b 100644
--- a/lib/kc3/0.1/serialize.kc3
+++ b/lib/kc3/0.1/serialize.kc3
@@ -8,4 +8,12 @@ defmodule Serialize do
 
   def to_str = cfn Str "kc3_serialize_to_str" (Ptr, Result)
 
+  def tag_to_str = fn (tag) {
+    s = Serialize.new()
+    Serialize.tag(s, tag)
+    str = Serialize.to_str(s)
+    Serialize.delete(s)
+    str
+  }
+
 end
diff --git a/libkc3/deserialize.c b/libkc3/deserialize.c
index 019c85c..e0e1e3f 100644
--- a/libkc3/deserialize.c
+++ b/libkc3/deserialize.c
@@ -10,14 +10,36 @@
  * AUTHOR BE CONSIDERED LIABLE FOR THE USE AND PERFORMANCE OF
  * THIS SOFTWARE.
  */
+#include "alloc.h"
 #include "assert.h"
 #include "buf.h"
 #include "deserialize.h"
 #include "map.h"
+#include "tag_type.h"
+
+bool * deserialize_bool (s_deserialize *ds, bool *dest)
+{
+  u8 x;
+  deserialize_u8(ds, &x);
+  *dest = x ? 1 : 0;
+  return dest;
+}
 
-bool *      deserialize_bool (s_deserialize *ds, bool *dest);
 character * deserialize_character (s_deserialize *ds, character *c);
 
+void deserialize_delete (s_deserialize *ds)
+{
+  //deserialize_clean(ds);
+  free(ds);
+}
+
+bool deserialize_from_str (s_deserialize *ds, s_str *str)
+{
+  if (! buf_init_str(&ds->buf, false, str))
+    return false;
+  return true;
+}
+
 s_deserialize * deserialize_init (s_deserialize *ds)
 {
   s_deserialize tmp = {0};
@@ -27,7 +49,34 @@ s_deserialize * deserialize_init (s_deserialize *ds)
 }
 
 s_list **   deserialize_list (s_deserialize *ds, s_list **list);
-s_tag *     deserialize_tag (s_deserialize *ds,  s_tag *tag);
+
+s_deserialize * deserialize_new (void)
+{
+  s_deserialize *ds;
+  ds = alloc(sizeof(s_deserialize));
+  return ds;
+}
+
+s_tag * deserialize_tag (s_deserialize *ds, s_tag *tag)
+{
+  u8 u8;
+  if (! deserialize_u8(ds, &u8))
+    return NULL;
+  tag->type = u8;
+  switch (tag->type) {
+  case TAG_U8:
+    deserialize_u8(ds, &tag->data.u8);
+    break;
+  default:
+    err_write_1("deserialize_tag: not implemented: ");
+    err_write_1(tag_type_to_string(tag->type));
+    err_write_1("\n");
+    assert(! "deserialize_tag: not implemented");
+    return NULL;
+  }
+  return tag;
+}
+
 s_tuple *   deserialize_tuple (s_deserialize *ds, s_tuple *tuple);
 s8 *        deserialize_s8 (s_deserialize *ds, s8 *x);
 s16 *       deserialize_s16 (s_deserialize *ds, s16 *x);
diff --git a/libkc3/deserialize.h b/libkc3/deserialize.h
index 1d2cfe5..92a788f 100644
--- a/libkc3/deserialize.h
+++ b/libkc3/deserialize.h
@@ -21,8 +21,14 @@
 
 #include "types.h"
 
+/* Heap-allocation functions, call deserialize_delete after use. */
+s_deserialize * deserialize_new (void);
+void            deserialize_delete (s_deserialize *ds);
+
+/* Operators. */
 bool *      deserialize_bool (s_deserialize *ds, bool *dest);
 character * deserialize_character (s_deserialize *ds, character *c);
+bool        deserialize_from_str (s_deserialize *ds, s_str *str);
 s_list **   deserialize_list (s_deserialize *ds, s_list **list);
 s_tag *     deserialize_tag (s_deserialize *ds,  s_tag *tag);
 s_tuple *   deserialize_tuple (s_deserialize *ds, s_tuple *tuple);
diff --git a/libkc3/kc3.c b/libkc3/kc3.c
index be79b6a..8594901 100644
--- a/libkc3/kc3.c
+++ b/libkc3/kc3.c
@@ -32,6 +32,7 @@
 #include "buf_fd.h"
 #include "buf_parse.h"
 #include "call.h"
+#include "deserialize.h"
 #include "env.h"
 #include "env_fork.h"
 #include "eval.h"
@@ -185,6 +186,31 @@ s_tag * kc3_defstruct (s_list **spec, s_tag *dest)
   return dest;
 }
 
+void kc3_deserialize_delete (s_deserialize **ds)
+{
+  deserialize_delete(*ds);
+}
+
+bool kc3_deserialize_from_str (s_deserialize **ds, s_str *str)
+{
+  return deserialize_from_str(*ds, str);
+}
+
+s_deserialize ** kc3_deserialize_new (s_deserialize **ds)
+{
+  s_deserialize *tmp;
+  tmp = deserialize_new();
+  if (! tmp)
+    return NULL;
+  *ds = tmp;
+  return ds;
+}
+
+s_tag * kc3_deserialize_tag (s_deserialize **ds, s_tag *dest)
+{
+  return deserialize_tag(*ds, dest);
+}
+
 void ** kc3_dlopen (const s_str *path, void **dest)
 {
   assert(path);
diff --git a/libkc3/serialize.c b/libkc3/serialize.c
index 2643603..8b3df23 100644
--- a/libkc3/serialize.c
+++ b/libkc3/serialize.c
@@ -106,6 +106,7 @@ DEF_SERIALIZE(sw)
 
 s_serialize * serialize_tag (s_serialize *serialize, const s_tag *tag)
 {
+  serialize_u8(serialize, tag->type);
   switch (tag->type){
   case TAG_BOOL: return serialize_bool(serialize, tag->data.bool_);
   case TAG_CHARACTER: