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

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>

diff --git a/miscutils/bc.c b/miscutils/bc.c
index 4fac2c99a092080b8cbb760aa70d4bf5f2f64be5..12bc80b3ee1c0122970338dd9f7da44f2f559041 100644 (file)
--- a/miscutils/bc.c
+++ b/miscutils/bc.c
@@ -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) {