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

bc: POSIX error/warn functions can be 'z' functions too

Browse Source 
In non-interactive config, they either return 'success', or do not return.

function                                             old     new   delta
zbc_posix_error_fmt                                   41      39      -2
bc_parse_expr_empty_ok                              1751    1744      -7
zbc_parse_stmt_possibly_auto                        1322    1314      -8
------------------------------------------------------------------------------
(add/remove: 5/5 grow/shrink: 0/2 up/down: 118/-135)          Total: -17 bytes

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
This commit is contained in:
Denys Vlasenko 2018-12-24 18:11:41 +01:00
parent 65b6fe09c4
commit 79587cb442
1 changed files with 42 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
miscutils/bc.c
View File

@ -962,13 +962,13 @@ static NOINLINE ERRORFUNC int bc_error_fmt(const char *fmt, ...)
}
#if ENABLE_BC
static NOINLINE int bc_posix_error_fmt(const char *fmt, ...)
static NOINLINE BC_STATUS zbc_posix_error_fmt(const char *fmt, ...)
{
va_list p;
// Are non-POSIX constructs totally ok?
if (!(option_mask32 & (BC_FLAG_S|BC_FLAG_W)))
return BC_STATUS_SUCCESS; // yes
RETURN_STATUS(BC_STATUS_SUCCESS); // yes
va_start(p, fmt);
bc_verror_msg(fmt, p);
@ -976,11 +976,13 @@ static NOINLINE int bc_posix_error_fmt(const char *fmt, ...)
// Do we treat non-POSIX constructs as errors?
if (!(option_mask32 & BC_FLAG_S))
return BC_STATUS_SUCCESS; // no, it's a warning
RETURN_STATUS(BC_STATUS_SUCCESS); // no, it's a warning
if (ENABLE_FEATURE_CLEAN_UP || G_ttyin)
return BC_STATUS_FAILURE;
RETURN_STATUS(BC_STATUS_FAILURE);
exit(1);
}
#define zbc_posix_error_fmt(...) (zbc_posix_error_fmt(__VA_ARGS__) COMMA_SUCCESS)
#endif
// We use error functions with "return bc_error(FMT[, PARAMS])" idiom.
@ -1015,22 +1017,26 @@ static ERRORFUNC int bc_error_variable_is_wrong_type(void)
IF_ERROR_RETURN_POSSIBLE(return) bc_error("variable is wrong type");
}
#if ENABLE_BC
static int bc_POSIX_requires(const char *msg)
static BC_STATUS zbc_POSIX_requires(const char *msg)
{
return bc_posix_error_fmt("POSIX requires %s", msg);
RETURN_STATUS(zbc_posix_error_fmt("POSIX requires %s", msg));
}
static int bc_POSIX_does_not_allow(const char *msg)
#define zbc_POSIX_requires(...) (zbc_POSIX_requires(__VA_ARGS__) COMMA_SUCCESS)
static BC_STATUS zbc_POSIX_does_not_allow(const char *msg)
{
return bc_posix_error_fmt("%s%s", "POSIX does not allow ", msg);
RETURN_STATUS(zbc_posix_error_fmt("%s%s", "POSIX does not allow ", msg));
}
static int bc_POSIX_does_not_allow_bool_ops_this_is_bad(const char *msg)
#define zbc_POSIX_does_not_allow(...) (zbc_POSIX_does_not_allow(__VA_ARGS__) COMMA_SUCCESS)
static BC_STATUS zbc_POSIX_does_not_allow_bool_ops_this_is_bad(const char *msg)
{
return bc_posix_error_fmt("%s%s %s", "POSIX does not allow ", "boolean operators; the following is bad:", msg);
RETURN_STATUS(zbc_posix_error_fmt("%s%s %s", "POSIX does not allow ", "boolean operators; the following is bad:", msg));
}
static int bc_POSIX_does_not_allow_empty_X_expression_in_for(const char *msg)
#define zbc_POSIX_does_not_allow_bool_ops_this_is_bad(...) (zbc_POSIX_does_not_allow_bool_ops_this_is_bad(__VA_ARGS__) COMMA_SUCCESS)
static BC_STATUS zbc_POSIX_does_not_allow_empty_X_expression_in_for(const char *msg)
{
return bc_posix_error_fmt("%san empty %s expression in a for loop", "POSIX does not allow ", msg);
RETURN_STATUS(zbc_posix_error_fmt("%san empty %s expression in a for loop", "POSIX does not allow ", msg));
}
#define zbc_POSIX_does_not_allow_empty_X_expression_in_for(...) (zbc_POSIX_does_not_allow_empty_X_expression_in_for(__VA_ARGS__) COMMA_SUCCESS)
#endif
static void bc_vec_grow(BcVec *v, size_t n)
@ -3054,8 +3060,8 @@ static BC_STATUS zbc_lex_identifier(BcLex *l)
continue; // "ifz" does not match "if" keyword, "if." does
l->t.t = BC_LEX_KEY_1st_keyword + i;
if (!bc_lex_kws_POSIX(i)) {
s = bc_posix_error_fmt("%sthe '%.8s' keyword", "POSIX does not allow ", bc_lex_kws[i].name8);
IF_ERROR_RETURN_POSSIBLE(if (s) RETURN_STATUS(s));
s = zbc_posix_error_fmt("%sthe '%.8s' keyword", "POSIX does not allow ", bc_lex_kws[i].name8);
if (s) RETURN_STATUS(s);
}
// We minus 1 because the index has already been incremented.
@ -3072,7 +3078,7 @@ static BC_STATUS zbc_lex_identifier(BcLex *l)
// bc: POSIX only allows one character names; the following is bad: 'qwe=1
// '
unsigned len = strchrnul(buf, '\n') - buf;
s = bc_posix_error_fmt("POSIX only allows one character names; the following is bad: '%.*s'", len, buf);
s = zbc_posix_error_fmt("POSIX only allows one character names; the following is bad: '%.*s'", len, buf);
}
RETURN_STATUS(s);
@ -3184,16 +3190,16 @@ static BC_STATUS zbc_lex_token(BcLex *l)
case '!':
bc_lex_assign(l, XC_LEX_OP_REL_NE, 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("!");
IF_ERROR_RETURN_POSSIBLE(if (s) RETURN_STATUS(s));
s = zbc_POSIX_does_not_allow_bool_ops_this_is_bad("!");
if (s) RETURN_STATUS(s);
}
break;
case '"':
s = zbc_lex_string(l);
break;
case '#':
s = bc_POSIX_does_not_allow("'#' script comments");
IF_ERROR_RETURN_POSSIBLE(if (s) RETURN_STATUS(s));
s = zbc_POSIX_does_not_allow("'#' script comments");
if (s) RETURN_STATUS(s);
bc_lex_lineComment(l);
break;
case '%':
@ -3202,8 +3208,8 @@ static BC_STATUS zbc_lex_token(BcLex *l)
case '&':
c2 = l->buf[l->i];
if (c2 == '&') {
s = bc_POSIX_does_not_allow_bool_ops_this_is_bad("&&");
IF_ERROR_RETURN_POSSIBLE(if (s) RETURN_STATUS(s));
s = zbc_POSIX_does_not_allow_bool_ops_this_is_bad("&&");
if (s) RETURN_STATUS(s);
++l->i;
l->t.t = BC_LEX_OP_BOOL_AND;
} else {
@ -3242,7 +3248,7 @@ static BC_STATUS zbc_lex_token(BcLex *l)
s = zbc_lex_number(l, c);
else {
l->t.t = BC_LEX_KEY_LAST;
s = bc_POSIX_does_not_allow("a period ('.') as a shortcut for the last result");
s = zbc_POSIX_does_not_allow("a period ('.') as a shortcut for the last result");
}
break;
case '/':
@ -3331,8 +3337,8 @@ static BC_STATUS zbc_lex_token(BcLex *l)
case '|':
c2 = l->buf[l->i];
if (c2 == '|') {
s = bc_POSIX_does_not_allow_bool_ops_this_is_bad("||");
IF_ERROR_RETURN_POSSIBLE(if (s) RETURN_STATUS(s));
s = zbc_POSIX_does_not_allow_bool_ops_this_is_bad("||");
if (s) RETURN_STATUS(s);
++l->i;
l->t.t = BC_LEX_OP_BOOL_OR;
} else {
@ -4116,8 +4122,8 @@ static BC_STATUS zbc_parse_return(BcParse *p)
if (s) RETURN_STATUS(s);
if (!paren || p->l.t.last != BC_LEX_RPAREN) {
s = bc_POSIX_requires("parentheses around return expressions");
IF_ERROR_RETURN_POSSIBLE(if (s) RETURN_STATUS(s));
s = zbc_POSIX_requires("parentheses around return expressions");
if (s) RETURN_STATUS(s);
}
bc_parse_push(p, XC_INST_RET);
@ -4243,8 +4249,8 @@ static BC_STATUS zbc_parse_for(BcParse *p)
bc_parse_push(p, XC_INST_POP);
if (s) RETURN_STATUS(s);
} else {
s = bc_POSIX_does_not_allow_empty_X_expression_in_for("init");
IF_ERROR_RETURN_POSSIBLE(if (s) RETURN_STATUS(s);)
s = zbc_POSIX_does_not_allow_empty_X_expression_in_for("init");
if (s) RETURN_STATUS(s);
}
if (p->l.t.t != BC_LEX_SCOLON) RETURN_STATUS(bc_error_bad_token());
@ -4264,7 +4270,7 @@ static BC_STATUS zbc_parse_for(BcParse *p)
// which has no string requirement.
bc_vec_string(&p->l.t.v, 1, "1");
bc_parse_pushNUM(p);
s = bc_POSIX_does_not_allow_empty_X_expression_in_for("condition");
s = zbc_POSIX_does_not_allow_empty_X_expression_in_for("condition");
}
if (s) RETURN_STATUS(s);
@ -4285,8 +4291,8 @@ static BC_STATUS zbc_parse_for(BcParse *p)
if (p->l.t.t != BC_LEX_RPAREN) RETURN_STATUS(bc_error_bad_token());
bc_parse_push(p, XC_INST_POP);
} else {
s = bc_POSIX_does_not_allow_empty_X_expression_in_for("update");
IF_ERROR_RETURN_POSSIBLE(if (s) RETURN_STATUS(s);)
s = zbc_POSIX_does_not_allow_empty_X_expression_in_for("update");
if (s) RETURN_STATUS(s);
}
bc_parse_pushJUMP(p, cond_idx);
@ -4421,7 +4427,7 @@ static BC_STATUS zbc_parse_funcdef(BcParse *p)
if (s) RETURN_STATUS(s);
if (p->l.t.t != BC_LEX_LBRACE)
s = bc_POSIX_requires("the left brace be on the same line as the function header");
s = zbc_POSIX_requires("the left brace be on the same line as the function header");
// Prevent "define z()<newline>" from being interpreted as function with empty stmt as body
s = zbc_lex_skip_if_at_NLINE(&p->l);
@ -4824,11 +4830,11 @@ static BcStatus bc_parse_expr_empty_ok(BcParse *p, uint8_t flags)
return bc_error_bad_expression();
if (!(flags & BC_PARSE_REL) && nrelops) {
s = bc_POSIX_does_not_allow("comparison operators outside if or loops");
IF_ERROR_RETURN_POSSIBLE(if (s) return s);
s = zbc_POSIX_does_not_allow("comparison operators outside if or loops");
if (s) return s;
} else if ((flags & BC_PARSE_REL) && nrelops > 1) {
s = bc_POSIX_requires("exactly one comparison operator per condition");
IF_ERROR_RETURN_POSSIBLE(if (s) return s);
s = zbc_POSIX_requires("exactly one comparison operator per condition");
if (s) return s;
}
if (flags & BC_PARSE_PRINT) {