LCOV - code coverage report
Current view: top level - libprimis-headers - command.h (source / functions) Coverage Total Hit
Test: Libprimis Test Coverage Lines: 98.1 % 52 51
Test Date: 2025-02-18 06:21:28 Functions: 100.0 % 12 12

            Line data    Source code
       1              : /**
       2              :  * @file command.h
       3              :  * @brief Script binding functionality.
       4              :  *
       5              :  * This file describes the CubeScript API for binding and executing code from within
       6              :  * the engine's CubeScript context.
       7              :  */
       8              : 
       9              : #ifndef COMMAND_H_
      10              : #define COMMAND_H_
      11              : 
      12              : enum
      13              : {
      14              :     Value_Null = 0,
      15              :     Value_Integer,
      16              :     Value_Float,
      17              :     Value_String,
      18              :     Value_Any,
      19              :     Value_Code,
      20              :     Value_Macro,
      21              :     Value_Ident,
      22              :     Value_CString,
      23              :     Value_CAny,
      24              :     Value_Word,
      25              :     Value_Pop,
      26              :     Value_Cond,
      27              : };
      28              : 
      29              : enum
      30              : {
      31              :     Id_Var,     //0
      32              :     Id_FloatVar,
      33              :     Id_StringVar,
      34              :     Id_Command,
      35              :     Id_Alias,
      36              :     Id_Local,   //5
      37              :     Id_Do,
      38              :     Id_DoArgs,
      39              :     Id_If,
      40              :     Id_Result,
      41              :     Id_Not,     //10
      42              :     Id_And,
      43              :     Id_Or,      //12
      44              : };
      45              : 
      46              : enum
      47              : {
      48              :     Idf_Persist    = 1<<0,
      49              :     Idf_Override   = 1<<1,
      50              :     Idf_Hex        = 1<<2,
      51              :     Idf_ReadOnly   = 1<<3,
      52              :     Idf_Overridden = 1<<4,
      53              :     Idf_Unknown    = 1<<5,
      54              :     Idf_Arg        = 1<<6,
      55              : };
      56              : 
      57              : struct ident;
      58              : 
      59              : struct identval
      60              : {
      61              :     union
      62              :     {
      63              :         int i;      // Id_Var, ValueInteger
      64              :         float f;    // Id_FloatVar, ValueFloat
      65              :         char *s;    // Id_StringVar, ValueString
      66              :         const uint *code; // ValueCode
      67              :         ident *id;  // ValueIdent
      68              :         const char *cstr; // ValueCString
      69              :     };
      70              : };
      71              : 
      72              : struct tagval : identval
      73              : {
      74              :     int type;
      75              : 
      76              :     void setint(int val);
      77              :     void setfloat(float val);
      78              :     void setnumber(double val);
      79              :     void setstr(char *val);
      80              :     void setnull();
      81              :     void setcode(const uint *val);
      82              :     void setmacro(const uint *val);
      83              :     void setcstr(const char *val);
      84              :     void setident(ident *val);
      85              : 
      86              :     const char *getstr() const;
      87              :     int getint() const;
      88              :     float getfloat() const;
      89              :     double getnumber() const;
      90              :     bool getbool() const;
      91              :     void getval(tagval &r) const;
      92              : 
      93              :     void cleanup();
      94              : };
      95              : 
      96              : struct identstack
      97              : {
      98              :     identval val;
      99              :     int valtype;
     100              :     identstack *next;
     101              : };
     102              : 
     103              : typedef void (__cdecl *identfun)(ident *id);
     104              : 
     105              : /**
     106              :  * @brief An object representing all Cubescript objects.
     107              :  *
     108              :  * This object defines all possible state for any object in Cubescript. Different
     109              :  * types will have different members due to the union types, but the ident object
     110              :  * is common to them regardless. This allows storage of CS objects in a uniform
     111              :  * map consisting of one type.
     112              :  */
     113              : struct ident
     114              : {
     115              :     //this pointer will point to different types depending upon the type of variable
     116              :     union identvalptr /**< points to an ident's value */
     117              :     {
     118              :         void  *p; /**< can point to any Id_*Var */
     119              :         int   *i; /**< points to an Id_Var (int) */
     120              :         float *f; /**< points to an Id_FloatVar */
     121              :         char **s; /**< points to a pointer to a Id_StringVar (C string) */
     122              :     };
     123              : 
     124              :     uchar type; /**< one of Id_* in Id_ enum */
     125              :     union
     126              :     {
     127              :         uchar valtype; /**< if alias, points to Id_Alias's type */
     128              :         uchar numargs; /**< if command, number of commands the Id_Command has */
     129              :     };
     130              :     ushort flags;
     131              :     int index;
     132              :     const char *name;
     133              :     union
     134              :     {
     135              :         struct // Id_Var, Id_FloatVar, Id_StringVar
     136              :         {
     137              :             union //number var range union type
     138              :             {
     139              :                 struct
     140              :                 {
     141              :                     int min, /**< if an int variable, its min allowed value*/
     142              :                         max; /**< if an int variable, its max allowed value*/
     143              :                 } i;     // Id_Var
     144              :                 struct
     145              :                 {
     146              :                     float min, /**< if a float variable, its min allowed value*/
     147              :                           max; /**< if a float variable, its max allowed value*/
     148              :                 } f; // Id_FloatVar
     149              :             };
     150              :             identvalptr storage;
     151              :             identval overrideval;
     152              :         } val;
     153              :         struct // Id_Alias
     154              :         {
     155              :             uint *code;
     156              :             identval val;
     157              :             identstack *stack;
     158              :         } alias;
     159              :         struct // Id_Command
     160              :         {
     161              :             const char *args;
     162              :             uint argmask;
     163              :         } cmd;
     164              :     };
     165              :     identfun fun; /**< the pointer a command or variable points to (the on-change command for a var)*/
     166              : 
     167         1114 :     ident() {}
     168              :     /**
     169              :      * @brief Constructor for an ident for an int variable.
     170              :      */
     171          387 :     ident(int t, const char *n, int m, int x, int *s, void *f = nullptr, int flags = 0)
     172          387 :         : type(t), flags(flags | (m > x ? Idf_ReadOnly : 0)), name(n), fun(reinterpret_cast<identfun>(f))
     173              :     {
     174          387 :         val.storage.i = s;
     175          387 :         val.i.min = m;
     176          387 :         val.i.max = x;
     177          387 :     }
     178              : 
     179              :     /**
     180              :      * @brief Constructor for an ident for a float variable.
     181              :      */
     182          112 :     ident(int t, const char *n, float m, float x, float *s, void *f = nullptr, int flags = 0)
     183          112 :         : type(t), flags(flags | (m > x ? Idf_ReadOnly : 0)), name(n), fun(reinterpret_cast<identfun>(f))
     184              :     {
     185          112 :         val.storage.f = s;
     186          112 :         val.f.min = m;
     187          112 :         val.f.max = x;
     188          112 :     }
     189              : 
     190              :     /**
     191              :      * @brief Constructor for an ident for a string variable.
     192              :      */
     193            5 :     ident(int t, const char *n, char **s, void *f = nullptr, int flags = 0)
     194            5 :         : type(t), flags(flags), name(n), fun(reinterpret_cast<identfun>(f))
     195              :     {
     196            5 :         val.storage.s = s;
     197            5 :     }
     198              : 
     199              :     // Id_Alias
     200              :     ident(int t, const char *n, char *a, int flags)
     201              :         : type(t), valtype(Value_String), flags(flags), name(n)
     202              :     {
     203              :         alias.code = nullptr;
     204              :         alias.stack = nullptr;
     205              :         alias.val.s = a;
     206              :     }
     207              : 
     208              :     ident(int t, const char *n, int a, int flags)
     209              :         : type(t), valtype(Value_Integer), flags(flags), name(n)
     210              :     {
     211              :         alias.code = nullptr;
     212              :         alias.stack = nullptr;
     213              :         alias.val.i = a;
     214              :     }
     215              : 
     216              :     ident(int t, const char *n, float a, int flags)
     217              :         : type(t), valtype(Value_Float), flags(flags), name(n)
     218              :     {
     219              :         alias.code = nullptr;
     220              :         alias.stack = nullptr;
     221              :         alias.val.f = a;
     222              :     }
     223              : 
     224           32 :     ident(int t, const char *n, int flags)
     225           32 :         : type(t), valtype(Value_Null), flags(flags), name(n)
     226              :     {
     227           32 :         alias.code = nullptr;
     228           32 :         alias.stack = nullptr;
     229           32 :     }
     230              : 
     231            2 :     ident(int t, const char *n, const tagval &v, int flags)
     232            2 :         : type(t), valtype(v.type), flags(flags), name(n)
     233              :     {
     234            2 :         alias.code = nullptr;
     235            2 :         alias.stack = nullptr;
     236            2 :         alias.val = v;
     237            2 :     }
     238              : 
     239              :     /**
     240              :      * @brief Constructor for an ident for a C++ bound command.
     241              :      */
     242          596 :     ident(int t, const char *n, const char *args, uint argmask, int numargs, void *f = nullptr, int flags = 0)
     243          596 :         : type(t), numargs(numargs), flags(flags), name(n), fun(reinterpret_cast<identfun>(f))
     244              :     {
     245          596 :         cmd.args = args;
     246          596 :         cmd.argmask = argmask;
     247          596 :     }
     248              : 
     249              :     /**
     250              :      * @brief Calls a change effect for this ident, if one exists.
     251              :      *
     252              :      * If there is no function pointed to by `fun` (it is null), then nothing
     253              :      * will occur.
     254              :      */
     255            1 :     void changed()
     256              :     {
     257            1 :         if(fun)
     258              :         {
     259            0 :             fun(this);
     260              :         }
     261            1 :     }
     262              : 
     263              :     /**
     264              :      * @brief Sets the value and type of value of this ident given a tagval
     265              :      *
     266              :      * Sets this ident's value type and value to the corresponding values from
     267              :      * the passed tagval object.
     268              :      *
     269              :      * @param v the tagval to set values from
     270              :      */
     271          285 :     void setval(const tagval &v)
     272              :     {
     273          285 :         valtype = v.type;
     274          285 :         alias.val = v;
     275          285 :     }
     276              : 
     277              :     /**
     278              :      * @brief Sets the value and type of value of this ident given an identstack
     279              :      *
     280              :      * Sets this ident's value type and value to the corresponding values from
     281              :      * the passed identstack object.
     282              :      *
     283              :      * @param v the identstack to set values from
     284              :      */
     285           95 :     void setval(const identstack &v)
     286              :     {
     287           95 :         valtype = v.valtype;
     288           95 :         alias.val = v.val;
     289           95 :     }
     290              : 
     291              :     /**
     292              :      * @brief Sets the value type of this ident to null.
     293              :      *
     294              :      * If a string is being stored inside this ident, it is freed.
     295              :      */
     296           28 :     void forcenull()
     297              :     {
     298           28 :         if(valtype==Value_String)
     299              :         {
     300            2 :             delete[] alias.val.s;
     301              :         }
     302           28 :         valtype = Value_Null;
     303           28 :     }
     304              : 
     305              :     /**
     306              :      * @brief Returns the saved value of the ident as a float.
     307              :      *
     308              :      * Returns a float even if the ident is of another type, e.g. integer
     309              :      *
     310              :      * @return the float value of the ident
     311              :      */
     312              :     float getfloat() const;
     313              : 
     314              :     /**
     315              :      * @brief Returns the saved value of the ident as an integer.
     316              :      *
     317              :      * Returns an int even if the ident is of another type, e.g. float
     318              :      */
     319              :     int getint() const;
     320              : 
     321              :     /**
     322              :      * @brief Returns the saved value of the ident as a double.
     323              :      *
     324              :      * Returns a double even if the ident is of another type, e.g. integer
     325              :      *
     326              :      * @return the double value of the ident
     327              :      */
     328              :     double getnumber() const;
     329              :     const char *getstr() const;
     330              :     void getval(tagval &r) const;
     331              :     void getcstr(tagval &v) const;
     332              :     void getcval(tagval &v) const;
     333              : };
     334              : 
     335              : /**
     336              :  * @brief Returns an integer value from a Cubescript command.
     337              :  *
     338              :  * When writing a CS command, this function returns an integer value to the inheriting
     339              :  * CS environment.
     340              :  *
     341              :  * @param v the value to return
     342              :  */
     343              : extern void intret(int v);
     344              : 
     345              : extern const char *floatstr(float v);
     346              : 
     347              : /**
     348              :  * @brief Returns a float value from a Cubescript command.
     349              :  *
     350              :  * When writing a CS command, this function returns a float value to the inheriting
     351              :  * CS environment.
     352              :  *
     353              :  * @param v the value to return
     354              :  */
     355              : extern void floatret(float v);
     356              : 
     357              : /**
     358              :  * @brief Returns a string value from a Cubescript command.
     359              :  *
     360              :  * When writing a CS command, this function returns a string value to the inheriting
     361              :  * CS environment.
     362              :  *
     363              :  * @param v the value to return
     364              :  */
     365              : extern void stringret(char *s);
     366              : 
     367              : /**
     368              :  * @brief Returns an alias' name from a Cubescript command.
     369              :  *
     370              :  * When writing a CS command, this functions a string value representing the name
     371              :  * of a Cubescript object to the inheriting CS environment.
     372              :  *
     373              :  * @param s the name of the ident to return
     374              :  */
     375              : extern void result(const char *s);
     376              : 
     377              : /**
     378              :  * @brief Returns the string passed as an integer.
     379              :  *
     380              :  * Parses the entire string, returning the value of the passed value as an integer.
     381              :  * The value of this value will always be greater than zero unless there is an
     382              :  * overflow beyond the size of `int`. The output may be converted by a trailing
     383              :  * radix digit as described in `strtoul`.
     384              :  *
     385              :  * @param s the string to turn into an integer
     386              :  */
     387          596 : inline int parseint(const char *s)
     388              : {
     389          596 :     return static_cast<int>(std::strtoul(s, nullptr, 0));
     390              : }
     391              : 
     392              : /**
     393              :  * @brief Registers an int variable in the Cubescript ident table.
     394              :  *
     395              :  * @param name the name of the aliased variable in Cubescript
     396              :  * @param min the minimum value the variable can be set at
     397              :  * @param cur the starting value of the variable
     398              :  * @param max the maximum value the variable can be set at
     399              :  * @param storage the pointer to the variable to be aliased to Cubescript
     400              :  * @param fun a function pointer to be called upon modification of the variable
     401              :  * @param flags the handling flags for the variable
     402              :  *
     403              :  * @return the value cur passed
     404              :  */
     405              : extern int variable(const char *name, int min, int cur, int max, int *storage, identfun fun, int flags);
     406              : 
     407              : /**
     408              :  * @brief Registers a float variable in the Cubescript ident table.
     409              :  *
     410              :  * Adds a float variable to the Cubescript ident table. The name of the Cubescript
     411              :  * variable does not necessarily need to correspond to the C++ variable's name.
     412              :  *
     413              :  * @param name the name of the aliased variable in Cubescript
     414              :  * @param min the minimum value the variable can be set at
     415              :  * @param cur the starting value of the variable
     416              :  * @param max the maximum value the variable can be set at
     417              :  * @param storage the pointer to the variable to be aliased to Cubescript
     418              :  * @param fun a function pointer to be called upon modification of the variable
     419              :  * @param flags the handling flags for the variable
     420              :  *
     421              :  * @return the value cur passed
     422              :  */
     423              : extern float fvariable(const char *name, float min, float cur, float max, float *storage, identfun fun, int flags);
     424              : 
     425              : /**
     426              :  * @brief Registers a C string variable in the Cubescript ident table.
     427              :  *
     428              :  * @param name the name of the aliased variable in Cubescript
     429              :  * @param cur the starting value of the variable
     430              :  * @param storage the pointer to the pointer to the variable to be aliased to Cubescript
     431              :  * @param fun a function pointer to be called upon modification of the variable
     432              :  * @param flags the handling flags for the variable
     433              :  *
     434              :  * @return the value cur passed
     435              :  */
     436              : extern char *svariable(const char *name, const char *cur, char **storage, identfun fun, int flags);
     437              : 
     438              : /**
     439              :  * @brief Sets a Cubescript integer value to the given value.
     440              :  *
     441              :  * @param name the name of the cubescript alias to change
     442              :  * @param i the value to set
     443              :  * @param dofunc whether to run the onchange function
     444              :  * @param doclamp whether to clamp the value to the specified limits
     445              :  */
     446              : extern void setvar(const char *name, int i, bool dofunc = true, bool doclamp = true);
     447              : 
     448              : /**
     449              :  * @brief Sets a Cubescript float value to the given value.
     450              :  *
     451              :  * @param name the name of the cubescript alias to change
     452              :  * @param i the value to set
     453              :  * @param dofunc whether to run the onchange function
     454              :  * @param doclamp whether to clamp the value to the specified limits
     455              :  */
     456              : extern void setfvar(const char *name, float f, bool dofunc = true, bool doclamp = true);
     457              : 
     458              : /**
     459              :  * @brief Sets a Cubescript string value to the given value.
     460              :  *
     461              :  * @param name the name of the cubescript alias to change
     462              :  * @param i the value to set
     463              :  * @param dofunc whether to run the onchange function
     464              :  */
     465              : extern void setsvar(const char *name, const char *str, bool dofunc = true);
     466              : 
     467              : /**
     468              :  * @brief Registers a command in the Cubescript ident table.
     469              :  *
     470              :  * The arguments of the function passed are cast away, so they are reconstructed using
     471              :  * the char * string passed to `narg`.
     472              :  *
     473              :  * @param name of the command in Cubescript
     474              :  * @param fun a function pointer to be called when the command is executed
     475              :  * @param narg string containing the arguments of the function
     476              :  * @param type the type of the command to create
     477              :  */
     478              : extern bool addcommand(const char *name, identfun fun, const char *narg = "", int type = Id_Command);
     479              : 
     480              : extern std::queue<ident *> triggerqueue; /**< A queue of game events for the engine to process */
     481              : 
     482              : /**
     483              :  * @brief Returns the pointer to the ident object with the given CS alias.
     484              :  *
     485              :  * @param the name of the cubescript object to get
     486              :  *
     487              :  * @return The address of the ident object.
     488              :  */
     489              : extern ident *getident(const char *name);
     490              : extern int execute(const uint *code);
     491              : 
     492              : /**
     493              :  * @brief Executes the contents of the string passed.
     494              :  *
     495              :  * Parses and executes the line of Cubescript given.
     496              :  *
     497              :  * @param p the C string containing the code to execute
     498              :  *
     499              :  * @return an int from the results of the execution
     500              :  */
     501              : extern int execute(const char *p);
     502              : 
     503              : /**
     504              :  * @brief Executes the contents of an ident, searched by name.
     505              :  *
     506              :  * Attempts to find in the ident table an ident with the given name, and
     507              :  * if found executes it.
     508              :  *
     509              :  * @param name the name of the ident to look for
     510              :  * @param noid the value to return if no ident is found
     511              :  * @param lookup if a command, and parameters are of format 'N', sets to -1
     512              :  */
     513              : extern int execident(const char *name, int noid = 0, bool lookup = false);
     514              : extern bool executebool(const uint *code);
     515              : 
     516              : /**
     517              :  * @brief Executes the contents of the referenced file.
     518              :  *
     519              :  * @param cfgfile the relative director of the file to execute
     520              :  * @param msg whether to print to console a failure message
     521              :  *
     522              :  * @return true if the file was successfully loaded
     523              :  * @return false if the file was not found
     524              :  */
     525              : extern bool execfile(const char *cfgfile, bool msg = true);
     526              : 
     527              : /**
     528              :  * @brief Replaces C style excape characters with Cubescript ones
     529              :  *
     530              :  * The resulting string is also wrapped in quotes ("").
     531              :  *
     532              :  * @param s the string to convert
     533              :  *
     534              :  * @return a string containing the escaped changes
     535              :  */
     536              : extern const char *escapestring(const char *s);
     537              : 
     538              : /**
     539              :  * @brief Prints out the formatted variable
     540              :  *
     541              :  * The param is intended to represent the value the ident object represents.
     542              :  *
     543              :  * @param id the ident object to print out
     544              :  * @param i the value to print out the variable equalling.
     545              :  */
     546              : extern void printvar(const ident *id, int i);
     547              : 
     548              : /**
     549              :  * @brief Modifies the value passed to fall within the boundaries passed.
     550              :  *
     551              :  * Clamps the value i to within minval and maxval. If hex is passed, warns in hex
     552              :  * mode, otherwise decimal. If the values are not within bounds, issued aformentioned
     553              :  * warning, refering to the passed name in the console message.
     554              :  *
     555              :  * @param hex toggles whether to display hex warning instead of decimal
     556              :  * @param name the name
     557              :  * @param i the value to clamp
     558              :  * @param minval the lowest value to clamp to
     559              :  * @param maxval the largest value to clamp to
     560              :  *
     561              :  * @return the clamped value
     562              :  */
     563              : extern int clampvar(bool hex, std::string name, int i, int minval, int maxval);
     564              : extern void loopiter(ident *id, identstack &stack, int i);
     565              : extern void loopend(ident *id, identstack &stack);
     566              : 
     567              : /**
     568              :  * @brief Escapes a string unless it is null.
     569              :  *
     570              :  * If an empty string is passed, escapestring() is not called. Otherwise, the same
     571              :  * behavior as in escapestring() is executed.
     572              :  *
     573              :  * @param s the string to convert
     574              :  *
     575              :  * @return a string containing the potentially applied escape changes
     576              :  */
     577              : const char *escapeid(const char *s);
     578              : 
     579              : /**
     580              :  * @brief Writes out the state of the CubeScript idents to a file.
     581              :  *
     582              :  * @param savedconfig the path to write to if name is nullptr
     583              :  * @param autoexec the path for the autoexec file for user modification, for display in top of file comment
     584              :  * @param defaultconfig the path for the master copy of the configuration file, for display in top of file comment
     585              :  * @param name the path to write to, if nullptr savedconfig is used instead
     586              :  */
     587              : extern void writecfg(const char *savedconfig, const char *autoexec = nullptr, const char *defaultconfig = nullptr, const char *name = nullptr);
     588              : 
     589              : /**
     590              :  * @brief Processes the cubescript sleep queue.
     591              :  *
     592              :  * At most, one sleep command is removed from the queue per cycle. Removes
     593              :  * queued sleep commands as they expire, which stops CS commands from executing
     594              :  * for a certain period of time.
     595              :  *
     596              :  * @param millis the current timestamp
     597              :  */
     598              : extern void checksleep(int millis);
     599              : 
     600              : /**
     601              :  * @brief Initializes the CubeScript preset argument idents.
     602              :  *
     603              :  * Intitializes the argument parameters (arg1, arg2, ..., arg<Max_Args>) as CS
     604              :  * ident objects. Required to use of $argN variables.
     605              :  * Also initializes the dummy ident, `//dummy`.
     606              :  *
     607              :  * @return always returns true
     608              :  */
     609              : extern bool initidents();
     610              : 
     611              : extern int identflags; /**< The flags to automatically set on ident objects */
     612              : 
     613              : /**
     614              :  * @brief Clears all aliases from the ident map.
     615              :  *
     616              :  * All aliases, aka objects created from within CubeScript, have their contents
     617              :  * (the names and code values associated with them) freed. Does not remove the
     618              :  * ident object itself from the global ident map.
     619              :  */
     620              : extern void clear_command();
     621              : 
     622              : // nasty macros for registering script functions, abuses globals to avoid excessive infrastructure
     623              : 
     624              : //* note: many of the VARF comments are very repetitive, because the code itself is nearly duplicated too *//
     625              : 
     626              : /* how command registration works:
     627              :  *  In C++, all global variables must be initiated before main() is called
     628              :  *  Each of these macro kludges (which are placed at the global scope level) initializes some kind of global variable
     629              :  *  Because the macro kludges are the definition of global variables, at program initializiation, they must be run first
     630              :  *  The values of the variables themselves don't matter because they only exist to cheat and run before main()
     631              :  *  The macro kludges themselves register commands or values within some vector<>-s which keeps track of all cmds/vars
     632              :  */
     633              : 
     634              : /*
     635              :  * Parameter Flags (exhaustive list, not exhaustive descriptions)
     636              :  * i an integer parameter
     637              :  * b a boolean parameter
     638              :  * f a float parameter (sets to 0 if over parameter limit)
     639              :  * F a float parameter (sets to value of previous parameter if over parameter limit)
     640              :  * s a string parameter (sets to new allocated string "" if over parameter limit)
     641              :  * S a string paremter (sets current string to "" if over parameter limit)
     642              :  * t sets to null if over parameter limit
     643              :  * T same as "t"
     644              :  * e a code block parameter
     645              :  * E a code block paremter (null)
     646              :  * r an ident parameter
     647              :  * $ an ident parameter
     648              :  * N a number parameter
     649              :  * D a bind parameter (e.g. player movement), adds a release action for the command
     650              :  * C an ident parameter, ComC
     651              :  * V a series of variadic parameter(s) (open ended series of values)
     652              :  * 1 repeat one arg
     653              :  * 2 repeat two args
     654              :  * 3 repeat three args
     655              :  * 4 repeat four args
     656              :  */
     657              : 
     658              : //integer var macros
     659              : //VAR_, _VARF, VARM_ are templates for "normal" macros that do not execute an inline function
     660              : #define VAR_(name, global, min, cur, max, persist)  int global = variable(#name, min, cur, max, &global, nullptr, persist)
     661              : #define VARN(name, global, min, cur, max) VAR_(name, global, min, cur, max, 0)
     662              : #define VARNP(name, global, min, cur, max) VAR_(name, global, min, cur, max, Idf_Persist)
     663              : #define VARNR(name, global, min, cur, max) VAR_(name, global, min, cur, max, Idf_Override)
     664              : #define VAR(name, min, cur, max) VAR_(name, name, min, cur, max, 0)
     665              : #define VARP(name, min, cur, max) VAR_(name, name, min, cur, max, Idf_Persist)
     666              : #define VARR(name, min, cur, max) VAR_(name, name, min, cur, max, Idf_Override)
     667              : 
     668              : //variable with inline function to be executed on change (VARiable with Function = VARF)
     669              : #define VARF_(name, global, min, cur, max, body, persist) \
     670              :     int global = variable(#name, min, cur, max, &global, [] (ident *) { body; }, persist); /* assign variable, needs fxn prototype declared above */
     671              : 
     672              : #define VARFN(name, global, min, cur, max, body) VARF_(name, global, min, cur, max, body, 0)
     673              : #define VARF(name, min, cur, max, body) VARF_(name, name, min, cur, max, body, 0)
     674              : #define VARFP(name, min, cur, max, body) VARF_(name, name, min, cur, max, body, Idf_Persist)
     675              : #define VARFR(name, min, cur, max, body) VARF_(name, name, min, cur, max, body, Idf_Override)
     676              : #define VARFNP(name, global, min, cur, max, body) VARF_(name, global, min, cur, max, body, Idf_Persist)
     677              : 
     678              : //hexadecimal var macros
     679              : #define HVAR_(name, global, min, cur, max, persist)  int global = variable(#name, min, cur, max, &global, nullptr, persist | Idf_Hex)
     680              : #define HVARP(name, min, cur, max) HVAR_(name, name, min, cur, max, Idf_Persist)
     681              : 
     682              : //hex variable with function to be executed on change (Hexadecimal VARiable with Function = HVARF)
     683              : //the CVAR series of macros borrows the HVARF macro as it deals with hex colors
     684              : #define HVARF_(name, global, min, cur, max, body, persist) \
     685              :     int global = variable(#name, min, cur, max, &global, [] (ident *) { body; }, persist | Idf_Hex); /* assign variable, needs fxn prototype declared above */
     686              : 
     687              : //color var macros
     688              : #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)
     689              : #define CVARP(name, cur) CVAR_(name, cur, , , Idf_Persist)
     690              : #define CVARR(name, cur) CVAR_(name, cur, , , Idf_Override)
     691              : #define CVARFP(name, cur, body) CVAR_(name, cur, , body, Idf_Persist)
     692              : #define CVAR0_(name, cur, body, persist) CVAR_(name, cur, { if(!_##name) _##name = cur; }, body, persist)
     693              : #define CVAR0R(name, cur) CVAR0_(name, cur, , Idf_Override)
     694              : #define CVAR1_(name, cur, body, persist) CVAR_(name, cur, { if(_##name <= 255) _##name |= (_##name<<8) | (_##name<<16); }, body, persist)
     695              : #define CVAR1R(name, cur) CVAR1_(name, cur, , Idf_Override)
     696              : #define CVAR1FR(name, cur, body) CVAR1_(name, cur, body, Idf_Override)
     697              : 
     698              : //float var macros
     699              : #define FVAR_(name, global, min, cur, max, persist) float global = fvariable(#name, min, cur, max, &global, nullptr, persist)
     700              : #define FVARNP(name, global, min, cur, max) FVAR_(name, global, min, cur, max, Idf_Persist)
     701              : #define FVAR(name, min, cur, max) FVAR_(name, name, min, cur, max, 0)
     702              : #define FVARP(name, min, cur, max) FVAR_(name, name, min, cur, max, Idf_Persist)
     703              : #define FVARR(name, min, cur, max) FVAR_(name, name, min, cur, max, Idf_Override)
     704              : 
     705              : //float variable with function to be executed on change (Float VARiable with Function = FVARF)
     706              : #define FVARF_(name, global, min, cur, max, body, persist) \
     707              :     float global = fvariable(#name, min, cur, max, &global, [] (ident *) { body; }, persist); /* assign variable, needs fxn prototype declared above */ \
     708              : 
     709              : #define FVARF(name, min, cur, max, body) FVARF_(name, name, min, cur, max, body, 0)
     710              : #define FVARFP(name, min, cur, max, body) FVARF_(name, name, min, cur, max, body, Idf_Persist)
     711              : #define FVARFR(name, min, cur, max, body) FVARF_(name, name, min, cur, max, body, Idf_Override)
     712              : 
     713              : //string var macros
     714              : #define SVAR_(name, global, cur, persist) char *global = svariable(#name, cur, &global, nullptr, persist)
     715              : #define SVAR(name, cur) SVAR_(name, name, cur, 0)
     716              : #define SVARP(name, cur) SVAR_(name, name, cur, Idf_Persist)
     717              : #define SVARR(name, cur) SVAR_(name, name, cur, Idf_Override)
     718              : 
     719              : //string variable with function to be executed on change (Float VARiable with Function = FVARF)
     720              : #define SVARF_(name, global, cur, body, persist) \
     721              :     char *global = svariable(#name, cur, &global, [] (ident *) { body; }, persist); /* assign variable, needs fxn prototype declared above */
     722              : 
     723              : #define SVARF(name, cur, body) SVARF_(name, name, cur, body, 0)
     724              : #define SVARFR(name, cur, body) SVARF_(name, name, cur, body, Idf_Override)
     725              : 
     726              : #endif /* COMMAND_H_ */
        

Generated by: LCOV version 2.0-1