2021-04-15 02:42:06 +02:00
|
|
|
/** @file ident.hh
|
|
|
|
*
|
|
|
|
* @brief Identifier management.
|
|
|
|
*
|
|
|
|
* Identifiers in `libcubescript` represent variables, aliases, commands
|
|
|
|
* and so on. This file contains the handles for those and everything you
|
|
|
|
* need to interface with them.
|
|
|
|
*
|
|
|
|
* @copyright See COPYING.md in the project tree for further information.
|
|
|
|
*/
|
|
|
|
|
2021-04-05 04:40:52 +02:00
|
|
|
#ifndef LIBCUBESCRIPT_CUBESCRIPT_IDENT_HH
|
|
|
|
#define LIBCUBESCRIPT_CUBESCRIPT_IDENT_HH
|
|
|
|
|
|
|
|
#include <string_view>
|
|
|
|
|
|
|
|
#include "value.hh"
|
|
|
|
|
|
|
|
namespace cubescript {
|
|
|
|
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief The type of the ident.
|
|
|
|
*
|
|
|
|
* Cubescript has a selection of idents. This represents the type of each.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
enum class ident_type {
|
2021-04-20 02:52:27 +02:00
|
|
|
IVAR = 0, /**< @brief Integer builtin variable. */
|
|
|
|
FVAR, /**< @brief Float builtin variable. */
|
|
|
|
SVAR, /**< @brief String builtin variable. */
|
|
|
|
COMMAND, /**< @brief Builtin command. */
|
|
|
|
ALIAS, /**< @brief User assigned variable. */
|
|
|
|
SPECIAL /**< @brief Other (internal unexposed type). */
|
2021-04-05 04:40:52 +02:00
|
|
|
};
|
|
|
|
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief The ident structure.
|
|
|
|
*
|
|
|
|
* Every object within the Cubescript language is represented with an ident.
|
|
|
|
* This is the generic base interface. There are some operations that are
|
|
|
|
* available on any ident.
|
|
|
|
*
|
|
|
|
* You can also check the actual type with it (cubescript::ident_type) and
|
|
|
|
* decide to cast it to its appropriate specific type, or use the helpers.
|
2021-04-23 03:20:53 +02:00
|
|
|
*
|
|
|
|
* An ident always has a valid name. A valid name is pretty much any
|
|
|
|
* valid Cubescript word (see cubescript::parse_word()) which does not
|
|
|
|
* begin with a number (a digit, a `+` or `-` followed by a digit or a
|
|
|
|
* period followed by a digit, or a period followed by a digit).
|
2021-04-20 02:52:27 +02:00
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
struct LIBCUBESCRIPT_EXPORT ident {
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief Get the cubescript::ident_type of this ident. */
|
2021-04-05 04:40:52 +02:00
|
|
|
ident_type get_type() const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Get a view to the name of the ident. */
|
2021-04-05 04:40:52 +02:00
|
|
|
std::string_view get_name() const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Get the index of the ident.
|
|
|
|
*
|
|
|
|
* Idents are internally indexed. There is no guarantee of what index
|
|
|
|
* the ident will have, but you can still use it to identify the object
|
|
|
|
* with an integer (it is guaranteed that once created, it will stay the
|
|
|
|
* same for the whole lifetime of the main thread).
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
int get_index() const;
|
|
|
|
|
2021-04-24 23:33:19 +02:00
|
|
|
/** @brief Check if the idents are the same. */
|
|
|
|
bool operator==(ident &other) const;
|
|
|
|
|
|
|
|
/** @brief Check if the idents are not the same. */
|
|
|
|
bool operator!=(ident &other) const;
|
|
|
|
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief Check if the ident is a cubescript::alias.
|
|
|
|
*
|
|
|
|
* Effectively like `get_type() == ident_type::ALIAS`.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
bool is_alias() const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Check if the ident is a cubescript::command.
|
|
|
|
*
|
|
|
|
* Effectively like `get_type() == ident_type::COMMAND`.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
bool is_command() const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Check if the ident is a special ident.
|
|
|
|
*
|
|
|
|
* Effectively like `get_type() == ident_type::SPECIAL`.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
bool is_special() const;
|
|
|
|
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief Check if the ident is a cubescript::global_var.
|
|
|
|
*
|
|
|
|
* This will return `true` if ident::get_type() returns either
|
|
|
|
* ident_type::IVAR, ident_type::FVAR or ident_type::SVAR.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
bool is_var() const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Check if the ident is a cubescript::integer_var.
|
|
|
|
*
|
|
|
|
* Effectively like `get_type() == ident_type::IVAR`.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
bool is_ivar() const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Check if the ident is a cubescript::float_var.
|
|
|
|
*
|
|
|
|
* Effectively like `get_type() == ident_type::FVAR`.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
bool is_fvar() const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Check if the ident is a cubescript::string_var.
|
|
|
|
*
|
|
|
|
* Effectively like `get_type() == ident_type::SVAR`.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
bool is_svar() const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Get if the ident is overridden.
|
|
|
|
*
|
|
|
|
* This can be true for aliases or builtins. When an alias or a builtin
|
|
|
|
* is assigned to and the VM is in override mode or the builtin is
|
|
|
|
* var_type::OVERRIDABLE, they are marked as overridden (and builtins
|
|
|
|
* have their value saved beforehand).
|
|
|
|
*
|
|
|
|
* This can be cleared later, which will erase the value (for aliases)
|
|
|
|
* or restore the saved one (for builtins). For aliases, this can be
|
|
|
|
* specific to the Cubescript thread.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
bool is_overridden(state &cs) const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Get if the ident is persistent.
|
|
|
|
*
|
|
|
|
* This can be true in two cases. Either it's a builtin and it has the
|
|
|
|
* var_type::PERSISTENT flag, or it's an alias that is assigned to while
|
|
|
|
* the VM is in persist mode. The latter can be thread specific (when the
|
|
|
|
* alias is currently pushed).
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
bool is_persistent(state &cs) const;
|
|
|
|
|
|
|
|
protected:
|
2021-04-07 00:30:39 +02:00
|
|
|
friend struct ident_p;
|
2021-04-05 04:40:52 +02:00
|
|
|
|
2021-04-07 00:30:39 +02:00
|
|
|
ident() = default;
|
2021-04-05 04:40:52 +02:00
|
|
|
|
|
|
|
struct ident_impl *p_impl{};
|
|
|
|
};
|
|
|
|
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief An additional cubescript::global_var type.
|
|
|
|
*
|
|
|
|
* Global vars can have no additional type, or they can be persistent, or
|
|
|
|
* they can be overridable. Persistent variables are meant to be saved and
|
|
|
|
* loaded later (the actual logic is up to the user of the library).
|
|
|
|
*
|
|
|
|
* Overridable variables are overridden when assigned to (this can also
|
|
|
|
* happen to normal variables when the VM is in override mode), which saves
|
|
|
|
* their old value (which can be restored later when un-overridden). This
|
|
|
|
* is mutually exclusive; overridable variables cannot be persistent, and
|
|
|
|
* attempting to assign to a persistent variable while the VM is in override
|
|
|
|
* mode will raise an error.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
enum class var_type {
|
2021-04-20 02:52:27 +02:00
|
|
|
DEFAULT = 0, /**< @brief The default type. */
|
|
|
|
PERSISTENT, /**< @brief Persistent variable. */
|
|
|
|
OVERRIDABLE /**< @brief Overridable variable. */
|
2021-04-05 04:40:52 +02:00
|
|
|
};
|
|
|
|
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief A global variable.
|
|
|
|
*
|
|
|
|
* This represents one of cubescript::integer_var, cubescript::float_var or
|
|
|
|
* cubescript::string_var as a single interface, with shared operations.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
struct LIBCUBESCRIPT_EXPORT global_var: ident {
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief Get whether the variable is read only.
|
|
|
|
*
|
|
|
|
* Variables can be set as read only during their creation (but not
|
|
|
|
* later). This will prevent assignments to them from within the language
|
|
|
|
* or using checked APIs, but it is still possible to assign to them
|
|
|
|
* using raw APIs. The raw APIs will not invoke value triggers, however.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
bool is_read_only() const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Get whether the variable is overridable.
|
|
|
|
*
|
|
|
|
* Equivalent to `get_variable_type() == var_type::OVERRIDABLE`.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
bool is_overridable() const;
|
|
|
|
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief Get the cubescript::var_type of the variable. */
|
2021-04-05 04:40:52 +02:00
|
|
|
var_type get_variable_type() const;
|
|
|
|
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief Save the variable.
|
|
|
|
*
|
|
|
|
* This is mainly intended for variable assignment triggers. If the
|
|
|
|
* variable is overridable or the given thread is in override mode,
|
|
|
|
* this will save the current value of the variable (if not already
|
|
|
|
* overridden). Otherwise, it will clear any existing overridden flag.
|
|
|
|
*
|
|
|
|
* @throw cubescript::error if the thread is in override mode and the
|
|
|
|
* variable is persistent.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
void save(state &cs);
|
|
|
|
|
|
|
|
protected:
|
|
|
|
global_var() = default;
|
|
|
|
};
|
|
|
|
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief An integer variable.
|
|
|
|
*
|
|
|
|
* A specialization of cubescript::global_var for integer values.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
struct LIBCUBESCRIPT_EXPORT integer_var: global_var {
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief Get the value of the variable. */
|
2021-04-05 04:40:52 +02:00
|
|
|
integer_type get_value() const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Set the value of the variable.
|
|
|
|
*
|
|
|
|
* If read only, an error is raised. If `do_write` is `false`, nothing
|
|
|
|
* will be performed other than the read-only checking. If `trigger` is
|
|
|
|
* `false`, a potential variable change trigger command will not be
|
|
|
|
* invoked. The value is saved with global_var::save(), assuming
|
|
|
|
* `do_write` is `true`. After that, integer_var::set_raw_value()
|
|
|
|
* is invoked, and then the trigger.
|
|
|
|
*
|
|
|
|
* @throw cubescript::error if read only or if the changed trigger throws.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
void set_value(
|
|
|
|
state &cs, integer_type val, bool do_write = true, bool trigger = true
|
|
|
|
);
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Set the value of the variable in a raw manner.
|
|
|
|
*
|
|
|
|
* This will always set the value and ignore any kinds of checks. It will
|
|
|
|
* not invoke any triggers either, nor it will save the the value.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
void set_raw_value(integer_type val);
|
|
|
|
|
|
|
|
protected:
|
|
|
|
integer_var() = default;
|
|
|
|
};
|
|
|
|
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief A float variable.
|
|
|
|
*
|
|
|
|
* A specialization of cubescript::global_var for float values.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
struct LIBCUBESCRIPT_EXPORT float_var: global_var {
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief Get the value of the variable. */
|
2021-04-05 04:40:52 +02:00
|
|
|
float_type get_value() const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Set the value of the variable.
|
|
|
|
*
|
|
|
|
* If read only, an error is raised. If `do_write` is `false`, nothing
|
|
|
|
* will be performed other than the read-only checking. If `trigger` is
|
|
|
|
* `false`, a potential variable change trigger command will not be
|
|
|
|
* invoked. The value is saved with global_var::save(), assuming
|
|
|
|
* `do_write` is `true`. After that, integer_var::set_raw_value()
|
|
|
|
* is invoked, and then the trigger.
|
|
|
|
*
|
|
|
|
* @throw cubescript::error if read only or if the changed trigger throws.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
void set_value(
|
|
|
|
state &cs, float_type val, bool do_write = true, bool trigger = true
|
|
|
|
);
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Set the value of the variable in a raw manner.
|
|
|
|
*
|
|
|
|
* This will always set the value and ignore any kinds of checks. It will
|
|
|
|
* not invoke any triggers either, nor it will save the the value.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
void set_raw_value(float_type val);
|
|
|
|
|
|
|
|
protected:
|
|
|
|
float_var() = default;
|
|
|
|
};
|
|
|
|
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief A string variable.
|
|
|
|
*
|
|
|
|
* A specialization of cubescript::global_var for string values.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
struct LIBCUBESCRIPT_EXPORT string_var: global_var {
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief Get the value of the variable. */
|
2021-04-05 04:40:52 +02:00
|
|
|
string_ref get_value() const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Set the value of the variable.
|
|
|
|
*
|
|
|
|
* If read only, an error is raised. If `do_write` is `false`, nothing
|
|
|
|
* will be performed other than the read-only checking. If `trigger` is
|
|
|
|
* `false`, a potential variable change trigger command will not be
|
|
|
|
* invoked. The value is saved with global_var::save(), assuming
|
|
|
|
* `do_write` is `true`. After that, integer_var::set_raw_value()
|
|
|
|
* is invoked, and then the trigger.
|
|
|
|
*
|
|
|
|
* @throw cubescript::error if read only or if the changed trigger throws.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
void set_value(
|
|
|
|
state &cs, string_ref val, bool do_write = true, bool trigger = true
|
|
|
|
);
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Set the value of the variable in a raw manner.
|
|
|
|
*
|
|
|
|
* This will always set the value and ignore any kinds of checks. It will
|
|
|
|
* not invoke any triggers either, nor it will save the the value.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
void set_raw_value(string_ref val);
|
|
|
|
|
|
|
|
protected:
|
|
|
|
string_var() = default;
|
|
|
|
};
|
|
|
|
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief An alias.
|
|
|
|
*
|
|
|
|
* An alias is an ident that is created inside the language, for example
|
|
|
|
* by assignment. Any variable that you can assign to or look up and is not
|
|
|
|
* a builtin is an alias. Aliases don't have special assignment syntax nor
|
|
|
|
* they have changed triggers nor value saving. They technically always
|
|
|
|
* represent a string within the language, though on C++ side they can
|
|
|
|
* have float or integer values too.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
struct LIBCUBESCRIPT_EXPORT alias: ident {
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief Get if this alias represents a function argument.
|
|
|
|
*
|
|
|
|
* This is true for `argN` aliases representing the arguments passed to
|
|
|
|
* the current function.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
bool is_arg() const;
|
|
|
|
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief Get the value of the alias for the given thread. */
|
2021-04-05 18:19:32 +02:00
|
|
|
any_value get_value(state &cs) const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Set the value of the alias for the given thread. */
|
2021-04-05 18:19:32 +02:00
|
|
|
void set_value(state &cs, any_value v);
|
|
|
|
|
2021-04-05 04:40:52 +02:00
|
|
|
protected:
|
|
|
|
alias() = default;
|
|
|
|
};
|
|
|
|
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief A command.
|
|
|
|
*
|
|
|
|
* Commands are builtins that can be invoked from the language and have a
|
|
|
|
* native implementation registered from C++. Once registered, a command
|
|
|
|
* cannot be unregistered or otherwise changed.
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
struct LIBCUBESCRIPT_EXPORT command: ident {
|
2021-04-20 02:52:27 +02:00
|
|
|
/** @brief Get the argument list. */
|
2021-04-05 04:40:52 +02:00
|
|
|
std::string_view get_args() const;
|
2021-04-20 02:52:27 +02:00
|
|
|
|
|
|
|
/** @brief Get the number of arguments the command expects.
|
|
|
|
*
|
|
|
|
* Only non-variadic arguments count here (i.e. no repeated arguments,
|
|
|
|
* no `C`, no `V`; everything else counts as one argument).
|
|
|
|
*/
|
2021-04-05 04:40:52 +02:00
|
|
|
int get_num_args() const;
|
|
|
|
|
|
|
|
protected:
|
|
|
|
command() = default;
|
|
|
|
};
|
|
|
|
|
2021-04-25 00:48:04 +02:00
|
|
|
/** @brief A safe alias handler for commands
|
|
|
|
*
|
|
|
|
* In general, when dealing with aliases in commands, you do not want to
|
|
|
|
* set them directly, since this would set the alias globally. Instead, you
|
|
|
|
* can use this to make aliases local to the command.
|
|
|
|
*
|
|
|
|
* Internally, each Cubescript thread has a mapping for alias state within
|
|
|
|
* the thread. This mapping is stack based - which means you can push an
|
|
|
|
* alias, and then anything affecting the value of the alias in that thread
|
|
|
|
* will only be visible until the stack is popped. This structure provides
|
|
|
|
* a safe means of handling the alias stack; constructing it will push the
|
|
|
|
* alias, destroying it will pop it.
|
|
|
|
*
|
|
|
|
* Therefore, what you can do is something like this:
|
|
|
|
*
|
|
|
|
* ```
|
|
|
|
* {
|
|
|
|
* alias_local s{my_thread, "test"};
|
|
|
|
* // branch taken when the alias was successfully pushed
|
|
|
|
* // setting the alias will only be visible within this scope
|
|
|
|
* s.set(some_value); // a convenient setter
|
|
|
|
* my_thread.run(...);
|
|
|
|
* }
|
|
|
|
* ```
|
|
|
|
*
|
|
|
|
* If the provided input is not an alias, a cubescript::error will be thrown.
|
|
|
|
* Often you don't have to catch it (since this is primarily intended for use
|
|
|
|
* within commands, the error will propagate outside your command).
|
|
|
|
*
|
|
|
|
* Since the goal is to interact tightly with RAII and ensure consistency at
|
|
|
|
* all times, it is not possible to copy or move this object. That means you
|
|
|
|
* should also not be storing it; it should be used purely as a scope based
|
|
|
|
* alias stack manager.
|
|
|
|
*/
|
|
|
|
struct LIBCUBESCRIPT_EXPORT alias_local {
|
|
|
|
/** @brief Construct the local handler */
|
|
|
|
alias_local(state &cs, ident &a);
|
|
|
|
|
|
|
|
/** @brief Construct the local handler
|
|
|
|
*
|
|
|
|
* The ident will be retrieved using state::new_ident().
|
|
|
|
*/
|
|
|
|
alias_local(state &cs, std::string_view name);
|
|
|
|
|
|
|
|
/** @brief Construct the local handler
|
|
|
|
*
|
|
|
|
* The ident will be retrieved from the value. If the contained value
|
|
|
|
* is not an ident, it will be treated as a name.
|
|
|
|
*/
|
|
|
|
alias_local(state &cs, any_value const &val);
|
|
|
|
|
|
|
|
/** @brief Destroy the local handler */
|
|
|
|
~alias_local();
|
|
|
|
|
|
|
|
/** @brief Local handlers are not copyable */
|
|
|
|
alias_local(alias_local const &) = delete;
|
|
|
|
|
|
|
|
/** @brief Local handlers are not movable */
|
|
|
|
alias_local(alias_local &&) = delete;
|
|
|
|
|
|
|
|
/** @brief Local handlers are not copy assignable */
|
|
|
|
alias_local &operator=(alias_local const &) = delete;
|
|
|
|
|
|
|
|
/** @brief Local handlers are not move assignable */
|
|
|
|
alias_local &operator=(alias_local &&v) = delete;
|
|
|
|
|
|
|
|
/** @brief Get the contained alias */
|
|
|
|
alias &get_alias() noexcept { return *p_alias; }
|
|
|
|
|
|
|
|
/** @brief Get the contained alias */
|
|
|
|
alias const &get_alias() const noexcept { return *p_alias; }
|
|
|
|
|
|
|
|
/** @brief Set the contained alias's value
|
|
|
|
*
|
|
|
|
* @return `true` if the alias is valid, `false` otherwise
|
|
|
|
*/
|
|
|
|
bool set(any_value val);
|
|
|
|
|
|
|
|
private:
|
|
|
|
alias *p_alias;
|
|
|
|
void *p_sp;
|
|
|
|
};
|
|
|
|
|
2021-04-05 04:40:52 +02:00
|
|
|
} /* namespace cubescript */
|
|
|
|
|
|
|
|
#endif /* LIBCUBESCRIPT_CUBESCRIPT_IDENT_HH */
|