BENB move initialization into init.lua

common/dep/lua-5.4.3/src/dirent.c

@@ -17,13 +17,14 @@ static int dirent_list(lua_State* L) {
 	lua_newtable(L);
 
 	int i = 0;
-	while (grid_platform_readdir(dir)) {
+	void* info;
+	while ((info = grid_platform_readdir(dir))) {
 
 		lua_newtable(L);
 
-		lua_pushstring(L, grid_platform_readdir_name());
+		lua_pushstring(L, grid_platform_file_info_name(info));
 		lua_rawseti(L, -2, 1);
-		lua_pushinteger(L, grid_platform_readdir_type());
+		lua_pushinteger(L, grid_platform_file_info_type(info));
 		lua_rawseti(L, -2, 2);
 
 		lua_rawseti(L, -2, ++i);
@@ -40,7 +41,7 @@ static int dirent_mkdir(lua_State* L) {
 
 	const char* path = luaL_checkstring(L, 1);
 
-	lua_pushboolean(L, grid_platform_make_directory(path) == 0);
+	lua_pushboolean(L, grid_platform_mkdir(path) == 0);
 
 	return 1;
 }

common/dep/lua-5.4.3/src/loslib.c

@@ -141,6 +141,7 @@
 
 #define l_remove(f) grid_platform_remove(f)
 #define l_rename(o, n) grid_platform_rename(o, n)
+#define l_stat(f, h) grid_platform_stat(f, h)
 
 
 
@@ -171,6 +172,13 @@ static int os_rename (lua_State *L) {
 }
 
 
+static int os_stat (lua_State *L) {
+  const char *filename = luaL_checkstring(L, 1);
+  void* dummy;
+  return luaL_fileresult(L, l_stat(filename, &dummy) == 0, filename);
+}
+
+
 static int os_tmpname (lua_State *L) {
   char buff[LUA_TMPNAMBUFSIZE];
   int err;
@@ -418,6 +426,7 @@ static const luaL_Reg syslib[] = {
   {"getenv",    os_getenv},
   {"remove",    os_remove},
   {"rename",    os_rename},
+  {"stat",      os_stat},
   {"setlocale", os_setlocale},
   {"time",      os_time},
   {"tmpname",   os_tmpname},

common/src/c/grid_decode.c

@@ -519,19 +519,16 @@ uint8_t grid_decode_immediate_to_ui(char* header, char* chunk) {
 
   char* script = &chunk[GRID_CLASS_IMMEDIATE_ACTIONSTRING_offset];
 
-  if (!grid_lua_strn_is_actionstring(script, length)) {
-    return 1;
-  }
-
   if (!grid_ui_bulk_semaphore_try(&grid_ui_state)) {
     return 1;
   }
 
   grid_lua_clear_stdo(&grid_lua_state);
-  script[length - 3] = '\0';
-  grid_lua_dostring_begin(&grid_lua_state, &script[6]);
+  assert(script[length] == GRID_CONST_ETX);
+  script[length] = '\0';
+  grid_lua_dostring_begin(&grid_lua_state, script);
+  script[length] = GRID_CONST_ETX;
   grid_lua_dostring_end(&grid_lua_state);
-  script[length - 3] = ' ';
   grid_lua_broadcast_stdo(&grid_lua_state);
 
   grid_ui_bulk_semaphore_release(&grid_ui_state);
@@ -575,10 +572,6 @@ uint8_t grid_decode_evaluate_to_ui(char* header, char* chunk) {
 
   char* script = (char*)&first[GRID_CLASS_EVALUATE_ELEMENT_DATA_offset];
 
-  if (!grid_lua_strn_is_actionstring(script, length)) {
-    return 1;
-  }
-
   uint8_t id = grid_msg_get_parameter_raw((uint8_t*)header, BRC_ID);
 
   struct grid_msg msg;
@@ -602,9 +595,10 @@ uint8_t grid_decode_evaluate_to_ui(char* header, char* chunk) {
   }
 
   grid_lua_clear_stdo(&grid_lua_state);
-  script[length - 3] = '\0';
-  bool status = grid_lua_dostring_begin(&grid_lua_state, &script[6]);
-  script[length - 3] = ' ';
+  assert(script[length] == GRID_CONST_ETX);
+  script[length] = '\0';
+  bool status = grid_lua_dostring_begin(&grid_lua_state, script);
+  script[length] = GRID_CONST_ETX;
   grid_lua_broadcast_stdo(&grid_lua_state);
 
   uint8_t respinstr = status ? GRID_INSTR_ACKNOWLEDGE_code : GRID_INSTR_NACKNOWLEDGE_code;
@@ -1196,15 +1190,15 @@ uint8_t grid_decode_config_to_ui(char* header, char* chunk) {
     // Disable HID
     grid_usb_keyboard_disable(&grid_usb_keyboard_state);
 
-    uint16_t actionlength = grid_msg_get_parameter_raw((uint8_t*)chunk, CLASS_CONFIG_ACTIONLENGTH);
+    uint16_t scriptlength = grid_msg_get_parameter_raw((uint8_t*)chunk, CLASS_CONFIG_ACTIONLENGTH);
 
-    char* action = &chunk[GRID_CLASS_CONFIG_ACTIONSTRING_offset];
+    char* script = &chunk[GRID_CLASS_CONFIG_ACTIONSTRING_offset];
 
     // By default, generate nacknowledge
     uint8_t respinstr = GRID_INSTR_NACKNOWLEDGE_code;
 
-    bool validlength = actionlength <= GRID_PARAMETER_ACTIONSTRING_maxlength;
-    bool endswithetx = validlength ? action[actionlength] == GRID_CONST_ETX : false;
+    bool validlength = scriptlength <= GRID_PARAMETER_ACTIONSTRING_maxlength;
+    bool endswithetx = validlength ? script[scriptlength] == GRID_CONST_ETX : false;
     bool currentpage = page == grid_ui_state.page_activepage;
     bool validelement = element < grid_ui_state.element_list_length;
     struct grid_ui_element* ele = validelement ? &grid_ui_state.element_list[element] : NULL;
@@ -1218,10 +1212,12 @@ uint8_t grid_decode_config_to_ui(char* header, char* chunk) {
       // Set alert for feedback
       grid_alert_all_set(&grid_led_state, GRID_LED_COLOR_WHITE, 64);
 
-      // Register actionstring for event
-      action[actionlength] = '\0';
-      grid_ui_event_register_actionstring(eve, action);
-      action[actionlength] = GRID_CONST_ETX;
+      // Register script for event
+      script[scriptlength] = '\0';
+      grid_lua_semaphore_lock(&grid_lua_state);
+      grid_ui_register_script(&grid_ui_state, element, event, script);
+      grid_lua_semaphore_release(&grid_lua_state);
+      script[scriptlength] = GRID_CONST_ETX;
 
       // Local-trigger the event
       grid_ui_event_state_set(eve, GRID_EVE_STATE_TRIG_LOCAL);

common/src/c/grid_littlefs.c

@@ -220,160 +220,65 @@ int grid_littlefs_lsdir(lfs_t* lfs, const char* path) {
   return 0;
 }
 
-int grid_littlefs_file_find(lfs_t* lfs, const char* path) {
+struct lfs_info STATINFO = {0};
 
-  struct lfs_info info;
-  int lfs_err = lfs_stat(lfs, path, &info);
-  if (lfs_err != LFS_ERR_OK) {
-    // printf("grid_littlefs_file_find stat error: %d\n", lfs_err);
-    return 1;
-  }
-
-  return info.type == LFS_TYPE_REG ? 0 : 1;
-}
-
-size_t grid_littlefs_file_size(lfs_t* lfs, const char* path) {
-
-  struct lfs_info info;
-  int lfs_err = lfs_stat(lfs, path, &info);
-  if (lfs_err != LFS_ERR_OK) {
-    printf("grid_littlefs_file_size stat error: %d\n", lfs_err);
-    return 0;
-  }
-
-  return info.size;
-}
-
-int grid_littlefs_file_read(lfs_t* lfs, const char* path, uint8_t* buffer, uint16_t size) {
-
-  lfs_file_t file;
-  int lfs_err = lfs_file_open(lfs, &file, path, LFS_O_RDONLY);
-  if (lfs_err != LFS_ERR_OK) {
-    printf("grid_littlefs_file_read open error: %d\n", lfs_err);
-    return 1;
-  }
+int grid_littlefs_stat(lfs_t* lfs, const char* path, void** statbuf) {
 
-  lfs_ssize_t read = lfs_file_read(lfs, &file, buffer, size);
-  if (read < 0) {
-    printf("grid_littlefs_file_read read error: %ld\n", read);
-    return 1;
-  }
-
-  lfs_err = lfs_file_close(lfs, &file);
+  int lfs_err = lfs_stat(lfs, path, &STATINFO);
   if (lfs_err != LFS_ERR_OK) {
-    printf("grid_littlefs_file_read close error: %d\n", lfs_err);
     return 1;
   }
 
+  *statbuf = &STATINFO;
   return 0;
 }
 
-int grid_littlefs_file_write(lfs_t* lfs, const char* path, const uint8_t* buffer, uint16_t size) {
-
-  lfs_file_t file;
-  int lfs_err = lfs_file_open(lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT);
-  if (lfs_err != LFS_ERR_OK) {
-    printf("grid_littlefs_file_write open error: %d\n", lfs_err);
-    return 1;
-  }
-
-  lfs_ssize_t wrote = lfs_file_write(lfs, &file, buffer, size);
-  if (wrote < 0) {
-    printf("grid_littlefs_file_write write error: %ld\n", wrote);
-    return 1;
-  }
-
-  lfs_err = lfs_file_close(lfs, &file);
-  if (lfs_err != LFS_ERR_OK) {
-    printf("grid_littlefs_file_write close error: %d\n", lfs_err);
-    return 1;
-  }
-
-  return 0;
-}
+struct lfs_info FIRSTDIR = {0};
 
-size_t grid_littlefs_get_total_bytes(struct lfs_config* cfg) { return cfg->block_size * cfg->block_count; }
-
-size_t grid_littlefs_get_used_bytes(lfs_t* lfs, struct lfs_config* cfg) {
-
-  size_t fs_size = cfg->block_size * lfs_fs_size(lfs);
-
-  // lfs_fs_size may return a size larger than the actual filesystem size
-  size_t total = grid_littlefs_get_total_bytes(cfg);
-  return fs_size > total ? total : fs_size;
-}
-
-int grid_littlefs_find_least_of_larger(lfs_t* lfs, const char* path, int* last_num) {
+void* grid_littlefs_dir_first(lfs_t* lfs, const char* path) {
 
   lfs_dir_t dir;
   int lfs_err = lfs_dir_open(lfs, &dir, path);
   if (lfs_err != LFS_ERR_OK) {
-    printf("grid_littlefs_lsdir open error: %d\n", lfs_err);
-    return 1;
+    printf("grid_littlefs_dir_first open error: %d\n", lfs_err);
+    return NULL;
   }
 
-  int min = INT_MAX;
-
-  struct lfs_info info;
-  while (lfs_dir_read(lfs, &dir, &info) > 0) {
+  struct lfs_info* ret = NULL;
+  while (lfs_dir_read(lfs, &dir, &FIRSTDIR) > 0) {
 
-    // Attempt to parse the name as two hexadecimal digits
-    int index;
-    int matched = sscanf(info.name, "%02x", &index);
-    if (matched != 1) {
+    // Ignore entry for current directory
+    if (strcmp(FIRSTDIR.name, ".") == 0) {
       continue;
     }
 
-    // Consider the index when it is larger than the last number
-    if (index > *last_num) {
-
-      // If the index is smaller than the previous smallest, store it
-      if (index < min) {
-        min = index;
-      }
+    // Ignore entry for parent directory
+    if (strcmp(FIRSTDIR.name, "..") == 0) {
+      continue;
     }
+
+    ret = &FIRSTDIR;
+    break;
   }
 
   lfs_err = lfs_dir_close(lfs, &dir);
   if (lfs_err != LFS_ERR_OK) {
-    printf("grid_littlefs_lsdir close error: %d\n", lfs_err);
-    return 1;
+    printf("grid_littlefs_dir_first close error: %d\n", lfs_err);
+    return NULL;
   }
 
-  int found = min != INT_MAX;
-
-  *last_num = found ? min : -1;
-
-  return found ? 0 : 1;
+  return ret;
 }
 
-int grid_littlefs_find_next_on_page(lfs_t* lfs, uint8_t page, int* last_ele, int* last_evt) {
-
-  char path[LFS_NAME_MAX + 1] = {0};
-
-  while (true) {
-
-    if (*last_evt < 0) {
-
-      // Try to find next valid element
-      sprintf(path, "%02x", page);
-      grid_littlefs_find_least_of_larger(lfs, path, last_ele);
+size_t grid_littlefs_get_total_bytes(struct lfs_config* cfg) { return cfg->block_size * cfg->block_count; }
 
-      // If no element is found, the traversal is over
-      if (*last_ele < 0) {
-        return 1;
-      }
-    }
+size_t grid_littlefs_get_used_bytes(lfs_t* lfs, struct lfs_config* cfg) {
 
-    // Try to find next valid event
-    sprintf(path, "%02x/%02x", page, *last_ele);
-    grid_littlefs_find_least_of_larger(lfs, path, last_evt);
+  size_t fs_size = cfg->block_size * lfs_fs_size(lfs);
 
-    // If a valid event is found, return success
-    if (*last_evt >= 0) {
-      return 0;
-    }
-  }
+  // lfs_fs_size may return a size larger than the actual filesystem size
+  size_t total = grid_littlefs_get_total_bytes(cfg);
+  return fs_size > total ? total : fs_size;
 }
 
 lfs_file_t* grid_littlefs_fopen(lfs_t* lfs, const char* path, const char* mode) {
@@ -525,6 +430,8 @@ struct lfs_info READDIR = {0};
 
 void* grid_littlefs_readdir(lfs_t* lfs, lfs_dir_t* dirp) { return lfs_dir_read(lfs, dirp, &READDIR) > 0 ? &READDIR : NULL; }
 
-const char* grid_littlefs_readdir_name() { return READDIR.name; }
+const char* grid_littlefs_file_info_name(struct lfs_info* info) { return info->name; }
+
+uint8_t grid_littlefs_file_info_type(struct lfs_info* info) { return info->type; }
 
-uint8_t grid_littlefs_readdir_type() { return READDIR.type; }
+uint32_t grid_littlefs_file_info_size(struct lfs_info* info) { return info->size; }

common/src/c/grid_littlefs.h

@@ -15,16 +15,12 @@ int grid_littlefs_mkdir(lfs_t* lfs, const char* path);
 int grid_littlefs_rmdir(lfs_t* lfs, const char* path);
 int grid_littlefs_lsdir(lfs_t* lfs, const char* path);
 
-int grid_littlefs_file_find(lfs_t* lfs, const char* path);
-size_t grid_littlefs_file_size(lfs_t* lfs, const char* path);
-int grid_littlefs_file_read(lfs_t* lfs, const char* path, uint8_t* buffer, uint16_t size);
-int grid_littlefs_file_write(lfs_t* lfs, const char* path, const uint8_t* buffer, uint16_t size);
+int grid_littlefs_stat(lfs_t* lfs, const char* path, void** statbuf);
+void* grid_littlefs_dir_first(lfs_t* lfs, const char* path);
 
 size_t grid_littlefs_get_total_bytes(struct lfs_config* cfg);
 size_t grid_littlefs_get_used_bytes(lfs_t* lfs, struct lfs_config* cfg);
 
-int grid_littlefs_find_next_on_page(lfs_t* lfs, uint8_t page, int* last_ele, int* last_evt);
-
 lfs_file_t* grid_littlefs_fopen(lfs_t* lfs, const char* path, const char* mode);
 int grid_littlefs_fclose(lfs_t* lfs, lfs_file_t* stream);
 size_t grid_littlefs_fwrite(lfs_t* lfs, const void* ptr, size_t size, size_t nmemb, lfs_file_t* stream);
@@ -35,7 +31,9 @@ int grid_littlefs_fflush(lfs_t* lfs, lfs_file_t* stream);
 lfs_dir_t* grid_littlefs_opendir(lfs_t* lfs, const char* name);
 int grid_littlefs_closedir(lfs_t* lfs, lfs_dir_t* dirp);
 void* grid_littlefs_readdir(lfs_t* lfs, lfs_dir_t* dirp);
-const char* grid_littlefs_readdir_name();
-uint8_t grid_littlefs_readdir_type();
+
+const char* grid_littlefs_file_info_name(struct lfs_info* info);
+uint8_t grid_littlefs_file_info_type(struct lfs_info* info);
+uint32_t grid_littlefs_file_info_size(struct lfs_info* info);
 
 #endif /* GRID_LITTLEFS_H */