Persistence fixes.

Author: c-smile

cutils.h

@@ -27,6 +27,7 @@
 
 #include <stdlib.h>
 #include <inttypes.h>
+#include <string.h>
 
 #ifdef _MSC_VER
   #include <windows.h>

qjscalc.c

@@ -81,6 +81,7 @@ DEF(await, "await")
 DEF(empty_string, "")
 /* identifiers */
 DEF(length, "length")
+DEF(tag, "tag")
 DEF(fileName, "fileName")
 DEF(lineNumber, "lineNumber")
 DEF(message, "message")

quickjs-atom.h

@@ -0,0 +1,124 @@
+/*
+ * QuickJS: binary JSON module (test only)
+ *
+ * Copyright (c) 2017-2019 Fabrice Bellard
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include "quickjs-libc.h"
+#include "cutils.h"
+
+static JSValue js_bjson_read(JSContext *ctx, JSValueConst this_val,
+  int argc, JSValueConst *argv)
+{
+  uint8_t *buf;
+  uint64_t pos = 0, len = 0;
+  JSValue obj;
+  JSValue cb = JS_UNINITIALIZED;
+  size_t size;
+  int flags;
+
+  if (argc > 1) {
+    if (JS_IsFunction(ctx, argv[1])) 
+      cb = argv[1];
+    else if (JS_ToIndex(ctx, &pos, argv[1]))
+      return JS_EXCEPTION;
+    if (argc > 2) {
+      if (JS_ToIndex(ctx, &len, argv[2]))
+        return JS_EXCEPTION;
+    }
+  }
+  buf = JS_GetArrayBuffer(ctx, &size, argv[0]);
+  if (!buf)
+    return JS_EXCEPTION;
+
+  if (len == 0)
+    len = size - pos;
+
+  if (pos + len > size)
+    return JS_ThrowRangeError(ctx, "array buffer overflow");
+  flags = 0;
+  if (argc > 3 && JS_ToBool(ctx, argv[3]))
+    flags |= JS_READ_OBJ_REFERENCE;
+
+  if (cb != JS_UNINITIALIZED) {
+    cb = JS_DupValue(ctx,cb);
+    size_t rest = 0;
+    uint8_t *sbuf = buf;
+    uint64_t slen = len;
+    uint8_t *send = buf + len;
+    do {
+      obj = JS_ReadObject2(ctx, sbuf, slen, flags, &rest);
+      sbuf = send - rest;
+      slen = rest;
+      JSValue rv = JS_Call(ctx, cb, JS_UNDEFINED, 1, &obj);
+      JS_FreeValue(ctx, obj);
+      if (JS_IsException(rv)) {
+        JS_FreeValue(ctx, cb);
+        return rv;
+      }
+      if (rv == JS_FALSE)
+        break;
+    } while (rest);
+    JS_FreeValue(ctx, cb);
+    return JS_NewInt64(ctx, rest);
+  }
+  else 
+    obj = JS_ReadObject(ctx, buf + pos, len, flags);
+  return obj;
+}
+
+static JSValue js_bjson_write(JSContext *ctx, JSValueConst this_val,
+  int argc, JSValueConst *argv)
+{
+  size_t len;
+  uint8_t *buf;
+  JSValue array;
+  int flags;
+
+  flags = 0;
+  if (JS_ToBool(ctx, argv[1]))
+    flags |= JS_WRITE_OBJ_REFERENCE;
+  buf = JS_WriteObject(ctx, &len, argv[0], flags);
+  if (!buf)
+    return JS_EXCEPTION;
+  array = JS_NewArrayBufferCopy(ctx, buf, len);
+  js_free(ctx, buf);
+  return array;
+}
+
+static const JSCFunctionListEntry js_bjson_funcs[] = {
+    JS_CFUNC_DEF("read", 4, js_bjson_read),
+    JS_CFUNC_DEF("write", 2, js_bjson_write),
+};
+
+static int js_bjson_init(JSContext *ctx, JSModuleDef *m)
+{
+  return JS_SetModuleExportList(ctx, m, js_bjson_funcs,
+    countof(js_bjson_funcs));
+}
+
+JSModuleDef *js_init_module_bjson(JSContext *ctx, const char *module_name)
+{
+  JSModuleDef *m;
+  m = JS_NewCModule(ctx, module_name, js_bjson_init);
+  if (!m) return NULL;
+  JS_AddModuleExportList(ctx, m, js_bjson_funcs, countof(js_bjson_funcs));
+  return m;
+}

quickjs-bjson.c

@@ -40,8 +40,11 @@ static int js_parse_jsx_expr(JSParseState *s, int level)
   JSValue tag = JS_UNINITIALIZED;
   JSAtom  attr_name = JS_ATOM_NULL;
   JSValue attr_value = JS_UNINITIALIZED;
+  int token_read = 0;
+  int is_bodyless = 0;
 
   const char* errmsg = "invalid JSX expression";
+  char  msg_buffer[512] = { 0 };
 #if defined(CONFIG_JSX_SCITER) // HTML shortcuts used by Sciter
   char class_buffer[512] = { 0 };
 #endif
@@ -107,7 +110,9 @@ static int js_parse_jsx_expr(JSParseState *s, int level)
         errmsg = "expecting '>'";
         goto fail;
       }
-      goto GENERATE_KIDS;
+      //goto GENERATE_KIDS;
+      is_bodyless = 1;
+      break;
     }
 #if defined(CONFIG_JSX_SCITER) // HTML shortcuts used by Sciter
     if (s->token.val == '#') { // <div #some> ->  <div id="some">
@@ -192,16 +197,29 @@ static int js_parse_jsx_expr(JSParseState *s, int level)
         goto fail;
     }
 
-    if (js_parse_expect(s, '='))
+    if (s->token.val != '=') {
+      token_read = 1;
+      attr_value = JS_AtomToString(s->ctx, JS_ATOM_empty_string);
+      goto PUSH_ATTR_VALUE;
+    }
+    else {
+      token_read = 0;
+      if (next_token(s)) // eat `=`
       goto fail;
+    }
 
     if (s->token.val == TOK_STRING) {
-      attr_value = JS_DupValue(s->ctx,s->token.u.str.str);
+      attr_value = JS_DupValue(s->ctx, s->token.u.str.str);
  PUSH_ATTR_VALUE:
       if (emit_push_const(s, attr_value, 0))
         goto fail;
       JS_FreeValue(s->ctx, attr_value);
     }
+    else if (s->token.val == TOK_TEMPLATE) {
+      if (js_parse_template(s, 0, NULL))
+        goto fail;
+      token_read = 1;
+    }
     else if (s->token.val == '{')
     {
       if (next_token(s))
@@ -213,15 +231,34 @@ static int js_parse_jsx_expr(JSParseState *s, int level)
         goto fail;
       }
     }
+    else if(s->token.val == TOK_NUMBER) {
+      attr_value = JS_DupValue(s->ctx,s->token.u.num.val);
+      goto PUSH_ATTR_VALUE;
+    }
+    else if (s->token.val == TOK_FALSE) {
+      emit_op(s, OP_push_false);
+    }
+    else if (s->token.val == TOK_TRUE) {
+      emit_op(s, OP_push_true);
+    }
+    else if (s->token.val == TOK_NULL) {
+      emit_op(s, OP_null);
+    }
+    else {
+      errmsg = "bad attribute value";
+      goto fail;
+    }
 
     set_object_name(s, attr_name);
     emit_op(s, OP_define_field);
     emit_atom(s, attr_name);
     JS_FreeAtom(s->ctx, attr_name);
 
+    if (!token_read) {
     if (next_web_token(s))
       goto fail;
   }
+  }
 
 #if defined(CONFIG_JSX_SCITER) // HTML shortcuts used by Sciter
   if (class_buffer[0]) { // add remaining classes 
@@ -239,7 +276,8 @@ static int js_parse_jsx_expr(JSParseState *s, int level)
 
   // parse content of the element
 
-  for (;;) {
+  while(!is_bodyless) 
+  {
     const uint8_t *p;
     p = s->last_ptr = s->buf_ptr;
     s->last_line_num = s->token.line_num;
@@ -271,7 +309,12 @@ static int js_parse_jsx_expr(JSParseState *s, int level)
           goto fail;
         if (token_is_ident(s->token.val)) {  /* keywords and reserved words have a valid atom */
           if (s->token.u.ident.atom != tag_atom) {
-            errmsg = "head and tail tags do not match";
+            char atail[64];
+            char ahead[64];
+            snprintf(msg_buffer, countof(msg_buffer), "head <%s> and tail </%s> tags do not match",
+              JS_AtomGetStr(s->ctx, ahead, countof(ahead), tag_atom),
+              JS_AtomGetStr(s->ctx, atail, countof(atail), s->token.u.ident.atom));
+            errmsg = msg_buffer;
             goto fail;
           }
           if (next_token(s))
@@ -301,7 +344,7 @@ static int js_parse_jsx_expr(JSParseState *s, int level)
     }
   }
 
-GENERATE_KIDS:
+//GENERATE_KIDS:
   emit_op(s, OP_array_from);
   emit_u16(s, kids_count);
 
@@ -315,15 +358,11 @@ static int js_parse_jsx_expr(JSParseState *s, int level)
 
   JS_FreeValue(s->ctx, tag);
   JS_FreeAtom(s->ctx, tag_atom);
-  //JS_FreeAtom(s->ctx, attr_name);
-  //JS_FreeValue(s->ctx, attr_value);
 
   return 0;
 fail:
   JS_FreeValue(s->ctx, tag);
   JS_FreeAtom(s->ctx, tag_atom);
-  JS_FreeAtom(s->ctx, attr_name);
-  //JS_FreeValue(s->ctx, attr_value);
   return js_parse_error(s, errmsg);
 }