/*
 * This program builds a linked stack in plain C much as the C++ example.
 * There are many differences, since plain C does not have templates or classes,
 * plus there's a couple of details I'm trying to avoid.  So, we're putting 
 * it all in one program.  Our stack will be of integers, not generic.
 */

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

// Integer stack node.
struct node {
	int data;
	struct node *next;
};

// Represents a stack.
struct stack {
	struct node * head;	// Head of the linked list.
	int size;		// Size of the stack.
};

/*
 * Methods on stack.
 */

// Initialize a new stack.  Call after declaring a stack.
void stack_init(struct stack *stk)
{
	stk->head = NULL;
	stk->size = 0;
}

// Clean up a stack.  This should be called after using a stack to make
// no garbage remains.
void stack_clear(struct stack *stk)
{
	struct node *scan = stk->head;
	while(scan != NULL) {
		struct node *zombie = scan;
		scan = scan->next;
		free(zombie);
	}
	stk->size = 0;
}

// Push the argument item.  
void stack_push(struct stack *stk, int itm) {
	// Create the node and fill it in.
	struct node *newnode = malloc(sizeof (struct node));
	newnode->data = itm;
	newnode->next = stk->head;

	// Add the node to the stack.
	stk->head = newnode;
	++stk->size;
}

// Pop the argument item, and return it.  Return 0 if the stack is empty.
// If zero is a valid data item, you should probably use the empty method
// before you pop.
int stack_pop(struct stack *stk) {
	// Bail on empty.
	if(stk->head == NULL) return 0;

	// Remove the node from the list.
	struct node *zombie = stk->head;
	stk->head = stk->head->next;
	--stk->size;

	// Extract the data and free the node.
	int itm = zombie->data;
	free(zombie);

	return itm;
}

// Tell if empty.
int stack_empty(struct stack *stk) {
	return stk->head == NULL;
}
	
// Report the size
int stack_size(struct stack *stk) {
	return stk->size;
}
	
int main()
{
	// Stack of integers.
	struct stack is;
	stack_init(&is);

	// Read the input.
	char op;
	while(scanf(" %c", &op) == 1) {
		// See what we got.
		if(op == '.') {
			// Halt char.
			break;
		} else if(isdigit(op)) {
			// Digit.  Unget it, read the number, and push it
			// on the stack.
			ungetc(op, stdin);
			int val;
			scanf("%d", &val);
			stack_push(&is, val);
			continue;
		} else if(strchr("+-*/", op) != NULL) {
			// Operator, pop the operands.
			if(stack_empty(&is)) break;
			int b = stack_pop(&is);
			if(stack_empty(&is)) break;
			int a = stack_pop(&is);

			// Push the operation result in place of the operands.
			switch(op) {
			case '+':
				stack_push(&is,a+b);
				break;
			case '-':
				stack_push(&is,a-b);
				break;
			case '*':
				stack_push(&is,a*b);
				break;
			case '/':
				stack_push(&is,a/b);
				break;
			}
		} else {
			// Just what it says.
			printf("Bad char %c.\n", op);
		}
	}

	// If there's a result, print it.  If the stack is empty, just
	// whine about it.
	if(!stack_empty(&is))
		printf("Value: %d\n", stack_pop(&is));

	printf("Stack has %d elements at exit.\n", stack_size(&is));
	stack_clear(&is);
}