Reverse Polish Notation in C with errors

Question

I need help implementing my code. Here is the code in C. My assignment is to create a program for reverse polish notation. Here is what I have so far. Several Errors I see are "EXE_BAD_ACCESS(code=1, address=0x32)" Any help would be of great use.

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>

typedef struct node
{
    int datum;
    int isOperator;
    struct node* left;
    struct node* right;
}*Node;

Node BuildTree(char** argv, int* index);
int isOperator(char ch);
int isadd(int);
int evaluate(Node);
void infix(Node, int);

int main(int argc, char* argv[])
{
    int i = 9; //argc - 1;
    Node tree = NULL;

    char* debugList[] = {NULL,"2","9","+","5","-", "6", "D", "3", "X"};

    tree = BuildTree(debugList, & i);
    infix(tree, 43);

    printf("\n%d", evaluate(tree));
    return 0;
}

Node BuildTree(char** argv, int* index)
{
    Node node;
    if (*index < 1)
        return NULL;

    if(isOperator(argv[*index][0]))
    {
        //insert to the right
        node = (Node) malloc(sizeof(Node));
        node -> datum = (int) argv[*index][0];
        (*index)--;
        node -> right = BuildTree(argv, index);
        node -> left = BuildTree(argv, index);
        node -> isOperator = 1;
        return node;
    }
    else
    {
        node = (Node) malloc(sizeof(Node));
        node -> right = NULL;
        node -> left = NULL;
        node -> datum = (int) argv[*index][0];
        node -> isOperator = 0;
        (*index)--;
        return node;
    }
}
// Return true if ch is a operator, otherwise false
int isOperator(char ch)
{
    if (ch == '+' || ch == '-' || ch == 'D' || ch == 'X')
        return 1;

    else
        return 0;
}

void infix(Node node, int c){
    if(node == NULL)
        return;
    else if (isadd(node -> datum) && !isadd(c)){
        printf("(");
        infix(node -> left, node -> datum);
        printf("%c", (char) node -> datum);
        infix(node -> right, node -> datum);
        printf(")");
    }
    else {
        infix(node -> left, node -> datum);
        printf("%c", (char) node -> datum);
        infix(node -> right, node -> datum);
    }
}

int isadd(int c)
{
    if(c == 43 || c == 45)
        return 1;
    else
        return 0;
}

int evaluate(Node node)
{
    if(node -> isOperator)
    {
        switch(node -> datum)
        {
            case 43:
                return evaluate(node -> left) + evaluate(node -> right);
            case 45:
                return evaluate(node -> left) - evaluate(node -> right);
            case 68:
                return evaluate(node -> left) / evaluate(node -> right);
            case 88:
                return evaluate(node -> left) * evaluate(node -> right);
            default :
                return -1;
        }
    }else{
        return node -> datum - 48;
    }
}

The portion I'm getting errors in are here.

int main(int argc, char* argv[])
{
    int i = 9; //argc - 1;
    Node tree = NULL;

    char* debugList[] = {NULL,"2","9","+","5","-", "6", "D", "3", "X"};

    tree = BuildTree(debugList, & i);
    infix(tree, 43);    //EXE_BAD_ACCESS(code=1, address=0x32)

    printf("\n%d", evaluate(tree));
    return 0;
}

And here.

void infix(Node node, int c){
    if(node == NULL)
        return;
    else if (isadd(node -> datum) && !isadd(c)){     //EXE_BAD_ACCESS(code=1, address=0x32)
        printf("(");
        infix(node -> left, node -> datum);          //EXE_BAD_ACCESS(code=1, address=0x32)
        printf("%c", (char) node -> datum);
        infix(node -> right, node -> datum);         //EXE_BAD_ACCESS(code=1, address=0x32)
        printf(")");
    }
    else {
        infix(node -> left, node -> datum);          //EXE_BAD_ACCESS(code=1, address=0x32)
        printf("%c", (char) node -> datum);
        infix(node -> right, node -> datum);         //EXE_BAD_ACCESS(code=1, address=0x32)
    }
}

Answer 1

in your code, change

node = (Node) malloc(sizeof(Node));

to

node = malloc(sizeof(struct node));

Node is of type struct node *.

Hoewver, as pointer out by @WhozCraig, the most portable and robust version of this code should be

node = malloc(sizeof *node);