modules/luci-base/src/template_lualib.c

   1 /*
   2  * LuCI Template - Lua binding
   3  *
   4  *   Copyright (C) 2009 Jo-Philipp Wich <jow@openwrt.org>
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License.
  17  */
  18
  19 #include "template_lualib.h"
  20
  21 static int template_L_do_parse(lua_State *L, struct template_parser *parser, const char *chunkname)
  22 {
  23         int lua_status, rv;
  24
  25         if (!parser)
  26         {
  27                 lua_pushnil(L);
  28                 lua_pushinteger(L, errno);
  29                 lua_pushstring(L, strerror(errno));
  30                 return 3;
  31         }
  32
  33         lua_status = lua_load(L, template_reader, parser, chunkname);
  34
  35         if (lua_status == 0)
  36                 rv = 1;
  37         else
  38                 rv = template_error(L, parser);
  39
  40         template_close(parser);
  41
  42         return rv;
  43 }
  44
  45 int template_L_parse(lua_State *L)
  46 {
  47         const char *file = luaL_checkstring(L, 1);
  48         struct template_parser *parser = template_open(file);
  49
  50         return template_L_do_parse(L, parser, file);
  51 }
  52
  53 int template_L_parse_string(lua_State *L)
  54 {
  55         size_t len;
  56         const char *str = luaL_checklstring(L, 1, &len);
  57         struct template_parser *parser = template_string(str, len);
  58
  59         return template_L_do_parse(L, parser, "[string]");
  60 }
  61
  62 int template_L_utf8(lua_State *L)
  63 {
  64         size_t len = 0;
  65         const char *str = luaL_checklstring(L, 1, &len);
  66         char *res = utf8(str, len);
  67
  68         if (res != NULL)
  69         {
  70                 lua_pushstring(L, res);
  71                 free(res);
  72
  73                 return 1;
  74         }
  75
  76         return 0;
  77 }
  78
  79 int template_L_pcdata(lua_State *L)
  80 {
  81         size_t len = 0;
  82         const char *str = luaL_checklstring(L, 1, &len);
  83         char *res = pcdata(str, len);
  84
  85         if (res != NULL)
  86         {
  87                 lua_pushstring(L, res);
  88                 free(res);
  89
  90                 return 1;
  91         }
  92
  93         return 0;
  94 }
  95
  96 int template_L_striptags(lua_State *L)
  97 {
  98         size_t len = 0;
  99         const char *str = luaL_checklstring(L, 1, &len);
 100         char *res = striptags(str, len);
 101
 102         if (res != NULL)
 103         {
 104                 lua_pushstring(L, res);
 105                 free(res);
 106
 107                 return 1;
 108         }
 109
 110         return 0;
 111 }
 112
 113 static int template_L_load_catalog(lua_State *L) {
 114         const char *lang = luaL_optstring(L, 1, "en");
 115         const char *dir  = luaL_optstring(L, 2, NULL);
 116         lua_pushboolean(L, !lmo_load_catalog(lang, dir));
 117         return 1;
 118 }
 119
 120 static int template_L_close_catalog(lua_State *L) {
 121         const char *lang = luaL_optstring(L, 1, "en");
 122         lmo_close_catalog(lang);
 123         return 0;
 124 }
 125
 126 static int template_L_change_catalog(lua_State *L) {
 127         const char *lang = luaL_optstring(L, 1, "en");
 128         lua_pushboolean(L, !lmo_change_catalog(lang));
 129         return 1;
 130 }
 131
 132 static int template_L_translate(lua_State *L) {
 133         size_t len;
 134         char *tr;
 135         int trlen;
 136         const char *key = luaL_checklstring(L, 1, &len);
 137
 138         switch (lmo_translate(key, len, &tr, &trlen))
 139         {
 140                 case 0:
 141                         lua_pushlstring(L, tr, trlen);
 142                         return 1;
 143
 144                 case -1:
 145                         return 0;
 146         }
 147
 148         lua_pushnil(L);
 149         lua_pushstring(L, "no catalog loaded");
 150         return 2;
 151 }
 152
 153 static int template_L_hash(lua_State *L) {
 154         size_t len;
 155         const char *key = luaL_checklstring(L, 1, &len);
 156         lua_pushinteger(L, sfh_hash(key, len));
 157         return 1;
 158 }
 159
 160
 161 /* module table */
 162 static const luaL_reg R[] = {
 163         { "parse",                              template_L_parse },
 164         { "parse_string",               template_L_parse_string },
 165         { "utf8",                               template_L_utf8 },
 166         { "pcdata",                             template_L_pcdata },
 167         { "striptags",                  template_L_striptags },
 168         { "load_catalog",               template_L_load_catalog },
 169         { "close_catalog",              template_L_close_catalog },
 170         { "change_catalog",             template_L_change_catalog },
 171         { "translate",                  template_L_translate },
 172         { "hash",                               template_L_hash },
 173         { NULL,                                 NULL }
 174 };
 175
 176 LUALIB_API int luaopen_luci_template_parser(lua_State *L) {
 177         luaL_register(L, TEMPLATE_LUALIB_META, R);
 178         return 1;
 179 }