Projectkk2glider/lua bitmap free (#4075)

* Better memory stats (CLI) * Bitmap buffer overflow check added * Lua bitmap improvements * Proper handling of symbolic links in simulator * S6R Lua script fixes: * added progress screen while loading bitmaps * memory for bitmaps is now freed when leaving the script * S6R Lua script: improved bitmap loading * * Lua Themes and Widgets moved to separate file and separate Lua state * Stand-alone, mixer and function scripts now behave the same as on Taranis (restarted after the stand-alone script was run) * both Lua states are independent: Themes and Widgets is initialized only at the start, the other one is initialized before and after the stand-alone script is run * Better leak test and report in BitmapBuffer * Re #3318: Lua compiler enabled in simu and Companion simulator. Usage: * any time <xxx>.lua file is about to be loaded and if file <xxx>.lua.src exists: * load contents of <xxx>.lua.src * compile Lua code * save compiled code into <xxx>.lua (effectively overwrites existing file) * immediately following the compilation the real file loading is done from <xxx>.lua (which by now contains compiled Lua bytecode)
2016-11-28 23:08:18 +01:00
parent ae383cd6a4
commit 92553b6589
18 changed files with 745 additions and 554 deletions
@@ -0,0 +1,462 @@
+/*
+ * Copyright (C) OpenTX
+ *
+ * Based on code named
+ *   th9x - http://code.google.com/p/th9x
+ *   er9x - http://code.google.com/p/er9x
+ *   gruvin9x - http://code.google.com/p/gruvin9x
+ *
+ * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * 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
+ * GNU General Public License for more details.
+ */
+
+#include <ctype.h>
+#include <stdio.h>
+#include "opentx.h"
+#include "bin_allocator.h"
+#include "lua/lua_api.h"
+
+#if defined(LUA_COMPILER) && defined(SIMU)
+  #include <lundump.h>
+  #include <lstate.h>
+#endif
+
+#define WIDGET_SCRIPTS_MAX_INSTRUCTIONS    (10000/100)
+#define MANUAL_SCRIPTS_MAX_INSTRUCTIONS    (20000/100)
+#define LUA_WARNING_INFO_LEN               64
+
+lua_State *lsWidgets = NULL;
+extern int custom_lua_atpanic(lua_State *L);
+
+#define LUA_FULLPATH_MAXLEN                (42) // max length (example: /SCRIPTS/THEMES/mytheme.lua)
+
+void exec(int function, int nresults=0)
+{
+  if (lsWidgets == 0) return;
+
+  if (function) {
+    luaSetInstructionsLimit(lsWidgets, WIDGET_SCRIPTS_MAX_INSTRUCTIONS);
+    lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, function);
+    if (lua_pcall(lsWidgets, 0, nresults, 0) != 0) {
+      TRACE("Error in theme  %s", lua_tostring(lsWidgets, -1));
+    }
+  }
+}
+
+ZoneOption * createOptionsArray(int reference)
+{
+  if (reference == 0) {
+    return NULL;
+  }
+
+  int count = 0;
+  lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, reference);
+  for (lua_pushnil(lsWidgets); lua_next(lsWidgets, -2); lua_pop(lsWidgets, 1)) {
+    count++;
+  }
+
+  ZoneOption * options = (ZoneOption *)malloc(sizeof(ZoneOption) * (count+1));
+
+  lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, reference);
+  ZoneOption * option = options;
+  for (lua_pushnil(lsWidgets); lua_next(lsWidgets, -2); lua_pop(lsWidgets, 1)) {
+    luaL_checktype(lsWidgets, -2, LUA_TNUMBER); // key is number
+    luaL_checktype(lsWidgets, -1, LUA_TTABLE); // value is table
+    uint8_t field = 0;
+    for (lua_pushnil(lsWidgets); lua_next(lsWidgets, -2) && field<5; lua_pop(lsWidgets, 1), field++) {
+      switch (field) {
+        case 0:
+          luaL_checktype(lsWidgets, -2, LUA_TNUMBER); // key is number
+          luaL_checktype(lsWidgets, -1, LUA_TSTRING); // value is string
+          option->name = lua_tostring(lsWidgets, -1);
+          break;
+        case 1:
+          luaL_checktype(lsWidgets, -2, LUA_TNUMBER); // key is number
+          luaL_checktype(lsWidgets, -1, LUA_TNUMBER); // value is number
+          option->type = (ZoneOption::Type)lua_tointeger(lsWidgets, -1);
+          break;
+        case 2:
+          luaL_checktype(lsWidgets, -2, LUA_TNUMBER); // key is number
+          luaL_checktype(lsWidgets, -1, LUA_TNUMBER); // value is number
+          option->deflt.signedValue = lua_tointeger(lsWidgets, -1);
+          break;
+        case 3:
+          luaL_checktype(lsWidgets, -2, LUA_TNUMBER); // key is number
+          luaL_checktype(lsWidgets, -1, LUA_TNUMBER); // value is number
+          option->min.signedValue = lua_tointeger(lsWidgets, -1);
+          break;
+        case 4:
+          luaL_checktype(lsWidgets, -2, LUA_TNUMBER); // key is number
+          luaL_checktype(lsWidgets, -1, LUA_TNUMBER); // value is number
+          option->max.signedValue = lua_tointeger(lsWidgets, -1);
+          break;
+      }
+    }
+    option++;
+  }
+
+  option->name = NULL; // sentinel
+
+  return options;
+}
+
+class LuaTheme: public Theme
+{
+  friend void luaLoadThemeCallback();
+
+  public:
+    LuaTheme(const char * name, int options):
+      Theme(name, createOptionsArray(options)),
+      loadFunction(0),
+      drawBackgroundFunction(0),
+      drawTopbarBackgroundFunction(0),
+      drawAlertBoxFunction(0)
+    {
+    }
+
+    virtual void load() const
+    {
+      luaLcdAllowed = true;
+      exec(loadFunction);
+    }
+
+    virtual void drawBackground() const
+    {
+      exec(drawBackgroundFunction);
+    }
+
+    virtual void drawTopbarBackground(uint8_t icon) const
+    {
+      exec(drawTopbarBackgroundFunction);
+    }
+
+#if 0
+    virtual void drawAlertBox(const char * title, const char * text, const char * action) const
+    {
+      exec(drawAlertBoxFunction);
+    }
+#endif
+
+  protected:
+    int loadFunction;
+    int drawBackgroundFunction;
+    int drawTopbarBackgroundFunction;
+    int drawAlertBoxFunction;
+};
+
+void luaLoadThemeCallback()
+{
+  TRACE("luaLoadThemeCallback()");
+  const char * name=NULL;
+  int themeOptions=0, loadFunction=0, drawBackgroundFunction=0, drawTopbarBackgroundFunction=0;
+
+  luaL_checktype(lsWidgets, -1, LUA_TTABLE);
+
+  for (lua_pushnil(lsWidgets); lua_next(lsWidgets, -2); lua_pop(lsWidgets, 1)) {
+    const char * key = lua_tostring(lsWidgets, -2);
+    if (!strcmp(key, "name")) {
+      name = luaL_checkstring(lsWidgets, -1);
+    }
+    else if (!strcmp(key, "options")) {
+      themeOptions = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
+      lua_pushnil(lsWidgets);
+    }
+    else if (!strcmp(key, "load")) {
+      loadFunction = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
+      lua_pushnil(lsWidgets);
+    }
+    else if (!strcmp(key, "drawBackground")) {
+      drawBackgroundFunction = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
+      lua_pushnil(lsWidgets);
+    }
+    else if (!strcmp(key, "drawTopbarBackground")) {
+      drawTopbarBackgroundFunction = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
+      lua_pushnil(lsWidgets);
+    }
+  }
+
+  if (name) {
+    LuaTheme * theme = new LuaTheme(name, themeOptions);
+    theme->loadFunction = loadFunction;
+    theme->drawBackgroundFunction = drawBackgroundFunction;
+    theme->drawTopbarBackgroundFunction = drawTopbarBackgroundFunction;
+    TRACE("Loaded Lua theme %s", name);
+  }
+}
+
+class LuaWidget: public Widget
+{
+  public:
+    LuaWidget(const WidgetFactory * factory, const Zone & zone, Widget::PersistentData * persistentData, int widgetData):
+      Widget(factory, zone, persistentData),
+      widgetData(widgetData)
+    {
+    }
+
+    virtual ~LuaWidget()
+    {
+      luaL_unref(lsWidgets, LUA_REGISTRYINDEX, widgetData);
+    }
+
+    virtual void update() const;
+
+    virtual void refresh();
+
+    virtual void background();
+
+  protected:
+    int widgetData;
+};
+
+void l_pushtableint(const char * key, int value)
+{
+  lua_pushstring(lsWidgets, key);
+  lua_pushinteger(lsWidgets, value);
+  lua_settable(lsWidgets, -3);
+}
+
+class LuaWidgetFactory: public WidgetFactory
+{
+  friend void luaLoadWidgetCallback();
+  friend class LuaWidget;
+
+  public:
+    LuaWidgetFactory(const char * name, int widgetOptions, int createFunction):
+      WidgetFactory(name, createOptionsArray(widgetOptions)),
+      createFunction(createFunction),
+      updateFunction(0),
+      refreshFunction(0),
+      backgroundFunction(0)
+    {
+    }
+
+    virtual Widget * create(const Zone & zone, Widget::PersistentData * persistentData, bool init=true) const
+    {
+      if (lsWidgets == 0) return 0;
+      if (init) {
+        initPersistentData(persistentData);
+      }
+
+      luaSetInstructionsLimit(lsWidgets, WIDGET_SCRIPTS_MAX_INSTRUCTIONS);
+      lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, createFunction);
+
+      lua_newtable(lsWidgets);
+      l_pushtableint("x", zone.x);
+      l_pushtableint("y", zone.y);
+      l_pushtableint("w", zone.w);
+      l_pushtableint("h", zone.h);
+
+      lua_newtable(lsWidgets);
+      int i = 0;
+      for (const ZoneOption * option = options; option->name; option++, i++) {
+        l_pushtableint(option->name, persistentData->options[i].signedValue);
+      }
+
+      if (lua_pcall(lsWidgets, 2, 1, 0) != 0) {
+        TRACE("Error in widget %s create() function: %s", getName(), lua_tostring(lsWidgets, -1));
+      }
+      int widgetData = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
+      Widget * widget = new LuaWidget(this, zone, persistentData, widgetData);
+      return widget;
+    }
+
+  protected:
+    int createFunction;
+    int updateFunction;
+    int refreshFunction;
+    int backgroundFunction;
+};
+
+void LuaWidget::update() const
+{
+  if (lsWidgets == 0) return;
+
+  luaSetInstructionsLimit(lsWidgets, WIDGET_SCRIPTS_MAX_INSTRUCTIONS);
+  LuaWidgetFactory * factory = (LuaWidgetFactory *)this->factory;
+  lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, factory->updateFunction);
+  lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, widgetData);
+
+  lua_newtable(lsWidgets);
+  int i = 0;
+  for (const ZoneOption * option = getOptions(); option->name; option++, i++) {
+    l_pushtableint(option->name, persistentData->options[i].signedValue);
+  }
+
+  if (lua_pcall(lsWidgets, 2, 0, 0) != 0) {
+    TRACE("Error in widget %s update() function: %s", factory->getName(), lua_tostring(lsWidgets, -1));
+  }
+}
+
+void LuaWidget::refresh()
+{
+  if (lsWidgets == 0) return;
+
+  luaSetInstructionsLimit(lsWidgets, WIDGET_SCRIPTS_MAX_INSTRUCTIONS);
+  LuaWidgetFactory * factory = (LuaWidgetFactory *)this->factory;
+  lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, factory->refreshFunction);
+  lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, widgetData);
+  if (lua_pcall(lsWidgets, 1, 0, 0) != 0) {
+    TRACE("Error in widget %s refresh() function: %s", factory->getName(), lua_tostring(lsWidgets, -1));
+  }
+}
+
+void LuaWidget::background()
+{
+  if (lsWidgets == 0) return;
+
+  luaSetInstructionsLimit(lsWidgets, WIDGET_SCRIPTS_MAX_INSTRUCTIONS);
+  LuaWidgetFactory * factory = (LuaWidgetFactory *)this->factory;
+  if (factory->backgroundFunction) {
+    lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, factory->backgroundFunction);
+    lua_rawgeti(lsWidgets, LUA_REGISTRYINDEX, widgetData);
+    if (lua_pcall(lsWidgets, 1, 0, 0) != 0) {
+      TRACE("Error in widget %s background() function: %s", factory->getName(), lua_tostring(lsWidgets, -1));
+    }
+  }
+}
+
+void luaLoadWidgetCallback()
+{
+  TRACE("luaLoadWidgetCallback()");
+  const char * name=NULL;
+  int widgetOptions=0, createFunction=0, updateFunction=0, refreshFunction=0, backgroundFunction=0;
+
+  luaL_checktype(lsWidgets, -1, LUA_TTABLE);
+
+  for (lua_pushnil(lsWidgets); lua_next(lsWidgets, -2); lua_pop(lsWidgets, 1)) {
+    const char * key = lua_tostring(lsWidgets, -2);
+    if (!strcmp(key, "name")) {
+      name = luaL_checkstring(lsWidgets, -1);
+    }
+    else if (!strcmp(key, "options")) {
+      widgetOptions = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
+      lua_pushnil(lsWidgets);
+    }
+    else if (!strcmp(key, "create")) {
+      createFunction = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
+      lua_pushnil(lsWidgets);
+    }
+    else if (!strcmp(key, "update")) {
+      updateFunction = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
+      lua_pushnil(lsWidgets);
+    }
+    else if (!strcmp(key, "refresh")) {
+      refreshFunction = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
+      lua_pushnil(lsWidgets);
+    }
+    else if (!strcmp(key, "background")) {
+      backgroundFunction = luaL_ref(lsWidgets, LUA_REGISTRYINDEX);
+      lua_pushnil(lsWidgets);
+    }
+  }
+
+  if (name && createFunction) {
+    LuaWidgetFactory * factory = new LuaWidgetFactory(name, widgetOptions, createFunction);
+    factory->updateFunction = updateFunction;
+    factory->refreshFunction = refreshFunction;
+    factory->backgroundFunction = backgroundFunction;
+    TRACE("Loaded Lua widget %s", name);
+  }
+}
+
+void luaLoadFile(const char * filename, void (*callback)())
+{
+  if (lsWidgets == 0) return;
+
+  TRACE("luaLoadFile() %s", filename);
+
+#if defined(LUA_COMPILER) && defined(SIMU)
+  luaCompileAndSave(lsWidgets, filename);
+#endif
+
+  luaSetInstructionsLimit(lsWidgets, MANUAL_SCRIPTS_MAX_INSTRUCTIONS);
+
+  PROTECT_LUA() {
+    if (luaL_loadfile(lsWidgets, filename) == 0 &&
+        lua_pcall(lsWidgets, 0, 1, 0) == 0 &&
+        lua_istable(lsWidgets, -1)) {
+      (*callback)();
+    }
+    else {
+      TRACE("Error in script %s: %s", filename, lua_tostring(lsWidgets, -1));
+    }
+  }
+  else {
+    // luaDisable();
+    lsWidgets = 0;
+    return;
+  }
+  UNPROTECT_LUA();
+}
+
+void luaLoadFiles(const char * directory, void (*callback)())
+{
+  char path[LUA_FULLPATH_MAXLEN+1];
+  FILINFO fno;
+  DIR dir;
+
+  strcpy(path, directory);
+  TRACE("luaLoadFiles() %s", path);
+
+  FRESULT res = f_opendir(&dir, path);        /* Open the directory */
+
+  if (res == FR_OK) {
+    int pathlen = strlen(path);
+    path[pathlen++] = '/';
+    for (;;) {
+      res = f_readdir(&dir, &fno);                   /* Read a directory item */
+      if (res != FR_OK || fno.fname[0] == 0) break;  /* Break on error or end of dir */
+      uint8_t len = strlen(fno.fname);
+      if (len > 0 && fno.fname[0]!='.' && (fno.fattrib & AM_DIR)) {
+        strcpy(&path[pathlen], fno.fname);
+        strcat(&path[pathlen], "/main.lua");
+        if (isFileAvailable(path)) {
+          luaLoadFile(path, callback);
+        }
+      }
+    }
+  }
+  else {
+    TRACE("f_opendir(%s) failed, code=%d", path, res);
+  }
+
+  f_closedir(&dir);
+}
+
+void luaInitThemesAndWidgets()
+{
+  TRACE("luaInitThemesAndWidgets");
+
+#if defined(USE_BIN_ALLOCATOR)
+  lsWidgets = lua_newstate(bin_l_alloc, NULL);   //we use our own allocator!
+#else
+  lsWidgets = lua_newstate(l_alloc, NULL);   //we use Lua default allocator
+#endif
+  if (lsWidgets) {
+    // install our panic handler
+    lua_atpanic(lsWidgets, &custom_lua_atpanic);
+
+    // protect libs and constants registration
+    PROTECT_LUA() {
+      luaRegisterLibraries(lsWidgets);
+    }
+    else {
+      // if we got panic during registration
+      // we disable Lua for this session
+      // luaDisable();
+      lsWidgets = 0;
+    }
+    UNPROTECT_LUA();
+    TRACE("lsWidgets %p", lsWidgets);
+    luaLoadFiles(THEMES_PATH, luaLoadThemeCallback);
+    luaLoadFiles(WIDGETS_PATH, luaLoadWidgetCallback);
+  }
+}