150. 逆波兰表达式求值

typedef int Item;
typedef struct stack_type* Stack;

struct node                   
{
	Item val;
	struct node* next;
};
struct stack_type             
{
	struct node* top;
};

static void terminate(const char* message)
{
	printf("%s\n", message);
	exit(EXIT_FAILURE);
}

bool is_empty(Stack s)
{
	if (s->top == NULL)
	{
		return true;
	}
	else
	{
		return false;
	}
}

Stack create(void)
{
	Stack s = malloc(sizeof(struct stack_type));
	if (s == NULL)
	{
		printf("Error: malloc failed in create.\n");
		exit(EXIT_FAILURE);
	}

	s->top = NULL;
	return s;                      
}

void push(Stack s, Item n)
{
	struct node* new_node = malloc(sizeof(struct node));
	if (new_node == NULL)
	{
		terminate("Error: malloc failed in push.");
	}

	new_node->val = n;
	new_node->next = s->top;
	s->top = new_node;
}

Item pop(Stack s)
{
	struct node* old_top;
	Item n;

	if (is_empty(s) == true)
	{
		terminate("Error in pop: stack is empty.");
	}

	old_top = s->top;
	n = old_top->val;
	s->top = old_top->next;
	free(old_top);
	return n;
}

int top(Stack s)
{
	return s->top->val;
}

bool is_number(const char* token)
{
	if (strlen(token) == 1)
	{
		if (token[0] == '+' || token[0] == '-' || token[0] == '*' || token[0] == '/')
		{
			return false;
		}
	}

	return true;
}

int evalRPN(char** tokens, int tokensSize)
{
	Stack s = create();

	for (int i = 0; i < tokensSize; i++)
	{
		char* token = tokens[i];

		if (is_number(token) == true)
		{
			push(s, atoi(token));
		}
		else
		{
			int number1 = pop(s);
			int number2 = pop(s);
			int number3;

			switch (token[0])
			{
			case '+':
				number3 = number2 + number1;
				break;
			case '-':
				number3 = number2 - number1;
				break;
			case '*':
				number3 = number2 * number1;
				break;
			case '/':
				number3 = number2 / number1;
				break;
			}
			push(s, number3);
		}
	}

	return top(s);
}