bc: shrink "dc only" code by dropping unused structure members

function                                             old     new   delta
zbc_program_num                                      979     981      +2
zbc_program_pushArray                                147     145      -2
bc_program_pushVar                                   198     196      -2
bc_program_func                                       17      15      -2
dc_num_printChar                                      24      21      -3
bc_program_retire                                     35      32      -3
bc_program_binOpRetire                                46      43      -3
zdc_program_printStream                              153     148      -5
zbc_program_prep                                      91      86      -5
zbc_program_copyToVar                                300     295      -5
zdc_program_modexp                                   721     715      -6
zbc_program_binOpPrep                                311     305      -6
bc_program_addFunc                                   138     132      -6
bc_num_printNewline                                   51      45      -6
bc_num_printHex                                       67      61      -6
bc_num_printDigits                                   137     131      -6
zdc_program_assignStr                                146     137      -9
bc_program_reset                                      64      55      -9
bc_func_free                                          27       5     -22
bc_parse_free                                         38       8     -30
bc_parse_create                                       92      47     -45
bc_func_init                                          50       5     -45
dc_main                                              691     645     -46
zdc_program_execStr                                  496     442     -54
zbc_program_print                                    677     623     -54
zbc_vm_process                                       204     137     -67
zbc_program_exec                                    4132    4057     -75
------------------------------------------------------------------------------
(add/remove: 0/0 grow/shrink: 1/26 up/down: 2/-522)          Total: -520 bytes
   text	   data	    bss	    dec	    hex	filename
 969767	    485	   7296	 977548	  eea8c	busybox_old
 969210	    485	   7296	 976991	  ee85f	busybox_unstripped

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>

diff --git a/miscutils/bc.c b/miscutils/bc.c
index c59d5a2b5320dbe58a569c8d99aa76bcb9f5beca..c5288102d1d7b8d448578afd6812e3d118533e98 100644 (file)
--- a/miscutils/bc.c
+++ b/miscutils/bc.c
@@ -348,9 +348,9 @@ typedef struct BcId {
 
 typedef struct BcFunc {
        BcVec code;
-       BcVec labels;
-       size_t nparams;
-       BcVec autos;
+       IF_BC(BcVec labels;)
+       IF_BC(BcVec autos;)
+       IF_BC(size_t nparams;)
 } BcFunc;
 
 typedef enum BcResultType {
@@ -385,7 +385,7 @@ typedef struct BcResult {
 typedef struct BcInstPtr {
        size_t func;
        size_t idx;
-       size_t len;
+       IF_BC(size_t len;)
 } BcInstPtr;
 
 // BC_LEX_NEG is not used in lexing; it is only for parsing.
@@ -664,30 +664,29 @@ typedef struct BcLex {
 typedef struct BcParse {
        BcLex l;
 
-       BcVec exits;
-       BcVec conds;
-
-       BcVec ops;
+       IF_BC(BcVec exits;)
+       IF_BC(BcVec conds;)
+       IF_BC(BcVec ops;)
 
        BcFunc *func;
        size_t fidx;
 
-       size_t in_funcdef;
+       IF_BC(size_t in_funcdef;)
 } BcParse;
 
 typedef struct BcProgram {
        size_t len;
-       size_t scale;
+       size_t nchars;
 
+       size_t scale;
        size_t ib_t;
        size_t ob_t;
-       BcNum ob;
 
        BcVec results;
        BcVec exestack;
 
        BcVec fns;
-       BcVec fn_map;
+       BcVec fn_map; //TODO: dc does not need this, its 'functions' are anonynomous (have no names)
 
        BcVec vars;
        BcVec var_map;
@@ -700,11 +699,9 @@ typedef struct BcProgram {
 
        const char *file;
 
-       BcNum last;
        BcNum zero;
-       BcNum one;
-
-       size_t nchars;
+       IF_BC(BcNum one;)
+       IF_BC(BcNum last;)
 } BcProgram;
 
 #define BC_PROG_MAIN (0)
@@ -1616,6 +1613,7 @@ static BC_STATUS zbc_num_shift(BcNum *n, size_t places)
 
 static BC_STATUS zbc_num_inv(BcNum *a, BcNum *b, size_t scale)
 {
+//TODO: nice example of non-allocated BcNum, use in other places as well!
        BcNum one;
        BcDig num[2];
 
@@ -2527,17 +2525,17 @@ static BC_STATUS zbc_func_insert(BcFunc *f, char *name, bool var)
 static void bc_func_init(BcFunc *f)
 {
        bc_char_vec_init(&f->code);
-       bc_vec_init(&f->autos, sizeof(BcId), bc_id_free);
-       bc_vec_init(&f->labels, sizeof(size_t), NULL);
-       f->nparams = 0;
+       IF_BC(bc_vec_init(&f->labels, sizeof(size_t), NULL);)
+       IF_BC(bc_vec_init(&f->autos, sizeof(BcId), bc_id_free);)
+       IF_BC(f->nparams = 0;)
 }
 
 static FAST_FUNC void bc_func_free(void *func)
 {
        BcFunc *f = (BcFunc *) func;
        bc_vec_free(&f->code);
-       bc_vec_free(&f->autos);
-       bc_vec_free(&f->labels);
+       IF_BC(bc_vec_free(&f->labels);)
+       IF_BC(bc_vec_free(&f->autos);)
 }
 
 static void bc_array_expand(BcVec *a, size_t len);
@@ -3566,10 +3564,10 @@ static void bc_program_reset(void)
 static void bc_parse_reset(BcParse *p)
 {
        if (p->fidx != BC_PROG_MAIN) {
-               p->func->nparams = 0;
                bc_vec_pop_all(&p->func->code);
-               bc_vec_pop_all(&p->func->autos);
-               bc_vec_pop_all(&p->func->labels);
+               IF_BC(bc_vec_pop_all(&p->func->labels);)
+               IF_BC(bc_vec_pop_all(&p->func->autos);)
+               IF_BC(p->func->nparams = 0;)
 
                p->fidx = BC_PROG_MAIN;
                p->func = bc_program_func_BC_PROG_MAIN();
@@ -3578,18 +3576,18 @@ static void bc_parse_reset(BcParse *p)
        p->l.i = p->l.len;
        p->l.t.t = BC_LEX_EOF;
 
-       bc_vec_pop_all(&p->exits);
-       bc_vec_pop_all(&p->conds);
-       bc_vec_pop_all(&p->ops);
+       IF_BC(bc_vec_pop_all(&p->exits);)
+       IF_BC(bc_vec_pop_all(&p->conds);)
+       IF_BC(bc_vec_pop_all(&p->ops);)
 
        bc_program_reset();
 }
 
 static void bc_parse_free(BcParse *p)
 {
-       bc_vec_free(&p->exits);
-       bc_vec_free(&p->conds);
-       bc_vec_free(&p->ops);
+       IF_BC(bc_vec_free(&p->exits);)
+       IF_BC(bc_vec_free(&p->conds);)
+       IF_BC(bc_vec_free(&p->ops);)
        bc_lex_free(&p->l);
 }
 
@@ -3598,9 +3596,9 @@ static void bc_parse_create(BcParse *p, size_t fidx)
        memset(p, 0, sizeof(BcParse));
 
        bc_lex_init(&p->l);
-       bc_vec_init(&p->exits, sizeof(size_t), NULL);
-       bc_vec_init(&p->conds, sizeof(size_t), NULL);
-       bc_vec_init(&p->ops, sizeof(BcLexType), NULL);
+       IF_BC(bc_vec_init(&p->exits, sizeof(size_t), NULL);)
+       IF_BC(bc_vec_init(&p->conds, sizeof(size_t), NULL);)
+       IF_BC(bc_vec_init(&p->ops, sizeof(BcLexType), NULL);)
 
        p->fidx = fidx;
        p->func = bc_program_func(fidx);
@@ -5036,12 +5034,17 @@ static BC_STATUS zbc_program_num(BcResult *r, BcNum **num, bool hex)
                                *num = bc_vec_top(v);
                        break;
                }
+#if ENABLE_BC
                case BC_RESULT_LAST:
                        *num = &G.prog.last;
                        break;
                case BC_RESULT_ONE:
                        *num = &G.prog.one;
                        break;
+#endif
+               default:
+                       // Testing the theory that dc does not reach LAST/ONE
+                       bb_error_msg_and_die("BUG:%d", r->t);
        }
 
        RETURN_STATUS(BC_STATUS_SUCCESS);
@@ -5178,7 +5181,7 @@ static BC_STATUS zbc_program_read(void)
 
        ip.func = BC_PROG_READ;
        ip.idx = 0;
-       ip.len = G.prog.results.len;
+       IF_BC(ip.len = G.prog.results.len;)
 
        // Update this pointer, just in case.
        f = bc_program_func(BC_PROG_READ);
@@ -5496,7 +5499,9 @@ static BC_STATUS zbc_program_print(char inst, size_t idx)
 
        if (BC_PROG_NUM(r, num)) {
                s = zbc_num_print(num, !pop);
-               if (!s) bc_num_copy(&G.prog.last, num);
+#if ENABLE_BC
+               if (!s && IS_BC) bc_num_copy(&G.prog.last, num);
+#endif
        } else {
                char *str;
 
@@ -6322,7 +6327,7 @@ static BC_STATUS zdc_program_execStr(char *code, size_t *bgn, bool cond)
        }
 
        ip.idx = 0;
-       ip.len = G.prog.results.len;
+       IF_BC(ip.len = G.prog.results.len;)
        ip.func = fidx;
 
        bc_vec_pop(&G.prog.results);
@@ -6977,7 +6982,7 @@ static void bc_program_free(void)
        bc_vec_free(&G.prog.exestack);
        bc_num_free(&G.prog.last);
        bc_num_free(&G.prog.zero);
-       bc_num_free(&G.prog.one);
+       IF_BC(bc_num_free(&G.prog.one);)
        bc_vec_free(&G.input_buffer);
 }
 
@@ -7001,14 +7006,14 @@ static void bc_program_init(void)
        G.prog.ib_t = 10;
        G.prog.ob_t = 10;
 
-       bc_num_init_DEF_SIZE(&G.prog.last);
-       //bc_num_zero(&G.prog.last); - already is
+       IF_BC(bc_num_init_DEF_SIZE(&G.prog.last);)
+       //IF_BC(bc_num_zero(&G.prog.last);) - already is
 
        bc_num_init_DEF_SIZE(&G.prog.zero);
        //bc_num_zero(&G.prog.zero); - already is
 
-       bc_num_init_DEF_SIZE(&G.prog.one);
-       bc_num_one(&G.prog.one);
+       IF_BC(bc_num_init_DEF_SIZE(&G.prog.one);)
+       IF_BC(bc_num_one(&G.prog.one);)
 
        bc_vec_init(&G.prog.fns, sizeof(BcFunc), bc_func_free);
        bc_vec_init(&G.prog.fn_map, sizeof(BcId), bc_id_free);