rename sauer to cubescript

--HG--
rename : tests/sauer/README => tests/cubescript/README
rename : tests/sauer/command.cpp => tests/cubescript/command.cpp
rename : tests/sauer/command.h => tests/cubescript/command.h
rename : tests/sauer/tools.h => tests/cubescript/tools.h

4 files changed, 2541 insertions, 0 deletions

diff --git a/tests/cubescript/README b/tests/cubescript/README
new file mode 100644
index 00000000..c3a09528
--- /dev/null
+++ b/tests/cubescript/README
@@ -0,0 +1,32 @@
+This directory contains files from Sauerbraten/Cube 2, http://sauerbraten.org/, whose license is:
+
+Sauerbraten source code license, usage, and documentation.
+
+You may use the Sauerbraten source code if you abide by the ZLIB license
+http://www.opensource.org/licenses/zlib-license.php
+(very similar to the BSD license):
+
+
+LICENSE
+=======
+
+Sauerbraten game engine source code, any release.
+
+Copyright (C) 2001-2010 Wouter van Oortmerssen, Lee Salzman, Mike Dysart, Robert Pointon, and Quinton Reeves
+
+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.
+
diff --git a/tests/cubescript/command.cpp b/tests/cubescript/command.cpp
new file mode 100644
index 00000000..cfd3d116
--- /dev/null
+++ b/tests/cubescript/command.cpp
@@ -0,0 +1,1427 @@
+// command.cpp: implements the parsing and execution of a tiny script language which
+// is largely backwards compatible with the quake console language.
+
+// XXX Emscripten: changed all sizeof to ES_SIZEOF
+
+// XXX Emscripten
+  #define STANDALONE
+
+  #include "limits.h"
+  #include "stdarg.h"
+  #include "string.h"
+  #include "stdio.h"
+  #include "stdlib.h"
+  #include "ctype.h"
+  #include "math.h"
+  #include "time.h"
+  #include <new>
+
+  #include "tools.h"
+  #include "command.h"
+
+  // console
+  enum
+  {
+      CON_INFO  = 1<<0,
+      CON_WARN  = 1<<1,
+      CON_ERROR = 1<<2,
+      CON_DEBUG = 1<<3,
+      CON_INIT  = 1<<4,
+      CON_ECHO  = 1<<5
+  };
+  extern void conoutf(const char *s, ...);
+  extern void conoutf(int type, const char *s, ...);
+
+  // command
+  extern int variable(const char *name, int min, int cur, int max, int *storage, void (*fun)(), int flags);
+  extern float fvariable(const char *name, float min, float cur, float max, float *storage, void (*fun)(), int flags);
+  extern char *svariable(const char *name, const char *cur, char **storage, void (*fun)(), int flags);
+  extern void setvar(const char *name, int i, bool dofunc = true, bool doclamp = true);
+  extern void setfvar(const char *name, float f, bool dofunc = true, bool doclamp = true);
+  extern void setsvar(const char *name, const char *str, bool dofunc = true);
+  extern void setvarchecked(ident *id, int val);
+  extern void setfvarchecked(ident *id, float val);
+  extern void setsvarchecked(ident *id, const char *val);
+  extern void touchvar(const char *name);
+  extern int getvar(const char *name);
+  extern int getvarmin(const char *name);
+  extern int getvarmax(const char *name);
+  extern bool identexists(const char *name);
+  extern ident *getident(const char *name);
+  extern ident *newident(const char *name);
+  extern bool addcommand(const char *name, void (*fun)(), const char *narg);
+  extern int execute(const char *p);
+  extern char *executeret(const char *p);
+  extern bool execfile(const char *cfgfile, bool msg = true);
+  extern void alias(const char *name, const char *action);
+  extern const char *getalias(const char *name);
+
+  // main
+  extern void fatal(const char *s, ...);
+
+  extern char *path(char *s);
+  extern char *path(const char *s, bool copy);
+  extern const char *parentdir(const char *directory);
+  extern bool fileexists(const char *path, const char *mode);
+  extern bool createdir(const char *path);
+  extern size_t fixpackagedir(char *dir);
+  extern void sethomedir(const char *dir);
+  extern void addpackagedir(const char *dir);
+  extern const char *findfile(const char *filename, const char *mode);
+  extern stream *openrawfile(const char *filename, const char *mode);
+  extern stream *openzipfile(const char *filename, const char *mode);
+  extern stream *openfile(const char *filename, const char *mode);
+  extern stream *opentempfile(const char *filename, const char *mode);
+  extern char *loadfile(const char *fn, int *size);
+  extern bool listdir(const char *dir, const char *ext, vector<char *> &files);
+  extern int listfiles(const char *dir, const char *ext, vector<char *> &files);
+  extern int listzipfiles(const char *dir, const char *ext, vector<char *> &files);
+  extern void seedMT(uint seed);
+  extern uint randomMT(void);
+// XXX =========================
+
+char *exchangestr(char *o, const char *n) { delete[] o; return newstring(n); }
+
+typedef hashtable<const char *, ident> identtable;
+
+identtable *idents = NULL;        // contains ALL vars/commands/aliases
+
+bool overrideidents = false, persistidents = true;
+
+void clearstack(ident &id)
+{
+    identstack *stack = id.stack;
+    while(stack)
+    {
+        delete[] stack->action;
+        identstack *tmp = stack;
+        stack = stack->next;
+        delete tmp;
+    }
+    id.stack = NULL;
+}
+
+void clear_command()
+{
+    enumerate(*idents, ident, i, if(i.type==ID_ALIAS) { DELETEA(i.name); DELETEA(i.action); if(i.stack) clearstack(i); });
+    if(idents) idents->clear();
+}
+
+void clearoverride(ident &i)
+{
+    if(i.override==NO_OVERRIDE) return;
+    switch(i.type)
+    {
+        case ID_ALIAS:
+            if(i.action[0])
+            {
+                if(i.action != i.isexecuting) delete[] i.action;
+                i.action = newstring("");
+            }
+            break;
+        case ID_VAR:
+            *i.storage.i = i.overrideval.i;
+            i.changed();
+            break;
+        case ID_FVAR:
+            *i.storage.f = i.overrideval.f;
+            i.changed();
+            break;
+        case ID_SVAR:
+            delete[] *i.storage.s;
+            *i.storage.s = i.overrideval.s;
+            i.changed();
+            break;
+    }
+    i.override = NO_OVERRIDE;
+}
+
+void clearoverrides()
+{
+    enumerate(*idents, ident, i, clearoverride(i));
+}
+
+void pushident(ident &id, char *val)
+{
+    if(id.type != ID_ALIAS) return;
+    identstack *stack = new identstack;
+    stack->action = id.isexecuting==id.action ? newstring(id.action) : id.action;
+    stack->next = id.stack;
+    id.stack = stack;
+    id.action = val;
+}
+
+void popident(ident &id)
+{
+    if(id.type != ID_ALIAS || !id.stack) return;
+    if(id.action != id.isexecuting) delete[] id.action;
+    identstack *stack = id.stack;
+    id.action = stack->action;
+    id.stack = stack->next;
+    delete stack;
+}
+
+ident *newident(const char *name)
+{
+    ident *id = idents->access(name);
+    if(!id)
+    {
+        ident init(ID_ALIAS, newstring(name), newstring(""), persistidents ? IDF_PERSIST : 0);
+        id = &idents->access(init.name, init);
+    }
+    return id;
+}
+
+void pusha(const char *name, char *action)
+{
+    pushident(*newident(name), action);
+}
+
+void push(char *name, char *action)
+{
+    pusha(name, newstring(action));
+}
+
+void pop(char *name)
+{
+    ident *id = idents->access(name);
+    if(id) popident(*id);
+}
+
+void resetvar(char *name)
+{
+    ident *id = idents->access(name);
+    if(!id) return;
+    if(id->flags&IDF_READONLY) conoutf(CON_ERROR, "variable %s is read-only", id->name);
+    else clearoverride(*id);
+}
+
+COMMAND(push, "ss");
+COMMAND(pop, "s");
+COMMAND(resetvar, "s");
+
+void aliasa(const char *name, char *action)
+{
+    ident *b = idents->access(name);
+    if(!b)
+    {
+        ident b(ID_ALIAS, newstring(name), action, persistidents ? IDF_PERSIST : 0);
+        if(overrideidents) b.override = OVERRIDDEN;
+        idents->access(b.name, b);
+    }
+    else if(b->type != ID_ALIAS)
+    {
+        conoutf(CON_ERROR, "cannot redefine builtin %s with an alias", name);
+        delete[] action;
+    }
+    else
+    {
+        if(b->action != b->isexecuting) delete[] b->action;
+        b->action = action;
+        if(overrideidents) b->override = OVERRIDDEN;
+        else
+        {
+            if(b->override != NO_OVERRIDE) b->override = NO_OVERRIDE;
+            if(persistidents)
+            {
+                if(!(b->flags & IDF_PERSIST)) b->flags |= IDF_PERSIST;
+            }
+            else if(b->flags & IDF_PERSIST) b->flags &= ~IDF_PERSIST;
+        }
+    }
+}
+
+void alias(const char *name, const char *action) { aliasa(name, newstring(action)); }
+
+COMMAND(alias, "ss");
+
+// variable's and commands are registered through globals, see cube.h
+
+int variable(const char *name, int min, int cur, int max, int *storage, void (*fun)(), int flags)
+{
+    if(!idents) idents = new identtable;
+    ident v(ID_VAR, name, min, cur, max, storage, (void *)fun, flags);
+    idents->access(name, v);
+    return cur;
+}
+
+float fvariable(const char *name, float min, float cur, float max, float *storage, void (*fun)(), int flags)
+{
+    if(!idents) idents = new identtable;
+    ident v(ID_FVAR, name, min, cur, max, storage, (void *)fun, flags);
+    idents->access(name, v);
+    return cur;
+}
+
+char *svariable(const char *name, const char *cur, char **storage, void (*fun)(), int flags)
+{
+    if(!idents) idents = new identtable;
+    ident v(ID_SVAR, name, newstring(cur), storage, (void *)fun, flags);
+    idents->access(name, v);
+    return v.val.s;
+}
+
+#define _GETVAR(id, vartype, name, retval) \
+    ident *id = idents->access(name); \
+    if(!id || id->type!=vartype) return retval;
+#define GETVAR(id, name, retval) _GETVAR(id, ID_VAR, name, retval)
+#define OVERRIDEVAR(errorval, saveval, resetval, clearval) \
+    if(overrideidents || id->flags&IDF_OVERRIDE) \
+    { \
+        if(id->flags&IDF_PERSIST) \
+        { \
+            conoutf(CON_ERROR, "cannot override persistent variable %s", id->name); \
+            errorval; \
+        } \
+        if(id->override==NO_OVERRIDE) { saveval; id->override = OVERRIDDEN; } \
+        else { clearval; } \
+    } \
+    else \
+    { \
+        if(id->override!=NO_OVERRIDE) { resetval; id->override = NO_OVERRIDE; } \
+        clearval; \
+    }
+
+void setvar(const char *name, int i, bool dofunc, bool doclamp)
+{
+    GETVAR(id, name, );
+    OVERRIDEVAR(return, id->overrideval.i = *id->storage.i, , )
+    if(doclamp) *id->storage.i = clamp(i, id->minval, id->maxval);
+    else *id->storage.i = i;
+    if(dofunc) id->changed();
+}
+void setfvar(const char *name, float f, bool dofunc, bool doclamp)
+{
+    _GETVAR(id, ID_FVAR, name, );
+    OVERRIDEVAR(return, id->overrideval.f = *id->storage.f, , );
+    if(doclamp) *id->storage.f = clamp(f, id->minvalf, id->maxvalf);
+    else *id->storage.f = f;
+    if(dofunc) id->changed();
+}
+void setsvar(const char *name, const char *str, bool dofunc)
+{
+    _GETVAR(id, ID_SVAR, name, );
+    OVERRIDEVAR(return, id->overrideval.s = *id->storage.s, delete[] id->overrideval.s, delete[] *id->storage.s);
+    *id->storage.s = newstring(str);
+    if(dofunc) id->changed();
+}
+int getvar(const char *name)
+{
+    GETVAR(id, name, 0);
+    return *id->storage.i;
+}
+int getvarmin(const char *name)
+{
+    GETVAR(id, name, 0);
+    return id->minval;
+}
+int getvarmax(const char *name)
+{
+    GETVAR(id, name, 0);
+    return id->maxval;
+}
+bool identexists(const char *name) { return idents->access(name)!=NULL; }
+ident *getident(const char *name) { return idents->access(name); }
+
+void touchvar(const char *name)
+{
+    ident *id = idents->access(name);
+    if(id) switch(id->type)
+    {
+        case ID_VAR:
+        case ID_FVAR:
+        case ID_SVAR:
+            id->changed();
+            break;
+    }
+}
+
+const char *getalias(const char *name)
+{
+    ident *i = idents->access(name);
+    return i && i->type==ID_ALIAS ? i->action : "";
+}
+
+void setvarchecked(ident *id, int val)
+{
+    if(id->flags&IDF_READONLY) conoutf(CON_ERROR, "variable %s is read-only", id->name);
+#ifndef STANDALONE
+    else if(!(id->flags&IDF_OVERRIDE) || overrideidents || game::allowedittoggle())
+#else
+    else
+#endif
+    {
+        OVERRIDEVAR(return, id->overrideval.i = *id->storage.i, , )
+        if(val<id->minval || val>id->maxval)
+        {
+            val = val<id->minval ? id->minval : id->maxval;                // clamp to valid range
+            conoutf(CON_ERROR,
+                id->flags&IDF_HEX ?
+                    (id->minval <= 255 ? "valid range for %s is %d..0x%X" : "valid range for %s is 0x%X..0x%X") :
+                    "valid range for %s is %d..%d",
+                id->name, id->minval, id->maxval);
+        }
+        *id->storage.i = val;
+        id->changed();                                             // call trigger function if available
+#ifndef STANDALONE
+        if(id->flags&IDF_OVERRIDE && !overrideidents) game::vartrigger(id);
+#endif
+    }
+}
+
+void setfvarchecked(ident *id, float val)
+{
+    if(id->flags&IDF_READONLY) conoutf(CON_ERROR, "variable %s is read-only", id->name);
+#ifndef STANDALONE
+    else if(!(id->flags&IDF_OVERRIDE) || overrideidents || game::allowedittoggle())
+#else
+    else
+#endif
+    {
+        OVERRIDEVAR(return, id->overrideval.f = *id->storage.f, , );
+        if(val<id->minvalf || val>id->maxvalf)
+        {
+            val = val<id->minvalf ? id->minvalf : id->maxvalf;                // clamp to valid range
+            conoutf(CON_ERROR, "valid range for %s is %s..%s", id->name, floatstr(id->minvalf), floatstr(id->maxvalf));
+        }
+        *id->storage.f = val;
+        id->changed();
+#ifndef STANDALONE
+        if(id->flags&IDF_OVERRIDE && !overrideidents) game::vartrigger(id);
+#endif
+    }
+}
+
+void setsvarchecked(ident *id, const char *val)
+{
+    if(id->flags&IDF_READONLY) conoutf(CON_ERROR, "variable %s is read-only", id->name);
+#ifndef STANDALONE
+    else if(!(id->flags&IDF_OVERRIDE) || overrideidents || game::allowedittoggle())
+#else
+    else
+#endif
+    {
+        OVERRIDEVAR(return, id->overrideval.s = *id->storage.s, delete[] id->overrideval.s, delete[] *id->storage.s);
+        *id->storage.s = newstring(val);
+        id->changed();
+#ifndef STANDALONE
+        if(id->flags&IDF_OVERRIDE && !overrideidents) game::vartrigger(id);
+#endif
+    }
+}
+
+bool addcommand(const char *name, void (*fun)(), const char *narg)
+{
+    if(!idents) idents = new identtable;
+    ident c(ID_COMMAND, name, narg, (void *)fun);
+    idents->access(name, c);
+    return false;
+}
+
+void addident(const char *name, ident *id)
+{
+    if(!idents) idents = new identtable;
+    idents->access(name, *id);
+}
+
+static vector<vector<char> *> wordbufs;
+static int bufnest = 0;
+
+char *parseexp(const char *&p, int right);
+
+void parsemacro(const char *&p, int level, vector<char> &wordbuf)
+{
+    int escape = 1;
+    while(*p=='@') p++, escape++;
+    if(level > escape)
+    {
+        while(escape--) wordbuf.add('@');
+        return;
+    }
+    if(*p=='(')
+    {
+        char *ret = parseexp(p, ')');
+        if(ret)
+        {
+            for(char *sub = ret; *sub; ) wordbuf.add(*sub++);
+            delete[] ret;
+        }
+        return;
+    }
+    static vector<char> ident;
+    ident.setsize(0);
+    while(isalnum(*p) || *p=='_') ident.add(*p++);
+    ident.add(0);
+    const char *alias = getalias(ident.getbuf());
+    while(*alias) wordbuf.add(*alias++);
+}
+
+const char *parsestring(const char *p)
+{
+    for(; *p; p++) switch(*p)
+    {
+        case '\r':
+        case '\n':
+        case '\"':
+            return p;
+        case '^':
+            if(*++p) break;
+            return p;
+    }
+    return p;
+}
+
+int escapestring(char *dst, const char *src, const char *end)
+{
+    char *start = dst;
+    while(src < end)
+    {
+        int c = *src++;
+        if(c == '^')
+        {
+            if(src >= end) break;
+            int e = *src++;
+            switch(e)
+            {
+                case 'n': *dst++ = '\n'; break;
+                case 't': *dst++ = '\t'; break;
+                case 'f': *dst++ = '\f'; break;
+                default: *dst++ = e; break;
+            }
+        }
+        else *dst++ = c;
+    }
+    return dst - start;
+}
+
+char *parseexp(const char *&p, int right)          // parse any nested set of () or []
+{
+    if(bufnest++>=wordbufs.length()) wordbufs.add(new vector<char>);
+    vector<char> &wordbuf = *wordbufs[bufnest-1];
+    int left = *p++;
+    for(int brak = 1; brak; )
+    {
+        size_t n = strcspn(p, "\r@\"/()[]");
+        wordbuf.put(p, n);
+        p += n;
+
+        int c = *p++;
+        switch(c)
+        {
+            case '\r': continue;
+            case '@':
+                if(left == '[') { parsemacro(p, brak, wordbuf); continue; }
+                break;
+            case '\"':
+            {
+                wordbuf.add(c);
+                const char *end = parsestring(p);
+                wordbuf.put(p, end - p);
+                p = end;
+                if(*p=='\"') wordbuf.add(*p++);
+                continue;
+            }
+            case '/':
+                if(*p=='/')
+                {
+                    p += strcspn(p, "\n\0");
+                    continue;
+                }
+                break;
+            case '\0':
+                p--;
+                conoutf(CON_ERROR, "missing \"%c\"", right);
+                wordbuf.setsize(0);
+                bufnest--;
+                return NULL;
+            case '(': case '[': if(c==left) brak++; break;
+            case ')': case ']': if(c==right) brak--; break;
+        }
+        wordbuf.add(c);
+    }
+    wordbuf.pop();
+    char *s;
+    if(left=='(')
+    {
+        wordbuf.add(0);
+        char *ret = executeret(wordbuf.getbuf());                    // evaluate () exps directly, and substitute result
+        wordbuf.pop();
+        s = ret ? ret : newstring("");
+    }
+    else
+    {
+        s = newstring(wordbuf.getbuf(), wordbuf.length());
+    }
+    wordbuf.setsize(0);
+    bufnest--;
+    return s;
+}
+
+char *lookup(char *n)                           // find value of ident referenced with $ in exp
+{
+    ident *id = idents->access(n+1);
+    if(id) switch(id->type)
+    {
+        case ID_VAR: return exchangestr(n, intstr(*id->storage.i));
+        case ID_FVAR: return exchangestr(n, floatstr(*id->storage.f));
+        case ID_SVAR: return exchangestr(n, *id->storage.s);
+        case ID_ALIAS: return exchangestr(n, id->action);
+    }
+    conoutf(CON_ERROR, "unknown alias lookup: %s", n+1);
+    return n;
+}
+
+char *parseword(const char *&p, int arg, int &infix)                       // parse single argument, including expressions
+{
+    for(;;)
+    {
+        p += strspn(p, " \t\r");
+        if(p[0]!='/' || p[1]!='/') break;
+        p += strcspn(p, "\n\0");
+    }
+    if(*p=='\"')
+    {
+        p++;
+        const char *end = parsestring(p);
+        char *s = newstring(end - p);
+        s[escapestring(s, p, end)] = '\0';
+        p = end;
+        if(*p=='\"') p++;
+        return s;
+    }
+    if(*p=='(') return parseexp(p, ')');
+    if(*p=='[') return parseexp(p, ']');
+    const char *word = p;
+    for(;;)
+    {
+        p += strcspn(p, "/; \t\r\n\0");
+        if(p[0]!='/' || p[1]=='/') break;
+        else if(p[1]=='\0') { p++; break; }
+        p += 2;
+    }
+    if(p-word==0) return NULL;
+    if(arg==1 && p-word==1) switch(*word)
+    {
+        case '=': infix = *word; break;
+    }
+    char *s = newstring(word, p-word);
+    if(*s=='$') return lookup(s);               // substitute variables
+    return s;
+}
+
+char *conc(char **w, int n, bool space)
+{
+    int len = space ? max(n-1, 0) : 0;
+    loopj(n) len += (int)strlen(w[j]);
+    char *r = newstring("", len);
+    loopi(n)
+    {
+        strcat(r, w[i]);  // make string-list out of all arguments
+        if(i==n-1) break;
+        if(space) strcat(r, " ");
+    }
+    return r;
+}
+
+VARN(numargs, _numargs, 25, 0, 0);
+
+static inline bool isinteger(char *c)
+{
+    return isdigit(c[0]) || ((c[0]=='+' || c[0]=='-' || c[0]=='.') && isdigit(c[1]));
+}
+
+char *commandret = NULL;
+
+char *executeret(const char *p)               // all evaluation happens here, recursively
+{
+    const int MAXWORDS = 25;                    // limit, remove
+    char *w[MAXWORDS];
+    char *retval = NULL;
+    #define setretval(v) { char *rv = v; if(rv) retval = rv; }
+    for(bool cont = true; cont;)                // for each ; seperated statement
+    {
+        int numargs = MAXWORDS, infix = 0;
+        loopi(MAXWORDS)                         // collect all argument values
+        {
+            w[i] = parseword(p, i, infix);   // parse and evaluate exps
+            if(!w[i]) { numargs = i; break; }
+        }
+
+        p += strcspn(p, ";\n\0");
+        cont = *p++!=0;                         // more statements if this isn't the end of the string
+        char *c = w[0];
+        if(!c || !*c) continue;                       // empty statement
+
+        DELETEA(retval);
+
+        if(infix)
+        {
+            switch(infix)
+            {
+                case '=':
+                    aliasa(c, numargs>2 ? w[2] : newstring(""));
+                    w[2] = NULL;
+                    break;
+            }
+        }
+        else
+        {
+            ident *id = idents->access(c);
+            if(!id)
+            {
+                if(!isinteger(c))
+                    conoutf(CON_ERROR, "unknown command: %s", c);
+                setretval(newstring(c));
+            }
+            else switch(id->type)
+            {
+                case ID_CCOMMAND:
+                case ID_COMMAND:                     // game defined commands
+                {
+                    void *v[MAXWORDS];
+                    union
+                    {
+                        int i;
+                        float f;
+                    } nstor[MAXWORDS];
+                    int n = 0, wn = 0;
+                    char *cargs = NULL;
+                    if(id->type==ID_CCOMMAND) v[n++] = id->self;
+                    for(const char *a = id->narg; *a; a++, n++) switch(*a)
+                    {
+                        case 's': v[n] = ++wn < numargs ? w[wn] : (char *)""; break;
+                        case 'i': nstor[n].i = ++wn < numargs ? parseint(w[wn]) : 0;  v[n] = &nstor[n].i; break;
+                        case 'f': nstor[n].f = ++wn < numargs ? parsefloat(w[wn]) : 0.0f; v[n] = &nstor[n].f; break;
+#ifndef STANDALONE
+                        case 'D': nstor[n].i = addreleaseaction(id->name) ? 1 : 0; v[n] = &nstor[n].i; break;
+#endif
+                        case 'V': v[n++] = w+1; nstor[n].i = numargs-1; v[n] = &nstor[n].i; break;
+                        case 'C': if(!cargs) cargs = conc(w+1, numargs-1, true); v[n] = cargs; break;
+                        default: fatal("builtin declared with illegal type");
+                    }
+                    switch(n)
+                    {
+                        case 0: ((void (__cdecl *)()                                      )id->fun)();                             break;
+                        case 1: ((void (__cdecl *)(void *)                                )id->fun)(v[0]);                         break;
+                        case 2: ((void (__cdecl *)(void *, void *)                        )id->fun)(v[0], v[1]);                   break;
+                        case 3: ((void (__cdecl *)(void *, void *, void *)                )id->fun)(v[0], v[1], v[2]);             break;
+                        case 4: ((void (__cdecl *)(void *, void *, void *, void *)        )id->fun)(v[0], v[1], v[2], v[3]);       break;
+                        case 5: ((void (__cdecl *)(void *, void *, void *, void *, void *))id->fun)(v[0], v[1], v[2], v[3], v[4]); break;
+                        case 6: ((void (__cdecl *)(void *, void *, void *, void *, void *, void *))id->fun)(v[0], v[1], v[2], v[3], v[4], v[5]); break;
+                        case 7: ((void (__cdecl *)(void *, void *, void *, void *, void *, void *, void *))id->fun)(v[0], v[1], v[2], v[3], v[4], v[5], v[6]); break;
+                        case 8: ((void (__cdecl *)(void *, void *, void *, void *, void *, void *, void *, void *))id->fun)(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]); break;
+                        default: fatal("builtin declared with too many args (use V?)");
+                    }
+                    if(cargs) delete[] cargs;
+                    setretval(commandret);
+                    commandret = NULL;
+                    break;
+                }
+
+                case ID_VAR:                        // game defined variables
+                    if(numargs <= 1)
+                    {
+                        if(id->flags&IDF_HEX && id->maxval==0xFFFFFF)
+                            conoutf("%s = 0x%.6X (%d, %d, %d)", c, *id->storage.i, (*id->storage.i>>16)&0xFF, (*id->storage.i>>8)&0xFF, *id->storage.i&0xFF);
+                        else
+                            conoutf(id->flags&IDF_HEX ? "%s = 0x%X" : "%s = %d", c, *id->storage.i);      // var with no value just prints its current value
+                    }
+                    else
+                    {
+                        int val = parseint(w[1]);
+                        if(id->flags&IDF_HEX && numargs > 2)
+                        {
+                            val <<= 16;
+                            val |= parseint(w[2])<<8;
+                            if(numargs > 3) val |= parseint(w[3]);
+                        }
+                        setvarchecked(id, val);
+                    }
+                    break;
+
+                case ID_FVAR:
+                    if(numargs <= 1) conoutf("%s = %s", c, floatstr(*id->storage.f));
+                    else setfvarchecked(id, parsefloat(w[1]));
+                    break;
+
+                case ID_SVAR:
+                    if(numargs <= 1) conoutf(strchr(*id->storage.s, '"') ? "%s = [%s]" : "%s = \"%s\"", c, *id->storage.s);
+                    else setsvarchecked(id, w[1]);
+                    break;
+
+                case ID_ALIAS:                              // alias, also used as functions and (global) variables
+                {
+                    delete[] w[0];
+                    static vector<ident *> argids;
+                    for(int i = 1; i<numargs; i++)
+                    {
+                        if(i > argids.length())
+                        {
+                            defformatstring(argname)("arg%d", i);
+                            argids.add(newident(argname));
+                        }
+                        pushident(*argids[i-1], w[i]); // set any arguments as (global) arg values so functions can access them
+                    }
+                    _numargs = numargs-1;
+                    bool wasoverriding = overrideidents;
+                    if(id->override!=NO_OVERRIDE) overrideidents = true;
+                    char *wasexecuting = id->isexecuting;
+                    id->isexecuting = id->action;
+                    setretval(executeret(id->action));
+                    if(id->isexecuting != id->action && id->isexecuting != wasexecuting) delete[] id->isexecuting;
+                    id->isexecuting = wasexecuting;
+                    overrideidents = wasoverriding;
+                    for(int i = 1; i<numargs; i++) popident(*argids[i-1]);
+                    continue;
+                }
+            }
+        }
+        loopj(numargs) if(w[j]) delete[] w[j];
+    }
+    return retval;
+}
+
+int execute(const char *p)
+{
+    char *ret = executeret(p);
+    int i = 0;
+    if(ret) { i = parseint(ret); delete[] ret; }
+    return i;
+}
+
+#ifndef STANDALONE
+static int sortidents(ident **x, ident **y)
+{
+    return strcmp((*x)->name, (*y)->name);
+}
+
+void writeescapedstring(stream *f, const char *s)
+{
+    f->putchar('"');
+    for(; *s; s++) switch(*s)
+    {
+        case '\n': f->write("^n", 2); break;
+        case '\t': f->write("^t", 2); break;
+        case '\f': f->write("^f", 2); break;
+        case '"': f->write("^\"", 2); break;
+        default: f->putchar(*s); break;
+    }
+    f->putchar('"');
+}
+#endif
+
+// below the commands that implement a small imperative language. thanks to the semantics of
+// () and [] expressions, any control construct can be defined trivially.
+
+static string retbuf[3];
+static int retidx = 0;
+
+const char *intstr(int v)
+{
+    retidx = (retidx + 1)%3;
+    formatstring(retbuf[retidx])("%d", v);
+    return retbuf[retidx];
+}
+
+void intret(int v)
+{
+    commandret = newstring(intstr(v));
+}
+
+const char *floatstr(float v)
+{
+    retidx = (retidx + 1)%3;
+    formatstring(retbuf[retidx])(v==int(v) ? "%.1f" : "%.7g", v);
+    return retbuf[retidx];
+}
+
+void floatret(float v)
+{
+    commandret = newstring(floatstr(v));
+}
+
+#undef ICOMMANDNAME
+#define ICOMMANDNAME(name) _stdcmd
+
+ICOMMAND(if, "sss", (char *cond, char *t, char *f), commandret = executeret(cond[0] && (!isinteger(cond) || parseint(cond)) ? t : f));
+ICOMMAND(?, "sss", (char *cond, char *t, char *f), result(cond[0] && (!isinteger(cond) || parseint(cond)) ? t : f));
+ICOMMAND(loop, "sis", (char *var, int *n, char *body),
+{
+    if(*n<=0) return;
+    ident *id = newident(var);
+    if(id->type!=ID_ALIAS) return;
+    loopi(*n)
+    {
+        if(i) sprintf(id->action, "%d", i);
+        else pushident(*id, newstring("0", 16));
+        execute(body);
+    }
+    popident(*id);
+});
+ICOMMAND(loopwhile, "siss", (char *var, int *n, char *cond, char *body),
+{
+    if(*n<=0) return;
+    ident *id = newident(var);
+    if(id->type!=ID_ALIAS) return;
+    loopi(*n)
+    {
+        if(i) sprintf(id->action, "%d", i);
+        else pushident(*id, newstring("0", 16));
+        if(!execute(cond)) break;
+        execute(body);
+    }
+    popident(*id);
+});
+ICOMMAND(while, "ss", (char *cond, char *body), while(execute(cond)) execute(body));    // can't get any simpler than this :)
+
+void concat(const char *s) { commandret = newstring(s); }
+void result(const char *s) { commandret = newstring(s); }
+
+void concatword(char **args, int *numargs)
+{
+    commandret = conc(args, *numargs, false);
+}
+
+void format(char **args, int *numargs)
+{
+    vector<char> s;
+    char *f = args[0];
+    while(*f)
+    {
+        int c = *f++;
+        if(c == '%')
+        {
+            int i = *f++;
+            if(i >= '1' && i <= '9')
+            {
+                i -= '0';
+                const char *sub = i < *numargs ? args[i] : "";
+                while(*sub) s.add(*sub++);
+            }
+            else s.add(i);
+        }
+        else s.add(c);
+    }
+    s.add('\0');
+    result(s.getbuf());
+}
+
+#define whitespaceskip s += strspn(s, "\n\t ")
+#define elementskip *s=='"' ? (++s, s += strcspn(s, "\"\n\0"), s += *s=='"') : s += strcspn(s, "\n\t \0")
+
+void explodelist(const char *s, vector<char *> &elems)
+{
+    whitespaceskip;
+    while(*s)
+    {
+        const char *elem = s;
+        elementskip;
+        elems.add(*elem=='"' ? newstring(elem+1, s-elem-(s[-1]=='"' ? 2 : 1)) : newstring(elem, s-elem));
+        whitespaceskip;
+    }
+}
+
+char *indexlist(const char *s, int pos)
+{
+    whitespaceskip;
+    loopi(pos)
+    {
+        elementskip;
+        whitespaceskip;
+        if(!*s) break;
+    }
+    const char *e = s;
+    elementskip;
+    if(*e=='"')
+    {
+        e++;
+        if(s[-1]=='"') --s;
+    }
+    return newstring(e, s-e);
+}
+
+int listlen(const char *s)
+{
+    int n = 0;
+    whitespaceskip;
+    for(; *s; n++) elementskip, whitespaceskip;
+    return n;
+}
+
+void at(char *s, int *pos)
+{
+    commandret = indexlist(s, *pos);
+}
+
+void substr(char *s, int *start, char *count)
+{
+    int len = strlen(s), offset = clamp(*start, 0, len);
+    commandret = newstring(&s[offset], count[0] ? clamp(parseint(count), 0, len - offset) : len - offset);
+}
+
+void getalias_(char *s)
+{
+    result(getalias(s));
+}
+
+COMMAND(concat, "C");
+COMMAND(result, "s");
+COMMAND(concatword, "V");
+COMMAND(format, "V");
+COMMAND(at, "si");
+COMMAND(substr, "sis");
+ICOMMAND(listlen, "s", (char *s), intret(listlen(s)));
+COMMANDN(getalias, getalias_, "s");
+
+void looplist(const char *var, const char *list, const char *body, bool search)
+{
+    ident *id = newident(var);
+    if(id->type!=ID_ALIAS) { if(search) intret(-1); return; }
+    int n = 0;
+    for(const char *s = list;;)
+    {
+        whitespaceskip;
+        if(!*s) { if(search) intret(-1); break; }
+        const char *start = s;
+        elementskip;
+        const char *end = s;
+        if(*start=='"') { start++; if(end[-1]=='"') --end; }
+        char *val = newstring(start, end-start);
+        if(n++) aliasa(id->name, val);
+        else pushident(*id, val);
+        if(execute(body) && search) { intret(n-1); break; }
+    }
+    if(n) popident(*id);
+}
+
+void prettylist(const char *s, const char *conj)
+{