Memory leak after shrinkage with realloc - c

Question

I don't know, what has happened to the formatting, but I can't mark selected chunks as code with Ctrl+K. SORRY FOR THAT
I use gcc with flags as a compiler and run valgrind with:
valgrind --leak-check=full -q --error-exitcode=1
I am trying ti write a calculator for addition and subtraction. The numbers are stored in an array of the fixed size, written in 10000 numerical system: each element of array has an allocated memory for four digits:
#include <stdlib.h>
#include <limits.h>
#define ELEMENTS 8
#define NUM_INT 4 //Number of digits
typedef struct numb {
int* digits;
int how_many; //How many cells with 4 digits
} numb;
void create(numb** tab) {
*tab = realloc(*tab, ELEMENTS * sizeof(**tab));
for (int i = 0; i < ELEMENTS; i++) {
numb cell;
cell.digits = calloc(NUM_INT, sizeof (*cell.digits));
cell.how_many = 1;
(*tab)[i] = cell; // Put in original array.
}
(*tab)[ELEMENTS-2].digits[0] = -1; // Don't bother about the values
(*tab)[ELEMENTS-1].digits[0] = 1;
}
The valgrind shows a problem in two functions:
addition of two structures
//help function
int simple_add(int w, int m, int* p) {
int number;
int result = w + m + *p;
if (result >= 10000) {
*p = division(result); //division by multiplication while p*i<=10000
number = result - 10000*(*p);
} else {
number = result;
*p = 0;
}
return number;
}
//problematic
void add(numb* a, numb* b) {
numb *big;
numb *small;
if (a->how_many != b->how_many) {
small = min(a, b); //simple min and max functions, not written for clarity
big = max(a, b);
} else {
big = a;
small = b;
}
int left = 0;
int i = 0;
while (i < small->how_many) {
big->digits[i] = simple_add(big->digits[i], small->digits[i], &left);
i++;
}
while (left != 0) {
if (i == big->how_many) {
if ((size_t)i*NUM_INT*sizeof(int) >= sizeof(big->digits)) {
int size;
if ((size_t)i*NUM_INT*sizeof(int) + 2 >= INT_MAX) size = INT_MAX-1;
else size = (size_t)i*NUM_INT*sizeof(int) + 2;
big->digits = realloc(big->digits, size);
}
big->digits[i++] = left;
big->how_many++;
pom = 0;
} else {
big->digits[i] = simple_add(big->digits[i], 0, &left);
i++;
}
}
*a = *big;
}
set the value to 0
void clear(numb* a) {
a->digits = realloc(a->digits, NUM_INT*sizeof(int));
a->digits[0] = 0;
a->how_many = 1;
}
For small numbers it works fine for valgrind, without errors. However, as the values in test files get bigger, I get stackovflow/segmentation fault:
I present three types of errors from valgrind to reduce the amount of clutter:
Just before segmenation fault:
Invalid free() / delete / delete[] / realloc()
==13932== at 0x4837D7B: realloc (vg_replace_malloc.c:826)
==13932== by 0x10A084: clear (address)
==13932== by 0x10A298: interpreter (in address)
==13932== by 0x10A375: game (in address)
==13932== by 0x10A436: main (in address)
Address 0x4a3ebc0 is 0 bytes inside a block of size 34 free'd
==13932== at 0x4837D7B: realloc (vg_replace_malloc.c:826)
==13932== by 0x10A084: clear (in /address)
==13932== by 0x10A298: interpreter (in address)
==13932== by 0x10A375: game (in /address)
==13932== by 0x10A436: main (in /address)
==13932== Block was alloc'd at ==13932== at 0x4837D7B: realloc (vg_replace_malloc.c:826) ==13932== by 0x10943A: add (in /address)
==13932== by 0x10A1F8: interpreter (in address)
==13932== by 0x10A375: game (in address)
Invalid write of size 4
==13932== at 0x10A096: clear (in /address)
==13932== by 0x10A298: interpreter (in /address)
==13932== by 0x10A375: game (in /address)
==13932== by 0x10A436: main (in /address)
==13932== Address 0x0 is not stack'd, malloc'd or (recently) free'd
Mostly this is invalid write or read; invalid free appears only once. I didn't want to clutter the post with the chunk of all messages, but if you need to, I can paste it.
Array from create is freed after the program.
Please, I would appreciate your suggestions. For small numbers it works, thus it is harder for me to track what is going on if we go to big ones. The numbers are supposed to be <INT_MAX
EDIT
I have run some tests and have found error in add and clear, but I don't know, how to fix it yet.
Issue:
I have to variables and add the using add()
the first one is zero, thus it has only one cell [0] ::= num a
the second one is over 10000 (for example: 16547), thus it has two cells [6547][1] ::= num b
**Where I have found the problem"
add b to a; a= 0; b = 16547
clear a //supposed to be 0
print out b <- I got an error
==52293== Invalid read of size 4
==52293== at 0x10CC75: print_a_number (call5.c:355)
==52293== by 0x10D027: interpreter (call5.c:397)
==52293== by 0x10D35F: rozgrywka (call5.c:453)
==52293== by 0x10D521: main (call5.c:496)
==52293== Address 0x58c6804 is 4 bytes inside a block of size 34 free'd
==52293== at 0x4837D7B: realloc (vg_replace_malloc.c:826)
==52293== by 0x10CD65: clear (call5.c:367)
==52293== by 0x10D215: interpreter (call5.c:426)
==52293== by 0x10D35F: rozgrywka (call5.c:453)
==52293== by 0x10D521: main (call5.c:496)
==52293== Block was alloc'd at
==52293== at 0x4837D7B: realloc (vg_replace_malloc.c:826)
==52293== by 0x10B887: add (call5.c:117)
==52293== by 0x10D115: interpreter (call5.c:406)
==52293== by 0x10D35F: game (call5.c:453)
==52293== by 0x10D521: main (call5.c:496)
As we can remember, clear realloced the size and left the first cell. However, the other cells are freed. It seems as if the second cell was lost [1], but I do not understand that, if I have assigned the value to the pointer *a in add.