wrap typed_array and object for fscript

dllexports/awtk.def

@@ -1827,6 +1827,8 @@ EXPORTS
     font_stb_create
     fscript_ext_init
     fscript_math_register
+    fscript_object_register
+    fscript_typed_array_register
     image_loader_stb
     stb_load_image
     input_method_default_create
@@ -2116,6 +2118,10 @@ EXPORTS
     object_default_clear_props
     object_default_find_prop
     object_locker_create
+    object_rbuffer_create
+    object_typed_array_create
+    object_wbuffer_create
+    object_wbuffer_create_extendable
     tk_ostream_write
     tk_ostream_seek
     tk_ostream_write_len

dllexports/tkc.def

@@ -807,6 +807,10 @@ EXPORTS
     object_default_clear_props
     object_default_find_prop
     object_locker_create
+    object_rbuffer_create
+    object_typed_array_create
+    object_wbuffer_create
+    object_wbuffer_create_extendable
     tk_ostream_write
     tk_ostream_seek
     tk_ostream_write_len

src/fscript_ext/fscript_ext.c

@@ -14,17 +14,26 @@
  *
  */
 
+#include "tkc/fscript.h"
 #include "fscript_ext/fscript_math.h"
+#include "fscript_ext/fscript_object.h"
+#include "fscript_ext/fscript_typed_array.h"
 
 #if defined(LINUX) || defined(WINDOWS) || defined(MACOS) || defined(ANDROID) || defined(IOS)
 #define FSCRIPT_WITH_MATH 1
+#define FSCRIPT_WITH_TYPED_ARRAY 1
 #endif/*PC*/
 
 ret_t fscript_ext_init(void) {
+  fscript_object_register();
 #ifdef FSCRIPT_WITH_MATH
   fscript_math_register();
 #endif/*FSCRIPT_WITH_MATH*/
 
+#ifdef FSCRIPT_WITH_TYPED_ARRAY
+  fscript_typed_array_register();
+#endif/*FSCRIPT_WITH_TYPED_ARRAY*/
+
   return RET_OK;
 }
 

src/fscript_ext/fscript_object.c

@@ -0,0 +1,83 @@
+/**
+ * File:   fscript_ext.h
+ * Author: AWTK Develop Team
+ * Brief:  ext functions for fscript
+ *
+ * Copyright (c) 2020 - 2021  Guangzhou ZHIYUAN Electronics Co.,Ltd.
+ *
+ */
+
+/**
+ * History:
+ * ================================================================
+ * 2021-01-03 Li XianJing <lixianjing@zlg.cn> created
+ *
+ */
+
+#include "tkc/fscript.h"
+#include "tkc/object_default.h"
+#include "fscript_ext/fscript_object.h"
+
+static ret_t func_object_ref(fscript_t* fscript, fscript_args_t* args, value_t* result) {
+  object_t* obj = NULL;
+  FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
+  obj = value_object(args->args);
+  return_value_if_fail(obj != NULL, RET_BAD_PARAMS);
+
+  OBJECT_REF(obj);
+  value_set_object(result, obj);
+
+  return RET_OK;
+}
+
+static ret_t func_object_unref(fscript_t* fscript, fscript_args_t* args, value_t* result) {
+  object_t* obj = NULL;
+  FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
+  obj = value_object(args->args);
+  return_value_if_fail(obj != NULL, RET_BAD_PARAMS);
+
+  OBJECT_UNREF(obj);
+
+  return RET_OK;
+}
+
+static ret_t func_object_get_prop(fscript_t* fscript, fscript_args_t* args, value_t* result) {
+  object_t* obj = NULL;
+  FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
+  obj = value_object(args->args);
+  return_value_if_fail(obj != NULL, RET_BAD_PARAMS);
+
+  object_get_prop(obj, value_str(args->args+1), result);
+
+  return RET_OK;
+}
+
+static ret_t func_object_set_prop(fscript_t* fscript, fscript_args_t* args, value_t* result) {
+  object_t* obj = NULL;
+  FSCRIPT_FUNC_CHECK(args->size == 3, RET_BAD_PARAMS);
+  obj = value_object(args->args);
+  return_value_if_fail(obj != NULL, RET_BAD_PARAMS);
+
+  value_set_bool(result, object_set_prop(obj, value_str(args->args+1), args->args+2) == RET_OK);
+
+  return RET_OK;
+}
+
+static ret_t func_object_create(fscript_t* fscript, fscript_args_t* args, value_t* result) {
+  object_t* obj = object_default_create();
+  return_value_if_fail(obj != NULL, RET_BAD_PARAMS);
+
+  value_set_object(result, obj);
+
+  return RET_OK;
+}
+
+ret_t fscript_object_register(void) {
+  ENSURE(fscript_register_func("object_create", func_object_create) == RET_OK);
+  ENSURE(fscript_register_func("object_ref", func_object_ref) == RET_OK);
+  ENSURE(fscript_register_func("object_unref", func_object_unref) == RET_OK);
+  ENSURE(fscript_register_func("object_set", func_object_set_prop) == RET_OK);
+  ENSURE(fscript_register_func("object_get", func_object_get_prop) == RET_OK);
+  
+  return RET_OK;
+}

src/fscript_ext/fscript_object.h

@@ -0,0 +1,35 @@
+/**
+ * File:   fscript_object.h
+ * Author: AWTK Develop Team
+ * Brief:  object functions for fscript
+ *
+ * Copyright (c) 2020 - 2021  Guangzhou ZHIYUAN Electronics Co.,Ltd.
+ *
+ */
+
+/**
+ * History:
+ * ================================================================
+ * 2021-01-03 Li XianJing <lixianjing@zlg.cn> created
+ *
+ */
+
+#ifndef TK_FSCRIPT_OBJECT_H
+#define TK_FSCRIPT_OBJECT_H
+
+#include "tkc/str.h"
+#include "tkc/object.h"
+
+BEGIN_C_DECLS
+
+/**
+ * @method fscript_object_register
+ * 注册object函数。
+ *
+ * @return {ret_t} 返回RET_OK表示成功，否则表示失败。
+ */
+ret_t fscript_object_register(void);
+
+END_C_DECLS
+
+#endif /*TK_FSCRIPT_OBJECT_H*/

src/fscript_ext/fscript_typed_array.c

@@ -0,0 +1,167 @@
+/**
+ * File:   fscript_typed_array.c
+ * Author: AWTK Develop Team
+ * Brief:  typed_array functions for fscript
+ *
+ * Copyright (c) 2020 - 2021  Guangzhou ZHIYUAN Electronics Co.,Ltd.
+ *
+ */
+
+/**
+ * History:
+ * ================================================================
+ * 2021-01-03 Li XianJing <lixianjing@zlg.cn> created
+ *
+ */
+
+
+#include "tkc/fscript.h"
+#include "tkc/object_typed_array.h"
+
+static ret_t func_array_create(fscript_t* fscript, fscript_args_t* args, value_t* result) {
+  object_t* obj = NULL;
+  uint32_t capacity = 0;
+  const char* stype = NULL;
+  value_type_t type = VALUE_TYPE_INT8;
+  FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
+  stype = value_str(args->args);
+  capacity = value_uint32(args->args+1);
+
+  if(tk_str_eq(stype, "i8")) {
+    type = VALUE_TYPE_INT8;
+  } else if(tk_str_eq(stype, "i16")) {
+    type = VALUE_TYPE_INT16;
+  } else if(tk_str_eq(stype, "i32")) {
+    type = VALUE_TYPE_INT32;
+  } else if(tk_str_eq(stype, "i64")) {
+    type = VALUE_TYPE_INT64;
+  } else if(tk_str_eq(stype, "u8")) {
+    type = VALUE_TYPE_UINT8;
+  } else if(tk_str_eq(stype, "u16")) {
+    type = VALUE_TYPE_UINT16;
+  } else if(tk_str_eq(stype, "u32")) {
+    type = VALUE_TYPE_UINT32;
+  } else if(tk_str_eq(stype, "u64")) {
+    type = VALUE_TYPE_UINT64;
+  } else if(tk_str_eq(stype, "f32")) {
+    type = VALUE_TYPE_FLOAT32;
+  } else if(tk_str_eq(stype, "float")) {
+    type = VALUE_TYPE_DOUBLE;
+  } else {
+    type = VALUE_TYPE_INT32;
+  }
+
+  obj = object_typed_array_create(type, capacity);
+  value_set_object(result, obj);
+
+  return RET_OK;
+}
+
+static typed_array_t* get_typed_array(fscript_t* fscript, fscript_args_t* args) {
+  object_t* obj = value_object(args->args);
+  return_value_if_fail(obj != NULL, NULL);
+
+  return OBJECT_TYPED_ARRAY(obj)->arr;
+}
+
+static ret_t func_array_push(fscript_t* fscript, fscript_args_t* args, value_t* result) {
+  typed_array_t* arr = NULL;
+  FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
+  arr = get_typed_array(fscript, args);
+  return_value_if_fail(arr != NULL, RET_BAD_PARAMS);
+
+  value_set_bool(result, typed_array_push(arr, args->args+1) == RET_OK);
+  
+  return RET_OK;
+}
+
+static ret_t func_array_pop(fscript_t* fscript, fscript_args_t* args, value_t* result) {
+  typed_array_t* arr = NULL;
+  FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
+  arr = get_typed_array(fscript, args);
+  return_value_if_fail(arr != NULL, RET_BAD_PARAMS);
+
+  return typed_array_pop(arr, result);
+}
+
+static ret_t func_array_set(fscript_t* fscript, fscript_args_t* args, value_t* result) {
+  typed_array_t* arr = NULL;
+  FSCRIPT_FUNC_CHECK(args->size == 3, RET_BAD_PARAMS);
+  arr = get_typed_array(fscript, args);
+  return_value_if_fail(arr != NULL, RET_BAD_PARAMS);
+
+  value_set_bool(result, typed_array_set(arr, value_uint32(args->args+1), args->args+2) == RET_OK);
+
+  return RET_OK;
+}
+
+static ret_t func_array_get(fscript_t* fscript, fscript_args_t* args, value_t* result) {
+  typed_array_t* arr = NULL;
+  FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
+  arr = get_typed_array(fscript, args);
+  return_value_if_fail(arr != NULL, RET_BAD_PARAMS);
+
+  typed_array_get(arr, value_uint32(args->args+1), result);
+
+  return RET_OK;
+}
+
+static ret_t func_array_size(fscript_t* fscript, fscript_args_t* args, value_t* result) {
+  typed_array_t* arr = NULL;
+  FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
+  arr = get_typed_array(fscript, args);
+  return_value_if_fail(arr != NULL, RET_BAD_PARAMS);
+
+  value_set_uint32(result, arr->size);
+
+  return RET_OK;
+}
+
+static ret_t func_array_byte_size(fscript_t* fscript, fscript_args_t* args, value_t* result) {
+  typed_array_t* arr = NULL;
+  FSCRIPT_FUNC_CHECK(args->size == 1, RET_BAD_PARAMS);
+  arr = get_typed_array(fscript, args);
+  return_value_if_fail(arr != NULL, RET_BAD_PARAMS);
+
+  value_set_uint32(result, arr->size * arr->element_size);
+
+  return RET_OK;
+}
+
+static ret_t func_array_insert(fscript_t* fscript, fscript_args_t* args, value_t* result) {
+  typed_array_t* arr = NULL;
+  FSCRIPT_FUNC_CHECK(args->size == 3, RET_BAD_PARAMS);
+  arr = get_typed_array(fscript, args);
+  return_value_if_fail(arr != NULL, RET_BAD_PARAMS);
+
+  value_set_bool(result, typed_array_insert(arr, value_uint32(args->args+1), args->args+2) == RET_OK);
+
+  return RET_OK;
+}
+
+static ret_t func_array_remove(fscript_t* fscript, fscript_args_t* args, value_t* result) {
+  typed_array_t* arr = NULL;
+  FSCRIPT_FUNC_CHECK(args->size == 2, RET_BAD_PARAMS);
+  arr = get_typed_array(fscript, args);
+  return_value_if_fail(arr != NULL, RET_BAD_PARAMS);
+
+  value_set_bool(result, typed_array_remove(arr, value_uint32(args->args+1)) == RET_OK);
+
+  return RET_OK;
+}
+
+ret_t fscript_typed_array_register(void) {
+  ENSURE(fscript_register_func("typed_array_create", func_array_create) == RET_OK);
+  ENSURE(fscript_register_func("typed_array_push", func_array_push) == RET_OK);
+  ENSURE(fscript_register_func("typed_array_pop", func_array_pop) == RET_OK);
+  ENSURE(fscript_register_func("typed_array_get", func_array_get) == RET_OK);
+  ENSURE(fscript_register_func("typed_array_set", func_array_set) == RET_OK);
+  ENSURE(fscript_register_func("typed_array_size", func_array_size) == RET_OK);
+  ENSURE(fscript_register_func("typed_array_byte_size", func_array_byte_size) == RET_OK);
+  ENSURE(fscript_register_func("typed_array_insert", func_array_insert) == RET_OK);
+  ENSURE(fscript_register_func("typed_array_remove", func_array_remove) == RET_OK);
+
+  return RET_OK;
+}
+
+

src/fscript_ext/fscript_typed_array.h

@@ -0,0 +1,35 @@
+/**
+ * File:   fscript_typed_array.h
+ * Author: AWTK Develop Team
+ * Brief:  typed_array functions for fscript
+ *
+ * Copyright (c) 2020 - 2021  Guangzhou ZHIYUAN Electronics Co.,Ltd.
+ *
+ */
+
+/**
+ * History:
+ * ================================================================
+ * 2021-01-03 Li XianJing <lixianjing@zlg.cn> created
+ *
+ */
+
+#ifndef TK_FSCRIPT_TYPED_ARRAY_H
+#define TK_FSCRIPT_TYPED_ARRAY_H
+
+#include "tkc/str.h"
+#include "tkc/object.h"
+
+BEGIN_C_DECLS
+
+/**
+ * @method fscript_typed_array_register
+ * 注册typed array函数。
+ *
+ * @return {ret_t} 返回RET_OK表示成功，否则表示失败。
+ */
+ret_t fscript_typed_array_register(void);
+
+END_C_DECLS
+
+#endif /*TK_FSCRIPT_TYPED_ARRAY_H*/

src/tkc/object_rbuffer.c

@@ -0,0 +1,81 @@
+/**
+ * File:   object_rbuffer.c
+ * Author: AWTK Develop Team
+ * Brief:  wrap rbuffer to an object.
+ *
+ * Copyright (c) 2020 - 2021  Guangzhou ZHIYUAN Electronics Co.,Ltd.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY { without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * License file for more details.
+ *
+ */
+
+/**
+ * History:
+ * ================================================================
+ * 2021-01-03 Li XianJing <xianjimli@hotmail.com> created
+ *
+ */
+
+#include "tkc/mem.h"
+#include "tkc/value.h"
+#include "tkc/utils.h"
+#include "object_rbuffer.h"
+
+static ret_t object_rbuffer_on_destroy(object_t* obj) {
+  return RET_OK;
+}
+
+static ret_t object_rbuffer_set_prop(object_t* obj, const char* name, const value_t* v) {
+  return RET_NOT_FOUND;
+}
+
+static ret_t object_rbuffer_get_prop(object_t* obj, const char* name, value_t* v) {
+  ret_t ret = RET_NOT_FOUND;
+  object_rbuffer_t* o = OBJECT_RBUFFER(obj);
+  return_value_if_fail(o != NULL && o->rbuffer != NULL, RET_BAD_PARAMS);
+
+  if(tk_str_eq(name, "cursor")) {
+    value_set_uint32(v, o->rbuffer->cursor);
+    ret = RET_OK;
+  } else if(tk_str_eq(name, "capacity")) {
+    value_set_uint32(v, o->rbuffer->capacity);
+    ret = RET_OK;
+  } else if(tk_str_eq(name, "data")) {
+    value_set_pointer(v, (void*)(o->rbuffer->data));
+    ret = RET_OK;
+  }
+
+  return ret;
+}
+
+static const object_vtable_t s_object_rbuffer_vtable = {.type = "object_rbuffer",
+                                                       .desc = "object_rbuffer",
+                                                       .size = sizeof(object_rbuffer_t),
+                                                       .is_collection = FALSE,
+                                                       .on_destroy = object_rbuffer_on_destroy,
+                                                       .get_prop = object_rbuffer_get_prop,
+                                                       .set_prop = object_rbuffer_set_prop
+};
+
+object_t* object_rbuffer_create(const uint8_t* data, uint32_t capacity) {
+  object_t* o = NULL;
+  object_rbuffer_t* wrapper = NULL;
+  o = object_create(&s_object_rbuffer_vtable);
+  return_value_if_fail(o != NULL, NULL);
+
+  wrapper = OBJECT_RBUFFER(o);
+  return_value_if_fail(wrapper != NULL, NULL);
+
+  wrapper->rbuffer = rbuffer_init(&(wrapper->arbuffer), data, capacity);
+
+  return o;
+}
+
+object_rbuffer_t* object_rbuffer_cast(object_t* obj) {
+  return_value_if_fail(obj != NULL && obj->vt == &s_object_rbuffer_vtable, NULL);
+
+  return (object_rbuffer_t*)(obj);
+}

src/tkc/object_rbuffer.h

@@ -0,0 +1,71 @@
+/**
+ * File:   object_rbuffer.h
+ * Author: AWTK Develop Team
+ * Brief:  wrap rbuffer to an object.
+ *
+ * Copyright (c) 2020 - 2021  Guangzhou ZHIYUAN Electronics Co.,Ltd.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * License file for more details.
+ *
+ */
+
+/**
+ * History:
+ * ================================================================
+ * 2021-01-03 Li XianJing <xianjimli@hotmail.com> created
+ *
+ */
+
+#ifndef TK_OBJECT_RBUFFER_H
+#define TK_OBJECT_RBUFFER_H
+
+#include "tkc/object.h"
+#include "tkc/buffer.h"
+
+BEGIN_C_DECLS
+
+/**
+ * @class object_rbuffer_t
+ * @parent object_t
+ *
+ * 将rbuffer包装成object。
+ *
+ */
+typedef struct _object_rbuffer_t {
+  object_t object;
+
+  /**
+   * @property {rbuffer_t*} rbuffer
+   * @annotation ["readable"]
+   * rbuffer对象。
+   *
+   */
+  rbuffer_t* rbuffer;
+
+  /*private*/
+  rbuffer_t arbuffer;
+} object_rbuffer_t;
+
+/**
+ * @method object_rbuffer_create
+ *
+ * 创建rbuffer对象。
+ *
+ * @annotation ["constructor"]
+ * @param {const uint8_t*} data 缓冲区。
+ * @param {uint16_t} capacity 缓冲区的容量。
+ *
+ * @return {object_t*} 返回object对象。
+ *
+ */
+object_t* object_rbuffer_create(const uint8_t* data, uint32_t capacity);
+
+object_rbuffer_t* object_rbuffer_cast(object_t* obj);
+#define OBJECT_RBUFFER(obj) object_rbuffer_cast(obj)
+
+END_C_DECLS
+
+#endif /*TK_OBJECT_RBUFFER_H*/

src/tkc/object_typed_array.c

@@ -0,0 +1,90 @@
+/**
+ * File:   object_typed_array.c
+ * Author: AWTK Develop Team
+ * Brief:  wrap typed array to an object.
+ *
+ * Copyright (c) 2020 - 2021  Guangzhou ZHIYUAN Electronics Co.,Ltd.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY { without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * License file for more details.
+ *
+ */
+
+/**
+ * History:
+ * ================================================================
+ * 2021-01-03 Li XianJing <xianjimli@hotmail.com> created
+ *
+ */
+
+#include "tkc/mem.h"
+#include "tkc/value.h"
+#include "tkc/utils.h"
+#include "object_typed_array.h"
+
+static ret_t object_typed_array_on_destroy(object_t* obj) {
+  object_typed_array_t* o = OBJECT_TYPED_ARRAY(obj);
+  return_value_if_fail(o != NULL && o->arr != NULL, RET_BAD_PARAMS);
+
+  typed_array_destroy(o->arr);
+  o->arr = NULL;
+
+  return RET_OK;
+}
+
+static ret_t object_typed_array_set_prop(object_t* obj, const char* name, const value_t* v) {
+  return RET_NOT_FOUND;
+}
+
+static ret_t object_typed_array_get_prop(object_t* obj, const char* name, value_t* v) {
+  ret_t ret = RET_NOT_FOUND;
+  object_typed_array_t* o = OBJECT_TYPED_ARRAY(obj);
+  return_value_if_fail(o != NULL && o->arr != NULL, RET_BAD_PARAMS);
+
+  if(tk_str_eq(name, "size")) {
+    value_set_uint32(v, o->arr->size);
+    ret = RET_OK;
+  } else if(tk_str_eq(name, "byte_size")) {
+    value_set_uint32(v, o->arr->size * o->arr->element_size);
+    ret = RET_OK;
+  } else if(tk_str_eq(name, "data")) {
+    value_set_pointer(v, o->arr->data);
+    ret = RET_OK;
+  }
+
+  return ret;
+}
+
+static const object_vtable_t s_object_typed_array_vtable = {.type = "object_typed_array",
+                                                       .desc = "object_typed_array",
+                                                       .size = sizeof(object_typed_array_t),
+                                                       .is_collection = FALSE,
+                                                       .on_destroy = object_typed_array_on_destroy,
+                                                       .get_prop = object_typed_array_get_prop,
+                                                       .set_prop = object_typed_array_set_prop
+};
+
+object_t* object_typed_array_create(value_type_t type, uint32_t capacity) {
+  object_t* o = NULL;
+  object_typed_array_t* wrapper = NULL;
+  o = object_create(&s_object_typed_array_vtable);
+  return_value_if_fail(o != NULL, NULL);
+
+  wrapper = OBJECT_TYPED_ARRAY(o);
+  return_value_if_fail(wrapper != NULL, NULL);
+
+  wrapper->arr = typed_array_create(type, capacity);
+  if (wrapper->arr == NULL) {
+    OBJECT_UNREF(o);
+  }
+
+  return o;
+}
+
+object_typed_array_t* object_typed_array_cast(object_t* obj) {
+  return_value_if_fail(obj != NULL && obj->vt == &s_object_typed_array_vtable, NULL);
+
+  return (object_typed_array_t*)(obj);
+}

src/tkc/object_typed_array.h

@@ -0,0 +1,68 @@
+/**
+ * File:   object_typed_array.h
+ * Author: AWTK Develop Team
+ * Brief:  wrap typed array to an object.
+ *
+ * Copyright (c) 2020 - 2021  Guangzhou ZHIYUAN Electronics Co.,Ltd.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * License file for more details.
+ *
+ */
+
+/**
+ * History:
+ * ================================================================
+ * 2021-01-03 Li XianJing <xianjimli@hotmail.com> created
+ *
+ */
+
+#ifndef TK_OBJECT_TYPED_ARRAY_H
+#define TK_OBJECT_TYPED_ARRAY_H
+
+#include "tkc/object.h"
+#include "tkc/typed_array.h"
+
+BEGIN_C_DECLS
+
+/**
+ * @class object_typed_array_t
+ * @parent object_t
+ *
+ * 将typed_array包装成object。
+ *
+ */
+typedef struct _object_typed_array_t {
+  object_t object;
+
+  /**
+   * @property {typed_array_t*} arr
+   * @annotation ["readable"]
+   * typed array对象。
+   *
+   */
+  typed_array_t* arr;
+} object_typed_array_t;
+
+/**
+ * @method object_typed_array_create
+ *
+ * 创建对象。
+ *
+ * @annotation ["constructor"]
+ * @param {value_type_t} type 元素的类型。
+ * @param {uint32_t} capacity 数组的初始容量(元素个数)。
+ *
+ * @return {object_t*} 返回object对象。
+ *
+ */
+object_t* object_typed_array_create(value_type_t type, uint32_t capacity);
+
+object_typed_array_t* object_typed_array_cast(object_t* obj);
+#define OBJECT_TYPED_ARRAY(obj) object_typed_array_cast(obj)
+
+END_C_DECLS
+
+#endif /*TK_OBJECT_TYPED_ARRAY_H*/

src/tkc/object_wbuffer.c

@@ -0,0 +1,101 @@
+/**
+ * File:   object_wbuffer.c
+ * Author: AWTK Develop Team
+ * Brief:  wrap wbuffer to an object.
+ *
+ * Copyright (c) 2020 - 2021  Guangzhou ZHIYUAN Electronics Co.,Ltd.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY { without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * License file for more details.
+ *
+ */
+
+/**
+ * History:
+ * ================================================================
+ * 2021-01-03 Li XianJing <xianjimli@hotmail.com> created
+ *
+ */
+
+#include "tkc/mem.h"
+#include "tkc/value.h"
+#include "tkc/utils.h"
+#include "object_wbuffer.h"
+
+static ret_t object_wbuffer_on_destroy(object_t* obj) {
+  object_wbuffer_t* o = OBJECT_WBUFFER(obj);
+  return_value_if_fail(o != NULL && o->wbuffer != NULL, RET_BAD_PARAMS);
+
+  wbuffer_deinit(o->wbuffer);
+  o->wbuffer = NULL;
+
+  return RET_OK;
+}
+
+static ret_t object_wbuffer_set_prop(object_t* obj, const char* name, const value_t* v) {
+  return RET_NOT_FOUND;
+}
+
+static ret_t object_wbuffer_get_prop(object_t* obj, const char* name, value_t* v) {
+  ret_t ret = RET_NOT_FOUND;
+  object_wbuffer_t* o = OBJECT_WBUFFER(obj);
+  return_value_if_fail(o != NULL && o->wbuffer != NULL, RET_BAD_PARAMS);
+
+  if(tk_str_eq(name, "cursor")) {
+    value_set_uint32(v, o->wbuffer->cursor);
+    ret = RET_OK;
+  } else if(tk_str_eq(name, "capacity")) {
+    value_set_uint32(v, o->wbuffer->capacity);
+    ret = RET_OK;
+  } else if(tk_str_eq(name, "data")) {
+    value_set_pointer(v, o->wbuffer->data);
+    ret = RET_OK;
+  }
+
+  return ret;
+}
+
+static const object_vtable_t s_object_wbuffer_vtable = {.type = "object_wbuffer",
+                                                       .desc = "object_wbuffer",
+                                                       .size = sizeof(object_wbuffer_t),
+                                                       .is_collection = FALSE,
+                                                       .on_destroy = object_wbuffer_on_destroy,
+                                                       .get_prop = object_wbuffer_get_prop,
+                                                       .set_prop = object_wbuffer_set_prop
+};
+
+object_t* object_wbuffer_create_ex(bool_t extendable, uint8_t* data, uint32_t capacity) {
+  object_t* o = NULL;
+  object_wbuffer_t* wrapper = NULL;
+  o = object_create(&s_object_wbuffer_vtable);
+  return_value_if_fail(o != NULL, NULL);
+
+  wrapper = OBJECT_WBUFFER(o);
+  return_value_if_fail(wrapper != NULL, NULL);
+
+  if(extendable) {
+    wrapper->wbuffer = wbuffer_init_extendable(&(wrapper->awbuffer));
+  } else {
+    wrapper->wbuffer = wbuffer_init(&(wrapper->awbuffer), data, capacity);
+  }
+
+  return o;
+}
+
+object_t* object_wbuffer_create(uint8_t* data, uint32_t capacity) {
+  return_value_if_fail(data != NULL, NULL);
+
+  return object_wbuffer_create_ex(FALSE, data, capacity);
+}
+
+object_t* object_wbuffer_create_extendable(void) {
+  return object_wbuffer_create_ex(TRUE, NULL, 0);
+}
+
+object_wbuffer_t* object_wbuffer_cast(object_t* obj) {
+  return_value_if_fail(obj != NULL && obj->vt == &s_object_wbuffer_vtable, NULL);
+
+  return (object_wbuffer_t*)(obj);
+}

src/tkc/object_wbuffer.h

@@ -0,0 +1,83 @@
+/**
+ * File:   object_wbuffer.h
+ * Author: AWTK Develop Team
+ * Brief:  wrap wbuffer to an object.
+ *
+ * Copyright (c) 2020 - 2021  Guangzhou ZHIYUAN Electronics Co.,Ltd.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * License file for more details.
+ *
+ */
+
+/**
+ * History:
+ * ================================================================
+ * 2021-01-03 Li XianJing <xianjimli@hotmail.com> created
+ *
+ */
+
+#ifndef TK_OBJECT_WBUFFER_H
+#define TK_OBJECT_WBUFFER_H
+
+#include "tkc/object.h"
+#include "tkc/buffer.h"
+
+BEGIN_C_DECLS
+
+/**
+ * @class object_wbuffer_t
+ * @parent object_t
+ *
+ * 将wbuffer包装成object。
+ *
+ */
+typedef struct _object_wbuffer_t {
+  object_t object;
+
+  /**
+   * @property {wbuffer_t*} wbuffer
+   * @annotation ["readable"]
+   * wbuffer对象。
+   *
+   */
+  wbuffer_t* wbuffer;
+
+  /*private*/
+  wbuffer_t awbuffer;
+} object_wbuffer_t;
+
+/**
+ * @method object_wbuffer_create
+ *
+ * 创建wbuffer对象。
+ *
+ * @annotation ["constructor"]
+ * @param {uint8_t*} data 缓冲区。
+ * @param {uint16_t} capacity 缓冲区的容量。
+ *
+ * @return {object_t*} 返回object对象。
+ *
+ */
+object_t* object_wbuffer_create(uint8_t* data, uint32_t capacity);
+
+/**
+ * @method object_wbuffer_create_extendable
+ *
+ * 创建可扩展的wbuffer对象。
+ *
+ * @annotation ["constructor"]
+ *
+ * @return {object_t*} 返回object对象。
+ *
+ */
+object_t* object_wbuffer_create_extendable(void);
+
+object_wbuffer_t* object_wbuffer_cast(object_t* obj);
+#define OBJECT_WBUFFER(obj) object_wbuffer_cast(obj)
+
+END_C_DECLS
+
+#endif /*TK_OBJECT_WBUFFER_H*/

tests/buffer_test.cc

@@ -1,4 +1,6 @@
 #include "tkc/buffer.h"
+#include "tkc/object_rbuffer.h"
+#include "tkc/object_wbuffer.h"
 #include "gtest/gtest.h"
 #include <string>
 
@@ -146,3 +148,28 @@ TEST(Buffer, string) {
   ASSERT_EQ(rbuffer_read_string(&rbuffer, &str), RET_OK);
   ASSERT_EQ(string(str), string(cstr));
 }
+
+TEST(Buffer, obj) {
+  const char* str = NULL;
+  object_t* wobj = object_wbuffer_create_extendable();
+  wbuffer_t* wbuffer = OBJECT_WBUFFER(wobj)->wbuffer;
+
+  wbuffer_write_string(wbuffer, "hello");
+  wbuffer_write_string(wbuffer, " world");
+  object_t* robj = object_rbuffer_create(wbuffer->data, wbuffer->cursor);
+  rbuffer_t* rbuffer = OBJECT_RBUFFER(robj)->rbuffer;
+
+  ASSERT_EQ(object_get_prop_int(wobj, "cursor", 0), 13);
+  ASSERT_EQ(object_get_prop_int(wobj, "capacity", 0), 14);
+  ASSERT_EQ(object_get_prop_pointer(wobj, "data"), (void*)(wbuffer->data));
+
+  rbuffer_read_string(rbuffer, &str);
+  ASSERT_STREQ(str, "hello");
+  
+  ASSERT_EQ(object_get_prop_int(robj, "cursor", 0), 6);
+  ASSERT_EQ(object_get_prop_int(robj, "capacity", 0), 13);
+  ASSERT_EQ(object_get_prop_pointer(robj, "data"), (void*)(rbuffer->data));
+
+  OBJECT_UNREF(wobj);
+  OBJECT_UNREF(robj);
+}

tests/fscript_run.cpp

@@ -5,6 +5,7 @@
 #include "tkc/time_now.h"
 #include "tkc/fscript.h"
 #include "tkc/object_default.h"
+#include "fscript_ext/fscript_ext.h"
 
 static ret_t run_fscript(const char* code, uint32_t times) {
   value_t v;
@@ -45,6 +46,9 @@ static ret_t run_fscript_file(const char* filename, uint32_t times) {
 int main(int argc, char* argv[]) {
   platform_prepare();
 
+  fscript_global_init();
+  fscript_ext_init();
+
   tk_mem_dump();
   if (argc < 2) {
     printf("Usage: %s script\n", argv[0]);
@@ -59,6 +63,7 @@ int main(int argc, char* argv[]) {
     }
   }
   tk_mem_dump();
+  fscript_global_deinit();
 
   return 0;
 }

tests/testdata/demo_object.fs

@@ -0,0 +1,4 @@
+a = object_create()
+object_set(a, "age", 123);
+print(object_get(a, "age"));
+object_unref(a)

tests/testdata/demo_typed_array.fs

@@ -0,0 +1,13 @@
+a=typed_array_create("i32", 10)
+
+typed_array_push(a, 123);
+typed_array_push(a, 234); 
+print(typed_array_get(a, 0))
+print(typed_array_get(a, 1))
+typed_array_insert(a, 0, 0); 
+print(typed_array_size(a))
+print(typed_array_get(a, 0))
+typed_array_remove(a, 0);
+print(typed_array_size(a))
+
+object_unref(a)

tests/typed_array_test.cc

@@ -1,4 +1,5 @@
 #include "tkc/typed_array.h"
+#include "tkc/object_typed_array.h"
 #include "gtest/gtest.h"
 
 TEST(TypedArray, basic) {
@@ -160,3 +161,25 @@ TEST(TypedArray, insert_uint32) {
 
   typed_array_destroy(a);
 }
+
+TEST(TypedArray, object1) {
+  value_t v;
+  uint8_t i  = 0;
+  object_t* obj = object_typed_array_create(VALUE_TYPE_UINT32, 0);
+  typed_array_t* a = OBJECT_TYPED_ARRAY(obj)->arr;
+
+  ASSERT_EQ(a != NULL, true);
+  ASSERT_EQ(a->element_size, sizeof(uint32_t));
+  for(i = 0; i < 255; i++) {
+    ASSERT_EQ(a->size, i);
+    ASSERT_EQ(typed_array_insert(a, 0, value_set_uint32(&v, i)), RET_OK);
+    ASSERT_EQ(typed_array_get(a, 0, &v), RET_OK);
+    ASSERT_EQ(value_uint32(&v), i);
+  }
+  
+  ASSERT_EQ(object_get_prop_int(obj, "size", 0), i);
+  ASSERT_EQ(object_get_prop_int(obj, "byte_size", 0), i*sizeof(uint32_t));
+  ASSERT_EQ(object_get_prop_pointer(obj, "data"), (void*)a->data);
+
+  typed_array_destroy(a);
+}

tools/idl_gen/idl.json

@@ -53197,6 +53197,26 @@
           "type": "ret_t",
           "desc": "返回RET_OK表示成功，否则表示失败。"
         }
+      },
+      {
+        "params": [],
+        "annotation": {},
+        "desc": "注册object函数。",
+        "name": "fscript_object_register",
+        "return": {
+          "type": "ret_t",
+          "desc": "返回RET_OK表示成功，否则表示失败。"
+        }
+      },
+      {
+        "params": [],
+        "annotation": {},
+        "desc": "注册typed array函数。",
+        "name": "fscript_typed_array_register",
+        "return": {
+          "type": "ret_t",
+          "desc": "返回RET_OK表示成功，否则表示失败。"
+        }
       }
     ],
     "events": [],
@@ -63396,6 +63416,150 @@
     "parent": "object_t",
     "level": 3
   },
+  {
+    "type": "class",
+    "methods": [
+      {
+        "params": [
+          {
+            "type": "const uint8_t*",
+            "name": "data",
+            "desc": "缓冲区。"
+          },
+          {
+            "type": "uint16_t",
+            "name": "capacity",
+            "desc": "缓冲区的容量。"
+          }
+        ],
+        "annotation": {
+          "constructor": true
+        },
+        "desc": "创建rbuffer对象。",
+        "name": "object_rbuffer_create",
+        "return": {
+          "type": "object_t*",
+          "desc": "返回object对象。"
+        }
+      }
+    ],
+    "events": [],
+    "properties": [
+      {
+        "name": "rbuffer",
+        "desc": "rbuffer对象。",
+        "type": "rbuffer_t*",
+        "annotation": {
+          "readable": true
+        }
+      }
+    ],
+    "header": "tkc/object_rbuffer.h",
+    "desc": "将rbuffer包装成object。",
+    "name": "object_rbuffer_t",
+    "parent": "object_t",
+    "level": 3
+  },
+  {
+    "type": "class",
+    "methods": [
+      {
+        "params": [
+          {
+            "type": "value_type_t",
+            "name": "type",
+            "desc": "元素的类型。"
+          },
+          {
+            "type": "uint32_t",
+            "name": "capacity",
+            "desc": "数组的初始容量(元素个数)。"
+          }
+        ],
+        "annotation": {
+          "constructor": true
+        },
+        "desc": "创建对象。",
+        "name": "object_typed_array_create",
+        "return": {
+          "type": "object_t*",
+          "desc": "返回object对象。"
+        }
+      }
+    ],
+    "events": [],
+    "properties": [
+      {
+        "name": "arr",
+        "desc": "typed array对象。",
+        "type": "typed_array_t*",
+        "annotation": {
+          "readable": true
+        }
+      }
+    ],
+    "header": "tkc/object_typed_array.h",
+    "desc": "将typed_array包装成object。",
+    "name": "object_typed_array_t",
+    "parent": "object_t",
+    "level": 3
+  },
+  {
+    "type": "class",
+    "methods": [
+      {
+        "params": [
+          {
+            "type": "uint8_t*",
+            "name": "data",
+            "desc": "缓冲区。"
+          },
+          {
+            "type": "uint16_t",
+            "name": "capacity",
+            "desc": "缓冲区的容量。"
+          }
+        ],
+        "annotation": {
+          "constructor": true
+        },
+        "desc": "创建wbuffer对象。",
+        "name": "object_wbuffer_create",
+        "return": {
+          "type": "object_t*",
+          "desc": "返回object对象。"
+        }
+      },
+      {
+        "params": [],
+        "annotation": {
+          "constructor": true
+        },
+        "desc": "创建可扩展的wbuffer对象。",
+        "name": "object_wbuffer_create_extendable",
+        "return": {
+          "type": "object_t*",
+          "desc": "返回object对象。"
+        }
+      }
+    ],
+    "events": [],
+    "properties": [
+      {
+        "name": "wbuffer",
+        "desc": "wbuffer对象。",
+        "type": "wbuffer_t*",
+        "annotation": {
+          "readable": true
+        }
+      }
+    ],
+    "header": "tkc/object_wbuffer.h",
+    "desc": "将wbuffer包装成object。",
+    "name": "object_wbuffer_t",
+    "parent": "object_t",
+    "level": 3
+  },
   {
     "type": "class",
     "methods": [

tools/idl_gen/tkc.json

@@ -21929,6 +21929,150 @@
     "parent": "object_t",
     "level": 3
   },
+  {
+    "type": "class",
+    "methods": [
+      {
+        "params": [
+          {
+            "type": "const uint8_t*",
+            "name": "data",
+            "desc": "缓冲区。"
+          },
+          {
+            "type": "uint16_t",
+            "name": "capacity",
+            "desc": "缓冲区的容量。"
+          }
+        ],
+        "annotation": {
+          "constructor": true
+        },
+        "desc": "创建rbuffer对象。",
+        "name": "object_rbuffer_create",
+        "return": {
+          "type": "object_t*",
+          "desc": "返回object对象。"
+        }
+      }
+    ],
+    "events": [],
+    "properties": [
+      {
+        "name": "rbuffer",
+        "desc": "rbuffer对象。",
+        "type": "rbuffer_t*",
+        "annotation": {
+          "readable": true
+        }
+      }
+    ],
+    "header": "tkc/object_rbuffer.h",
+    "desc": "将rbuffer包装成object。",
+    "name": "object_rbuffer_t",
+    "parent": "object_t",
+    "level": 3
+  },
+  {
+    "type": "class",
+    "methods": [
+      {
+        "params": [
+          {
+            "type": "value_type_t",
+            "name": "type",
+            "desc": "元素的类型。"
+          },
+          {
+            "type": "uint32_t",
+            "name": "capacity",
+            "desc": "数组的初始容量(元素个数)。"
+          }
+        ],
+        "annotation": {
+          "constructor": true
+        },
+        "desc": "创建对象。",
+        "name": "object_typed_array_create",
+        "return": {
+          "type": "object_t*",
+          "desc": "返回object对象。"
+        }
+      }
+    ],
+    "events": [],
+    "properties": [
+      {
+        "name": "arr",
+        "desc": "typed array对象。",
+        "type": "typed_array_t*",
+        "annotation": {
+          "readable": true
+        }
+      }
+    ],
+    "header": "tkc/object_typed_array.h",
+    "desc": "将typed_array包装成object。",
+    "name": "object_typed_array_t",
+    "parent": "object_t",
+    "level": 3
+  },
+  {
+    "type": "class",
+    "methods": [
+      {
+        "params": [
+          {
+            "type": "uint8_t*",
+            "name": "data",
+            "desc": "缓冲区。"
+          },
+          {
+            "type": "uint16_t",
+            "name": "capacity",
+            "desc": "缓冲区的容量。"
+          }
+        ],
+        "annotation": {
+          "constructor": true
+        },
+        "desc": "创建wbuffer对象。",
+        "name": "object_wbuffer_create",
+        "return": {
+          "type": "object_t*",
+          "desc": "返回object对象。"
+        }
+      },
+      {
+        "params": [],
+        "annotation": {
+          "constructor": true
+        },
+        "desc": "创建可扩展的wbuffer对象。",
+        "name": "object_wbuffer_create_extendable",
+        "return": {
+          "type": "object_t*",
+          "desc": "返回object对象。"
+        }
+      }
+    ],
+    "events": [],
+    "properties": [
+      {
+        "name": "wbuffer",
+        "desc": "wbuffer对象。",
+        "type": "wbuffer_t*",
+        "annotation": {
+          "readable": true
+        }
+      }
+    ],
+    "header": "tkc/object_wbuffer.h",
+    "desc": "将wbuffer包装成object。",
+    "name": "object_wbuffer_t",
+    "parent": "object_t",
+    "level": 3
+  },
   {
     "type": "class",
     "methods": [