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

style update

master
Daniel Kolesa 2016-09-07 19:42:12 +02:00
parent aa367f4a0c
commit 2440d2bb9a
6 changed files with 170 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
cs_gen.cc
View File

@ -430,7 +430,7 @@ lookupid:
CsIdent *id = gs.cs.new_ident(lookup.get());
if (id) {
switch (id->get_type()) {
case CsIdentType::ivar:
case CsIdentType::Ivar:
gs.code.push(
CODE_IVAR | cs_ret_code(ltype, RET_INT) |
(id->get_index() << 8)
@ -447,7 +447,7 @@ lookupid:
break;
}
return;
case CsIdentType::fvar:
case CsIdentType::Fvar:
gs.code.push(
CODE_FVAR | cs_ret_code(ltype, RET_FLOAT) |
(id->get_index() << 8)
@ -464,7 +464,7 @@ lookupid:
break;
}
return;
case CsIdentType::svar:
case CsIdentType::Svar:
switch (ltype) {
case VAL_POP:
return;
@ -485,7 +485,7 @@ lookupid:
break;
}
goto done;
case CsIdentType::alias:
case CsIdentType::Alias:
switch (ltype) {
case VAL_POP:
return;
@ -519,7 +519,7 @@ lookupid:
break;
}
goto done;
case CsIdentType::command: {
case CsIdentType::Command: {
int comtype = CODE_COM, numargs = 0;
if (prevargs >= MaxResults) {
gs.code.push(CODE_ENTER);
@ -750,16 +750,16 @@ lookupid:
CsIdent *id = gs.cs.new_ident(lookup.get());
if (id) {
switch (id->get_type()) {
case CsIdentType::ivar:
case CsIdentType::Ivar:
gs.code.push(CODE_IVAR | (id->get_index() << 8));
goto done;
case CsIdentType::fvar:
case CsIdentType::Fvar:
gs.code.push(CODE_FVAR | (id->get_index() << 8));
goto done;
case CsIdentType::svar:
case CsIdentType::Svar:
gs.code.push(CODE_SVARM | (id->get_index() << 8));
goto done;
case CsIdentType::alias:
case CsIdentType::Alias:
gs.code.push(
(id->get_index() < MaxArguments
? CODE_LOOKUPMARG
@ -1103,7 +1103,7 @@ static void compilestatements(GenState &gs, int rettype, int brak, int prevargs)
CsIdent *id = gs.cs.new_ident(idname.get());
if (id) {
switch (id->get_type()) {
case CsIdentType::alias:
case CsIdentType::Alias:
more = compilearg(gs, VAL_ANY, prevargs);
if (!more) {
gs.gen_str();
@ -1115,7 +1115,7 @@ static void compilestatements(GenState &gs, int rettype, int brak, int prevargs)
) | (id->get_index() << 8)
);
goto endstatement;
case CsIdentType::ivar:
case CsIdentType::Ivar:
more = compilearg(gs, VAL_INT, prevargs);
if (!more) {
gs.gen_int();
@ -1124,7 +1124,7 @@ static void compilestatements(GenState &gs, int rettype, int brak, int prevargs)
CODE_IVAR1 | (id->get_index() << 8)
);
goto endstatement;
case CsIdentType::fvar:
case CsIdentType::Fvar:
more = compilearg(gs, VAL_FLOAT, prevargs);
if (!more) {
gs.gen_float();
@ -1133,7 +1133,7 @@ static void compilestatements(GenState &gs, int rettype, int brak, int prevargs)
CODE_FVAR1 | (id->get_index() << 8)
);
goto endstatement;
case CsIdentType::svar:
case CsIdentType::Svar:
more = compilearg(gs, VAL_CSTR, prevargs);
if (!more) {
gs.gen_str();

134
cs_val.cc
View File

@ -13,10 +13,10 @@ static inline T &csv_get(U &stor) {
template<typename T>
static inline void csv_cleanup(CsValueType tv, T &stor) {
switch (tv) {
case CsValueType::string:
case CsValueType::String:
delete[] csv_get<char *>(stor);
break;
case CsValueType::code: {
case CsValueType::Code: {
ostd::Uint32 *bcode = csv_get<ostd::Uint32 *>(stor);
if (bcode[-1] == CODE_START) {
delete[] bcode;
@ -29,7 +29,7 @@ static inline void csv_cleanup(CsValueType tv, T &stor) {
}
CsValue::CsValue():
p_stor(), p_len(0), p_type(CsValueType::null)
p_stor(), p_len(0), p_type(CsValueType::Null)
{}
CsValue::~CsValue() {
@ -46,23 +46,23 @@ CsValue::CsValue(CsValue &&v): CsValue() {
CsValue &CsValue::operator=(CsValue const &v) {
csv_cleanup(p_type, p_stor);
p_type = CsValueType::null;
p_type = CsValueType::Null;
switch (v.get_type()) {
case CsValueType::integer:
case CsValueType::number:
case CsValueType::ident:
case CsValueType::Int:
case CsValueType::Float:
case CsValueType::Ident:
p_len = v.p_len;
p_type = v.p_type;
p_stor = v.p_stor;
break;
case CsValueType::string:
case CsValueType::cstring:
case CsValueType::macro:
case CsValueType::String:
case CsValueType::Cstring:
case CsValueType::Macro:
set_str(
ostd::ConstCharRange(csv_get<char const *>(v.p_stor), v.p_len)
);
break;
case CsValueType::code:
case CsValueType::Code:
set_code(cs_copy_code(v.get_code()));
break;
default:
@ -76,7 +76,7 @@ CsValue &CsValue::operator=(CsValue &&v) {
p_stor = v.p_stor;
p_type = v.p_type;
p_len = v.p_len;
v.p_type = CsValueType::null;
v.p_type = CsValueType::Null;
return *this;
}
@ -86,13 +86,13 @@ CsValueType CsValue::get_type() const {
void CsValue::set_int(CsInt val) {
csv_cleanup(p_type, p_stor);
p_type = CsValueType::integer;
p_type = CsValueType::Int;
csv_get<CsInt>(p_stor) = val;
}
void CsValue::set_float(CsFloat val) {
csv_cleanup(p_type, p_stor);
p_type = CsValueType::number;
p_type = CsValueType::Float;
csv_get<CsFloat>(p_stor) = val;
}
@ -111,44 +111,44 @@ void CsValue::set_str(CsString val) {
void CsValue::set_null() {
csv_cleanup(p_type, p_stor);
p_type = CsValueType::null;
p_type = CsValueType::Null;
}
void CsValue::set_code(CsBytecode *val) {
csv_cleanup(p_type, p_stor);
p_type = CsValueType::code;
p_type = CsValueType::Code;
csv_get<CsBytecode *>(p_stor) = val;
}
void CsValue::set_cstr(ostd::ConstCharRange val) {
csv_cleanup(p_type, p_stor);
p_type = CsValueType::cstring;
p_type = CsValueType::Cstring;
p_len = val.size();
csv_get<char const *>(p_stor) = val.data();
}
void CsValue::set_mstr(ostd::CharRange val) {
csv_cleanup(p_type, p_stor);
p_type = CsValueType::string;
p_type = CsValueType::String;
p_len = val.size();
csv_get<char *>(p_stor) = val.data();
}
void CsValue::set_ident(CsIdent *val) {
csv_cleanup(p_type, p_stor);
p_type = CsValueType::ident;
p_type = CsValueType::Ident;
csv_get<CsIdent *>(p_stor) = val;
}
void CsValue::set_macro(ostd::ConstCharRange val) {
csv_cleanup(p_type, p_stor);
p_type = CsValueType::macro;
p_type = CsValueType::Macro;
p_len = val.size();
csv_get<char const *>(p_stor) = val.data();
}
void CsValue::force_null() {
if (get_type() == CsValueType::null) {
if (get_type() == CsValueType::Null) {
return;
}
set_null();
@ -157,17 +157,17 @@ void CsValue::force_null() {
CsFloat CsValue::force_float() {
CsFloat rf = 0.0f;
switch (get_type()) {
case CsValueType::integer:
case CsValueType::Int:
rf = csv_get<CsInt>(p_stor);
break;
case CsValueType::string:
case CsValueType::macro:
case CsValueType::cstring:
case CsValueType::String:
case CsValueType::Macro:
case CsValueType::Cstring:
rf = cs_parse_float(
ostd::ConstCharRange(csv_get<char const *>(p_stor), p_len)
);
break;
case CsValueType::number:
case CsValueType::Float:
return csv_get<CsFloat>(p_stor);
default:
break;
@ -179,17 +179,17 @@ CsFloat CsValue::force_float() {
CsInt CsValue::force_int() {
CsInt ri = 0;
switch (get_type()) {
case CsValueType::number:
case CsValueType::Float:
ri = csv_get<CsFloat>(p_stor);
break;
case CsValueType::string:
case CsValueType::macro:
case CsValueType::cstring:
case CsValueType::String:
case CsValueType::Macro:
case CsValueType::Cstring:
ri = cs_parse_int(
ostd::ConstCharRange(csv_get<char const *>(p_stor), p_len)
);
break;
case CsValueType::integer:
case CsValueType::Int:
return csv_get<CsInt>(p_stor);
default:
break;
@ -201,17 +201,17 @@ CsInt CsValue::force_int() {
ostd::ConstCharRange CsValue::force_str() {
CsString rs;
switch (get_type()) {
case CsValueType::number:
case CsValueType::Float:
rs = ostd::move(floatstr(csv_get<CsFloat>(p_stor)));
break;
case CsValueType::integer:
case CsValueType::Int:
rs = ostd::move(intstr(csv_get<CsInt>(p_stor)));
break;
case CsValueType::macro:
case CsValueType::cstring:
case CsValueType::Macro:
case CsValueType::Cstring:
rs = ostd::ConstCharRange(csv_get<char const *>(p_stor), p_len);
break;
case CsValueType::string:
case CsValueType::String:
return ostd::ConstCharRange(csv_get<char const *>(p_stor), p_len);
default:
break;
@ -222,13 +222,13 @@ ostd::ConstCharRange CsValue::force_str() {
CsInt CsValue::get_int() const {
switch (get_type()) {
case CsValueType::number:
case CsValueType::Float:
return CsInt(csv_get<CsFloat>(p_stor));
case CsValueType::integer:
case CsValueType::Int:
return csv_get<CsInt>(p_stor);
case CsValueType::string:
case CsValueType::macro:
case CsValueType::cstring:
case CsValueType::String:
case CsValueType::Macro:
case CsValueType::Cstring:
return cs_parse_int(
ostd::ConstCharRange(csv_get<char const *>(p_stor), p_len)
);
@ -240,13 +240,13 @@ CsInt CsValue::get_int() const {
CsFloat CsValue::get_float() const {
switch (get_type()) {
case CsValueType::number:
case CsValueType::Float:
return csv_get<CsFloat>(p_stor);
case CsValueType::integer:
case CsValueType::Int:
return CsFloat(csv_get<CsInt>(p_stor));
case CsValueType::string:
case CsValueType::macro:
case CsValueType::cstring:
case CsValueType::String:
case CsValueType::Macro:
case CsValueType::Cstring:
return cs_parse_float(
ostd::ConstCharRange(csv_get<char const *>(p_stor), p_len)
);
@ -257,14 +257,14 @@ CsFloat CsValue::get_float() const {
}
CsBytecode *CsValue::get_code() const {
if (get_type() != CsValueType::code) {
if (get_type() != CsValueType::Code) {
return nullptr;
}
return csv_get<CsBytecode *>(p_stor);
}
CsIdent *CsValue::get_ident() const {
if (get_type() != CsValueType::ident) {
if (get_type() != CsValueType::Ident) {
return nullptr;
}
return csv_get<CsIdent *>(p_stor);
@ -272,13 +272,13 @@ CsIdent *CsValue::get_ident() const {
CsString CsValue::get_str() const {
switch (get_type()) {
case CsValueType::string:
case CsValueType::macro:
case CsValueType::cstring:
case CsValueType::String:
case CsValueType::Macro:
case CsValueType::Cstring:
return ostd::ConstCharRange(csv_get<char const *>(p_stor), p_len);
case CsValueType::integer:
case CsValueType::Int:
return intstr(csv_get<CsInt>(p_stor));
case CsValueType::number:
case CsValueType::Float:
return floatstr(csv_get<CsFloat>(p_stor));
default:
break;
@ -288,9 +288,9 @@ CsString CsValue::get_str() const {
ostd::ConstCharRange CsValue::get_strr() const {
switch (get_type()) {
case CsValueType::string:
case CsValueType::macro:
case CsValueType::cstring:
case CsValueType::String:
case CsValueType::Macro:
case CsValueType::Cstring:
return ostd::ConstCharRange(csv_get<char const *>(p_stor), p_len);
default:
break;
@ -300,17 +300,17 @@ ostd::ConstCharRange CsValue::get_strr() const {
void CsValue::get_val(CsValue &r) const {
switch (get_type()) {
case CsValueType::string:
case CsValueType::macro:
case CsValueType::cstring:
case CsValueType::String:
case CsValueType::Macro:
case CsValueType::Cstring:
r.set_str(
ostd::ConstCharRange(csv_get<char const *>(p_stor), p_len)
);
break;
case CsValueType::integer:
case CsValueType::Int:
r.set_int(csv_get<CsInt>(p_stor));
break;
case CsValueType::number:
case CsValueType::Float:
r.set_float(csv_get<CsFloat>(p_stor));
break;
default:
@ -329,7 +329,7 @@ OSTD_EXPORT bool cs_code_is_empty(CsBytecode *code) {
}
bool CsValue::code_is_empty() const {
if (get_type() != CsValueType::code) {
if (get_type() != CsValueType::Code) {
return true;
}
return cscript::cs_code_is_empty(csv_get<CsBytecode *>(p_stor));
@ -354,13 +354,13 @@ static inline bool cs_get_bool(ostd::ConstCharRange s) {
bool CsValue::get_bool() const {
switch (get_type()) {
case CsValueType::number:
case CsValueType::Float:
return csv_get<CsFloat>(p_stor) != 0;
case CsValueType::integer:
case CsValueType::Int:
return csv_get<CsInt>(p_stor) != 0;
case CsValueType::string:
case CsValueType::macro:
case CsValueType::cstring:
case CsValueType::String:
case CsValueType::Macro:
case CsValueType::Cstring:
return cs_get_bool(
ostd::ConstCharRange(csv_get<char const *>(p_stor), p_len)
);

74
cs_vm.cc
View File

@ -169,9 +169,9 @@ static inline ostd::Uint32 *forcecode(CsState &cs, CsValue &v) {
static inline void forcecond(CsState &cs, CsValue &v) {
switch (v.get_type()) {
case CsValueType::string:
case CsValueType::macro:
case CsValueType::cstring:
case CsValueType::String:
case CsValueType::Macro:
case CsValueType::Cstring:
if (!v.get_strr().empty()) {
forcecode(cs, v);
} else {
@ -193,17 +193,17 @@ static ostd::Uint32 emptyblock[VAL_ANY][2] = {
static inline void force_arg(CsValue &v, int type) {
switch (type) {
case RET_STR:
if (v.get_type() != CsValueType::string) {
if (v.get_type() != CsValueType::String) {
v.force_str();
}
break;
case RET_INT:
if (v.get_type() != CsValueType::integer) {
if (v.get_type() != CsValueType::Int) {
v.force_int();
}
break;
case RET_FLOAT:
if (v.get_type() != CsValueType::number) {
if (v.get_type() != CsValueType::Float) {
v.force_float();
}
break;
@ -487,16 +487,16 @@ static inline int cs_get_lookupu_type(
CsState &cs, CsValue &arg, CsIdent *&id, ostd::Uint32 op
) {
if (
arg.get_type() != CsValueType::string &&
arg.get_type() != CsValueType::macro &&
arg.get_type() != CsValueType::cstring
arg.get_type() != CsValueType::String &&
arg.get_type() != CsValueType::Macro &&
arg.get_type() != CsValueType::Cstring
) {
return -2; /* default case */
}
id = cs.get_ident(arg.get_strr());
if (id) {
switch(id->get_type()) {
case CsIdentType::alias:
case CsIdentType::Alias:
if (id->get_flags() & IDF_UNKNOWN) {
break;
}
@ -507,13 +507,13 @@ static inline int cs_get_lookupu_type(
return ID_UNKNOWN;
}
return ID_ALIAS;
case CsIdentType::svar:
case CsIdentType::Svar:
return ID_SVAR;
case CsIdentType::ivar:
case CsIdentType::Ivar:
return ID_IVAR;
case CsIdentType::fvar:
case CsIdentType::Fvar:
return ID_FVAR;
case CsIdentType::command: {
case CsIdentType::Command: {
arg.set_null();
CsValue buf[MaxArguments];
callcommand(cs, static_cast<CsCommand *>(id), buf, arg, 0, true);
@ -680,7 +680,7 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) {
case CODE_JUMP_RESULT_TRUE: {
ostd::Uint32 len = op >> 8;
--numargs;
if (args[numargs].get_type() == CsValueType::code) {
if (args[numargs].get_type() == CsValueType::Code) {
cs.run(args[numargs].get_code(), result);
} else {
result = ostd::move(args[numargs]);
@ -693,7 +693,7 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) {
case CODE_JUMP_RESULT_FALSE: {
ostd::Uint32 len = op >> 8;
--numargs;
if (args[numargs].get_type() == CsValueType::code) {
if (args[numargs].get_type() == CsValueType::Code) {
cs.run(args[numargs].get_code(), result);
} else {
result = ostd::move(args[numargs]);
@ -818,23 +818,23 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) {
CsValue &arg = args[numargs - 1];
GenState gs(cs);
switch (arg.get_type()) {
case CsValueType::integer:
case CsValueType::Int:
gs.code.reserve(8);
gs.code.push(CODE_START);
gs.gen_int(arg.get_int());
gs.code.push(CODE_RESULT);
gs.code.push(CODE_EXIT);
break;
case CsValueType::number:
case CsValueType::Float:
gs.code.reserve(8);
gs.code.push(CODE_START);
gs.gen_float(arg.get_float());
gs.code.push(CODE_RESULT);
gs.code.push(CODE_EXIT);
break;
case CsValueType::string:
case CsValueType::macro:
case CsValueType::cstring:
case CsValueType::String:
case CsValueType::Macro:
case CsValueType::Cstring:
gs.code.reserve(64);
gs.gen_main(arg.get_strr());
break;
@ -854,9 +854,9 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) {
case CODE_COND: {
CsValue &arg = args[numargs - 1];
switch (arg.get_type()) {
case CsValueType::string:
case CsValueType::macro:
case CsValueType::cstring: {
case CsValueType::String:
case CsValueType::Macro:
case CsValueType::Cstring: {
ostd::ConstCharRange s = arg.get_strr();
if (!s.empty()) {
GenState gs(cs);
@ -895,9 +895,9 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) {
CsValue &arg = args[numargs - 1];
CsIdent *id = cs.identmap[DummyIdx];
if (
arg.get_type() == CsValueType::string ||
arg.get_type() == CsValueType::macro ||
arg.get_type() == CsValueType::cstring
arg.get_type() == CsValueType::String ||
arg.get_type() == CsValueType::Macro ||
arg.get_type() == CsValueType::Cstring
) {
id = cs.new_ident(arg.get_strr());
}
@ -1402,9 +1402,9 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) {
int callargs = op >> 8, offset = numargs - callargs;
CsValue &idarg = args[offset - 1];
if (
idarg.get_type() != CsValueType::string &&
idarg.get_type() != CsValueType::macro &&
idarg.get_type() != CsValueType::cstring
idarg.get_type() != CsValueType::String &&
idarg.get_type() != CsValueType::Macro &&
idarg.get_type() != CsValueType::Cstring
) {
litval:
result = ostd::move(idarg);
@ -1500,7 +1500,7 @@ noid:
force_arg(result, op & CODE_RET_MASK);
continue;
}
if (a->get_value().get_type() == CsValueType::null) {
if (a->get_value().get_type() == CsValueType::Null) {
goto noid;
}
cs_call_alias(
@ -1546,7 +1546,7 @@ void CsState::run(CsIdent *id, CsValueRange args, CsValue &ret) {
break;
}
/* fallthrough */
case CsIdentType::command:
case CsIdentType::Command:
if (nargs < static_cast<CsCommand *>(id)->get_num_args()) {
CsValue buf[MaxArguments];
memcpy(buf, args.data(), args.size() * sizeof(CsValue));
@ -1562,14 +1562,14 @@ void CsState::run(CsIdent *id, CsValueRange args, CsValue &ret) {
}
nargs = 0;
break;
case CsIdentType::ivar:
case CsIdentType::Ivar:
if (args.empty()) {
print_var(static_cast<CsIvar *>(id));
} else {
set_var_int_checked(static_cast<CsIvar *>(id), args);
}
break;
case CsIdentType::fvar:
case CsIdentType::Fvar:
if (args.empty()) {
print_var(static_cast<CsFvar *>(id));
} else {
@ -1578,7 +1578,7 @@ void CsState::run(CsIdent *id, CsValueRange args, CsValue &ret) {
);
}
break;
case CsIdentType::svar:
case CsIdentType::Svar:
if (args.empty()) {
print_var(static_cast<CsSvar *>(id));
} else {
@ -1587,14 +1587,14 @@ void CsState::run(CsIdent *id, CsValueRange args, CsValue &ret) {
);
}
break;
case CsIdentType::alias: {
case CsIdentType::Alias: {
CsAlias *a = static_cast<CsAlias *>(id);
if (a->get_index() < MaxArguments) {
if (!(p_stack->usedargs & (1 << a->get_index()))) {
break;
}
}
if (a->get_value().get_type() == CsValueType::null) {
if (a->get_value().get_type() == CsValueType::Null) {
break;
}
cs_call_alias(

90
cubescript.cc
View File

@ -41,48 +41,48 @@ 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) ? IDF_READONLY : 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) ? IDF_READONLY : 0)),
p_storage(v), p_minval(m), p_maxval(x), p_overrideval(0)
{}
CsSvar::CsSvar(ostd::ConstCharRange name, CsString v, CsVarCb f, int fl):
CsVar(CsIdentType::svar, name, ostd::move(f), fl),
CsVar(CsIdentType::Svar, name, ostd::move(f), fl),
p_storage(ostd::move(v)), p_overrideval()
{}
CsAlias::CsAlias(ostd::ConstCharRange name, char *a, int fl):
CsIdent(CsIdentType::alias, name, fl),
CsIdent(CsIdentType::Alias, name, fl),
p_acode(nullptr), p_astack(nullptr)
{
p_val.set_mstr(a);
}
CsAlias::CsAlias(ostd::ConstCharRange name, CsInt a, int fl):
CsIdent(CsIdentType::alias, name, fl),
CsIdent(CsIdentType::Alias, name, fl),
p_acode(nullptr), p_astack(nullptr)
{
p_val.set_int(a);
}
CsAlias::CsAlias(ostd::ConstCharRange name, CsFloat a, int fl):
CsIdent(CsIdentType::alias, name, fl),
CsIdent(CsIdentType::Alias, name, fl),
p_acode(nullptr), p_astack(nullptr)
{
p_val.set_float(a);
}
CsAlias::CsAlias(ostd::ConstCharRange name, int fl):
CsIdent(CsIdentType::alias, name, fl),
CsIdent(CsIdentType::Alias, name, fl),
p_acode(nullptr), p_astack(nullptr)
{
p_val.set_null();
}
CsAlias::CsAlias(ostd::ConstCharRange name, CsValue v, int fl):
CsIdent(CsIdentType::alias, name, fl),
CsIdent(CsIdentType::Alias, name, fl),
p_acode(nullptr), p_astack(nullptr), p_val(ostd::move(v))
{}
@ -90,12 +90,12 @@ CsCommand::CsCommand(
ostd::ConstCharRange name, ostd::ConstCharRange args,
int nargs, CsCommandCb f
):
CsIdent(CsIdentType::command, name, 0),
CsIdent(CsIdentType::Command, name, 0),
p_cargs(args), p_cb_cftv(ostd::move(f)), p_numargs(nargs)
{}
bool CsIdent::is_alias() const {
return get_type() == CsIdentType::alias;
return get_type() == CsIdentType::Alias;
}
CsAlias *CsIdent::get_alias() {
@ -113,7 +113,7 @@ CsAlias const *CsIdent::get_alias() const {
}
bool CsIdent::is_command() const {
return get_type() == CsIdentType::command;
return get_type() == CsIdentType::Command;
}
CsCommand *CsIdent::get_command() {
@ -131,12 +131,12 @@ CsCommand const *CsIdent::get_command() const {
}
bool CsIdent::is_special() const {
return get_type() == CsIdentType::special;
return get_type() == CsIdentType::Special;
}
bool CsIdent::is_var() const {
CsIdentType tp = get_type();
return (tp >= CsIdentType::ivar) && (tp <= CsIdentType::svar);
return (tp >= CsIdentType::Ivar) && (tp <= CsIdentType::Svar);
}
CsVar *CsIdent::get_var() {
@ -154,7 +154,7 @@ CsVar const *CsIdent::get_var() const {
}
bool CsIdent::is_ivar() const {
return get_type() == CsIdentType::ivar;
return get_type() == CsIdentType::Ivar;
}
CsIvar *CsIdent::get_ivar() {
@ -172,7 +172,7 @@ CsIvar const *CsIdent::get_ivar() const {
}
bool CsIdent::is_fvar() const {
return get_type() == CsIdentType::fvar;
return get_type() == CsIdentType::Fvar;
}
CsFvar *CsIdent::get_fvar() {
@ -190,7 +190,7 @@ CsFvar const *CsIdent::get_fvar() const {
}
bool CsIdent::is_svar() const {
return get_type() == CsIdentType::svar;
return get_type() == CsIdentType::Svar;
}
CsSvar *CsIdent::get_svar() {
@ -399,25 +399,25 @@ void CsState::clear_override(CsIdent &id) {
return;
}
switch (id.get_type()) {
case CsIdentType::alias: {
case CsIdentType::Alias: {
CsAlias &a = static_cast<CsAlias &>(id);
CsAliasInternal::clean_code(&a);
a.get_value().set_str("");
break;
}
case CsIdentType::ivar: {
case CsIdentType::Ivar: {
CsIvar &iv = static_cast<CsIvar &>(id);
iv.set_value(iv.p_overrideval);
iv.changed();
break;
}
case CsIdentType::fvar: {
case CsIdentType::Fvar: {
CsFvar &fv = static_cast<CsFvar &>(id);
fv.set_value(fv.p_overrideval);
fv.changed();
break;
}
case CsIdentType::svar: {
case CsIdentType::Svar: {
CsSvar &sv = static_cast<CsSvar &>(id);
sv.set_value(sv.p_overrideval);
sv.changed();
@ -460,11 +460,11 @@ CsIdent *CsState::new_ident(ostd::ConstCharRange name, int flags) {
CsIdent *CsState::force_ident(CsValue &v) {
switch (v.get_type()) {
case CsValueType::ident:
case CsValueType::Ident:
return v.get_ident();
case CsValueType::macro:
case CsValueType::cstring:
case CsValueType::string: {
case CsValueType::Macro:
case CsValueType::Cstring:
case CsValueType::String: {
CsIdent *id = new_ident(v.get_strr());
v.set_ident(id);
return id;
@ -520,7 +520,7 @@ void CsState::set_alias(ostd::ConstCharRange name, CsValue v) {
CsIdent *id = get_ident(name);
if (id) {
switch (id->get_type()) {
case CsIdentType::alias: {
case CsIdentType::Alias: {
CsAlias *a = static_cast<CsAlias *>(id);
if (a->get_index() < MaxArguments) {
CsAliasInternal::set_arg(a, *this, v);
@ -529,13 +529,13 @@ void CsState::set_alias(ostd::ConstCharRange name, CsValue v) {
}
return;
}
case CsIdentType::ivar:
case CsIdentType::Ivar:
set_var_int_checked(static_cast<CsIvar *>(id), v.get_int());
break;
case CsIdentType::fvar:
case CsIdentType::Fvar:
set_var_float_checked(static_cast<CsFvar *>(id), v.get_float());
break;
case CsIdentType::svar:
case CsIdentType::Svar:
set_var_str_checked(static_cast<CsSvar *>(id), v.get_str());
break;
default:
@ -587,17 +587,17 @@ void CsState::print_var(CsSvar *sv) {
void CsState::print_var(CsVar *v) {
switch (v->get_type()) {
case CsIdentType::ivar: {
case CsIdentType::Ivar: {
CsIvar *iv = static_cast<CsIvar *>(v);
print_var(iv);
break;
}
case CsIdentType::fvar: {
case CsIdentType::Fvar: {
CsFvar *fv = static_cast<CsFvar *>(v);
print_var(fv);
break;
}
case CsIdentType::svar: {
case CsIdentType::Svar: {
CsSvar *sv = static_cast<CsSvar *>(v);
print_var(sv);
break;
@ -609,17 +609,17 @@ void CsState::print_var(CsVar *v) {
void CsAlias::get_cstr(CsValue &v) const {
switch (p_val.get_type()) {
case CsValueType::macro:
case CsValueType::Macro:
v.set_macro(p_val.get_strr());
break;
case CsValueType::string:
case CsValueType::cstring:
case CsValueType::String:
case CsValueType::Cstring:
v.set_cstr(p_val.get_strr());
break;
case CsValueType::integer:
case CsValueType::Int:
v.set_str(ostd::move(intstr(p_val.get_int())));
break;
case CsValueType::number:
case CsValueType::Float:
v.set_str(ostd::move(floatstr(p_val.get_float())));
break;
default:
@ -630,17 +630,17 @@ void CsAlias::get_cstr(CsValue &v) const {
void CsAlias::get_cval(CsValue &v) const {
switch (p_val.get_type()) {
case CsValueType::macro:
case CsValueType::Macro:
v.set_macro(p_val.get_strr());
break;
case CsValueType::string:
case CsValueType::cstring:
case CsValueType::String:
case CsValueType::Cstring:
v.set_cstr(p_val.get_strr());
break;
case CsValueType::integer:
case CsValueType::Int:
v.set_int(p_val.get_int());
break;
case CsValueType::number:
case CsValueType::Float:
v.set_float(p_val.get_float());
break;
default:
@ -651,7 +651,7 @@ void CsAlias::get_cval(CsValue &v) const {
CsIdentType CsIdent::get_type() const {
if (p_type > ID_ALIAS) {
return CsIdentType::special;
return CsIdentType::Special;
}
return CsIdentType(p_type);
}
@ -1055,7 +1055,7 @@ void cs_init_lib_base(CsState &cs) {
CsInt val = args[0].get_int();
for (ostd::Size i = 1; (i + 1) < args.size(); i += 2) {
if (
(args[i].get_type() == CsValueType::null) ||
(args[i].get_type() == CsValueType::Null) ||
(args[i].get_int() == val)
) {
cs.run(args[i + 1].get_code(), res);
@ -1068,7 +1068,7 @@ void cs_init_lib_base(CsState &cs) {
CsFloat val = args[0].get_float();
for (ostd::Size i = 1; (i + 1) < args.size(); i += 2) {
if (
(args[i].get_type() == CsValueType::null) ||
(args[i].get_type() == CsValueType::Null) ||
(args[i].get_float() == val)
) {
cs.run(args[i + 1].get_code(), res);
@ -1081,7 +1081,7 @@ void cs_init_lib_base(CsState &cs) {
CsString val = args[0].get_str();
for (ostd::Size i = 1; (i + 1) < args.size(); i += 2) {
if (
(args[i].get_type() == CsValueType::null) ||
(args[i].get_type() == CsValueType::Null) ||
(args[i].get_str() == val)
) {
cs.run(args[i + 1].get_code(), res);

14
cubescript.hh
View File

@ -61,7 +61,7 @@ OSTD_EXPORT bool cs_code_is_empty(CsBytecode *code);
struct CsIdent;
enum class CsValueType {
null = 0, integer, number, string, cstring, code, macro, ident
Null = 0, Int, Float, String, Cstring, Code, Macro, Ident
};
struct OSTD_EXPORT CsValue {
@ -119,7 +119,7 @@ struct CsIdentStack {
struct CsState;
enum class CsIdentType {
ivar = 0, fvar, svar, command, alias, special
Ivar = 0, Fvar, Svar, Command, Alias, Special
};
struct CsVar;
@ -603,7 +603,7 @@ namespace util {
for (ostd::Size i = 0; i < vals.size(); ++i) {
auto s = ostd::appender<CsString>();
switch (vals[i].get_type()) {
case CsValueType::integer: {
case CsValueType::Int: {
auto r = format_int(
ostd::forward<R>(writer), vals[i].get_int()
);
@ -612,7 +612,7 @@ namespace util {
}
break;
}
case CsValueType::number: {
case CsValueType::Float: {
auto r = format_float(
ostd::forward<R>(writer), vals[i].get_float()
);
@ -621,9 +621,9 @@ namespace util {
}
break;
}
case CsValueType::string:
case CsValueType::cstring:
case CsValueType::macro: {
case CsValueType::String:
case CsValueType::Cstring:
case CsValueType::Macro: {
auto sv = vals[i].get_strr();
ret += writer.put_n(sv.data(), sv.size());
break;

2
tools/repl.cc
View File

@ -189,7 +189,7 @@ static void do_call(CsState &cs, ostd::ConstCharRange line) {
return;
}
signal(SIGINT, SIG_DFL);
if (ret.get_type() != CsValueType::null) {
if (ret.get_type() != CsValueType::Null) {
ostd::writeln(ret.get_str());
}
}