diff --git a/cs_gen.cc b/cs_gen.cc index 4c2b7da4..2b3f9d33 100644 --- a/cs_gen.cc +++ b/cs_gen.cc @@ -286,17 +286,17 @@ endblock: } /* namespace util */ static inline int cs_ret_code(int type, int def = 0) { - if (type >= VAL_ANY) { - return (type == VAL_CSTR) ? RET_STR : def; + if (type >= CsValAny) { + return (type == CsValCstring) ? CsRetString : def; } - return type << CODE_RET; + return type << CsCodeRet; } static void compilestatements( GenState &gs, int rettype, int brak = '\0', int prevargs = 0 ); static inline char const *compileblock( - GenState &gs, char const *p, int rettype = RET_NULL, int brak = '\0' + GenState &gs, char const *p, int rettype = CsRetNull, int brak = '\0' ); void GenState::gen_int(ostd::ConstCharRange word) { @@ -309,43 +309,43 @@ void GenState::gen_float(ostd::ConstCharRange word) { void GenState::gen_value(int wordtype, ostd::ConstCharRange word) { switch (wordtype) { - case VAL_CANY: + case CsValCany: if (!word.empty()) { gen_str(word, true); } else { gen_null(); } break; - case VAL_CSTR: + case CsValCstring: gen_str(word, true); break; - case VAL_ANY: + case CsValAny: if (!word.empty()) { gen_str(word); } else { gen_null(); } break; - case VAL_STR: + case CsValString: gen_str(word); break; - case VAL_FLOAT: + case CsValFloat: gen_float(word); break; - case VAL_INT: + case CsValInt: gen_int(word); break; - case VAL_COND: + case CsValCond: if (!word.empty()) { compileblock(*this, word.data()); } else { gen_null(); } break; - case VAL_CODE: + case CsValCode: compileblock(*this, word.data()); break; - case VAL_IDENT: + case CsValIdent: gen_ident(word); break; default: @@ -354,28 +354,28 @@ void GenState::gen_value(int wordtype, ostd::ConstCharRange word) { } static inline void compileblock(GenState &gs) { - gs.code.push(CODE_EMPTY); + gs.code.push(CsCodeEmpty); } static inline char const *compileblock( GenState &gs, char const *p, int rettype, int brak ) { ostd::Size start = gs.code.size(); - gs.code.push(CODE_BLOCK); - gs.code.push(CODE_OFFSET | ((start + 2) << 8)); + gs.code.push(CsCodeBlock); + gs.code.push(CsCodeOffset | ((start + 2) << 8)); if (p) { char const *op = gs.source; gs.source = p; - compilestatements(gs, VAL_ANY, brak); + compilestatements(gs, CsValAny, brak); p = gs.source; gs.source = op; } if (gs.code.size() > start + 2) { - gs.code.push(CODE_EXIT | rettype); + gs.code.push(CsCodeExit | rettype); gs.code[start] |= ostd::Uint32(gs.code.size() - (start + 1)) << 8; } else { gs.code.resize(start); - gs.code.push(CODE_EMPTY | rettype); + gs.code.push(CsCodeEmpty | rettype); } return p; } @@ -383,7 +383,7 @@ static inline char const *compileblock( static inline void compileunescapestr(GenState &gs, bool macro = false) { gs.next_char(); char const *end = parsestring(gs.source); - gs.code.push(macro ? CODE_MACRO : (CODE_VAL | RET_STR)); + gs.code.push(macro ? CsCodeMacro : (CsCodeVal | CsRetString)); gs.code.reserve( gs.code.size() + (end - gs.source) / sizeof(ostd::Uint32) + 1 ); @@ -413,12 +413,12 @@ static void compilelookup(GenState &gs, int ltype, int prevargs = MaxResults) { switch (gs.current()) { case '(': case '[': - if (!compilearg(gs, VAL_CSTR, prevargs)) { + if (!compilearg(gs, CsValCstring, prevargs)) { goto invalid; } break; case '$': - compilelookup(gs, VAL_CSTR, prevargs); + compilelookup(gs, CsValCstring, prevargs); break; case '\"': lookup = ostd::Box(cutstring(gs.source)); @@ -432,54 +432,54 @@ lookupid: switch (id->get_type()) { case CsIdentType::Ivar: gs.code.push( - CODE_IVAR | cs_ret_code(ltype, RET_INT) | + CsCodeIvar | cs_ret_code(ltype, CsRetInt) | (id->get_index() << 8) ); switch (ltype) { - case VAL_POP: + case CsValPop: gs.code.pop(); break; - case VAL_CODE: - gs.code.push(CODE_COMPILE); + case CsValCode: + gs.code.push(CsCodeCompile); break; - case VAL_IDENT: - gs.code.push(CODE_IDENTU); + case CsValIdent: + gs.code.push(CsCodeIdentU); break; } return; case CsIdentType::Fvar: gs.code.push( - CODE_FVAR | cs_ret_code(ltype, RET_FLOAT) | + CsCodeFvar | cs_ret_code(ltype, CsRetFloat) | (id->get_index() << 8) ); switch (ltype) { - case VAL_POP: + case CsValPop: gs.code.pop(); break; - case VAL_CODE: - gs.code.push(CODE_COMPILE); + case CsValCode: + gs.code.push(CsCodeCompile); break; - case VAL_IDENT: - gs.code.push(CODE_IDENTU); + case CsValIdent: + gs.code.push(CsCodeIdentU); break; } return; case CsIdentType::Svar: switch (ltype) { - case VAL_POP: + case CsValPop: return; - case VAL_CANY: - case VAL_CSTR: - case VAL_CODE: - case VAL_IDENT: - case VAL_COND: + case CsValCany: + case CsValCstring: + case CsValCode: + case CsValIdent: + case CsValCond: gs.code.push( - CODE_SVARM | (id->get_index() << 8) + CsCodeSvarM | (id->get_index() << 8) ); break; default: gs.code.push( - CODE_SVAR | cs_ret_code(ltype, RET_STR) | + CsCodeSvar | cs_ret_code(ltype, CsRetString) | (id->get_index() << 8) ); break; @@ -487,42 +487,42 @@ lookupid: goto done; case CsIdentType::Alias: switch (ltype) { - case VAL_POP: + case CsValPop: return; - case VAL_CANY: - case VAL_COND: + case CsValCany: + case CsValCond: gs.code.push( (id->get_index() < MaxArguments - ? CODE_LOOKUPMARG - : CODE_LOOKUPM + ? CsCodeLookupMarg + : CsCodeLookupM ) | (id->get_index() << 8) ); break; - case VAL_CSTR: - case VAL_CODE: - case VAL_IDENT: + case CsValCstring: + case CsValCode: + case CsValIdent: gs.code.push( (id->get_index() < MaxArguments - ? CODE_LOOKUPMARG - : CODE_LOOKUPM - ) | RET_STR | (id->get_index() << 8) + ? CsCodeLookupMarg + : CsCodeLookupM + ) | CsRetString | (id->get_index() << 8) ); break; default: gs.code.push( (id->get_index() < MaxArguments - ? CODE_LOOKUPARG - : CODE_LOOKUP - ) | cs_ret_code(ltype, RET_STR) | + ? CsCodeLookupArg + : CsCodeLookup + ) | cs_ret_code(ltype, CsRetString) | (id->get_index() << 8) ); break; } goto done; case CsIdentType::Command: { - int comtype = CODE_COM, numargs = 0; + int comtype = CsCodeCom, numargs = 0; if (prevargs >= MaxResults) { - gs.code.push(CODE_ENTER); + gs.code.push(CsCodeEnter); } auto fmt = static_cast(id)->get_args(); for (char c: fmt) { @@ -548,7 +548,7 @@ lookupid: numargs++; break; case 'F': - gs.code.push(CODE_DUP | RET_FLOAT); + gs.code.push(CsCodeDup | CsRetFloat); numargs++; break; case 'E': @@ -574,10 +574,10 @@ lookupid: numargs++; break; case 'C': - comtype = CODE_COMC; + comtype = CsCodeComC; goto compilecomv; case 'V': - comtype = CODE_COMV; + comtype = CsCodeComV; goto compilecomv; case '1': case '2': @@ -591,8 +591,8 @@ lookupid: ); gs.code.push( (prevargs >= MaxResults - ? CODE_EXIT - : CODE_RESULT_ARG + ? CsCodeExit + : CsCodeResultArg ) | cs_ret_code(ltype) ); goto done; @@ -603,8 +603,8 @@ lookupid: ); gs.code.push( (prevargs >= MaxResults - ? CODE_EXIT - : CODE_RESULT_ARG + ? CsCodeExit + : CsCodeResultArg ) | cs_ret_code(ltype) ); goto done; @@ -618,44 +618,44 @@ lookupid: } } switch (ltype) { - case VAL_CANY: - case VAL_COND: - gs.code.push(CODE_LOOKUPMU); + case CsValCany: + case CsValCond: + gs.code.push(CsCodeLookupMu); break; - case VAL_CSTR: - case VAL_CODE: - case VAL_IDENT: - gs.code.push(CODE_LOOKUPMU | RET_STR); + case CsValCstring: + case CsValCode: + case CsValIdent: + gs.code.push(CsCodeLookupMu | CsRetString); break; default: - gs.code.push(CODE_LOOKUPU | cs_ret_code(ltype)); + gs.code.push(CsCodeLookupU | cs_ret_code(ltype)); break; } done: switch (ltype) { - case VAL_POP: - gs.code.push(CODE_POP); + case CsValPop: + gs.code.push(CsCodePop); break; - case VAL_CODE: - gs.code.push(CODE_COMPILE); + case CsValCode: + gs.code.push(CsCodeCompile); break; - case VAL_COND: - gs.code.push(CODE_COND); + case CsValCond: + gs.code.push(CsCodeCond); break; - case VAL_IDENT: - gs.code.push(CODE_IDENTU); + case CsValIdent: + gs.code.push(CsCodeIdentU); break; } return; invalid: switch (ltype) { - case VAL_POP: + case CsValPop: break; - case VAL_NULL: - case VAL_ANY: - case VAL_CANY: - case VAL_WORD: - case VAL_COND: + case CsValNull: + case CsValAny: + case CsValCany: + case CsValWord: + case CsValCond: gs.gen_null(); break; default: @@ -666,7 +666,7 @@ invalid: static bool compileblockstr(GenState &gs, ostd::ConstCharRange str, bool macro) { int startc = gs.code.size(); - gs.code.push(macro ? CODE_MACRO : CODE_VAL | RET_STR); + gs.code.push(macro ? CsCodeMacro : CsCodeVal | CsRetString); gs.code.reserve(gs.code.size() + str.size() / sizeof(ostd::Uint32) + 1); char *buf = reinterpret_cast(&gs.code[gs.code.size()]); int len = 0; @@ -723,15 +723,15 @@ static bool compileblocksub(GenState &gs, int prevargs) { char const *op; switch (gs.current()) { case '(': - if (!compilearg(gs, VAL_CANY, prevargs)) { + if (!compilearg(gs, CsValCany, prevargs)) { return false; } break; case '[': - if (!compilearg(gs, VAL_CSTR, prevargs)) { + if (!compilearg(gs, CsValCstring, prevargs)) { return false; } - gs.code.push(CODE_LOOKUPMU); + gs.code.push(CsCodeLookupMu); break; case '\"': lookup = ostd::Box(cutstring(gs.source)); @@ -751,19 +751,19 @@ lookupid: if (id) { switch (id->get_type()) { case CsIdentType::Ivar: - gs.code.push(CODE_IVAR | (id->get_index() << 8)); + gs.code.push(CsCodeIvar | (id->get_index() << 8)); goto done; case CsIdentType::Fvar: - gs.code.push(CODE_FVAR | (id->get_index() << 8)); + gs.code.push(CsCodeFvar | (id->get_index() << 8)); goto done; case CsIdentType::Svar: - gs.code.push(CODE_SVARM | (id->get_index() << 8)); + gs.code.push(CsCodeSvarM | (id->get_index() << 8)); goto done; case CsIdentType::Alias: gs.code.push( (id->get_index() < MaxArguments - ? CODE_LOOKUPMARG - : CODE_LOOKUPM + ? CsCodeLookupMarg + : CsCodeLookupM ) | (id->get_index() << 8) ); goto done; @@ -772,7 +772,7 @@ lookupid: } } gs.gen_str(lookup.get(), true); - gs.code.push(CODE_LOOKUPMU); + gs.code.push(CsCodeLookupMu); done: break; } @@ -820,10 +820,10 @@ static void compileblockmain(GenState &gs, int wordtype, int prevargs) { cs_debug_code_line(gs.cs, line, "too many @s"); } if (!concs && prevargs >= MaxResults) { - gs.code.push(CODE_ENTER); + gs.code.push(CsCodeEnter); } if (concs + 2 > MaxArguments) { - gs.code.push(CODE_CONCW | RET_STR | (concs << 8)); + gs.code.push(CsCodeConcW | CsRetString | (concs << 8)); concs = 1; } if (compileblockstr( @@ -847,23 +847,23 @@ done: if (gs.source - 1 > start) { if (!concs) { switch (wordtype) { - case VAL_POP: + case CsValPop: return; - case VAL_CODE: - case VAL_COND: - gs.source = compileblock(gs, start, RET_NULL, ']'); + case CsValCode: + case CsValCond: + gs.source = compileblock(gs, start, CsRetNull, ']'); return; - case VAL_IDENT: + case CsValIdent: gs.gen_ident(ostd::ConstCharRange(start, gs.source - 1)); return; } } switch (wordtype) { - case VAL_CSTR: - case VAL_CODE: - case VAL_IDENT: - case VAL_CANY: - case VAL_COND: + case CsValCstring: + case CsValCode: + case CsValIdent: + case CsValCany: + case CsValCond: compileblockstr( gs, ostd::ConstCharRange(start, gs.source - 1), true ); @@ -880,49 +880,49 @@ done: } if (concs) { if (prevargs >= MaxResults) { - gs.code.push(CODE_CONCM | cs_ret_code(wordtype) | (concs << 8)); - gs.code.push(CODE_EXIT | cs_ret_code(wordtype)); + gs.code.push(CsCodeConcM | cs_ret_code(wordtype) | (concs << 8)); + gs.code.push(CsCodeExit | cs_ret_code(wordtype)); } else { - gs.code.push(CODE_CONCW | cs_ret_code(wordtype) | (concs << 8)); + gs.code.push(CsCodeConcW | cs_ret_code(wordtype) | (concs << 8)); } } switch (wordtype) { - case VAL_POP: + case CsValPop: if (concs || gs.source - 1 > start) { - gs.code.push(CODE_POP); + gs.code.push(CsCodePop); } break; - case VAL_COND: + case CsValCond: if (!concs && gs.source - 1 <= start) { gs.gen_null(); } else { - gs.code.push(CODE_COND); + gs.code.push(CsCodeCond); } break; - case VAL_CODE: + case CsValCode: if (!concs && gs.source - 1 <= start) { compileblock(gs); } else { - gs.code.push(CODE_COMPILE); + gs.code.push(CsCodeCompile); } break; - case VAL_IDENT: + case CsValIdent: if (!concs && gs.source - 1 <= start) { gs.gen_ident(); } else { - gs.code.push(CODE_IDENTU); + gs.code.push(CsCodeIdentU); } break; - case VAL_CSTR: - case VAL_CANY: + case CsValCstring: + case CsValCany: if (!concs && gs.source - 1 <= start) { gs.gen_str(ostd::ConstCharRange(), true); } break; - case VAL_STR: - case VAL_NULL: - case VAL_ANY: - case VAL_WORD: + case CsValString: + case CsValNull: + case CsValAny: + case CsValWord: if (!concs && gs.source - 1 <= start) { gs.gen_str(); } @@ -932,7 +932,7 @@ done: if (gs.source - 1 <= start) { gs.gen_value(wordtype); } else { - gs.code.push(CODE_FORCE | (wordtype << CODE_RET)); + gs.code.push(CsCodeForce | (wordtype << CsCodeRet)); } } break; @@ -950,13 +950,13 @@ static bool compilearg( switch (gs.current()) { case '\"': switch (wordtype) { - case VAL_POP: + case CsValPop: gs.source = parsestring(gs.source + 1); if (gs.current() == '\"') { gs.next_char(); } break; - case VAL_COND: { + case CsValCond: { char *s = cutstring(gs.source); if (s[0]) { compileblock(gs, s); @@ -966,21 +966,21 @@ static bool compilearg( delete[] s; break; } - case VAL_CODE: { + case CsValCode: { char *s = cutstring(gs.source); compileblock(gs, s); delete[] s; break; } - case VAL_WORD: + case CsValWord: *word = ostd::Box(cutstring(gs.source)); break; - case VAL_ANY: - case VAL_STR: + case CsValAny: + case CsValString: compileunescapestr(gs); break; - case VAL_CANY: - case VAL_CSTR: + case CsValCany: + case CsValCstring: compileunescapestr(gs, true); break; default: { @@ -997,35 +997,35 @@ static bool compilearg( case '(': gs.next_char(); if (prevargs >= MaxResults) { - gs.code.push(CODE_ENTER); + gs.code.push(CsCodeEnter); compilestatements( - gs, wordtype > VAL_ANY ? VAL_CANY : VAL_ANY, ')' + gs, wordtype > CsValAny ? CsValCany : CsValAny, ')' ); - gs.code.push(CODE_EXIT | cs_ret_code(wordtype)); + gs.code.push(CsCodeExit | cs_ret_code(wordtype)); } else { ostd::Size start = gs.code.size(); compilestatements( - gs, wordtype > VAL_ANY ? VAL_CANY : VAL_ANY, ')', prevargs + gs, wordtype > CsValAny ? CsValCany : CsValAny, ')', prevargs ); if (gs.code.size() > start) { - gs.code.push(CODE_RESULT_ARG | cs_ret_code(wordtype)); + gs.code.push(CsCodeResultArg | cs_ret_code(wordtype)); } else { gs.gen_value(wordtype); return true; } } switch (wordtype) { - case VAL_POP: - gs.code.push(CODE_POP); + case CsValPop: + gs.code.push(CsCodePop); break; - case VAL_COND: - gs.code.push(CODE_COND); + case CsValCond: + gs.code.push(CsCodeCond); break; - case VAL_CODE: - gs.code.push(CODE_COMPILE); + case CsValCode: + gs.code.push(CsCodeCompile); break; - case VAL_IDENT: - gs.code.push(CODE_IDENTU); + case CsValIdent: + gs.code.push(CsCodeIdentU); break; } return true; @@ -1035,12 +1035,12 @@ static bool compilearg( return true; default: switch (wordtype) { - case VAL_POP: { + case CsValPop: { char const *s = gs.source; gs.source = parseword(gs.source); return gs.source != s; } - case VAL_COND: { + case CsValCond: { char *s = cutword(gs.source); if (!s) { return false; @@ -1049,7 +1049,7 @@ static bool compilearg( delete[] s; return true; } - case VAL_CODE: { + case CsValCode: { char *s = cutword(gs.source); if (!s) { return false; @@ -1058,7 +1058,7 @@ static bool compilearg( delete[] s; return true; } - case VAL_WORD: + case CsValWord: *word = ostd::Box(cutword(gs.source)); return !!*word; default: { @@ -1081,7 +1081,7 @@ static void compilestatements(GenState &gs, int rettype, int brak, int prevargs) for (;;) { skipcomments(gs.source); idname.reset(); - bool more = compilearg(gs, VAL_WORD, prevargs, &idname); + bool more = compilearg(gs, CsValWord, prevargs, &idname); if (!more) { goto endstatement; } @@ -1104,42 +1104,42 @@ static void compilestatements(GenState &gs, int rettype, int brak, int prevargs) if (id) { switch (id->get_type()) { case CsIdentType::Alias: - more = compilearg(gs, VAL_ANY, prevargs); + more = compilearg(gs, CsValAny, prevargs); if (!more) { gs.gen_str(); } gs.code.push( (id->get_index() < MaxArguments - ? CODE_ALIASARG - : CODE_ALIAS + ? CsCodeAliasArg + : CsCodeAlias ) | (id->get_index() << 8) ); goto endstatement; case CsIdentType::Ivar: - more = compilearg(gs, VAL_INT, prevargs); + more = compilearg(gs, CsValInt, prevargs); if (!more) { gs.gen_int(); } gs.code.push( - CODE_IVAR1 | (id->get_index() << 8) + CsCodeIvar1 | (id->get_index() << 8) ); goto endstatement; case CsIdentType::Fvar: - more = compilearg(gs, VAL_FLOAT, prevargs); + more = compilearg(gs, CsValFloat, prevargs); if (!more) { gs.gen_float(); } gs.code.push( - CODE_FVAR1 | (id->get_index() << 8) + CsCodeFvar1 | (id->get_index() << 8) ); goto endstatement; case CsIdentType::Svar: - more = compilearg(gs, VAL_CSTR, prevargs); + more = compilearg(gs, CsValCstring, prevargs); if (!more) { gs.gen_str(); } gs.code.push( - CODE_SVAR1 | (id->get_index() << 8) + CsCodeSvar1 | (id->get_index() << 8) ); goto endstatement; default: @@ -1148,11 +1148,11 @@ static void compilestatements(GenState &gs, int rettype, int brak, int prevargs) } gs.gen_str(idname.get(), true); } - more = compilearg(gs, VAL_ANY); + more = compilearg(gs, CsValAny); if (!more) { gs.gen_str(); } - gs.code.push(CODE_ALIASU); + gs.code.push(CsCodeAliasU); goto endstatement; } } @@ -1160,13 +1160,13 @@ static void compilestatements(GenState &gs, int rettype, int brak, int prevargs) if (!idname) { noid: while (numargs < MaxArguments) { - more = compilearg(gs, VAL_CANY, prevargs + numargs); + more = compilearg(gs, CsValCany, prevargs + numargs); if (!more) { break; } ++numargs; } - gs.code.push(CODE_CALLU | (numargs << 8)); + gs.code.push(CsCodeCallU | (numargs << 8)); } else { CsIdent *id = gs.cs.get_ident(idname.get()); if (!id) { @@ -1175,12 +1175,12 @@ noid: goto noid; } switch (rettype) { - case VAL_ANY: - case VAL_CANY: { + case CsValAny: + case CsValCany: { ostd::ConstCharRange end = idname.get(); CsInt val = cs_parse_int(end, &end); if (!end.empty()) { - gs.gen_str(idname.get(), rettype == VAL_CANY); + gs.gen_str(idname.get(), rettype == CsValCany); } else { gs.gen_int(val); } @@ -1190,12 +1190,12 @@ noid: gs.gen_value(rettype, idname.get()); break; } - gs.code.push(CODE_RESULT); + gs.code.push(CsCodeResult); } else { switch (id->get_type_raw()) { - case ID_ALIAS: + case CsIdAlias: while (numargs < MaxArguments) { - more = compilearg(gs, VAL_ANY, prevargs + numargs); + more = compilearg(gs, CsValAny, prevargs + numargs); if (!more) { break; } @@ -1203,13 +1203,13 @@ noid: } gs.code.push( (id->get_index() < MaxArguments - ? CODE_CALLARG - : CODE_CALL + ? CsCodeCallArg + : CsCodeCall ) | (numargs << 8) | (id->get_index() << 13) ); break; - case ID_COMMAND: { - int comtype = CODE_COM, fakeargs = 0; + case CsIdCommand: { + int comtype = CsCodeCom, fakeargs = 0; bool rep = false; auto fmt = static_cast(id)->get_args(); for (; !fmt.empty(); ++fmt) { @@ -1218,7 +1218,8 @@ noid: case 's': if (more) { more = compilearg( - gs, *fmt == 's' ? VAL_CSTR : VAL_STR, + gs, *fmt == 's' + ? CsValCstring : CsValString, prevargs + numargs ); } @@ -1234,7 +1235,7 @@ noid: int numconc = 1; while ((numargs + numconc) < MaxArguments) { more = compilearg( - gs, VAL_CSTR, + gs, CsValCstring, prevargs + numargs + numconc ); if (!more) { @@ -1244,7 +1245,8 @@ noid: } if (numconc > 1) { gs.code.push( - CODE_CONC | RET_STR | (numconc << 8) + CsCodeConc | CsRetString | + (numconc << 8) ); } } @@ -1253,7 +1255,7 @@ noid: case 'i': if (more) { more = compilearg( - gs, VAL_INT, prevargs + numargs + gs, CsValInt, prevargs + numargs ); } if (!more) { @@ -1268,7 +1270,7 @@ noid: case 'b': if (more) { more = compilearg( - gs, VAL_INT, prevargs + numargs + gs, CsValInt, prevargs + numargs ); } if (!more) { @@ -1283,7 +1285,7 @@ noid: case 'f': if (more) { more = compilearg( - gs, VAL_FLOAT, prevargs + numargs + gs, CsValFloat, prevargs + numargs ); } if (!more) { @@ -1298,14 +1300,14 @@ noid: case 'F': if (more) { more = compilearg( - gs, VAL_FLOAT, prevargs + numargs + gs, CsValFloat, prevargs + numargs ); } if (!more) { if (rep) { break; } - gs.code.push(CODE_DUP | RET_FLOAT); + gs.code.push(CsCodeDup | CsRetFloat); fakeargs++; } numargs++; @@ -1314,7 +1316,8 @@ noid: case 't': if (more) { more = compilearg( - gs, *fmt == 't' ? VAL_CANY : VAL_ANY, + gs, *fmt == 't' + ? CsValCany : CsValAny, prevargs + numargs ); } @@ -1330,7 +1333,7 @@ noid: case 'E': if (more) { more = compilearg( - gs, VAL_COND, prevargs + numargs + gs, CsValCond, prevargs + numargs ); } if (!more) { @@ -1345,7 +1348,7 @@ noid: case 'e': if (more) { more = compilearg( - gs, VAL_CODE, prevargs + numargs + gs, CsValCode, prevargs + numargs ); } if (!more) { @@ -1360,7 +1363,7 @@ noid: case 'r': if (more) { more = compilearg( - gs, VAL_IDENT, prevargs + numargs + gs, CsValIdent, prevargs + numargs ); } if (!more) { @@ -1381,11 +1384,11 @@ noid: numargs++; break; case 'C': - comtype = CODE_COMC; + comtype = CsCodeComC; if (more) { while (numargs < MaxArguments) { more = compilearg( - gs, VAL_CANY, prevargs + numargs + gs, CsValCany, prevargs + numargs ); if (!more) { break; @@ -1395,11 +1398,11 @@ noid: } goto compilecomv; case 'V': - comtype = CODE_COMV; + comtype = CsCodeComV; if (more) { while (numargs < MaxArguments) { more = compilearg( - gs, VAL_CANY, prevargs + numargs + gs, CsValCany, prevargs + numargs ); if (!more) { break; @@ -1418,7 +1421,7 @@ noid: rep = true; } else { while (numargs > MaxArguments) { - gs.code.push(CODE_POP); + gs.code.push(CsCodePop); --numargs; } } @@ -1437,11 +1440,11 @@ compilecomv: ); break; } - case ID_LOCAL: + case CsIdLocal: if (more) { while (numargs < MaxArguments) { more = compilearg( - gs, VAL_IDENT, prevargs + numargs + gs, CsValIdent, prevargs + numargs ); if (!more) { break; @@ -1450,121 +1453,121 @@ compilecomv: } } if (more) { - while ((more = compilearg(gs, VAL_POP))); + while ((more = compilearg(gs, CsValPop))); } - gs.code.push(CODE_LOCAL | (numargs << 8)); + gs.code.push(CsCodeLocal | (numargs << 8)); break; - case ID_DO: + case CsIdDo: if (more) { - more = compilearg(gs, VAL_CODE, prevargs); + more = compilearg(gs, CsValCode, prevargs); } gs.code.push( - (more ? CODE_DO : CODE_NULL) | cs_ret_code(rettype) + (more ? CsCodeDo : CsCodeNull) | cs_ret_code(rettype) ); break; - case ID_DOARGS: + case CsIdDoArgs: if (more) { - more = compilearg(gs, VAL_CODE, prevargs); + more = compilearg(gs, CsValCode, prevargs); } gs.code.push( - (more ? CODE_DOARGS : CODE_NULL) | + (more ? CsCodeDoArgs : CsCodeNull) | cs_ret_code(rettype) ); break; - case ID_IF: + case CsIdIf: if (more) { - more = compilearg(gs, VAL_CANY, prevargs); + more = compilearg(gs, CsValCany, prevargs); } if (!more) { - gs.code.push(CODE_NULL | cs_ret_code(rettype)); + gs.code.push(CsCodeNull | cs_ret_code(rettype)); } else { int start1 = gs.code.size(); - more = compilearg(gs, VAL_CODE, prevargs + 1); + more = compilearg(gs, CsValCode, prevargs + 1); if (!more) { - gs.code.push(CODE_POP); - gs.code.push(CODE_NULL | cs_ret_code(rettype)); + gs.code.push(CsCodePop); + gs.code.push(CsCodeNull | cs_ret_code(rettype)); } else { int start2 = gs.code.size(); - more = compilearg(gs, VAL_CODE, prevargs + 2); + more = compilearg(gs, CsValCode, prevargs + 2); ostd::Uint32 inst1 = gs.code[start1]; - ostd::Uint32 op1 = inst1 & ~CODE_RET_MASK; + ostd::Uint32 op1 = inst1 & ~CsCodeRetMask; ostd::Uint32 len1 = start2 - (start1 + 1); if (!more) { - if (op1 == (CODE_BLOCK | (len1 << 8))) { + if (op1 == (CsCodeBlock | (len1 << 8))) { gs.code[start1] = (len1 << 8) | - CODE_JUMP_FALSE; - gs.code[start1 + 1] = CODE_ENTER_RESULT; + CsCodeJumpFalse; + gs.code[start1 + 1] = CsCodeEnterResult; gs.code[start1 + len1] = ( - gs.code[start1 + len1] & ~CODE_RET_MASK + gs.code[start1 + len1] & ~CsCodeRetMask ) | cs_ret_code(rettype); break; } compileblock(gs); } else { ostd::Uint32 inst2 = gs.code[start2]; - ostd::Uint32 op2 = inst2 & ~CODE_RET_MASK; + ostd::Uint32 op2 = inst2 & ~CsCodeRetMask; ostd::Uint32 len2 = gs.code.size() - (start2 + 1); - if (op2 == (CODE_BLOCK | (len2 << 8))) { - if (op1 == (CODE_BLOCK | (len1 << 8))) { + if (op2 == (CsCodeBlock | (len2 << 8))) { + if (op1 == (CsCodeBlock | (len1 << 8))) { gs.code[start1] = ( (start2 - start1) << 8 - ) | CODE_JUMP_FALSE; - gs.code[start1 + 1] = CODE_ENTER_RESULT; + ) | CsCodeJumpFalse; + gs.code[start1 + 1] = CsCodeEnterResult; gs.code[start1 + len1] = ( - gs.code[start1 + len1] & ~CODE_RET_MASK + gs.code[start1 + len1] & ~CsCodeRetMask ) | cs_ret_code(rettype); - gs.code[start2] = (len2 << 8) | CODE_JUMP; - gs.code[start2 + 1] = CODE_ENTER_RESULT; + gs.code[start2] = (len2 << 8) | CsCodeJump; + gs.code[start2 + 1] = CsCodeEnterResult; gs.code[start2 + len2] = ( - gs.code[start2 + len2] & ~CODE_RET_MASK + gs.code[start2 + len2] & ~CsCodeRetMask ) | cs_ret_code(rettype); break; - } else if (op1 == (CODE_EMPTY | (len1 << 8))) { - gs.code[start1] = CODE_NULL | - (inst2 & CODE_RET_MASK); - gs.code[start2] = (len2 << 8) | CODE_JUMP_TRUE; - gs.code[start2 + 1] = CODE_ENTER_RESULT; + } else if (op1 == (CsCodeEmpty | (len1 << 8))) { + gs.code[start1] = CsCodeNull | + (inst2 & CsCodeRetMask); + gs.code[start2] = (len2 << 8) | CsCodeJumpTrue; + gs.code[start2 + 1] = CsCodeEnterResult; gs.code[start2 + len2] = ( - gs.code[start2 + len2] & ~CODE_RET_MASK + gs.code[start2 + len2] & ~CsCodeRetMask ) | cs_ret_code(rettype); break; } } } gs.code.push( - CODE_COM | cs_ret_code(rettype) | + CsCodeCom | cs_ret_code(rettype) | (id->get_index() << 8) ); } } break; - case ID_RESULT: + case CsIdResult: if (more) { - more = compilearg(gs, VAL_ANY, prevargs); + more = compilearg(gs, CsValAny, prevargs); } gs.code.push( - (more ? CODE_RESULT : CODE_NULL) | + (more ? CsCodeResult : CsCodeNull) | cs_ret_code(rettype) ); break; - case ID_NOT: + case CsIdNot: if (more) { - more = compilearg(gs, VAL_CANY, prevargs); + more = compilearg(gs, CsValCany, prevargs); } gs.code.push( - (more ? CODE_NOT : CODE_TRUE) | cs_ret_code(rettype) + (more ? CsCodeNot : CsCodeTrue) | cs_ret_code(rettype) ); break; - case ID_AND: - case ID_OR: + case CsIdAnd: + case CsIdOr: if (more) { - more = compilearg(gs, VAL_COND, prevargs); + more = compilearg(gs, CsValCond, prevargs); } if (!more) { gs.code.push( - ((id->get_type_raw() == ID_AND) - ? CODE_TRUE - : CODE_FALSE + ((id->get_type_raw() == CsIdAnd) + ? CsCodeTrue + : CsCodeFalse ) | cs_ret_code(rettype) ); } else { @@ -1572,16 +1575,16 @@ compilecomv: int start = gs.code.size(), end = start; while (numargs < MaxArguments) { more = compilearg( - gs, VAL_COND, prevargs + numargs + gs, CsValCond, prevargs + numargs ); if (!more) { break; } numargs++; if (( - gs.code[end] & ~CODE_RET_MASK + gs.code[end] & ~CsCodeRetMask ) != ( - CODE_BLOCK | (ostd::Uint32( + CsCodeBlock | (ostd::Uint32( gs.code.size() - (end + 1) ) << 8) )) { @@ -1592,7 +1595,7 @@ compilecomv: if (more) { while (numargs < MaxArguments) { more = compilearg( - gs, VAL_COND, prevargs + numargs + gs, CsValCond, prevargs + numargs ); if (!more) { break; @@ -1600,13 +1603,13 @@ compilecomv: numargs++; } gs.code.push( - CODE_COMV | cs_ret_code(rettype) | + CsCodeComV | cs_ret_code(rettype) | (numargs << 8) | (id->get_index() << 13) ); } else { - ostd::Uint32 op = (id->get_type_raw() == ID_AND) - ? CODE_JUMP_RESULT_FALSE - : CODE_JUMP_RESULT_TRUE; + ostd::Uint32 op = (id->get_type_raw() == CsIdAnd) + ? CsCodeJumpResultFalse + : CsCodeJumpResultTrue; gs.code.push(op); end = gs.code.size(); while ((start + 1) < end) { @@ -1614,52 +1617,54 @@ compilecomv: gs.code[start] = ( (end - (start + 1)) << 8 ) | op; - gs.code[start + 1] = CODE_ENTER; + gs.code[start + 1] = CsCodeEnter; gs.code[start + len] = ( - gs.code[start + len] & ~CODE_RET_MASK + gs.code[start + len] & ~CsCodeRetMask ) | cs_ret_code(rettype); start += len + 1; } } } break; - case ID_IVAR: - if (!(more = compilearg(gs, VAL_INT, prevargs))) { - gs.code.push(CODE_PRINT | (id->get_index() << 8)); - } else if (!(id->get_flags() & IDF_HEX) || !( - more = compilearg(gs, VAL_INT, prevargs + 1) + case CsIdIvar: + if (!(more = compilearg(gs, CsValInt, prevargs))) { + gs.code.push(CsCodePrint | (id->get_index() << 8)); + } else if (!(id->get_flags() & CsIdfHex) || !( + more = compilearg(gs, CsValInt, prevargs + 1) )) { - gs.code.push(CODE_IVAR1 | (id->get_index() << 8)); + gs.code.push(CsCodeIvar1 | (id->get_index() << 8)); } else if (!( - more = compilearg(gs, VAL_INT, prevargs + 2) + more = compilearg(gs, CsValInt, prevargs + 2) )) { - gs.code.push(CODE_IVAR2 | (id->get_index() << 8)); + gs.code.push(CsCodeIvar2 | (id->get_index() << 8)); } else { - gs.code.push(CODE_IVAR3 | (id->get_index() << 8)); + gs.code.push(CsCodeIvar3 | (id->get_index() << 8)); } break; - case ID_FVAR: - if (!(more = compilearg(gs, VAL_FLOAT, prevargs))) { - gs.code.push(CODE_PRINT | (id->get_index() << 8)); + case CsIdFvar: + if (!(more = compilearg(gs, CsValFloat, prevargs))) { + gs.code.push(CsCodePrint | (id->get_index() << 8)); } else { - gs.code.push(CODE_FVAR1 | (id->get_index() << 8)); + gs.code.push(CsCodeFvar1 | (id->get_index() << 8)); } break; - case ID_SVAR: - if (!(more = compilearg(gs, VAL_CSTR, prevargs))) { - gs.code.push(CODE_PRINT | (id->get_index() << 8)); + case CsIdSvar: + if (!(more = compilearg(gs, CsValCstring, prevargs))) { + gs.code.push(CsCodePrint | (id->get_index() << 8)); } else { do { ++numargs; } while (numargs < MaxArguments && ( more = compilearg( - gs, VAL_CANY, prevargs + numargs + gs, CsValCany, prevargs + numargs ) )); if (numargs > 1) { - gs.code.push(CODE_CONC | RET_STR | (numargs << 8)); + gs.code.push( + CsCodeConc | CsRetString | (numargs << 8) + ); } - gs.code.push(CODE_SVAR1 | (id->get_index() << 8)); + gs.code.push(CsCodeSvar1 | (id->get_index() << 8)); } break; } @@ -1667,14 +1672,16 @@ compilecomv: } endstatement: if (more) { - while (compilearg(gs, VAL_POP)); + while (compilearg(gs, CsValPop)); } gs.source += strcspn(gs.source, ")];/\n\0"); char c = gs.next_char(); switch (c) { case '\0': if (c != brak) { - cs_debug_code_line(gs.cs, line, "missing \"%c\"", char(brak)); + cs_debug_code_line( + gs.cs, line, "missing \"%c\"", char(brak) + ); } gs.source--; return; @@ -1696,9 +1703,9 @@ endstatement: void GenState::gen_main(ostd::ConstCharRange s, int ret_type) { source = s.data(); - code.push(CODE_START); - compilestatements(*this, VAL_ANY); - code.push(CODE_EXIT | ((ret_type < VAL_ANY) ? (ret_type << CODE_RET) : 0)); + code.push(CsCodeStart); + compilestatements(*this, CsValAny); + code.push(CsCodeExit | ((ret_type < CsValAny) ? (ret_type << CsCodeRet) : 0)); } } /* namespace cscript */ \ No newline at end of file diff --git a/cs_val.cc b/cs_val.cc index fac969f0..f6018154 100644 --- a/cs_val.cc +++ b/cs_val.cc @@ -18,7 +18,7 @@ static inline void csv_cleanup(CsValueType tv, T &stor) { break; case CsValueType::Code: { ostd::Uint32 *bcode = csv_get(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(code) & CODE_OP_MASK - ) == CODE_EXIT; + *reinterpret_cast(code) & CsCodeOpMask + ) == CsCodeExit; } bool CsValue::code_is_empty() const { diff --git a/cs_vm.cc b/cs_vm.cc index 8190cecf..879a027e 100644 --- a/cs_vm.cc +++ b/cs_vm.cc @@ -96,15 +96,15 @@ static void bcode_ref(ostd::Uint32 *code) { if (!code) { return; } - if ((*code & CODE_OP_MASK) == CODE_START) { + if ((*code & CsCodeOpMask) == CsCodeStart) { bcode_incr(code); return; } - switch (code[-1]&CODE_OP_MASK) { - case CODE_START: + switch (code[-1]&CsCodeOpMask) { + case CsCodeStart: bcode_incr(&code[-1]); break; - case CODE_OFFSET: + case CsCodeOffset: code -= ostd::Ptrdiff(code[-1] >> 8); bcode_incr(code); break; @@ -115,15 +115,15 @@ static void bcode_unref(ostd::Uint32 *code) { if (!code) { return; } - if ((*code & CODE_OP_MASK) == CODE_START) { + if ((*code & CsCodeOpMask) == CsCodeStart) { bcode_decr(code); return; } - switch (code[-1]&CODE_OP_MASK) { - case CODE_START: + switch (code[-1]&CsCodeOpMask) { + case CsCodeStart: bcode_decr(&code[-1]); break; - case CODE_OFFSET: + case CsCodeOffset: code -= ostd::Ptrdiff(code[-1] >> 8); bcode_decr(code); break; @@ -183,26 +183,26 @@ static inline void forcecond(CsState &cs, CsValue &v) { } } -static ostd::Uint32 emptyblock[VAL_ANY][2] = { - { CODE_START + 0x100, CODE_EXIT | RET_NULL }, - { CODE_START + 0x100, CODE_EXIT | RET_INT }, - { CODE_START + 0x100, CODE_EXIT | RET_FLOAT }, - { CODE_START + 0x100, CODE_EXIT | RET_STR } +static ostd::Uint32 emptyblock[CsValAny][2] = { + { CsCodeStart + 0x100, CsCodeExit | CsRetNull }, + { CsCodeStart + 0x100, CsCodeExit | CsRetInt }, + { CsCodeStart + 0x100, CsCodeExit | CsRetFloat }, + { CsCodeStart + 0x100, CsCodeExit | CsRetString } }; static inline void force_arg(CsValue &v, int type) { switch (type) { - case RET_STR: + case CsRetString: if (v.get_type() != CsValueType::String) { v.force_str(); } break; - case RET_INT: + case CsRetInt: if (v.get_type() != CsValueType::Int) { v.force_int(); } break; - case RET_FLOAT: + case CsRetFloat: if (v.get_type() != CsValueType::Float) { v.force_float(); } @@ -217,33 +217,33 @@ static ostd::Uint32 *skipcode( for (;;) { ostd::Uint32 op = *code++; switch (op & 0xFF) { - case CODE_MACRO: - case CODE_VAL | RET_STR: { + case CsCodeMacro: + case CsCodeVal | CsRetString: { ostd::Uint32 len = op >> 8; code += len / sizeof(ostd::Uint32) + 1; continue; } - case CODE_BLOCK: - case CODE_JUMP: - case CODE_JUMP_TRUE: - case CODE_JUMP_FALSE: - case CODE_JUMP_RESULT_TRUE: - case CODE_JUMP_RESULT_FALSE: { + case CsCodeBlock: + case CsCodeJump: + case CsCodeJumpTrue: + case CsCodeJumpFalse: + case CsCodeJumpResultTrue: + case CsCodeJumpResultFalse: { ostd::Uint32 len = op >> 8; code += len; continue; } - case CODE_ENTER: - case CODE_ENTER_RESULT: + case CsCodeEnter: + case CsCodeEnterResult: ++depth; continue; - case CODE_EXIT | RET_NULL: - case CODE_EXIT | RET_STR: - case CODE_EXIT | RET_INT: - case CODE_EXIT | RET_FLOAT: + case CsCodeExit | CsRetNull: + case CsCodeExit | CsRetString: + case CsCodeExit | CsRetInt: + case CsCodeExit | CsRetFloat: if (depth <= 0) { if (result) { - force_arg(*result, op & CODE_RET_MASK); + force_arg(*result, op & CsCodeRetMask); } return code; } @@ -257,7 +257,7 @@ CsBytecode *cs_copy_code(CsBytecode *c) { ostd::Uint32 *bcode = reinterpret_cast(c); ostd::Uint32 *end = skipcode(bcode); ostd::Uint32 *dst = new ostd::Uint32[end - bcode + 1]; - *dst++ = CODE_START; + *dst++ = CsCodeStart; memcpy(dst, bcode, (end - bcode) * sizeof(ostd::Uint32)); return reinterpret_cast(dst); } @@ -363,7 +363,7 @@ static inline void callcommand( break; } args[i].set_code( - reinterpret_cast(emptyblock[VAL_NULL] + 1) + reinterpret_cast(emptyblock[CsValNull] + 1) ); fakeargs++; } else { @@ -434,7 +434,7 @@ static inline void cs_call_alias( int oldargs = anargs->get_value(); anargs->set_value(callargs); int oldflags = cs.identflags; - cs.identflags |= a->get_flags()&IDF_OVERRIDDEN; + cs.identflags |= a->get_flags()&CsIdfOverridden; CsIdentLink aliaslink = { a, cs.p_stack, (1<set_value(oldargs); nargs = offset - skip; } @@ -469,7 +469,7 @@ static thread_local int rundepth = 0; static inline CsAlias *cs_get_lookup_id(CsState &cs, ostd::Uint32 op) { CsIdent *id = cs.identmap[op >> 8]; - if (id->get_flags() & IDF_UNKNOWN) { + if (id->get_flags() & CsIdfUnknown) { cs_debug_code(cs, "unknown alias lookup: %s", id->get_name()); } return static_cast(id); @@ -497,35 +497,35 @@ static inline int cs_get_lookupu_type( if (id) { switch(id->get_type()) { case CsIdentType::Alias: - if (id->get_flags() & IDF_UNKNOWN) { + if (id->get_flags() & CsIdfUnknown) { break; } if ( (id->get_index() < MaxArguments) && !(cs.p_stack->usedargs & (1 << id->get_index())) ) { - return ID_UNKNOWN; + return CsIdUnknown; } - return ID_ALIAS; + return CsIdAlias; case CsIdentType::Svar: - return ID_SVAR; + return CsIdSvar; case CsIdentType::Ivar: - return ID_IVAR; + return CsIdIvar; case CsIdentType::Fvar: - return ID_FVAR; + return CsIdFvar; case CsIdentType::Command: { arg.set_null(); CsValue buf[MaxArguments]; callcommand(cs, static_cast(id), buf, arg, 0, true); - force_arg(arg, op & CODE_RET_MASK); + force_arg(arg, op & CsCodeRetMask); return -2; /* ignore */ } default: - return ID_UNKNOWN; + return CsIdUnknown; } } cs_debug_code(cs, "unknown alias lookup: %s", arg.get_strr()); - return ID_UNKNOWN; + return CsIdUnknown; } static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { @@ -544,88 +544,88 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { for (;;) { ostd::Uint32 op = *code++; switch (op & 0xFF) { - case CODE_START: - case CODE_OFFSET: + case CsCodeStart: + case CsCodeOffset: continue; - case CODE_NULL | RET_NULL: + case CsCodeNull | CsRetNull: result.set_null(); continue; - case CODE_NULL | RET_STR: + case CsCodeNull | CsRetString: result.set_str(""); continue; - case CODE_NULL | RET_INT: + case CsCodeNull | CsRetInt: result.set_int(0); continue; - case CODE_NULL | RET_FLOAT: + case CsCodeNull | CsRetFloat: result.set_float(0.0f); continue; - case CODE_FALSE | RET_STR: + case CsCodeFalse | CsRetString: result.set_str("0"); continue; - case CODE_FALSE | RET_NULL: - case CODE_FALSE | RET_INT: + case CsCodeFalse | CsRetNull: + case CsCodeFalse | CsRetInt: result.set_int(0); continue; - case CODE_FALSE | RET_FLOAT: + case CsCodeFalse | CsRetFloat: result.set_float(0.0f); continue; - case CODE_TRUE | RET_STR: + case CsCodeTrue | CsRetString: result.set_str("1"); continue; - case CODE_TRUE | RET_NULL: - case CODE_TRUE | RET_INT: + case CsCodeTrue | CsRetNull: + case CsCodeTrue | CsRetInt: result.set_int(1); continue; - case CODE_TRUE | RET_FLOAT: + case CsCodeTrue | CsRetFloat: result.set_float(1.0f); continue; - case CODE_NOT | RET_STR: + case CsCodeNot | CsRetString: --numargs; result.set_str(args[numargs].get_bool() ? "0" : "1"); continue; - case CODE_NOT | RET_NULL: - case CODE_NOT | RET_INT: + case CsCodeNot | CsRetNull: + case CsCodeNot | CsRetInt: --numargs; result.set_int(!args[numargs].get_bool()); continue; - case CODE_NOT | RET_FLOAT: + case CsCodeNot | CsRetFloat: --numargs; result.set_float(CsFloat(!args[numargs].get_bool())); continue; - case CODE_POP: + case CsCodePop: numargs -= 1; continue; - case CODE_ENTER: + case CsCodeEnter: code = runcode(cs, code, args[numargs++]); continue; - case CODE_ENTER_RESULT: + case CsCodeEnterResult: code = runcode(cs, code, result); continue; - case CODE_EXIT | RET_STR: - case CODE_EXIT | RET_INT: - case CODE_EXIT | RET_FLOAT: - force_arg(result, op & CODE_RET_MASK); + case CsCodeExit | CsRetString: + case CsCodeExit | CsRetInt: + case CsCodeExit | CsRetFloat: + force_arg(result, op & CsCodeRetMask); /* fallthrough */ - case CODE_EXIT | RET_NULL: + case CsCodeExit | CsRetNull: goto exit; - case CODE_RESULT_ARG | RET_STR: - case CODE_RESULT_ARG | RET_INT: - case CODE_RESULT_ARG | RET_FLOAT: - force_arg(result, op & CODE_RET_MASK); + case CsCodeResultArg | CsRetString: + case CsCodeResultArg | CsRetInt: + case CsCodeResultArg | CsRetFloat: + force_arg(result, op & CsCodeRetMask); /* fallthrough */ - case CODE_RESULT_ARG | RET_NULL: + case CsCodeResultArg | CsRetNull: args[numargs++] = ostd::move(result); continue; - case CODE_PRINT: + case CsCodePrint: cs.print_var(static_cast(cs.identmap[op >> 8])); continue; - case CODE_LOCAL: { + case CsCodeLocal: { int numlocals = op >> 8, offset = numargs - numlocals; CsIdentStack locals[MaxArguments]; for (int i = 0; i < numlocals; ++i) { @@ -638,46 +638,46 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { goto exit; } - case CODE_DOARGS | RET_NULL: - case CODE_DOARGS | RET_STR: - case CODE_DOARGS | RET_INT: - case CODE_DOARGS | RET_FLOAT: + case CsCodeDoArgs | CsRetNull: + case CsCodeDoArgs | CsRetString: + case CsCodeDoArgs | CsRetInt: + case CsCodeDoArgs | CsRetFloat: if (cs.p_stack != &cs.noalias) { cs_do_args(cs, [&]() { cs.run(args[--numargs].get_code(), result); - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); }); continue; } /* fallthrough */ - case CODE_DO | RET_NULL: - case CODE_DO | RET_STR: - case CODE_DO | RET_INT: - case CODE_DO | RET_FLOAT: + case CsCodeDo | CsRetNull: + case CsCodeDo | CsRetString: + case CsCodeDo | CsRetInt: + case CsCodeDo | CsRetFloat: cs.run(args[--numargs].get_code(), result); - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); continue; - case CODE_JUMP: { + case CsCodeJump: { ostd::Uint32 len = op >> 8; code += len; continue; } - case CODE_JUMP_TRUE: { + case CsCodeJumpTrue: { ostd::Uint32 len = op >> 8; if (args[--numargs].get_bool()) { code += len; } continue; } - case CODE_JUMP_FALSE: { + case CsCodeJumpFalse: { ostd::Uint32 len = op >> 8; if (!args[--numargs].get_bool()) { code += len; } continue; } - case CODE_JUMP_RESULT_TRUE: { + case CsCodeJumpResultTrue: { ostd::Uint32 len = op >> 8; --numargs; if (args[numargs].get_type() == CsValueType::Code) { @@ -690,7 +690,7 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { } continue; } - case CODE_JUMP_RESULT_FALSE: { + case CsCodeJumpResultFalse: { ostd::Uint32 len = op >> 8; --numargs; if (args[numargs].get_type() == CsValueType::Code) { @@ -704,7 +704,7 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { continue; } - case CODE_MACRO: { + case CsCodeMacro: { ostd::Uint32 len = op >> 8; args[numargs++].set_macro(ostd::ConstCharRange( reinterpret_cast(code), len @@ -713,7 +713,7 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { continue; } - case CODE_VAL | RET_STR: { + case CsCodeVal | CsRetString: { ostd::Uint32 len = op >> 8; args[numargs++].set_str(ostd::ConstCharRange( reinterpret_cast(code), len @@ -721,7 +721,7 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { code += len / sizeof(ostd::Uint32) + 1; continue; } - case CODE_VALI | RET_STR: { + case CsCodeValInt | CsRetString: { char s[4] = { char((op >> 8) & 0xFF), char((op >> 16) & 0xFF), @@ -730,83 +730,83 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { args[numargs++].set_str(s); continue; } - case CODE_VAL | RET_NULL: - case CODE_VALI | RET_NULL: + case CsCodeVal | CsRetNull: + case CsCodeValInt | CsRetNull: args[numargs++].set_null(); continue; - case CODE_VAL | RET_INT: + case CsCodeVal | CsRetInt: args[numargs++].set_int(CsInt(*code++)); continue; - case CODE_VALI | RET_INT: + case CsCodeValInt | CsRetInt: args[numargs++].set_int(CsInt(op) >> 8); continue; - case CODE_VAL | RET_FLOAT: + case CsCodeVal | CsRetFloat: args[numargs++].set_float( *reinterpret_cast(code++) ); continue; - case CODE_VALI | RET_FLOAT: + case CsCodeValInt | CsRetFloat: args[numargs++].set_float(CsFloat(CsInt(op) >> 8)); continue; - case CODE_DUP | RET_NULL: + case CsCodeDup | CsRetNull: args[numargs - 1].get_val(args[numargs]); numargs++; continue; - case CODE_DUP | RET_INT: + case CsCodeDup | CsRetInt: args[numargs].set_int(args[numargs - 1].get_int()); numargs++; continue; - case CODE_DUP | RET_FLOAT: + case CsCodeDup | CsRetFloat: args[numargs].set_float(args[numargs - 1].get_float()); numargs++; continue; - case CODE_DUP | RET_STR: + case CsCodeDup | CsRetString: args[numargs].set_str(ostd::move(args[numargs - 1].get_str())); numargs++; continue; - case CODE_FORCE | RET_STR: + case CsCodeForce | CsRetString: args[numargs - 1].force_str(); continue; - case CODE_FORCE | RET_INT: + case CsCodeForce | CsRetInt: args[numargs - 1].force_int(); continue; - case CODE_FORCE | RET_FLOAT: + case CsCodeForce | CsRetFloat: args[numargs - 1].force_float(); continue; - case CODE_RESULT | RET_NULL: + case CsCodeResult | CsRetNull: result = ostd::move(args[--numargs]); continue; - case CODE_RESULT | RET_STR: - case CODE_RESULT | RET_INT: - case CODE_RESULT | RET_FLOAT: + case CsCodeResult | CsRetString: + case CsCodeResult | CsRetInt: + case CsCodeResult | CsRetFloat: result = ostd::move(args[--numargs]); - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); continue; - case CODE_EMPTY | RET_NULL: + case CsCodeEmpty | CsRetNull: args[numargs++].set_code( - reinterpret_cast(emptyblock[VAL_NULL] + 1) + reinterpret_cast(emptyblock[CsValNull] + 1) ); break; - case CODE_EMPTY | RET_STR: + case CsCodeEmpty | CsRetString: args[numargs++].set_code( - reinterpret_cast(emptyblock[VAL_STR] + 1) + reinterpret_cast(emptyblock[CsValString] + 1) ); break; - case CODE_EMPTY | RET_INT: + case CsCodeEmpty | CsRetInt: args[numargs++].set_code( - reinterpret_cast(emptyblock[VAL_INT] + 1) + reinterpret_cast(emptyblock[CsValInt] + 1) ); break; - case CODE_EMPTY | RET_FLOAT: + case CsCodeEmpty | CsRetFloat: args[numargs++].set_code( - reinterpret_cast(emptyblock[VAL_FLOAT] + 1) + reinterpret_cast(emptyblock[CsValFloat] + 1) ); break; - case CODE_BLOCK: { + case CsCodeBlock: { ostd::Uint32 len = op >> 8; args[numargs++].set_code( reinterpret_cast(code + 1) @@ -814,23 +814,23 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { code += len; continue; } - case CODE_COMPILE: { + case CsCodeCompile: { CsValue &arg = args[numargs - 1]; GenState gs(cs); switch (arg.get_type()) { case CsValueType::Int: gs.code.reserve(8); - gs.code.push(CODE_START); + gs.code.push(CsCodeStart); gs.gen_int(arg.get_int()); - gs.code.push(CODE_RESULT); - gs.code.push(CODE_EXIT); + gs.code.push(CsCodeResult); + gs.code.push(CsCodeExit); break; case CsValueType::Float: gs.code.reserve(8); - gs.code.push(CODE_START); + gs.code.push(CsCodeStart); gs.gen_float(arg.get_float()); - gs.code.push(CODE_RESULT); - gs.code.push(CODE_EXIT); + gs.code.push(CsCodeResult); + gs.code.push(CsCodeExit); break; case CsValueType::String: case CsValueType::Macro: @@ -840,10 +840,10 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { break; default: gs.code.reserve(8); - gs.code.push(CODE_START); + gs.code.push(CsCodeStart); gs.gen_null(); - gs.code.push(CODE_RESULT); - gs.code.push(CODE_EXIT); + gs.code.push(CsCodeResult); + gs.code.push(CsCodeExit); break; } arg.set_code( @@ -851,7 +851,7 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { ); continue; } - case CODE_COND: { + case CsCodeCond: { CsValue &arg = args[numargs - 1]; switch (arg.get_type()) { case CsValueType::String: @@ -876,10 +876,10 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { continue; } - case CODE_IDENT: + case CsCodeIdent: args[numargs++].set_ident(cs.identmap[op >> 8]); continue; - case CODE_IDENTARG: { + case CsCodeIdentArg: { CsAlias *a = static_cast(cs.identmap[op >> 8]); if (!(cs.p_stack->usedargs & (1 << a->get_index()))) { CsValue nv; @@ -891,7 +891,7 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { args[numargs++].set_ident(a); continue; } - case CODE_IDENTU: { + case CsCodeIdentU: { CsValue &arg = args[numargs - 1]; CsIdent *id = cs.identmap[DummyIdx]; if ( @@ -916,41 +916,41 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { continue; } - case CODE_LOOKUPU | RET_STR: { + case CsCodeLookupU | CsRetString: { CsIdent *id = nullptr; CsValue &arg = args[numargs - 1]; switch (cs_get_lookupu_type(cs, arg, id, op)) { - case ID_ALIAS: + case CsIdAlias: arg.set_str(ostd::move( static_cast(id)->get_value().get_str() )); continue; - case ID_SVAR: + case CsIdSvar: arg.set_str(static_cast(id)->get_value()); continue; - case ID_IVAR: + case CsIdIvar: arg.set_str(ostd::move( intstr(static_cast(id)->get_value()) )); continue; - case ID_FVAR: + case CsIdFvar: arg.set_str(ostd::move( floatstr(static_cast(id)->get_value()) )); continue; - case ID_UNKNOWN: + case CsIdUnknown: arg.set_str(""); continue; default: continue; } } - case CODE_LOOKUP | RET_STR: + case CsCodeLookup | CsRetString: args[numargs++].set_str( ostd::move(cs_get_lookup_id(cs, op)->get_value().get_str()) ); continue; - case CODE_LOOKUPARG | RET_STR: { + case CsCodeLookupArg | CsRetString: { CsAlias *a = cs_get_lookuparg_id(cs, op); if (!a) { args[numargs++].set_str(""); @@ -961,41 +961,41 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { } continue; } - case CODE_LOOKUPU | RET_INT: { + case CsCodeLookupU | CsRetInt: { CsIdent *id = nullptr; CsValue &arg = args[numargs - 1]; switch (cs_get_lookupu_type(cs, arg, id, op)) { - case ID_ALIAS: + case CsIdAlias: arg.set_int( static_cast(id)->get_value().get_int() ); continue; - case ID_SVAR: + case CsIdSvar: arg.set_int(cs_parse_int( static_cast(id)->get_value() )); continue; - case ID_IVAR: + case CsIdIvar: arg.set_int(static_cast(id)->get_value()); continue; - case ID_FVAR: + case CsIdFvar: arg.set_int( CsInt(static_cast(id)->get_value()) ); continue; - case ID_UNKNOWN: + case CsIdUnknown: arg.set_int(0); continue; default: continue; } } - case CODE_LOOKUP | RET_INT: + case CsCodeLookup | CsRetInt: args[numargs++].set_int( cs_get_lookup_id(cs, op)->get_value().get_int() ); continue; - case CODE_LOOKUPARG | RET_INT: { + case CsCodeLookupArg | CsRetInt: { CsAlias *a = cs_get_lookuparg_id(cs, op); if (!a) { args[numargs++].set_int(0); @@ -1004,43 +1004,43 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { } continue; } - case CODE_LOOKUPU | RET_FLOAT: { + case CsCodeLookupU | CsRetFloat: { CsIdent *id = nullptr; CsValue &arg = args[numargs - 1]; switch (cs_get_lookupu_type(cs, arg, id, op)) { - case ID_ALIAS: + case CsIdAlias: arg.set_float( static_cast(id)->get_value().get_float() ); continue; - case ID_SVAR: + case CsIdSvar: arg.set_float(cs_parse_float( static_cast(id)->get_value() )); continue; - case ID_IVAR: + case CsIdIvar: arg.set_float(CsFloat( static_cast(id)->get_value() )); continue; - case ID_FVAR: + case CsIdFvar: arg.set_float( static_cast(id)->get_value() ); continue; - case ID_UNKNOWN: + case CsIdUnknown: arg.set_float(CsFloat(0)); continue; default: continue; } } - case CODE_LOOKUP | RET_FLOAT: + case CsCodeLookup | CsRetFloat: args[numargs++].set_float( cs_get_lookup_id(cs, op)->get_value().get_float() ); continue; - case CODE_LOOKUPARG | RET_FLOAT: { + case CsCodeLookupArg | CsRetFloat: { CsAlias *a = cs_get_lookuparg_id(cs, op); if (!a) { args[numargs++].set_float(CsFloat(0)); @@ -1049,35 +1049,35 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { } continue; } - case CODE_LOOKUPU | RET_NULL: { + case CsCodeLookupU | CsRetNull: { CsIdent *id = nullptr; CsValue &arg = args[numargs - 1]; switch (cs_get_lookupu_type(cs, arg, id, op)) { - case ID_ALIAS: + case CsIdAlias: static_cast(id)->get_value().get_val(arg); continue; - case ID_SVAR: + case CsIdSvar: arg.set_str(static_cast(id)->get_value()); continue; - case ID_IVAR: + case CsIdIvar: arg.set_int(static_cast(id)->get_value()); continue; - case ID_FVAR: + case CsIdFvar: arg.set_float( static_cast(id)->get_value() ); continue; - case ID_UNKNOWN: + case CsIdUnknown: arg.set_null(); continue; default: continue; } } - case CODE_LOOKUP | RET_NULL: + case CsCodeLookup | CsRetNull: cs_get_lookup_id(cs, op)->get_value().get_val(args[numargs++]); continue; - case CODE_LOOKUPARG | RET_NULL: { + case CsCodeLookupArg | CsRetNull: { CsAlias *a = cs_get_lookuparg_id(cs, op); if (!a) { args[numargs++].set_null(); @@ -1087,37 +1087,37 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { continue; } - case CODE_LOOKUPMU | RET_STR: { + case CsCodeLookupMu | CsRetString: { CsIdent *id = nullptr; CsValue &arg = args[numargs - 1]; switch (cs_get_lookupu_type(cs, arg, id, op)) { - case ID_ALIAS: + case CsIdAlias: static_cast(id)->get_cstr(arg); continue; - case ID_SVAR: + case CsIdSvar: arg.set_cstr(static_cast(id)->get_value()); continue; - case ID_IVAR: + case CsIdIvar: arg.set_str(ostd::move( intstr(static_cast(id)->get_value()) )); continue; - case ID_FVAR: + case CsIdFvar: arg.set_str(ostd::move( floatstr(static_cast(id)->get_value()) )); continue; - case ID_UNKNOWN: + case CsIdUnknown: arg.set_cstr(""); continue; default: continue; } } - case CODE_LOOKUPM | RET_STR: + case CsCodeLookupM | CsRetString: cs_get_lookup_id(cs, op)->get_cstr(args[numargs++]); continue; - case CODE_LOOKUPMARG | RET_STR: { + case CsCodeLookupMarg | CsRetString: { CsAlias *a = cs_get_lookuparg_id(cs, op); if (!a) { args[numargs++].set_cstr(""); @@ -1126,33 +1126,33 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { } continue; } - case CODE_LOOKUPMU | RET_NULL: { + case CsCodeLookupMu | CsRetNull: { CsIdent *id = nullptr; CsValue &arg = args[numargs - 1]; switch (cs_get_lookupu_type(cs, arg, id, op)) { - case ID_ALIAS: + case CsIdAlias: static_cast(id)->get_cval(arg); continue; - case ID_SVAR: + case CsIdSvar: arg.set_cstr(static_cast(id)->get_value()); continue; - case ID_IVAR: + case CsIdIvar: arg.set_int(static_cast(id)->get_value()); continue; - case ID_FVAR: + case CsIdFvar: arg.set_float(static_cast(id)->get_value()); continue; - case ID_UNKNOWN: + case CsIdUnknown: arg.set_null(); continue; default: continue; } } - case CODE_LOOKUPM | RET_NULL: + case CsCodeLookupM | CsRetNull: cs_get_lookup_id(cs, op)->get_cval(args[numargs++]); continue; - case CODE_LOOKUPMARG | RET_NULL: { + case CsCodeLookupMarg | CsRetNull: { CsAlias *a = cs_get_lookuparg_id(cs, op); if (!a) { args[numargs++].set_null(); @@ -1162,57 +1162,57 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { continue; } - case CODE_SVAR | RET_STR: - case CODE_SVAR | RET_NULL: + case CsCodeSvar | CsRetString: + case CsCodeSvar | CsRetNull: args[numargs++].set_str( static_cast(cs.identmap[op >> 8])->get_value() ); continue; - case CODE_SVAR | RET_INT: + case CsCodeSvar | CsRetInt: args[numargs++].set_int(cs_parse_int( static_cast(cs.identmap[op >> 8])->get_value() )); continue; - case CODE_SVAR | RET_FLOAT: + case CsCodeSvar | CsRetFloat: args[numargs++].set_float(cs_parse_float( static_cast(cs.identmap[op >> 8])->get_value() )); continue; - case CODE_SVARM: + case CsCodeSvarM: args[numargs++].set_cstr( static_cast(cs.identmap[op >> 8])->get_value() ); continue; - case CODE_SVAR1: + case CsCodeSvar1: cs.set_var_str_checked( static_cast(cs.identmap[op >> 8]), args[--numargs].get_strr() ); continue; - case CODE_IVAR | RET_INT: - case CODE_IVAR | RET_NULL: + case CsCodeIvar | CsRetInt: + case CsCodeIvar | CsRetNull: args[numargs++].set_int( static_cast(cs.identmap[op >> 8])->get_value() ); continue; - case CODE_IVAR | RET_STR: + case CsCodeIvar | CsRetString: args[numargs++].set_str(ostd::move(intstr( static_cast(cs.identmap[op >> 8])->get_value() ))); continue; - case CODE_IVAR | RET_FLOAT: + case CsCodeIvar | CsRetFloat: args[numargs++].set_float(CsFloat( static_cast(cs.identmap[op >> 8])->get_value() )); continue; - case CODE_IVAR1: + case CsCodeIvar1: cs.set_var_int_checked( static_cast(cs.identmap[op >> 8]), args[--numargs].get_int() ); continue; - case CODE_IVAR2: + case CsCodeIvar2: numargs -= 2; cs.set_var_int_checked( static_cast(cs.identmap[op >> 8]), @@ -1220,7 +1220,7 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { | (args[numargs + 1].get_int() << 8) ); continue; - case CODE_IVAR3: + case CsCodeIvar3: numargs -= 3; cs.set_var_int_checked( static_cast(cs.identmap[op >> 8]), @@ -1229,62 +1229,62 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { | (args[numargs + 2].get_int())); continue; - case CODE_FVAR | RET_FLOAT: - case CODE_FVAR | RET_NULL: + case CsCodeFvar | CsRetFloat: + case CsCodeFvar | CsRetNull: args[numargs++].set_float( static_cast(cs.identmap[op >> 8])->get_value() ); continue; - case CODE_FVAR | RET_STR: + case CsCodeFvar | CsRetString: args[numargs++].set_str(ostd::move(floatstr( static_cast(cs.identmap[op >> 8])->get_value() ))); continue; - case CODE_FVAR | RET_INT: + case CsCodeFvar | CsRetInt: args[numargs++].set_int(int( static_cast(cs.identmap[op >> 8])->get_value() )); continue; - case CODE_FVAR1: + case CsCodeFvar1: cs.set_var_float_checked( static_cast(cs.identmap[op >> 8]), args[--numargs].get_float() ); continue; - case CODE_COM | RET_NULL: - case CODE_COM | RET_STR: - case CODE_COM | RET_FLOAT: - case CODE_COM | RET_INT: { + case CsCodeCom | CsRetNull: + case CsCodeCom | CsRetString: + case CsCodeCom | CsRetFloat: + case CsCodeCom | CsRetInt: { CsCommand *id = static_cast(cs.identmap[op >> 8]); int offset = numargs - id->get_num_args(); result.force_null(); CsCommandInternal::call( id, CsValueRange(args + offset, id->get_num_args()), result ); - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); numargs = offset; continue; } - case CODE_COMV | RET_NULL: - case CODE_COMV | RET_STR: - case CODE_COMV | RET_FLOAT: - case CODE_COMV | RET_INT: { + case CsCodeComV | CsRetNull: + case CsCodeComV | CsRetString: + case CsCodeComV | CsRetFloat: + case CsCodeComV | CsRetInt: { CsCommand *id = static_cast(cs.identmap[op >> 13]); int callargs = (op >> 8) & 0x1F, offset = numargs - callargs; result.force_null(); CsCommandInternal::call( id, ostd::iter(&args[offset], callargs), result ); - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); numargs = offset; continue; } - case CODE_COMC | RET_NULL: - case CODE_COMC | RET_STR: - case CODE_COMC | RET_FLOAT: - case CODE_COMC | RET_INT: { + case CsCodeComC | CsRetNull: + case CsCodeComC | CsRetString: + case CsCodeComC | CsRetFloat: + case CsCodeComC | CsRetInt: { CsCommand *id = static_cast(cs.identmap[op >> 13]); int callargs = (op >> 8) & 0x1F, offset = numargs - callargs; result.force_null(); @@ -1297,36 +1297,36 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { tv.set_str(ostd::move(buf.get())); CsCommandInternal::call(id, CsValueRange(&tv, 1), result); } - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); numargs = offset; continue; } - case CODE_CONC | RET_NULL: - case CODE_CONC | RET_STR: - case CODE_CONC | RET_FLOAT: - case CODE_CONC | RET_INT: - case CODE_CONCW | RET_NULL: - case CODE_CONCW | RET_STR: - case CODE_CONCW | RET_FLOAT: - case CODE_CONCW | RET_INT: { + case CsCodeConc | CsRetNull: + case CsCodeConc | CsRetString: + case CsCodeConc | CsRetFloat: + case CsCodeConc | CsRetInt: + case CsCodeConcW | CsRetNull: + case CsCodeConcW | CsRetString: + case CsCodeConcW | CsRetFloat: + case CsCodeConcW | CsRetInt: { int numconc = op >> 8; auto buf = ostd::appender(); cscript::util::tvals_concat( buf, ostd::iter(&args[numargs - numconc], numconc), - ((op & CODE_OP_MASK) == CODE_CONC) ? " " : "" + ((op & CsCodeOpMask) == CsCodeConc) ? " " : "" ); numargs = numargs - numconc; args[numargs].set_str(ostd::move(buf.get())); - force_arg(args[numargs], op & CODE_RET_MASK); + force_arg(args[numargs], op & CsCodeRetMask); numargs++; continue; } - case CODE_CONCM | RET_NULL: - case CODE_CONCM | RET_STR: - case CODE_CONCM | RET_FLOAT: - case CODE_CONCM | RET_INT: { + case CsCodeConcM | CsRetNull: + case CsCodeConcM | CsRetString: + case CsCodeConcM | CsRetFloat: + case CsCodeConcM | CsRetInt: { int numconc = op >> 8; auto buf = ostd::appender(); cscript::util::tvals_concat( @@ -1334,40 +1334,40 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { ); numargs = numargs - numconc; result.set_str(ostd::move(buf.get())); - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); continue; } - case CODE_ALIAS: + case CsCodeAlias: CsAliasInternal::set_alias( static_cast(cs.identmap[op >> 8]), cs, args[--numargs] ); continue; - case CODE_ALIASARG: + case CsCodeAliasArg: CsAliasInternal::set_arg( static_cast(cs.identmap[op >> 8]), cs, args[--numargs] ); continue; - case CODE_ALIASU: + case CsCodeAliasU: numargs -= 2; cs.set_alias( args[numargs].get_str(), ostd::move(args[numargs + 1]) ); continue; - case CODE_CALL | RET_NULL: - case CODE_CALL | RET_STR: - case CODE_CALL | RET_FLOAT: - case CODE_CALL | RET_INT: { + case CsCodeCall | CsRetNull: + case CsCodeCall | CsRetString: + case CsCodeCall | CsRetFloat: + case CsCodeCall | CsRetInt: { result.force_null(); CsIdent *id = cs.identmap[op >> 13]; int callargs = (op >> 8) & 0x1F, offset = numargs - callargs; - if (id->get_flags() & IDF_UNKNOWN) { + if (id->get_flags() & CsIdfUnknown) { cs_debug_code(cs, "unknown command: %s", id->get_name()); numargs = offset; - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); continue; } cs_call_alias( @@ -1376,16 +1376,16 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { ); continue; } - case CODE_CALLARG | RET_NULL: - case CODE_CALLARG | RET_STR: - case CODE_CALLARG | RET_FLOAT: - case CODE_CALLARG | RET_INT: { + case CsCodeCallArg | CsRetNull: + case CsCodeCallArg | CsRetString: + case CsCodeCallArg | CsRetFloat: + case CsCodeCallArg | CsRetInt: { result.force_null(); CsIdent *id = cs.identmap[op >> 13]; int callargs = (op >> 8) & 0x1F, offset = numargs - callargs; if (!(cs.p_stack->usedargs & (1 << id->get_index()))) { numargs = offset; - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); continue; } cs_call_alias( @@ -1395,10 +1395,10 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { continue; } - case CODE_CALLU | RET_NULL: - case CODE_CALLU | RET_STR: - case CODE_CALLU | RET_FLOAT: - case CODE_CALLU | RET_INT: { + case CsCodeCallU | CsRetNull: + case CsCodeCallU | CsRetString: + case CsCodeCallU | CsRetFloat: + case CsCodeCallU | CsRetInt: { int callargs = op >> 8, offset = numargs - callargs; CsValue &idarg = args[offset - 1]; if ( @@ -1408,7 +1408,7 @@ static ostd::Uint32 *runcode(CsState &cs, ostd::Uint32 *code, CsValue &result) { ) { litval: result = ostd::move(idarg); - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); numargs = offset - 1; continue; } @@ -1421,7 +1421,7 @@ noid: cs_debug_code(cs, "unknown command: %s", idarg.get_strr()); result.force_null(); numargs = offset - 1; - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); continue; } result.force_null(); @@ -1429,19 +1429,19 @@ noid: default: if (!CsCommandInternal::has_cb(id)) { numargs = offset - 1; - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); continue; } /* fallthrough */ - case ID_COMMAND: + case CsIdCommand: callcommand( cs, static_cast(id), &args[offset], result, callargs ); - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); numargs = offset - 1; continue; - case ID_LOCAL: { + case CsIdLocal: { CsIdentStack locals[MaxArguments]; for (ostd::Size j = 0; j < ostd::Size(callargs); ++j) { cs_push_alias(cs.force_ident( @@ -1454,7 +1454,7 @@ noid: } goto exit; } - case ID_IVAR: + case CsIdIvar: if (callargs <= 0) { cs.print_var(static_cast(id)); } else { @@ -1464,9 +1464,9 @@ noid: ); } numargs = offset - 1; - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); continue; - case ID_FVAR: + case CsIdFvar: if (callargs <= 0) { cs.print_var(static_cast(id)); } else { @@ -1476,9 +1476,9 @@ noid: ); } numargs = offset - 1; - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); continue; - case ID_SVAR: + case CsIdSvar: if (callargs <= 0) { cs.print_var(static_cast(id)); } else { @@ -1488,16 +1488,16 @@ noid: ); } numargs = offset - 1; - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); continue; - case ID_ALIAS: { + case CsIdAlias: { CsAlias *a = static_cast(id); if ( a->get_index() < MaxArguments && !(cs.p_stack->usedargs & (1 << a->get_index())) ) { numargs = offset - 1; - force_arg(result, op & CODE_RET_MASK); + force_arg(result, op & CsCodeRetMask); continue; } if (a->get_value().get_type() == CsValueType::Null) { @@ -1526,7 +1526,7 @@ void CsState::run(ostd::ConstCharRange code, CsValue &ret) { GenState gs(*this); gs.code.reserve(64); /* FIXME range */ - gs.gen_main(code.data(), VAL_ANY); + gs.gen_main(code.data(), CsValAny); runcode(*this, gs.code.data() + 1, ret); if (int(gs.code[0]) >= 0x100) { gs.code.disown(); @@ -1598,7 +1598,7 @@ void CsState::run(CsIdent *id, CsValueRange args, CsValue &ret) { break; } cs_call_alias( - *this, a, args.data(), ret, nargs, nargs, 0, 0, RET_NULL + *this, a, args.data(), ret, nargs, nargs, 0, 0, CsRetNull ); break; } diff --git a/cs_vm.hh b/cs_vm.hh index f9ab2730..f57ceda9 100644 --- a/cs_vm.hh +++ b/cs_vm.hh @@ -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(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; } } diff --git a/cubescript.cc b/cubescript.cc index a7a777c3..bb5eb6ea 100644 --- a/cubescript.cc +++ b/cubescript.cc @@ -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(buf), IDF_ARG); + new_ident(static_cast(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 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); } } diff --git a/cubescript.hh b/cubescript.hh index ae9ccfd8..1eff8d40 100644 --- a/cubescript.hh +++ b/cubescript.hh @@ -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; @@ -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(