static void
findPerl6Tags (void)
{
struct p6Ctx ctx;
#define RESET_TOKENS() do { ctx.n_tokens = 0; } while (0)
#define PUSH_TOKEN(_t_) do { \
if (ctx.n_tokens < ARRAY_SIZE(ctx.tokens)) { \
ctx.tokens[ ctx.n_tokens ] = _t_; \
++ctx.n_tokens; \
} else { \
Assert(!"Token stack overflown: this is quite odd"); \
RESET_TOKENS(); \
} \
} while (0)
initP6Ctx(&ctx);
const char *s;
int len;
while ((len = getNonSpaceStr(&ctx, &s)) > 0) {
enum token token = matchToken(s, len);
if ((int) token >= 0) {
PUSH_TOKEN(token);
} else if (ctx.n_tokens > 0) {
possiblyMakeTag(&ctx, s, len);
RESET_TOKENS();
}
}
deinitP6Ctx(&ctx);
}
void clCommandLineParser::DoParse()
{
wxString tmpstr = m_commandline;
wxString curtoken;
int state = STATE_NORMAL;
for(size_t i = 0; i < tmpstr.length(); ++i) {
wxChar ch = tmpstr.at(i);
switch(state) {
case STATE_NORMAL: {
switch(ch) {
case '\n':
case '\r':
HANDLE_NEWLINE();
break;
case ' ':
case '\t':
// whitespace, start new token
PUSH_TOKEN();
break;
case '"':
PUSH_TOKEN();
state = STATE_IN_DOUBLE_QUOTES;
break;
case '\'':
PUSH_TOKEN();
state = STATE_IN_SINGLE_QUOTES;
break;
default: {
// Normal
curtoken << ch;
break;
}
}
break;
}
case STATE_IN_DOUBLE_QUOTES:
if(ch == '"') {
PUSH_TOKEN();
state = STATE_NORMAL;
} else {
curtoken << ch;
}
break;
case STATE_IN_SINGLE_QUOTES:
if(ch == '\'') {
PUSH_TOKEN();
state = STATE_NORMAL;
} else {
curtoken << ch;
}
break;
}
}
PUSH_TOKEN();
}
//
// BinaryTokenPPACS::make_tokens
//
void BinaryTokenPPACS::make_tokens
(ObjectVector const &objects, std::vector<BinaryTokenPPACS> *instructions)
{
static ObjectExpression::Pointer const fracbits =
ObjectExpression::CreateValueINT(16, SourcePosition::builtin());
static std::vector<std::string> const nolabels;
std::vector<ObjectExpression::Pointer> args;
ObjectVector::const_iterator object;
for (object = objects.begin(); object != objects.end(); ++object)
{
SourcePosition const &pos = object->pos;
std::vector<std::string> const *labels = &object->labels;
switch (object->code)
{
BINTOKACS_TOKENS_MAP_ALL();
BINTOKACS_TOKENS_TRAN_ALL();
//
// Operators
//
CASE_REMAP(ADD_AUTO_I, ADD_AUTO);
CASE_REMAP(ADD_AUTO_U, ADD_AUTO);
CASE_REMAP(ADD_AUTO_X, ADD_AUTO);
CASE_REMAP(ADD_PTR_I, ADD_PTR);
CASE_REMAP(ADD_PTR_U, ADD_PTR);
CASE_REMAP(ADD_PTR_X, ADD_PTR);
CASE_REMAP(ADD_STATIC_I, ADD_STATIC);
CASE_REMAP(ADD_STATIC_U, ADD_STATIC);
CASE_REMAP(ADD_STATIC_X, ADD_STATIC);
CASE_REMAP(AND_AUTO_I, AND_AUTO);
CASE_REMAP(AND_AUTO_U, AND_AUTO);
CASE_REMAP(AND_AUTO_X, AND_AUTO);
CASE_REMAP(AND_PTR_I, AND_PTR);
CASE_REMAP(AND_PTR_U, AND_PTR);
CASE_REMAP(AND_PTR_X, AND_PTR);
CASE_REMAP(AND_STATIC_I, AND_STATIC);
CASE_REMAP(AND_STATIC_U, AND_STATIC);
CASE_REMAP(AND_STATIC_X, AND_STATIC);
CASE_REMAP(DEC_AUTO_I, DEC_AUTO);
CASE_REMAP(DEC_AUTO_U, DEC_AUTO);
CASE_REMAP(DEC_PTR_I, DEC_PTR);
CASE_REMAP(DEC_PTR_U, DEC_PTR);
CASE_REMAP(DEC_STATIC_I, DEC_STATIC);
CASE_REMAP(DEC_STATIC_U, DEC_STATIC);
CASE_REMAP(DIV_STK_X, DIV_STK_X);
CASE_REMAP(DIV_AUTO_I, DIV_AUTO);
CASE_REMAP(DIV_PTR_I, DIV_PTR);
CASE_REMAP(DIV_STATIC_I, DIV_STATIC);
CASE_REMAP(INC_AUTO_I, INC_AUTO);
CASE_REMAP(INC_AUTO_U, INC_AUTO);
CASE_REMAP(INC_PTR_I, INC_PTR);
CASE_REMAP(INC_PTR_U, INC_PTR);
CASE_REMAP(INC_STATIC_I, INC_STATIC);
CASE_REMAP(INC_STATIC_U, INC_STATIC);
CASE_REMAP(IOR_AUTO_I, IOR_AUTO);
CASE_REMAP(IOR_AUTO_U, IOR_AUTO);
CASE_REMAP(IOR_AUTO_X, IOR_AUTO);
CASE_REMAP(IOR_PTR_I, IOR_PTR);
CASE_REMAP(IOR_PTR_U, IOR_PTR);
CASE_REMAP(IOR_PTR_X, IOR_PTR);
CASE_REMAP(IOR_STATIC_I, IOR_STATIC);
CASE_REMAP(IOR_STATIC_U, IOR_STATIC);
CASE_REMAP(IOR_STATIC_X, IOR_STATIC);
CASE_REMAP(LSH_AUTO_I, LSH_AUTO);
CASE_REMAP(LSH_AUTO_U, LSH_AUTO);
CASE_REMAP(LSH_AUTO_X, LSH_AUTO);
CASE_REMAP(LSH_PTR_I, LSH_PTR);
CASE_REMAP(LSH_PTR_U, LSH_PTR);
CASE_REMAP(LSH_PTR_X, LSH_PTR);
CASE_REMAP(LSH_STATIC_I, LSH_STATIC);
CASE_REMAP(LSH_STATIC_U, LSH_STATIC);
CASE_REMAP(LSH_STATIC_X, LSH_STATIC);
CASE_REMAP(MOD_AUTO_I, MOD_AUTO);
CASE_REMAP(MOD_AUTO_X, MOD_AUTO);
CASE_REMAP(MOD_PTR_I, MOD_PTR);
CASE_REMAP(MOD_PTR_X, MOD_PTR);
CASE_REMAP(MOD_STATIC_I, MOD_STATIC);
CASE_REMAP(MOD_STATIC_X, MOD_STATIC);
CASE_REMAP(MUL_STK_X, MUL_STK_X);
CASE_REMAP(MUL_AUTO_I, MUL_AUTO);
CASE_REMAP(MUL_AUTO_U, MUL_AUTO);
CASE_REMAP(MUL_PTR_I, MUL_PTR);
CASE_REMAP(MUL_PTR_U, MUL_PTR);
CASE_REMAP(MUL_STATIC_I, MUL_STATIC);
CASE_REMAP(MUL_STATIC_U, MUL_STATIC);
CASE_REMAP(RSH_AUTO_I, RSH_AUTO);
CASE_REMAP(RSH_AUTO_X, RSH_AUTO);
CASE_REMAP(RSH_PTR_I, RSH_PTR);
CASE_REMAP(RSH_PTR_X, RSH_PTR);
CASE_REMAP(RSH_STATIC_I, RSH_STATIC);
CASE_REMAP(RSH_STATIC_X, RSH_STATIC);
CASE_REMAP(SUB_AUTO_I, SUB_AUTO);
CASE_REMAP(SUB_AUTO_U, SUB_AUTO);
CASE_REMAP(SUB_AUTO_X, SUB_AUTO);
CASE_REMAP(SUB_PTR_I, SUB_PTR);
CASE_REMAP(SUB_PTR_U, SUB_PTR);
CASE_REMAP(SUB_PTR_X, SUB_PTR);
CASE_REMAP(SUB_STATIC_I, SUB_STATIC);
CASE_REMAP(SUB_STATIC_U, SUB_STATIC);
CASE_REMAP(SUB_STATIC_X, SUB_STATIC);
CASE_REMAP(XOR_AUTO_I, XOR_AUTO);
CASE_REMAP(XOR_AUTO_U, XOR_AUTO);
CASE_REMAP(XOR_AUTO_X, XOR_AUTO);
CASE_REMAP(XOR_PTR_I, XOR_PTR);
CASE_REMAP(XOR_PTR_U, XOR_PTR);
CASE_REMAP(XOR_PTR_X, XOR_PTR);
CASE_REMAP(XOR_STATIC_I, XOR_STATIC);
CASE_REMAP(XOR_STATIC_U, XOR_STATIC);
CASE_REMAP(XOR_STATIC_X, XOR_STATIC);
//
// Jumps
//
CASE_REMAP(JMP, JMP);
//
// Variable Address
//
CASE_REMAP(GET_AUTPTR_IMM, GET_AUTPTR_IMM);
CASE_REMAP(ADD_AUTPTR, ADD_AUTPTR);
case OCODE_ADD_AUTPTR_IMM:
PUSH_TOKEN_ARGS1(BCODE_GET_IMM, 1);
PUSH_TOKEN(BCODE_ADD_AUTPTR);
break;
CASE_REMAP(SUB_AUTPTR, SUB_AUTPTR);
case OCODE_SUB_AUTPTR_IMM:
PUSH_TOKEN_ARGS1(BCODE_GET_IMM, 1);
PUSH_TOKEN(BCODE_SUB_AUTPTR);
break;
//
// Variable Get
//
CASE_REMAP(GET_STATIC, GET_STATIC);
CASE_REMAP(GET_AUTO, GET_AUTO);
CASE_REMAP(GET_PTR, GET_PTR);
CASE_REMAP(GET_TEMP, GET_AUTO);
//
// Variable Set
//
CASE_REMAP(SET_STATIC, SET_STATIC);
CASE_REMAP(SET_AUTO, SET_AUTO);
CASE_REMAP(SET_PTR, SET_PTR);
CASE_REMAP(SET_TEMP, SET_AUTO);
//
// ACS Extensions
//
CASE_MAP_ACSE(MID_GET);
CASE_MAP_ACSE(MID_SET);
//
// ACS Printing
//
CASE_MAP_ACSP(END_ERROR);
CASE_MAP_ACSP(END_LOG);
CASE_REMAP_ACSP(NUM_DEC_X, NUM_DEC_X);
case OCODE_NONE:
default:
Error_P("unknown OCODE: %s", make_string(object->code));
}
}
}
static char*
parse_comment(PSTATE* p_state, char *beg, char *end, U32 utf8, SV* self)
{
char *s = beg;
if (p_state->strict_comment) {
dTOKENS(4);
char *start_com = s; /* also used to signal inside/outside */
while (1) {
/* try to locate "--" */
FIND_DASH_DASH:
/* printf("find_dash_dash: [%s]\n", s); */
while (s < end && *s != '-' && *s != '>')
s++;
if (s == end) {
FREE_TOKENS;
return beg;
}
if (*s == '>') {
s++;
if (start_com)
goto FIND_DASH_DASH;
/* we are done recognizing all comments, make callbacks */
report_event(p_state, E_COMMENT,
beg - 4, s, utf8,
tokens, num_tokens,
self);
FREE_TOKENS;
return s;
}
s++;
if (s == end) {
FREE_TOKENS;
return beg;
}
if (*s == '-') {
/* two dashes in a row seen */
s++;
/* do something */
if (start_com) {
PUSH_TOKEN(start_com, s-2);
start_com = 0;
}
else {
start_com = s;
}
}
}
}
else if (p_state->no_dash_dash_comment_end) {
token_pos_t token;
token.beg = beg;
/* a lone '>' signals end-of-comment */
while (s < end && *s != '>')
s++;
token.end = s;
if (s < end) {
s++;
report_event(p_state, E_COMMENT, beg-4, s, utf8, &token, 1, self);
return s;
}
else {
return beg;
}
}
else { /* non-strict comment */
token_pos_t token;
token.beg = beg;
/* try to locate /--\s*>/ which signals end-of-comment */
LOCATE_END:
while (s < end && *s != '-')
s++;
token.end = s;
if (s < end) {
s++;
if (*s == '-') {
s++;
while (isHSPACE(*s))
s++;
if (*s == '>') {
s++;
/* yup */
report_event(p_state, E_COMMENT, beg-4, s, utf8, &token, 1, self);
return s;
}
}
if (s < end) {
s = token.end + 1;
goto LOCATE_END;
}
}
if (s == end)
return beg;
}
return 0;
}
static char*
parse_start(PSTATE* p_state, char *beg, char *end, U32 utf8, SV* self)
{
char *s = beg;
int empty_tag = 0; /* XML feature */
dTOKENS(16);
hctype_t tag_name_first, tag_name_char;
hctype_t attr_name_first, attr_name_char;
if (p_state->strict_names || p_state->xml_mode) {
tag_name_first = attr_name_first = HCTYPE_NAME_FIRST;
tag_name_char = attr_name_char = HCTYPE_NAME_CHAR;
}
else {
tag_name_first = tag_name_char = HCTYPE_NOT_SPACE_GT;
attr_name_first = HCTYPE_NOT_SPACE_GT;
attr_name_char = HCTYPE_NOT_SPACE_EQ_GT;
}
s += 2;
while (s < end && isHCTYPE(*s, tag_name_char))
s++;
PUSH_TOKEN(beg+1, s); /* tagname */
while (isHSPACE(*s))
s++;
if (s == end)
goto PREMATURE;
while (isHCTYPE(*s, attr_name_first)) {
/* attribute */
char *attr_name_beg = s;
char *attr_name_end;
s++;
while (s < end && isHCTYPE(*s, attr_name_char))
s++;
if (s == end)
goto PREMATURE;
attr_name_end = s;
PUSH_TOKEN(attr_name_beg, attr_name_end); /* attr name */
while (isHSPACE(*s))
s++;
if (s == end)
goto PREMATURE;
if (*s == '=') {
/* with a value */
s++;
while (isHSPACE(*s))
s++;
if (s == end)
goto PREMATURE;
if (*s == '>') {
/* parse it similar to ="" */
PUSH_TOKEN(s, s);
break;
}
if (*s == '"' || *s == '\'') {
char *str_beg = s;
s++;
while (s < end && *s != *str_beg)
s++;
if (s == end)
goto PREMATURE;
s++;
PUSH_TOKEN(str_beg, s);
}
else {
char *word_start = s;
while (s < end && isHNOT_SPACE_GT(*s)) {
if (p_state->xml_mode && *s == '/')
break;
s++;
}
if (s == end)
goto PREMATURE;
PUSH_TOKEN(word_start, s);
}
while (isHSPACE(*s))
s++;
if (s == end)
goto PREMATURE;
}
else {
PUSH_TOKEN(0, 0); /* boolean attr value */
}
}
if (p_state->xml_mode && *s == '/') {
s++;
if (s == end)
goto PREMATURE;
empty_tag = 1;
}
if (*s == '>') {
s++;
/* done */
report_event(p_state, E_START, beg, s, utf8, tokens, num_tokens, self);
if (empty_tag)
report_event(p_state, E_END, s, s, utf8, tokens, 1, self);
if (!p_state->xml_mode) {
/* find out if this start tag should put us into literal_mode
*/
int i;
int tag_len = tokens[0].end - tokens[0].beg;
for (i = 0; literal_mode_elem[i].len; i++) {
if (tag_len == literal_mode_elem[i].len) {
/* try to match it */
char *s = beg + 1;
char *t = literal_mode_elem[i].str;
int len = tag_len;
while (len) {
if (toLOWER(*s) != *t)
break;
s++;
t++;
if (!--len) {
/* found it */
p_state->literal_mode = literal_mode_elem[i].str;
p_state->is_cdata = literal_mode_elem[i].is_cdata;
/* printf("Found %s\n", p_state->literal_mode); */
goto END_OF_LITERAL_SEARCH;
}
}
}
}
END_OF_LITERAL_SEARCH:
;
}
FREE_TOKENS;
return s;
}
FREE_TOKENS;
return 0;
PREMATURE:
FREE_TOKENS;
return beg;
}
static char*
parse_decl(PSTATE* p_state, char *beg, char *end, U32 utf8, SV* self)
{
char *s = beg + 2;
if (*s == '-') {
/* comment? */
char *tmp;
s++;
if (s == end)
return beg;
if (*s != '-')
goto DECL_FAIL; /* nope, illegal */
/* yes, two dashes seen */
s++;
tmp = parse_comment(p_state, s, end, utf8, self);
return (tmp == s) ? beg : tmp;
}
#ifdef MARKED_SECTION
if (*s == '[') {
/* marked section */
char *tmp;
s++;
tmp = parse_marked_section(p_state, s, end, utf8, self);
if (!tmp)
goto DECL_FAIL;
return (tmp == s) ? beg : tmp;
}
#endif
if (*s == '>') {
/* make <!> into empty comment <SGML Handbook 36:32> */
token_pos_t token;
token.beg = s;
token.end = s;
s++;
report_event(p_state, E_COMMENT, beg, s, utf8, &token, 1, self);
return s;
}
if (isALPHA(*s)) {
dTOKENS(8);
char *decl_id = s;
STRLEN decl_id_len;
s++;
/* declaration */
while (s < end && isHNAME_CHAR(*s))
s++;
decl_id_len = s - decl_id;
/* just hardcode a few names as the recognized declarations */
if (!((decl_id_len == 7 &&
strnEQx(decl_id, "DOCTYPE", 7, !p_state->xml_mode)) ||
(decl_id_len == 6 &&
strnEQx(decl_id, "ENTITY", 6, !p_state->xml_mode))
)
)
{
goto FAIL;
}
/* first word available */
PUSH_TOKEN(decl_id, s);
while (s < end && isHSPACE(*s)) {
s++;
while (s < end && isHSPACE(*s))
s++;
if (s == end)
goto PREMATURE;
if (*s == '"' || *s == '\'') {
char *str_beg = s;
s++;
while (s < end && *s != *str_beg)
s++;
if (s == end)
goto PREMATURE;
s++;
PUSH_TOKEN(str_beg, s);
}
else if (*s == '-') {
/* comment */
char *com_beg = s;
s++;
if (s == end)
goto PREMATURE;
if (*s != '-')
goto FAIL;
s++;
while (1) {
while (s < end && *s != '-')
s++;
if (s == end)
goto PREMATURE;
s++;
if (s == end)
goto PREMATURE;
if (*s == '-') {
s++;
PUSH_TOKEN(com_beg, s);
break;
}
}
}
else if (*s != '>') {
/* plain word */
char *word_beg = s;
s++;
while (s < end && isHNOT_SPACE_GT(*s))
s++;
if (s == end)
goto PREMATURE;
PUSH_TOKEN(word_beg, s);
}
else {
break;
}
}
if (s == end)
goto PREMATURE;
if (*s == '>') {
s++;
report_event(p_state, E_DECLARATION, beg, s, utf8, tokens, num_tokens, self);
FREE_TOKENS;
return s;
}
FAIL:
FREE_TOKENS;
goto DECL_FAIL;
PREMATURE:
FREE_TOKENS;
return beg;
}
DECL_FAIL:
if (p_state->strict_comment)
return 0;
/* consider everything up to the first '>' a comment */
s = skip_until_gt(s, end);
if (s < end) {
token_pos_t token;
token.beg = beg + 2;
token.end = s;
s++;
report_event(p_state, E_COMMENT, beg, s, utf8, &token, 1, self);
return s;
}
else {
return beg;
}
}
//
// BinaryTokenZDACS::make_tokens
//
void BinaryTokenZDACS::make_tokens
(ObjectVector const &objects, std::vector<BinaryTokenZDACS> *instructions)
{
static ObjectExpression::Pointer const fracbits =
ObjectExpression::CreateValueINT(16, SourcePosition::builtin());
static ObjectExpression::Pointer const indexAddr =
ObjectExpression::CreateValueINT(option_addr_array, SourcePosition::builtin());
static ObjectExpression::Reference const indexAuto =
ObjectExpression::CreateValueINT(option_auto_array, SourcePosition::builtin());
static ObjectExpression::Reference const indexRet1 =
ObjectExpression::CreateValueINT(-1, SourcePosition::builtin());
static ObjectExpression::Pointer const indexStack =
ObjectExpression::CreateValueINT(option_addr_stack, SourcePosition::builtin());
static ObjectExpression::Reference const func_GetChar =
ObjectExpression::CreateValueUNS(15, SourcePosition::builtin());
static ObjectExpression::Reference const func_GetCharArgs =
ObjectExpression::CreateValueUNS(2, SourcePosition::builtin());
static ObjectExpression::Reference const func_Getptr =
ObjectExpression::CreateValueSymbol("__Getptr", SourcePosition::builtin());
static ObjectExpression::Reference const func_Setptr =
ObjectExpression::CreateValueSymbol("__Setptr", SourcePosition::builtin());
static ObjectExpression::Reference const func_Udiv =
ObjectExpression::CreateValueSymbol("__Udiv", SourcePosition::builtin());
static ObjectExpression::Reference const func_Ursh =
ObjectExpression::CreateValueSymbol("__Ursh", SourcePosition::builtin());
static std::vector<std::string> const nolabels;
std::vector<ObjectExpression::Pointer> args;
ObjectVector::const_iterator object;
for (object = objects.begin(); object != objects.end(); ++object)
{
SourcePosition const &pos = object->pos;
std::vector<std::string> const *labels = &object->labels;
switch (object->code)
{
BINTOKACS_TOKENS_MAP_ALL();
BINTOKACS_TOKENS_TRAN_ALL();
// Operators
CASE_ADDR_BINOP(ADD, _I,);
CASE_ADDR_BINOP(ADD, _U,);
CASE_ADDR_BINOP(ADD, _X,);
CASE_REMAP_REGS(ADD, _I,);
CASE_REMAP_REGS(ADD, _U,);
CASE_REMAP_REGS(ADD, _X,);
CASE_ADDR_BINOP(AND, _I,);
CASE_ADDR_BINOP(AND, _U,);
CASE_ADDR_BINOP(AND, _X,);
CASE_REMAP_REG2(AND, _I,);
CASE_REMAP_REG2(AND, _U,);
CASE_REMAP_REG2(AND, _X,);
CASE_ADDR_UNAOP(DEC, _I,);
CASE_ADDR_UNAOP(DEC, _U,);
CASE_REMAP_REGS(DEC, _I,);
CASE_REMAP_REGS(DEC, _U,);
CASE_REMAP(DIV_STK_X, DIV_STK_X);
CASE_ADDR_BINOP(DIV, _I,);
CASE_REMAP_REGS(DIV, _I,);
case OCODE_DIV_STK_U:
args.push_back(func_Udiv);
PUSH_TOKEN(BCODE_JMP_CAL_IMM);
break;
CASE_ADDR_UNAOP(INC, _I,);
CASE_ADDR_UNAOP(INC, _U,);
CASE_REMAP_REGS(INC, _I,);
CASE_REMAP_REGS(INC, _U,);
CASE_ADDR_BINOP(IOR, _I,);
CASE_ADDR_BINOP(IOR, _U,);
CASE_ADDR_BINOP(IOR, _X,);
CASE_REMAP_REG2(IOR, _I,);
CASE_REMAP_REG2(IOR, _U,);
CASE_REMAP_REG2(IOR, _X,);
CASE_ADDR_BINOP(LSH, _I,);
CASE_ADDR_BINOP(LSH, _U,);
CASE_ADDR_BINOP(LSH, _X,);
CASE_REMAP_REG2(LSH, _I,);
CASE_REMAP_REG2(LSH, _U,);
CASE_REMAP_REG2(LSH, _X,);
CASE_ADDR_BINOP(MOD, _I,);
CASE_ADDR_BINOP(MOD, _X,);
CASE_REMAP_REGS(MOD, _I,);
CASE_REMAP_REGS(MOD, _X,);
case OCODE_MOD_STK_U:
args.push_back(func_Udiv);
PUSH_TOKEN(BCODE_JMP_CAL_NIL_IMM);
args.push_back(indexRet1);
PUSH_TOKEN(BCODE_GET_IMM);
args.push_back(indexAuto);
PUSH_TOKEN(BCODE_GET_WLDARR);
break;
CASE_REMAP(MUL_STK_X, MUL_STK_X);
CASE_ADDR_BINOP(MUL, _I,);
CASE_ADDR_BINOP(MUL, _U,);
CASE_REMAP_REGS(MUL, _I,);
CASE_REMAP_REGS(MUL, _U,);
CASE_ADDR_BINOP(RSH, _I,);
CASE_ADDR_BINOP(RSH, _X,);
CASE_REMAP_REG2(RSH, _I,);
CASE_REMAP_REG2(RSH, _X,);
case OCODE_RSH_STK_U:
args.push_back(func_Ursh);
PUSH_TOKEN(BCODE_JMP_CAL_IMM);
break;
CASE_ADDR_BINOP(SUB, _I,);
CASE_ADDR_BINOP(SUB, _U,);
CASE_ADDR_BINOP(SUB, _X,);
CASE_REMAP_REGS(SUB, _I,);
CASE_REMAP_REGS(SUB, _U,);
CASE_REMAP_REGS(SUB, _X,);
CASE_ADDR_BINOP(XOR, _I,);
CASE_ADDR_BINOP(XOR, _U,);
CASE_ADDR_BINOP(XOR, _X,);
CASE_REMAP_REG2(XOR, _I,);
CASE_REMAP_REG2(XOR, _U,);
CASE_REMAP_REG2(XOR, _X,);
CASE_REMAP(INV_STK_I, INV_STK);
CASE_REMAP(INV_STK_U, INV_STK);
CASE_REMAP(INV_STK_X, INV_STK);
// Jumps
CASE_REMAP(JMP, JMP);
case OCODE_JMP_TAB:
if((args = object->args).size() % 2)
Error_P("uneven OCODE_JMP_TAB");
PUSH_TOKEN(BCODE_JMP_TAB);
break;
CASE_REMAP(JMP_CAL, JMP_CAL);
CASE_REMAP(JMP_CAL_IMM, JMP_CAL_IMM);
case OCODE_JMP_CAL_NIL:
PUSH_TOKEN(BCODE_JMP_CAL);
PUSH_TOKEN(BCODE_STK_DROP);
break;
CASE_REMAP(JMP_CAL_NIL_IMM, JMP_CAL_NIL_IMM);
CASE_REMAP(JMP_RET, JMP_RET);
CASE_REMAP(JMP_RET_NIL, JMP_RET_NIL);
// Stack-ops.
CASE_REMAP(STK_COPY, STK_COPY);
CASE_REMAP(STK_SWAP, STK_SWAP);
// Trigonometry
CASE_REMAP(TRIG_COS_X, TRIG_COS);
CASE_REMAP(TRIG_SIN_X, TRIG_SIN);
// Variable Address
case OCODE_GET_AUTPTR:
args.push_back(indexStack);
PUSH_TOKEN(BCODE_GET_WLDREG);
break;
case OCODE_GET_AUTPTR_IMM:
args.push_back(indexStack);
PUSH_TOKEN(BCODE_GET_WLDREG);
PUSH_TOKEN_ADD_ARG0();
break;
case OCODE_SET_AUTPTR_IMM:
PUSH_TOKEN_ARGS1(BCODE_GET_IMM, 1);
case OCODE_SET_AUTPTR:
args.push_back(indexStack);
PUSH_TOKEN(BCODE_SET_WLDREG);
break;
case OCODE_ADD_AUTPTR_IMM:
PUSH_TOKEN_ARGS1(BCODE_GET_IMM, 1);
case OCODE_ADD_AUTPTR:
args.push_back(indexStack);
PUSH_TOKEN(BCODE_ADD_WLDREG);
break;
case OCODE_SUB_AUTPTR_IMM:
PUSH_TOKEN_ARGS1(BCODE_GET_IMM, 1);
case OCODE_SUB_AUTPTR:
args.push_back(indexStack);
PUSH_TOKEN(BCODE_SUB_WLDREG);
break;
// Variable Get
case OCODE_GET_FUNCP:
// Don't tag nullptr.
if(object->getArg(0)->resolveUNS())
{
PUSH_TOKEN_ARGS1(BCODE_GET_FUNCP, 1);
}
else
{
PUSH_TOKEN_ARGS1(BCODE_GET_IMM, 1);
}
break;
case OCODE_GET_STRING:
PUSH_TOKEN_ARGS1(BCODE_GET_IMM, 1);
// Don't tag nullptr.
if(option_string_tag && object->getArg(0)->resolveUNS())
PUSH_TOKEN(BCODE_STRING_TAG);
break;
case OCODE_GET_FARPTR:
PUSH_TOKEN_ADD_ARG0();
args.push_back(func_Getptr);
PUSH_TOKEN(BCODE_JMP_CAL_IMM);
break;
case OCODE_GET_STRPTR:
PUSH_TOKEN_ADD_ARG0();
args.push_back(func_GetCharArgs);
args.push_back(func_GetChar);
PUSH_TOKEN(BCODE_NATIVE);
break;
CASE_ADDR_UNAOP(GET,,);
CASE_REMAP_REGS(GET,,);
// Variable Set
case OCODE_SET_FARPTR:
PUSH_TOKEN_ADD_ARG0();
args.push_back(func_Setptr);
PUSH_TOKEN(BCODE_JMP_CAL_NIL_IMM);
break;
CASE_ADDR_BINOP(SET,,);
CASE_REMAP_REGS(SET,,);
CASE_REMAP(SET_SCRRET, SET_SCRRET);
// Miscellaneous
CASE_REMAP(NATIVE, NATIVE);
// ACS
// ACS Common Extensions
// ACS Extensions
CASE_MAP_ACSE(GAME_EXEC);
CASE_MAP_ACSE(GAME_EXEC_IMM);
CASE_MAP_ACSE(GAME_GET_CVAR);
CASE_MAP_ACSE(GAME_GET_INVASIONSTATE);
CASE_MAP_ACSE(GAME_GET_INVASIONWAVE);
CASE_MAP_ACSE(GAME_GET_LEVELINFO);
CASE_MAP_ACSE(GAME_GET_TEAMINFO_PLAYERCOUNT_BLUE);
CASE_MAP_ACSE(GAME_GET_TEAMINFO_PLAYERCOUNT_RED);
CASE_MAP_ACSE(GAME_GET_TEAMINFO_SCORE_BLUE);
CASE_MAP_ACSE(GAME_GET_TEAMINFO_SCORE_RED);
CASE_MAP_ACSE(GAME_GET_THINGCOUNT_STR);
CASE_MAP_ACSE(GAME_GET_TYPE_ONEFLAGCTF);
CASE_MAP_ACSE(GAME_GET_TYPE_SINGLEPLAYER);
CASE_MAP_ACSE(GAME_REPLACETEXTURES);
CASE_MAP_ACSE(GAME_SET_AIRCONTROL);
CASE_MAP_ACSE(GAME_SET_AIRCONTROL_IMM);
CASE_MAP_ACSE(GAME_SET_GRAVITY);
CASE_MAP_ACSE(GAME_SET_GRAVITY_IMM);
CASE_MAP_ACSE(GAME_SET_LEVEL);
CASE_MAP_ACSE(GAME_SET_MUSIC);
CASE_MAP_ACSE(GAME_SET_MUSIC_IMM);
CASE_MAP_ACSE(GAME_SET_MUSICLOCAL);
CASE_MAP_ACSE(GAME_SET_MUSICLOCAL_IMM);
CASE_MAP_ACSE(GAME_SET_MUSICST);
CASE_MAP_ACSE(GAME_SET_SKY);
CASE_MAP_ACSE(LINE_GET_OFFSETY);
CASE_MAP_ACSE(LTAG_SET_BLOCKMONSTER);
CASE_MAP_ACSE(MISC_PLAYMOVIE);
CASE_MAP_ACSE(MTAG_ADD_INVENTORY);
CASE_MAP_ACSE(MTAG_CHK_TEXTURE_CEILING);
CASE_MAP_ACSE(MTAG_CHK_TEXTURE_FLOOR);
CASE_MAP_ACSE(MTAG_CLR_INVENTORY);
CASE_MAP_ACSE(MTAG_DAMAGE);
CASE_MAP_ACSE(MTAG_GET);
CASE_MAP_ACSE(MTAG_GET_ANGLE);
CASE_MAP_ACSE(MTAG_GET_CEILINGZ);
CASE_MAP_ACSE(MTAG_GET_CLASSIFICATION);
CASE_MAP_ACSE(MTAG_GET_FLOORZ);
CASE_MAP_ACSE(MTAG_GET_INVENTORY);
CASE_MAP_ACSE(MTAG_GET_LIGHTLEVEL);
CASE_MAP_ACSE(MTAG_GET_PITCH);
CASE_MAP_ACSE(MTAG_GET_X);
CASE_MAP_ACSE(MTAG_GET_Y);
CASE_MAP_ACSE(MTAG_GET_Z);
CASE_MAP_ACSE(MTAG_MORPH);
CASE_MAP_ACSE(MTAG_SET);
CASE_MAP_ACSE(MTAG_SET_ANGLE);
CASE_MAP_ACSE(MTAG_SET_CAMERATEXTURE);
CASE_MAP_ACSE(MTAG_SET_MARINESPRITE);
CASE_MAP_ACSE(MTAG_SET_MARINEWEAPON);
CASE_MAP_ACSE(MTAG_SET_PITCH);
CASE_MAP_ACSE(MTAG_SET_SPECIAL);
CASE_MAP_ACSE(MTAG_SET_STATE);
CASE_MAP_ACSE(MTAG_SET_XYZ);
CASE_MAP_ACSE(MTAG_SUB_INVENTORY);
CASE_MAP_ACSE(MTAG_UNMORPH);
CASE_MAP_ACSE(MTAG_USEINVENTORY);
CASE_MAP_ACSE(PLAYER_GET_CAMERA);
CASE_MAP_ACSE(PLAYER_GET_CLASS);
CASE_MAP_ACSE(PLAYER_GET_INFO);
CASE_MAP_ACSE(PLAYER_GET_INGAME);
CASE_MAP_ACSE(PLAYER_GET_INPUT);
CASE_MAP_ACSE(PLAYER_GET_ISBOT);
CASE_MAP_ACSE(SCREEN_FADE_RANGE);
CASE_MAP_ACSE(SCREEN_FADE_START);
CASE_MAP_ACSE(SCREEN_FADE_STOP);
CASE_MAP_ACSE(SCREEN_GET_HEIGHT);
CASE_MAP_ACSE(SCREEN_GET_WIDTH);
CASE_MAP_ACSE(SCREEN_SET_HUDSIZE);
CASE_MAP_ACSE(SOUND_AMBIENTLOCAL);
CASE_MAP_ACSE(SOUND_THING);
CASE_MAP_ACSE(SPAWN_POINT);
CASE_MAP_ACSE(SPAWN_POINT_IMM);
CASE_MAP_ACSE(SPAWN_PROJECTILE_SID);
CASE_MAP_ACSE(SPAWN_PROJECTILE_STR);
CASE_MAP_ACSE(SPAWN_SPOT_ANGLE);
CASE_MAP_ACSE(SPAWN_SPOT_ANGLE_IMM);
CASE_MAP_ACSE(SPAWN_SPOT);
CASE_MAP_ACSE(SPECIAL_EXEC5_RETN1);
CASE_MAP_ACSE(STAG_DAMAGE);
CASE_MAP_ACSE(STAG_GET_LIGHTLEVEL);
CASE_MAP_ACSE(STAG_GET_THINGCOUNT_SID);
CASE_MAP_ACSE(STAG_GET_THINGCOUNT_STR);
CASE_MAP_ACSE(STAG_GET_Z_CEILING);
CASE_MAP_ACSE(STAG_GET_Z_FLOOR);
CASE_MAP_ACSE(STAG_SET_TRIGGER_CEILING);
CASE_MAP_ACSE(STAG_SET_TRIGGER_FLOOR);
CASE_MAP_ACSE(STRING_COPY_GLOBALRANGE);
CASE_MAP_ACSE(STRING_COPY_MAPRANGE);
CASE_MAP_ACSE(STRING_COPY_WORLDRANGE);
CASE_MAP_ACSE(STRING_GET_LENGTH);
CASE_MAP_ACSE(THING_ADD_INVENTORY);
CASE_MAP_ACSE(THING_ADD_INVENTORY_IMM);
CASE_MAP_ACSE(THING_CHK_WEAPON);
CASE_MAP_ACSE(THING_CLR_INVENTORY);
CASE_MAP_ACSE(THING_GET_AMMOCAP);
CASE_MAP_ACSE(THING_GET_ARMOR);
CASE_MAP_ACSE(THING_GET_FRAGS);
CASE_MAP_ACSE(THING_GET_HEALTH);
CASE_MAP_ACSE(THING_GET_INVENTORY);
CASE_MAP_ACSE(THING_GET_INVENTORY_IMM);
CASE_MAP_ACSE(THING_GET_MTAG);
CASE_MAP_ACSE(THING_GET_PLAYERNUMBER);
CASE_MAP_ACSE(THING_GET_SIGIL);
CASE_MAP_ACSE(THING_GET_TEAM);
CASE_MAP_ACSE(THING_SET_AMMOCAP);
CASE_MAP_ACSE(THING_SET_MUGSHOT);
CASE_MAP_ACSE(THING_SET_WEAPON);
CASE_MAP_ACSE(THING_SUB_INVENTORY);
CASE_MAP_ACSE(THING_SUB_INVENTORY_IMM);
CASE_MAP_ACSE(THING_USEINVENTORY);
CASE_MAP_ACSE(TRANSLATION_DESAT);
CASE_MAP_ACSE(TRANSLATION_END);
CASE_MAP_ACSE(TRANSLATION_PALETTE);
CASE_MAP_ACSE(TRANSLATION_RGB);
CASE_MAP_ACSE(TRANSLATION_START);
CASE_MAP_ACSE(TRIG_VECTORANGLE);
CASE_MAP_ACSE(WAIT_SNAM);
// ACS Printing
CASE_MAP_ACSP(END_HUD);
CASE_MAP_ACSP(END_HUD_BOLD);
CASE_MAP_ACSP(END_LOG);
CASE_MAP_ACSP(END_OPT);
CASE_MAP_ACSP(END_STR);
CASE_MAP_ACSP(KEYBIND);
CASE_REMAP_ACSP(NUM_BIN_U, NUM_BIN);
CASE_REMAP_ACSP(NUM_DEC_X, NUM_DEC_X);
CASE_REMAP_ACSP(NUM_HEX_U, NUM_HEX);
CASE_MAP_ACSP(PLAYER_NAME);
CASE_MAP_ACSP(SET_FONT);
CASE_MAP_ACSP(SET_FONT_IMM);
CASE_MAP_ACSP(START_OPT);
CASE_MAP_ACSP(STR_GBLARR);
CASE_MAP_ACSP(STR_GBLRNG);
CASE_MAP_ACSP(STR_LOCALIZED);
CASE_MAP_ACSP(STR_MAPARR);
CASE_MAP_ACSP(STR_MAPRNG);
CASE_MAP_ACSP(STR_WLDARR);
CASE_MAP_ACSP(STR_WLDRNG);
case OCODE_NONE:
default:
Error_P("unknown OCODE: %s", make_string(object->code));
}
}
}
