Berry bytes setfloat getfloat

lib/libesp32/berry/generate/be_const_strtab.h

@@ -494,6 +494,7 @@ extern const bcstring be_const_str_get_vbus_voltage;
 extern const bcstring be_const_str_get_warning_level;
 extern const bcstring be_const_str_get_width;
 extern const bcstring be_const_str_getbits;
+extern const bcstring be_const_str_getfloat;
 extern const bcstring be_const_str_geti;
 extern const bcstring be_const_str_global;
 extern const bcstring be_const_str_gpio;
@@ -803,6 +804,7 @@ extern const bcstring be_const_str_set_xy;
 extern const bcstring be_const_str_set_y;
 extern const bcstring be_const_str_set_zoom;
 extern const bcstring be_const_str_setbits;
+extern const bcstring be_const_str_setfloat;
 extern const bcstring be_const_str_seti;
 extern const bcstring be_const_str_setitem;
 extern const bcstring be_const_str_setmember;

lib/libesp32/berry/generate/be_fixed_be_class_bytes.h

@@ -1,40 +1,42 @@
 #include "be_constobj.h"
 
 static be_define_const_map_slots(be_class_bytes_map) {
-    { be_const_key(_X2Elen, -1), be_const_var(0) },
-    { be_const_key(setbits, 13), be_const_closure(setbits_closure) },
-    { be_const_key(item, 15), be_const_func(m_item) },
-    { be_const_key(tostring, 6), be_const_func(m_tostring) },
-    { be_const_key(tob64, 18), be_const_func(m_tob64) },
-    { be_const_key(_X2Esize, -1), be_const_var(1) },
-    { be_const_key(seti, -1), be_const_func(m_set) },
     { be_const_key(deinit, -1), be_const_func(m_deinit) },
-    { be_const_key(get, -1), be_const_func(m_getu) },
-    { be_const_key(size, -1), be_const_func(m_size) },
-    { be_const_key(clear, 16), be_const_func(m_clear) },
-    { be_const_key(fromb64, -1), be_const_func(m_fromb64) },
-    { be_const_key(copy, 28), be_const_func(m_copy) },
-    { be_const_key(getbits, -1), be_const_closure(getbits_closure) },
-    { be_const_key(_X21_X3D, 8), be_const_func(m_nequal) },
-    { be_const_key(geti, 17), be_const_func(m_geti) },
-    { be_const_key(init, 22), be_const_func(m_init) },
-    { be_const_key(set, 23), be_const_func(m_set) },
-    { be_const_key(_change_buffer, -1), be_const_func(m_change_buffer) },
-    { be_const_key(add, -1), be_const_func(m_add) },
-    { be_const_key(resize, -1), be_const_func(m_resize) },
-    { be_const_key(_X2Ep, 19), be_const_var(2) },
-    { be_const_key(asstring, -1), be_const_func(m_asstring) },
-    { be_const_key(setitem, -1), be_const_func(m_setitem) },
-    { be_const_key(_X2E_X2E, 9), be_const_func(m_connect) },
-    { be_const_key(_X2B, 27), be_const_func(m_merge) },
+    { be_const_key(get, 5), be_const_func(m_getu) },
+    { be_const_key(fromb64, 18), be_const_func(m_fromb64) },
+    { be_const_key(copy, -1), be_const_func(m_copy) },
     { be_const_key(_buffer, -1), be_const_func(m_buffer) },
-    { be_const_key(_X3D_X3D, -1), be_const_func(m_equal) },
+    { be_const_key(getfloat, -1), be_const_func(m_getfloat) },
+    { be_const_key(getbits, -1), be_const_closure(getbits_closure) },
+    { be_const_key(tob64, -1), be_const_func(m_tob64) },
+    { be_const_key(item, -1), be_const_func(m_item) },
+    { be_const_key(_X21_X3D, -1), be_const_func(m_nequal) },
+    { be_const_key(clear, 28), be_const_func(m_clear) },
+    { be_const_key(size, 4), be_const_func(m_size) },
     { be_const_key(fromstring, -1), be_const_func(m_fromstring) },
+    { be_const_key(_X2Elen, 21), be_const_var(0) },
+    { be_const_key(seti, -1), be_const_func(m_set) },
+    { be_const_key(_X2B, 9), be_const_func(m_merge) },
+    { be_const_key(_X2Esize, 13), be_const_var(1) },
+    { be_const_key(setfloat, 6), be_const_func(m_setfloat) },
+    { be_const_key(_X2Ep, -1), be_const_var(2) },
+    { be_const_key(set, -1), be_const_func(m_set) },
+    { be_const_key(asstring, 0), be_const_func(m_asstring) },
+    { be_const_key(add, 24), be_const_func(m_add) },
+    { be_const_key(setitem, -1), be_const_func(m_setitem) },
+    { be_const_key(_change_buffer, -1), be_const_func(m_change_buffer) },
+    { be_const_key(_X3D_X3D, 15), be_const_func(m_equal) },
+    { be_const_key(resize, 2), be_const_func(m_resize) },
+    { be_const_key(tostring, -1), be_const_func(m_tostring) },
+    { be_const_key(setbits, -1), be_const_closure(setbits_closure) },
+    { be_const_key(_X2E_X2E, -1), be_const_func(m_connect) },
+    { be_const_key(init, -1), be_const_func(m_init) },
+    { be_const_key(geti, -1), be_const_func(m_geti) },
 };
 
 static be_define_const_map(
     be_class_bytes_map,
-    29
+    31
 );
 
 BE_EXPORT_VARIABLE be_define_const_class(

lib/libesp32/berry/src/be_byteslib.c

@@ -833,6 +833,30 @@ static int m_get(bvm *vm, bbool sign)
     be_return_nil(vm);
 }
 
+/*
+ * Get a float (32 bits)
+ * `getfloat(index:int [, big_endian:bool]) -> real`
+ */
+static int m_getfloat(bvm *vm)
+{
+    int argc = be_top(vm);
+    buf_impl attr = bytes_check_data(vm, 0); /* we reserve 4 bytes anyways */
+    check_ptr(vm, &attr);
+    if (argc >=2 && be_isint(vm, 2)) {
+        int32_t idx = be_toint(vm, 2);
+        bbool be = bfalse;             /* little endian? */
+        if (argc >= 3) {
+            be = be_tobool(vm, 3);
+        }
+        int32_t ret_i = be ? buf_get4_be(&attr, idx) : buf_get4_le(&attr, idx);
+        float* ret_f = (float*) &ret_i;
+        be_pop(vm, argc - 1);
+        be_pushreal(vm, *ret_f);
+        be_return(vm);
+    }
+    be_return_nil(vm);
+}
+
 /* signed int */
 static int m_geti(bvm *vm)
 {
@@ -882,6 +906,32 @@ static int m_set(bvm *vm)
     be_return_nil(vm);
 }
 
+/*
+ * Set a 32 bits float
+ * `setfloat(index:int, value:real or int [, big_endian:bool]) -> nil`
+ * 
+ */
+static int m_setfloat(bvm *vm)
+{
+    int argc = be_top(vm);
+    buf_impl attr = bytes_check_data(vm, 0); /* we reserve 4 bytes anyways */
+    check_ptr(vm, &attr);
+    if (argc >=3 && be_isint(vm, 2) && (be_isint(vm, 3) || be_isreal(vm, 3))) {
+        int32_t idx = be_toint(vm, 2);
+        float val_f = (float) be_toreal(vm, 3);
+        int32_t* val_i = (int32_t*) &val_f;
+        bbool be = bfalse;
+        if (argc >= 4) {
+            be = be_tobool(vm, 4);
+        }
+        if (be) { buf_set4_be(&attr, idx, *val_i); } else { buf_set4_le(&attr, idx, *val_i); }
+        be_pop(vm, argc - 1);
+        m_write_attributes(vm, 1, &attr);  /* update attributes */
+        be_return_nil(vm);
+    }
+    be_return_nil(vm);
+}
+
 static int m_setitem(bvm *vm)
 {
     int argc = be_top(vm);
@@ -1489,6 +1539,8 @@ class be_class_bytes (scope: global, name: bytes) {
     add, func(m_add)
     get, func(m_getu)
     geti, func(m_geti)
+    getfloat, func(m_getfloat)
+    setfloat, func(m_setfloat)
     set, func(m_set)
     seti, func(m_set)
     item, func(m_item)

lib/libesp32/berry/tests/bytes.be

@@ -183,3 +183,41 @@ assert(b[5..10] == bytes("5566778899AA"))
 assert(b[-10..-5] == bytes("66778899AABB"))
 assert(b[5..-10] == bytes("5566"))
 assert(b[7..-12] == bytes())
+
+#- floats little endian -#
+b = bytes("00000000")
+b.setfloat(0, 0)
+assert(b == bytes("00000000"))
+b.setfloat(0, 1)
+assert(b == bytes("0000803F"))
+b.setfloat(0, -1)
+assert(b == bytes("000080BF"))
+b.setfloat(0, 3.5)
+assert(b == bytes("00006040"))
+import math
+b.setfloat(0, math.nan)
+assert(b == bytes("0000C07F"))
+
+assert(bytes("00000000").getfloat(0) == 0)
+assert(bytes("0000803F").getfloat(0) == 1)
+assert(bytes("000080BF").getfloat(0) == -1)
+assert(bytes("00006040").getfloat(0) == 3.5)
+
+#- floats big endian -#
+b = bytes("00000000")
+b.setfloat(0, 0, true)
+assert(b == bytes("00000000"))
+b.setfloat(0, 1, true)
+assert(b == bytes("3F800000"))
+b.setfloat(0, -1, true)
+assert(b == bytes("BF800000"))
+b.setfloat(0, 3.5, true)
+assert(b == bytes("40600000"))
+import math
+b.setfloat(0, math.nan, true)
+assert(b == bytes("7FC00000"))
+
+assert(bytes("00000000").getfloat(0, true) == 0)
+assert(bytes("3F800000").getfloat(0, true) == 1)
+assert(bytes("BF800000").getfloat(0, true) == -1)
+assert(bytes("40600000").getfloat(0, true) == 3.5)