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>

1 files changed, 46 insertions, 41 deletions

diff --git a/miscutils/bc.c b/miscutils/bc.c
index c59d5a2b5..c5288102d 100644
--- 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);