X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fuci.git;a=blobdiff_plain;f=lua%2Fuci.c;h=ddb9c5cc23c1db81348f7a2091a2ca5e250d3d73;hp=1c67742736df9871d9cb7ca7ae8745961b958feb;hb=7daf94275cce4c9dd74fe4eb846b0f4d40486f1d;hpb=e1738122f616e3dce498598d55f84fa8a7e2263b diff --git a/lua/uci.c b/lua/uci.c index 1c67742..ddb9c5c 100644 --- a/lua/uci.c +++ b/lua/uci.c @@ -25,6 +25,7 @@ #include #define MODNAME "uci" +#define METANAME MODNAME ".meta" //#define DEBUG 1 #ifdef DEBUG @@ -33,18 +34,76 @@ #define DPRINTF(...) do {} while (0) #endif -static struct uci_context *ctx = NULL; -enum autoload { - AUTOLOAD_OFF = 0, - AUTOLOAD_ON = 1, - AUTOLOAD_FORCE = 2 -}; +#if !defined LUA_VERSION_NUM || LUA_VERSION_NUM==501 + +/* + * ** Adapted from Lua 5.2.0 + * */ +static void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) { + luaL_checkstack(L, nup+1, "too many upvalues"); + for (; l->name != NULL; l++) { /* fill the table with given functions */ + int i; + lua_pushstring(L, l->name); + for (i = 0; i < nup; i++) /* copy upvalues to the top */ + lua_pushvalue(L, -(nup+1)); + lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */ + lua_settable(L, -(nup + 3)); + } + lua_pop(L, nup); /* remove upvalues */ +} + +#define lua_rawlen(L, i) lua_objlen(L, i) + +#endif + +static struct uci_context *global_ctx = NULL; + +static struct uci_context * +find_context(lua_State *L, int *offset) +{ + struct uci_context **ctx; + if (!lua_isuserdata(L, 1)) { + if (!global_ctx) { + global_ctx = uci_alloc_context(); + if (!global_ctx) { + luaL_error(L, "failed to allocate UCI context"); + return NULL; + } + } + if (offset) + *offset = 0; + return global_ctx; + } + if (offset) + *offset = 1; + ctx = luaL_checkudata(L, 1, METANAME); + if (!ctx || !*ctx) { + luaL_error(L, "failed to get UCI context"); + return NULL; + } + + return *ctx; +} static struct uci_package * -find_package(lua_State *L, const char *name, enum autoload al) +find_package(lua_State *L, struct uci_context *ctx, const char *str, bool al) { struct uci_package *p = NULL; struct uci_element *e; + char *sep; + char *name; + + sep = strchr(str, '.'); + if (sep) { + name = malloc(1 + sep - str); + if (!name) { + luaL_error(L, "out of memory"); + return NULL; + } + strncpy(name, str, sep - str); + name[sep - str] = 0; + } else + name = (char *) str; uci_foreach_element(&ctx->root, e) { if (strcmp(e->name, name) != 0) @@ -54,41 +113,80 @@ find_package(lua_State *L, const char *name, enum autoload al) goto done; } - if (al == AUTOLOAD_FORCE) + if (al) uci_load(ctx, name, &p); - else if (al) { - do { - lua_getfield(L, LUA_GLOBALSINDEX, "uci"); - lua_getfield(L, -1, "autoload"); - if (!lua_isboolean(L, -1)) - break; - if (!lua_toboolean(L, -1)) - break; +done: + if (name != str) + free(name); + return p; +} + +static int +lookup_args(lua_State *L, struct uci_context *ctx, int offset, struct uci_ptr *ptr, char **buf) +{ + char *s = NULL; + int n; + + n = lua_gettop(L); + luaL_checkstring(L, 1 + offset); + s = strdup(lua_tostring(L, 1 + offset)); + if (!s) + goto error; - uci_load(ctx, name, &p); - } while (0); - lua_pop(L, 2); + memset(ptr, 0, sizeof(struct uci_ptr)); + if (!find_package(L, ctx, s, true)) + goto error; + + switch (n - offset) { + case 4: + case 3: + ptr->option = luaL_checkstring(L, 3 + offset); + /* fall through */ + case 2: + ptr->section = luaL_checkstring(L, 2 + offset); + ptr->package = luaL_checkstring(L, 1 + offset); + if (uci_lookup_ptr(ctx, ptr, NULL, true) != UCI_OK) + goto error; + break; + case 1: + if (uci_lookup_ptr(ctx, ptr, s, true) != UCI_OK) + goto error; + break; + default: + luaL_error(L, "invalid argument count"); + goto error; } -done: - return p; + *buf = s; + return 0; + +error: + if (s) + free(s); + return 1; } -static void uci_lua_perror(lua_State *L, char *name) +static int +uci_push_status(lua_State *L, struct uci_context *ctx, bool hasarg) { - lua_getfield(L, LUA_GLOBALSINDEX, "uci"); - lua_getfield(L, -1, "warn"); - if (!lua_isboolean(L, -1)) - goto done; - if (lua_toboolean(L, -1) != 1) - goto done; - uci_perror(ctx, name); -done: - lua_pop(L, 2); + char *str = NULL; + + if (!hasarg) + lua_pushboolean(L, (ctx->err == UCI_OK)); + if (ctx->err) { + uci_get_errorstr(ctx, &str, MODNAME); + if (str) { + lua_pushstring(L, str); + free(str); + return 2; + } + } + return 1; } -static void uci_push_option(lua_State *L, struct uci_option *o) +static void +uci_push_option(lua_State *L, struct uci_option *o) { struct uci_element *e; int i = 0; @@ -111,15 +209,22 @@ static void uci_push_option(lua_State *L, struct uci_option *o) } } -static void uci_push_section(lua_State *L, struct uci_section *s) +static void +uci_push_section(lua_State *L, struct uci_section *s, int index) { struct uci_element *e; lua_newtable(L); + lua_pushboolean(L, s->anonymous); + lua_setfield(L, -2, ".anonymous"); lua_pushstring(L, s->type); lua_setfield(L, -2, ".type"); lua_pushstring(L, s->e.name); lua_setfield(L, -2, ".name"); + if (index >= 0) { + lua_pushinteger(L, index); + lua_setfield(L, -2, ".index"); + } uci_foreach_element(&s->options, e) { struct uci_option *o = uci_to_option(e); @@ -128,31 +233,35 @@ static void uci_push_section(lua_State *L, struct uci_section *s) } } -static void uci_push_package(lua_State *L, struct uci_package *p) +static void +uci_push_package(lua_State *L, struct uci_package *p) { struct uci_element *e; int i = 0; lua_newtable(L); uci_foreach_element(&p->sections, e) { - i++; - uci_push_section(L, uci_to_section(e)); + uci_push_section(L, uci_to_section(e), i); lua_setfield(L, -2, e->name); + i++; } } static int uci_lua_unload(lua_State *L) { + struct uci_context *ctx; struct uci_package *p; const char *s; + int offset = 0; - luaL_checkstring(L, 1); - s = lua_tostring(L, -1); - p = find_package(L, s, AUTOLOAD_OFF); + ctx = find_context(L, &offset); + luaL_checkstring(L, 1 + offset); + s = lua_tostring(L, 1 + offset); + p = find_package(L, ctx, s, false); if (p) { uci_unload(ctx, p); - lua_pushboolean(L, 1); + return uci_push_status(L, ctx, false); } else { lua_pushboolean(L, 0); } @@ -162,56 +271,67 @@ uci_lua_unload(lua_State *L) static int uci_lua_load(lua_State *L) { + struct uci_context *ctx; struct uci_package *p = NULL; const char *s; + int offset = 0; + ctx = find_context(L, &offset); uci_lua_unload(L); lua_pop(L, 1); /* bool ret value of unload */ s = lua_tostring(L, -1); - if (uci_load(ctx, s, &p)) { - uci_lua_perror(L, "uci.load"); - lua_pushboolean(L, 0); - } else { - lua_pushboolean(L, 1); - } - - return 1; + uci_load(ctx, s, &p); + return uci_push_status(L, ctx, false); } static int uci_lua_foreach(lua_State *L) { + struct uci_context *ctx; struct uci_package *p; - struct uci_element *e; + struct uci_element *e, *tmp; const char *package, *type; bool ret = false; + int offset = 0; + int i = 0; - package = luaL_checkstring(L, 1); + ctx = find_context(L, &offset); + package = luaL_checkstring(L, 1 + offset); - if (lua_isnil(L, 2)) + if (lua_isnil(L, 2 + offset)) type = NULL; else - type = luaL_checkstring(L, 2); + type = luaL_checkstring(L, 2 + offset); - if (!lua_isfunction(L, 3) || !package) - luaL_error(L, "Invalid argument"); + if (!lua_isfunction(L, 3 + offset) || !package) + return luaL_error(L, "Invalid argument"); - p = find_package(L, package, AUTOLOAD_ON); + p = find_package(L, ctx, package, true); if (!p) goto done; - uci_foreach_element(&p->sections, e) { + uci_foreach_element_safe(&p->sections, tmp, e) { struct uci_section *s = uci_to_section(e); + i++; + if (type && (strcmp(s->type, type) != 0)) continue; - lua_pushvalue(L, 3); /* iterator function */ - uci_push_section(L, s); - if (lua_pcall(L, 1, 0, 0) == 0) + lua_pushvalue(L, 3 + offset); /* iterator function */ + uci_push_section(L, s, i - 1); + if (lua_pcall(L, 1, 1, 0) == 0) { ret = true; + if (lua_isboolean(L, -1) && !lua_toboolean(L, -1)) + break; + } + else + { + lua_error(L); + break; + } } done: @@ -222,84 +342,58 @@ done: static int uci_lua_get_any(lua_State *L, bool all) { + struct uci_context *ctx; struct uci_element *e = NULL; - struct uci_package *p = NULL; - struct uci_option *o = NULL; - const char *package = NULL; - const char *section = NULL; - const char *option = NULL; - char *s; - int err = UCI_ERR_MEM; - int n; + struct uci_ptr ptr; + int offset = 0; + char *s = NULL; + int err = UCI_ERR_NOTFOUND; - n = lua_gettop(L); + ctx = find_context(L, &offset); - luaL_checkstring(L, 1); - s = strdup(lua_tostring(L, 1)); - if (!s) + if (lookup_args(L, ctx, offset, &ptr, &s)) goto error; - if (n > 1) { - package = luaL_checkstring(L, 1); - section = luaL_checkstring(L, 2); - if (n > 2) - option = luaL_checkstring(L, 3); - } else { - if ((err = uci_parse_tuple(ctx, s, (char **) &package, (char **) §ion, (char **) &option, NULL))) - goto error; - } - - if (!all && (section == NULL)) { + uci_lookup_ptr(ctx, &ptr, NULL, true); + if (!all && !ptr.s) { err = UCI_ERR_INVAL; goto error; } - - p = find_package(L, package, AUTOLOAD_ON); - if (!p) { + if (!(ptr.flags & UCI_LOOKUP_COMPLETE)) { err = UCI_ERR_NOTFOUND; goto error; } - if (section) { - if ((err = uci_lookup(ctx, &e, p, section, option))) - goto error; - } else { - e = &p->e; - } - + err = UCI_OK; + e = ptr.last; switch(e->type) { case UCI_TYPE_PACKAGE: - uci_push_package(L, p); + uci_push_package(L, ptr.p); break; case UCI_TYPE_SECTION: if (all) - uci_push_section(L, uci_to_section(e)); + uci_push_section(L, ptr.s, -1); else - lua_pushstring(L, uci_to_section(e)->type); + lua_pushstring(L, ptr.s->type); break; case UCI_TYPE_OPTION: - o = uci_to_option(e); - uci_push_option(L, o); + uci_push_option(L, ptr.o); break; default: err = UCI_ERR_INVAL; goto error; } + if (s) + free(s); + if (!err) + return 1; + error: if (s) free(s); - switch(err) { - default: - ctx->err = err; - uci_lua_perror(L, "uci.get"); - /* fall through */ - case UCI_ERR_NOTFOUND: - lua_pushnil(L); - /* fall through */ - case 0: - return 1; - } + lua_pushnil(L); + return uci_push_status(L, ctx, true); } static int @@ -317,157 +411,246 @@ uci_lua_get_all(lua_State *L) static int uci_lua_add(lua_State *L) { + struct uci_context *ctx; struct uci_section *s = NULL; struct uci_package *p; const char *package; const char *type; const char *name = NULL; + int offset = 0; - do { - package = luaL_checkstring(L, 1); - type = luaL_checkstring(L, 2); - p = find_package(L, package, AUTOLOAD_ON); - if (!p) - break; - - if (uci_add_section(ctx, p, type, &s) || !s) - break; + ctx = find_context(L, &offset); + package = luaL_checkstring(L, 1 + offset); + type = luaL_checkstring(L, 2 + offset); + p = find_package(L, ctx, package, true); + if (!p) + goto fail; - name = s->e.name; - } while (0); + if (uci_add_section(ctx, p, type, &s) || !s) + goto fail; + name = s->e.name; lua_pushstring(L, name); return 1; + +fail: + lua_pushnil(L); + return uci_push_status(L, ctx, true); } static int uci_lua_delete(lua_State *L) { - const char *package = NULL; - const char *section = NULL; - const char *option = NULL; - struct uci_package *p; - const char *s; + struct uci_context *ctx; + struct uci_ptr ptr; + int offset = 0; + char *s = NULL; + + ctx = find_context(L, &offset); + + if (lookup_args(L, ctx, offset, &ptr, &s)) + goto error; + + uci_delete(ctx, &ptr); + +error: + if (s) + free(s); + return uci_push_status(L, ctx, false); +} + +static int +uci_lua_rename(lua_State *L) +{ + struct uci_context *ctx; + struct uci_ptr ptr; int err = UCI_ERR_MEM; - int nargs; + char *s = NULL; + int nargs, offset = 0; + ctx = find_context(L, &offset); nargs = lua_gettop(L); - s = luaL_checkstring(L, 1); - switch(nargs) { + if (lookup_args(L, ctx, offset, &ptr, &s)) + goto error; + + switch(nargs - offset) { case 1: - /* Format: uci.delete("p.s[.o]") */ - s = strdup(s); - if (!s) - goto error; + /* Format: uci.set("p.s.o=v") or uci.set("p.s=v") */ + break; + case 4: + /* Format: uci.set("p", "s", "o", "v") */ + ptr.value = luaL_checkstring(L, nargs); + break; + case 3: + /* Format: uci.set("p", "s", "v") */ + ptr.value = ptr.option; + ptr.option = NULL; + break; + default: + err = UCI_ERR_INVAL; + goto error; + } - if ((err = uci_parse_tuple(ctx, (char *) s, (char **) &package, (char **) §ion, (char **) &option, NULL))) + err = uci_lookup_ptr(ctx, &ptr, NULL, true); + if (err) + goto error; + + if (((ptr.s == NULL) && (ptr.option != NULL)) || (ptr.value == NULL)) { + err = UCI_ERR_INVAL; + goto error; + } + + err = uci_rename(ctx, &ptr); + if (err) + goto error; + +error: + if (s) + free(s); + return uci_push_status(L, ctx, false); +} + +static int +uci_lua_reorder(lua_State *L) +{ + struct uci_context *ctx; + struct uci_ptr ptr; + int err = UCI_ERR_MEM; + char *s = NULL; + int nargs, offset = 0; + + ctx = find_context(L, &offset); + nargs = lua_gettop(L); + if (lookup_args(L, ctx, offset, &ptr, &s)) + goto error; + + switch(nargs - offset) { + case 1: + /* Format: uci.set("p.s=v") or uci.set("p.s=v") */ + if (ptr.option) { + err = UCI_ERR_INVAL; goto error; + } break; case 3: - /* Format: uci.delete("p", "s", "o") */ - option = luaL_checkstring(L, 3); - /* fall through */ - case 2: - /* Format: uci.delete("p", "s") */ - section = luaL_checkstring(L, 2); - package = s; + /* Format: uci.set("p", "s", "v") */ + ptr.value = ptr.option; + ptr.option = NULL; break; default: err = UCI_ERR_INVAL; goto error; } - p = find_package(L, package, AUTOLOAD_ON); - if (!p) { - err = UCI_ERR_NOTFOUND; + err = uci_lookup_ptr(ctx, &ptr, NULL, true); + if (err) + goto error; + + if ((ptr.s == NULL) || (ptr.value == NULL)) { + err = UCI_ERR_INVAL; goto error; } - err = uci_delete(ctx, p, section, option); -error: + err = uci_reorder_section(ctx, ptr.s, strtoul(ptr.value, NULL, 10)); if (err) - uci_lua_perror(L, "uci.set"); - lua_pushboolean(L, (err == 0)); - return 1; + goto error; + +error: + if (s) + free(s); + return uci_push_status(L, ctx, false); } + static int uci_lua_set(lua_State *L) { - struct uci_package *p; - const char *package = NULL; - const char *section = NULL; - const char *option = NULL; - const char *value = NULL; - const char *s; - int err = UCI_ERR_MEM; - int i, nargs; + struct uci_context *ctx; + struct uci_ptr ptr; bool istable = false; + int err = UCI_ERR_MEM; + char *s = NULL; + const char *v; + int i, nargs, offset = 0; + ctx = find_context(L, &offset); nargs = lua_gettop(L); + if (lookup_args(L, ctx, offset, &ptr, &s)) + goto error; - s = luaL_checkstring(L, 1); - switch(nargs) { + switch(nargs - offset) { case 1: /* Format: uci.set("p.s.o=v") or uci.set("p.s=v") */ - s = strdup(s); - if (!s) - goto error; - - if ((err = uci_parse_tuple(ctx, (char *) s, (char **) &package, (char **) §ion, (char **) &option, (char **) &value))) - goto error; break; case 4: /* Format: uci.set("p", "s", "o", "v") */ - option = luaL_checkstring(L, 3); - /* fall through */ - case 3: - /* Format: uci.set("p", "s", "v") */ - package = s; - section = luaL_checkstring(L, 2); if (lua_istable(L, nargs)) { - if (lua_objlen(L, nargs) < 1) - luaL_error(L, "Cannot set an uci option to an empty table value"); + if (lua_rawlen(L, nargs) < 1) + return luaL_error(L, "Cannot set an uci option to an empty table value"); lua_rawgeti(L, nargs, 1); - value = luaL_checkstring(L, -1); + ptr.value = luaL_checkstring(L, -1); lua_pop(L, 1); istable = true; } else { - value = luaL_checkstring(L, nargs); + ptr.value = luaL_checkstring(L, nargs); } break; + case 3: + /* Format: uci.set("p", "s", "v") */ + ptr.value = ptr.option; + ptr.option = NULL; + break; default: err = UCI_ERR_INVAL; goto error; } - if ((section == NULL) || (value == NULL)) { - err = UCI_ERR_INVAL; + err = uci_lookup_ptr(ctx, &ptr, NULL, true); + if (err) goto error; - } - p = find_package(L, package, AUTOLOAD_ON); - if (!p) { - err = UCI_ERR_NOTFOUND; + if (((ptr.s == NULL) && (ptr.option != NULL)) || (ptr.value == NULL)) { + err = UCI_ERR_INVAL; goto error; } - err = uci_set(ctx, p, section, option, value, NULL); + if (istable) { - for (i = 2; i <= lua_objlen(L, nargs); i++) { + if (lua_rawlen(L, nargs) == 1) { + i = 1; + if (ptr.o) { + v = ptr.value; + ptr.value = NULL; + err = uci_delete(ctx, &ptr); + if (err) + goto error; + ptr.value = v; + } + } else { + i = 2; + err = uci_set(ctx, &ptr); + if (err) + goto error; + } + + for (; i <= lua_rawlen(L, nargs); i++) { lua_rawgeti(L, nargs, i); - value = luaL_checkstring(L, -1); - err = uci_add_list(ctx, p, section, option, value, NULL); + ptr.value = luaL_checkstring(L, -1); + err = uci_add_list(ctx, &ptr); lua_pop(L, 1); if (err) goto error; } + } else { + err = uci_set(ctx, &ptr); + if (err) + goto error; } + error: - if (err) - uci_lua_perror(L, "uci.set"); - lua_pushboolean(L, (err == 0)); - return 1; + if (s) + free(s); + return uci_push_status(L, ctx, false); } enum pkg_cmd { @@ -479,67 +662,46 @@ enum pkg_cmd { static int uci_lua_package_cmd(lua_State *L, enum pkg_cmd cmd) { + struct uci_context *ctx; struct uci_element *e, *tmp; - const char *s = NULL; - const char *section = NULL; - const char *option = NULL; - int failed = 0; - int nargs; + struct uci_ptr ptr; + char *s = NULL; + int nargs, offset = 0; + ctx = find_context(L, &offset); nargs = lua_gettop(L); - switch(nargs) { - case 3: - if (cmd != CMD_REVERT) - goto err; - luaL_checkstring(L, 1); - option = lua_tostring(L, -1); - lua_pop(L, 1); - /* fall through */ - case 2: - if (cmd != CMD_REVERT) - goto err; - luaL_checkstring(L, 1); - section = lua_tostring(L, -1); - lua_pop(L, 1); - /* fall through */ - case 1: - luaL_checkstring(L, 1); - s = lua_tostring(L, -1); - lua_pop(L, 1); - break; - case 0: - break; - default: - err: - luaL_error(L, "Invalid argument count"); - break; - } + if ((cmd != CMD_REVERT) && (nargs - offset > 1)) + goto err; + + if (lookup_args(L, ctx, offset, &ptr, &s)) + goto err; + + uci_lookup_ptr(ctx, &ptr, NULL, true); uci_foreach_element_safe(&ctx->root, tmp, e) { struct uci_package *p = uci_to_package(e); - int ret = UCI_ERR_INVAL; - if (s && (strcmp(s, e->name) != 0)) + if (ptr.p && (ptr.p != p)) continue; + ptr.p = p; switch(cmd) { case CMD_COMMIT: - ret = uci_commit(ctx, &p, false); + uci_commit(ctx, &p, false); break; case CMD_SAVE: - ret = uci_save(ctx, p); + uci_save(ctx, p); break; case CMD_REVERT: - ret = uci_revert(ctx, &p, section, option); + uci_revert(ctx, &ptr); break; } - - if (ret != 0) - failed = 1; } - lua_pushboolean(L, !failed); - return 1; +err: + if (s) + free(s); + return uci_push_status(L, ctx, false); } static int @@ -563,10 +725,11 @@ uci_lua_revert(lua_State *L) static void uci_lua_add_change(lua_State *L, struct uci_element *e) { - struct uci_history *h; + struct uci_delta *h; const char *name; + const char *value; - h = uci_to_history(e); + h = uci_to_delta(e); if (!h->section) return; @@ -578,38 +741,78 @@ uci_lua_add_change(lua_State *L, struct uci_element *e) lua_setfield(L, -3, h->section); } - name = (h->e.name ? h->e.name : ".type"); - if (h->value) - lua_pushstring(L, h->value); - else - lua_pushstring(L, ""); - lua_setfield(L, -2, name); + name = h->e.name; + value = h->value ? h->value : ""; + + if (name) { + lua_getfield(L, -1, name); + + /* this delta is a list add operation */ + if (h->cmd == UCI_CMD_LIST_ADD) { + /* there seems to be no table yet */ + if (!lua_istable(L, -1)) { + lua_newtable(L); + + /* if there is a value on the stack already, add */ + if (!lua_isnil(L, -2)) { + lua_pushvalue(L, -2); + lua_rawseti(L, -2, 1); + lua_pushstring(L, value); + lua_rawseti(L, -2, 2); + + /* this is the first table item */ + } else { + lua_pushstring(L, value); + lua_rawseti(L, -2, 1); + } + + lua_setfield(L, -3, name); + + /* a table is on the top of the stack and this is a subsequent, + * list_add, append this value to table */ + } else { + lua_pushstring(L, value); + lua_rawseti(L, -2, lua_rawlen(L, -2) + 1); + } + + /* non-list change, simply set/replace field */ + } else { + lua_pushstring(L, value); + lua_setfield(L, -3, name); + } + + lua_pop(L, 1); + } else { + lua_pushstring(L, value); + lua_setfield(L, -2, ".type"); + } + lua_pop(L, 1); } static void -uci_lua_changes_pkg(lua_State *L, const char *package) +uci_lua_changes_pkg(lua_State *L, struct uci_context *ctx, const char *package) { struct uci_package *p = NULL; struct uci_element *e; bool autoload = false; - p = find_package(L, package, AUTOLOAD_OFF); + p = find_package(L, ctx, package, false); if (!p) { autoload = true; - p = find_package(L, package, AUTOLOAD_FORCE); + p = find_package(L, ctx, package, true); if (!p) return; } - if (uci_list_empty(&p->history) && uci_list_empty(&p->saved_history)) + if (uci_list_empty(&p->delta) && uci_list_empty(&p->saved_delta)) goto done; lua_newtable(L); - uci_foreach_element(&p->saved_history, e) { + uci_foreach_element(&p->saved_delta, e) { uci_lua_add_change(L, e); } - uci_foreach_element(&p->history, e) { + uci_foreach_element(&p->delta, e) { uci_lua_add_change(L, e); } lua_setfield(L, -2, p->e.name); @@ -622,30 +825,32 @@ done: static int uci_lua_changes(lua_State *L) { + struct uci_context *ctx; const char *package = NULL; char **config = NULL; int nargs; - int i; + int i, offset = 0; + ctx = find_context(L, &offset); nargs = lua_gettop(L); - switch(nargs) { + switch(nargs - offset) { case 1: - package = luaL_checkstring(L, 1); + package = luaL_checkstring(L, 1 + offset); case 0: break; default: - luaL_error(L, "invalid argument count"); + return luaL_error(L, "invalid argument count"); } lua_newtable(L); if (package) { - uci_lua_changes_pkg(L, package); + uci_lua_changes_pkg(L, ctx, package); } else { if (uci_list_configs(ctx, &config) != 0) goto done; for(i = 0; config[i] != NULL; i++) { - uci_lua_changes_pkg(L, config[i]); + uci_lua_changes_pkg(L, ctx, config[i]); } } @@ -654,43 +859,139 @@ done: } static int +uci_lua_get_confdir(lua_State *L) +{ + struct uci_context *ctx = find_context(L, NULL); + lua_pushstring(L, ctx->confdir); + return 1; +} + +static int uci_lua_set_confdir(lua_State *L) { - int ret; + struct uci_context *ctx; + int offset = 0; + + ctx = find_context(L, &offset); + luaL_checkstring(L, 1 + offset); + uci_set_confdir(ctx, lua_tostring(L, -1)); + return uci_push_status(L, ctx, false); +} - luaL_checkstring(L, 1); - ret = uci_set_confdir(ctx, lua_tostring(L, -1)); - lua_pushboolean(L, (ret == 0)); +static int +uci_lua_get_savedir(lua_State *L) +{ + struct uci_context *ctx = find_context(L, NULL); + lua_pushstring(L, ctx->savedir); return 1; } static int +uci_lua_add_delta(lua_State *L) +{ + struct uci_context *ctx; + int offset = 0; + + ctx = find_context(L, &offset); + luaL_checkstring(L, 1 + offset); + uci_add_delta_path(ctx, lua_tostring(L, -1)); + return uci_push_status(L, ctx, false); +} + +static int uci_lua_set_savedir(lua_State *L) { - int ret; + struct uci_context *ctx; + int offset = 0; + + ctx = find_context(L, &offset); + luaL_checkstring(L, 1 + offset); + uci_set_savedir(ctx, lua_tostring(L, -1)); + return uci_push_status(L, ctx, false); +} + +static int +uci_lua_list_configs(lua_State *L) +{ + struct uci_context *ctx; + char **configs = NULL; + char **ptr; + int i = 1; + + ctx = find_context(L, NULL); + if ((uci_list_configs(ctx, &configs) != UCI_OK) || !configs) + return uci_push_status(L, ctx, false); + lua_newtable(L); + for (ptr = configs; *ptr; ptr++) { + lua_pushstring(L, *ptr); + lua_rawseti(L, -2, i++); + } + free(configs); + return 1; +} - luaL_checkstring(L, 1); - ret = uci_set_savedir(ctx, lua_tostring(L, -1)); - lua_pushboolean(L, (ret == 0)); +static int +uci_lua_gc(lua_State *L) +{ + struct uci_context *ctx = find_context(L, NULL); + uci_free_context(ctx); + return 0; +} +static int +uci_lua_cursor(lua_State *L) +{ + struct uci_context **u; + int argc = lua_gettop(L); + + u = lua_newuserdata(L, sizeof(struct uci_context *)); + luaL_getmetatable(L, METANAME); + lua_setmetatable(L, -2); + + *u = uci_alloc_context(); + if (!*u) + return luaL_error(L, "Cannot allocate UCI context"); + switch (argc) { + case 2: + if (lua_isstring(L, 2) && + (uci_set_savedir(*u, luaL_checkstring(L, 2)) != UCI_OK)) + return luaL_error(L, "Unable to set savedir"); + /* fall through */ + case 1: + if (lua_isstring(L, 1) && + (uci_set_confdir(*u, luaL_checkstring(L, 1)) != UCI_OK)) + return luaL_error(L, "Unable to set savedir"); + break; + default: + break; + } return 1; } static const luaL_Reg uci[] = { + { "__gc", uci_lua_gc }, + { "cursor", uci_lua_cursor }, { "load", uci_lua_load }, { "unload", uci_lua_unload }, { "get", uci_lua_get }, { "get_all", uci_lua_get_all }, { "add", uci_lua_add }, { "set", uci_lua_set }, + { "rename", uci_lua_rename }, { "save", uci_lua_save }, { "delete", uci_lua_delete }, { "commit", uci_lua_commit }, { "revert", uci_lua_revert }, + { "reorder", uci_lua_reorder }, { "changes", uci_lua_changes }, { "foreach", uci_lua_foreach }, + { "add_history", uci_lua_add_delta }, + { "add_delta", uci_lua_add_delta }, + { "get_confdir", uci_lua_get_confdir }, { "set_confdir", uci_lua_set_confdir }, + { "get_savedir", uci_lua_get_savedir }, { "set_savedir", uci_lua_set_savedir }, + { "list_configs", uci_lua_list_configs }, { NULL, NULL }, }; @@ -698,16 +999,22 @@ static const luaL_Reg uci[] = { int luaopen_uci(lua_State *L) { - ctx = uci_alloc_context(); - if (!ctx) - luaL_error(L, "Cannot allocate UCI context\n"); - luaL_register(L, MODNAME, uci); + /* create metatable */ + luaL_newmetatable(L, METANAME); + + /* metatable.__index = metatable */ + lua_pushvalue(L, -1); + lua_setfield(L, -2, "__index"); - /* enable autoload by default */ - lua_getfield(L, LUA_GLOBALSINDEX, "uci"); - lua_pushboolean(L, 1); - lua_setfield(L, -2, "autoload"); + /* fill metatable */ + luaL_setfuncs(L, uci, 0); lua_pop(L, 1); - return 0; + /* create module */ + lua_newtable(L); + lua_pushvalue(L, -1); + luaL_setfuncs(L, uci, 0); + lua_setglobal(L, MODNAME); + + return 1; }