Untitled

#include <stdio.h>


struct integer {
        int* digits;
        int size;
};


struct integer* convert_integer(char* stringInt);
void print(struct integer* p);
struct integer* add(struct integer *p, struct integer *q);
int compare(struct integer *p, struct integer *q);
struct integer* subtract(struct integer *p, struct integer *q);

int main () {

    int number;
    int i;
    int bigger;
    int choice;
    char convert1[200];
    char convert2[200];

    FILE* ofp = fopen("bigint.txt", "r");

    fscanf(ofp, "%d" , &number);

    for (i=0; i<number; i++){

        fscanf(ofp , "%d" , &choice);
        fscanf(ofp , "%s %s" , convert1, convert2);

        struct integer* numone;
        struct integer* numtwo;
        struct integer* addans;
        struct integer* subans;


        numone = convert_integer(convert1);
        numtwo = convert_integer(convert2);

        bigger = compare(numone,numtwo);
        printf("%d\n\n" , bigger);


        if (choice == 1){

            addans = add(numone, numtwo);
            print(numone);
            printf(" + ");
            print(numtwo);
            printf(" = ");
            print(addans);
            printf("\n\n");

        }

        else if (choice == 2){

            subans = subtract(numone, numtwo);
            print(subans);
            printf("\n\n");

        }

        else
            printf("Invaild data");

    }

    /*free(numone->digits);
    free(numtwo->digits);
    free(numone);
    free(numtwo);
    free(addans->digits);
    free(addans);
    free(subans->digits);
    free(subans);*/

    fclose(ofp);

    system ("PAUSE");
    return 0;
}

struct integer* convert_integer(char* stringInt){
    struct integer* number;
    number = (struct integer*) malloc(sizeof (struct integer));
    int n;
    n = strlen(stringInt);
    number->digits = (int*) malloc (n*sizeof(int));
    number->size = n;
    int i;

    for (i=0; i<n; i++){
        number->digits[i] = (int)(stringInt[number->size-1-i] - '0');
    }
    return number;
}

void print(struct integer* p) {
    int i;
    for (i=p->size-1; i >= 0; i--) {
        printf("%d" , p->digits[i]);
    }
}

struct integer* add(struct integer *p, struct integer *q){

    int larger;
    int smaller;


    if(p->size > q->size || p->size == q->size){
        larger = p->size;
        smaller = q->size;
    }
    else {
        larger = q->size;
        smaller = p->size;
    }

    struct integer* answerarray;
    answerarray = (struct integer*) malloc(sizeof (struct integer));
    answerarray->size = larger+1;
    answerarray->digits = (int*) calloc((larger+1), sizeof(int));

    int i;
    int ans;
    int carry = 0;

    for (i=0; i < smaller; i++){

        ans = p->digits[i] + q->digits[i];
        printf("Current answer: %d\n", ans);
        if(carry == 1) {
            ans = ans + 1;
            carry = 0;
        }

        if (ans >= 10){
            ans = ans % 10;
            answerarray->digits[i] = ans;
            carry = 1;
        }
        else {
            answerarray->digits[i] = ans;
        }

    }
    for(i = i - 1; i < larger; i++)
    {
        if (carry == 1){
            answerarray->digits[i] = 1;
        }
        else
        {
            answerarray->digits = (int*)realloc(answerarray->digits, (larger)*sizeof(int));
            answerarray->size = larger;
        }
    }

    return answerarray;
}

int compare(struct integer *p, struct integer *q){


    if(p->size < q->size){
        return -1;
    }

    else if (p->size > q->size){
        return 1;
    }

    else {

        int i;
        for (i = (p->size-1); i >= 0; i--) {

            if(p->digits[i] < q->digits[i]){
                return -1;
            }

            else if (p->digits[i] > q->digits[i]){
                return 1;
            }

        }
    }

     return 0;
}


struct integer* subtract(struct integer *p, struct integer *q){

    int bigger;
    int larger;

    bigger = compare(p, q);

        if (bigger == 1 || bigger == 0){
            larger = p->size;
        }
        else {
            larger = q->size;
        }

    struct integer* answerarray;
    answerarray = (struct integer*) malloc(sizeof (struct integer));
    answerarray->digits = (int*) malloc((larger) * sizeof(int));
    answerarray->size = larger;

    int i;
    int ans;
    int carry = 0;

    for (i=0; i <= larger; i++){

        if (bigger == 1 || bigger == 0){
            ans = p->digits[i] - q->digits[i];
        }
        else {
            ans = q->digits[i] - p->digits[i];
        }

        if(carry == 1) {
            ans = ans - 1;
            carry = 0;
        }

        if (ans <= 0){

            if (bigger == 1 || bigger == 0){
                ans = (p->digits[i] + 10) - q->digits[i];
            }
            else {
                ans = (q->digits[i] +10) - p->digits[i];
            }
            answerarray->digits[i] = ans;
            carry ++;
        }
    }

        if (carry == 1){
        answerarray->digits[answerarray->size-1] = answerarray->digits[answerarray->size-1] - 1;
    }
            if (bigger == 1 || bigger == 0){
                print(p);
                printf(" - ");
                print(q);
                printf(" = ");
            }
            else {
                print(q);
                printf(" - ");
                print(p);
                printf(" = ");
            }

    return answerarray;
}