error signal(SIGABRT) raised in C program - c

Question

Couldn't understand why my program is producing an error signal.
#include<stdio.h>
#include<stdlib.h>
struct Node{
int data;
struct Node *next;
};
int MAX_SIZE = 1;
char stack[1];
int top = -1;
int isempty() {
if(top == -1)return 1;
else return 0;
}
int isfull() {
if(top == 0)return 1;
else return 0;
}
int pop() {
int data;
if(!isempty()) {
data = stack[top];
top = top - 1;
return data;
} else {
printf("Could not retrieve data, Stack is empty.\n");
}
}
void push(int data) {
if(!isfull()) {
top = top + 1;
stack[top] = data;
} else {
printf("Could not insert data, Stack is full.\n");
}
}
struct Node* newNode(int d){
struct Node *temp = (struct Node*)malloc(sizeof(struct Node));
temp->data = d;
temp->next = NULL;
return temp;
}
struct Node* reverse(struct Node* head){
//reverses the linked list and returns the pointer pointing to the first node of the reversed linked list.
struct Node *prev = NULL, *curr = head;
while (curr) {
struct Node* temp = curr->next;
curr->next = prev;
prev = curr;
curr = temp;
free(temp);
}
head = prev;
return head;
}
struct Node* addition(struct Node* first, struct Node* second){
struct Node *rev1, *rev2;
struct Node *res = NULL, *revres = NULL;
struct Node *temp, *prev = NULL;
int carry = 0, sum;
rev1 = reverse(first);
rev2 = reverse(second);
while (rev1 != NULL || rev2 != NULL) {
sum = carry + (rev1 ? rev1->data : 0) + (rev2 ? rev2->data : 0);
carry = (sum >= 1000) ? 1 : 0;
sum = sum % 1000;
temp = newNode(sum);
if (res == NULL)
res = temp;
else
prev->next = temp;
prev = temp;
if (rev1)
rev1 = rev1->next;
if (rev2)
rev2 = rev2->next;
}
if (carry > 0){
struct Node *new = newNode(carry);
temp->next = new;
free(new);
}
revres = reverse(res);
while (revres->data == 0 && revres->next) {
struct Node* temp = revres;
revres = revres->next;
free(temp);
}
return revres;
}
int length_reversal(struct Node** head_ref){
// reverses the given linkedlist in-place and also returns the number of nodes in the list.
struct Node* prev = NULL;
struct Node* current = *head_ref;
struct Node* next;
int len = 0;
while (current != NULL) {
len++;
next = current->next;
current->next = prev;
prev = current;
current = next;
}
*head_ref = prev;
return len;
}
void addData(struct Node** head_ref, int new_data){
struct Node* new_node = newNode(new_data);
new_node->next = (*head_ref);
(*head_ref) = new_node;
free(new_node);
}
struct Node* make_empty_list(int size){
struct Node* head = NULL;
while (size--)
addData(&head, 0);
return head;
}
struct Node* multiplication(struct Node* first, struct Node* second){
int m = length_reversal(&first), n = length_reversal(&second);
struct Node* result = make_empty_list(m + n + 1);
struct Node *second_ptr = second, *result_ptr1 = result, *result_ptr2, *first_ptr;
while (second_ptr) {
int carry = 0;
result_ptr2 = result_ptr1;
first_ptr = first;
while (first_ptr) {
int mul = first_ptr->data * second_ptr->data + carry;
result_ptr2->data += mul % 1000;
carry = (mul / 1000) + (result_ptr2->data / 1000);
result_ptr2->data = result_ptr2->data % 1000;
first_ptr = first_ptr->next;
result_ptr2 = result_ptr2->next;
}
if (carry > 0) {
result_ptr2->data += carry;
}
result_ptr1 = result_ptr1->next;
second_ptr = second_ptr->next;
}
length_reversal(&result);
length_reversal(&first);
length_reversal(&second);
while (result->data == 0 && result->next) {
struct Node* temp = result;
result = result->next;
free(temp);
}
return result;
}
struct Node* input(FILE* fp){
char ch;
int i = 0;
struct Node *result = NULL, *first= NULL;
struct Node *it1 = NULL, *it2 = NULL, *it3 = NULL;
char str[3];
while(EOF != (ch=fgetc(fp)) && ch != '\n'){
if(ch == '=')return it1;
else if(ch == '0'||ch == '1'||ch == '2'||ch == '3'||ch == '4'||ch == '5'||
ch == '6'||ch == '7'||ch == '8'||ch == '9'){
if(i==3){printf("invalid input\n"); return NULL;}
str[i] = ch;
i++;
}
else if(ch == '+'){
push(ch);
}
else if(ch == '*'){
push(ch);
}
else if(ch == '$'){
it3 = newNode(atoi(str));
i = 0;
if(!first){
if(!it1)it1 = it3;
else it2 = it3;
}
else{
first->next = it3;
first = NULL;
}
if(!isempty()){
char c = pop();
if(c == '+'){result = addition(it1, it2); it1 = result; it2 = NULL;}
if(c == '*'){result = multiplication(it1, it2); it1 = result; it2 = NULL;}
}
}
else if(ch == ','){
if(first != NULL){
it3 = newNode(atoi(str));
first->next = it3;
first = first->next;
i=0;
}
else{
if(!it1){
first = newNode(atoi(str));
it1 = first;
i=0;
}
else{
first = newNode(atoi(str));
it2 = first;
i=0;
}
}
}
else if(ch == ' ') continue;
else {
printf("Invalid input");
return NULL;
}
}
return it1;
}
void output(FILE *fout, struct Node* list) {
struct Node *temp;
for (temp = list; temp->next != NULL; temp = temp->next)
fprintf (fout, "%03d,", temp->data);
fprintf(fout, "%03d$", temp->data);
fprintf (fout, "\n");
}
int main(){
FILE *fp;
fp = fopen("input_txt.txt", "r");
char c;
while(EOF != (c=getc(fp)) && c != '='){
ungetc(c, fp);
struct Node* res = input(fp);
if(res){
output(stdout, res);
}
}
return 0;
}
I have tried using a debugger to understand the problem, but no luck there.
The problem was described as
"""You will represent an arbitrarily large unsigned integer I by a singly linked list of its DIGITs d1 ,
d2 , ... , dm , where d1 is the least significant DIGIT of I and dm is the most significant DIGIT of I.
Assume that the DIGITs are from a number system with base 1,00010. Implement each DIGIT as a C
unsigned int with DIGIT values in [0, 999].
a) Write C functions to perform the arithmetic operations addition and multiplication of large
unsigned integers.
b) Write a C function to input a large unsigned integer from stdin as comma separated DIGITs
in decimal, ordered on decreasing significance and terminated by a $
c) Write a C function to output a large unsigned integer to stdout in the format used for input,
showing each DIGIT as 3 decimal digits.
d) Write a C main() which will repeatedly accept (from stdin) and evaluate, large integer infix
expressions on large unsigned integer constants using the operators “+” (addition) and “*”
(multiplication). An expression is terminated by “=”. On encountering an “=”, the value of
the expression is to be printed to stdout. Evaluate expressions from left to right. The main() loop
should terminate when it receives an empty expression (terminated by =)."""
This was my assignment question for which the deadline was over a week ago and I couldn't figure out the problem with my code.
For example, the 2 line input
111,041,411,111,011$ + 222,222$ * 003$ =
results in the output
333,124,233,999,699$