From 0a1172b75f571685c264a8b9d8ee224bbf11381f Mon Sep 17 00:00:00 2001 From: xolatile Date: Wed, 6 Aug 2025 22:54:55 +0200 Subject: Please do not hate me, it makes sense... --- src/engine/command.cpp | 1301 ++++++++++++++++-------------------------------- 1 file changed, 430 insertions(+), 871 deletions(-) (limited to 'src/engine/command.cpp') diff --git a/src/engine/command.cpp b/src/engine/command.cpp index 012b8c1..5248899 100644 --- a/src/engine/command.cpp +++ b/src/engine/command.cpp @@ -9,38 +9,31 @@ ident *dummyident = NULL; int identflags = 0; -enum -{ +enum { MAXARGS = 25, MAXCOMARGS = 12 }; VARN(numargs, _numargs, MAXARGS, 0, 0); -static inline void freearg(tagval &v) -{ - switch(v.type) - { +static inline void freearg(tagval &v) { + switch(v.type) { case VAL_STR: delete[] v.s; break; case VAL_CODE: if(v.code[-1] == CODE_START) delete[] (uchar *)&v.code[-1]; break; } } -static inline void forcenull(tagval &v) -{ - switch(v.type) - { +static inline void forcenull(tagval &v) { + switch(v.type) { case VAL_NULL: return; } freearg(v); v.setnull(); } -static inline float forcefloat(tagval &v) -{ +static inline float forcefloat(tagval &v) { float f = 0.0f; - switch(v.type) - { + switch(v.type) { case VAL_INT: f = v.i; break; case VAL_STR: f = parsefloat(v.s); break; case VAL_MACRO: f = parsefloat(v.s); break; @@ -51,11 +44,9 @@ static inline float forcefloat(tagval &v) return f; } -static inline int forceint(tagval &v) -{ +static inline int forceint(tagval &v) { int i = 0; - switch(v.type) - { + switch(v.type) { case VAL_FLOAT: i = v.f; break; case VAL_STR: i = parseint(v.s); break; case VAL_MACRO: i = parseint(v.s); break; @@ -66,11 +57,9 @@ static inline int forceint(tagval &v) return i; } -static inline const char *forcestr(tagval &v) -{ +static inline const char *forcestr(tagval &v) { const char *s = ""; - switch(v.type) - { + switch(v.type) { case VAL_FLOAT: s = floatstr(v.f); break; case VAL_INT: s = intstr(v.i); break; case VAL_STR: @@ -82,29 +71,23 @@ static inline const char *forcestr(tagval &v) return s; } -static inline void forcearg(tagval &v, int type) -{ - switch(type) - { +static inline void forcearg(tagval &v, int type) { + switch(type) { case RET_STR: if(v.type != VAL_STR) forcestr(v); break; case RET_INT: if(v.type != VAL_INT) forceint(v); break; case RET_FLOAT: if(v.type != VAL_FLOAT) forcefloat(v); break; } } -static inline ident *forceident(tagval &v) -{ - switch(v.type) - { +static inline ident *forceident(tagval &v) { + switch(v.type) { case VAL_IDENT: return v.id; - case VAL_MACRO: - { + case VAL_MACRO: { ident *id = newident(v.s, IDF_UNKNOWN); v.setident(id); return id; } - case VAL_STR: - { + case VAL_STR: { ident *id = newident(v.s, IDF_UNKNOWN); delete[] v.s; v.setident(id); @@ -116,39 +99,31 @@ static inline ident *forceident(tagval &v) return dummyident; } -void tagval::cleanup() -{ +void tagval::cleanup() { freearg(*this); } -static inline void freeargs(tagval *args, int &oldnum, int newnum) -{ +static inline void freeargs(tagval *args, int &oldnum, int newnum) { for(int i = newnum; i < oldnum; i++) freearg(args[i]); oldnum = newnum; } -static inline void cleancode(ident &id) -{ - if(id.code) - { +static inline void cleancode(ident &id) { + if(id.code) { id.code[0] -= 0x100; if(int(id.code[0]) < 0x100) delete[] id.code; id.code = NULL; } } -struct nullval : tagval -{ +struct nullval : tagval { nullval() { setnull(); } } nullval; tagval noret = nullval, *commandret = &noret; -void clear_command() -{ - enumerate(idents, ident, i, - { - if(i.type==ID_ALIAS) - { +void clear_command() { + enumerate(idents, ident, i, { + if(i.type==ID_ALIAS) { DELETEA(i.name); i.forcenull(); DELETEA(i.code); @@ -156,14 +131,11 @@ void clear_command() }); } -void clearoverride(ident &i) -{ +void clearoverride(ident &i) { if(!(i.flags&IDF_OVERRIDDEN)) return; - switch(i.type) - { + switch(i.type) { case ID_ALIAS: - if(i.valtype==VAL_STR) - { + if(i.valtype==VAL_STR) { if(!i.val.s[0]) break; delete[] i.val.s; } @@ -188,18 +160,15 @@ void clearoverride(ident &i) i.flags &= ~IDF_OVERRIDDEN; } -void clearoverrides() -{ +void clearoverrides() { enumerate(idents, ident, i, clearoverride(i)); } static bool initedidents = false; static vector *identinits = NULL; -static inline ident *addident(const ident &id) -{ - if(!initedidents) - { +static inline ident *addident(const ident &id) { + if(!initedidents) { if(!identinits) identinits = new vector; identinits->add(id); return NULL; @@ -209,17 +178,14 @@ static inline ident *addident(const ident &id) return identmap.add(&def); } -static bool initidents() -{ +static bool initidents() { initedidents = true; - for(int i = 0; i < MAXARGS; i++) - { + for(int i = 0; i < MAXARGS; i++) { defformatstring(argname, "arg%d", i+1); newident(argname, IDF_ARG); } dummyident = newident("//dummy", IDF_UNKNOWN); - if(identinits) - { + if(identinits) { loopv(*identinits) addident((*identinits)[i]); DELETEP(identinits); } @@ -229,17 +195,14 @@ UNUSED static bool forceinitidents = initidents(); static const char *sourcefile = NULL, *sourcestr = NULL; -static const char *debugline(const char *p, const char *fmt) -{ +static const char *debugline(const char *p, const char *fmt) { if(!sourcestr) return fmt; int num = 1; const char *line = sourcestr; - for(;;) - { + for(;;) { const char *end = strchr(line, '\n'); if(!end) end = line + strlen(line); - if(p >= line && p <= end) - { + if(p >= line && p <= end) { static string buf; if(sourcefile) formatstring(buf, "%s:%d: %s", sourcefile, num, fmt); else formatstring(buf, "%d: %s", num, fmt); @@ -252,8 +215,7 @@ static const char *debugline(const char *p, const char *fmt) return fmt; } -static struct identlink -{ +static struct identlink { ident *id; identlink *next; int usedargs; @@ -262,13 +224,11 @@ static struct identlink VAR(dbgalias, 0, 4, 1000); -static void debugalias() -{ +static void debugalias() { if(!dbgalias) return; int total = 0, depth = 0; for(identlink *l = aliasstack; l != &noalias; l = l->next) total++; - for(identlink *l = aliasstack; l != &noalias; l = l->next) - { + for(identlink *l = aliasstack; l != &noalias; l = l->next) { ident *id = l->id; ++depth; if(depth < dbgalias) conoutf(CON_ERROR, " %d) %s", total-depth+1, id->name); @@ -280,41 +240,33 @@ static int nodebug = 0; static void debugcode(const char *fmt, ...) PRINTFARGS(1, 2); -static void debugcode(const char *fmt, ...) -{ +static void debugcode(const char *fmt, ...) { if(nodebug) return; - va_list args; va_start(args, fmt); conoutfv(CON_ERROR, fmt, args); va_end(args); - debugalias(); } static void debugcodeline(const char *p, const char *fmt, ...) PRINTFARGS(2, 3); -static void debugcodeline(const char *p, const char *fmt, ...) -{ +static void debugcodeline(const char *p, const char *fmt, ...) { if(nodebug) return; - va_list args; va_start(args, fmt); conoutfv(CON_ERROR, debugline(p, fmt), args); va_end(args); - debugalias(); } ICOMMAND(nodebug, "e", (uint *body), { nodebug++; executeret(body, *commandret); nodebug--; }); -void addident(ident *id) -{ +void addident(ident *id) { addident(*id); } -static inline void pusharg(ident &id, const tagval &v, identstack &stack) -{ +static inline void pusharg(ident &id, const tagval &v, identstack &stack) { stack.val = id.val; stack.valtype = id.valtype; stack.next = id.stack; @@ -323,8 +275,7 @@ static inline void pusharg(ident &id, const tagval &v, identstack &stack) cleancode(id); } -static inline void poparg(ident &id) -{ +static inline void poparg(ident &id) { if(!id.stack) return; identstack *stack = id.stack; if(id.valtype == VAL_STR) delete[] id.val.s; @@ -333,8 +284,7 @@ static inline void poparg(ident &id) id.stack = stack->next; } -ICOMMAND(push, "rte", (ident *id, tagval *v, uint *code), -{ +ICOMMAND(push, "rte", (ident *id, tagval *v, uint *code), { if(id->type != ID_ALIAS || id->index < MAXARGS) return; identstack stack; pusharg(*id, *v, stack); @@ -344,40 +294,32 @@ ICOMMAND(push, "rte", (ident *id, tagval *v, uint *code), poparg(*id); }); -static inline void pushalias(ident &id, identstack &stack) -{ - if(id.type == ID_ALIAS && id.index >= MAXARGS) - { +static inline void pushalias(ident &id, identstack &stack) { + if(id.type == ID_ALIAS && id.index >= MAXARGS) { pusharg(id, nullval, stack); id.flags &= ~IDF_UNKNOWN; } } -static inline void popalias(ident &id) -{ +static inline void popalias(ident &id) { if(id.type == ID_ALIAS && id.index >= MAXARGS) poparg(id); } KEYWORD(local, ID_LOCAL); -static inline bool checknumber(const char *s) -{ +static inline bool checknumber(const char *s) { if(isdigit(s[0])) return true; - else switch(s[0]) - { + else switch(s[0]) { case '+': case '-': return isdigit(s[1]) || (s[1] == '.' && isdigit(s[2])); case '.': return isdigit(s[1]) != 0; default: return false; } } -ident *newident(const char *name, int flags) -{ +ident *newident(const char *name, int flags) { ident *id = idents.access(name); - if(!id) - { - if(checknumber(name)) - { + if(!id) { + if(checknumber(name)) { debugcode("number %s is not a valid identifier name", name); return dummyident; } @@ -386,27 +328,23 @@ ident *newident(const char *name, int flags) return id; } -ident *writeident(const char *name, int flags) -{ +ident *writeident(const char *name, int flags) { ident *id = newident(name, flags); - if(id->index < MAXARGS && !(aliasstack->usedargs&(1<index))) - { + if(id->index < MAXARGS && !(aliasstack->usedargs&(1<index))) { pusharg(*id, nullval, aliasstack->argstack[id->index]); aliasstack->usedargs |= 1<index; } return id; } -ident *readident(const char *name) -{ +ident *readident(const char *name) { ident *id = idents.access(name); if(id && id->index < MAXARGS && !(aliasstack->usedargs&(1<index))) return NULL; return id; } -void resetvar(char *name) -{ +void resetvar(char *name) { ident *id = idents.access(name); if(!id) return; if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name); @@ -415,89 +353,73 @@ void resetvar(char *name) COMMAND(resetvar, "s"); -static inline void setarg(ident &id, tagval &v) -{ - if(aliasstack->usedargs&(1<usedargs&(1<argstack[id.index]); aliasstack->usedargs |= 1<type == ID_ALIAS) - { + if(id) { + if(id->type == ID_ALIAS) { if(id->index < MAXARGS) setarg(*id, v); else setalias(*id, v); } - else - { + else { debugcode("cannot redefine builtin %s with an alias", id->name); freearg(v); } } - else if(checknumber(name)) - { + else if(checknumber(name)) { debugcode("cannot alias number %s", name); freearg(v); } - else - { + else { addident(ident(ID_ALIAS, newstring(name), v, identflags)); } } -void alias(const char *name, const char *str) -{ +void alias(const char *name, const char *str) { tagval v; v.setstr(newstring(str)); setalias(name, v); } -void alias(const char *name, tagval &v) -{ +void alias(const char *name, tagval &v) { setalias(name, v); } -ICOMMAND(alias, "st", (const char *name, tagval *v), -{ +ICOMMAND(alias, "st", (const char *name, tagval *v), { setalias(name, *v); v->type = VAL_NULL; }); // variable's and commands are registered through globals, see cube.h -int variable(const char *name, int min, int cur, int max, int *storage, identfun fun, int flags) -{ +int variable(const char *name, int min, int cur, int max, int *storage, identfun fun, int flags) { addident(ident(ID_VAR, name, min, max, storage, (void *)fun, flags)); return cur; } -float fvariable(const char *name, float min, float cur, float max, float *storage, identfun fun, int flags) -{ +float fvariable(const char *name, float min, float cur, float max, float *storage, identfun fun, int flags) { addident(ident(ID_FVAR, name, min, max, storage, (void *)fun, flags)); return cur; } -char *svariable(const char *name, const char *cur, char **storage, identfun fun, int flags) -{ +char *svariable(const char *name, const char *cur, char **storage, identfun fun, int flags) { addident(ident(ID_SVAR, name, storage, (void *)fun, flags)); return newstring(cur); } @@ -507,67 +429,59 @@ char *svariable(const char *name, const char *cur, char **storage, identfun fun, 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(identflags&IDF_OVERRIDDEN || id->flags&IDF_OVERRIDE) \ - { \ - if(id->flags&IDF_PERSIST) \ - { \ + if(identflags&IDF_OVERRIDDEN || id->flags&IDF_OVERRIDE) { \ + \ + if(id->flags&IDF_PERSIST) { \ + \ debugcode("cannot override persistent variable %s", id->name); \ errorval; \ } \ if(!(id->flags&IDF_OVERRIDDEN)) { saveval; id->flags |= IDF_OVERRIDDEN; } \ else { clearval; } \ } \ - else \ - { \ + else { \ + \ if(id->flags&IDF_OVERRIDDEN) { resetval; id->flags &= ~IDF_OVERRIDDEN; } \ clearval; \ } -void setvar(const char *name, int i, bool dofunc, bool doclamp) -{ +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) -{ +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) -{ +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) -{ +int getvar(const char *name) { GETVAR(id, name, 0); return *id->storage.i; } -int getvarmin(const char *name) -{ +int getvarmin(const char *name) { GETVAR(id, name, 0); return id->minval; } -int getvarmax(const char *name) -{ +int getvarmax(const char *name) { GETVAR(id, name, 0); return id->maxval; } -float getfvarmin(const char *name) -{ +float getfvarmin(const char *name) { _GETVAR(id, ID_FVAR, name, 0); return id->minvalf; } -float getfvarmax(const char *name) -{ +float getfvarmax(const char *name) { _GETVAR(id, ID_FVAR, name, 0); return id->maxvalf; } @@ -580,11 +494,9 @@ ICOMMAND(getfvarmax, "s", (char *s), floatret(getfvarmax(s))); bool identexists(const char *name) { return idents.access(name)!=NULL; } ident *getident(const char *name) { return idents.access(name); } -void touchvar(const char *name) -{ +void touchvar(const char *name) { ident *id = idents.access(name); - if(id) switch(id->type) - { + if(id) switch(id->type) { case ID_VAR: case ID_FVAR: case ID_SVAR: @@ -593,16 +505,14 @@ void touchvar(const char *name) } } -const char *getalias(const char *name) -{ +const char *getalias(const char *name) { ident *i = idents.access(name); return i && i->type==ID_ALIAS && (i->index >= MAXARGS || aliasstack->usedargs&(1<index)) ? i->getstr() : ""; } ICOMMAND(getalias, "s", (char *s), result(getalias(s))); -int clampvar(ident *id, int val, int minval, int maxval) -{ +int clampvar(ident *id, int val, int minval, int maxval) { if(val < minval) val = minval; else if(val > maxval) val = maxval; else return val; @@ -613,15 +523,13 @@ int clampvar(ident *id, int val, int minval, int maxval) return val; } -void setvarchecked(ident *id, int val) -{ +void setvarchecked(ident *id, int val) { if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name); #ifndef STANDALONE - else if(!(id->flags&IDF_OVERRIDE) || identflags&IDF_OVERRIDDEN || game::allowedittoggle()) + else if(!(id->flags&IDF_OVERRIDE) || identflags&IDF_OVERRIDDEN || game::allowedittoggle()) { #else - else + else { #endif - { OVERRIDEVAR(return, id->overrideval.i = *id->storage.i, , ) if(val < id->minval || val > id->maxval) val = clampvar(id, val, id->minval, id->maxval); *id->storage.i = val; @@ -632,19 +540,16 @@ void setvarchecked(ident *id, int val) } } -static inline void setvarchecked(ident *id, tagval *args, int numargs) -{ +static inline void setvarchecked(ident *id, tagval *args, int numargs) { int val = forceint(args[0]); - if(id->flags&IDF_HEX && numargs > 1) - { + if(id->flags&IDF_HEX && numargs > 1) { val = (val << 16) | (forceint(args[1])<<8); if(numargs > 2) val |= forceint(args[2]); } setvarchecked(id, val); } -float clampfvar(ident *id, float val, float minval, float maxval) -{ +float clampfvar(ident *id, float val, float minval, float maxval) { if(val < minval) val = minval; else if(val > maxval) val = maxval; else return val; @@ -652,15 +557,13 @@ float clampfvar(ident *id, float val, float minval, float maxval) return val; } -void setfvarchecked(ident *id, float val) -{ +void setfvarchecked(ident *id, float val) { if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name); #ifndef STANDALONE - else if(!(id->flags&IDF_OVERRIDE) || identflags&IDF_OVERRIDDEN || game::allowedittoggle()) + else if(!(id->flags&IDF_OVERRIDE) || identflags&IDF_OVERRIDDEN || game::allowedittoggle()) { #else - else + else { #endif - { OVERRIDEVAR(return, id->overrideval.f = *id->storage.f, , ); if(val < id->minvalf || val > id->maxvalf) val = clampfvar(id, val, id->minvalf, id->maxvalf); *id->storage.f = val; @@ -671,15 +574,13 @@ void setfvarchecked(ident *id, float val) } } -void setsvarchecked(ident *id, const char *val) -{ +void setsvarchecked(ident *id, const char *val) { if(id->flags&IDF_READONLY) debugcode("variable %s is read-only", id->name); #ifndef STANDALONE - else if(!(id->flags&IDF_OVERRIDE) || identflags&IDF_OVERRIDDEN || game::allowedittoggle()) + else if(!(id->flags&IDF_OVERRIDE) || identflags&IDF_OVERRIDDEN || game::allowedittoggle()) { #else - 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(); @@ -689,10 +590,8 @@ void setsvarchecked(ident *id, const char *val) } } -ICOMMAND(set, "rt", (ident *id, tagval *v), -{ - switch(id->type) - { +ICOMMAND(set, "rt", (ident *id, tagval *v), { + switch(id->type) { case ID_ALIAS: if(id->index < MAXARGS) setarg(*id, *v); else setalias(*id, *v); v->type = VAL_NULL; @@ -707,8 +606,7 @@ ICOMMAND(set, "rt", (ident *id, tagval *v), setsvarchecked(id, forcestr(*v)); break; case ID_COMMAND: - if(id->flags&IDF_EMUVAR) - { + if(id->flags&IDF_EMUVAR) { execute(id, v, 1); v->type = VAL_NULL; break; @@ -720,13 +618,11 @@ ICOMMAND(set, "rt", (ident *id, tagval *v), } }); -bool addcommand(const char *name, identfun fun, const char *args) -{ +bool addcommand(const char *name, identfun fun, const char *args) { uint argmask = 0; int numargs = 0, flags = 0; bool limit = true; - for(const char *fmt = args; *fmt; fmt++) switch(*fmt) - { + for(const char *fmt = args; *fmt; fmt++) switch(*fmt) { case 'i': case 'b': case 'f': case 't': case 'N': case 'D': if(numargs < MAXARGS) numargs++; break; case '$': flags |= IDF_EMUVAR; // fall through case 's': case 'e': case 'r': if(numargs < MAXARGS) { argmask |= 1<= end) break; int e = *src++; - switch(e) - { + switch(e) { case 'n': *dst++ = '\n'; break; case 't': *dst++ = '\t'; break; case 'f': *dst++ = '\f'; break; @@ -783,19 +672,15 @@ int unescapestring(char *dst, const char *src, const char *end) return dst - start; } -static char *conc(vector &buf, tagval *v, int n, bool space, const char *prefix = NULL, int prefixlen = 0) -{ - if(prefix) - { +static char *conc(vector &buf, tagval *v, int n, bool space, const char *prefix = NULL, int prefixlen = 0) { + if(prefix) { buf.put(prefix, prefixlen); if(space && n) buf.add(' '); } - loopi(n) - { + loopi(n) { const char *s = ""; int len = 0; - switch(v[i].type) - { + switch(v[i].type) { case VAL_INT: s = intstr(v[i].i); break; case VAL_FLOAT: s = floatstr(v[i].f); break; case VAL_STR: s = v[i].s; break; @@ -811,13 +696,11 @@ static char *conc(vector &buf, tagval *v, int n, bool space, const char *p return buf.getbuf(); } -static char *conc(tagval *v, int n, bool space, const char *prefix, int prefixlen) -{ +static char *conc(tagval *v, int n, bool space, const char *prefix, int prefixlen) { static int vlen[MAXARGS]; static char numbuf[3*MAXSTRLEN]; int len = prefixlen, numlen = 0, i = 0; - for(; i < n; i++) switch(v[i].type) - { + for(; i < n; i++) switch(v[i].type) { case VAL_MACRO: len += (vlen[i] = v[i].code[-1]>>8); break; case VAL_STR: len += (vlen[i] = int(strlen(v[i].s))); break; case VAL_INT: @@ -836,16 +719,13 @@ overflow: if(space) len += max(prefix ? i : i-1, 0); char *buf = newstring(len + numlen); int offset = 0, numoffset = 0; - if(prefix) - { + if(prefix) { memcpy(buf, prefix, prefixlen); offset += prefixlen; if(space && i) buf[offset++] = ' '; } - loopj(i) - { - if(v[j].type == VAL_INT || v[j].type == VAL_FLOAT) - { + loopj(i) { + if(v[j].type == VAL_INT || v[j].type == VAL_FLOAT) { memcpy(&buf[offset], &numbuf[numoffset], vlen[j]); numoffset += vlen[j]; } @@ -855,8 +735,7 @@ overflow: if(space) buf[offset++] = ' '; } buf[offset] = '\0'; - if(i < n) - { + if(i < n) { char *morebuf = conc(&v[i], n-i, space, buf, offset); delete[] buf; return morebuf; @@ -864,28 +743,23 @@ overflow: return buf; } -static inline char *conc(tagval *v, int n, bool space) -{ +static inline char *conc(tagval *v, int n, bool space) { return conc(v, n, space, NULL, 0); } -static inline char *conc(tagval *v, int n, bool space, const char *prefix) -{ +static inline char *conc(tagval *v, int n, bool space, const char *prefix) { return conc(v, n, space, prefix, strlen(prefix)); } -static inline void skipcomments(const char *&p) -{ - for(;;) - { +static inline void skipcomments(const char *&p) { + for(;;) { p += strspn(p, " \t\r"); if(p[0]!='/' || p[1]!='/') break; p += strcspn(p, "\n\0"); } } -static inline char *cutstring(const char *&p, int &len) -{ +static inline char *cutstring(const char *&p, int &len) { p++; const char *end = parsestring(p); char *s = newstring(end - p); @@ -896,16 +770,13 @@ static inline char *cutstring(const char *&p, int &len) return s; } -static inline const char *parseword(const char *p) -{ +static inline const char *parseword(const char *p) { const int maxbrak = 100; static char brakstack[maxbrak]; int brakdepth = 0; - for(;; p++) - { + for(;; p++) { p += strcspn(p, "\"/;()[] \t\r\n\0"); - switch(p[0]) - { + switch(p[0]) { case '"': case ';': case ' ': case '\t': case '\r': case '\n': case '\0': return p; case '/': if(p[1] == '/') return p; break; case '[': case '(': if(brakdepth >= maxbrak) return p; brakstack[brakdepth++] = p[0]; break; @@ -916,8 +787,7 @@ static inline const char *parseword(const char *p) return p; } -static inline char *cutword(const char *&p, int &len) -{ +static inline char *cutword(const char *&p, int &len) { const char *word = p; p = parseword(p); len = p-word; @@ -925,10 +795,8 @@ static inline char *cutword(const char *&p, int &len) return newstring(word, len); } -static inline void compilestr(vector &code, const char *word, int len, bool macro = false) -{ - if(len <= 3 && !macro) - { +static inline void compilestr(vector &code, const char *word, int len, bool macro = false) { + if(len <= 3 && !macro) { uint op = CODE_VALI|RET_STR; for(int i = 0; i < len; i++) op |= uint(uchar(word[i]))<<((i+1)*8); code.add(op); @@ -937,8 +805,7 @@ static inline void compilestr(vector &code, const char *word, int len, boo code.add((macro ? CODE_MACRO : CODE_VAL|RET_STR)|(len<<8)); code.put((const uint *)word, len/sizeof(uint)); size_t endlen = len%sizeof(uint); - union - { + union { char c[sizeof(uint)]; uint u; } end; @@ -947,30 +814,25 @@ static inline void compilestr(vector &code, const char *word, int len, boo code.add(end.u); } -static inline void compilestr(vector &code, const char *word = NULL) -{ +static inline void compilestr(vector &code, const char *word = NULL) { if(!word) { code.add(CODE_VALI|RET_STR); return; } compilestr(code, word, int(strlen(word))); } -static inline void compileint(vector &code, int i) -{ +static inline void compileint(vector &code, int i) { if(i >= -0x800000 && i <= 0x7FFFFF) code.add(CODE_VALI|RET_INT|(i<<8)); - else - { + else { code.add(CODE_VAL|RET_INT); code.add(i); } } -static inline void compilenull(vector &code) -{ +static inline void compilenull(vector &code) { code.add(CODE_VALI|RET_NULL); } -static inline void compileblock(vector &code) -{ +static inline void compileblock(vector &code) { int start = code.length(); code.add(CODE_BLOCK); code.add(CODE_OFFSET|((start+2)<<8)); @@ -978,27 +840,22 @@ static inline void compileblock(vector &code) code[start] |= uint(code.length() - (start + 1))<<8; } -static inline void compileident(vector &code, ident *id) -{ +static inline void compileident(vector &code, ident *id) { code.add((id->index < MAXARGS ? CODE_IDENTARG : CODE_IDENT)|(id->index<<8)); } -static inline void compileident(vector &code, const char *word = NULL) -{ +static inline void compileident(vector &code, const char *word = NULL) { compileident(code, word ? newident(word, IDF_UNKNOWN) : dummyident); } -static inline void compileint(vector &code, const char *word = NULL) -{ +static inline void compileint(vector &code, const char *word = NULL) { return compileint(code, word ? parseint(word) : 0); } -static inline void compilefloat(vector &code, float f) -{ +static inline void compilefloat(vector &code, float f) { if(int(f) == f && f >= -0x800000 && f <= 0x7FFFFF) code.add(CODE_VALI|RET_FLOAT|(int(f)<<8)); - else - { + else { union { float f; uint u; } conv; conv.f = f; code.add(CODE_VAL|RET_FLOAT); @@ -1006,24 +863,20 @@ static inline void compilefloat(vector &code, float f) } } -static inline void compilefloat(vector &code, const char *word = NULL) -{ +static inline void compilefloat(vector &code, const char *word = NULL) { return compilefloat(code, word ? parsefloat(word) : 0.0f); } static bool compilearg(vector &code, const char *&p, int wordtype); static void compilestatements(vector &code, const char *&p, int rettype, int brak = '\0'); -static inline void compileval(vector &code, int wordtype, char *word, int wordlen) -{ - switch(wordtype) - { +static inline void compileval(vector &code, int wordtype, char *word, int wordlen) { + switch(wordtype) { case VAL_STR: compilestr(code, word, wordlen, true); break; case VAL_ANY: compilestr(code, word, wordlen); break; case VAL_FLOAT: compilefloat(code, word); break; case VAL_INT: compileint(code, word); break; - case VAL_CODE: - { + case VAL_CODE: { int start = code.length(); code.add(CODE_BLOCK); code.add(CODE_OFFSET|((start+2)<<8)); @@ -1041,12 +894,10 @@ static inline void compileval(vector &code, int wordtype, char *word, int static bool compileword(vector &code, const char *&p, int wordtype, char *&word, int &wordlen); -static void compilelookup(vector &code, const char *&p, int ltype) -{ +static void compilelookup(vector &code, const char *&p, int ltype) { char *lookup = NULL; int lookuplen = 0; - switch(*++p) - { + switch(*++p) { case '(': case '[': if(!compileword(code, p, VAL_STR, lookup, lookuplen)) goto invalid; @@ -1057,24 +908,20 @@ static void compilelookup(vector &code, const char *&p, int ltype) case '\"': lookup = cutstring(p, lookuplen); goto lookupid; - default: - { + default: { lookup = cutword(p, lookuplen); if(!lookup) goto invalid; lookupid: ident *id = newident(lookup, IDF_UNKNOWN); - if(id) switch(id->type) - { + if(id) switch(id->type) { case ID_VAR: code.add(CODE_IVAR|((ltype >= VAL_ANY ? VAL_INT : ltype)<index<<8)); goto done; case ID_FVAR: code.add(CODE_FVAR|((ltype >= VAL_ANY ? VAL_FLOAT : ltype)<index<<8)); goto done; case ID_SVAR: code.add(CODE_SVAR|((ltype >= VAL_ANY ? VAL_STR : ltype)<index<<8)); goto done; case ID_ALIAS: code.add((id->index < MAXARGS ? CODE_LOOKUPARG : CODE_LOOKUP)|((ltype >= VAL_ANY ? VAL_STR : ltype)<index<<8)); goto done; - case ID_COMMAND: - { + case ID_COMMAND: { int comtype = CODE_COM, numargs = 0; code.add(CODE_ENTER); - for(const char *fmt = id->args; *fmt; fmt++) switch(*fmt) - { + for(const char *fmt = id->args; *fmt; fmt++) switch(*fmt) { case 's': compilestr(code, NULL, 0, true); numargs++; break; case 'i': compileint(code); numargs++; break; case 'b': compileint(code, INT_MIN); numargs++; break; @@ -1105,37 +952,31 @@ static void compilelookup(vector &code, const char *&p, int ltype) code.add(CODE_LOOKUPU|((ltype < VAL_ANY ? ltype< &code, const char *str, const char *end, bool macro) -{ +static bool compileblockstr(vector &code, const char *str, const char *end, bool macro) { int start = code.length(); code.add(macro ? CODE_MACRO : CODE_VAL|RET_STR); char *buf = (char *)code.reserve((end-str)/sizeof(uint)+1).buf; int len = 0; - while(str < end) - { + while(str < end) { int n = strcspn(str, "\r/\"@]\0"); memcpy(&buf[len], str, n); len += n; str += n; - switch(*str) - { + switch(*str) { case '\r': str++; break; - case '\"': - { + case '\"': { const char *start = str; str = parsestring(str+1); if(*str=='\"') str++; @@ -1144,11 +985,9 @@ static bool compileblockstr(vector &code, const char *str, const char *end break; } case '/': - if(str[1] == '/') - { + if(str[1] == '/') { size_t comment = strcspn(str, "\n\0"); - if (iscubepunct(str[2])) - { + if (iscubepunct(str[2])) { memcpy(&buf[len], str, comment); len += comment; } @@ -1171,12 +1010,10 @@ done: return true; } -static bool compileblocksub(vector &code, const char *&p) -{ +static bool compileblocksub(vector &code, const char *&p) { char *lookup = NULL; int lookuplen = 0; - switch(*p) - { + switch(*p) { case '(': if(!compilearg(code, p, VAL_STR)) return false; break; @@ -1187,9 +1024,8 @@ static bool compileblocksub(vector &code, const char *&p) case '\"': lookup = cutstring(p, lookuplen); goto lookupid; - default: - { - { + default: { + { const char *start = p; while(iscubealnum(*p) || *p=='_') p++; lookuplen = p-start; @@ -1198,8 +1034,7 @@ static bool compileblocksub(vector &code, const char *&p) } lookupid: ident *id = newident(lookup, IDF_UNKNOWN); - if(id) switch(id->type) - { + if(id) switch(id->type) { case ID_VAR: code.add(CODE_IVAR|RET_STR|(id->index<<8)); goto done; case ID_FVAR: code.add(CODE_FVAR|RET_STR|(id->index<<8)); goto done; case ID_SVAR: code.add(CODE_SVAR|RET_STR|(id->index<<8)); goto done; @@ -1215,16 +1050,13 @@ static bool compileblocksub(vector &code, const char *&p) return true; } -static void compileblock(vector &code, const char *&p, int wordtype) -{ +static void compileblock(vector &code, const char *&p, int wordtype) { const char *line = p, *start = p; int concs = 0; - for(int brak = 1; brak;) - { + for(int brak = 1; brak;) { p += strcspn(p, "@\"/[]\0"); int c = *p++; - switch(c) - { + switch(c) { case '\0': debugcodeline(line, "missing \"]\""); p--; @@ -1238,16 +1070,14 @@ static void compileblock(vector &code, const char *&p, int wordtype) break; case '[': brak++; break; case ']': brak--; break; - case '@': - { + case '@': { const char *esc = p; while(*p == '@') p++; int level = p - (esc - 1); if(brak > level) continue; else if(brak < level) debugcodeline(line, "too many @s"); if(!concs) code.add(CODE_ENTER); - if(concs + 2 > MAXARGS) - { + if(concs + 2 > MAXARGS) { code.add(CODE_CONCW|RET_STR|(concs<<8)); concs = 1; } @@ -1260,12 +1090,9 @@ static void compileblock(vector &code, const char *&p, int wordtype) } } done: - if(p-1 > start) - { - if(!concs) switch(wordtype) - { - case VAL_CODE: - { + if(p-1 > start) { + if(!concs) switch(wordtype) { + case VAL_CODE: { p = start; int inst = code.length(); code.add(CODE_BLOCK); @@ -1275,8 +1102,7 @@ done: code[inst] |= uint(code.length() - (inst + 1))<<8; return; } - case VAL_IDENT: - { + case VAL_IDENT: { char *name = newstring(start, p-1-start); compileident(code, name); delete[] name; @@ -1286,21 +1112,18 @@ done: compileblockstr(code, start, p-1, concs > 0); if(concs > 1) concs++; } - if(concs) - { + if(concs) { code.add(CODE_CONCM|(wordtype < VAL_ANY ? wordtype< &code, const char *&p, int wordtype, char *&word, int &wordlen) -{ +static bool compileword(vector &code, const char *&p, int wordtype, char *&word, int &wordlen) { skipcomments(p); - switch(*p) - { + switch(*p) { case '\"': word = cutstring(p, wordlen); break; case '$': compilelookup(code, p, wordtype); return true; case '(': @@ -1320,8 +1141,7 @@ static bool compileword(vector &code, const char *&p, int wordtype, char * code.add(CODE_ENTER); compilestatements(code, p, VAL_ANY, ')'); code.add(CODE_EXIT|(wordtype < VAL_ANY ? wordtype< &code, const char *&p, int wordtype, char * return word!=NULL; } -static inline bool compilearg(vector &code, const char *&p, int wordtype) -{ +static inline bool compilearg(vector &code, const char *&p, int wordtype) { char *word = NULL; int wordlen = 0; bool more = compileword(code, p, wordtype, word, wordlen); if(!more) return false; - if(word) - { + if(word) { compileval(code, wordtype, word, wordlen); delete[] word; } return true; } -static void compilestatements(vector &code, const char *&p, int rettype, int brak) -{ +static void compilestatements(vector &code, const char *&p, int rettype, int brak) { const char *line = p; char *idname = NULL; int idlen = 0; ident *id = NULL; int numargs = 0; - for(;;) - { + for(;;) { skipcomments(p); idname = NULL; bool more = compileword(code, p, VAL_ANY, idname, idlen); if(!more) goto endstatement; skipcomments(p); - if(p[0] == '=') switch(p[1]) - { + if(p[0] == '=') switch(p[1]) { case '/': if(p[2] != '/') break; [[fallthrough]]; @@ -1380,11 +1195,9 @@ static void compilestatements(vector &code, const char *&p, int rettype, i [[fallthrough]]; case '\0': p++; - if(idname) - { + if(idname) { id = newident(idname, IDF_UNKNOWN); - if(id) switch(id->type) - { + if(id) switch(id->type) { case ID_ALIAS: if(!(more = compilearg(code, p, VAL_ANY))) compilestr(code); code.add((id->index < MAXARGS ? CODE_ALIASARG : CODE_ALIAS)|(id->index<<8)); @@ -1414,17 +1227,14 @@ static void compilestatements(vector &code, const char *&p, int rettype, i } compilecommand: numargs = 0; - if(!idname) - { + if(!idname) { noid: while(numargs < MAXARGS && (more = compilearg(code, p, VAL_ANY))) numargs++; code.add(CODE_CALLU); } - else - { + else { id = idents.access(idname); - if(!id) - { + if(!id) { if(!checknumber(idname)) { compilestr(code, idname, idlen); delete[] idname; goto noid; } char *end = idname; int val = int(strtoul(idname, &end, 0)); @@ -1432,28 +1242,23 @@ static void compilestatements(vector &code, const char *&p, int rettype, i else compileint(code, val); code.add(CODE_RESULT); } - else switch(id->type) - { + else switch(id->type) { case ID_ALIAS: while(numargs < MAXARGS && (more = compilearg(code, p, VAL_ANY))) numargs++; code.add((id->index < MAXARGS ? CODE_CALLARG : CODE_CALL)|(id->index<<8)); break; - case ID_COMMAND: - { + case ID_COMMAND: { int comtype = CODE_COM, fakeargs = 0; bool rep = false; - for(const char *fmt = id->args; *fmt; fmt++) switch(*fmt) - { + for(const char *fmt = id->args; *fmt; fmt++) switch(*fmt) { case 's': if(more) more = compilearg(code, p, VAL_STR); - if(!more) - { + if(!more) { if(rep) break; compilestr(code, NULL, 0, true); fakeargs++; } - else if(!fmt[1]) - { + else if(!fmt[1]) { int numconc = 0; while(numargs + numconc < MAXARGS && (more = compilearg(code, p, VAL_STR))) numconc++; if(numconc > 0) code.add(CODE_CONC|RET_STR|((numconc+1)<<8)); @@ -1474,8 +1279,7 @@ static void compilestatements(vector &code, const char *&p, int rettype, i case 'C': comtype = CODE_COMC; if(more) while(numargs < MAXARGS && (more = compilearg(code, p, VAL_ANY))) numargs++; numargs = 1; goto endfmt; case 'V': comtype = CODE_COMV; if(more) while(numargs < MAXARGS && (more = compilearg(code, p, VAL_ANY))) numargs++; numargs = 2; goto endfmt; case '1': case '2': case '3': case '4': - if(more && numargs < MAXARGS) - { + if(more && numargs < MAXARGS) { int numrep = *fmt-'0'+1; fmt -= numrep; rep = true; @@ -1504,8 +1308,7 @@ static void compilestatements(vector &code, const char *&p, int rettype, i break; case ID_SVAR: if(!(more = compilearg(code, p, VAL_STR))) code.add(CODE_PRINT|(id->index<<8)); - else - { + else { int numconc = 0; while(numconc+1 < MAXARGS && (more = compilearg(code, p, VAL_ANY))) numconc++; if(numconc > 0) code.add(CODE_CONC|RET_STR|((numconc+1)<<8)); @@ -1520,19 +1323,16 @@ static void compilestatements(vector &code, const char *&p, int rettype, i if(more) while(compilearg(code, p, VAL_ANY)) code.add(CODE_POP); p += strcspn(p, ")];/\n\0"); int c = *p++; - switch(c) - { + switch(c) { case '\0': if(c != brak) debugcodeline(line, "missing \"%c\"", brak); p--; return; - case ')': case ']': if(c == brak) return; debugcodeline(line, "unexpected \"%c\"", c); break; - case '/': if(*p == '/') p += strcspn(p, "\n\0"); goto endstatement; @@ -1540,15 +1340,13 @@ static void compilestatements(vector &code, const char *&p, int rettype, i } } -static void compilemain(vector &code, const char *p, int rettype = VAL_ANY) -{ +static void compilemain(vector &code, const char *p, int rettype = VAL_ANY) { code.add(CODE_START); compilestatements(code, p, VAL_ANY); code.add(CODE_EXIT|(rettype < VAL_ANY ? rettype< buf; buf.reserve(64); compilemain(buf, p); @@ -1558,17 +1356,14 @@ uint *compilecode(const char *p) return code; } -void keepcode(uint *code) -{ +void keepcode(uint *code) { if(!code) return; - switch(*code&CODE_OP_MASK) - { + switch(*code&CODE_OP_MASK) { case CODE_START: *code += 0x100; return; } - switch(code[-1]&CODE_OP_MASK) - { + switch(code[-1]&CODE_OP_MASK) { case CODE_START: code[-1] += 0x100; break; @@ -1579,18 +1374,15 @@ void keepcode(uint *code) } } -void freecode(uint *code) -{ +void freecode(uint *code) { if(!code) return; - switch(*code&CODE_OP_MASK) - { + switch(*code&CODE_OP_MASK) { case CODE_START: *code -= 0x100; if(int(*code) < 0x100) delete[] code; return; } - switch(code[-1]&CODE_OP_MASK) - { + switch(code[-1]&CODE_OP_MASK) { case CODE_START: code[-1] -= 0x100; if(int(code[-1]) < 0x100) delete[] &code[-1]; @@ -1603,8 +1395,7 @@ void freecode(uint *code) } } -void printvar(ident *id, int i) -{ +void printvar(ident *id, int i) { if(i < 0) conoutf(CON_INFO, id->index, "%s = %d", id->name, i); else if(id->flags&IDF_HEX && id->maxval==0xFFFFFF) conoutf(CON_INFO, id->index, "%s = 0x%.6X (%d, %d, %d)", id->name, i, (i>>16)&0xFF, (i>>8)&0xFF, i&0xFF); @@ -1612,38 +1403,31 @@ void printvar(ident *id, int i) conoutf(CON_INFO, id->index, id->flags&IDF_HEX ? "%s = 0x%X" : "%s = %d", id->name, i); } -void printfvar(ident *id, float f) -{ +void printfvar(ident *id, float f) { conoutf(CON_INFO, id->index, "%s = %s", id->name, floatstr(f)); } -void printsvar(ident *id, const char *s) -{ +void printsvar(ident *id, const char *s) { conoutf(CON_INFO, id->index, strchr(s, '"') ? "%s = [%s]" : "%s = \"%s\"", id->name, s); } template -static void printvar(ident *id, int type, V &val) -{ - switch(type) - { +static void printvar(ident *id, int type, V &val) { + switch(type) { case VAL_INT: printvar(id, val.getint()); break; case VAL_FLOAT: printfvar(id, val.getfloat()); break; default: printsvar(id, val.getstr()); break; } } -void printvar(ident *id) -{ - switch(id->type) - { +void printvar(ident *id) { + switch(id->type) { case ID_VAR: printvar(id, *id->storage.i); break; case ID_FVAR: printfvar(id, *id->storage.f); break; case ID_SVAR: printsvar(id, *id->storage.s); break; case ID_ALIAS: printvar(id, id->valtype, *id); break; case ID_COMMAND: - if(id->flags&IDF_EMUVAR) - { + if(id->flags&IDF_EMUVAR) { tagval result; executeret(id, NULL, 0, true, result); printvar(id, result.type, result); @@ -1669,23 +1453,18 @@ typedef void (__cdecl *comfun11)(void *, void *, void *, void *, void *, void *, typedef void (__cdecl *comfun12)(void *, void *, void *, void *, void *, void *, void *, void *, void *, void *, void *, void *); typedef void (__cdecl *comfunv)(tagval *, int); -static const uint *skipcode(const uint *code, tagval &result) -{ +static const uint *skipcode(const uint *code, tagval &result) { int depth = 0; - for(;;) - { + for(;;) { uint op = *code++; - switch(op&0xFF) - { + switch(op&0xFF) { case CODE_MACRO: - case CODE_VAL|RET_STR: - { + case CODE_VAL|RET_STR: { uint len = op>>8; code += len/sizeof(uint) + 1; continue; } - case CODE_BLOCK: - { + case CODE_BLOCK: { uint len = op>>8; code += len; continue; @@ -1694,8 +1473,7 @@ static const uint *skipcode(const uint *code, tagval &result) ++depth; continue; case CODE_EXIT|RET_NULL: case CODE_EXIT|RET_STR: case CODE_EXIT|RET_INT: case CODE_EXIT|RET_FLOAT: - if(depth <= 0) - { + if(depth <= 0) { forcearg(result, op&CODE_RET_MASK); return code; } @@ -1705,27 +1483,23 @@ static const uint *skipcode(const uint *code, tagval &result) } } -static inline void callcommand(ident *id, tagval *args, int numargs, bool lookup = false) -{ +static inline void callcommand(ident *id, tagval *args, int numargs, bool lookup = false) { int i = -1, fakeargs = 0; bool rep = false; - for(const char *fmt = id->args; *fmt; fmt++) switch(*fmt) - { + for(const char *fmt = id->args; *fmt; fmt++) switch(*fmt) { case 'i': if(++i >= numargs) { if(rep) break; args[i].setint(0); fakeargs++; } else forceint(args[i]); break; case 'b': if(++i >= numargs) { if(rep) break; args[i].setint(INT_MIN); fakeargs++; } else forceint(args[i]); break; case 'f': if(++i >= numargs) { if(rep) break; args[i].setfloat(0.0f); fakeargs++; } else forcefloat(args[i]); break; case 's': if(++i >= numargs) { if(rep) break; args[i].setstr(newstring("")); fakeargs++; } else forcestr(args[i]); break; case 't': if(++i >= numargs) { if(rep) break; args[i].setnull(); fakeargs++; } break; case 'e': - if(++i >= numargs) - { + if(++i >= numargs) { if(rep) break; static uint buf[2] = { CODE_START + 0x100, CODE_EXIT }; args[i].setcode(buf); fakeargs++; } - else - { + else { vector buf; buf.reserve(64); compilemain(buf, numargs <= i ? "" : args[i].getstr()); @@ -1746,8 +1520,8 @@ static inline void callcommand(ident *id, tagval *args, int numargs, bool lookup } #define ARG(n) (id->argmask&(1<fun)(); break; \ case 1: ((comfun1)id->fun)(ARG(0)); break; \ case 2: ((comfun2)id->fun)(ARG(0), ARG(1)); break; \ @@ -1772,11 +1546,9 @@ cleanup: #define MAXRUNDEPTH 255 static int rundepth = 0; -static const uint *runcode(const uint *code, tagval &result) -{ +static const uint *runcode(const uint *code, tagval &result) { result.setnull(); - if(rundepth >= MAXRUNDEPTH) - { + if(rundepth >= MAXRUNDEPTH) { debugcode("exceeded recursion limit"); return skipcode(code, result); } @@ -1785,13 +1557,10 @@ static const uint *runcode(const uint *code, tagval &result) int numargs = 0; tagval args[MAXARGS+1], *prevret = commandret; commandret = &result; - for(;;) - { + for(;;) { uint op = *code++; - switch(op&0xFF) - { + switch(op&0xFF) { case CODE_START: case CODE_OFFSET: continue; - case CODE_POP: freearg(args[--numargs]); continue; @@ -1804,8 +1573,7 @@ static const uint *runcode(const uint *code, tagval &result) case CODE_PRINT: printvar(identmap[op>>8]); continue; - case CODE_LOCAL: - { + case CODE_LOCAL: { identstack locals[MAXARGS]; freearg(result); loopi(numargs) pushalias(*args[i].id, locals[i]); @@ -1813,24 +1581,19 @@ static const uint *runcode(const uint *code, tagval &result) loopi(numargs) popalias(*args[i].id); goto exit; } - - case CODE_MACRO: - { + case CODE_MACRO: { uint len = op>>8; args[numargs++].setmacro(code); code += len/sizeof(uint) + 1; continue; } - - case CODE_VAL|RET_STR: - { + case CODE_VAL|RET_STR: { uint len = op>>8; args[numargs++].setstr(newstring((const char *)code, len)); code += len/sizeof(uint) + 1; continue; } - case CODE_VALI|RET_STR: - { + case CODE_VALI|RET_STR: { char s[4] = { char((op>>8)&0xFF), char((op>>16)&0xFF), char((op>>24)&0xFF), '\0' }; args[numargs++].setstr(newstring(s)); continue; @@ -1841,11 +1604,9 @@ static const uint *runcode(const uint *code, tagval &result) case CODE_VALI|RET_INT: args[numargs++].setint(int(op)>>8); continue; case CODE_VAL|RET_FLOAT: args[numargs++].setfloat(*(const float *)code++); continue; case CODE_VALI|RET_FLOAT: args[numargs++].setfloat(float(int(op)>>8)); continue; - case CODE_FORCE|RET_STR: forcestr(args[numargs-1]); continue; case CODE_FORCE|RET_INT: forceint(args[numargs-1]); continue; case CODE_FORCE|RET_FLOAT: forcefloat(args[numargs-1]); continue; - case CODE_RESULT|RET_NULL: case CODE_RESULT|RET_STR: case CODE_RESULT|RET_INT: case CODE_RESULT|RET_FLOAT: litval: freearg(result); @@ -1854,20 +1615,16 @@ static const uint *runcode(const uint *code, tagval &result) args[0].setnull(); freeargs(args, numargs, 0); continue; - - case CODE_BLOCK: - { + case CODE_BLOCK: { uint len = op>>8; args[numargs++].setcode(code+1); code += len; continue; } - case CODE_COMPILE: - { + case CODE_COMPILE: { tagval &arg = args[numargs-1]; vector buf; - switch(arg.type) - { + switch(arg.type) { case VAL_INT: buf.reserve(8); buf.add(CODE_START); compileint(buf, arg.i); buf.add(CODE_RESULT); buf.add(CODE_EXIT); break; case VAL_FLOAT: buf.reserve(8); buf.add(CODE_START); compilefloat(buf, arg.f); buf.add(CODE_RESULT); buf.add(CODE_EXIT); break; case VAL_STR: case VAL_MACRO: buf.reserve(64); compilemain(buf, arg.s); freearg(arg); break; @@ -1877,27 +1634,22 @@ static const uint *runcode(const uint *code, tagval &result) buf.disown(); continue; } - case CODE_IDENT: args[numargs++].setident(identmap[op>>8]); continue; - case CODE_IDENTARG: - { + case CODE_IDENTARG: { ident *id = identmap[op>>8]; - if(!(aliasstack->usedargs&(1<index))) - { + if(!(aliasstack->usedargs&(1<index))) { pusharg(*id, nullval, aliasstack->argstack[id->index]); aliasstack->usedargs |= 1<index; } args[numargs++].setident(id); continue; } - case CODE_IDENTU: - { + case CODE_IDENTU: { tagval &arg = args[numargs-1]; ident *id = arg.type == VAL_STR || arg.type == VAL_MACRO ? newident(arg.s, IDF_UNKNOWN) : dummyident; - if(id->index < MAXARGS && !(aliasstack->usedargs&(1<index))) - { + if(id->index < MAXARGS && !(aliasstack->usedargs&(1<index))) { pusharg(*id, nullval, aliasstack->argstack[id->index]); aliasstack->usedargs |= 1<index; } @@ -1905,14 +1657,13 @@ static const uint *runcode(const uint *code, tagval &result) arg.setident(id); continue; } - case CODE_LOOKUPU|RET_STR: #define LOOKUPU(aval, sval, ival, fval, nval) { \ tagval &arg = args[numargs-1]; \ if(arg.type != VAL_STR && arg.type != VAL_MACRO) continue; \ id = idents.access(arg.s); \ - if(id) switch(id->type) \ - { \ + if(id) switch(id->type) { \ + \ case ID_ALIAS: \ if(id->flags&IDF_UNKNOWN) break; \ freearg(arg); \ @@ -1922,8 +1673,8 @@ static const uint *runcode(const uint *code, tagval &result) case ID_SVAR: freearg(arg); sval; continue; \ case ID_VAR: freearg(arg); ival; continue; \ case ID_FVAR: freearg(arg); fval; continue; \ - case ID_COMMAND: \ - { \ + case ID_COMMAND: { \ + \ freearg(arg); \ arg.setnull(); \ commandret = &arg; \ @@ -1991,24 +1742,20 @@ static const uint *runcode(const uint *code, tagval &result) LOOKUP(id->getval(args[numargs++])); case CODE_LOOKUPARG|RET_NULL: LOOKUPARG(id->getval(args[numargs++]), args[numargs++].setnull()); - case CODE_SVAR|RET_STR: case CODE_SVAR|RET_NULL: args[numargs++].setstr(newstring(*identmap[op>>8]->storage.s)); continue; case CODE_SVAR|RET_INT: args[numargs++].setint(parseint(*identmap[op>>8]->storage.s)); continue; case CODE_SVAR|RET_FLOAT: args[numargs++].setfloat(parsefloat(*identmap[op>>8]->storage.s)); continue; case CODE_SVAR1: setsvarchecked(identmap[op>>8], args[0].s); freeargs(args, numargs, 0); continue; - case CODE_IVAR|RET_INT: case CODE_IVAR|RET_NULL: args[numargs++].setint(*identmap[op>>8]->storage.i); continue; case CODE_IVAR|RET_STR: args[numargs++].setstr(newstring(intstr(*identmap[op>>8]->storage.i))); continue; case CODE_IVAR|RET_FLOAT: args[numargs++].setfloat(float(*identmap[op>>8]->storage.i)); continue; case CODE_IVAR1: setvarchecked(identmap[op>>8], args[0].i); numargs = 0; continue; case CODE_IVAR2: setvarchecked(identmap[op>>8], (args[0].i<<16)|(args[1].i<<8)); numargs = 0; continue; case CODE_IVAR3: setvarchecked(identmap[op>>8], (args[0].i<<16)|(args[1].i<<8)|args[2].i); numargs = 0; continue; - case CODE_FVAR|RET_FLOAT: case CODE_FVAR|RET_NULL: args[numargs++].setfloat(*identmap[op>>8]->storage.f); continue; case CODE_FVAR|RET_STR: args[numargs++].setstr(newstring(floatstr(*identmap[op>>8]->storage.f))); continue; case CODE_FVAR|RET_INT: args[numargs++].setint(int(*identmap[op>>8]->storage.f)); continue; case CODE_FVAR1: setfvarchecked(identmap[op>>8], args[0].f); numargs = 0; continue; - case CODE_COM|RET_NULL: case CODE_COM|RET_STR: case CODE_COM|RET_FLOAT: case CODE_COM|RET_INT: id = identmap[op>>8]; #ifndef STANDALONE @@ -2034,17 +1781,14 @@ static const uint *runcode(const uint *code, tagval &result) goto forceresult; case CODE_COMC|RET_NULL: case CODE_COMC|RET_STR: case CODE_COMC|RET_FLOAT: case CODE_COMC|RET_INT: id = identmap[op>>8]; - forcenull(result); - { + forcenull(result); { vector buf; buf.reserve(MAXSTRLEN); ((comfun1)id->fun)(conc(buf, args, numargs, true)); } goto forceresult; - case CODE_CONC|RET_NULL: case CODE_CONC|RET_STR: case CODE_CONC|RET_FLOAT: case CODE_CONC|RET_INT: - case CODE_CONCW|RET_NULL: case CODE_CONCW|RET_STR: case CODE_CONCW|RET_FLOAT: case CODE_CONCW|RET_INT: - { + case CODE_CONCW|RET_NULL: case CODE_CONCW|RET_STR: case CODE_CONCW|RET_FLOAT: case CODE_CONCW|RET_INT: { int numconc = op>>8; char *s = conc(&args[numargs-numconc], numconc, (op&CODE_OP_MASK)==CODE_CONC); freeargs(args, numargs, numargs-numconc); @@ -2052,9 +1796,7 @@ static const uint *runcode(const uint *code, tagval &result) forcearg(args[numargs-1], op&CODE_RET_MASK); continue; } - - case CODE_CONCM|RET_NULL: case CODE_CONCM|RET_STR: case CODE_CONCM|RET_FLOAT: case CODE_CONCM|RET_INT: - { + case CODE_CONCM|RET_NULL: case CODE_CONCM|RET_STR: case CODE_CONCM|RET_FLOAT: case CODE_CONCM|RET_INT: { int numconc = op>>8; char *s = conc(&args[numargs-numconc], numconc, false); freeargs(args, numargs, numargs-numconc); @@ -2062,7 +1804,6 @@ static const uint *runcode(const uint *code, tagval &result) forcearg(result, op&CODE_RET_MASK); continue; } - case CODE_ALIAS: setalias(*identmap[op>>8], args[--numargs]); freeargs(args, numargs, 0); @@ -2076,7 +1817,6 @@ static const uint *runcode(const uint *code, tagval &result) setalias(args[0].s, args[--numargs]); freeargs(args, numargs, 0); continue; - case CODE_CALL|RET_NULL: case CODE_CALL|RET_STR: case CODE_CALL|RET_FLOAT: case CODE_CALL|RET_INT: #define CALLALIAS(offset) { \ identstack argstack[MAXARGS]; \ @@ -2106,8 +1846,7 @@ static const uint *runcode(const uint *code, tagval &result) } forcenull(result); id = identmap[op>>8]; - if(id->flags&IDF_UNKNOWN) - { + if(id->flags&IDF_UNKNOWN) { debugcode("unknown command: %s", id->name); goto forceresult; } @@ -2119,12 +1858,10 @@ static const uint *runcode(const uint *code, tagval &result) if(!(aliasstack->usedargs&(1<index))) goto forceresult; CALLALIAS(0); continue; - case CODE_CALLU|RET_NULL: case CODE_CALLU|RET_STR: case CODE_CALLU|RET_FLOAT: case CODE_CALLU|RET_INT: if(args[0].type != VAL_STR) goto litval; id = idents.access(args[0].s); - if(!id) - { + if(!id) { noid: if(checknumber(args[0].s)) goto litval; debugcode("unknown command: %s", args[0].s); @@ -2132,16 +1869,14 @@ static const uint *runcode(const uint *code, tagval &result) goto forceresult; } forcenull(result); - switch(id->type) - { + switch(id->type) { case ID_COMMAND: freearg(args[0]); callcommand(id, args+1, numargs-1); forcearg(result, op&CODE_RET_MASK); numargs = 0; continue; - case ID_LOCAL: - { + case ID_LOCAL: { identstack locals[MAXARGS]; freearg(args[0]); loopj(numargs-1) pushalias(*forceident(args[j+1]), locals[j]); @@ -2175,13 +1910,11 @@ exit: return code; } -void executeret(const uint *code, tagval &result) -{ +void executeret(const uint *code, tagval &result) { runcode(code, result); } -void executeret(const char *p, tagval &result) -{ +void executeret(const char *p, tagval &result) { vector code; code.reserve(64); compilemain(code, p, VAL_ANY); @@ -2189,21 +1922,18 @@ void executeret(const char *p, tagval &result) if(int(code[0]) >= 0x100) code.disown(); } -void executeret(ident *id, tagval *args, int numargs, bool lookup, tagval &result) -{ +void executeret(ident *id, tagval *args, int numargs, bool lookup, tagval &result) { result.setnull(); ++rundepth; tagval *prevret = commandret; commandret = &result; if(rundepth > MAXRUNDEPTH) debugcode("exceeded recursion limit"); - else if(id) switch(id->type) - { + else if(id) switch(id->type) { default: if(!id->fun) break; // fall-through case ID_COMMAND: - if(numargs < id->numargs) - { + if(numargs < id->numargs) { tagval buf[MAXARGS]; memcpy(buf, args, numargs*sizeof(tagval)); callcommand(id, buf, numargs, lookup); @@ -2233,8 +1963,7 @@ void executeret(ident *id, tagval *args, int numargs, bool lookup, tagval &resul --rundepth; } -char *executestr(const uint *code) -{ +char *executestr(const uint *code) { tagval result; runcode(code, result); if(result.type == VAL_NULL) return NULL; @@ -2242,8 +1971,7 @@ char *executestr(const uint *code) return result.s; } -char *executestr(const char *p) -{ +char *executestr(const char *p) { tagval result; executeret(p, result); if(result.type == VAL_NULL) return NULL; @@ -2251,8 +1979,7 @@ char *executestr(const char *p) return result.s; } -char *executestr(ident *id, tagval *args, int numargs, bool lookup) -{ +char *executestr(ident *id, tagval *args, int numargs, bool lookup) { tagval result; executeret(id, args, numargs, lookup, result); if(result.type == VAL_NULL) return NULL; @@ -2260,14 +1987,12 @@ char *executestr(ident *id, tagval *args, int numargs, bool lookup) return result.s; } -char *execidentstr(const char *name, bool lookup) -{ +char *execidentstr(const char *name, bool lookup) { ident *id = idents.access(name); return id ? executestr(id, NULL, 0, lookup) : NULL; } -int execute(const uint *code) -{ +int execute(const uint *code) { tagval result; runcode(code, result); int i = result.getint(); @@ -2275,8 +2000,7 @@ int execute(const uint *code) return i; } -int execute(const char *p) -{ +int execute(const char *p) { vector code; code.reserve(64); compilemain(code, p, VAL_INT); @@ -2288,8 +2012,7 @@ int execute(const char *p) return i; } -int execute(ident *id, tagval *args, int numargs, bool lookup) -{ +int execute(ident *id, tagval *args, int numargs, bool lookup) { tagval result; executeret(id, args, numargs, lookup, result); int i = result.getint(); @@ -2297,31 +2020,25 @@ int execute(ident *id, tagval *args, int numargs, bool lookup) return i; } -int execident(const char *name, int noid, bool lookup) -{ +int execident(const char *name, int noid, bool lookup) { ident *id = idents.access(name); return id ? execute(id, NULL, 0, lookup) : noid; } -static inline bool getbool(const char *s) -{ - switch(s[0]) - { +static inline bool getbool(const char *s) { + switch(s[0]) { case '+': case '-': - switch(s[1]) - { + switch(s[1]) { case '0': break; case '.': return !isdigit(s[2]) || parsefloat(s) != 0; default: return true; } // fall through - case '0': - { + case '0': { char *end; int val = int(strtoul((char *)s, &end, 0)); if(val) return true; - switch(*end) - { + switch(*end) { case 'e': case '.': return parsefloat(s) != 0; default: return false; } @@ -2332,10 +2049,8 @@ static inline bool getbool(const char *s) } } -static inline bool getbool(const tagval &v) -{ - switch(v.type) - { +static inline bool getbool(const tagval &v) { + switch(v.type) { case VAL_FLOAT: return v.f!=0; case VAL_INT: return v.i!=0; case VAL_STR: case VAL_MACRO: return getbool(v.s); @@ -2343,8 +2058,7 @@ static inline bool getbool(const tagval &v) } } -bool executebool(const uint *code) -{ +bool executebool(const uint *code) { tagval result; runcode(code, result); bool b = getbool(result); @@ -2352,8 +2066,7 @@ bool executebool(const uint *code) return b; } -bool executebool(const char *p) -{ +bool executebool(const char *p) { tagval result; executeret(p, result); bool b = getbool(result); @@ -2361,8 +2074,7 @@ bool executebool(const char *p) return b; } -bool executebool(ident *id, tagval *args, int numargs, bool lookup) -{ +bool executebool(ident *id, tagval *args, int numargs, bool lookup) { tagval result; executeret(id, args, numargs, lookup, result); bool b = getbool(result); @@ -2370,19 +2082,16 @@ bool executebool(ident *id, tagval *args, int numargs, bool lookup) return b; } -bool execidentbool(const char *name, bool noid, bool lookup) -{ +bool execidentbool(const char *name, bool noid, bool lookup) { ident *id = idents.access(name); return id ? executebool(id, NULL, 0, lookup) : noid; } -bool execfile(const char *cfgfile, bool msg) -{ +bool execfile(const char *cfgfile, bool msg) { string s; copystring(s, cfgfile); char *buf = loadfile(path(s), NULL); - if(!buf) - { + if(!buf) { if(msg) conoutf(CON_ERROR, "could not read \"%s\"", cfgfile); return false; } @@ -2397,16 +2106,14 @@ bool execfile(const char *cfgfile, bool msg) } ICOMMAND(exec, "sb", (char *file, int *msg), intret(execfile(file, *msg != 0) ? 1 : 0)); -const char *escapestring(const char *s) -{ +const char *escapestring(const char *s) { static vector strbuf[3]; static int stridx = 0; stridx = (stridx + 1)%3; vector &buf = strbuf[stridx]; buf.setsize(0); buf.add('"'); - for(; *s; s++) switch(*s) - { + for(; *s; s++) switch(*s) { case '\n': buf.put("^n", 2); break; case '\t': buf.put("^t", 2); break; case '\f': buf.put("^f", 2); break; @@ -2419,27 +2126,23 @@ const char *escapestring(const char *s) } ICOMMAND(escape, "s", (char *s), result(escapestring(s))); -ICOMMAND(unescape, "s", (char *s), -{ +ICOMMAND(unescape, "s", (char *s), { int len = strlen(s); char *d = newstring(len); d[unescapestring(d, s, &s[len])] = '\0'; stringret(d); }); -const char *escapeid(const char *s) -{ +const char *escapeid(const char *s) { const char *end = s + strcspn(s, "\"/;()[]@ \f\t\r\n\0"); return *end ? escapestring(s) : s; } -bool validateblock(const char *s) -{ +bool validateblock(const char *s) { const int maxbrak = 100; static char brakstack[maxbrak]; int brakdepth = 0; - for(; *s; s++) switch(*s) - { + for(; *s; s++) switch(*s) { case '[': case '(': if(brakdepth >= maxbrak) return false; brakstack[brakdepth++] = *s; break; case ']': if(brakdepth <= 0 || brakstack[--brakdepth] != '[') return false; break; case ')': if(brakdepth <= 0 || brakstack[--brakdepth] != '(') return false; break; @@ -2451,8 +2154,7 @@ bool validateblock(const char *s) } #ifndef STANDALONE -void writecfg(const char *name) -{ +void writecfg(const char *name) { stream *f = openutf8file(path(name && name[0] ? name : game::savedconfig(), true), "w"); if(!f) return; f->printf("// automatically written on exit, DO NOT MODIFY\n// delete this file to have %s overwrite these settings\n// modify settings in game, or put settings in %s to override anything\n\n", game::defaultconfig(), game::autoexec()); @@ -2462,11 +2164,9 @@ void writecfg(const char *name) vector ids; enumerate(idents, ident, id, ids.add(&id)); ids.sortname(); - loopv(ids) - { + loopv(ids) { ident &id = *ids[i]; - if(id.flags&IDF_PERSIST) switch(id.type) - { + if(id.flags&IDF_PERSIST) switch(id.type) { case ID_VAR: f->printf("%s %d\n", escapeid(id), *id.storage.i); break; case ID_FVAR: f->printf("%s %s\n", escapeid(id), floatstr(*id.storage.f)); break; case ID_SVAR: f->printf("%s %s\n", escapeid(id), escapestring(*id.storage.s)); break; @@ -2475,11 +2175,9 @@ void writecfg(const char *name) f->printf("\n"); writebinds(f); f->printf("\n"); - loopv(ids) - { + loopv(ids) { ident &id = *ids[i]; - if(id.type==ID_ALIAS && id.flags&IDF_PERSIST && !(id.flags&IDF_OVERRIDDEN)) switch(id.valtype) - { + if(id.type==ID_ALIAS && id.flags&IDF_PERSIST && !(id.flags&IDF_OVERRIDDEN)) switch(id.valtype) { case VAL_STR: if(!id.val.s[0]) break; if(!validateblock(id.val.s)) { f->printf("%s = %s\n", escapeid(id), escapestring(id.val.s)); break; } @@ -2498,8 +2196,7 @@ void writecfg(const char *name) COMMAND(writecfg, "s"); #endif -void changedvars() -{ +void changedvars() { vector ids; enumerate(idents, ident, id, if(id.flags&IDF_OVERRIDDEN) ids.add(&id)); ids.sortname(); @@ -2513,27 +2210,23 @@ COMMAND(changedvars, ""); static string retbuf[4]; static int retidx = 0; -const char *intstr(int v) -{ +const char *intstr(int v) { retidx = (retidx + 1)%4; intformat(retbuf[retidx], v); return retbuf[retidx]; } -void intret(int v) -{ +void intret(int v) { commandret->setint(v); } -const char *floatstr(float v) -{ +const char *floatstr(float v) { retidx = (retidx + 1)%4; floatformat(retbuf[retidx], v); return retbuf[retidx]; } -void floatret(float v) -{ +void floatret(float v) { commandret->setfloat(v); } @@ -2544,11 +2237,9 @@ ICOMMAND(do, "e", (uint *body), executeret(body, *commandret)); ICOMMAND(if, "tee", (tagval *cond, uint *t, uint *f), executeret(getbool(*cond) ? t : f, *commandret)); ICOMMAND(?, "ttt", (tagval *cond, tagval *t, tagval *f), result(*(getbool(*cond) ? t : f))); -ICOMMAND(pushif, "rte", (ident *id, tagval *v, uint *code), -{ +ICOMMAND(pushif, "rte", (ident *id, tagval *v, uint *code), { if(id->type != ID_ALIAS || id->index < MAXARGS) return; - if(getbool(*v)) - { + if(getbool(*v)) { identstack stack; pusharg(*id, *v, stack); v->type = VAL_NULL; @@ -2558,63 +2249,51 @@ ICOMMAND(pushif, "rte", (ident *id, tagval *v, uint *code), } }); -void loopiter(ident *id, identstack &stack, const tagval &v) -{ - if(id->stack != &stack) - { +void loopiter(ident *id, identstack &stack, const tagval &v) { + if(id->stack != &stack) { pusharg(*id, v, stack); id->flags &= ~IDF_UNKNOWN; } - else - { + else { if(id->valtype == VAL_STR) delete[] id->val.s; cleancode(*id); id->setval(v); } } -void loopend(ident *id, identstack &stack) -{ +void loopend(ident *id, identstack &stack) { if(id->stack == &stack) poparg(*id); } -static inline void setiter(ident &id, int i, identstack &stack) -{ - if(id.stack == &stack) - { - if(id.valtype != VAL_INT) - { +static inline void setiter(ident &id, int i, identstack &stack) { + if(id.stack == &stack) { + if(id.valtype != VAL_INT) { if(id.valtype == VAL_STR) delete[] id.val.s; cleancode(id); id.valtype = VAL_INT; } id.val.i = i; } - else - { + else { tagval t; t.setint(i); pusharg(id, t, stack); id.flags &= ~IDF_UNKNOWN; } } -ICOMMAND(loop, "rie", (ident *id, int *n, uint *body), -{ +ICOMMAND(loop, "rie", (ident *id, int *n, uint *body), { if(*n <= 0 || id->type!=ID_ALIAS) return; identstack stack; - loopi(*n) - { + loopi(*n) { setiter(*id, i, stack); execute(body); } poparg(*id); }); -ICOMMAND(loopwhile, "riee", (ident *id, int *n, uint *cond, uint *body), -{ +ICOMMAND(loopwhile, "riee", (ident *id, int *n, uint *cond, uint *body), { if(*n <= 0 || id->type!=ID_ALIAS) return; identstack stack; - loopi(*n) - { + loopi(*n) { setiter(*id, i, stack); if(!executebool(cond)) break; execute(body); @@ -2623,12 +2302,10 @@ ICOMMAND(loopwhile, "riee", (ident *id, int *n, uint *cond, uint *body), }); ICOMMAND(while, "ee", (uint *cond, uint *body), while(executebool(cond)) execute(body)); -char *loopconc(ident *id, int n, uint *body, bool space) -{ +char *loopconc(ident *id, int n, uint *body, bool space) { identstack stack; vector s; - loopi(n) - { + loopi(n) { setiter(*id, i, stack); tagval v; executeret(body, v); @@ -2643,39 +2320,32 @@ char *loopconc(ident *id, int n, uint *body, bool space) return newstring(s.getbuf(), s.length()-1); } -ICOMMAND(loopconcat, "rie", (ident *id, int *n, uint *body), -{ +ICOMMAND(loopconcat, "rie", (ident *id, int *n, uint *body), { if(*n > 0 && id->type==ID_ALIAS) commandret->setstr(loopconc(id, *n, body, true)); }); -ICOMMAND(loopconcatword, "rie", (ident *id, int *n, uint *body), -{ +ICOMMAND(loopconcatword, "rie", (ident *id, int *n, uint *body), { if(*n > 0 && id->type==ID_ALIAS) commandret->setstr(loopconc(id, *n, body, false)); }); -void concat(tagval *v, int n) -{ +void concat(tagval *v, int n) { commandret->setstr(conc(v, n, true)); } COMMAND(concat, "V"); -void concatword(tagval *v, int n) -{ +void concatword(tagval *v, int n) { commandret->setstr(conc(v, n, false)); } COMMAND(concatword, "V"); -void append(ident *id, tagval *v, bool space) -{ +void append(ident *id, tagval *v, bool space) { if(id->type != ID_ALIAS || v->type == VAL_NULL) return; - if(id->valtype == VAL_NULL) - { + if(id->valtype == VAL_NULL) { noprefix: if(id->index < MAXARGS) setarg(*id, *v); else setalias(*id, *v); v->type = VAL_NULL; } - else - { + else { const char *prefix = id->getstr(); if(!prefix[0]) goto noprefix; tagval r; @@ -2686,40 +2356,32 @@ void append(ident *id, tagval *v, bool space) ICOMMAND(append, "rt", (ident *id, tagval *v), append(id, v, true)); ICOMMAND(appendword, "rt", (ident *id, tagval *v), append(id, v, false)); -void result(tagval &v) -{ +void result(tagval &v) { *commandret = v; v.type = VAL_NULL; } -void stringret(char *s) -{ +void stringret(char *s) { commandret->setstr(s); } -void result(const char *s) -{ +void result(const char *s) { commandret->setstr(newstring(s)); } -ICOMMAND(result, "t", (tagval *v), -{ +ICOMMAND(result, "t", (tagval *v), { *commandret = *v; v->type = VAL_NULL; }); -void format(tagval *args, int numargs) -{ +void format(tagval *args, int numargs) { vector s; const char *f = args[0].getstr(); - while(*f) - { + while(*f) { int c = *f++; - if(c == '%') - { + if(c == '%') { int i = *f++; - if(i >= '1' && i <= '9') - { + if(i >= '1' && i <= '9') { i -= '0'; const char *sub = i < numargs ? args[i].getstr() : ""; while(*sub) s.add(*sub++); @@ -2735,31 +2397,25 @@ COMMAND(format, "V"); static const char *liststart = NULL, *listend = NULL, *listquotestart = NULL, *listquoteend = NULL; -static inline void skiplist(const char *&p) -{ - for(;;) - { +static inline void skiplist(const char *&p) { + for(;;) { p += strspn(p, " \t\r\n"); if(p[0]!='/' || p[1]!='/') break; p += strcspn(p, "\n\0"); } } -static bool parselist(const char *&s, const char *&start = liststart, const char *&end = listend, const char *"estart = listquotestart, const char *"eend = listquoteend) -{ +static bool parselist(const char *&s, const char *&start = liststart, const char *&end = listend, const char *"estart = listquotestart, const char *"eend = listquoteend) { skiplist(s); - switch(*s) - { + switch(*s) { case '"': quotestart = s++; start = s; s = parsestring(s); end = s; if(*s == '"') s++; quoteend = s; break; case '(': case '[': quotestart = s; start = s+1; - for(int braktype = *s++, brak = 1;;) - { + for(int braktype = *s++, brak = 1;;) { s += strcspn(s, "\"/;()[]\0"); int c = *s++; - switch(c) - { + switch(c) { case '\0': s--; quoteend = end = s; return true; case '"': s = parsestring(s); if(*s == '"') s++; break; case '/': if(*s == '/') s += strcspn(s, "\n\0"); break; @@ -2780,34 +2436,29 @@ static bool parselist(const char *&s, const char *&start = liststart, const char return true; } -void explodelist(const char *s, vector &elems, int limit) -{ +void explodelist(const char *s, vector &elems, int limit) { const char *start, *end; while((limit < 0 || elems.length() < limit) && parselist(s, start, end)) elems.add(newstring(start, end-start)); } -char *indexlist(const char *s, int pos) -{ +char *indexlist(const char *s, int pos) { loopi(pos) if(!parselist(s)) return newstring(""); const char *start, *end; return parselist(s, start, end) ? newstring(start, end-start) : newstring(""); } -int listlen(const char *s) -{ +int listlen(const char *s) { int n = 0; while(parselist(s)) n++; return n; } ICOMMAND(listlen, "s", (char *s), intret(listlen(s))); -void at(tagval *args, int numargs) -{ +void at(tagval *args, int numargs) { if(!numargs) return; const char *start = args[0].getstr(), *end = start + strlen(start); - for(int i = 1; i < numargs; i++) - { + for(int i = 1; i < numargs; i++) { const char *list = start; int pos = args[i].getint(); for(; pos > 0; pos--) if(!parselist(list)) break; @@ -2817,28 +2468,23 @@ void at(tagval *args, int numargs) } COMMAND(at, "si1V"); -void substr(char *s, int *start, int *count, int *numargs) -{ +void substr(char *s, int *start, int *count, int *numargs) { int len = strlen(s), offset = clamp(*start, 0, len); commandret->setstr(newstring(&s[offset], *numargs >= 3 ? clamp(*count, 0, len - offset) : len - offset)); } COMMAND(substr, "siiN"); -void chopstr(char *s, int *lim, char *ellipsis) -{ +void chopstr(char *s, int *lim, char *ellipsis) { int len = strlen(s), maxlen = abs(*lim); - if(len > maxlen) - { + if(len > maxlen) { int elen = strlen(ellipsis); maxlen = max(maxlen, elen); char *chopped = newstring(maxlen); - if(*lim < 0) - { + if(*lim < 0) { memcpy(chopped, ellipsis, elen); memcpy(&chopped[elen], &s[len - (maxlen - elen)], maxlen - elen); } - else - { + else { memcpy(chopped, s, maxlen - elen); memcpy(&chopped[maxlen - elen], ellipsis, elen); } @@ -2849,8 +2495,7 @@ void chopstr(char *s, int *lim, char *ellipsis) } COMMAND(chopstr, "sis"); -void sublist(const char *s, int *skip, int *count, int *numargs) -{ +void sublist(const char *s, int *skip, int *count, int *numargs) { int offset = max(*skip, 0), len = *numargs >= 3 ? max(*count, 0) : -1; loopi(offset) if(!parselist(s)) break; if(len < 0) { if(offset > 0) skiplist(s); commandret->setstr(newstring(s)); return; } @@ -2860,25 +2505,21 @@ void sublist(const char *s, int *skip, int *count, int *numargs) } COMMAND(sublist, "siiN"); -ICOMMAND(stripcolors, "s", (char *s), -{ +ICOMMAND(stripcolors, "s", (char *s), { int len = strlen(s); char *d = newstring(len); filtertext(d, s, true, false, len); stringret(d); }); -static inline void setiter(ident &id, char *val, identstack &stack) -{ - if(id.stack == &stack) - { +static inline void setiter(ident &id, char *val, identstack &stack) { + if(id.stack == &stack) { if(id.valtype == VAL_STR) delete[] id.val.s; else id.valtype = VAL_STR; cleancode(id); id.val.s = val; } - else - { + else { tagval t; t.setstr(val); pusharg(id, t, stack); @@ -2886,13 +2527,11 @@ static inline void setiter(ident &id, char *val, identstack &stack) } } -void listfind(ident *id, const char *list, const uint *body) -{ +void listfind(ident *id, const char *list, const uint *body) { if(id->type!=ID_ALIAS) { intret(-1); return; } identstack stack; int n = -1; - for(const char *s = list, *start, *end; parselist(s, start, end);) - { + for(const char *s = list, *start, *end; parselist(s, start, end);) { ++n; char *val = newstring(start, end-start); setiter(*id, val, stack); @@ -2904,13 +2543,11 @@ found: } COMMAND(listfind, "rse"); -void looplist(ident *id, const char *list, const uint *body) -{ +void looplist(ident *id, const char *list, const uint *body) { if(id->type!=ID_ALIAS) return; identstack stack; int n = 0; - for(const char *s = list, *start, *end; parselist(s, start, end); n++) - { + for(const char *s = list, *start, *end; parselist(s, start, end); n++) { char *val = newstring(start, end-start); setiter(*id, val, stack); execute(body); @@ -2919,13 +2556,11 @@ void looplist(ident *id, const char *list, const uint *body) } COMMAND(looplist, "rse"); -void loopsublist(ident *id, const char *list, int *skip, int *count, const uint *body) -{ +void loopsublist(ident *id, const char *list, int *skip, int *count, const uint *body) { if(id->type!=ID_ALIAS) return; identstack stack; int n = 0, offset = max(*skip, 0), len = *count < 0 ? INT_MAX : offset + *count; - for(const char *s = list, *start, *end; parselist(s, start, end) && n < len; n++) if(n >= offset) - { + for(const char *s = list, *start, *end; parselist(s, start, end) && n < len; n++) if(n >= offset) { char *val = newstring(start, end-start); setiter(*id, val, stack); execute(body); @@ -2934,19 +2569,15 @@ void loopsublist(ident *id, const char *list, int *skip, int *count, const uint } COMMAND(loopsublist, "rsiie"); -void looplistconc(ident *id, const char *list, const uint *body, bool space) -{ +void looplistconc(ident *id, const char *list, const uint *body, bool space) { if(id->type!=ID_ALIAS) return; identstack stack; vector r; int n = 0; - for(const char *s = list, *start, *end; parselist(s, start, end); n++) - { + for(const char *s = list, *start, *end; parselist(s, start, end); n++) { char *val = newstring(start, end-start); setiter(*id, val, stack); - if(n && space) r.add(' '); - tagval v; executeret(body, v); const char *vstr = v.getstr(); @@ -2961,19 +2592,15 @@ void looplistconc(ident *id, const char *list, const uint *body, bool space) ICOMMAND(looplistconcat, "rse", (ident *id, char *list, uint *body), looplistconc(id, list, body, true)); ICOMMAND(looplistconcatword, "rse", (ident *id, char *list, uint *body), looplistconc(id, list, body, false)); -void listfilter(ident *id, const char *list, const uint *body) -{ +void listfilter(ident *id, const char *list, const uint *body) { if(id->type!=ID_ALIAS) return; identstack stack; vector r; int n = 0; - for(const char *s = list, *start, *end, *quotestart, *quoteend; parselist(s, start, end, quotestart, quoteend); n++) - { + for(const char *s = list, *start, *end, *quotestart, *quoteend; parselist(s, start, end, quotestart, quoteend); n++) { char *val = newstring(start, end-start); setiter(*id, val, stack); - - if(executebool(body)) - { + if(executebool(body)) { if(r.length()) r.add(' '); r.put(quotestart, quoteend-quotestart); } @@ -2984,18 +2611,14 @@ void listfilter(ident *id, const char *list, const uint *body) } COMMAND(listfilter, "rse"); -void prettylist(const char *s, const char *conj) -{ +void prettylist(const char *s, const char *conj) { vector p; const char *start, *end; - for(int len = listlen(s), n = 0; parselist(s, start, end); n++) - { + for(int len = listlen(s), n = 0; parselist(s, start, end); n++) { p.put(start, end - start); - if(n+1 < len) - { + if(n+1 < len) { if(len > 2 || !conj[0]) p.add(','); - if(n+2 == len && conj[0]) - { + if(n+2 == len && conj[0]) { p.add(' '); p.put(conj, strlen(conj)); } @@ -3007,11 +2630,9 @@ void prettylist(const char *s, const char *conj) } COMMAND(prettylist, "ss"); -int listincludes(const char *list, const char *needle, int needlelen) -{ +int listincludes(const char *list, const char *needle, int needlelen) { int offset = 0; - for(const char *s = list, *start, *end; parselist(s, start, end);) - { + for(const char *s = list, *start, *end; parselist(s, start, end);) { int len = end - start; if(needlelen == len && !strncmp(needle, start, len)) return offset; offset++; @@ -3020,13 +2641,10 @@ int listincludes(const char *list, const char *needle, int needlelen) } ICOMMAND(indexof, "ss", (char *list, char *elem), intret(listincludes(list, elem, strlen(elem)))); -char *listdel(const char *s, const char *del) -{ +char *listdel(const char *s, const char *del) { vector p; - for(const char *start, *end, *qstart, *qend; parselist(s, start, end, qstart, qend);) - { - if(listincludes(del, start, end-start) < 0) - { + for(const char *start, *end, *qstart, *qend; parselist(s, start, end, qstart, qend);) { + if(listincludes(del, start, end-start) < 0) { if(!p.empty()) p.add(' '); p.put(qstart, qend-qstart); } @@ -3036,22 +2654,19 @@ char *listdel(const char *s, const char *del) } ICOMMAND(listdel, "ss", (char *list, char *del), commandret->setstr(listdel(list, del))); -void listsplice(const char *s, const char *vals, int *skip, int *count) -{ +void listsplice(const char *s, const char *vals, int *skip, int *count) { int offset = max(*skip, 0), len = max(*count, 0); const char *list = s, *start, *end, *qstart, *qend = s; loopi(offset) if(!parselist(s, start, end, qstart, qend)) break; vector p; if(qend > list) p.put(list, qend-list); - if(*vals) - { + if(*vals) { if(!p.empty()) p.add(' '); p.put(vals, strlen(vals)); } loopi(len) if(!parselist(s)) break; skiplist(s); - switch(*s) - { + switch(*s) { case '\0': case ')': case ']': break; default: if(!p.empty()) p.add(' '); @@ -3063,30 +2678,25 @@ void listsplice(const char *s, const char *vals, int *skip, int *count) } COMMAND(listsplice, "ssii"); -ICOMMAND(loopfiles, "rsse", (ident *id, char *dir, char *ext, uint *body), -{ +ICOMMAND(loopfiles, "rsse", (ident *id, char *dir, char *ext, uint *body), { if(id->type!=ID_ALIAS) return; identstack stack; vector files; listfiles(dir, ext[0] ? ext : NULL, files); - loopvrev(files) - { + loopvrev(files) { char *file = files[i]; bool redundant = false; loopj(i) if(!strcmp(files[j], file)) { redundant = true; break; } if(redundant) delete[] files.removeunordered(i); } - loopv(files) - { + loopv(files) { char *file = files[i]; - if(i) - { + if(i) { if(id->valtype == VAL_STR) delete[] id->val.s; else id->valtype = VAL_STR; id->val.s = file; } - else - { + else { tagval t; t.setstr(file); pusharg(*id, t, stack); @@ -3097,8 +2707,7 @@ ICOMMAND(loopfiles, "rsse", (ident *id, char *dir, char *ext, uint *body), if(files.length()) poparg(*id); }); -void findfile_(char *name) -{ +void findfile_(char *name) { string fname; copystring(fname, name); path(fname); @@ -3111,18 +2720,14 @@ void findfile_(char *name) } COMMANDN(findfile, findfile_, "s"); -struct sortitem -{ +struct sortitem { const char *str, *quotestart, *quoteend; }; -struct sortfun -{ +struct sortfun { ident *x, *y; uint *body; - - bool operator()(const sortitem &xval, const sortitem &yval) - { + bool operator()(const sortitem &xval, const sortitem &yval) { if(x->valtype != VAL_MACRO) x->valtype = VAL_MACRO; cleancode(*x); x->val.code = (const uint *)xval.str; @@ -3133,43 +2738,33 @@ struct sortfun } }; -void sortlist(char *list, ident *x, ident *y, uint *body) -{ +void sortlist(char *list, ident *x, ident *y, uint *body) { if(x == y || x->type != ID_ALIAS || y->type != ID_ALIAS) return; - vector items; int macrolen = strlen(list), total = 0; char *macros = newstring(list, macrolen); const char *curlist = list, *start, *end, *quotestart, *quoteend; - while(parselist(curlist, start, end, quotestart, quoteend)) - { + while(parselist(curlist, start, end, quotestart, quoteend)) { macros[end - list] = '\0'; sortitem item = { ¯os[start - list], quotestart, quoteend }; items.add(item); total += int(quoteend - quotestart); } - identstack xstack, ystack; pusharg(*x, nullval, xstack); x->flags &= ~IDF_UNKNOWN; pusharg(*y, nullval, ystack); y->flags &= ~IDF_UNKNOWN; - sortfun f = { x, y, body }; items.sort(f); - poparg(*x); poparg(*y); - char *sorted = macros; int sortedlen = total + max(items.length() - 1, 0); - if(macrolen < sortedlen) - { + if(macrolen < sortedlen) { delete[] macros; sorted = newstring(sortedlen); } - int offset = 0; - loopv(items) - { + loopv(items) { sortitem &item = items[i]; int len = int(item.quoteend - item.quotestart); if(i) sorted[offset++] = ' '; @@ -3177,7 +2772,6 @@ void sortlist(char *list, ident *x, ident *y, uint *body) offset += len; } sorted[offset] = '\0'; - commandret->setstr(sorted); } COMMAND(sortlist, "srre"); @@ -3210,21 +2804,17 @@ ICOMMAND(&~, "ii", (int *a, int *b), intret(*a & ~*b)); ICOMMAND(|~, "ii", (int *a, int *b), intret(*a | ~*b)); ICOMMAND(<<, "ii", (int *a, int *b), intret(*b < 32 ? *a << max(*b, 0) : 0)); ICOMMAND(>>, "ii", (int *a, int *b), intret(*a >> clamp(*b, 0, 31))); -ICOMMAND(&&, "e1V", (tagval *args, int numargs), -{ +ICOMMAND(&&, "e1V", (tagval *args, int numargs), { if(!numargs) intret(1); - else loopi(numargs) - { + else loopi(numargs) { if(i) freearg(*commandret); executeret(args[i].code, *commandret); if(!getbool(*commandret)) break; } }); -ICOMMAND(||, "e1V", (tagval *args, int numargs), -{ +ICOMMAND(||, "e1V", (tagval *args, int numargs), { if(!numargs) intret(0); - else loopi(numargs) - { + else loopi(numargs) { if(i) freearg(*commandret); executeret(args[i].code, *commandret); if(getbool(*commandret)) break; @@ -3248,26 +2838,22 @@ ICOMMAND(loge, "f", (float *a), floatret(log(*a))); ICOMMAND(log2, "f", (float *a), floatret(log(*a)/M_LN2)); ICOMMAND(log10, "f", (float *a), floatret(log10(*a))); ICOMMAND(exp, "f", (float *a), floatret(exp(*a))); -ICOMMAND(min, "V", (tagval *args, int numargs), -{ +ICOMMAND(min, "V", (tagval *args, int numargs), { int val = numargs > 0 ? args[numargs - 1].getint() : 0; loopi(numargs - 1) val = min(val, args[i].getint()); intret(val); }); -ICOMMAND(max, "V", (tagval *args, int numargs), -{ +ICOMMAND(max, "V", (tagval *args, int numargs), { int val = numargs > 0 ? args[numargs - 1].getint() : 0; loopi(numargs - 1) val = max(val, args[i].getint()); intret(val); }); -ICOMMAND(minf, "V", (tagval *args, int numargs), -{ +ICOMMAND(minf, "V", (tagval *args, int numargs), { float val = numargs > 0 ? args[numargs - 1].getfloat() : 0.0f; loopi(numargs - 1) val = min(val, args[i].getfloat()); floatret(val); }); -ICOMMAND(maxf, "V", (tagval *args, int numargs), -{ +ICOMMAND(maxf, "V", (tagval *args, int numargs), { float val = numargs > 0 ? args[numargs - 1].getfloat() : 0.0f; loopi(numargs - 1) val = max(val, args[i].getfloat()); floatret(val); @@ -3277,12 +2863,10 @@ ICOMMAND(absf, "f", (float *n), floatret(fabs(*n))); ICOMMAND(floor, "f", (float *n), floatret(floor(*n))); ICOMMAND(ceil, "f", (float *n), floatret(ceil(*n))); -ICOMMAND(round, "ff", (float *n, float *k), -{ +ICOMMAND(round, "ff", (float *n, float *k), { double step = *k; double r = *n; - if(step > 0) - { + if(step > 0) { r += step * (r < 0 ? -0.5 : 0.5); r -= fmod(r, step); } @@ -3290,34 +2874,29 @@ ICOMMAND(round, "ff", (float *n, float *k), floatret(float(r)); }); -ICOMMAND(cond, "ee2V", (tagval *args, int numargs), -{ - for(int i = 0; i < numargs; i += 2) - { - if(i+1 < numargs) - { - if(executebool(args[i].code)) - { +ICOMMAND(cond, "ee2V", (tagval *args, int numargs), { + for(int i = 0; i < numargs; i += 2) { + if(i+1 < numargs) { + if(executebool(args[i].code)) { executeret(args[i+1].code, *commandret); break; } } - else - { + else { executeret(args[i].code, *commandret); break; } } }); #define CASECOMMAND(name, fmt, type, acc, compare) \ - ICOMMAND(name, fmt "te2V", (tagval *args, int numargs), \ - { \ + ICOMMAND(name, fmt "te2V", (tagval *args, int numargs), { \ + \ type val = acc; \ int i; \ - for(i = 1; i+1 < numargs; i += 2) \ - { \ - if(compare) \ - { \ + for(i = 1; i+1 < numargs; i += 2) { \ + \ + if(compare) { \ + \ executeret(args[i+1].code, *commandret); \ return; \ } \ @@ -3328,15 +2907,12 @@ CASECOMMAND(casef, "f", float, args[0].getfloat(), args[i].type == VAL_NULL || a CASECOMMAND(cases, "s", const char *, args[0].getstr(), args[i].type == VAL_NULL || !strcmp(args[i].getstr(), val)); ICOMMAND(rnd, "ii", (int *a, int *b), intret(*a - *b > 0 ? rnd(*a - *b) + *b : *b)); -ICOMMAND(rndstr, "i", (int *len), -{ +ICOMMAND(rndstr, "i", (int *len), { int n = clamp(*len, 0, 10000); char *s = newstring(n); - for(int i = 0; i < n;) - { + for(int i = 0; i < n;) { uint r = randomMT(); - for(int j = min(i + 4, n); i < j; i++) - { + for(int j = min(i + 4, n); i < j; i++) { s[i] = (r%255) + 1; r /= 255; } @@ -3361,15 +2937,12 @@ ICOMMAND(codestr, "i", (int *i), { char *s = newstring(1); s[0] = char(*i); s[1] ICOMMAND(struni, "si", (char *s, int *i), intret(*i > 0 ? (memchr(s, 0, *i) ? 0 : cube2uni(s[*i])) : cube2uni(s[0]))); ICOMMAND(unistr, "i", (int *i), { char *s = newstring(1); s[0] = uni2cube(*i); s[1] = '\0'; stringret(s); }); -int naturalsort(const char *a, const char *b) -{ - for(;;) - { +int naturalsort(const char *a, const char *b) { + for(;;) { int ac = *a, bc = *b; if(!ac) return bc ? -1 : 0; else if(!bc) return 1; - else if(isdigit(ac) && isdigit(bc)) - { + else if(isdigit(ac) && isdigit(bc)) { while(*a == '0') a++; while(*b == '0') b++; const char *a0 = a, *b0 = b; @@ -3388,8 +2961,8 @@ int naturalsort(const char *a, const char *b) ICOMMAND(naturalsort, "ss", (char *a, char *b), intret(naturalsort(a,b)<=0)); #define STRMAPCOMMAND(name, map) \ - ICOMMAND(name, "s", (char *s), \ - { \ + ICOMMAND(name, "s", (char *s), { \ + \ int len = strlen(s); \ char *m = newstring(len); \ loopi(len) m[i] = map(s[i]); \ @@ -3400,23 +2973,18 @@ ICOMMAND(naturalsort, "ss", (char *a, char *b), intret(naturalsort(a,b)<=0)); STRMAPCOMMAND(strlower, cubelower); STRMAPCOMMAND(strupper, cubeupper); -char *strreplace(const char *s, const char *oldval, const char *newval) -{ +char *strreplace(const char *s, const char *oldval, const char *newval) { vector buf; - int oldlen = strlen(oldval); if(!oldlen) return newstring(s); - for(;;) - { + for(;;) { const char *found = strstr(s, oldval); - if(found) - { + if(found) { while(s < found) buf.add(*s++); for(const char *n = newval; *n; n++) buf.add(*n); s = found + oldlen; } - else - { + else { while(*s) buf.add(*s++); buf.add('\0'); return newstring(buf.getbuf(), buf.length()); @@ -3426,8 +2994,7 @@ char *strreplace(const char *s, const char *oldval, const char *newval) ICOMMAND(strreplace, "sss", (char *s, char *o, char *n), commandret->setstr(strreplace(s, o, n))); -void strsplice(const char *s, const char *vals, int *skip, int *count) -{ +void strsplice(const char *s, const char *vals, int *skip, int *count) { int slen = strlen(s), vlen = strlen(vals), offset = clamp(*skip, 0, slen), len = clamp(*count, 0, slen - offset); @@ -3443,15 +3010,13 @@ COMMAND(strsplice, "ssii"); #ifndef STANDALONE ICOMMAND(getmillis, "i", (int *total), intret(*total ? totalmillis : lastmillis)); -struct sleepcmd -{ +struct sleepcmd { int delay, millis, flags; char *command; }; vector sleepcmds; -void addsleep(int *msec, char *cmd) -{ +void addsleep(int *msec, char *cmd) { sleepcmd &s = sleepcmds.add(); s.delay = max(*msec, 1); s.millis = lastmillis; @@ -3461,13 +3026,10 @@ void addsleep(int *msec, char *cmd) COMMANDN(sleep, addsleep, "is"); -void checksleep(int millis) -{ - loopv(sleepcmds) - { +void checksleep(int millis) { + loopv(sleepcmds) { sleepcmd &s = sleepcmds[i]; - if(millis - s.millis >= s.delay) - { + if(millis - s.millis >= s.delay) { char *cmd = s.command; // execute might create more sleep commands s.command = NULL; int oldflags = identflags; @@ -3480,19 +3042,16 @@ void checksleep(int millis) } } -void clearsleep(bool clearoverrides) -{ +void clearsleep(bool clearoverrides) { int len = 0; - loopv(sleepcmds) if(sleepcmds[i].command) - { + loopv(sleepcmds) if(sleepcmds[i].command) { if(clearoverrides && !(sleepcmds[i].flags&IDF_OVERRIDDEN)) sleepcmds[len++] = sleepcmds[i]; else delete[] sleepcmds[i].command; } sleepcmds.shrink(len); } -void clearsleep_(int *clearoverrides) -{ +void clearsleep_(int *clearoverrides) { clearsleep(*clearoverrides!=0 || identflags&IDF_OVERRIDDEN); } -- cgit v1.2.3