JDBtracker
/
libcubescript
forked from OctaForge/libcubescript
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

style updates

master
Daniel Kolesa 2016-09-07 20:20:36 +02:00
parent 2440d2bb9a
commit 935b5bf634
6 changed files with 652 additions and 645 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

561
cs_gen.cc
View File

File diff suppressed because it is too large Load Diff

6
cs_val.cc
View File

@ -18,7 +18,7 @@ static inline void csv_cleanup(CsValueType tv, T &stor) {
break;
case CsValueType::Code: {
ostd::Uint32 *bcode = csv_get<ostd::Uint32 *>(stor);
if (bcode[-1] == CODE_START) {
if (bcode[-1] == CsCodeStart) {
delete[] bcode;
}
break;
@ -324,8 +324,8 @@ OSTD_EXPORT bool cs_code_is_empty(CsBytecode *code) {
return true;
}
return (
*reinterpret_cast<ostd::Uint32 *>(code) & CODE_OP_MASK
) == CODE_EXIT;
*reinterpret_cast<ostd::Uint32 *>(code) & CsCodeOpMask
) == CsCodeExit;
}
bool CsValue::code_is_empty() const {

534
cs_vm.cc
View File

File diff suppressed because it is too large Load Diff

110
cs_vm.hh
View File

@ -18,19 +18,19 @@ static constexpr int NumargsIdx = MaxArguments + 1;
static constexpr int DbgaliasIdx = MaxArguments + 2;
enum {
ID_UNKNOWN = -1, ID_IVAR, ID_FVAR, ID_SVAR, ID_COMMAND, ID_ALIAS,
ID_LOCAL, ID_DO, ID_DOARGS, ID_IF, ID_RESULT, ID_NOT, ID_AND, ID_OR
CsIdUnknown = -1, CsIdIvar, CsIdFvar, CsIdSvar, CsIdCommand, CsIdAlias,
CsIdLocal, CsIdDo, CsIdDoArgs, CsIdIf, CsIdResult, CsIdNot, CsIdAnd, CsIdOr
};
enum {
VAL_NULL = 0, VAL_INT, VAL_FLOAT, VAL_STR,
VAL_ANY, VAL_CODE, VAL_MACRO, VAL_IDENT, VAL_CSTR,
VAL_CANY, VAL_WORD, VAL_POP, VAL_COND
CsValNull = 0, CsValInt, CsValFloat, CsValString,
CsValAny, CsValCode, CsValMacro, CsValIdent, CsValCstring,
CsValCany, CsValWord, CsValPop, CsValCond
};
static const int cs_valtypet[] = {
VAL_NULL, VAL_INT, VAL_FLOAT, VAL_STR,
VAL_CSTR, VAL_CODE, VAL_MACRO, VAL_IDENT
CsValNull, CsValInt, CsValFloat, CsValString,
CsValCstring, CsValCode, CsValMacro, CsValIdent
};
static inline int cs_vtype_to_int(CsValueType v) {
@ -39,45 +39,45 @@ static inline int cs_vtype_to_int(CsValueType v) {
/* instruction: uint32 [length 24][retflag 2][opcode 6] */
enum {
CODE_START = 0,
CODE_OFFSET,
CODE_NULL, CODE_TRUE, CODE_FALSE, CODE_NOT,
CODE_POP,
CODE_ENTER, CODE_ENTER_RESULT,
CODE_EXIT, CODE_RESULT_ARG,
CODE_VAL, CODE_VALI,
CODE_DUP,
CODE_MACRO,
CODE_BOOL,
CODE_BLOCK, CODE_EMPTY,
CODE_COMPILE, CODE_COND,
CODE_FORCE,
CODE_RESULT,
CODE_IDENT, CODE_IDENTU, CODE_IDENTARG,
CODE_COM, CODE_COMC, CODE_COMV,
CODE_CONC, CODE_CONCW, CODE_CONCM, CODE_DOWN,
CODE_SVAR, CODE_SVARM, CODE_SVAR1,
CODE_IVAR, CODE_IVAR1, CODE_IVAR2, CODE_IVAR3,
CODE_FVAR, CODE_FVAR1,
CODE_LOOKUP, CODE_LOOKUPU, CODE_LOOKUPARG,
CODE_LOOKUPM, CODE_LOOKUPMU, CODE_LOOKUPMARG,
CODE_ALIAS, CODE_ALIASU, CODE_ALIASARG,
CODE_CALL, CODE_CALLU, CODE_CALLARG,
CODE_PRINT,
CODE_LOCAL,
CODE_DO, CODE_DOARGS,
CODE_JUMP, CODE_JUMP_TRUE, CODE_JUMP_FALSE,
CODE_JUMP_RESULT_TRUE, CODE_JUMP_RESULT_FALSE,
CsCodeStart = 0,
CsCodeOffset,
CsCodeNull, CsCodeTrue, CsCodeFalse, CsCodeNot,
CsCodePop,
CsCodeEnter, CsCodeEnterResult,
CsCodeExit, CsCodeResultArg,
CsCodeVal, CsCodeValInt,
CsCodeDup,
CsCodeMacro,
CsCodeBool,
CsCodeBlock, CsCodeEmpty,
CsCodeCompile, CsCodeCond,
CsCodeForce,
CsCodeResult,
CsCodeIdent, CsCodeIdentU, CsCodeIdentArg,
CsCodeCom, CsCodeComC, CsCodeComV,
CsCodeConc, CsCodeConcW, CsCodeConcM,
CsCodeSvar, CsCodeSvarM, CsCodeSvar1,
CsCodeIvar, CsCodeIvar1, CsCodeIvar2, CsCodeIvar3,
CsCodeFvar, CsCodeFvar1,
CsCodeLookup, CsCodeLookupU, CsCodeLookupArg,
CsCodeLookupM, CsCodeLookupMu, CsCodeLookupMarg,
CsCodeAlias, CsCodeAliasU, CsCodeAliasArg,
CsCodeCall, CsCodeCallU, CsCodeCallArg,
CsCodePrint,
CsCodeLocal,
CsCodeDo, CsCodeDoArgs,
CsCodeJump, CsCodeJumpTrue, CsCodeJumpFalse,
CsCodeJumpResultTrue, CsCodeJumpResultFalse,
CODE_OP_MASK = 0x3F,
CODE_RET = 6,
CODE_RET_MASK = 0xC0,
CsCodeOpMask = 0x3F,
CsCodeRet = 6,
CsCodeRetMask = 0xC0,
/* return type flags */
RET_NULL = VAL_NULL << CODE_RET,
RET_STR = VAL_STR << CODE_RET,
RET_INT = VAL_INT << CODE_RET,
RET_FLOAT = VAL_FLOAT << CODE_RET,
CsRetNull = CsValNull << CsCodeRet,
CsRetString = CsValString << CsCodeRet,
CsRetInt = CsValInt << CsCodeRet,
CsRetFloat = CsValFloat << CsCodeRet,
};
ostd::ConstCharRange cs_debug_line(
@ -120,7 +120,7 @@ struct GenState {
void gen_str(ostd::ConstCharRange word, bool macro = false) {
if (word.size() <= 3 && !macro) {
ostd::Uint32 op = CODE_VALI | RET_STR;
ostd::Uint32 op = CsCodeValInt | CsRetString;
for (ostd::Size i = 0; i < word.size(); ++i) {
op |= ostd::Uint32(ostd::byte(word[i])) << ((i + 1) * 8);
}
@ -128,7 +128,7 @@ struct GenState {
return;
}
code.push(
(macro ? CODE_MACRO : (CODE_VAL | RET_STR)) | (word.size() << 8)
(macro ? CsCodeMacro : (CsCodeVal | CsRetString)) | (word.size() << 8)
);
code.push_n(
reinterpret_cast<ostd::Uint32 const *>(word.data()),
@ -145,18 +145,18 @@ struct GenState {
}
void gen_str() {
code.push(CODE_VALI | RET_STR);
code.push(CsCodeValInt | CsRetString);
}
void gen_null() {
code.push(CODE_VALI | RET_NULL);
code.push(CsCodeValInt | CsRetNull);
}
void gen_int(CsInt i = 0) {
if (i >= -0x800000 && i <= 0x7FFFFF) {
code.push(CODE_VALI | RET_INT | (i << 8));
code.push(CsCodeValInt | CsRetInt | (i << 8));
} else {
code.push(CODE_VAL | RET_INT);
code.push(CsCodeVal | CsRetInt);
code.push(i);
}
}
@ -165,14 +165,14 @@ struct GenState {
void gen_float(CsFloat f = 0.0f) {
if (CsInt(f) == f && f >= -0x800000 && f <= 0x7FFFFF) {
code.push(CODE_VALI | RET_FLOAT | (CsInt(f) << 8));
code.push(CsCodeValInt | CsRetFloat | (CsInt(f) << 8));
} else {
union {
CsFloat f;
ostd::Uint32 u;
} c;
c.f = f;
code.push(CODE_VAL | RET_FLOAT);
code.push(CsCodeVal | CsRetFloat);
code.push(c.u);
}
}
@ -182,8 +182,8 @@ struct GenState {
void gen_ident(CsIdent *id) {
code.push(
((id->get_index() < MaxArguments)
? CODE_IDENTARG
: CODE_IDENT
? CsCodeIdentArg
: CsCodeIdent
) | (id->get_index() << 8)
);
}
@ -200,7 +200,7 @@ struct GenState {
int wordtype, ostd::ConstCharRange word = ostd::ConstCharRange()
);
void gen_main(ostd::ConstCharRange s, int ret_type = VAL_ANY);
void gen_main(ostd::ConstCharRange s, int ret_type = CsValAny);
char next_char() {
return *source++;
@ -243,7 +243,7 @@ struct CsAliasInternal {
a->p_val = ostd::move(v);
clean_code(a);
if (um) {
a->p_flags &= ~IDF_UNKNOWN;
a->p_flags &= ~CsIdfUnknown;
}
}

60
cubescript.cc
View File

@ -41,14 +41,14 @@ CsVar::CsVar(CsIdentType tp, ostd::ConstCharRange name, CsVarCb f, int fl):
CsIvar::CsIvar(
ostd::ConstCharRange name, CsInt m, CsInt x, CsInt v, CsVarCb f, int fl
):
CsVar(CsIdentType::Ivar, name, ostd::move(f), fl | ((m > x) ? IDF_READONLY : 0)),
CsVar(CsIdentType::Ivar, name, ostd::move(f), fl | ((m > x) ? CsIdfReadOnly : 0)),
p_storage(v), p_minval(m), p_maxval(x), p_overrideval(0)
{}
CsFvar::CsFvar(
ostd::ConstCharRange name, CsFloat m, CsFloat x, CsFloat v, CsVarCb f, int fl
):
CsVar(CsIdentType::Fvar, name, ostd::move(f), fl | ((m > x) ? IDF_READONLY : 0)),
CsVar(CsIdentType::Fvar, name, ostd::move(f), fl | ((m > x) ? CsIdfReadOnly : 0)),
p_storage(v), p_minval(m), p_maxval(x), p_overrideval(0)
{}
@ -260,7 +260,7 @@ CsState::CsState(): p_out(&ostd::out), p_err(&ostd::err) {
for (int i = 0; i < MaxArguments; ++i) {
char buf[32];
snprintf(buf, sizeof(buf), "arg%d", i + 1);
new_ident(static_cast<char const *>(buf), IDF_ARG);
new_ident(static_cast<char const *>(buf), CsIdfArg);
}
CsIdent *id = new_ident("//dummy");
assert(id->get_index() == DummyIdx);
@ -273,7 +273,7 @@ CsState::CsState(): p_out(&ostd::out), p_err(&ostd::err) {
new_command("do", "e", [this](CsValueRange args, CsValue &res) {
run(args[0].get_code(), res);
})->p_type = ID_DO;
})->p_type = CsIdDo;
new_command("doargs", "e", [this](CsValueRange args, CsValue &res) {
if (p_stack != &noalias) {
@ -281,19 +281,19 @@ CsState::CsState(): p_out(&ostd::out), p_err(&ostd::err) {
} else {
run(args[0].get_code(), res);
}
})->p_type = ID_DOARGS;
})->p_type = CsIdDoArgs;
new_command("if", "tee", [this](CsValueRange args, CsValue &res) {
run((args[0].get_bool() ? args[1] : args[2]).get_code(), res);
})->p_type = ID_IF;
})->p_type = CsIdIf;
new_command("result", "T", [](CsValueRange args, CsValue &res) {
res = ostd::move(args[0]);
})->p_type = ID_RESULT;
})->p_type = CsIdResult;
new_command("!", "t", [](CsValueRange args, CsValue &res) {
res.set_int(!args[0].get_bool());
})->p_type = ID_NOT;
})->p_type = CsIdNot;
new_command("&&", "E1V", [this](CsValueRange args, CsValue &res) {
if (args.empty()) {
@ -311,7 +311,7 @@ CsState::CsState(): p_out(&ostd::out), p_err(&ostd::err) {
}
}
}
})->p_type = ID_AND;
})->p_type = CsIdAnd;
new_command("||", "E1V", [this](CsValueRange args, CsValue &res) {
if (args.empty()) {
@ -329,9 +329,9 @@ CsState::CsState(): p_out(&ostd::out), p_err(&ostd::err) {
}
}
}
})->p_type = ID_OR;
})->p_type = CsIdOr;
new_command("local", nullptr, nullptr)->p_type = ID_LOCAL;
new_command("local", nullptr, nullptr)->p_type = CsIdLocal;
cs_init_lib_base(*this);
}
@ -395,7 +395,7 @@ void *CsState::alloc(void *ptr, ostd::Size, ostd::Size ns) {
}
void CsState::clear_override(CsIdent &id) {
if (!(id.get_flags() & IDF_OVERRIDDEN)) {
if (!(id.get_flags() & CsIdfOverridden)) {
return;
}
switch (id.get_type()) {
@ -426,7 +426,7 @@ void CsState::clear_override(CsIdent &id) {
default:
break;
}
id.p_flags &= ~IDF_OVERRIDDEN;
id.p_flags &= ~CsIdfOverridden;
}
void CsState::clear_overrides() {
@ -501,7 +501,7 @@ bool CsState::reset_var(ostd::ConstCharRange name) {
if (!id) {
return false;
}
if (id->get_flags() & IDF_READONLY) {
if (id->get_flags() & CsIdfReadOnly) {
cs_debug_code(*this, "variable %s is read only", id->get_name());
return false;
}
@ -558,7 +558,7 @@ void CsState::print_var(CsIvar *iv) {
get_out().writefln("%s = %d", iv->get_name(), i);
return;
}
if (iv->get_flags() & IDF_HEX) {
if (iv->get_flags() & CsIdfHex) {
if (iv->get_val_max() == 0xFFFFFF) {
get_out().writefln(
"%s = 0x%.6X (%d, %d, %d)", iv->get_name(),
@ -650,7 +650,7 @@ void CsAlias::get_cval(CsValue &v) const {
}
CsIdentType CsIdent::get_type() const {
if (p_type > ID_ALIAS) {
if (p_type > CsIdAlias) {
return CsIdentType::Special;
}
return CsIdentType(p_type);
@ -670,20 +670,20 @@ int CsIdent::get_index() const {
template<typename SF>
static inline bool cs_override_var(CsState &cs, CsVar *v, int &vflags, SF sf) {
if ((cs.identflags & IDF_OVERRIDDEN) || (vflags & IDF_OVERRIDE)) {
if (vflags & IDF_PERSIST) {
if ((cs.identflags & CsIdfOverridden) || (vflags & CsIdfOverride)) {
if (vflags & CsIdfPersist) {
cs_debug_code(
cs, "cannot override persistent variable '%s'", v->get_name()
);
return false;
}
if (!(vflags & IDF_OVERRIDDEN)) {
if (!(vflags & CsIdfOverridden)) {
sf();
vflags |= IDF_OVERRIDDEN;
vflags |= CsIdfOverridden;
}
} else {
if (vflags & IDF_OVERRIDDEN) {
vflags &= ~IDF_OVERRIDDEN;
if (vflags & CsIdfOverridden) {
vflags &= ~CsIdfOverridden;
}
}
return true;
@ -841,7 +841,7 @@ CsInt cs_clamp_var(CsState &cs, CsIvar *iv, CsInt v) {
}
cs_debug_code(
cs,
(iv->get_flags() & IDF_HEX)
(iv->get_flags() & CsIdfHex)
? (
(iv->get_val_min() <= 255)
? "valid range for '%s' is %d..0x%X"
@ -854,7 +854,7 @@ CsInt cs_clamp_var(CsState &cs, CsIvar *iv, CsInt v) {
}
void CsState::set_var_int_checked(CsIvar *iv, CsInt v) {
if (iv->get_flags() & IDF_READONLY) {
if (iv->get_flags() & CsIdfReadOnly) {
cs_debug_code(*this, "variable '%s' is read only", iv->get_name());
return;
}
@ -874,7 +874,7 @@ void CsState::set_var_int_checked(CsIvar *iv, CsInt v) {
void CsState::set_var_int_checked(CsIvar *iv, CsValueRange args) {
CsInt v = args[0].force_int();
if ((iv->get_flags() & IDF_HEX) && (args.size() > 1)) {
if ((iv->get_flags() & CsIdfHex) && (args.size() > 1)) {
v = (v << 16) | (args[1].force_int() << 8);
if (args.size() > 2) {
v |= args[2].force_int();
@ -899,7 +899,7 @@ CsFloat cs_clamp_fvar(CsState &cs, CsFvar *fv, CsFloat v) {
}
void CsState::set_var_float_checked(CsFvar *fv, CsFloat v) {
if (fv->get_flags() & IDF_READONLY) {
if (fv->get_flags() & CsIdfReadOnly) {
cs_debug_code(*this, "variable '%s' is read only", fv->get_name());
return;
}
@ -918,7 +918,7 @@ void CsState::set_var_float_checked(CsFvar *fv, CsFloat v) {
}
void CsState::set_var_str_checked(CsSvar *sv, ostd::ConstCharRange v) {
if (sv->get_flags() & IDF_READONLY) {
if (sv->get_flags() & CsIdfReadOnly) {
cs_debug_code(*this, "variable '%s' is read only", sv->get_name());
return;
}
@ -1272,13 +1272,13 @@ void cs_init_lib_string(CsState &cs);
void cs_init_lib_list(CsState &cs);
OSTD_EXPORT void CsState::init_libs(int libs) {
if (libs & CS_LIB_MATH) {
if (libs & CsLibMath) {
cs_init_lib_math(*this);
}
if (libs & CS_LIB_STRING) {
if (libs & CsLibString) {
cs_init_lib_string(*this);
}
if (libs & CS_LIB_LIST) {
if (libs & CsLibList) {
cs_init_lib_list(*this);
}
}

26
cubescript.hh
View File

@ -21,13 +21,13 @@
namespace cscript {
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
CsIdfPersist = 1 << 0,
CsIdfOverride = 1 << 1,
CsIdfHex = 1 << 2,
CsIdfReadOnly = 1 << 3,
CsIdfOverridden = 1 << 4,
CsIdfUnknown = 1 << 5,
CsIdfArg = 1 << 6
};
struct CsBytecode;
@ -309,10 +309,10 @@ struct CsIdentLink {
};
enum {
CS_LIB_MATH = 1 << 0,
CS_LIB_STRING = 1 << 1,
CS_LIB_LIST = 1 << 2,
CS_LIB_ALL = 0b111
CsLibMath = 1 << 0,
CsLibString = 1 << 1,
CsLibList = 1 << 2,
CsLibAll = 0b111
};
using CsHookCb = ostd::Function<void()>;
@ -344,12 +344,12 @@ struct OSTD_EXPORT CsState {
virtual void *alloc(void *ptr, ostd::Size olds, ostd::Size news);
void init_libs(int libs = CS_LIB_ALL);
void init_libs(int libs = CsLibAll);
void clear_override(CsIdent &id);
void clear_overrides();
CsIdent *new_ident(ostd::ConstCharRange name, int flags = IDF_UNKNOWN);
CsIdent *new_ident(ostd::ConstCharRange name, int flags = CsIdfUnknown);
CsIdent *force_ident(CsValue &v);
CsIvar *new_ivar(