This adds the Zlib License which is compatible with GPLv2 as long as its terms are met. Files originally licensed as Zlib should use the "GPL-2.0+ AND Zlib" SPDX identifier.

Signed-off-by: Sean Anderson seanga2@gmail.com ---

Licenses/README | 1 + Licenses/zlib.txt | 14 ++++++++++++++ 2 files changed, 15 insertions(+) create mode 100644 Licenses/zlib.txt

diff --git a/Licenses/README b/Licenses/README index d09f0fe2cb..d5af353520 100644 --- a/Licenses/README +++ b/Licenses/README @@ -152,4 +152,5 @@ IBM PIBS (PowerPC Initialization and IBM-pibs ibm-pibs.txt ISC License ISC Y isc.txt https://spdx.org/licenses/ISC MIT License MIT Y mit.txt https://spdx.org/licenses/MIT.html SIL OPEN FONT LICENSE (OFL-1.1) OFL-1.1 Y OFL.txt https://spdx.org/licenses/OFL-1.1.html +zlib License Zlib Y zlib.txt https://spdx.org/licenses/Zlib.html X11 License X11 x11.txt https://spdx.org/licenses/X11.html diff --git a/Licenses/zlib.txt b/Licenses/zlib.txt new file mode 100644 index 0000000000..7ea8dde871 --- /dev/null +++ b/Licenses/zlib.txt @@ -0,0 +1,14 @@ +This software is provided 'as-is', without any express or implied warranty. In +no event will the authors be held liable for any damages arising from the use +of this software. + +Permission is granted to anyone to use this software for any purpose, including +commercial applications, and to alter it and redistribute it freely, subject +to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not +claim that you wrote the original software. If you use this software in a +product, an acknowledgment in the product documentation would be appreciated +but is not required. + 2. Altered source versions must be plainly marked as such, and must not be +misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution.

This is the LIL programming language [1] as originally written by Kostas Michalopoulos badsector@runtimeterror.com. LIL is a stripped-down TCL variant. Many syntax features are very similar to shell:

=> echo Hello from $stdout Hello from serial,vidconsole

LIL supports functions, scoped variables, and command substitution. For a short example, running the following script

func fact {n} { if {$n} { expr {$n * [fact [expr {$n - 1}]]} } { return 1 } } echo [fact 10] echo [fact 20]

would result in the output

fact 3628800 2432902008176640000

For more examples, please refer to the "test: Add tests for LIL" later in this series.

I have made several mostly-mechanical modifications to the source before importing it to reduce patches to functional changes. If you are interested in what has been changed before this commit, refer to my lil git repository [2]. In addition, some functions and features have been removed from this patch as I have better determined what is necessary for U-Boot and what is not. If there is sufficient interest, I can add those changes to the repository as well.

[1] http://runtimeterror.com/tech/lil/ [2] https://github.com/Forty-Bot/lil/commits/master

Signed-off-by: Sean Anderson seanga2@gmail.com ---

MAINTAINERS | 6 + cmd/Kconfig | 11 +- common/Makefile | 1 + common/cli_lil.c | 2991 +++++++++++++++++++++++++++++++++++++++++++++ include/cli_lil.h | 111 ++ 5 files changed, 3119 insertions(+), 1 deletion(-) create mode 100644 common/cli_lil.c create mode 100644 include/cli_lil.h

diff --git a/MAINTAINERS b/MAINTAINERS index 2d267aeff2..0184de5f93 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -766,6 +766,12 @@ S: Maintained T: git https://source.denx.de/u-boot/custodians/u-boot-i2c.git F: drivers/i2c/

+LIL SHELL +M: Sean Anderson seanga2@gmail.com +S: Maintained +F: common/cli_lil.c +F: include/cli_lil.h + LOGGING M: Simon Glass sjg@chromium.org S: Maintained diff --git a/cmd/Kconfig b/cmd/Kconfig index 9e8b69258f..8bccc572af 100644 --- a/cmd/Kconfig +++ b/cmd/Kconfig @@ -23,6 +23,15 @@ config HUSH_PARSER If disabled, you get the old, much simpler behaviour with a somewhat smaller memory footprint.

+config LIL + bool "Use LIL shell" + depends on CMDLINE + help + This options enables the "Little Interpreted Language" (LIL) shell as + command line interpreter, thus enabling powerful command line syntax + like `proc name {args} {body}' functions or `echo [some command]` + command substitution ("tcl scripts"). + config CMDLINE_EDITING bool "Enable command line editing" depends on CMDLINE @@ -1379,7 +1388,7 @@ config CMD_ECHO

config CMD_ITEST bool "itest" - default y + default y if !LIL help Return true/false on integer compare.

diff --git a/common/Makefile b/common/Makefile index 829ea5fb42..dce04b305e 100644 --- a/common/Makefile +++ b/common/Makefile @@ -10,6 +10,7 @@ obj-y += main.o obj-y += exports.o obj-$(CONFIG_HASH) += hash.o obj-$(CONFIG_HUSH_PARSER) += cli_hush.o +obj-$(CONFIG_LIL) += cli_lil.o obj-$(CONFIG_AUTOBOOT) += autoboot.o

# This option is not just y/n - it can have a numeric value diff --git a/common/cli_lil.c b/common/cli_lil.c new file mode 100644 index 0000000000..c8c6986fe1 --- /dev/null +++ b/common/cli_lil.c @@ -0,0 +1,2991 @@ +// SPDX-License-Identifier: GPL-2.0+ AND Zlib +/* + * LIL - Little Interpreted Language + * Copyright (C) 2021 Sean Anderson seanga2@gmail.com + * Copyright (C) 2010-2013 Kostas Michalopoulos badsector@runtimelegend.com + * + * This file originated from the LIL project, licensed under Zlib. All + * modifications are licensed under GPL-2.0+ + */ + +#include <common.h> +#include <cli_lil.h> +#include <ctype.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +/* Enable pools for reusing values, lists and environments. This will use more memory and + * will rely on the runtime/OS to free the pools once the program ends, but will cause + * considerably less memory fragmentation and improve the script execution performance. */ +/*#define LIL_ENABLE_POOLS*/ + +/* Enable limiting recursive calls to lil_parse - this can be used to avoid call stack + * overflows and is also useful when running through an automated fuzzer like AFL */ +/*#define LIL_ENABLE_RECLIMIT 10000*/ + +#define ERROR_NOERROR 0 +#define ERROR_DEFAULT 1 +#define ERROR_FIXHEAD 2 + +#define CALLBACKS 8 +#define HASHMAP_CELLS 256 +#define HASHMAP_CELLMASK 0xFF + +struct hashentry { + char *k; + void *v; +}; + +struct hashcell { + struct hashentry *e; + size_t c; +}; + +struct hashmap { + struct hashcell cell[HASHMAP_CELLS]; +}; + +struct lil_value { + size_t l; +#ifdef LIL_ENABLE_POOLS + size_t c; +#endif + char *d; +}; + +struct lil_var { + char *n; + struct lil_env *env; + struct lil_value *v; +}; + +struct lil_env { + struct lil_env *parent; + struct lil_func *func; + struct lil_var **var; + size_t vars; + struct hashmap varmap; + struct lil_value *retval; + int retval_set; + int breakrun; +}; + +struct lil_list { + struct lil_value **v; + size_t c; + size_t cap; +}; + +struct lil_func { + char *name; + struct lil_value *code; + struct lil_list *argnames; + lil_func_proc_t proc; +}; + +struct lil { + const char *code; /* need save on parse */ + const char *rootcode; + size_t clen; /* need save on parse */ + size_t head; /* need save on parse */ + int ignoreeol; + struct lil_func **cmd; + size_t cmds; + struct hashmap cmdmap; + struct lil_env *env; + struct lil_env *rootenv; + struct lil_env *downenv; + struct lil_value *empty; + int error; + size_t err_head; + char *err_msg; + lil_callback_proc_t callback[CALLBACKS]; + size_t parse_depth; +}; + +struct expreval { + const char *code; + size_t len, head; + ssize_t ival; + int error; +}; + +static struct lil_value *next_word(struct lil *lil); +static void register_stdcmds(struct lil *lil); + +#ifdef LIL_ENABLE_POOLS +static struct lil_value **pool; +static int poolsize, poolcap; +static struct lil_list **listpool; +static size_t listpoolsize, listpoolcap; +static struct lil_env **envpool; +static size_t envpoolsize, envpoolcap; +#endif + +static char *strclone(const char *s) +{ + size_t len = strlen(s) + 1; + char *ns = malloc(len); + + if (!ns) + return NULL; + memcpy(ns, s, len); + return ns; +} + +static unsigned long hm_hash(const char *key) +{ + unsigned long hash = 5381; + int c; + + while ((c = *key++)) + hash = ((hash << 5) + hash) + c; + return hash; +} + +static void hm_init(struct hashmap *hm) +{ + memset(hm, 0, sizeof(struct hashmap)); +} + +static void hm_destroy(struct hashmap *hm) +{ + size_t i, j; + + for (i = 0; i < HASHMAP_CELLS; i++) { + for (j = 0; j < hm->cell[i].c; j++) + free(hm->cell[i].e[j].k); + free(hm->cell[i].e); + } +} + +static void hm_put(struct hashmap *hm, const char *key, void *value) +{ + struct hashcell *cell = hm->cell + (hm_hash(key) & HASHMAP_CELLMASK); + size_t i; + + for (i = 0; i < cell->c; i++) { + if (!strcmp(key, cell->e[i].k)) { + cell->e[i].v = value; + return; + } + } + + cell->e = realloc(cell->e, sizeof(struct hashentry) * (cell->c + 1)); + cell->e[cell->c].k = strclone(key); + cell->e[cell->c].v = value; + cell->c++; +} + +static void *hm_get(struct hashmap *hm, const char *key) +{ + struct hashcell *cell = hm->cell + (hm_hash(key) & HASHMAP_CELLMASK); + size_t i; + + for (i = 0; i < cell->c; i++) + if (!strcmp(key, cell->e[i].k)) + return cell->e[i].v; + return NULL; +} + +static int hm_has(struct hashmap *hm, const char *key) +{ + struct hashcell *cell = hm->cell + (hm_hash(key) & HASHMAP_CELLMASK); + size_t i; + + for (i = 0; i < cell->c; i++) + if (!strcmp(key, cell->e[i].k)) + return 1; + return 0; +} + +#ifdef LIL_ENABLE_POOLS +static struct lil_value *alloc_from_pool(void) +{ + if (poolsize > 0) { + poolsize--; + return pool[poolsize]; + } else { + struct lil_value *val = calloc(1, sizeof(struct lil_value)); + + return val; + } +} + +static void release_to_pool(struct lil_value *val) +{ + if (poolsize == poolcap) { + poolcap = poolcap ? (poolcap + poolcap / 2) : 64; + pool = realloc(pool, sizeof(struct lil_value *) * poolcap); + } + pool[poolsize++] = val; +} + +static void ensure_capacity(struct lil_value *val, size_t cap) +{ + if (val->c < cap) { + val->c = cap + 128; + val->d = realloc(val->d, val->c); + } +} +#endif + +static struct lil_value *alloc_value_len(const char *str, size_t len) +{ +#ifdef LIL_ENABLE_POOLS + struct lil_value *val = alloc_from_pool(); +#else + struct lil_value *val = calloc(1, sizeof(struct lil_value)); +#endif + + if (!val) + return NULL; + if (str) { + val->l = len; +#ifdef LIL_ENABLE_POOLS + ensure_capacity(val, len + 1); +#else + val->d = malloc(len + 1); + if (!val->d) { + free(val); + return NULL; + } +#endif + memcpy(val->d, str, len); + val->d[len] = 0; + } else { + val->l = 0; +#ifdef LIL_ENABLE_POOLS + ensure_capacity(val, 1); + val->d[0] = '\0'; +#else + val->d = NULL; +#endif + } + return val; +} + +static struct lil_value *alloc_value(const char *str) +{ + return alloc_value_len(str, str ? strlen(str) : 0); +} + +struct lil_value *lil_clone_value(struct lil_value *src) +{ + struct lil_value *val; + + if (!src) + return NULL; +#ifdef LIL_ENABLE_POOLS + val = alloc_from_pool(); +#else + val = calloc(1, sizeof(struct lil_value)); +#endif + if (!val) + return NULL; + + val->l = src->l; + if (src->l) { +#ifdef LIL_ENABLE_POOLS + ensure_capacity(val, val->l + 1); +#else + val->d = malloc(val->l + 1); + if (!val->d) { + free(val); + return NULL; + } +#endif + memcpy(val->d, src->d, val->l + 1); + } else { +#ifdef LIL_ENABLE_POOLS + ensure_capacity(val, 1); + val->d[0] = '\0'; +#else + val->d = NULL; +#endif + } + return val; +} + +int lil_append_char(struct lil_value *val, char ch) +{ +#ifdef LIL_ENABLE_POOLS + ensure_capacity(val, val->l + 2); + val->d[val->l++] = ch; + val->d[val->l] = '\0'; +#else + char *new = realloc(val->d, val->l + 2); + + if (!new) + return 0; + + new[val->l++] = ch; + new[val->l] = 0; + val->d = new; +#endif + return 1; +} + +int lil_append_string_len(struct lil_value *val, const char *s, size_t len) +{ +#ifndef LIL_ENABLE_POOLS + char *new; +#endif + + if (!s || !s[0]) + return 1; + +#ifdef LIL_ENABLE_POOLS + ensure_capacity(val, val->l + len + 1); + memcpy(val->d + val->l, s, len + 1); +#else + new = realloc(val->d, val->l + len + 1); + if (!new) + return 0; + + memcpy(new + val->l, s, len + 1); + val->d = new; +#endif + val->l += len; + return 1; +} + +int lil_append_string(struct lil_value *val, const char *s) +{ + return lil_append_string_len(val, s, strlen(s)); +} + +int lil_append_val(struct lil_value *val, struct lil_value *v) +{ +#ifndef LIL_ENABLE_POOLS + char *new; +#endif + + if (!v || !v->l) + return 1; + +#ifdef LIL_ENABLE_POOLS + ensure_capacity(val, val->l + v->l + 1); + memcpy(val->d + val->l, v->d, v->l + 1); +#else + new = realloc(val->d, val->l + v->l + 1); + if (!new) + return 0; + + memcpy(new + val->l, v->d, v->l + 1); + val->d = new; +#endif + val->l += v->l; + return 1; +} + +void lil_free_value(struct lil_value *val) +{ + if (!val) + return; + +#ifdef LIL_ENABLE_POOLS + release_to_pool(val); +#else + free(val->d); + free(val); +#endif +} + +struct lil_list *lil_alloc_list(void) +{ + struct lil_list *list; + +#ifdef LIL_ENABLE_POOLS + if (listpoolsize > 0) + return listpool[--listpoolsize]; +#endif + list = calloc(1, sizeof(struct lil_list)); + list->v = NULL; + return list; +} + +void lil_free_list(struct lil_list *list) +{ + size_t i; + + if (!list) + return; + + for (i = 0; i < list->c; i++) + lil_free_value(list->v[i]); + +#ifdef LIL_ENABLE_POOLS + list->c = 0; + if (listpoolsize == listpoolcap) { + listpoolcap = + listpoolcap ? (listpoolcap + listpoolcap / 2) : 32; + listpool = realloc(listpool, + sizeof(struct lil_list *) * listpoolcap); + } + listpool[listpoolsize++] = list; +#else + free(list->v); + free(list); +#endif +} + +void lil_list_append(struct lil_list *list, struct lil_value *val) +{ + if (list->c == list->cap) { + size_t cap = list->cap ? (list->cap + list->cap / 2) : 32; + struct lil_value **nv = + realloc(list->v, sizeof(struct lil_value *) * cap); + + if (!nv) + return; + + list->cap = cap; + list->v = nv; + } + list->v[list->c++] = val; +} + +size_t lil_list_size(struct lil_list *list) +{ + return list->c; +} + +struct lil_value *lil_list_get(struct lil_list *list, size_t index) +{ + return index >= list->c ? NULL : list->v[index]; +} + +static int needs_escape(const char *str) +{ + size_t i; + + if (!str || !str[0]) + return 1; + + for (i = 0; str[i]; i++) + if (ispunct(str[i]) || isspace(str[i])) + return 1; + + return 0; +} + +struct lil_value *lil_list_to_value(struct lil_list *list, int do_escape) +{ + struct lil_value *val = alloc_value(NULL); + size_t i, j; + + for (i = 0; i < list->c; i++) { + int escape = + do_escape ? needs_escape(lil_to_string(list->v[i])) : 0; + + if (i) + lil_append_char(val, ' '); + + if (escape) { + lil_append_char(val, '{'); + for (j = 0; j < list->v[i]->l; j++) { + if (list->v[i]->d[j] == '{') + lil_append_string(val, "}"\o"{"); + else if (list->v[i]->d[j] == '}') + lil_append_string(val, "}"\c"{"); + else + lil_append_char(val, list->v[i]->d[j]); + } + lil_append_char(val, '}'); + } else { + lil_append_val(val, list->v[i]); + } + } + return val; +} + +struct lil_env *lil_alloc_env(struct lil_env *parent) +{ + struct lil_env *env; + +#ifdef LIL_ENABLE_POOLS + if (envpoolsize > 0) { + size_t i, j; + + env = envpool[--envpoolsize]; + env->parent = parent; + env->func = NULL; + env->var = NULL; + env->vars = 0; + env->retval = NULL; + env->retval_set = 0; + env->breakrun = 0; + for (i = 0; i < HASHMAP_CELLS; i++) { + for (j = 0; j < env->varmap.cell[i].c; j++) + free(env->varmap.cell[i].e[j].k); + env->varmap.cell[i].c = 0; + } + return env; + } +#endif + env = calloc(1, sizeof(struct lil_env)); + env->parent = parent; + return env; +} + +void lil_free_env(struct lil_env *env) +{ + size_t i; + + if (!env) + return; + + lil_free_value(env->retval); +#ifdef LIL_ENABLE_POOLS + for (i = 0; i < env->vars; i++) { + free(env->var[i]->n); + lil_free_value(env->var[i]->v); + free(env->var[i]); + } + free(env->var); + + if (envpoolsize == envpoolcap) { + envpoolcap = envpoolcap ? (envpoolcap + envpoolcap / 2) : 64; + envpool = + realloc(envpool, sizeof(struct lil_env *) * envpoolcap); + } + envpool[envpoolsize++] = env; +#else + hm_destroy(&env->varmap); + for (i = 0; i < env->vars; i++) { + free(env->var[i]->n); + lil_free_value(env->var[i]->v); + free(env->var[i]); + } + free(env->var); + free(env); +#endif +} + +static struct lil_var *lil_find_local_var(struct lil *lil, struct lil_env *env, + const char *name) +{ + return hm_get(&env->varmap, name); +} + +static struct lil_var *lil_find_var(struct lil *lil, struct lil_env *env, + const char *name) +{ + struct lil_var *r = lil_find_local_var(lil, env, name); + + if (r) + return r; + + if (env == lil->rootenv) + return NULL; + + return lil_find_var(lil, lil->rootenv, name); +} + +static struct lil_func *lil_find_cmd(struct lil *lil, const char *name) +{ + return hm_get(&lil->cmdmap, name); +} + +static struct lil_func *add_func(struct lil *lil, const char *name) +{ + struct lil_func *cmd; + struct lil_func **ncmd; + + cmd = lil_find_cmd(lil, name); + if (cmd) { + if (cmd->argnames) + lil_free_list(cmd->argnames); + lil_free_value(cmd->code); + cmd->argnames = NULL; + cmd->code = NULL; + cmd->proc = NULL; + return cmd; + } + + cmd = calloc(1, sizeof(struct lil_func)); + cmd->name = strclone(name); + + ncmd = realloc(lil->cmd, sizeof(struct lil_func *) * (lil->cmds + 1)); + if (!ncmd) { + free(cmd); + return NULL; + } + + lil->cmd = ncmd; + ncmd[lil->cmds++] = cmd; + hm_put(&lil->cmdmap, name, cmd); + return cmd; +} + +static void del_func(struct lil *lil, struct lil_func *cmd) +{ + size_t i, index = lil->cmds; + + for (i = 0; i < lil->cmds; i++) { + if (lil->cmd[i] == cmd) { + index = i; + break; + } + } + if (index == lil->cmds) + return; + + hm_put(&lil->cmdmap, cmd->name, 0); + if (cmd->argnames) + lil_free_list(cmd->argnames); + + lil_free_value(cmd->code); + free(cmd->name); + free(cmd); + lil->cmds--; + for (i = index; i < lil->cmds; i++) + lil->cmd[i] = lil->cmd[i + 1]; +} + +int lil_register(struct lil *lil, const char *name, lil_func_proc_t proc) +{ + struct lil_func *cmd = add_func(lil, name); + + if (!cmd) + return 0; + cmd->proc = proc; + return 1; +} + +struct lil_var *lil_set_var(struct lil *lil, const char *name, + struct lil_value *val, int local) +{ + struct lil_var **nvar; + struct lil_env *env = + local == LIL_SETVAR_GLOBAL ? lil->rootenv : lil->env; + int freeval = 0; + + if (!name[0]) + return NULL; + + if (local != LIL_SETVAR_LOCAL_NEW) { + struct lil_var *var = lil_find_var(lil, env, name); + + if (local == LIL_SETVAR_LOCAL_ONLY && var && + var->env == lil->rootenv && var->env != env) + var = NULL; + + if (((!var && env == lil->rootenv) || + (var && var->env == lil->rootenv)) && + lil->callback[LIL_CALLBACK_SETVAR]) { + lil_setvar_callback_proc_t proc = + (lil_setvar_callback_proc_t) + lil->callback[LIL_CALLBACK_SETVAR]; + struct lil_value *newval = val; + int r = proc(lil, name, &newval); + + if (r < 0) { + return NULL; + } else if (r > 0) { + val = newval; + freeval = 1; + } + } + + if (var) { + lil_free_value(var->v); + var->v = freeval ? val : lil_clone_value(val); + return var; + } + } + + nvar = realloc(env->var, sizeof(struct lil_var *) * (env->vars + 1)); + if (!nvar) { + /* TODO: report memory error */ + return NULL; + } + + env->var = nvar; + nvar[env->vars] = calloc(1, sizeof(struct lil_var)); + nvar[env->vars]->n = strclone(name); + nvar[env->vars]->env = env; + nvar[env->vars]->v = freeval ? val : lil_clone_value(val); + hm_put(&env->varmap, name, nvar[env->vars]); + return nvar[env->vars++]; +} + +struct lil_value *lil_get_var(struct lil *lil, const char *name) +{ + return lil_get_var_or(lil, name, lil->empty); +} + +struct lil_value *lil_get_var_or(struct lil *lil, const char *name, + struct lil_value *defvalue) +{ + struct lil_var *var = lil_find_var(lil, lil->env, name); + struct lil_value *retval = var ? var->v : defvalue; + + if (lil->callback[LIL_CALLBACK_GETVAR] && + (!var || var->env == lil->rootenv)) { + lil_getvar_callback_proc_t proc = + (lil_getvar_callback_proc_t) + lil->callback[LIL_CALLBACK_GETVAR]; + struct lil_value *newretval = retval; + + if (proc(lil, name, &newretval)) + retval = newretval; + } + return retval; +} + +struct lil_env *lil_push_env(struct lil *lil) +{ + struct lil_env *env = lil_alloc_env(lil->env); + + lil->env = env; + return env; +} + +void lil_pop_env(struct lil *lil) +{ + if (lil->env->parent) { + struct lil_env *next = lil->env->parent; + + lil_free_env(lil->env); + lil->env = next; + } +} + +struct lil *lil_new(void) +{ + struct lil *lil = calloc(1, sizeof(struct lil)); + + lil->rootenv = lil->env = lil_alloc_env(NULL); + lil->empty = alloc_value(NULL); + hm_init(&lil->cmdmap); + register_stdcmds(lil); + return lil; +} + +static int islilspecial(char ch) +{ + return ch == '$' || ch == '{' || ch == '}' || ch == '[' || ch == ']' || + ch == '"' || ch == ''' || ch == ';'; +} + +static int eolchar(char ch) +{ + return ch == '\n' || ch == '\r' || ch == ';'; +} + +static int ateol(struct lil *lil) +{ + return !(lil->ignoreeol) && eolchar(lil->code[lil->head]); +} + +static void lil_skip_spaces(struct lil *lil) +{ + while (lil->head < lil->clen) { + if (lil->code[lil->head] == '#') { + if (lil->code[lil->head + 1] == '#' && + lil->code[lil->head + 2] != '#') { + lil->head += 2; + while (lil->head < lil->clen) { + if ((lil->code[lil->head] == '#') && + (lil->code[lil->head + 1] == '#') && + (lil->code[lil->head + 2] != '#')) { + lil->head += 2; + break; + } + lil->head++; + } + } else { + while (lil->head < lil->clen && + !eolchar(lil->code[lil->head])) + lil->head++; + } + } else if (lil->code[lil->head] == '\' && + eolchar(lil->code[lil->head + 1])) { + lil->head++; + while (lil->head < lil->clen && + eolchar(lil->code[lil->head])) + lil->head++; + } else if (eolchar(lil->code[lil->head])) { + if (lil->ignoreeol) + lil->head++; + else + break; + } else if (isspace(lil->code[lil->head])) { + lil->head++; + } else { + break; + } + } +} + +static struct lil_value *get_bracketpart(struct lil *lil) +{ + size_t cnt = 1; + struct lil_value *val, *cmd = alloc_value(NULL); + int save_eol = lil->ignoreeol; + + lil->ignoreeol = 0; + lil->head++; + while (lil->head < lil->clen) { + if (lil->code[lil->head] == '[') { + lil->head++; + cnt++; + lil_append_char(cmd, '['); + } else if (lil->code[lil->head] == ']') { + lil->head++; + if (--cnt == 0) + break; + else + lil_append_char(cmd, ']'); + } else { + lil_append_char(cmd, lil->code[lil->head++]); + } + } + + val = lil_parse_value(lil, cmd, 0); + lil_free_value(cmd); + lil->ignoreeol = save_eol; + return val; +} + +static struct lil_value *get_dollarpart(struct lil *lil) +{ + struct lil_value *val, *name, *tmp; + + lil->head++; + name = next_word(lil); + tmp = alloc_value("set "); + lil_append_val(tmp, name); + lil_free_value(name); + + val = lil_parse_value(lil, tmp, 0); + lil_free_value(tmp); + return val; +} + +static struct lil_value *next_word(struct lil *lil) +{ + struct lil_value *val; + size_t start; + + lil_skip_spaces(lil); + if (lil->code[lil->head] == '$') { + val = get_dollarpart(lil); + } else if (lil->code[lil->head] == '{') { + size_t cnt = 1; + + lil->head++; + val = alloc_value(NULL); + while (lil->head < lil->clen) { + if (lil->code[lil->head] == '{') { + lil->head++; + cnt++; + lil_append_char(val, '{'); + } else if (lil->code[lil->head] == '}') { + lil->head++; + if (--cnt == 0) + break; + else + lil_append_char(val, '}'); + } else { + lil_append_char(val, lil->code[lil->head++]); + } + } + } else if (lil->code[lil->head] == '[') { + val = get_bracketpart(lil); + } else if (lil->code[lil->head] == '"' || + lil->code[lil->head] == ''') { + char sc = lil->code[lil->head++]; + + val = alloc_value(NULL); + while (lil->head < lil->clen) { + if (lil->code[lil->head] == '[' || + lil->code[lil->head] == '$') { + struct lil_value *tmp = + lil->code[lil->head] == '$' ? + get_dollarpart(lil) : + get_bracketpart(lil); + + lil_append_val(val, tmp); + lil_free_value(tmp); + lil->head--; /* avoid skipping the char below */ + } else if (lil->code[lil->head] == '\') { + lil->head++; + switch (lil->code[lil->head]) { + case 'b': + lil_append_char(val, '\b'); + break; + case 't': + lil_append_char(val, '\t'); + break; + case 'n': + lil_append_char(val, '\n'); + break; + case 'v': + lil_append_char(val, '\v'); + break; + case 'f': + lil_append_char(val, '\f'); + break; + case 'r': + lil_append_char(val, '\r'); + break; + case '0': + lil_append_char(val, 0); + break; + case 'a': + lil_append_char(val, '\a'); + break; + case 'c': + lil_append_char(val, '}'); + break; + case 'o': + lil_append_char(val, '{'); + break; + default: + lil_append_char(val, + lil->code[lil->head]); + break; + } + } else if (lil->code[lil->head] == sc) { + lil->head++; + break; + } else { + lil_append_char(val, lil->code[lil->head]); + } + lil->head++; + } + } else { + start = lil->head; + while (lil->head < lil->clen && + !isspace(lil->code[lil->head]) && + !islilspecial(lil->code[lil->head])) + lil->head++; + val = alloc_value_len(lil->code + start, lil->head - start); + } + return val ? val : alloc_value(NULL); +} + +static struct lil_list *substitute(struct lil *lil) +{ + struct lil_list *words = lil_alloc_list(); + + lil_skip_spaces(lil); + while (lil->head < lil->clen && !ateol(lil) && !lil->error) { + struct lil_value *w = alloc_value(NULL); + + do { + size_t head = lil->head; + struct lil_value *wp = next_word(lil); + + if (head == + lil->head) { /* something wrong, the parser can't proceed */ + lil_free_value(w); + lil_free_value(wp); + lil_free_list(words); + return NULL; + } + + lil_append_val(w, wp); + lil_free_value(wp); + } while (lil->head < lil->clen && + !eolchar(lil->code[lil->head]) && + !isspace(lil->code[lil->head]) && !lil->error); + lil_skip_spaces(lil); + + lil_list_append(words, w); + } + + return words; +} + +struct lil_list *lil_subst_to_list(struct lil *lil, struct lil_value *code) +{ + const char *save_code = lil->code; + size_t save_clen = lil->clen; + size_t save_head = lil->head; + int save_igeol = lil->ignoreeol; + struct lil_list *words; + + lil->code = lil_to_string(code); + lil->clen = code->l; + lil->head = 0; + lil->ignoreeol = 1; + + words = substitute(lil); + if (!words) + words = lil_alloc_list(); + + lil->code = save_code; + lil->clen = save_clen; + lil->head = save_head; + lil->ignoreeol = save_igeol; + return words; +} + +struct lil_value *lil_subst_to_value(struct lil *lil, struct lil_value *code) +{ + struct lil_list *words = lil_subst_to_list(lil, code); + struct lil_value *val; + + val = lil_list_to_value(words, 0); + lil_free_list(words); + return val; +} + +static struct lil_value *run_cmd(struct lil *lil, struct lil_func *cmd, + struct lil_list *words) +{ + struct lil_value *r; + + if (cmd->proc) { + size_t shead = lil->head; + + r = cmd->proc(lil, words->c - 1, words->v + 1); + if (lil->error == ERROR_FIXHEAD) { + lil->error = ERROR_DEFAULT; + lil->err_head = shead; + } + } else { + lil_push_env(lil); + lil->env->func = cmd; + + if (cmd->argnames->c == 1 && + !strcmp(lil_to_string(cmd->argnames->v[0]), "args")) { + struct lil_value *args = lil_list_to_value(words, 1); + + lil_set_var(lil, "args", args, LIL_SETVAR_LOCAL_NEW); + lil_free_value(args); + } else { + size_t i; + + for (i = 0; i < cmd->argnames->c; i++) { + struct lil_value *val; + + if (i < words->c - 1) + val = words->v[i + 1]; + else + val = lil->empty; + + lil_set_var(lil, + lil_to_string(cmd->argnames->v[i]), + val, LIL_SETVAR_LOCAL_NEW); + } + } + r = lil_parse_value(lil, cmd->code, 1); + + lil_pop_env(lil); + } + + return r; +} + +struct lil_value *lil_parse(struct lil *lil, const char *code, size_t codelen, + int funclevel) +{ + const char *save_code = lil->code; + size_t save_clen = lil->clen; + size_t save_head = lil->head; + struct lil_value *val = NULL; + struct lil_list *words = NULL; + + if (!save_code) + lil->rootcode = code; + lil->code = code; + lil->clen = codelen ? codelen : strlen(code); + lil->head = 0; + + lil_skip_spaces(lil); + lil->parse_depth++; +#ifdef LIL_ENABLE_RECLIMIT + if (lil->parse_depth > LIL_ENABLE_RECLIMIT) { + lil_set_error(lil, "Too many recursive calls"); + goto cleanup; + } +#endif + + if (lil->parse_depth == 1) + lil->error = 0; + + if (funclevel) + lil->env->breakrun = 0; + + while (lil->head < lil->clen && !lil->error) { + if (words) + lil_free_list(words); + + if (val) + lil_free_value(val); + val = NULL; + + words = substitute(lil); + if (!words || lil->error) + goto cleanup; + + if (words->c) { + struct lil_func *cmd = + lil_find_cmd(lil, lil_to_string(words->v[0])); + + if (!cmd) { + if (words->v[0]->l) { + char msg[64]; + + snprintf(msg, sizeof(msg), + "unknown function %s", + words->v[0]->d); + lil_set_error_at(lil, lil->head, msg); + goto cleanup; + } + } else { + val = run_cmd(lil, cmd, words); + } + + if (lil->env->breakrun) + goto cleanup; + } + + lil_skip_spaces(lil); + while (ateol(lil)) + lil->head++; + lil_skip_spaces(lil); + } + +cleanup: + if (lil->error && lil->callback[LIL_CALLBACK_ERROR] && + lil->parse_depth == 1) { + lil_error_callback_proc_t proc = + (lil_error_callback_proc_t) + lil->callback[LIL_CALLBACK_ERROR]; + + proc(lil, lil->err_head, lil->err_msg); + } + + if (words) + lil_free_list(words); + lil->code = save_code; + lil->clen = save_clen; + lil->head = save_head; + + if (funclevel && lil->env->retval_set) { + if (val) + lil_free_value(val); + val = lil->env->retval; + lil->env->retval = NULL; + lil->env->retval_set = 0; + lil->env->breakrun = 0; + } + + lil->parse_depth--; + return val ? val : alloc_value(NULL); +} + +struct lil_value *lil_parse_value(struct lil *lil, struct lil_value *val, + int funclevel) +{ + if (!val || !val->d || !val->l) + return alloc_value(NULL); + + return lil_parse(lil, val->d, val->l, funclevel); +} + +void lil_callback(struct lil *lil, int cb, lil_callback_proc_t proc) +{ + if (cb < 0 || cb > CALLBACKS) + return; + + lil->callback[cb] = proc; +} + +void lil_set_error(struct lil *lil, const char *msg) +{ + if (lil->error) + return; + + free(lil->err_msg); + lil->error = ERROR_FIXHEAD; + lil->err_head = 0; + lil->err_msg = strclone(msg ? msg : ""); +} + +void lil_set_error_at(struct lil *lil, size_t pos, const char *msg) +{ + if (lil->error) + return; + + free(lil->err_msg); + lil->error = ERROR_DEFAULT; + lil->err_head = pos; + lil->err_msg = strclone(msg ? msg : ""); +} + +int lil_error(struct lil *lil, const char **msg, size_t *pos) +{ + if (!lil->error) + return 0; + + *msg = lil->err_msg; + *pos = lil->err_head; + lil->error = ERROR_NOERROR; + + return 1; +} + +#define EERR_NO_ERROR 0 +#define EERR_SYNTAX_ERROR 1 +#define EERR_DIVISION_BY_ZERO 3 +#define EERR_INVALID_EXPRESSION 4 + +static void ee_expr(struct expreval *ee); + +static int ee_invalidpunct(int ch) +{ + return ispunct(ch) && ch != '!' && ch != '~' && ch != '(' && + ch != ')' && ch != '-' && ch != '+'; +} + +static void ee_skip_spaces(struct expreval *ee) +{ + while (ee->head < ee->len && isspace(ee->code[ee->head])) + ee->head++; +} + +static void ee_numeric_element(struct expreval *ee) +{ + ee_skip_spaces(ee); + ee->ival = 0; + while (ee->head < ee->len) { + if (!isdigit(ee->code[ee->head])) + break; + + ee->ival = ee->ival * 10 + (ee->code[ee->head] - '0'); + ee->head++; + } +} + +static void ee_element(struct expreval *ee) +{ + if (isdigit(ee->code[ee->head])) { + ee_numeric_element(ee); + return; + } + + /* + * for anything else that might creep in (usually from strings), we set + * the value to 1 so that strings evaluate as "true" when used in + * conditional expressions + */ + ee->ival = 1; + ee->error = EERR_INVALID_EXPRESSION; /* special flag, will be cleared */ +} + +static void ee_paren(struct expreval *ee) +{ + ee_skip_spaces(ee); + if (ee->code[ee->head] == '(') { + ee->head++; + ee_expr(ee); + ee_skip_spaces(ee); + + if (ee->code[ee->head] == ')') + ee->head++; + else + ee->error = EERR_SYNTAX_ERROR; + } else { + ee_element(ee); + } +} + +static void ee_unary(struct expreval *ee) +{ + ee_skip_spaces(ee); + if (ee->head < ee->len && !ee->error && + (ee->code[ee->head] == '-' || ee->code[ee->head] == '+' || + ee->code[ee->head] == '~' || ee->code[ee->head] == '!')) { + char op = ee->code[ee->head++]; + + ee_unary(ee); + if (ee->error) + return; + + switch (op) { + case '-': + ee->ival = -ee->ival; + break; + case '+': + /* ignore it, doesn't change a thing */ + break; + case '~': + ee->ival = ~ee->ival; + break; + case '!': + ee->ival = !ee->ival; + break; + } + } else { + ee_paren(ee); + } +} + +static void ee_muldiv(struct expreval *ee) +{ + ee_unary(ee); + if (ee->error) + return; + + ee_skip_spaces(ee); + while (ee->head < ee->len && !ee->error && + !ee_invalidpunct(ee->code[ee->head + 1]) && + (ee->code[ee->head] == '*' || ee->code[ee->head] == '/' || + ee->code[ee->head] == '\' || ee->code[ee->head] == '%')) { + ssize_t oival = ee->ival; + + switch (ee->code[ee->head]) { + case '*': + ee->head++; + ee_unary(ee); + if (ee->error) + return; + + ee->ival = ee->ival * oival; + break; + case '%': + ee->head++; + ee_unary(ee); + if (ee->error) + return; + + if (ee->ival == 0) + ee->error = EERR_DIVISION_BY_ZERO; + else + ee->ival = oival % ee->ival; + break; + case '/': + ee->head++; + ee_unary(ee); + if (ee->error) + return; + + if (ee->ival == 0) + ee->error = EERR_DIVISION_BY_ZERO; + else + ee->ival = oival / ee->ival; + break; + case '\': + ee->head++; + ee_unary(ee); + if (ee->error) + return; + + if (ee->ival == 0) + ee->error = EERR_DIVISION_BY_ZERO; + else + ee->ival = oival / ee->ival; + break; + } + + ee_skip_spaces(ee); + } +} + +static void ee_addsub(struct expreval *ee) +{ + ee_muldiv(ee); + ee_skip_spaces(ee); + + while (ee->head < ee->len && !ee->error && + !ee_invalidpunct(ee->code[ee->head + 1]) && + (ee->code[ee->head] == '+' || ee->code[ee->head] == '-')) { + ssize_t oival = ee->ival; + + switch (ee->code[ee->head]) { + case '+': + ee->head++; + ee_muldiv(ee); + if (ee->error) + return; + + ee->ival = ee->ival + oival; + break; + case '-': + ee->head++; + ee_muldiv(ee); + if (ee->error) + return; + + ee->ival = oival - ee->ival; + break; + } + + ee_skip_spaces(ee); + } +} + +static void ee_shift(struct expreval *ee) +{ + ee_addsub(ee); + ee_skip_spaces(ee); + + while (ee->head < ee->len && !ee->error && + ((ee->code[ee->head] == '<' && ee->code[ee->head + 1] == '<') || + (ee->code[ee->head] == '>' && ee->code[ee->head + 1] == '>'))) { + ssize_t oival = ee->ival; + + ee->head++; + switch (ee->code[ee->head]) { + case '<': + ee->head++; + ee_addsub(ee); + if (ee->error) + return; + + ee->ival = oival << ee->ival; + break; + case '>': + ee->head++; + ee_addsub(ee); + if (ee->error) + return; + + ee->ival = oival >> ee->ival; + break; + } + + ee_skip_spaces(ee); + } +} + +static void ee_compare(struct expreval *ee) +{ + ee_shift(ee); + ee_skip_spaces(ee); + + while (ee->head < ee->len && !ee->error && + ((ee->code[ee->head] == '<' && + !ee_invalidpunct(ee->code[ee->head + 1])) || + (ee->code[ee->head] == '>' && + !ee_invalidpunct(ee->code[ee->head + 1])) || + (ee->code[ee->head] == '<' && ee->code[ee->head + 1] == '=') || + (ee->code[ee->head] == '>' && ee->code[ee->head + 1] == '='))) { + ssize_t oival = ee->ival; + int op = 4; + + if (ee->code[ee->head] == '<' && + !ee_invalidpunct(ee->code[ee->head + 1])) + op = 1; + else if (ee->code[ee->head] == '>' && + !ee_invalidpunct(ee->code[ee->head + 1])) + op = 2; + else if (ee->code[ee->head] == '<' && + ee->code[ee->head + 1] == '=') + op = 3; + + ee->head += op > 2 ? 2 : 1; + + switch (op) { + case 1: + ee_shift(ee); + if (ee->error) + return; + + ee->ival = (oival < ee->ival) ? 1 : 0; + break; + case 2: + ee_shift(ee); + if (ee->error) + return; + + ee->ival = (oival > ee->ival) ? 1 : 0; + break; + case 3: + ee_shift(ee); + if (ee->error) + return; + + ee->ival = (oival <= ee->ival) ? 1 : 0; + break; + case 4: + ee_shift(ee); + if (ee->error) + return; + + ee->ival = (oival >= ee->ival) ? 1 : 0; + break; + } + + ee_skip_spaces(ee); + } +} + +static void ee_equals(struct expreval *ee) +{ + ee_compare(ee); + ee_skip_spaces(ee); + + while (ee->head < ee->len && !ee->error && + ((ee->code[ee->head] == '=' && ee->code[ee->head + 1] == '=') || + (ee->code[ee->head] == '!' && ee->code[ee->head + 1] == '='))) { + ssize_t oival = ee->ival; + int op = ee->code[ee->head] == '=' ? 1 : 2; + + ee->head += 2; + + switch (op) { + case 1: + ee_compare(ee); + if (ee->error) + return; + + ee->ival = (oival == ee->ival) ? 1 : 0; + break; + case 2: + ee_compare(ee); + if (ee->error) + return; + + ee->ival = (oival != ee->ival) ? 1 : 0; + break; + } + + ee_skip_spaces(ee); + } +} + +static void ee_bitand(struct expreval *ee) +{ + ee_equals(ee); + ee_skip_spaces(ee); + + while (ee->head < ee->len && !ee->error && + (ee->code[ee->head] == '&' && + !ee_invalidpunct(ee->code[ee->head + 1]))) { + ssize_t oival = ee->ival; + ee->head++; + + ee_equals(ee); + if (ee->error) + return; + + ee->ival = oival & ee->ival; + + ee_skip_spaces(ee); + } +} + +static void ee_bitor(struct expreval *ee) +{ + ee_bitand(ee); + ee_skip_spaces(ee); + + while (ee->head < ee->len && !ee->error && + (ee->code[ee->head] == '|' && + !ee_invalidpunct(ee->code[ee->head + 1]))) { + ssize_t oival = ee->ival; + + ee->head++; + + ee_bitand(ee); + if (ee->error) + return; + + ee->ival = oival | ee->ival; + + ee_skip_spaces(ee); + } +} + +static void ee_logand(struct expreval *ee) +{ + ee_bitor(ee); + ee_skip_spaces(ee); + + while (ee->head < ee->len && !ee->error && + (ee->code[ee->head] == '&' && ee->code[ee->head + 1] == '&')) { + ssize_t oival = ee->ival; + + ee->head += 2; + + ee_bitor(ee); + if (ee->error) + return; + + ee->ival = (oival && ee->ival) ? 1 : 0; + + ee_skip_spaces(ee); + } +} + +static void ee_logor(struct expreval *ee) +{ + ee_logand(ee); + ee_skip_spaces(ee); + + while (ee->head < ee->len && !ee->error && + (ee->code[ee->head] == '|' && ee->code[ee->head + 1] == '|')) { + ssize_t oival = ee->ival; + + ee->head += 2; + + ee_logand(ee); + if (ee->error) + return; + + ee->ival = (oival || ee->ival) ? 1 : 0; + + ee_skip_spaces(ee); + } +} + +static void ee_expr(struct expreval *ee) +{ + ee_logor(ee); + if (ee->error == EERR_INVALID_EXPRESSION) { + /* + * invalid expression doesn't really matter, it is only used to + * stop the expression parsing. + */ + ee->error = EERR_NO_ERROR; + ee->ival = 1; + } +} + +struct lil_value *lil_eval_expr(struct lil *lil, struct lil_value *code) +{ + struct expreval ee; + + code = lil_subst_to_value(lil, code); + if (lil->error) + return NULL; + + ee.code = lil_to_string(code); + if (!ee.code[0]) { + /* + * an empty expression equals to 0 so that it can be used as a + * false value in conditionals + */ + lil_free_value(code); + return lil_alloc_integer(0); + } + + ee.head = 0; + ee.len = code->l; + ee.ival = 0; + ee.error = 0; + + ee_expr(&ee); + lil_free_value(code); + if (ee.error) { + switch (ee.error) { + case EERR_DIVISION_BY_ZERO: + lil_set_error(lil, "division by zero in expression"); + break; + case EERR_SYNTAX_ERROR: + lil_set_error(lil, "expression syntax error"); + break; + } + return NULL; + } + return lil_alloc_integer(ee.ival); +} + +struct lil_value *lil_unused_name(struct lil *lil, const char *part) +{ + char *name = malloc(strlen(part) + 64); + struct lil_value *val; + size_t i; + + for (i = 0; i < (size_t)-1; i++) { + sprintf(name, "!!un!%s!%09u!nu!!", part, (unsigned int)i); + if (lil_find_cmd(lil, name)) + continue; + + if (lil_find_var(lil, lil->env, name)) + continue; + + val = lil_alloc_string(name); + free(name); + return val; + } + return NULL; +} + +struct lil_value *lil_arg(struct lil_value **argv, size_t index) +{ + return argv ? argv[index] : NULL; +} + +const char *lil_to_string(struct lil_value *val) +{ + return (val && val->l) ? val->d : ""; +} + +ssize_t lil_to_integer(struct lil_value *val) +{ + return simple_strtol(lil_to_string(val), NULL, 0); +} + +int lil_to_boolean(struct lil_value *val) +{ + const char *s = lil_to_string(val); + size_t i, dots = 0; + + if (!s[0]) + return 0; + + for (i = 0; s[i]; i++) { + if (s[i] != '0' && s[i] != '.') + return 1; + + if (s[i] == '.') { + if (dots) + return 1; + + dots = 1; + } + } + + return 0; +} + +struct lil_value *lil_alloc_string(const char *str) +{ + return alloc_value(str); +} + +struct lil_value *lil_alloc_string_len(const char *str, size_t len) +{ + return alloc_value_len(str, len); +} + +struct lil_value *lil_alloc_integer(ssize_t num) +{ + char buff[128]; + + sprintf(buff, "%zd", num); + return alloc_value(buff); +} + +void lil_free(struct lil *lil) +{ + size_t i; + + if (!lil) + return; + + free(lil->err_msg); + lil_free_value(lil->empty); + while (lil->env) { + struct lil_env *next = lil->env->parent; + + lil_free_env(lil->env); + lil->env = next; + } + + for (i = 0; i < lil->cmds; i++) { + if (lil->cmd[i]->argnames) + lil_free_list(lil->cmd[i]->argnames); + + lil_free_value(lil->cmd[i]->code); + free(lil->cmd[i]->name); + free(lil->cmd[i]); + } + + hm_destroy(&lil->cmdmap); + free(lil->cmd); + free(lil); +} + +static struct lil_value *fnc_reflect(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_func *func; + const char *type; + size_t i; + struct lil_value *r; + + if (!argc) + return NULL; + + type = lil_to_string(argv[0]); + if (!strcmp(type, "version")) + return lil_alloc_string(LIL_VERSION_STRING); + + if (!strcmp(type, "args")) { + if (argc < 2) + return NULL; + func = lil_find_cmd(lil, lil_to_string(argv[1])); + if (!func || !func->argnames) + return NULL; + return lil_list_to_value(func->argnames, 1); + } + + if (!strcmp(type, "body")) { + if (argc < 2) + return NULL; + + func = lil_find_cmd(lil, lil_to_string(argv[1])); + if (!func || func->proc) + return NULL; + + return lil_clone_value(func->code); + } + + if (!strcmp(type, "func-count")) + return lil_alloc_integer(lil->cmds); + + if (!strcmp(type, "funcs")) { + struct lil_list *funcs = lil_alloc_list(); + + for (i = 0; i < lil->cmds; i++) + lil_list_append(funcs, + lil_alloc_string(lil->cmd[i]->name)); + + r = lil_list_to_value(funcs, 1); + lil_free_list(funcs); + return r; + } + + if (!strcmp(type, "vars")) { + struct lil_list *vars = lil_alloc_list(); + struct lil_env *env = lil->env; + + while (env) { + for (i = 0; i < env->vars; i++) { + struct lil_value *var = + lil_alloc_string(env->var[i]->n); + + lil_list_append(vars, var); + } + env = env->parent; + } + + r = lil_list_to_value(vars, 1); + lil_free_list(vars); + return r; + } + + if (!strcmp(type, "globals")) { + struct lil_list *vars = lil_alloc_list(); + + for (i = 0; i < lil->rootenv->vars; i++) { + struct lil_value *var = + lil_alloc_string(lil->rootenv->var[i]->n); + + lil_list_append(vars, var); + } + + r = lil_list_to_value(vars, 1); + lil_free_list(vars); + return r; + } + + if (!strcmp(type, "has-func")) { + const char *target; + + if (argc == 1) + return NULL; + + target = lil_to_string(argv[1]); + return hm_has(&lil->cmdmap, target) ? lil_alloc_string("1") : + NULL; + } + + if (!strcmp(type, "has-var")) { + const char *target; + struct lil_env *env = lil->env; + + if (argc == 1) + return NULL; + + target = lil_to_string(argv[1]); + while (env) { + if (hm_has(&env->varmap, target)) + return lil_alloc_string("1"); + env = env->parent; + } + return NULL; + } + + if (!strcmp(type, "has-global")) { + const char *target; + + if (argc == 1) + return NULL; + + target = lil_to_string(argv[1]); + for (i = 0; i < lil->rootenv->vars; i++) + if (!strcmp(target, lil->rootenv->var[i]->n)) + return lil_alloc_string("1"); + return NULL; + } + + if (!strcmp(type, "error")) + return lil->err_msg ? lil_alloc_string(lil->err_msg) : NULL; + + if (!strcmp(type, "this")) { + struct lil_env *env = lil->env; + + while (env != lil->rootenv && !env->func) + env = env->parent; + + if (env == lil->rootenv) + return lil_alloc_string(lil->rootcode); + + return env->func ? env->func->code : NULL; + } + + if (!strcmp(type, "name")) { + struct lil_env *env = lil->env; + + while (env != lil->rootenv && !env->func) + env = env->parent; + + if (env == lil->rootenv) + return NULL; + + return env->func ? lil_alloc_string(env->func->name) : NULL; + } + + return NULL; +} + +static struct lil_value *fnc_func(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_value *name; + struct lil_func *cmd; + struct lil_list *fargs; + + if (argc < 1) + return NULL; + + if (argc >= 3) { + name = lil_clone_value(argv[0]); + fargs = lil_subst_to_list(lil, argv[1]); + cmd = add_func(lil, lil_to_string(argv[0])); + cmd->argnames = fargs; + cmd->code = lil_clone_value(argv[2]); + } else { + name = lil_unused_name(lil, "anonymous-function"); + if (argc < 2) { + struct lil_value *tmp = lil_alloc_string("args"); + + fargs = lil_subst_to_list(lil, tmp); + lil_free_value(tmp); + cmd = add_func(lil, lil_to_string(name)); + cmd->argnames = fargs; + cmd->code = lil_clone_value(argv[0]); + } else { + fargs = lil_subst_to_list(lil, argv[0]); + cmd = add_func(lil, lil_to_string(name)); + cmd->argnames = fargs; + cmd->code = lil_clone_value(argv[1]); + } + } + + return name; +} + +static struct lil_value *fnc_rename(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_value *r; + struct lil_func *func; + const char *oldname; + const char *newname; + + if (argc < 2) + return NULL; + + oldname = lil_to_string(argv[0]); + newname = lil_to_string(argv[1]); + func = lil_find_cmd(lil, oldname); + if (!func) { + char *msg = malloc(24 + strlen(oldname)); + + sprintf(msg, "unknown function '%s'", oldname); + lil_set_error_at(lil, lil->head, msg); + free(msg); + return NULL; + } + + r = lil_alloc_string(func->name); + if (newname[0]) { + hm_put(&lil->cmdmap, oldname, 0); + hm_put(&lil->cmdmap, newname, func); + free(func->name); + func->name = strclone(newname); + } else { + del_func(lil, func); + } + + return r; +} + +static struct lil_value *fnc_unusedname(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + return lil_unused_name(lil, argc > 0 ? lil_to_string(argv[0]) : + "unusedname"); +} + +static struct lil_value *fnc_quote(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_value *r; + size_t i; + + if (argc < 1) + return NULL; + + r = alloc_value(NULL); + for (i = 0; i < argc; i++) { + if (i) + lil_append_char(r, ' '); + lil_append_val(r, argv[i]); + } + + return r; +} + +static struct lil_value *fnc_set(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + size_t i = 0; + struct lil_var *var = NULL; + int access = LIL_SETVAR_LOCAL; + + if (!argc) + return NULL; + + if (!strcmp(lil_to_string(argv[0]), "global")) { + i = 1; + access = LIL_SETVAR_GLOBAL; + } + + while (i < argc) { + if (argc == i + 1) { + struct lil_value *val = + lil_get_var(lil, lil_to_string(argv[i])); + + return lil_clone_value(val); + } + + var = lil_set_var(lil, lil_to_string(argv[i]), argv[i + 1], + access); + i += 2; + } + + return var ? lil_clone_value(var->v) : NULL; +} + +static struct lil_value *fnc_local(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + size_t i; + + for (i = 0; i < argc; i++) { + const char *varname = lil_to_string(argv[i]); + + if (!lil_find_local_var(lil, lil->env, varname)) + lil_set_var(lil, varname, lil->empty, + LIL_SETVAR_LOCAL_NEW); + } + + return NULL; +} + +static struct lil_value *fnc_eval(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + if (argc == 1) + return lil_parse_value(lil, argv[0], 0); + + if (argc > 1) { + struct lil_value *val = alloc_value(NULL), *r; + size_t i; + + for (i = 0; i < argc; i++) { + if (i) + lil_append_char(val, ' '); + lil_append_val(val, argv[i]); + } + + r = lil_parse_value(lil, val, 0); + lil_free_value(val); + return r; + } + + return NULL; +} + +static struct lil_value *fnc_topeval(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_env *thisenv = lil->env; + struct lil_env *thisdownenv = lil->downenv; + struct lil_value *r; + + lil->env = lil->rootenv; + lil->downenv = thisenv; + + r = fnc_eval(lil, argc, argv); + lil->downenv = thisdownenv; + lil->env = thisenv; + return r; +} + +static struct lil_value *fnc_upeval(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_env *thisenv = lil->env; + struct lil_env *thisdownenv = lil->downenv; + struct lil_value *r; + + if (lil->rootenv == thisenv) + return fnc_eval(lil, argc, argv); + + lil->env = thisenv->parent; + lil->downenv = thisenv; + + r = fnc_eval(lil, argc, argv); + lil->env = thisenv; + lil->downenv = thisdownenv; + return r; +} + +static struct lil_value *fnc_downeval(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_value *r; + struct lil_env *upenv = lil->env; + struct lil_env *downenv = lil->downenv; + + if (!downenv) + return fnc_eval(lil, argc, argv); + + lil->downenv = NULL; + lil->env = downenv; + + r = fnc_eval(lil, argc, argv); + lil->downenv = downenv; + lil->env = upenv; + return r; +} + +static struct lil_value *fnc_count(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_list *list; + char buff[64]; + + if (!argc) + return alloc_value("0"); + + list = lil_subst_to_list(lil, argv[0]); + sprintf(buff, "%u", (unsigned int)list->c); + lil_free_list(list); + return alloc_value(buff); +} + +static struct lil_value *fnc_index(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_list *list; + size_t index; + struct lil_value *r; + + if (argc < 2) + return NULL; + + list = lil_subst_to_list(lil, argv[0]); + index = (size_t)lil_to_integer(argv[1]); + if (index >= list->c) + r = NULL; + else + r = lil_clone_value(list->v[index]); + lil_free_list(list); + return r; +} + +static struct lil_value *fnc_indexof(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_list *list; + size_t index; + struct lil_value *r = NULL; + + if (argc < 2) + return NULL; + + list = lil_subst_to_list(lil, argv[0]); + for (index = 0; index < list->c; index++) { + if (!strcmp(lil_to_string(list->v[index]), + lil_to_string(argv[1]))) { + r = lil_alloc_integer(index); + break; + } + } + + lil_free_list(list); + return r; +} + +static struct lil_value *fnc_append(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_list *list; + struct lil_value *r; + size_t i, base = 1; + int access = LIL_SETVAR_LOCAL; + const char *varname; + + if (argc < 2) + return NULL; + + varname = lil_to_string(argv[0]); + if (!strcmp(varname, "global")) { + if (argc < 3) + return NULL; + + varname = lil_to_string(argv[1]); + base = 2; + access = LIL_SETVAR_GLOBAL; + } + + list = lil_subst_to_list(lil, lil_get_var(lil, varname)); + for (i = base; i < argc; i++) + lil_list_append(list, lil_clone_value(argv[i])); + + r = lil_list_to_value(list, 1); + lil_free_list(list); + lil_set_var(lil, varname, r, access); + return r; +} + +static struct lil_value *fnc_slice(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_list *list, *slice; + size_t i; + ssize_t from, to; + struct lil_value *r; + + if (argc < 1) + return NULL; + if (argc < 2) + return lil_clone_value(argv[0]); + + from = lil_to_integer(argv[1]); + if (from < 0) + from = 0; + + list = lil_subst_to_list(lil, argv[0]); + to = argc > 2 ? lil_to_integer(argv[2]) : (ssize_t)list->c; + if (to > (ssize_t)list->c) + to = list->c; + else if (to < from) + to = from; + + slice = lil_alloc_list(); + for (i = (size_t)from; i < (size_t)to; i++) + lil_list_append(slice, lil_clone_value(list->v[i])); + lil_free_list(list); + + r = lil_list_to_value(slice, 1); + lil_free_list(slice); + return r; +} + +static struct lil_value *fnc_filter(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_list *list, *filtered; + size_t i; + struct lil_value *r; + const char *varname = "x"; + int base = 0; + + if (argc < 1) + return NULL; + + if (argc < 2) + return lil_clone_value(argv[0]); + + if (argc > 2) { + base = 1; + varname = lil_to_string(argv[0]); + } + + list = lil_subst_to_list(lil, argv[base]); + filtered = lil_alloc_list(); + for (i = 0; i < list->c && !lil->env->breakrun; i++) { + lil_set_var(lil, varname, list->v[i], LIL_SETVAR_LOCAL_ONLY); + r = lil_eval_expr(lil, argv[base + 1]); + if (lil_to_boolean(r)) + lil_list_append(filtered, lil_clone_value(list->v[i])); + lil_free_value(r); + } + lil_free_list(list); + + r = lil_list_to_value(filtered, 1); + lil_free_list(filtered); + return r; +} + +static struct lil_value *fnc_list(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_list *list = lil_alloc_list(); + struct lil_value *r; + size_t i; + + for (i = 0; i < argc; i++) + lil_list_append(list, lil_clone_value(argv[i])); + + r = lil_list_to_value(list, 1); + lil_free_list(list); + return r; +} + +static struct lil_value *fnc_subst(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + if (argc < 1) + return NULL; + + return lil_subst_to_value(lil, argv[0]); +} + +static struct lil_value *fnc_concat(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_list *list; + struct lil_value *r, *tmp; + size_t i; + + if (argc < 1) + return NULL; + + r = lil_alloc_string(""); + for (i = 0; i < argc; i++) { + list = lil_subst_to_list(lil, argv[i]); + tmp = lil_list_to_value(list, 1); + lil_free_list(list); + lil_append_val(r, tmp); + lil_free_value(tmp); + } + return r; +} + +static struct lil_value *fnc_foreach(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_list *list, *rlist; + struct lil_value *r; + size_t i, listidx = 0, codeidx = 1; + const char *varname = "i"; + + if (argc < 2) + return NULL; + + if (argc >= 3) { + varname = lil_to_string(argv[0]); + listidx = 1; + codeidx = 2; + } + + rlist = lil_alloc_list(); + list = lil_subst_to_list(lil, argv[listidx]); + for (i = 0; i < list->c; i++) { + struct lil_value *rv; + + lil_set_var(lil, varname, list->v[i], LIL_SETVAR_LOCAL_ONLY); + rv = lil_parse_value(lil, argv[codeidx], 0); + if (rv->l) + lil_list_append(rlist, rv); + else + lil_free_value(rv); + + if (lil->env->breakrun || lil->error) + break; + } + + r = lil_list_to_value(rlist, 1); + lil_free_list(list); + lil_free_list(rlist); + return r; +} + +static struct lil_value *fnc_return(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + lil->env->breakrun = 1; + lil_free_value(lil->env->retval); + lil->env->retval = argc < 1 ? NULL : lil_clone_value(argv[0]); + lil->env->retval_set = 1; + return argc < 1 ? NULL : lil_clone_value(argv[0]); +} + +static struct lil_value *fnc_result(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + if (argc > 0) { + lil_free_value(lil->env->retval); + lil->env->retval = lil_clone_value(argv[0]); + lil->env->retval_set = 1; + } + + return lil->env->retval_set ? lil_clone_value(lil->env->retval) : NULL; +} + +static struct lil_value *fnc_expr(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + if (argc == 1) + return lil_eval_expr(lil, argv[0]); + + if (argc > 1) { + struct lil_value *val = alloc_value(NULL), *r; + size_t i; + + for (i = 0; i < argc; i++) { + if (i) + lil_append_char(val, ' '); + lil_append_val(val, argv[i]); + } + + r = lil_eval_expr(lil, val); + lil_free_value(val); + return r; + } + + return NULL; +} + +static struct lil_value *real_inc(struct lil *lil, const char *varname, + ssize_t v) +{ + struct lil_value *pv = lil_get_var(lil, varname); + + pv = lil_alloc_integer(lil_to_integer(pv) + v); + lil_set_var(lil, varname, pv, LIL_SETVAR_LOCAL); + return pv; +} + +static struct lil_value *fnc_inc(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + if (argc < 1) + return NULL; + + return real_inc(lil, lil_to_string(argv[0]), + argc > 1 ? lil_to_integer(argv[1]) : 1); +} + +static struct lil_value *fnc_dec(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + if (argc < 1) + return NULL; + + return real_inc(lil, lil_to_string(argv[0]), + -(argc > 1 ? lil_to_integer(argv[1]) : 1)); +} + +static struct lil_value *fnc_if(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_value *val, *r = NULL; + int base = 0, not = 0, v; + + if (argc < 1) + return NULL; + + if (!strcmp(lil_to_string(argv[0]), "not")) + base = not = 1; + + if (argc < (size_t)base + 2) + return NULL; + + val = lil_eval_expr(lil, argv[base]); + if (!val || lil->error) + return NULL; + + v = lil_to_boolean(val); + if (not) + v = !v; + + if (v) + r = lil_parse_value(lil, argv[base + 1], 0); + else if (argc > (size_t)base + 2) + r = lil_parse_value(lil, argv[base + 2], 0); + + lil_free_value(val); + return r; +} + +static struct lil_value *fnc_while(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_value *val, *r = NULL; + int base = 0, not = 0, v; + + if (argc < 1) + return NULL; + + if (!strcmp(lil_to_string(argv[0]), "not")) + base = not = 1; + + if (argc < (size_t)base + 2) + return NULL; + + while (!lil->error && !lil->env->breakrun) { + val = lil_eval_expr(lil, argv[base]); + if (!val || lil->error) + return NULL; + + v = lil_to_boolean(val); + if (not) + v = !v; + + if (!v) { + lil_free_value(val); + break; + } + + if (r) + lil_free_value(r); + r = lil_parse_value(lil, argv[base + 1], 0); + lil_free_value(val); + } + + return r; +} + +static struct lil_value *fnc_for(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_value *val, *r = NULL; + + if (argc < 4) + return NULL; + + lil_free_value(lil_parse_value(lil, argv[0], 0)); + while (!lil->error && !lil->env->breakrun) { + val = lil_eval_expr(lil, argv[1]); + if (!val || lil->error) + return NULL; + + if (!lil_to_boolean(val)) { + lil_free_value(val); + break; + } + + if (r) + lil_free_value(r); + r = lil_parse_value(lil, argv[3], 0); + lil_free_value(val); + lil_free_value(lil_parse_value(lil, argv[2], 0)); + } + + return r; +} + +static struct lil_value *fnc_char(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + char s[2]; + + if (!argc) + return NULL; + + s[0] = (char)lil_to_integer(argv[0]); + s[1] = 0; + return lil_alloc_string(s); +} + +static struct lil_value *fnc_charat(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + size_t index; + char chstr[2]; + const char *str; + + if (argc < 2) + return NULL; + + str = lil_to_string(argv[0]); + index = (size_t)lil_to_integer(argv[1]); + if (index >= strlen(str)) + return NULL; + + chstr[0] = str[index]; + chstr[1] = 0; + return lil_alloc_string(chstr); +} + +static struct lil_value *fnc_codeat(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + size_t index; + const char *str; + + if (argc < 2) + return NULL; + + str = lil_to_string(argv[0]); + index = (size_t)lil_to_integer(argv[1]); + if (index >= strlen(str)) + return NULL; + + return lil_alloc_integer(str[index]); +} + +static struct lil_value *fnc_substr(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + const char *str; + struct lil_value *r; + size_t start, end, i, slen; + + if (argc < 2) + return NULL; + + str = lil_to_string(argv[0]); + if (!str[0]) + return NULL; + + slen = strlen(str); + start = simple_strtol(lil_to_string(argv[1]), NULL, 0); + end = argc > 2 ? simple_strtol(lil_to_string(argv[2]), NULL, 0) : slen; + if (end > slen) + end = slen; + + if (start >= end) + return NULL; + + r = lil_alloc_string(""); + for (i = start; i < end; i++) + lil_append_char(r, str[i]); + return r; +} + +static struct lil_value *fnc_strpos(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + const char *hay; + const char *str; + size_t min = 0; + + if (argc < 2) + return lil_alloc_integer(-1); + + hay = lil_to_string(argv[0]); + if (argc > 2) { + min = simple_strtol(lil_to_string(argv[2]), NULL, 0); + if (min >= strlen(hay)) + return lil_alloc_integer(-1); + } + + str = strstr(hay + min, lil_to_string(argv[1])); + if (!str) + return lil_alloc_integer(-1); + + return lil_alloc_integer(str - hay); +} + +static struct lil_value *fnc_length(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + size_t i, total = 0; + + for (i = 0; i < argc; i++) { + if (i) + total++; + total += strlen(lil_to_string(argv[i])); + } + + return lil_alloc_integer((ssize_t)total); +} + +static struct lil_value *real_trim(const char *str, const char *chars, int left, + int right) +{ + int base = 0; + struct lil_value *r = NULL; + + if (left) { + while (str[base] && strchr(chars, str[base])) + base++; + if (!right) + r = lil_alloc_string(str[base] ? str + base : NULL); + } + + if (right) { + size_t len; + char *s; + + s = strclone(str + base); + len = strlen(s); + while (len && strchr(chars, s[len - 1])) + len--; + + s[len] = 0; + r = lil_alloc_string(s); + free(s); + } + + return r; +} + +static struct lil_value *fnc_trim(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + const char *chars; + + if (!argc) + return NULL; + + if (argc < 2) + chars = " \f\n\r\t\v"; + else + chars = lil_to_string(argv[1]); + + return real_trim(lil_to_string(argv[0]), chars, 1, 1); +} + +static struct lil_value *fnc_ltrim(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + const char *chars; + + if (!argc) + return NULL; + + if (argc < 2) + chars = " \f\n\r\t\v"; + else + chars = lil_to_string(argv[1]); + + return real_trim(lil_to_string(argv[0]), chars, 1, 0); +} + +static struct lil_value *fnc_rtrim(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + const char *chars; + + if (!argc) + return NULL; + + if (argc < 2) + chars = " \f\n\r\t\v"; + else + chars = lil_to_string(argv[1]); + + return real_trim(lil_to_string(argv[0]), chars, 0, 1); +} + +static struct lil_value *fnc_strcmp(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + if (argc < 2) + return NULL; + + return lil_alloc_integer(strcmp(lil_to_string(argv[0]), + lil_to_string(argv[1]))); +} + +static struct lil_value *fnc_streq(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + if (argc < 2) + return NULL; + + return lil_alloc_integer(strcmp(lil_to_string(argv[0]), + lil_to_string(argv[1])) ? 0 : 1); +} + +static struct lil_value *fnc_repstr(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + const char *from; + const char *to; + char *src; + const char *sub; + size_t idx; + size_t fromlen; + size_t tolen; + size_t srclen; + struct lil_value *r; + + if (argc < 1) + return NULL; + + if (argc < 3) + return lil_clone_value(argv[0]); + + from = lil_to_string(argv[1]); + to = lil_to_string(argv[2]); + if (!from[0]) + return NULL; + + src = strclone(lil_to_string(argv[0])); + srclen = strlen(src); + fromlen = strlen(from); + tolen = strlen(to); + while ((sub = strstr(src, from))) { + char *newsrc = malloc(srclen - fromlen + tolen + 1); + + idx = sub - src; + if (idx) + memcpy(newsrc, src, idx); + + memcpy(newsrc + idx, to, tolen); + memcpy(newsrc + idx + tolen, src + idx + fromlen, + srclen - idx - fromlen); + srclen = srclen - fromlen + tolen; + free(src); + src = newsrc; + src[srclen] = 0; + } + + r = lil_alloc_string(src); + free(src); + return r; +} + +static struct lil_value *fnc_split(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_list *list; + const char *sep = " "; + size_t i; + struct lil_value *val; + const char *str; + + if (argc == 0) + return NULL; + if (argc > 1) { + sep = lil_to_string(argv[1]); + if (!sep || !sep[0]) + return lil_clone_value(argv[0]); + } + + val = lil_alloc_string(""); + str = lil_to_string(argv[0]); + list = lil_alloc_list(); + for (i = 0; str[i]; i++) { + if (strchr(sep, str[i])) { + lil_list_append(list, val); + val = lil_alloc_string(""); + } else { + lil_append_char(val, str[i]); + } + } + + lil_list_append(list, val); + val = lil_list_to_value(list, 1); + lil_free_list(list); + return val; +} + +static struct lil_value *fnc_try(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_value *r; + + if (argc < 1) + return NULL; + + if (lil->error) + return NULL; + + r = lil_parse_value(lil, argv[0], 0); + if (lil->error) { + lil->error = ERROR_NOERROR; + lil_free_value(r); + + if (argc > 1) + r = lil_parse_value(lil, argv[1], 0); + else + r = 0; + } + return r; +} + +static struct lil_value *fnc_error(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + lil_set_error(lil, argc > 0 ? lil_to_string(argv[0]) : NULL); + return NULL; +} + +static struct lil_value *fnc_lmap(struct lil *lil, size_t argc, + struct lil_value **argv) +{ + struct lil_list *list; + size_t i; + + if (argc < 2) + return NULL; + + list = lil_subst_to_list(lil, argv[0]); + for (i = 1; i < argc; i++) + lil_set_var(lil, lil_to_string(argv[i]), + lil_list_get(list, i - 1), LIL_SETVAR_LOCAL); + lil_free_list(list); + return NULL; +} + +static void register_stdcmds(struct lil *lil) +{ + lil_register(lil, "append", fnc_append); + lil_register(lil, "char", fnc_char); + lil_register(lil, "charat", fnc_charat); + lil_register(lil, "codeat", fnc_codeat); + lil_register(lil, "concat", fnc_concat); + lil_register(lil, "count", fnc_count); + lil_register(lil, "dec", fnc_dec); + lil_register(lil, "downeval", fnc_downeval); + lil_register(lil, "error", fnc_error); + lil_register(lil, "eval", fnc_eval); + lil_register(lil, "expr", fnc_expr); + lil_register(lil, "filter", fnc_filter); + lil_register(lil, "for", fnc_for); + lil_register(lil, "foreach", fnc_foreach); + lil_register(lil, "func", fnc_func); + lil_register(lil, "if", fnc_if); + lil_register(lil, "inc", fnc_inc); + lil_register(lil, "index", fnc_index); + lil_register(lil, "indexof", fnc_indexof); + lil_register(lil, "length", fnc_length); + lil_register(lil, "list", fnc_list); + lil_register(lil, "lmap", fnc_lmap); + lil_register(lil, "local", fnc_local); + lil_register(lil, "ltrim", fnc_ltrim); + lil_register(lil, "quote", fnc_quote); + lil_register(lil, "reflect", fnc_reflect); + lil_register(lil, "rename", fnc_rename); + lil_register(lil, "repstr", fnc_repstr); + lil_register(lil, "result", fnc_result); + lil_register(lil, "return", fnc_return); + lil_register(lil, "rtrim", fnc_rtrim); + lil_register(lil, "set", fnc_set); + lil_register(lil, "slice", fnc_slice); + lil_register(lil, "split", fnc_split); + lil_register(lil, "strcmp", fnc_strcmp); + lil_register(lil, "streq", fnc_streq); + lil_register(lil, "strpos", fnc_strpos); + lil_register(lil, "subst", fnc_subst); + lil_register(lil, "substr", fnc_substr); + lil_register(lil, "topeval", fnc_topeval); + lil_register(lil, "trim", fnc_trim); + lil_register(lil, "try", fnc_try); + lil_register(lil, "unusedname", fnc_unusedname); + lil_register(lil, "upeval", fnc_upeval); + lil_register(lil, "while", fnc_while); +} diff --git a/include/cli_lil.h b/include/cli_lil.h new file mode 100644 index 0000000000..c72977ea5c --- /dev/null +++ b/include/cli_lil.h @@ -0,0 +1,111 @@ +/* SPDX-License-Identifier: GPL-2.0+ AND Zlib */ +/* + * LIL - Little Interpreted Language + * Copyright (C) 2021 Sean Anderson seanga2@gmail.com + * Copyright (C) 2010-2013 Kostas Michalopoulos badsector@runtimelegend.com + * + * This file originated from the LIL project, licensed under Zlib. All + * modifications are licensed under GPL-2.0+ + */ + +#ifndef __LIL_H_INCLUDED__ +#define __LIL_H_INCLUDED__ + +#define LIL_VERSION_STRING "0.1" + +#define LIL_SETVAR_GLOBAL 0 +#define LIL_SETVAR_LOCAL 1 +#define LIL_SETVAR_LOCAL_NEW 2 +#define LIL_SETVAR_LOCAL_ONLY 3 + +#define LIL_CALLBACK_EXIT 0 +#define LIL_CALLBACK_WRITE 1 +#define LIL_CALLBACK_READ 2 +#define LIL_CALLBACK_STORE 3 +#define LIL_CALLBACK_SOURCE 4 +#define LIL_CALLBACK_ERROR 5 +#define LIL_CALLBACK_SETVAR 6 +#define LIL_CALLBACK_GETVAR 7 + +#include <stdint.h> +#include <inttypes.h> + +struct lil_value; +struct lil_func; +struct lil_var; +struct lil_env; +struct lil_list; +struct lil; +typedef struct lil_value *(*lil_func_proc_t)(struct lil *lil, size_t argc, + struct lil_value **argv); +typedef void (*lil_exit_callback_proc_t)(struct lil *lil, + struct lil_value *arg); +typedef void (*lil_write_callback_proc_t)(struct lil *lil, const char *msg); +typedef char *(*lil_read_callback_proc_t)(struct lil *lil, const char *name); +typedef char *(*lil_source_callback_proc_t)(struct lil *lil, const char *name); +typedef void (*lil_store_callback_proc_t)(struct lil *lil, const char *name, + const char *data); +typedef void (*lil_error_callback_proc_t)(struct lil *lil, size_t pos, + const char *msg); +typedef int (*lil_setvar_callback_proc_t)(struct lil *lil, const char *name, + struct lil_value **value); +typedef int (*lil_getvar_callback_proc_t)(struct lil *lil, const char *name, + struct lil_value **value); +typedef void (*lil_callback_proc_t)(void); + +struct lil *lil_new(void); +void lil_free(struct lil *lil); + +int lil_register(struct lil *lil, const char *name, lil_func_proc_t proc); + +struct lil_value *lil_parse(struct lil *lil, const char *code, size_t codelen, + int funclevel); +struct lil_value *lil_parse_value(struct lil *lil, struct lil_value *val, + int funclevel); + +void lil_callback(struct lil *lil, int cb, lil_callback_proc_t proc); + +void lil_set_error(struct lil *lil, const char *msg); +void lil_set_error_at(struct lil *lil, size_t pos, const char *msg); +int lil_error(struct lil *lil, const char **msg, size_t *pos); + +const char *lil_to_string(struct lil_value *val); +ssize_t lil_to_integer(struct lil_value *val); +int lil_to_boolean(struct lil_value *val); + +struct lil_value *lil_alloc_string(const char *str); +struct lil_value *lil_alloc_integer(ssize_t num); +void lil_free_value(struct lil_value *val); + +struct lil_value *lil_clone_value(struct lil_value *src); +int lil_append_char(struct lil_value *val, char ch); +int lil_append_string(struct lil_value *val, const char *s); +int lil_append_val(struct lil_value *val, struct lil_value *v); + +struct lil_list *lil_alloc_list(void); +void lil_free_list(struct lil_list *list); +void lil_list_append(struct lil_list *list, struct lil_value *val); +size_t lil_list_size(struct lil_list *list); +struct lil_value *lil_list_get(struct lil_list *list, size_t index); +struct lil_value *lil_list_to_value(struct lil_list *list, int do_escape); + +struct lil_list *lil_subst_to_list(struct lil *lil, struct lil_value *code); +struct lil_value *lil_subst_to_value(struct lil *lil, struct lil_value *code); + +struct lil_env *lil_alloc_env(struct lil_env *parent); +void lil_free_env(struct lil_env *env); +struct lil_env *lil_push_env(struct lil *lil); +void lil_pop_env(struct lil *lil); + +struct lil_var *lil_set_var(struct lil *lil, const char *name, + struct lil_value *val, int local); +struct lil_value *lil_get_var(struct lil *lil, const char *name); +struct lil_value *lil_get_var_or(struct lil *lil, const char *name, + struct lil_value *defvalue); + +struct lil_value *lil_eval_expr(struct lil *lil, struct lil_value *code); +struct lil_value *lil_unused_name(struct lil *lil, const char *part); + +struct lil_value *lil_arg(struct lil_value **argv, size_t index); + +#endif

This helps reduce the size impact of LIL to approximately that of hush. The builtin functions have been chosen to roughly match the functionality present in hush. In addition, arithmetic is removed from expr to reduce size further.

Signed-off-by: Sean Anderson seanga2@gmail.com ---

cmd/Kconfig | 10 ++++++ common/cli_lil.c | 83 +++++++++++++++++++++++++++--------------------- 2 files changed, 57 insertions(+), 36 deletions(-)

diff --git a/cmd/Kconfig b/cmd/Kconfig index 8bccc572af..0a7b73cb6d 100644 --- a/cmd/Kconfig +++ b/cmd/Kconfig @@ -32,6 +32,16 @@ config LIL like `proc name {args} {body}' functions or `echo [some command]` command substitution ("tcl scripts").

+if LIL + +config LIL_FULL + bool "Enable all LIL features" + help + This enables all LIL builtin functions, as well as expression support + for arithmetic and bitwise operations. + +endif + config CMDLINE_EDITING bool "Enable command line editing" depends on CMDLINE diff --git a/common/cli_lil.c b/common/cli_lil.c index 294d79e86e..a2e5cdf35a 100644 --- a/common/cli_lil.c +++ b/common/cli_lil.c @@ -1321,7 +1321,7 @@ static void ee_unary(struct expreval *ee) static void ee_muldiv(struct expreval *ee) { ee_unary(ee); - if (ee->error) + if (ee->error || !IS_ENABLED(CONFIG_LIL_FULL)) return;

ee_skip_spaces(ee); @@ -1382,8 +1382,10 @@ static void ee_muldiv(struct expreval *ee) static void ee_addsub(struct expreval *ee) { ee_muldiv(ee); - ee_skip_spaces(ee); + if (!IS_ENABLED(CONFIG_LIL_FULL)) + return;

+ ee_skip_spaces(ee); while (ee->head < ee->len && !ee->error && !ee_invalidpunct(ee->code[ee->head + 1]) && (ee->code[ee->head] == '+' || ee->code[ee->head] == '-')) { @@ -1415,8 +1417,10 @@ static void ee_addsub(struct expreval *ee) static void ee_shift(struct expreval *ee) { ee_addsub(ee); - ee_skip_spaces(ee); + if (!IS_ENABLED(CONFIG_LIL_FULL)) + return;

+ ee_skip_spaces(ee); while (ee->head < ee->len && !ee->error && ((ee->code[ee->head] == '<' && ee->code[ee->head + 1] == '<') || (ee->code[ee->head] == '>' && ee->code[ee->head + 1] == '>'))) { @@ -1545,8 +1549,10 @@ static void ee_equals(struct expreval *ee) static void ee_bitand(struct expreval *ee) { ee_equals(ee); - ee_skip_spaces(ee); + if (!IS_ENABLED(CONFIG_LIL_FULL)) + return;

+ ee_skip_spaces(ee); while (ee->head < ee->len && !ee->error && (ee->code[ee->head] == '&' && !ee_invalidpunct(ee->code[ee->head + 1]))) { @@ -1566,8 +1572,10 @@ static void ee_bitand(struct expreval *ee) static void ee_bitor(struct expreval *ee) { ee_bitand(ee); - ee_skip_spaces(ee); + if (!IS_ENABLED(CONFIG_LIL_FULL)) + return;

+ ee_skip_spaces(ee); while (ee->head < ee->len && !ee->error && (ee->code[ee->head] == '|' && !ee_invalidpunct(ee->code[ee->head + 1]))) { @@ -2932,49 +2940,52 @@ static struct lil_value *fnc_lmap(struct lil *lil, size_t argc,

static void register_stdcmds(struct lil *lil) { - lil_register(lil, "append", fnc_append); - lil_register(lil, "char", fnc_char); - lil_register(lil, "charat", fnc_charat); - lil_register(lil, "codeat", fnc_codeat); - lil_register(lil, "concat", fnc_concat); - lil_register(lil, "count", fnc_count); lil_register(lil, "dec", fnc_dec); - lil_register(lil, "downeval", fnc_downeval); - lil_register(lil, "error", fnc_error); lil_register(lil, "eval", fnc_eval); lil_register(lil, "expr", fnc_expr); - lil_register(lil, "filter", fnc_filter); lil_register(lil, "for", fnc_for); lil_register(lil, "foreach", fnc_foreach); lil_register(lil, "func", fnc_func); lil_register(lil, "if", fnc_if); lil_register(lil, "inc", fnc_inc); - lil_register(lil, "index", fnc_index); - lil_register(lil, "indexof", fnc_indexof); - lil_register(lil, "length", fnc_length); - lil_register(lil, "list", fnc_list); - lil_register(lil, "lmap", fnc_lmap); lil_register(lil, "local", fnc_local); - lil_register(lil, "ltrim", fnc_ltrim); - lil_register(lil, "quote", fnc_quote); - lil_register(lil, "reflect", fnc_reflect); - lil_register(lil, "rename", fnc_rename); - lil_register(lil, "repstr", fnc_repstr); - lil_register(lil, "result", fnc_result); lil_register(lil, "return", fnc_return); - lil_register(lil, "rtrim", fnc_rtrim); lil_register(lil, "set", fnc_set); - lil_register(lil, "slice", fnc_slice); - lil_register(lil, "split", fnc_split); lil_register(lil, "strcmp", fnc_strcmp); - lil_register(lil, "streq", fnc_streq); - lil_register(lil, "strpos", fnc_strpos); - lil_register(lil, "subst", fnc_subst); - lil_register(lil, "substr", fnc_substr); - lil_register(lil, "topeval", fnc_topeval); - lil_register(lil, "trim", fnc_trim); lil_register(lil, "try", fnc_try); - lil_register(lil, "unusedname", fnc_unusedname); - lil_register(lil, "upeval", fnc_upeval); lil_register(lil, "while", fnc_while); + + if (IS_ENABLED(CONFIG_LIL_FULL)) { + lil_register(lil, "append", fnc_append); + lil_register(lil, "char", fnc_char); + lil_register(lil, "charat", fnc_charat); + lil_register(lil, "codeat", fnc_codeat); + lil_register(lil, "concat", fnc_concat); + lil_register(lil, "count", fnc_count); + lil_register(lil, "downeval", fnc_downeval); + lil_register(lil, "error", fnc_error); + lil_register(lil, "filter", fnc_filter); + lil_register(lil, "index", fnc_index); + lil_register(lil, "indexof", fnc_indexof); + lil_register(lil, "length", fnc_length); + lil_register(lil, "list", fnc_list); + lil_register(lil, "lmap", fnc_lmap); + lil_register(lil, "ltrim", fnc_ltrim); + lil_register(lil, "quote", fnc_quote); + lil_register(lil, "reflect", fnc_reflect); + lil_register(lil, "rename", fnc_rename); + lil_register(lil, "repstr", fnc_repstr); + lil_register(lil, "result", fnc_result); + lil_register(lil, "rtrim", fnc_rtrim); + lil_register(lil, "slice", fnc_slice); + lil_register(lil, "split", fnc_split); + lil_register(lil, "streq", fnc_streq); + lil_register(lil, "strpos", fnc_strpos); + lil_register(lil, "subst", fnc_subst); + lil_register(lil, "substr", fnc_substr); + lil_register(lil, "topeval", fnc_topeval); + lil_register(lil, "trim", fnc_trim); + lil_register(lil, "unusedname", fnc_unusedname); + lil_register(lil, "upeval", fnc_upeval); + } }

Several functions have different names than they do in TCL. To make things easier for those familiar with TCL, rename them to their TCL equivalents. At the moment, this is only done for functions not used by LIL_FULL. Some functions need more substantive work to conform them to TCL. For example, in TCL, there is a `string` function with a subcommand of `compare`, which is the same as the top-level function `compare`. Several functions also have no TCL equivalent. Do we need these?

TODO: do this for all functions

Signed-off-by: Sean Anderson seanga2@gmail.com ---

common/cli_lil.c | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/common/cli_lil.c b/common/cli_lil.c index a2e5cdf35a..a6c77ee19c 100644 --- a/common/cli_lil.c +++ b/common/cli_lil.c @@ -1829,10 +1829,10 @@ static struct lil_value *fnc_reflect(struct lil *lil, size_t argc, return lil_clone_value(func->code); }

- if (!strcmp(type, "func-count")) + if (!strcmp(type, "proc-count")) return lil_alloc_integer(lil->cmds);

- if (!strcmp(type, "funcs")) { + if (!strcmp(type, "procs")) { struct lil_list *funcs = lil_alloc_list();

for (i = 0; i < lil->cmds; i++) @@ -1878,7 +1878,7 @@ static struct lil_value *fnc_reflect(struct lil *lil, size_t argc, return r; }

- if (!strcmp(type, "has-func")) { + if (!strcmp(type, "has-proc")) { const char *target;

if (argc == 1) @@ -1948,7 +1948,7 @@ static struct lil_value *fnc_reflect(struct lil *lil, size_t argc, return NULL; }

-static struct lil_value *fnc_func(struct lil *lil, size_t argc, +static struct lil_value *fnc_proc(struct lil *lil, size_t argc, struct lil_value **argv) { struct lil_value *name; @@ -2472,8 +2472,8 @@ static struct lil_value *real_inc(struct lil *lil, const char *varname, return pv; }

-static struct lil_value *fnc_inc(struct lil *lil, size_t argc, - struct lil_value **argv) +static struct lil_value *fnc_incr(struct lil *lil, size_t argc, + struct lil_value **argv) { if (argc < 1) return NULL; @@ -2482,8 +2482,8 @@ static struct lil_value *fnc_inc(struct lil *lil, size_t argc, argc > 1 ? lil_to_integer(argv[1]) : 1); }

-static struct lil_value *fnc_dec(struct lil *lil, size_t argc, - struct lil_value **argv) +static struct lil_value *fnc_decr(struct lil *lil, size_t argc, + struct lil_value **argv) { if (argc < 1) return NULL; @@ -2786,8 +2786,8 @@ static struct lil_value *fnc_rtrim(struct lil *lil, size_t argc, return real_trim(lil_to_string(argv[0]), chars, 0, 1); }

-static struct lil_value *fnc_strcmp(struct lil *lil, size_t argc, - struct lil_value **argv) +static struct lil_value *fnc_compare(struct lil *lil, size_t argc, + struct lil_value **argv) { if (argc < 2) return NULL; @@ -2940,18 +2940,18 @@ static struct lil_value *fnc_lmap(struct lil *lil, size_t argc,

static void register_stdcmds(struct lil *lil) { - lil_register(lil, "dec", fnc_dec); + lil_register(lil, "decr", fnc_decr); lil_register(lil, "eval", fnc_eval); lil_register(lil, "expr", fnc_expr); lil_register(lil, "for", fnc_for); lil_register(lil, "foreach", fnc_foreach); - lil_register(lil, "func", fnc_func); + lil_register(lil, "proc", fnc_proc); lil_register(lil, "if", fnc_if); - lil_register(lil, "inc", fnc_inc); + lil_register(lil, "incr", fnc_incr); lil_register(lil, "local", fnc_local); lil_register(lil, "return", fnc_return); lil_register(lil, "set", fnc_set); - lil_register(lil, "strcmp", fnc_strcmp); + lil_register(lil, "compare", fnc_compare); lil_register(lil, "try", fnc_try); lil_register(lil, "while", fnc_while);

We only need the getvar and setvar callbacks for now (to integrate with the environment). So remove all the other callbacks. Instead of allowing callbacks to be set at any time, just set them once in lil_new. Lastly, get rid of the typedefs and use a struct to pass in the callbacks instead.

Signed-off-by: Sean Anderson seanga2@gmail.com ---

common/cli_lil.c | 45 ++++++++++++--------------------------------- include/cli_lil.h | 34 ++++++++-------------------------- 2 files changed, 20 insertions(+), 59 deletions(-)

diff --git a/common/cli_lil.c b/common/cli_lil.c index 3d1e6181f9..539a4a3238 100644 --- a/common/cli_lil.c +++ b/common/cli_lil.c @@ -24,7 +24,6 @@ * overflows and is also useful when running through an automated fuzzer like AFL */ /*#define LIL_ENABLE_RECLIMIT 10000*/

-#define CALLBACKS 8 #define HASHMAP_CELLS 256 #define HASHMAP_CELLMASK 0xFF

@@ -100,7 +99,7 @@ struct lil { } error; size_t err_head; char *err_msg; - lil_callback_proc_t callback[CALLBACKS]; + struct lil_callbacks callbacks; size_t parse_depth; };

@@ -667,14 +666,10 @@ struct lil_var *lil_set_var(struct lil *lil, const char *name, var->env == lil->rootenv && var->env != env) var = NULL;

- if (((!var && env == lil->rootenv) || - (var && var->env == lil->rootenv)) && - lil->callback[LIL_CALLBACK_SETVAR]) { - lil_setvar_callback_proc_t proc = - (lil_setvar_callback_proc_t) - lil->callback[LIL_CALLBACK_SETVAR]; + if (lil->callbacks.setvar && ((!var && env == lil->rootenv) || + (var && var->env == lil->rootenv))) { struct lil_value *newval = val; - int r = proc(lil, name, &newval); + int r = lil->callbacks.setvar(lil, name, &newval);

if (r < 0) { return NULL; @@ -717,14 +712,10 @@ struct lil_value *lil_get_var_or(struct lil *lil, const char *name, struct lil_var *var = lil_find_var(lil, lil->env, name); struct lil_value *retval = var ? var->v : defvalue;

- if (lil->callback[LIL_CALLBACK_GETVAR] && - (!var || var->env == lil->rootenv)) { - lil_getvar_callback_proc_t proc = - (lil_getvar_callback_proc_t) - lil->callback[LIL_CALLBACK_GETVAR]; + if (lil->callbacks.getvar && (!var || var->env == lil->rootenv)) { struct lil_value *newretval = retval;

- if (proc(lil, name, &newretval)) + if (lil->callbacks.getvar(lil, name, &newretval)) retval = newretval; } return retval; @@ -748,10 +739,15 @@ void lil_pop_env(struct lil *lil) } }

-struct lil *lil_new(void) +struct lil *lil_new(const struct lil_callbacks *callbacks) { struct lil *lil = calloc(1, sizeof(struct lil));

+ if (!lil) + return NULL; + + if (callbacks) + memcpy(&lil->callbacks, callbacks, sizeof(lil->callbacks)); lil->rootenv = lil->env = lil_alloc_env(NULL); lil->empty = alloc_value(NULL); hm_init(&lil->cmdmap); @@ -1148,15 +1144,6 @@ struct lil_value *lil_parse(struct lil *lil, const char *code, size_t codelen, }

cleanup: - if (lil->error && lil->callback[LIL_CALLBACK_ERROR] && - lil->parse_depth == 1) { - lil_error_callback_proc_t proc = - (lil_error_callback_proc_t) - lil->callback[LIL_CALLBACK_ERROR]; - - proc(lil, lil->err_head, lil->err_msg); - } - if (words) lil_free_list(words); lil->code = save_code; @@ -1185,14 +1172,6 @@ struct lil_value *lil_parse_value(struct lil *lil, struct lil_value *val, return lil_parse(lil, val->d, val->l, funclevel); }

-void lil_callback(struct lil *lil, int cb, lil_callback_proc_t proc) -{ - if (cb < 0 || cb > CALLBACKS) - return; - - lil->callback[cb] = proc; -} - void lil_set_error(struct lil *lil, const char *msg) { if (lil->error) diff --git a/include/cli_lil.h b/include/cli_lil.h index 48735e0605..b8df94a766 100644 --- a/include/cli_lil.h +++ b/include/cli_lil.h @@ -20,15 +20,6 @@ enum lil_setvar { LIL_SETVAR_LOCAL_ONLY, };

-#define LIL_CALLBACK_EXIT 0 -#define LIL_CALLBACK_WRITE 1 -#define LIL_CALLBACK_READ 2 -#define LIL_CALLBACK_STORE 3 -#define LIL_CALLBACK_SOURCE 4 -#define LIL_CALLBACK_ERROR 5 -#define LIL_CALLBACK_SETVAR 6 -#define LIL_CALLBACK_GETVAR 7 - #include <stdint.h> #include <inttypes.h>

@@ -40,22 +31,15 @@ struct lil_list; struct lil; typedef struct lil_value *(*lil_func_proc_t)(struct lil *lil, size_t argc, struct lil_value **argv); -typedef void (*lil_exit_callback_proc_t)(struct lil *lil, - struct lil_value *arg); -typedef void (*lil_write_callback_proc_t)(struct lil *lil, const char *msg); -typedef char *(*lil_read_callback_proc_t)(struct lil *lil, const char *name); -typedef char *(*lil_source_callback_proc_t)(struct lil *lil, const char *name); -typedef void (*lil_store_callback_proc_t)(struct lil *lil, const char *name, - const char *data); -typedef void (*lil_error_callback_proc_t)(struct lil *lil, size_t pos, - const char *msg); -typedef int (*lil_setvar_callback_proc_t)(struct lil *lil, const char *name, - struct lil_value **value); -typedef int (*lil_getvar_callback_proc_t)(struct lil *lil, const char *name, - struct lil_value **value); -typedef void (*lil_callback_proc_t)(void);

-struct lil *lil_new(void); +struct lil_callbacks { + int (*setvar)(struct lil *lil, const char *name, + struct lil_value **value); + int (*getvar)(struct lil *lil, const char *name, + struct lil_value **value); +}; + +struct lil *lil_new(const struct lil_callbacks *callbacks); void lil_free(struct lil *lil);

int lil_register(struct lil *lil, const char *name, lil_func_proc_t proc); @@ -65,8 +49,6 @@ struct lil_value *lil_parse(struct lil *lil, const char *code, size_t codelen, struct lil_value *lil_parse_value(struct lil *lil, struct lil_value *val, int funclevel);

-void lil_callback(struct lil *lil, int cb, lil_callback_proc_t proc); - void lil_set_error(struct lil *lil, const char *msg); void lil_set_error_at(struct lil *lil, size_t pos, const char *msg); int lil_error(struct lil *lil, const char **msg, size_t *pos);

This adds numeric error codes to be used for errors. This makes it easier for code to differentiate between different classes of errors. Some error codes are not used yet, and will be added in future commits. The position argument has been removed for a few reasons:

- It doesn't make sense for some errors, such as running out of memory - It was often not very helpful, since it pointed at the end of the command - Determining the location of an error is more difficult when the parsing and evaluating steps are done separately.

In addition, lil.error is changed to lil.err for consistency.

Signed-off-by: Sean Anderson seanga2@gmail.com ---

common/cli_lil.c | 92 ++++++++++++++++++----------------------------- include/cli_lil.h | 36 +++++++++++++++++-- 2 files changed, 68 insertions(+), 60 deletions(-)

diff --git a/common/cli_lil.c b/common/cli_lil.c index dd020e8452..1bdf0e5265 100644 --- a/common/cli_lil.c +++ b/common/cli_lil.c @@ -92,12 +92,7 @@ struct lil { struct lil_env *rootenv; struct lil_env *downenv; struct lil_value *empty; - enum { - ERROR_NOERROR = 0, - ERROR_DEFAULT, - ERROR_FIXHEAD, - } error; - size_t err_head; + enum lil_error err; char *err_msg; struct lil_callbacks callbacks; size_t parse_depth; @@ -117,6 +112,7 @@ struct expreval {

static struct lil_value *next_word(struct lil *lil); static void register_stdcmds(struct lil *lil); +static void lil_set_error(struct lil *lil, enum lil_error err, const char *msg);

#ifdef LIL_ENABLE_POOLS static struct lil_value **pool; @@ -974,7 +970,7 @@ static struct lil_list *substitute(struct lil *lil) struct lil_list *words = lil_alloc_list();

lil_skip_spaces(lil); - while (lil->head < lil->clen && !ateol(lil) && !lil->error) { + while (lil->head < lil->clen && !ateol(lil) && !lil->err) { struct lil_value *w = alloc_value(NULL);

do { @@ -993,7 +989,7 @@ static struct lil_list *substitute(struct lil *lil) lil_free_value(wp); } while (lil->head < lil->clen && !eolchar(lil->code[lil->head]) && - !isspace(lil->code[lil->head]) && !lil->error); + !isspace(lil->code[lil->head]) && !lil->err); lil_skip_spaces(lil);

lil_list_append(words, w); @@ -1042,13 +1038,7 @@ static struct lil_value *run_cmd(struct lil *lil, struct lil_func *cmd, struct lil_value *r;

if (cmd->proc) { - size_t shead = lil->head; - r = cmd->proc(lil, words->c - 1, words->v + 1); - if (lil->error == ERROR_FIXHEAD) { - lil->error = ERROR_DEFAULT; - lil->err_head = shead; - } } else { lil_push_env(lil); lil->env->func = cmd; @@ -1102,18 +1092,18 @@ struct lil_value *lil_parse(struct lil *lil, const char *code, size_t codelen, lil->parse_depth++; #ifdef LIL_ENABLE_RECLIMIT if (lil->parse_depth > LIL_ENABLE_RECLIMIT) { - lil_set_error(lil, "Too many recursive calls"); + lil_set_error(lil, LIL_ERR_DEPTH, "Too many recursive calls"); goto cleanup; } #endif

if (lil->parse_depth == 1) - lil->error = 0; + lil->err = LIL_ERR_NONE;

if (funclevel) lil->env->breakrun = 0;

- while (lil->head < lil->clen && !lil->error) { + while (lil->head < lil->clen && !lil->err) { if (words) lil_free_list(words);

@@ -1122,7 +1112,7 @@ struct lil_value *lil_parse(struct lil *lil, const char *code, size_t codelen, val = NULL;

words = substitute(lil); - if (!words || lil->error) + if (!words || lil->err) goto cleanup;

if (words->c) { @@ -1136,7 +1126,7 @@ struct lil_value *lil_parse(struct lil *lil, const char *code, size_t codelen, snprintf(msg, sizeof(msg), "unknown function %s", words->v[0]->d); - lil_set_error_at(lil, lil->head, msg); + lil_set_error(lil, LIL_ERR_NOCMD, msg); goto cleanup; } } else { @@ -1182,38 +1172,25 @@ struct lil_value *lil_parse_value(struct lil *lil, struct lil_value *val, return lil_parse(lil, val->d, val->l, funclevel); }

-void lil_set_error(struct lil *lil, const char *msg) +static void lil_set_error(struct lil *lil, enum lil_error err, const char *msg) { - if (lil->error) - return; - + assert(!lil->err); free(lil->err_msg); - lil->error = ERROR_FIXHEAD; - lil->err_head = 0; - lil->err_msg = strdup(msg ? msg : ""); + lil->err = err; + lil->err_msg = strdup(msg); }

-void lil_set_error_at(struct lil *lil, size_t pos, const char *msg) +enum lil_error lil_error(struct lil *lil, const char **msg) { - if (lil->error) - return; + enum lil_error err = lil->err;

- free(lil->err_msg); - lil->error = ERROR_DEFAULT; - lil->err_head = pos; - lil->err_msg = strdup(msg ? msg : ""); -} - -int lil_error(struct lil *lil, const char **msg, size_t *pos) -{ - if (!lil->error) - return 0; + if (!err) + return LIL_ERR_NONE;

*msg = lil->err_msg; - *pos = lil->err_head; - lil->error = ERROR_NOERROR; + lil->err = LIL_ERR_NONE;

- return 1; + return err; }

static void ee_expr(struct expreval *ee); @@ -1642,7 +1619,7 @@ struct lil_value *lil_eval_expr(struct lil *lil, struct lil_value *code) struct expreval ee;

code = lil_subst_to_value(lil, code); - if (lil->error) + if (lil->err) return NULL;

ee.code = lil_to_string(code); @@ -1664,13 +1641,13 @@ struct lil_value *lil_eval_expr(struct lil *lil, struct lil_value *code) lil_free_value(code); switch (ee.error) { case EERR_DIVISION_BY_ZERO: - lil_set_error(lil, "division by zero in expression"); + lil_set_error(lil, LIL_ERR_DOM, "division by zero"); return NULL; case EERR_SYNTAX_ERROR: - lil_set_error(lil, "expression syntax error"); + lil_set_error(lil, LIL_ERR_SYNTAX, "expression syntax"); return NULL; case EERR_INVALID_EXPRESSION: - lil_set_error(lil, "invalid expression"); + lil_set_error(lil, LIL_ERR_SYNTAX, "invalid expression"); return NULL; case EERR_NO_ERROR: break; @@ -1994,7 +1971,7 @@ static struct lil_value *fnc_rename(struct lil *lil, size_t argc, char *msg = malloc(24 + strlen(oldname));

sprintf(msg, "unknown function '%s'", oldname); - lil_set_error_at(lil, lil->head, msg); + lil_set_error(lil, LIL_ERR_NOCMD, msg); free(msg); return NULL; } @@ -2397,7 +2374,7 @@ static struct lil_value *fnc_foreach(struct lil *lil, size_t argc, else lil_free_value(rv);

- if (lil->env->breakrun || lil->error) + if (lil->env->breakrun || lil->err) break; }

@@ -2499,7 +2476,7 @@ static struct lil_value *fnc_if(struct lil *lil, size_t argc, return NULL;

val = lil_eval_expr(lil, argv[base]); - if (!val || lil->error) + if (!val || lil->err) return NULL;

v = lil_to_boolean(val); @@ -2530,9 +2507,9 @@ static struct lil_value *fnc_while(struct lil *lil, size_t argc, if (argc < (size_t)base + 2) return NULL;

- while (!lil->error && !lil->env->breakrun) { + while (!lil->err && !lil->env->breakrun) { val = lil_eval_expr(lil, argv[base]); - if (!val || lil->error) + if (!val || lil->err) return NULL;

v = lil_to_boolean(val); @@ -2562,9 +2539,9 @@ static struct lil_value *fnc_for(struct lil *lil, size_t argc, return NULL;

lil_free_value(lil_parse_value(lil, argv[0], 0)); - while (!lil->error && !lil->env->breakrun) { + while (!lil->err && !lil->env->breakrun) { val = lil_eval_expr(lil, argv[1]); - if (!val || lil->error) + if (!val || lil->err) return NULL;

if (!lil_to_boolean(val)) { @@ -2889,12 +2866,12 @@ static struct lil_value *fnc_try(struct lil *lil, size_t argc, if (argc < 1) return NULL;

- if (lil->error) + if (lil->err) return NULL;

r = lil_parse_value(lil, argv[0], 0); - if (lil->error) { - lil->error = ERROR_NOERROR; + if (lil->err) { + lil->err = LIL_ERR_NONE; lil_free_value(r);

if (argc > 1) @@ -2908,7 +2885,8 @@ static struct lil_value *fnc_try(struct lil *lil, size_t argc, static struct lil_value *fnc_error(struct lil *lil, size_t argc, struct lil_value **argv) { - lil_set_error(lil, argc > 0 ? lil_to_string(argv[0]) : NULL); + lil_set_error(lil, LIL_ERR_USER, + argc > 0 ? lil_to_string(argv[0]) : NULL); return NULL; }

diff --git a/include/cli_lil.h b/include/cli_lil.h index b8df94a766..cdaa79fd15 100644 --- a/include/cli_lil.h +++ b/include/cli_lil.h @@ -39,6 +39,38 @@ struct lil_callbacks { struct lil_value **value); };

+/** + * enum lil_error - Error codes returned by @lil_error + * LIL_ERR_NONE: No error + * LIL_ERR_OOM: Out of memory + * LIL_ERR_CASE: Missing case statement; generally a bug in the program or the + * result of memory corruption. + * LIL_ERR_DEPTH: Too much recursion while parsing or evaluating + * LIL_ERR_SYNTAX: Unrecoverable syntax error + * LIL_ERR_EOF: Unexpected end of input; may be recoverable by prompting the + * user for more input. + * LIL_ERR_INTR: Interrupted by Ctrl-C + * LIL_ERR_NOCMD: No such command + * LIL_ERR_NOVAR: No such variable + * LIL_ERR_ARGC: Incorrect number of arguments + * LIL_ERR_DOM: Numerical argument out of range (typically division by zero) + * LIL_ERR_USER: Error set by user + */ +enum lil_error { + LIL_ERR_NONE = 0, + LIL_ERR_OOM, + LIL_ERR_CASE, + LIL_ERR_DEPTH, + LIL_ERR_SYNTAX, + LIL_ERR_EOF, + LIL_ERR_INTR, + LIL_ERR_NOCMD, + LIL_ERR_NOVAR, + LIL_ERR_ARGC, + LIL_ERR_DOM, + LIL_ERR_USER, +}; + struct lil *lil_new(const struct lil_callbacks *callbacks); void lil_free(struct lil *lil);

@@ -49,9 +81,7 @@ struct lil_value *lil_parse(struct lil *lil, const char *code, size_t codelen, struct lil_value *lil_parse_value(struct lil *lil, struct lil_value *val, int funclevel);

-void lil_set_error(struct lil *lil, const char *msg); -void lil_set_error_at(struct lil *lil, size_t pos, const char *msg); -int lil_error(struct lil *lil, const char **msg, size_t *pos); +enum lil_error lil_error(struct lil *lil, const char **msg);

const char *lil_to_string(struct lil_value *val); ssize_t lil_to_integer(struct lil_value *val);

This adds several helper functions for common error types. This helps keep down code duplication, and also ensures that each of these errors uses the same message.

Signed-off-by: Sean Anderson seanga2@gmail.com ---

common/cli_lil.c | 38 +++++++++++++++++++++++++++++++++----- 1 file changed, 33 insertions(+), 5 deletions(-)

diff --git a/common/cli_lil.c b/common/cli_lil.c index f29c8065d8..c19a25b2bf 100644 --- a/common/cli_lil.c +++ b/common/cli_lil.c @@ -116,6 +116,9 @@ static void lil_set_error(struct lil *lil, enum lil_error err, const char *msg); static void lil_set_errorf(struct lil *lil, enum lil_error err, const char *fmt, ...) __attribute((format(__printf__, 3, 4))); +static void lil_set_error_oom(struct lil *lil); +static void lil_set_error_nocmd(struct lil *lil, const char *cmdname); +static void lil_set_error_intr(struct lil *lil);

#ifdef LIL_ENABLE_POOLS static struct lil_value **pool; @@ -1124,9 +1127,8 @@ struct lil_value *lil_parse(struct lil *lil, const char *code, size_t codelen,

if (!cmd) { if (words->v[0]->l) { - lil_set_errorf(lil, LIL_ERR_NOCMD, - "unknown function %s", - words->v[0]->d); + lil_set_error_nocmd(lil, + words->v[0]->d); goto cleanup; } } else { @@ -1204,6 +1206,33 @@ static void lil_set_errorf(struct lil *lil, enum lil_error err, va_end(saveargs); }

+/* + * The next several functions provide helpers for throwing some formulaic + * errors. Their purpose is to ensure that the same wording is used everywhere + * the error is used. This reduces data size. + */ + +static void lil_set_error_oom(struct lil *lil) +{ + lil_set_error(lil, LIL_ERR_OOM, NULL); +} + +static void lil_set_error_argc(struct lil *lil, size_t expected) +{ + lil_set_errorf(lil, LIL_ERR_ARGC, "%s: expected %zu arguments", + lil->env->proc ?: lil->env->func->name, expected); +} + +static void lil_set_error_nocmd(struct lil *lil, const char *cmdname) +{ + lil_set_errorf(lil, LIL_ERR_NOCMD, "no such command %s", cmdname); +} + +static void lil_set_error_intr(struct lil *lil) +{ + lil_set_error(lil, LIL_ERR_INTR, "interrupted"); +} + enum lil_error lil_error(struct lil *lil, const char **msg) { enum lil_error err = lil->err; @@ -1992,8 +2021,7 @@ static struct lil_value *fnc_rename(struct lil *lil, size_t argc, newname = lil_to_string(argv[1]); func = lil_find_cmd(lil, oldname); if (!func) { - lil_set_errorf(lil, LIL_ERR_NOCMD, "unknown function %s", - oldname); + lil_set_error_nocmd(lil, oldname); return NULL; }

This adds a Kconfig option to enable memory pools for some commonly-created and destroyed LIL structures. There is still some significant code duplication, so perhaps these functions can be refactored further to all use common pool functions.

Signed-off-by: Sean Anderson seanga2@gmail.com ---

cmd/Kconfig | 7 ++ common/cli_lil.c | 275 +++++++++++++++++++++++------------------------ 2 files changed, 143 insertions(+), 139 deletions(-)

diff --git a/cmd/Kconfig b/cmd/Kconfig index b61a7557a9..28a387b380 100644 --- a/cmd/Kconfig +++ b/cmd/Kconfig @@ -46,6 +46,13 @@ config LIL_FULL This enables all LIL builtin functions, as well as expression support for arithmetic and bitwise operations.

+config LIL_POOLS + bool "Use memory pools for LIL structures" + help + Enable pools for reusing values, lists, and environments. This will + use more memory but will cause considerably less memory fragmentation + and improve the script execution performance. + endif

endif diff --git a/common/cli_lil.c b/common/cli_lil.c index 7fbae1964a..750a085f63 100644 --- a/common/cli_lil.c +++ b/common/cli_lil.c @@ -17,11 +17,6 @@ #include <stdio.h> #include <string.h>

-/* Enable pools for reusing values, lists and environments. This will use more memory and - * will rely on the runtime/OS to free the pools once the program ends, but will cause - * considerably less memory fragmentation and improve the script execution performance. */ -/*#define LIL_ENABLE_POOLS*/ - /* Enable limiting recursive calls to lil_parse - this can be used to avoid call stack * overflows and is also useful when running through an automated fuzzer like AFL */ /*#define LIL_ENABLE_RECLIMIT 10000*/ @@ -69,7 +64,7 @@ struct hashmap { */ struct lil_value { size_t l; -#ifdef LIL_ENABLE_POOLS +#ifdef CONFIG_LIL_POOLS size_t c; #endif char *d; @@ -223,14 +218,12 @@ static void lil_set_error_oom(struct lil *lil); static void lil_set_error_nocmd(struct lil *lil, const char *cmdname); static void lil_set_error_intr(struct lil *lil);

-#ifdef LIL_ENABLE_POOLS -static struct lil_value **pool; -static int poolsize, poolcap; -static struct lil_list **listpool; -static size_t listpoolsize, listpoolcap; -static struct lil_env **envpool; -static size_t envpoolsize, envpoolcap; -#endif +static __maybe_unused struct lil_value **pool; +static __maybe_unused int poolsize, poolcap; +static __maybe_unused struct lil_list **listpool; +static __maybe_unused size_t listpoolsize, listpoolcap; +static __maybe_unused struct lil_env **envpool; +static __maybe_unused size_t envpoolsize, envpoolcap;

static unsigned long hm_hash(const char *key) { @@ -298,7 +291,7 @@ static int hm_has(struct hashmap *hm, const char *key) return 0; }

-#ifdef LIL_ENABLE_POOLS +#ifdef CONFIG_LIL_POOLS static struct lil_value *alloc_from_pool(void) { if (poolsize > 0) { @@ -327,39 +320,48 @@ static void ensure_capacity(struct lil_value *val, size_t cap) val->d = realloc(val->d, val->c); } } +#else +static struct lil_value *alloc_from_pool(void) +{ + return NULL; +} + +static void release_to_pool(struct lil_value *val) { } +static void ensure_capacity(struct lil_value *val, size_t cap) { } #endif

static struct lil_value *alloc_value_len(const char *str, size_t len) { -#ifdef LIL_ENABLE_POOLS - struct lil_value *val = alloc_from_pool(); -#else - struct lil_value *val = calloc(1, sizeof(struct lil_value)); -#endif + struct lil_value *val;

+ if (IS_ENABLED(CONFIG_LIL_POOLS)) + val = alloc_from_pool(); + else + val = calloc(1, sizeof(struct lil_value)); if (!val) return NULL; + if (str) { val->l = len; -#ifdef LIL_ENABLE_POOLS - ensure_capacity(val, len + 1); -#else - val->d = malloc(len + 1); - if (!val->d) { - free(val); - return NULL; + if (IS_ENABLED(CONFIG_LIL_POOLS)) { + ensure_capacity(val, len + 1); + } else { + val->d = malloc(len + 1); + if (!val->d) { + free(val); + return NULL; + } } -#endif memcpy(val->d, str, len); val->d[len] = 0; } else { val->l = 0; -#ifdef LIL_ENABLE_POOLS - ensure_capacity(val, 1); - val->d[0] = '\0'; -#else - val->d = NULL; -#endif + if (IS_ENABLED(CONFIG_LIL_POOLS)) { + ensure_capacity(val, 1); + val->d[0] = '\0'; + } else { + val->d = NULL; + } } return val; } @@ -375,76 +377,72 @@ struct lil_value *lil_clone_value(struct lil_value *src)

if (!src) return NULL; -#ifdef LIL_ENABLE_POOLS - val = alloc_from_pool(); -#else - val = calloc(1, sizeof(struct lil_value)); -#endif + + if (IS_ENABLED(CONFIG_LIL_POOLS)) + val = alloc_from_pool(); + else + val = calloc(1, sizeof(struct lil_value)); if (!val) return NULL;

val->l = src->l; if (src->l) { -#ifdef LIL_ENABLE_POOLS - ensure_capacity(val, val->l + 1); -#else - val->d = malloc(val->l + 1); - if (!val->d) { - free(val); - return NULL; + if (IS_ENABLED(CONFIG_LIL_POOLS)) { + ensure_capacity(val, val->l + 1); + } else { + val->d = malloc(val->l + 1); + if (!val->d) { + free(val); + return NULL; + } } -#endif memcpy(val->d, src->d, val->l + 1); } else { -#ifdef LIL_ENABLE_POOLS - ensure_capacity(val, 1); - val->d[0] = '\0'; -#else - val->d = NULL; -#endif + if (IS_ENABLED(CONFIG_LIL_POOLS)) { + ensure_capacity(val, 1); + val->d[0] = '\0'; + } else { + val->d = NULL; + } } return val; }

int lil_append_char(struct lil_value *val, char ch) { -#ifdef LIL_ENABLE_POOLS - ensure_capacity(val, val->l + 2); - val->d[val->l++] = ch; - val->d[val->l] = '\0'; -#else - char *new = realloc(val->d, val->l + 2); + if (IS_ENABLED(CONFIG_LIL_POOLS)) { + ensure_capacity(val, val->l + 2); + val->d[val->l++] = ch; + val->d[val->l] = '\0'; + } else { + char *new = realloc(val->d, val->l + 2);

- if (!new) - return 0; + if (!new) + return 0;

- new[val->l++] = ch; - new[val->l] = 0; - val->d = new; -#endif + new[val->l++] = ch; + new[val->l] = 0; + val->d = new; + } return 1; }

int lil_append_string_len(struct lil_value *val, const char *s, size_t len) { -#ifndef LIL_ENABLE_POOLS - char *new; -#endif - if (!s || !s[0]) return 1;

-#ifdef LIL_ENABLE_POOLS - ensure_capacity(val, val->l + len + 1); - memcpy(val->d + val->l, s, len + 1); -#else - new = realloc(val->d, val->l + len + 1); - if (!new) - return 0; + if (IS_ENABLED(CONFIG_LIL_POOLS)) { + ensure_capacity(val, val->l + len + 1); + memcpy(val->d + val->l, s, len + 1); + } else { + char *new = realloc(val->d, val->l + len + 1);

- memcpy(new + val->l, s, len + 1); - val->d = new; -#endif + if (!new) + return 0; + memcpy(new + val->l, s, len + 1); + val->d = new; + } val->l += len; return 1; } @@ -456,24 +454,20 @@ int lil_append_string(struct lil_value *val, const char *s)

int lil_append_val(struct lil_value *val, struct lil_value *v) { -#ifndef LIL_ENABLE_POOLS - char *new; -#endif - if (!v || !v->l) return 1;

-#ifdef LIL_ENABLE_POOLS - ensure_capacity(val, val->l + v->l + 1); - memcpy(val->d + val->l, v->d, v->l + 1); -#else - new = realloc(val->d, val->l + v->l + 1); - if (!new) - return 0; + if (IS_ENABLED(CONFIG_LIL_POOLS)) { + ensure_capacity(val, val->l + v->l + 1); + memcpy(val->d + val->l, v->d, v->l + 1); + } else { + char *new = realloc(val->d, val->l + v->l + 1);

- memcpy(new + val->l, v->d, v->l + 1); - val->d = new; -#endif + if (!new) + return 0; + memcpy(new + val->l, v->d, v->l + 1); + val->d = new; + } val->l += v->l; return 1; } @@ -483,22 +477,21 @@ void lil_free_value(struct lil_value *val) if (!val) return;

-#ifdef LIL_ENABLE_POOLS - release_to_pool(val); -#else - free(val->d); - free(val); -#endif + if (IS_ENABLED(CONFIG_LIL_POOLS)) { + release_to_pool(val); + } else { + free(val->d); + free(val); + } }

struct lil_list *lil_alloc_list(void) { struct lil_list *list;

-#ifdef LIL_ENABLE_POOLS - if (listpoolsize > 0) + if (IS_ENABLED(CONFIG_LIL_POOLS) && listpoolsize > 0) return listpool[--listpoolsize]; -#endif + list = calloc(1, sizeof(struct lil_list)); list->v = NULL; return list; @@ -514,19 +507,21 @@ void lil_free_list(struct lil_list *list) for (i = 0; i < list->c; i++) lil_free_value(list->v[i]);

-#ifdef LIL_ENABLE_POOLS - list->c = 0; - if (listpoolsize == listpoolcap) { - listpoolcap = - listpoolcap ? (listpoolcap + listpoolcap / 2) : 32; - listpool = realloc(listpool, - sizeof(struct lil_list *) * listpoolcap); + if (IS_ENABLED(CONFIG_LIL_POOLS)) { + list->c = 0; + if (listpoolsize == listpoolcap) { + if (listpoolcap) + listpoolcap += listpoolcap / 2; + else + listpoolcap = 32; + listpool = realloc(listpool, + sizeof(*listpool) * listpoolcap); + } + listpool[listpoolsize++] = list; + } else { + free(list->v); + free(list); } - listpool[listpoolsize++] = list; -#else - free(list->v); - free(list); -#endif }

void lil_list_append(struct lil_list *list, struct lil_value *val) @@ -603,8 +598,7 @@ struct lil_env *lil_alloc_env(struct lil_env *parent) { struct lil_env *env;

-#ifdef LIL_ENABLE_POOLS - if (envpoolsize > 0) { + if (IS_ENABLED(CONFIG_LIL_POOLS) && envpoolsize > 0) { size_t i, j;

env = envpool[--envpoolsize]; @@ -622,7 +616,7 @@ struct lil_env *lil_alloc_env(struct lil_env *parent) } return env; } -#endif + env = calloc(1, sizeof(struct lil_env)); env->parent = parent; return env; @@ -636,30 +630,33 @@ void lil_free_env(struct lil_env *env) return;

lil_free_value(env->retval); -#ifdef LIL_ENABLE_POOLS - for (i = 0; i < env->vars; i++) { - free(env->var[i]->n); - lil_free_value(env->var[i]->v); - free(env->var[i]); - } - free(env->var); + if (IS_ENABLED(CONFIG_LIL_POOLS)) { + for (i = 0; i < env->vars; i++) { + free(env->var[i]->n); + lil_free_value(env->var[i]->v); + free(env->var[i]); + } + free(env->var);

- if (envpoolsize == envpoolcap) { - envpoolcap = envpoolcap ? (envpoolcap + envpoolcap / 2) : 64; - envpool = - realloc(envpool, sizeof(struct lil_env *) * envpoolcap); + if (envpoolsize == envpoolcap) { + if (envpoolcap) + envpoolcap += envpoolcap / 2; + else + envpoolcap = 64; + envpool = realloc(envpool, + sizeof(*envpool) * envpoolcap); + } + envpool[envpoolsize++] = env; + } else { + hm_destroy(&env->varmap); + for (i = 0; i < env->vars; i++) { + free(env->var[i]->n); + lil_free_value(env->var[i]->v); + free(env->var[i]); + } + free(env->var); + free(env); } - envpool[envpoolsize++] = env; -#else - hm_destroy(&env->varmap); - for (i = 0; i < env->vars; i++) { - free(env->var[i]->n); - lil_free_value(env->var[i]->v); - free(env->var[i]); - } - free(env->var); - free(env); -#endif }

static struct lil_var *lil_find_local_var(struct lil *lil, struct lil_env *env,

This tests several aspects of the parser. These tests are primarily adapted from the *.lil code examples included with upstream LIL. These tests should probably get their own category, especially if I add additional styles of tests.

Signed-off-by: Sean Anderson seanga2@gmail.com --- Yes, I know checkpatch complains about the quoted string being split, but that warning is intended for user-visible strings.

MAINTAINERS | 1 + test/cmd/Makefile | 1 + test/cmd/lil.c | 339 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 341 insertions(+) create mode 100644 test/cmd/lil.c

diff --git a/MAINTAINERS b/MAINTAINERS index 0184de5f93..3bf460127b 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -771,6 +771,7 @@ M: Sean Anderson seanga2@gmail.com S: Maintained F: common/cli_lil.c F: include/cli_lil.h +F: test/cmd/lil.c

LOGGING M: Simon Glass sjg@chromium.org diff --git a/test/cmd/Makefile b/test/cmd/Makefile index 2cfe43a6bd..4f7440cb44 100644 --- a/test/cmd/Makefile +++ b/test/cmd/Makefile @@ -5,6 +5,7 @@ ifdef CONFIG_HUSH_PARSER obj-$(CONFIG_CONSOLE_RECORD) += test_echo.o endif +obj-$(CONFIG_LIL_FULL) += lil.o obj-y += mem.o obj-$(CONFIG_CMD_ADDRMAP) += addrmap.o obj-$(CONFIG_CMD_MEM_SEARCH) += mem_search.o diff --git a/test/cmd/lil.c b/test/cmd/lil.c new file mode 100644 index 0000000000..896b2fed15 --- /dev/null +++ b/test/cmd/lil.c @@ -0,0 +1,339 @@ +// SPDX-License-Identifier: GPL-2.0+ AND Zlib +/* + * Copyright (C) 2021 Sean Anderson seanga2@gmail.com + * Copyright (C) 2010-2021 Kostas Michalopoulos + * + * This file contains code which originated from the LIL project, licensed under + * Zlib. All modifications are licensed under GPL-2.0+ + */ + +#include <common.h> +#include <asm/global_data.h> +#include <cli_lil.h> +#include <test/lib.h> +#include <test/test.h> +#include <test/ut.h> + +const char helpers[] = + "proc assert {cond} {" + "if not [upeval expr [set cond]] {" + "error [set cond]" + "}" + "};" + "proc assert_err {cmd} {" + "set ok 1;" + "try {upeval $cmd; set ok 0} {};" + "assert {$ok};" + "};" + "proc asserteq {expr1 expr2} {" + "set val1 [upeval 'expr "$expr1"'];" + "set val2 [upeval 'expr "$expr2"'];" + "if {$val1 != $val2} {" + "error '$expr1 == ${expr2}: " + "Expected ${val1}, got $val2'" + "}" + "};" + "proc asserteq_str {expr1 expr2} {" + "set val1 [upeval 'subst "$expr1"'];" + "set val2 [upeval 'subst "$expr2"'];" + "if not [streq $val1 $val2] {" + "error '$expr1 == ${expr2}: " + "Expected ${val1}, got $val2'" + "}" + "};" + "proc asserteq_list {xs ys} {" + "set xlen [count $xs];" + "set ylen [count $ys];" + "if not {$xlen == $ylen} {" + "error '\[count ${xs}\] == \[count ${ys}\]: " + "Expected ${xlen}, got $ylen'\n" + "};" + "for {set i 0} {$i < $xlen} {incr i} {" + "set x [index $xs $i];" + "set y [index $ys $i];" + "if not {[streq $x $y]} {" + "error '$xs == ${ys}: " + "Expected $x at ${i}, got $y'" + "}" + "}" + "}"; + +static const struct { + const char *name; + const char *cmd; +} lil_tests[] = { + {"and", + "proc and args {" + "foreach [slice $args 1] {" + "upeval 'downeval \'set v \'\[${i}\]';" + "if not $v { return 0 }" + "};" + "return 1" + "};" + "set a 0;" + "set final [and {set a 3} {return 0} {set a 32}];" + "asserteq 0 {$final};" + "assert 3 {$a};" + }, + {"assert", + "assert 1;" + "assert_err {assert 0};" + "asserteq 1 1;" + "assert_err {asserteq 1 0};" + "asserteq_str {string one} {string one};" + "assert_err {asserteq_str {string one} {string two}};" + "asserteq_list [list 1 2 3] [list 1 2 3];" + "assert_err {asserteq_list [list 1 2] [list 1 2 3]};" + "assert_err {asserteq_list [list 1 2 3] [list 1 2]};" + "assert_err {asserteq_list [list 1 2 3] [list 1 2 4]};" + }, + {"downeval", + "proc grab-some-list {} {" + "set items {};" + "upeval {" + "foreach $some-list {" + "downeval 'append items $i'" + "}" + "};" + "return $items" + "};" + "set some-list [list foo bar baz blah moo boo];" + "asserteq_list $some-list [grab-some-list]" + }, + {"expr", + "asserteq 7 {1 + ( 2 * 3 )};" + "asserteq 7 {1+(2*3)};" + "asserteq -6 {1+ ~(2*3)};" + "asserteq -6 {1 + ~( 2 * 3 )};" + "asserteq -6 {1 +~ (2*3 )};" + "asserteq -6 {~(2*3)+1};" + "asserteq 0 {1*!(2+2)};" + "asserteq -1 {~!(!{})};" + "asserteq 1 {1 +~*(2*3)};" + "asserteq 1 {'hello'};" + "asserteq 0 {0};" + "asserteq 0 {{}};" + "asserteq 1 {()};" + "asserteq 1 {( )};" + "asserteq_str '' {[expr]};" + }, + {"factorial", + "proc fact {n} {" + "if {$n} {" + "expr {$n * [fact [expr {$n - 1}]]}" + "} {" + "return 1" + "}" + "};" + "asserteq 1 {[fact 0]};" + "asserteq 1 {[fact 1]};" + "asserteq 6 {[fact 3]};" + "asserteq 3628800 {[fact 10]};" + "asserteq 2432902008176640000 {[fact 20]}" + }, + {"filter", + "set short_procs [filter [reflect procs] {[length $x] < 5}];" + "foreach $short_procs {assert {[length $i] < 5}}" + }, + {"funcs", + "proc lapply {list proc} {" + "set ret {};" + "foreach $list {" + "append ret [$proc $i];" + "};" + "return $ret" + "};" + "set list [list {bad's day} {good's day} eh??];" + "asserteq_list [lapply $list split] [list " + "[list {bad's} day] " + "[list {good's} day] " + "[list eh??]" + "];" + "asserteq_list [lapply $list length] [list 9 10 4];" + "asserteq_list [lapply $list [proc {a} {" + "return [index [split $a] 0]" + "}]] [list {bad's} {good's} eh??]" + }, + {"lists", + "set l [list foo bar baz bad];" + "asserteq_str baz {[index $l 2]};" + "append l 'Hello, world!';" + "asserteq_list $l [list foo bar baz bad 'Hello, world!'];" + "set l [subst $l];" + "asserteq_list $l [list foo bar baz bad Hello, world!];" + "lmap $l foox barx bamia;" + "asserteq_str foo {$foox};" + "asserteq_str bar {$barx};" + "asserteq_str baz {$bamia};" + "set l {one # linebreaks are ignored in list parsing mode\n" + "\n" + "two;three # a semicolon still counts as line break\n" + " # (which in list mode is treated as a\n" + " # separator for list entries)\n" + "# of course a semicolon inside quotes is treated like normal\n" + "three';'and';a;half'\n" + "# like in code mode, a semicolon will stop the comment; four\n" + "\n" + "# below we have a quote, square brackets for inline\n" + "# expansions are still taken into consideration\n" + "[quote {this line will be ignored completely\n" + " as will this line and instead be replaced\n" + " with the 'five' below since while in code\n" + " mode (that is, inside the brackets here)\n" + " linebreaks are still processed}\n" + " quote five]\n" + "\n" + "# The curly brackets are also processed so the next three\n" + "# lines will show up as three separate lines\n" + "{six\n" + "seven\n" + "eight}}\n" + "asserteq_list $l [list one two three 'three;and;a;half' four " + "five 'six\nseven\neight'];" + }, + {"local", + "proc bits-for {x} {" + "local y bits;" + "set y 0 bits 0;" + "while {$y <= $x} {" + "incr bits;" + "set y [expr 1 << $bits]" + "};" + "return $bits" + "};" + "set y 1001;" + "set bits [bits-for $y];" + "set x 45;" + "set bitsx [bits-for $x];" + "asserteq 1001 {$y};" + "asserteq 10 {$bits};" + "asserteq 45 {$x};" + "asserteq 6 {$bitsx}" + }, + {"multiline comment", + "# this line will not be executed, but the following will\n" + "set ok1 1\n" + "## This is a multiline comment\n" + " which, as the name implies,\n" + " spans multiple lines.\n" + "set ok2 1\n" + " the code above wouldn't execute,\n" + " but this will --> ##set ok3 1\n" + "### more than two #s will not count as multiline comments\n" + "set ok4 1\n" + "# Note that semicolons can be used as linebreaks so\n" + "# this code will be executed: ; set ok5 1\n" + "##\n" + " ...however inside multiline comments semicolons do not\n" + " stop the comment section (pretty much like linebreaks)\n" + " and this code will not be executed: ; set ok6 1\n" + "##\n" + "# Also note that unlike in regular code, semicolons cannot\n" + "# be escaped in single-line comments, e.g.: ; set ok7 1\n" + "asserteq_str 1 {$ok1};" + "assert {![reflect has-var ok2]}" + "asserteq_str 1 {$ok3};" + "asserteq_str 1 {$ok4};" + "asserteq_str 1 {$ok5};" + "assert {![reflect has-var ok6]}" + "asserteq_str 1 {$ok7};" + }, + {"multiline code", + "asserteq_list [list hello \\n" + " world] [list hello world]" + }, + {"return", + "proc uses_return {} {" + "return 1;" + "return 0;" + "};" + "proc doesnt_use_return {} {" + "quote 1;" + "};" + "proc uses_result {} {" + "result 1;" + "quote 0;" + "};" + "assert {[uses_return]};" + "assert {[doesnt_use_return]};" + "assert {[uses_result]}" + }, + {"strings", + "set a 'This is a string';" + "set b 'This is another string';" + "asserteq 16 {[length $a]};" + "asserteq 22 {[length $b]};" + "asserteq_str a {[charat $a [expr [length $a] / 2]]};" + "asserteq_str t {[charat $b [expr [length $b] / 2]]};" + "asserteq 97 {[codeat $a [expr [length $a] / 2]]};" + "asserteq 116 {[codeat $b [expr [length $b] / 2]]};" + "asserteq 10 {[strpos $a string]};" + "asserteq 16 {[strpos $b string]};" + "asserteq -78 {[compare $a $b]};" + "assert {![streq $a $b]};" + "asserteq_str 'This is a foo' {[repstr $a string foo]};" + "asserteq_str 'This is another foo' {[repstr $b string foo]};" + "asserteq_list [split $a] [list This is a string];" + "asserteq_list [split $b] [list This is another string];" + }, + {"topeval", + "proc does-something {} {" + "topeval {" + "asserteq 10 {$x};" + "set x 42;" + "downeval {set y [expr $x * 10]}" + "};" + "asserteq 420 {$y}" + "};" + "proc calls-something {} {" + "local x;" + "set x 33;" + "does-something;" + "asserteq 33 {$x};" + "asserteq 420 {$y}" + "};" + "set x 10;" + "set y 20;" + "calls-something;" + "asserteq 42 {$x};" + "asserteq 420 {$y}" + }, + {"trim", + "set str ' Hello, world! ';" + "asserteq_str 'Hello, world!' {[trim $str]};" + "asserteq_str 'Hello, world! ' {[ltrim $str]};" + "asserteq_str ' Hello, world!' {[rtrim $str]};" + "asserteq_str 'Hello world' {[foreach [split $str] {" + "quote [trim $i {,!}]" + "}]};" + "asserteq_str 'Hello world' {[filter [split $str {,! }] {" + "[length $x] > 0" + "}]};" + }, +}; + +static int lib_test_lil(struct unit_test_state *uts) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(lil_tests); i++) { + const char *err_msg; + enum lil_error err; + struct lil *lil = lil_new(NULL); + + lil_free_value(lil_parse(lil, helpers, sizeof(helpers) - 1, 0)); + ut_asserteq(LIL_ERR_NONE, lil_error(lil, &err_msg)); + lil_free_value(lil_parse(lil, lil_tests[i].cmd, 0, 0)); + err = lil_error(lil, &err_msg); + if (err) { + ut_failf(uts, __FILE__, __LINE__, __func__, + lil_tests[i].name, "err=%d: %s", err, err_msg); + lil_free(lil); + return CMD_RET_FAILURE; + }; + lil_free(lil); + } + + return 0; +} +LIB_TEST(lib_test_lil, 0);

lil_append_val is just lil_append_string with the string and length taken from a struct lil_value. Use lil_append_stringh_len to implement both. Do the same for lil_clone_value.

Signed-off-by: Sean Anderson seanga2@gmail.com ---

common/cli_lil.c | 51 ++---------------------------------------------- 1 file changed, 2 insertions(+), 49 deletions(-)

diff --git a/common/cli_lil.c b/common/cli_lil.c index 6c05531441..5875fbd46b 100644 --- a/common/cli_lil.c +++ b/common/cli_lil.c @@ -369,39 +369,7 @@ static struct lil_value *alloc_value(const char *str)

struct lil_value *lil_clone_value(struct lil_value *src) { - struct lil_value *val; - - if (!src) - return NULL; - - if (IS_ENABLED(CONFIG_LIL_POOLS)) - val = alloc_from_pool(); - else - val = calloc(1, sizeof(struct lil_value)); - if (!val) - return NULL; - - val->l = src->l; - if (src->l) { - if (IS_ENABLED(CONFIG_LIL_POOLS)) { - ensure_capacity(val, val->l + 1); - } else { - val->d = malloc(val->l + 1); - if (!val->d) { - free(val); - return NULL; - } - } - memcpy(val->d, src->d, val->l + 1); - } else { - if (IS_ENABLED(CONFIG_LIL_POOLS)) { - ensure_capacity(val, 1); - val->d[0] = '\0'; - } else { - val->d = NULL; - } - } - return val; + return alloc_value_len(src->d, src->l); }

int lil_append_char(struct lil_value *val, char ch) @@ -450,22 +418,7 @@ int lil_append_string(struct lil_value *val, const char *s)

int lil_append_val(struct lil_value *val, struct lil_value *v) { - if (!v || !v->l) - return 1; - - if (IS_ENABLED(CONFIG_LIL_POOLS)) { - ensure_capacity(val, val->l + v->l + 1); - memcpy(val->d + val->l, v->d, v->l + 1); - } else { - char *new = realloc(val->d, val->l + v->l + 1); - - if (!new) - return 0; - memcpy(new + val->l, v->d, v->l + 1); - val->d = new; - } - val->l += v->l; - return 1; + return lil_append_string_len(val, v->d, v->l); }

void lil_free_value(struct lil_value *val)

This provides an easy way to enable assertions and debug messages. It will also be used to enable tracing features in future patches.

Signed-off-by: Sean Anderson seanga2@gmail.com ---

cmd/Kconfig | 6 ++++++ common/Makefile | 3 +++ 2 files changed, 9 insertions(+)

diff --git a/cmd/Kconfig b/cmd/Kconfig index 7c8962cfc2..bba72bbdc2 100644 --- a/cmd/Kconfig +++ b/cmd/Kconfig @@ -61,6 +61,12 @@ config LIL_RECLIMIT avoid call stack overflows and is also useful when running through an automated fuzzer like AFL. Set to 0 to disable the recursion limit.

+config LIL_DEBUG + bool "Enable LIL debugging" + help + This enables debug prints, assertions, and other tracing features in + LIL. If you are not working on LIL, say 'n' here. + endif

endif diff --git a/common/Makefile b/common/Makefile index dce04b305e..558e1932fe 100644 --- a/common/Makefile +++ b/common/Makefile @@ -11,6 +11,9 @@ obj-y += exports.o obj-$(CONFIG_HASH) += hash.o obj-$(CONFIG_HUSH_PARSER) += cli_hush.o obj-$(CONFIG_LIL) += cli_lil.o +ifneq ($(CONFIG_LIL_DEBUG),) +CFLAGS_cli_lil.o += -DDEBUG +endif obj-$(CONFIG_AUTOBOOT) += autoboot.o

# This option is not just y/n - it can have a numeric value

This allows callers of hwalk_r to pass data to their callback. This mirrors e.g. env_attr_walk.

Signed-off-by: Sean Anderson seanga2@gmail.com ---

cmd/nvedit.c | 8 ++++---- env/callback.c | 4 ++-- env/flags.c | 4 ++-- include/search.h | 2 +- lib/hashtable.c | 5 +++-- 5 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/cmd/nvedit.c b/cmd/nvedit.c index d14ba10cef..b855e502c0 100644 --- a/cmd/nvedit.c +++ b/cmd/nvedit.c @@ -481,7 +481,7 @@ static int print_static_binding(const char *var_name, const char *callback_name, return 0; }

-static int print_active_callback(struct env_entry *entry) +static int print_active_callback(struct env_entry *entry, void *priv) { struct env_clbk_tbl *clbkp; int i; @@ -544,7 +544,7 @@ int do_env_callback(struct cmd_tbl *cmdtp, int flag, int argc, puts("Active callback bindings:\n"); printf("\t%-20s %-20s\n", "Variable Name", "Callback Name"); printf("\t%-20s %-20s\n", "-------------", "-------------"); - hwalk_r(&env_htab, print_active_callback); + hwalk_r(&env_htab, print_active_callback, NULL); return 0; } #endif @@ -563,7 +563,7 @@ static int print_static_flags(const char *var_name, const char *flags, return 0; }

-static int print_active_flags(struct env_entry *entry) +static int print_active_flags(struct env_entry *entry, void *priv) { enum env_flags_vartype type; enum env_flags_varaccess access; @@ -617,7 +617,7 @@ int do_env_flags(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) "Variable Access"); printf("\t%-20s %-20s %-20s\n", "-------------", "-------------", "---------------"); - hwalk_r(&env_htab, print_active_flags); + hwalk_r(&env_htab, print_active_flags, NULL); return 0; } #endif diff --git a/env/callback.c b/env/callback.c index 638a02b28f..47075acb92 100644 --- a/env/callback.c +++ b/env/callback.c @@ -83,7 +83,7 @@ void env_callback_init(struct env_entry *var_entry) * Called on each existing env var prior to the blanket update since removing * a callback association should remove its callback. */ -static int clear_callback(struct env_entry *entry) +static int clear_callback(struct env_entry *entry, void *priv) { entry->callback = NULL;

@@ -127,7 +127,7 @@ static int on_callbacks(const char *name, const char *value, enum env_op op, int flags) { /* remove all callbacks */ - hwalk_r(&env_htab, clear_callback); + hwalk_r(&env_htab, clear_callback, NULL);

/* configure any static callback bindings */ env_attr_walk(ENV_CALLBACK_LIST_STATIC, set_callback, NULL); diff --git a/env/flags.c b/env/flags.c index e3e833c433..f2e36e3dd3 100644 --- a/env/flags.c +++ b/env/flags.c @@ -468,7 +468,7 @@ void env_flags_init(struct env_entry *var_entry) * Called on each existing env var prior to the blanket update since removing * a flag in the flag list should remove its flags. */ -static int clear_flags(struct env_entry *entry) +static int clear_flags(struct env_entry *entry, void *priv) { entry->flags = 0;

@@ -503,7 +503,7 @@ static int on_flags(const char *name, const char *value, enum env_op op, int flags) { /* remove all flags */ - hwalk_r(&env_htab, clear_flags); + hwalk_r(&env_htab, clear_flags, NULL);

/* configure any static flags */ env_attr_walk(ENV_FLAGS_LIST_STATIC, set_flags, NULL); diff --git a/include/search.h b/include/search.h index d0bb44388e..4a0828fb8d 100644 --- a/include/search.h +++ b/include/search.h @@ -105,7 +105,7 @@ int himport_r(struct hsearch_data *htab, const char *env, size_t size,

/* Walk the whole table calling the callback on each element */ int hwalk_r(struct hsearch_data *htab, - int (*callback)(struct env_entry *entry)); + int (*callback)(struct env_entry *entry, void *priv), void *priv);

/* Flags for himport_r(), hexport_r(), hdelete_r(), and hsearch_r() */ #define H_NOCLEAR (1 << 0) /* do not clear hash table before importing */ diff --git a/lib/hashtable.c b/lib/hashtable.c index ff5ff72639..425a880222 100644 --- a/lib/hashtable.c +++ b/lib/hashtable.c @@ -998,14 +998,15 @@ end: * Walk all of the entries in the hash, calling the callback for each one. * this allows some generic operation to be performed on each element. */ -int hwalk_r(struct hsearch_data *htab, int (*callback)(struct env_entry *entry)) +int hwalk_r(struct hsearch_data *htab, + int (*callback)(struct env_entry *entry, void *priv), void *priv) { int i; int retval;

for (i = 1; i <= htab->size; ++i) { if (htab->table[i].used > 0) { - retval = callback(&htab->table[i].entry); + retval = callback(&htab->table[i].entry, priv); if (retval) return retval; }

hm_put allocates memory, and this can fail. Instead of failing silently, return an error code. This also fixes up callers to handle this error.

Signed-off-by: Sean Anderson seanga2@gmail.com ---

common/cli_lil.c | 47 ++++++++++++++++++++++++++++++++--------------- 1 file changed, 32 insertions(+), 15 deletions(-)

diff --git a/common/cli_lil.c b/common/cli_lil.c index 2ed96ebc2d..7ec73675f3 100644 --- a/common/cli_lil.c +++ b/common/cli_lil.c @@ -326,22 +326,30 @@ static void hm_destroy(struct hashmap *hm) } }

-static void hm_put(struct hashmap *hm, const char *key, void *value) +static enum lil_error hm_put(struct hashmap *hm, const char *key, void *value) { struct hashcell *cell = hm->cell + (hm_hash(key) & HASHMAP_CELLMASK); + struct hashentry *newe; size_t i;

for (i = 0; i < cell->c; i++) { if (!strcmp(key, cell->e[i].k)) { cell->e[i].v = value; - return; + return LIL_ERR_NONE; } }

- cell->e = realloc(cell->e, sizeof(struct hashentry) * (cell->c + 1)); - cell->e[cell->c].k = strdup(key); - cell->e[cell->c].v = value; + newe = realloc(cell->e, sizeof(struct hashentry) * (cell->c + 1)); + if (!newe) + return LIL_ERR_OOM; + cell->e = newe; + + newe[cell->c].k = strdup(key); + if (!newe[cell->c].k) + return LIL_ERR_OOM; + newe[cell->c].v = value; cell->c++; + return LIL_ERR_NONE; }

static void *hm_get(struct hashmap *hm, const char *key) @@ -738,19 +746,24 @@ static struct lil_func *add_func(struct lil *lil, const char *name)

cmd = calloc(1, sizeof(struct lil_func)); if (!cmd) - return NULL; + goto oom; cmd->name = strdup(name);

ncmd = realloc(lil->cmd, sizeof(struct lil_func *) * (lil->cmds + 1)); - if (!ncmd) { - free(cmd); - return NULL; - } - + if (!ncmd) + goto oom; lil->cmd = ncmd; + ncmd[lil->cmds++] = cmd; - hm_put(&lil->cmdmap, name, cmd); + if (hm_put(&lil->cmdmap, name, cmd)) + goto oom; + return cmd; + +oom: + free(cmd); + lil_set_error_oom(lil); + return NULL; }

static void del_func(struct lil *lil, struct lil_func *cmd) @@ -766,7 +779,11 @@ static void del_func(struct lil *lil, struct lil_func *cmd) if (index == lil->cmds) return;

- hm_put(&lil->cmdmap, cmd->name, 0); + /* + * The only way this fails is if we don't find the command; this + * means our caller wants to delete a command which doesn't exist + */ + assert(!hm_put(&lil->cmdmap, cmd->name, NULL)); if (cmd->argnames) lil_free_list(cmd->argnames);

@@ -783,9 +800,9 @@ int lil_register(struct lil *lil, const char *name, lil_func_proc_t proc) struct lil_func *cmd = add_func(lil, name);

if (!cmd) - return 0; + return LIL_ERR_OOM; cmd->proc = proc; - return 1; + return LIL_ERR_NONE; }

struct lil_var *lil_set_var(struct lil *lil, const char *name,

This function took an argument do_quote which determined whether or not to quote an item. All callers set it to true, so remove it and always quote.

Signed-off-by: Sean Anderson seanga2@gmail.com ---

common/cli_lil.c | 34 ++++++++++++++-------------------- include/cli_lil.h | 2 +- 2 files changed, 15 insertions(+), 21 deletions(-)

diff --git a/common/cli_lil.c b/common/cli_lil.c index 1c7c340bda..153c34791b 100644 --- a/common/cli_lil.c +++ b/common/cli_lil.c @@ -2092,7 +2092,7 @@ static struct lil_value *run_cmd(struct lil *lil, struct lil_func *cmd, if (cmd->argnames->c == 1 && !strcmp(lil_to_string(lil_list_get(cmd->argnames, 0)), "args")) { - struct lil_value *args = lil_list_to_value(words, 1); + struct lil_value *args = lil_list_to_value(words);

lil_set_var(lil, "args", args, LIL_SETVAR_LOCAL_NEW); lil_free_value(args); @@ -2389,7 +2389,7 @@ braces: return needs; }

-struct lil_value *lil_list_to_value(struct lil_list *list, bool do_escape) +struct lil_value *lil_list_to_value(struct lil_list *list) { struct lil_value *val = alloc_value(NULL); size_t i, j; @@ -2397,17 +2397,11 @@ struct lil_value *lil_list_to_value(struct lil_list *list, bool do_escape) for (i = 0; i < list->c; i++) { char q; struct lil_value *item = lil_list_get(list, i); - enum needs needs; - - if (do_escape) - needs = item_needs(lil_to_string(item), item->l); - else - needs = NEEDS_NOTHING;

if (i) lil_append_char(val, ' ');

- switch (needs) { + switch (item_needs(lil_to_string(item), item->l)) { case NEEDS_NOTHING: if (lil_append_val(val, item)) goto err; @@ -3087,7 +3081,7 @@ static struct lil_value *fnc_reflect(struct lil *lil, size_t argc, func = lil_find_cmd(lil, lil_to_string(argv[1])); if (!func || !func->argnames) return NULL; - return lil_list_to_value(func->argnames, 1); + return lil_list_to_value(func->argnames); }

if (!strcmp(type, "body")) { @@ -3111,7 +3105,7 @@ static struct lil_value *fnc_reflect(struct lil *lil, size_t argc, lil_list_append(funcs, lil_alloc_string(lil->cmd[i]->name));

- r = lil_list_to_value(funcs, 1); + r = lil_list_to_value(funcs); lil_free_list(funcs); return r; } @@ -3130,7 +3124,7 @@ static struct lil_value *fnc_reflect(struct lil *lil, size_t argc, env = env->parent; }

- r = lil_list_to_value(vars, 1); + r = lil_list_to_value(vars); lil_free_list(vars); return r; } @@ -3145,7 +3139,7 @@ static struct lil_value *fnc_reflect(struct lil *lil, size_t argc, lil_list_append(vars, var); }

- r = lil_list_to_value(vars, 1); + r = lil_list_to_value(vars); lil_free_list(vars); return r; } @@ -3513,7 +3507,7 @@ static struct lil_value *fnc_append(struct lil *lil, size_t argc, for (i = base; i < argc; i++) lil_list_append(list, lil_clone_value(argv[i]));

- r = lil_list_to_value(list, 1); + r = lil_list_to_value(list); lil_free_list(list); lil_set_var(lil, varname, r, access); return r; @@ -3548,7 +3542,7 @@ static struct lil_value *fnc_slice(struct lil *lil, size_t argc, lil_list_append(slice, lil_clone_value(lil_list_get(list, i))); lil_free_list(list);

- r = lil_list_to_value(slice, 1); + r = lil_list_to_value(slice); lil_free_list(slice); return r; } @@ -3586,7 +3580,7 @@ static struct lil_value *fnc_filter(struct lil *lil, size_t argc, } lil_free_list(list);

- r = lil_list_to_value(filtered, 1); + r = lil_list_to_value(filtered); lil_free_list(filtered); return r; } @@ -3601,7 +3595,7 @@ static struct lil_value *fnc_list(struct lil *lil, size_t argc, for (i = 0; i < argc; i++) lil_list_append(list, lil_clone_value(argv[i]));

- r = lil_list_to_value(list, 1); + r = lil_list_to_value(list); lil_free_list(list); return r; } @@ -3628,7 +3622,7 @@ static struct lil_value *fnc_concat(struct lil *lil, size_t argc, r = lil_alloc_string(""); for (i = 0; i < argc; i++) { list = lil_subst_to_list(lil, argv[i]); - tmp = lil_list_to_value(list, 1); + tmp = lil_list_to_value(list); lil_free_list(list); lil_append_val(r, tmp); lil_free_value(tmp); @@ -3672,7 +3666,7 @@ static struct lil_value *fnc_foreach(struct lil *lil, size_t argc, break; }

- r = lil_list_to_value(rlist, 1); + r = lil_list_to_value(rlist); lil_free_list(list); lil_free_list(rlist); return r; @@ -4147,7 +4141,7 @@ static struct lil_value *fnc_split(struct lil *lil, size_t argc, }

lil_list_append(list, val); - val = lil_list_to_value(list, 1); + val = lil_list_to_value(list); lil_free_list(list); return val; } diff --git a/include/cli_lil.h b/include/cli_lil.h index 290329372a..6fbc270f1b 100644 --- a/include/cli_lil.h +++ b/include/cli_lil.h @@ -161,7 +161,7 @@ void lil_free_list(struct lil_list *list); int lil_list_append(struct lil_list *list, void *item); size_t lil_list_size(struct lil_list *list); struct lil_value *lil_list_get(struct lil_list *list, size_t index); -struct lil_value *lil_list_to_value(struct lil_list *list, bool do_escape); +struct lil_value *lil_list_to_value(struct lil_list *list);

struct lil_list *lil_subst_to_list(struct lil *lil, struct lil_value *code); struct lil_value *lil_subst_to_value(struct lil *lil, struct lil_value *code);

This allows us to convert lil_values into a form which can be re-parsed. We were already doing this for lists, so we just have to expose the inner loop.

Signed-off-by: Sean Anderson seanga2@gmail.com ---

common/cli_lil.c | 89 ++++++++++++++++++++++++++++-------------------- 1 file changed, 52 insertions(+), 37 deletions(-)

diff --git a/common/cli_lil.c b/common/cli_lil.c index 42659920b5..2a8600ffb6 100644 --- a/common/cli_lil.c +++ b/common/cli_lil.c @@ -2387,49 +2387,64 @@ braces: return needs; }

+static enum lil_error do_quote(struct lil_value *val, struct lil_value *item) +{ + char q; + size_t i; + + switch (item_needs(lil_to_string(item), item->l)) { + case NEEDS_NOTHING: + return lil_append_val(val, item); + case NEEDS_BRACES: + return lil_append_char(val, '{') ?: + lil_append_val(val, item) ?: + lil_append_char(val, '}'); + case NEEDS_DOUBLE: + q = '"'; + goto quote; + case NEEDS_SINGLE: + q = '''; +quote: + if (lil_append_char(val, q)) + return LIL_ERR_OOM; + + for (i = 0; i < item->l; i++) { + char c = item->d[i]; + + if (c == '\' || c == q) + if (lil_append_char(val, '\')) + return LIL_ERR_OOM; + if (lil_append_char(val, c)) + return LIL_ERR_OOM; + } + if (lil_append_char(val, q)) + return LIL_ERR_OOM; + } + return LIL_ERR_NONE; +} + +static struct lil_value *lil_quote_value(struct lil_value *val) +{ + struct lil_value *r = alloc_value(NULL); + + if (do_quote(r, val)) { + lil_free_value(r); + return NULL; + } + return r; +} + struct lil_value *lil_list_to_value(struct lil_list *list) { struct lil_value *val = alloc_value(NULL); - size_t i, j; + size_t i;

for (i = 0; i < list->c; i++) { - char q; - struct lil_value *item = lil_list_get(list, i); + if (i && lil_append_char(val, ' ')) + goto err;

- if (i) - lil_append_char(val, ' '); - - switch (item_needs(lil_to_string(item), item->l)) { - case NEEDS_NOTHING: - if (lil_append_val(val, item)) - goto err; - continue; - case NEEDS_BRACES: - if (lil_append_char(val, '{') || - lil_append_val(val, item) || - lil_append_char(val, '}')) - goto err; - continue; - case NEEDS_DOUBLE: - q = '"'; - goto quote; - case NEEDS_SINGLE: - q = '''; -quote: - if (lil_append_char(val, q)) - goto err; - for (j = 0; j < item->l; j++) { - char c = item->d[j]; - - if (c == '\' || c == q) - if (lil_append_char(val, '\')) - goto err; - if (lil_append_char(val, c)) - goto err; - } - if (lil_append_char(val, q)) - goto err; - } + if (do_quote(val, lil_list_get(list, i))) + goto err; } return val;