command.h

Go to the documentation of this file.

 
#ifndef COMMAND_H_
#define COMMAND_H_
 
enum
{
    Value_Null = 0,
    Value_Integer,
    Value_Float,
    Value_String,
    Value_Any,
    Value_Code,
    Value_Macro,
    Value_Ident,
    Value_CString,
    Value_CAny,
    Value_Word,
    Value_Pop,
    Value_Cond,
};
 
enum
{
    Id_Var,     //0
    Id_FloatVar,
    Id_StringVar,
    Id_Command,
    Id_Alias,
    Id_Local,   //5
    Id_Do,
    Id_DoArgs,
    Id_If,
    Id_Result,
    Id_Not,     //10
    Id_And,
    Id_Or,      //12
};
 
enum
{
    Idf_Persist    = 1<<0,
    Idf_Override   = 1<<1,
    Idf_Hex        = 1<<2,
    Idf_ReadOnly   = 1<<3,
    Idf_Overridden = 1<<4,
    Idf_Unknown    = 1<<5,
    Idf_Arg        = 1<<6,
};
 
struct ident;
 
struct identval
{
    union
    {
        int i;      // Id_Var, ValueInteger
        float f;    // Id_FloatVar, ValueFloat
        char *s;    // Id_StringVar, ValueString
        const uint *code; // ValueCode
        ident *id;  // ValueIdent
        const char *cstr; // ValueCString
    };
};
 
struct tagval : identval
{
    int type;
 
    void setint(int val);
    void setfloat(float val);
    void setnumber(double val);
    void setstr(char *val);
    void setnull();
    void setcode(const uint *val);
    void setmacro(const uint *val);
    void setcstr(const char *val);
    void setident(ident *val);
 
    const char *getstr() const;
    int getint() const;
    float getfloat() const;
    double getnumber() const;
    bool getbool() const;
    void getval(tagval &r) const;
 
    void cleanup();
};
 
struct identstack
{
    identval val;
    int valtype;
    identstack *next;
};
 
typedef void (__cdecl *identfun)(ident *id);

struct ident
{
    //this pointer will point to different types depending upon the type of variable
    union identvalptr 
    {
        void  *p; 
        int   *i; 
        float *f; 
        char **s; 
    };
 
    uchar type; 
    union
    {
        uchar valtype; 
        uchar numargs; 
    };
    ushort flags;
    int index;
    const char *name;
    union
    {
        struct // Id_Var, Id_FloatVar, Id_StringVar
        {
            union //number var range union type
            {
                struct
                {
                    int min, 
                        max; 
                } i;     // Id_Var
                struct
                {
                    float min, 
                          max; 
                } f; // Id_FloatVar
            };
            identvalptr storage;
            identval overrideval;
        } val;
        struct // Id_Alias
        {
            uint *code;
            identval val;
            identstack *stack;
        } alias;
        struct // Id_Command
        {
            const char *args;
            uint argmask;
        } cmd;
    };
    identfun fun; 
 
    ident() {}
    ident(int t, const char *n, int m, int x, int *s, void *f = nullptr, int flags = 0)
        : type(t), flags(flags | (m > x ? Idf_ReadOnly : 0)), name(n), fun(reinterpret_cast<identfun>(f))
    {
        val.storage.i = s;
        val.i.min = m;
        val.i.max = x;
    }

    ident(int t, const char *n, float m, float x, float *s, void *f = nullptr, int flags = 0)
        : type(t), flags(flags | (m > x ? Idf_ReadOnly : 0)), name(n), fun(reinterpret_cast<identfun>(f))
    {
        val.storage.f = s;
        val.f.min = m;
        val.f.max = x;
    }

    ident(int t, const char *n, char **s, void *f = nullptr, int flags = 0)
        : type(t), flags(flags), name(n), fun(reinterpret_cast<identfun>(f))
    {
        val.storage.s = s;
    }
 
    // Id_Alias
    ident(int t, const char *n, char *a, int flags)
        : type(t), valtype(Value_String), flags(flags), name(n)
    {
        alias.code = nullptr;
        alias.stack = nullptr;
        alias.val.s = a;
    }
 
    ident(int t, const char *n, int a, int flags)
        : type(t), valtype(Value_Integer), flags(flags), name(n)
    {
        alias.code = nullptr;
        alias.stack = nullptr;
        alias.val.i = a;
    }
 
    ident(int t, const char *n, float a, int flags)
        : type(t), valtype(Value_Float), flags(flags), name(n)
    {
        alias.code = nullptr;
        alias.stack = nullptr;
        alias.val.f = a;
    }
 
    ident(int t, const char *n, int flags)
        : type(t), valtype(Value_Null), flags(flags), name(n)
    {
        alias.code = nullptr;
        alias.stack = nullptr;
    }
 
    ident(int t, const char *n, const tagval &v, int flags)
        : type(t), valtype(v.type), flags(flags), name(n)
    {
        alias.code = nullptr;
        alias.stack = nullptr;
        alias.val = v;
    }

    ident(int t, const char *n, const char *args, uint argmask, int numargs, void *f = nullptr, int flags = 0)
        : type(t), numargs(numargs), flags(flags), name(n), fun(reinterpret_cast<identfun>(f))
    {
        cmd.args = args;
        cmd.argmask = argmask;
    }

    void changed()
    {
        if(fun)
        {
            fun(this);
        }
    }

    void setval(const tagval &v)
    {
        valtype = v.type;
        alias.val = v;
    }

    void setval(const identstack &v)
    {
        valtype = v.valtype;
        alias.val = v.val;
    }

    void forcenull()
    {
        if(valtype==Value_String)
        {
            delete[] alias.val.s;
        }
        valtype = Value_Null;
    }

    float getfloat() const;

    int getint() const;

    double getnumber() const;
    const char *getstr() const;
    void getval(tagval &r) const;
    void getcstr(tagval &v) const;
    void getcval(tagval &v) const;
};

extern void intret(int v);

extern const char *floatstr(float v);

extern void floatret(float v);

extern void stringret(char *s);

extern void result(const char *s);

inline int parseint(const char *s)
{
    return static_cast<int>(std::strtoul(s, nullptr, 0));
}

extern int variable(const char *name, int min, int cur, int max, int *storage, identfun fun, int flags);

extern float fvariable(const char *name, float min, float cur, float max, float *storage, identfun fun, int flags);

extern char *svariable(const char *name, const char *cur, char **storage, identfun 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 bool addcommand(const char *name, identfun fun, const char *narg = "", int type = Id_Command);
 
extern std::queue<ident *> triggerqueue; 

extern ident *getident(const char *name);
extern int execute(const uint *code);

extern int execute(const char *p);

extern int execident(const char *name, int noid = 0, bool lookup = false);
extern bool executebool(const uint *code);

extern bool execfile(const char *cfgfile, bool msg = true);

extern const char *escapestring(const char *s);

extern void printvar(const ident *id, int i);

extern int clampvar(bool hex, std::string name, int i, int minval, int maxval);
extern void loopiter(ident *id, identstack &stack, int i);
extern void loopend(ident *id, identstack &stack);

const char *escapeid(const char *s);

extern void writecfg(const char *savedconfig, const char *autoexec = nullptr, const char *defaultconfig = nullptr, const char *name = nullptr);

extern void checksleep(int millis);

extern bool initidents();
 
extern int identflags; 

extern void clear_command();
 
// nasty macros for registering script functions, abuses globals to avoid excessive infrastructure
 
//* note: many of the VARF comments are very repetitive, because the code itself is nearly duplicated too *//
 
/* how command registration works:
 *  In C++, all global variables must be initiated before main() is called
 *  Each of these macro kludges (which are placed at the global scope level) initializes some kind of global variable
 *  Because the macro kludges are the definition of global variables, at program initializiation, they must be run first
 *  The values of the variables themselves don't matter because they only exist to cheat and run before main()
 *  The macro kludges themselves register commands or values within some vector<>-s which keeps track of all cmds/vars
 */
 
/*
 * Parameter Flags (exhaustive list, not exhaustive descriptions)
 * i an integer parameter
 * b a boolean parameter
 * f a float parameter (sets to 0 if over parameter limit)
 * F a float parameter (sets to value of previous parameter if over parameter limit)
 * s a string parameter (sets to new allocated string "" if over parameter limit)
 * S a string paremter (sets current string to "" if over parameter limit)
 * t sets to null if over parameter limit
 * T same as "t"
 * e a code block parameter
 * E a code block paremter (null)
 * r an ident parameter
 * $ an ident parameter
 * N a number parameter
 * D a bind parameter (e.g. player movement), adds a release action for the command
 * C an ident parameter, ComC
 * V a series of variadic parameter(s) (open ended series of values)
 * 1 repeat one arg
 * 2 repeat two args
 * 3 repeat three args
 * 4 repeat four args
 */
 
//integer var macros
//VAR_, _VARF, VARM_ are templates for "normal" macros that do not execute an inline function
#define VAR_(name, global, min, cur, max, persist)  int global = variable(#name, min, cur, max, &global, nullptr, persist)
#define VARN(name, global, min, cur, max) VAR_(name, global, min, cur, max, 0)
#define VARNP(name, global, min, cur, max) VAR_(name, global, min, cur, max, Idf_Persist)
#define VARNR(name, global, min, cur, max) VAR_(name, global, min, cur, max, Idf_Override)
#define VAR(name, min, cur, max) VAR_(name, name, min, cur, max, 0)
#define VARP(name, min, cur, max) VAR_(name, name, min, cur, max, Idf_Persist)
#define VARR(name, min, cur, max) VAR_(name, name, min, cur, max, Idf_Override)
 
//variable with inline function to be executed on change (VARiable with Function = VARF)
#define VARF_(name, global, min, cur, max, body, persist) \
    int global = variable(#name, min, cur, max, &global, [] (ident *) { body; }, persist); /* assign variable, needs fxn prototype declared above */
 
#define VARFN(name, global, min, cur, max, body) VARF_(name, global, min, cur, max, body, 0)
#define VARF(name, min, cur, max, body) VARF_(name, name, min, cur, max, body, 0)
#define VARFP(name, min, cur, max, body) VARF_(name, name, min, cur, max, body, Idf_Persist)
#define VARFR(name, min, cur, max, body) VARF_(name, name, min, cur, max, body, Idf_Override)
#define VARFNP(name, global, min, cur, max, body) VARF_(name, global, min, cur, max, body, Idf_Persist)
 
//hexadecimal var macros
#define HVAR_(name, global, min, cur, max, persist)  int global = variable(#name, min, cur, max, &global, nullptr, persist | Idf_Hex)
#define HVARP(name, min, cur, max) HVAR_(name, name, min, cur, max, Idf_Persist)
 
//hex variable with function to be executed on change (Hexadecimal VARiable with Function = HVARF)
//the CVAR series of macros borrows the HVARF macro as it deals with hex colors
#define HVARF_(name, global, min, cur, max, body, persist) \
    int global = variable(#name, min, cur, max, &global, [] (ident *) { body; }, persist | Idf_Hex); /* assign variable, needs fxn prototype declared above */
 
//color var macros
#define CVAR_(name, cur, init, body, persist) bvec name = bvec::hexcolor(cur); HVARF_(name, _##name, 0, cur, 0xFFFFFF, { init; name = bvec::hexcolor(_##name); body; }, persist)
#define CVARP(name, cur) CVAR_(name, cur, , , Idf_Persist)
#define CVARR(name, cur) CVAR_(name, cur, , , Idf_Override)
#define CVARFP(name, cur, body) CVAR_(name, cur, , body, Idf_Persist)
#define CVAR0_(name, cur, body, persist) CVAR_(name, cur, { if(!_##name) _##name = cur; }, body, persist)
#define CVAR0R(name, cur) CVAR0_(name, cur, , Idf_Override)
#define CVAR1_(name, cur, body, persist) CVAR_(name, cur, { if(_##name <= 255) _##name |= (_##name<<8) | (_##name<<16); }, body, persist)
#define CVAR1R(name, cur) CVAR1_(name, cur, , Idf_Override)
#define CVAR1FR(name, cur, body) CVAR1_(name, cur, body, Idf_Override)
 
//float var macros
#define FVAR_(name, global, min, cur, max, persist) float global = fvariable(#name, min, cur, max, &global, nullptr, persist)
#define FVARNP(name, global, min, cur, max) FVAR_(name, global, min, cur, max, Idf_Persist)
#define FVAR(name, min, cur, max) FVAR_(name, name, min, cur, max, 0)
#define FVARP(name, min, cur, max) FVAR_(name, name, min, cur, max, Idf_Persist)
#define FVARR(name, min, cur, max) FVAR_(name, name, min, cur, max, Idf_Override)
 
//float variable with function to be executed on change (Float VARiable with Function = FVARF)
#define FVARF_(name, global, min, cur, max, body, persist) \
    float global = fvariable(#name, min, cur, max, &global, [] (ident *) { body; }, persist); /* assign variable, needs fxn prototype declared above */ \
 
#define FVARF(name, min, cur, max, body) FVARF_(name, name, min, cur, max, body, 0)
#define FVARFP(name, min, cur, max, body) FVARF_(name, name, min, cur, max, body, Idf_Persist)
#define FVARFR(name, min, cur, max, body) FVARF_(name, name, min, cur, max, body, Idf_Override)
 
//string var macros
#define SVAR_(name, global, cur, persist) char *global = svariable(#name, cur, &global, nullptr, persist)
#define SVAR(name, cur) SVAR_(name, name, cur, 0)
#define SVARP(name, cur) SVAR_(name, name, cur, Idf_Persist)
#define SVARR(name, cur) SVAR_(name, name, cur, Idf_Override)
 
//string variable with function to be executed on change (Float VARiable with Function = FVARF)
#define SVARF_(name, global, cur, body, persist) \
    char *global = svariable(#name, cur, &global, [] (ident *) { body; }, persist); /* assign variable, needs fxn prototype declared above */
 
#define SVARF(name, cur, body) SVARF_(name, name, cur, body, 0)
#define SVARFR(name, cur, body) SVARF_(name, name, cur, body, Idf_Override)
 
#endif /* COMMAND_H_ */