emo/busybox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

bc: rename several BC_LEX_OPs to XC_LEX_OPs.

Browse Source 
Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
This commit is contained in:
Denys Vlasenko 2018-12-24 14:14:23 +01:00
parent abf6cf6765
commit 69560f42da
1 changed files with 72 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

143
miscutils/bc.c
View File

@ -388,27 +388,27 @@ typedef struct BcInstPtr {
IF_BC(size_t results_len_before_call;) IF_BC(size_t results_len_before_call;)
} BcInstPtr; } BcInstPtr;
// BC_LEX_NEG is not used in lexing; it is only for parsing. // XC_LEX_NEG is not used in lexing; it is only for parsing.
typedef enum BcLexType { typedef enum BcLexType {
XC_LEX_EOF, XC_LEX_EOF,
XC_LEX_INVALID, XC_LEX_INVALID,
BC_LEX_1st_op, XC_LEX_1st_op,
BC_LEX_NEG = BC_LEX_1st_op, // order XC_LEX_NEG = XC_LEX_1st_op, // order
BC_LEX_OP_POWER, // should XC_LEX_OP_POWER, // should
BC_LEX_OP_MULTIPLY, // match XC_LEX_OP_MULTIPLY, // match
BC_LEX_OP_DIVIDE, // INST XC_LEX_OP_DIVIDE, // INST
BC_LEX_OP_MODULUS, // constants XC_LEX_OP_MODULUS, // constants
BC_LEX_OP_PLUS, // for XC_LEX_OP_PLUS, // for
BC_LEX_OP_MINUS, // these XC_LEX_OP_MINUS, // these
BC_LEX_OP_REL_EQ, // opeartions XC_LEX_OP_REL_EQ, // opeartions
BC_LEX_OP_REL_LE, // | XC_LEX_OP_REL_LE, // |
BC_LEX_OP_REL_GE, // | XC_LEX_OP_REL_GE, // |
BC_LEX_OP_REL_NE, // | XC_LEX_OP_REL_NE, // |
BC_LEX_OP_REL_LT, // | XC_LEX_OP_REL_LT, // |
BC_LEX_OP_REL_GT, // | XC_LEX_OP_REL_GT, // |
BC_LEX_OP_BOOL_NOT, // | BC_LEX_OP_BOOL_NOT, // |
BC_LEX_OP_BOOL_OR, // | BC_LEX_OP_BOOL_OR, // |
@ -593,7 +593,7 @@ static ALWAYS_INLINE long bc_parse_exprs(unsigned i)
} }
// This is an array of data for operators that correspond to // This is an array of data for operators that correspond to
// [BC_LEX_1st_op...BC_LEX_last_op] token types. // [XC_LEX_1st_op...] token types.
static const uint8_t bc_parse_ops[] = { static const uint8_t bc_parse_ops[] = {
#define OP(p,l) ((int)(l) * 0x10 + (p)) #define OP(p,l) ((int)(l) * 0x10 + (p))
OP(1, false), // neg OP(1, false), // neg
@ -617,18 +617,18 @@ static const //BcLexType - should be this type
uint8_t uint8_t
dc_char_to_LEX[] = { dc_char_to_LEX[] = {
/* %&'( */ /* %&'( */
BC_LEX_OP_MODULUS, XC_LEX_INVALID, XC_LEX_INVALID, BC_LEX_LPAREN, XC_LEX_OP_MODULUS, XC_LEX_INVALID, XC_LEX_INVALID, BC_LEX_LPAREN,
/* )*+, */ /* )*+, */
XC_LEX_INVALID, BC_LEX_OP_MULTIPLY, BC_LEX_OP_PLUS, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_OP_MULTIPLY, XC_LEX_OP_PLUS, XC_LEX_INVALID,
/* -./ */ /* -./ */
BC_LEX_OP_MINUS, XC_LEX_INVALID, BC_LEX_OP_DIVIDE, XC_LEX_OP_MINUS, XC_LEX_INVALID, XC_LEX_OP_DIVIDE,
/* 0123456789 */ /* 0123456789 */
XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID,
XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID,
XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID,
/* :;<=>?@ */ /* :;<=>?@ */
DC_LEX_COLON, BC_LEX_SCOLON, BC_LEX_OP_REL_GT, BC_LEX_OP_REL_EQ, DC_LEX_COLON, BC_LEX_SCOLON, XC_LEX_OP_REL_GT, XC_LEX_OP_REL_EQ,
BC_LEX_OP_REL_LT, BC_LEX_KEY_READ, XC_LEX_INVALID, XC_LEX_OP_REL_LT, BC_LEX_KEY_READ, XC_LEX_INVALID,
/* ABCDEFGH */ /* ABCDEFGH */
XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID,
XC_LEX_INVALID, XC_LEX_INVALID, DC_LEX_EQ_NO_REG, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, DC_LEX_EQ_NO_REG, XC_LEX_INVALID,
@ -641,7 +641,7 @@ dc_char_to_LEX[] = {
/* Z[\] */ /* Z[\] */
BC_LEX_KEY_LENGTH, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID, BC_LEX_KEY_LENGTH, XC_LEX_INVALID, XC_LEX_INVALID, XC_LEX_INVALID,
/* ^_` */ /* ^_` */
BC_LEX_OP_POWER, BC_LEX_NEG, XC_LEX_INVALID, XC_LEX_OP_POWER, XC_LEX_NEG, XC_LEX_INVALID,
/* abcdefgh */ /* abcdefgh */
DC_LEX_ASCIIFY, XC_LEX_INVALID, DC_LEX_CLEAR_STACK, DC_LEX_DUPLICATE, DC_LEX_ASCIIFY, XC_LEX_INVALID, DC_LEX_CLEAR_STACK, DC_LEX_DUPLICATE,
DC_LEX_ELSE, DC_LEX_PRINT_STACK, XC_LEX_INVALID, XC_LEX_INVALID, DC_LEX_ELSE, DC_LEX_PRINT_STACK, XC_LEX_INVALID, XC_LEX_INVALID,
@ -660,7 +660,8 @@ static const //BcInst - should be this type. Using signed narrow type since DC_I
int8_t int8_t
dc_LEX_to_INST[] = { // (so many INVALIDs b/c dc parser does not generate these LEXs) // corresponding BC_LEX_xyz: dc_LEX_to_INST[] = { // (so many INVALIDs b/c dc parser does not generate these LEXs) // corresponding BC_LEX_xyz:
DC_INST_INVALID, DC_INST_INVALID, // EOF INVALID DC_INST_INVALID, DC_INST_INVALID, // EOF INVALID
DC_INST_INVALID, XC_INST_POWER, XC_INST_MULTIPLY, XC_INST_DIVIDE, // NEG OP_POWER OP_MULTIPLY OP_DIVIDE DC_INST_INVALID, // NEG
XC_INST_POWER, XC_INST_MULTIPLY, XC_INST_DIVIDE, // OP_POWER OP_MULTIPLY OP_DIVIDE
XC_INST_MODULUS, XC_INST_PLUS, XC_INST_MINUS, // OP_MODULUS OP_PLUS OP_MINUS XC_INST_MODULUS, XC_INST_PLUS, XC_INST_MINUS, // OP_MODULUS OP_PLUS OP_MINUS
DC_INST_INVALID, DC_INST_INVALID, DC_INST_INVALID, DC_INST_INVALID, // OP_REL_EQ OP_REL_LE OP_REL_GE OP_REL_NE DC_INST_INVALID, DC_INST_INVALID, DC_INST_INVALID, DC_INST_INVALID, // OP_REL_EQ OP_REL_LE OP_REL_GE OP_REL_NE
DC_INST_INVALID, DC_INST_INVALID, // OP_REL_LT OP_REL_GT DC_INST_INVALID, DC_INST_INVALID, // OP_REL_LT OP_REL_GT
@ -3159,7 +3160,7 @@ static BC_STATUS zbc_lex_token(BcLex *l)
bc_lex_whitespace(l); bc_lex_whitespace(l);
break; break;
case '!': case '!':
bc_lex_assign(l, BC_LEX_OP_REL_NE, BC_LEX_OP_BOOL_NOT); bc_lex_assign(l, XC_LEX_OP_REL_NE, BC_LEX_OP_BOOL_NOT);
if (l->t.t == BC_LEX_OP_BOOL_NOT) { if (l->t.t == BC_LEX_OP_BOOL_NOT) {
s = bc_POSIX_does_not_allow_bool_ops_this_is_bad("!"); s = bc_POSIX_does_not_allow_bool_ops_this_is_bad("!");
IF_ERROR_RETURN_POSSIBLE(if (s) RETURN_STATUS(s)); IF_ERROR_RETURN_POSSIBLE(if (s) RETURN_STATUS(s));
@ -3174,7 +3175,7 @@ static BC_STATUS zbc_lex_token(BcLex *l)
bc_lex_lineComment(l); bc_lex_lineComment(l);
break; break;
case '%': case '%':
bc_lex_assign(l, BC_LEX_OP_ASSIGN_MODULUS, BC_LEX_OP_MODULUS); bc_lex_assign(l, BC_LEX_OP_ASSIGN_MODULUS, XC_LEX_OP_MODULUS);
break; break;
case '&': case '&':
c2 = l->buf[l->i]; c2 = l->buf[l->i];
@ -3193,7 +3194,7 @@ static BC_STATUS zbc_lex_token(BcLex *l)
l->t.t = (BcLexType)(c - '(' + BC_LEX_LPAREN); l->t.t = (BcLexType)(c - '(' + BC_LEX_LPAREN);
break; break;
case '*': case '*':
bc_lex_assign(l, BC_LEX_OP_ASSIGN_MULTIPLY, BC_LEX_OP_MULTIPLY); bc_lex_assign(l, BC_LEX_OP_ASSIGN_MULTIPLY, XC_LEX_OP_MULTIPLY);
break; break;
case '+': case '+':
c2 = l->buf[l->i]; c2 = l->buf[l->i];
@ -3201,7 +3202,7 @@ static BC_STATUS zbc_lex_token(BcLex *l)
++l->i; ++l->i;
l->t.t = BC_LEX_OP_INC; l->t.t = BC_LEX_OP_INC;
} else } else
bc_lex_assign(l, BC_LEX_OP_ASSIGN_PLUS, BC_LEX_OP_PLUS); bc_lex_assign(l, BC_LEX_OP_ASSIGN_PLUS, XC_LEX_OP_PLUS);
break; break;
case ',': case ',':
l->t.t = BC_LEX_COMMA; l->t.t = BC_LEX_COMMA;
@ -3212,7 +3213,7 @@ static BC_STATUS zbc_lex_token(BcLex *l)
++l->i; ++l->i;
l->t.t = BC_LEX_OP_DEC; l->t.t = BC_LEX_OP_DEC;
} else } else
bc_lex_assign(l, BC_LEX_OP_ASSIGN_MINUS, BC_LEX_OP_MINUS); bc_lex_assign(l, BC_LEX_OP_ASSIGN_MINUS, XC_LEX_OP_MINUS);
break; break;
case '.': case '.':
if (isdigit(l->buf[l->i])) if (isdigit(l->buf[l->i]))
@ -3227,7 +3228,7 @@ static BC_STATUS zbc_lex_token(BcLex *l)
if (c2 == '*') if (c2 == '*')
s = zbc_lex_comment(l); s = zbc_lex_comment(l);
else else
bc_lex_assign(l, BC_LEX_OP_ASSIGN_DIVIDE, BC_LEX_OP_DIVIDE); bc_lex_assign(l, BC_LEX_OP_ASSIGN_DIVIDE, XC_LEX_OP_DIVIDE);
break; break;
case '0': case '0':
case '1': case '1':
@ -3251,13 +3252,13 @@ static BC_STATUS zbc_lex_token(BcLex *l)
l->t.t = BC_LEX_SCOLON; l->t.t = BC_LEX_SCOLON;
break; break;
case '<': case '<':
bc_lex_assign(l, BC_LEX_OP_REL_LE, BC_LEX_OP_REL_LT); bc_lex_assign(l, XC_LEX_OP_REL_LE, XC_LEX_OP_REL_LT);
break; break;
case '=': case '=':
bc_lex_assign(l, BC_LEX_OP_REL_EQ, BC_LEX_OP_ASSIGN); bc_lex_assign(l, XC_LEX_OP_REL_EQ, BC_LEX_OP_ASSIGN);
break; break;
case '>': case '>':
bc_lex_assign(l, BC_LEX_OP_REL_GE, BC_LEX_OP_REL_GT); bc_lex_assign(l, XC_LEX_OP_REL_GE, XC_LEX_OP_REL_GT);
break; break;
case '[': case '[':
case ']': case ']':
@ -3271,7 +3272,7 @@ static BC_STATUS zbc_lex_token(BcLex *l)
s = bc_error_bad_character(c); s = bc_error_bad_character(c);
break; break;
case '^': case '^':
bc_lex_assign(l, BC_LEX_OP_ASSIGN_POWER, BC_LEX_OP_POWER); bc_lex_assign(l, BC_LEX_OP_ASSIGN_POWER, XC_LEX_OP_POWER);
break; break;
case 'a': case 'a':
case 'b': case 'b':
@ -3395,8 +3396,8 @@ static BC_STATUS zdc_lex_token(BcLex *l)
static const //BcLexType - should be this type, but narrower type saves size: static const //BcLexType - should be this type, but narrower type saves size:
uint8_t uint8_t
dc_lex_regs[] = { dc_lex_regs[] = {
BC_LEX_OP_REL_EQ, BC_LEX_OP_REL_LE, BC_LEX_OP_REL_GE, BC_LEX_OP_REL_NE, XC_LEX_OP_REL_EQ, XC_LEX_OP_REL_LE, XC_LEX_OP_REL_GE, XC_LEX_OP_REL_NE,
BC_LEX_OP_REL_LT, BC_LEX_OP_REL_GT, BC_LEX_SCOLON, DC_LEX_COLON, XC_LEX_OP_REL_LT, XC_LEX_OP_REL_GT, BC_LEX_SCOLON, DC_LEX_COLON,
DC_LEX_ELSE, DC_LEX_LOAD, DC_LEX_LOAD_POP, BC_LEX_OP_ASSIGN, DC_LEX_ELSE, DC_LEX_LOAD, DC_LEX_LOAD_POP, BC_LEX_OP_ASSIGN,
DC_LEX_STORE_PUSH, DC_LEX_STORE_PUSH,
}; };
@ -3446,11 +3447,11 @@ static BC_STATUS zdc_lex_token(BcLex *l)
case '!': case '!':
c2 = l->buf[l->i]; c2 = l->buf[l->i];
if (c2 == '=') if (c2 == '=')
l->t.t = BC_LEX_OP_REL_NE; l->t.t = XC_LEX_OP_REL_NE;
else if (c2 == '<') else if (c2 == '<')
l->t.t = BC_LEX_OP_REL_LE; l->t.t = XC_LEX_OP_REL_LE;
else if (c2 == '>') else if (c2 == '>')
l->t.t = BC_LEX_OP_REL_GE; l->t.t = XC_LEX_OP_REL_GE;
else else
RETURN_STATUS(bc_error_bad_character(c)); RETURN_STATUS(bc_error_bad_character(c));
++l->i; ++l->i;
@ -3686,7 +3687,7 @@ static size_t bc_program_addFunc(char *name)
// We can calculate the conversion between tokens and exprs by subtracting the // We can calculate the conversion between tokens and exprs by subtracting the
// position of the first operator in the lex enum and adding the position of the // position of the first operator in the lex enum and adding the position of the
// first in the expr enum. Note: This only works for binary operators. // first in the expr enum. Note: This only works for binary operators.
#define BC_TOKEN_2_INST(t) ((char) ((t) - BC_LEX_OP_POWER + XC_INST_POWER)) #define BC_TOKEN_2_INST(t) ((char) ((t) - XC_LEX_OP_POWER + XC_INST_POWER))
static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags); static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags);
@ -3726,19 +3727,19 @@ static BC_STATUS zbc_parse_stmt_allow_NLINE_before(BcParse *p, const char *after
static void bc_parse_operator(BcParse *p, BcLexType type, size_t start, static void bc_parse_operator(BcParse *p, BcLexType type, size_t start,
size_t *nexprs) size_t *nexprs)
{ {
char l, r = bc_parse_op_PREC(type - BC_LEX_1st_op); char l, r = bc_parse_op_PREC(type - XC_LEX_1st_op);
bool left = bc_parse_op_LEFT(type - BC_LEX_1st_op); bool left = bc_parse_op_LEFT(type - XC_LEX_1st_op);
while (p->ops.len > start) { while (p->ops.len > start) {
BcLexType t = BC_PARSE_TOP_OP(p); BcLexType t = BC_PARSE_TOP_OP(p);
if (t == BC_LEX_LPAREN) break; if (t == BC_LEX_LPAREN) break;
l = bc_parse_op_PREC(t - BC_LEX_1st_op); l = bc_parse_op_PREC(t - XC_LEX_1st_op);
if (l >= r && (l != r || !left)) break; if (l >= r && (l != r || !left)) break;
bc_parse_push(p, BC_TOKEN_2_INST(t)); bc_parse_push(p, BC_TOKEN_2_INST(t));
bc_vec_pop(&p->ops); bc_vec_pop(&p->ops);
*nexprs -= (t != BC_LEX_OP_BOOL_NOT && t != BC_LEX_NEG); *nexprs -= (t != BC_LEX_OP_BOOL_NOT && t != XC_LEX_NEG);
} }
bc_vec_push(&p->ops, &type); bc_vec_push(&p->ops, &type);
@ -3756,7 +3757,7 @@ static BC_STATUS zbc_parse_rightParen(BcParse *p, size_t ops_bgn, size_t *nexs)
bc_parse_push(p, BC_TOKEN_2_INST(top)); bc_parse_push(p, BC_TOKEN_2_INST(top));
bc_vec_pop(&p->ops); bc_vec_pop(&p->ops);
*nexs -= (top != BC_LEX_OP_BOOL_NOT && top != BC_LEX_NEG); *nexs -= (top != BC_LEX_OP_BOOL_NOT && top != XC_LEX_NEG);
if (p->ops.len <= ops_bgn) if (p->ops.len <= ops_bgn)
RETURN_STATUS(bc_error_bad_expression()); RETURN_STATUS(bc_error_bad_expression());
@ -4032,13 +4033,13 @@ static BC_STATUS zbc_parse_minus(BcParse *p, BcInst *prev, size_t ops_bgn,
type = rparen || etype == BC_INST_INC_POST || etype == BC_INST_DEC_POST || type = rparen || etype == BC_INST_INC_POST || etype == BC_INST_DEC_POST ||
(etype >= XC_INST_NUM && etype <= XC_INST_SQRT) ? (etype >= XC_INST_NUM && etype <= XC_INST_SQRT) ?
BC_LEX_OP_MINUS : XC_LEX_OP_MINUS :
BC_LEX_NEG; XC_LEX_NEG;
*prev = BC_TOKEN_2_INST(type); *prev = BC_TOKEN_2_INST(type);
// We can just push onto the op stack because this is the largest // We can just push onto the op stack because this is the largest
// precedence operator that gets pushed. Inc/dec does not. // precedence operator that gets pushed. Inc/dec does not.
if (type != BC_LEX_OP_MINUS) if (type != XC_LEX_OP_MINUS)
bc_vec_push(&p->ops, &type); bc_vec_push(&p->ops, &type);
else else
bc_parse_operator(p, type, ops_bgn, nexprs); bc_parse_operator(p, type, ops_bgn, nexprs);
@ -4523,9 +4524,9 @@ static BC_STATUS zbc_parse_stmt_possibly_auto(BcParse *p, bool auto_allowed)
dbg_lex("%s:%d p->l.t.t:%d", __func__, __LINE__, p->l.t.t); dbg_lex("%s:%d p->l.t.t:%d", __func__, __LINE__, p->l.t.t);
switch (p->l.t.t) { switch (p->l.t.t) {
case XC_LEX_OP_MINUS:
case BC_LEX_OP_INC: case BC_LEX_OP_INC:
case BC_LEX_OP_DEC: case BC_LEX_OP_DEC:
case BC_LEX_OP_MINUS:
case BC_LEX_OP_BOOL_NOT: case BC_LEX_OP_BOOL_NOT:
case BC_LEX_LPAREN: case BC_LEX_LPAREN:
case BC_LEX_NAME: case BC_LEX_NAME:
@ -4642,7 +4643,7 @@ static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags)
s = zbc_parse_incdec(p, &prev, &paren_expr, &nexprs, flags); s = zbc_parse_incdec(p, &prev, &paren_expr, &nexprs, flags);
rprn = get_token = bin_last = false; rprn = get_token = bin_last = false;
break; break;
case BC_LEX_OP_MINUS: case XC_LEX_OP_MINUS:
s = zbc_parse_minus(p, &prev, ops_bgn, rprn, &nexprs); s = zbc_parse_minus(p, &prev, ops_bgn, rprn, &nexprs);
rprn = get_token = false; rprn = get_token = false;
bin_last = prev == XC_INST_MINUS; bin_last = prev == XC_INST_MINUS;
@ -4665,17 +4666,17 @@ static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags)
break; break;
} }
// Fallthrough. // Fallthrough.
case BC_LEX_OP_POWER: case XC_LEX_OP_POWER:
case BC_LEX_OP_MULTIPLY: case XC_LEX_OP_MULTIPLY:
case BC_LEX_OP_DIVIDE: case XC_LEX_OP_DIVIDE:
case BC_LEX_OP_MODULUS: case XC_LEX_OP_MODULUS:
case BC_LEX_OP_PLUS: case XC_LEX_OP_PLUS:
case BC_LEX_OP_REL_EQ: case XC_LEX_OP_REL_EQ:
case BC_LEX_OP_REL_LE: case XC_LEX_OP_REL_LE:
case BC_LEX_OP_REL_GE: case XC_LEX_OP_REL_GE:
case BC_LEX_OP_REL_NE: case XC_LEX_OP_REL_NE:
case BC_LEX_OP_REL_LT: case XC_LEX_OP_REL_LT:
case BC_LEX_OP_REL_GT: case XC_LEX_OP_REL_GT:
case BC_LEX_OP_BOOL_NOT: case BC_LEX_OP_BOOL_NOT:
case BC_LEX_OP_BOOL_OR: case BC_LEX_OP_BOOL_OR:
case BC_LEX_OP_BOOL_AND: case BC_LEX_OP_BOOL_AND:
@ -4684,12 +4685,12 @@ static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags)
) { ) {
return bc_error_bad_expression(); return bc_error_bad_expression();
} }
nrelops += t >= BC_LEX_OP_REL_EQ && t <= BC_LEX_OP_REL_GT; nrelops += (t >= XC_LEX_OP_REL_EQ && t <= XC_LEX_OP_REL_GT);
prev = BC_TOKEN_2_INST(t); prev = BC_TOKEN_2_INST(t);
bc_parse_operator(p, t, ops_bgn, &nexprs); bc_parse_operator(p, t, ops_bgn, &nexprs);
s = zbc_lex_next(&p->l); s = zbc_lex_next(&p->l);
rprn = get_token = false; rprn = get_token = false;
bin_last = t != BC_LEX_OP_BOOL_NOT; bin_last = (t != BC_LEX_OP_BOOL_NOT);
break; break;
case BC_LEX_LPAREN: case BC_LEX_LPAREN:
if (BC_PARSE_LEAF(prev, rprn)) if (BC_PARSE_LEAF(prev, rprn))
@ -4793,7 +4794,7 @@ static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags)
bc_parse_push(p, BC_TOKEN_2_INST(top)); bc_parse_push(p, BC_TOKEN_2_INST(top));
nexprs -= (top != BC_LEX_OP_BOOL_NOT && top != BC_LEX_NEG); nexprs -= (top != BC_LEX_OP_BOOL_NOT && top != XC_LEX_NEG);
bc_vec_pop(&p->ops); bc_vec_pop(&p->ops);
} }
@ -4912,14 +4913,14 @@ static BC_STATUS zdc_parse_token(BcParse *p, BcLexType t)
s = BC_STATUS_SUCCESS; s = BC_STATUS_SUCCESS;
get_token = true; get_token = true;
switch (t) { switch (t) {
case BC_LEX_OP_REL_EQ: case XC_LEX_OP_REL_EQ:
case BC_LEX_OP_REL_LE: case XC_LEX_OP_REL_LE:
case BC_LEX_OP_REL_GE: case XC_LEX_OP_REL_GE:
case BC_LEX_OP_REL_NE: case XC_LEX_OP_REL_NE:
case BC_LEX_OP_REL_LT: case XC_LEX_OP_REL_LT:
case BC_LEX_OP_REL_GT: case XC_LEX_OP_REL_GT:
dbg_lex("%s:%d LEX_OP_REL_xyz", __func__, __LINE__); dbg_lex("%s:%d LEX_OP_REL_xyz", __func__, __LINE__);
s = zdc_parse_cond(p, t - BC_LEX_OP_REL_EQ + XC_INST_REL_EQ); s = zdc_parse_cond(p, t - XC_LEX_OP_REL_EQ + XC_INST_REL_EQ);
get_token = false; get_token = false;
break; break;
case BC_LEX_SCOLON: case BC_LEX_SCOLON:
@ -4931,7 +4932,7 @@ static BC_STATUS zdc_parse_token(BcParse *p, BcLexType t)
dbg_lex("%s:%d LEX_STR", __func__, __LINE__); dbg_lex("%s:%d LEX_STR", __func__, __LINE__);
dc_parse_string(p); dc_parse_string(p);
break; break;
case BC_LEX_NEG: case XC_LEX_NEG:
dbg_lex("%s:%d LEX_NEG", __func__, __LINE__); dbg_lex("%s:%d LEX_NEG", __func__, __LINE__);
s = zbc_lex_next(&p->l); s = zbc_lex_next(&p->l);
if (s) RETURN_STATUS(s); if (s) RETURN_STATUS(s);