Rpn Calculator

#include "rpn.h"
 
int main (void) {
	int type;
	double op1;
	double op2;
	char s[MAXOP];
	allocateStack(10);
	printf("Type h and press enter for help.\n");
	while ((type= getop(s))) {
		switch (type) {
			case NUMBER:
				push (atof(s));
				printStack();
				break;
			case FUNCTION:
				if(strcmp(s,"sin") == 0) {
					push(sin(pop()));
				}
				else if (strcmp(s,"cos") == 0) {
					push(cos(pop()));
				}
				else if (strcmp(s,"tan") == 0) {
					push(tan(pop()));
				}
			        ..............................
				else if (strcmp(s,"!") == 0) {
					op1 = floor(pop());
					for (op2=op1-1; op2>0; op2--) {
						op1 = op1 * op2;
					}
					push(op1);
				}
				printStack();
				break;
			case '+':
				push(pop() + pop());
				printStack();
				break;
			case '*':
				push(pop() * pop());
				printStack();
				break;
			case '-':
				op2 = pop();
				push(pop() - op2);
				printStack();
				break;
			case '^':
				op1 = pop();
				op2 = pop();
				push(pow(op2,op1));
				printStack();
				break;
			case '/':
				op2=pop();
				if(op2 != 0.0)
					push(pop()/op2);
				else
					printf("Zero devisor error, yo");
				printStack();
				break;
			case 'n':
				push(0 - pop());
				printStack();
				break;
			case 'b':
				pop();
				printStack();
				break;
			case '%':
				op1 = pop();
				op2 = pop();
				push(op2-((int)(op2/ op1)*op1));
				printStack();
				break;
			case ' ':
				dup();
				printStack();
				break;
			case 'q':
				exit(0);
				break;
 
			case 's':
				//Swap first 2 elements
				op1 = pop();
				op2 = pop();
				push(op1);
				push(op2);
				printStack();
				break;
			case 'w':
				printf("Stack Size: %d\n", getStackSize());
				break;
			case 'c':
				clearStack();
				printStack();
				break;
			case 'f':
				setClear(1);
				break;
			case 'g':
				setClear(0);
				break;
			case 'h':
				printHelp();
				break;
			default:
				printf("unknown command %s.", s);
				break;
		}
	}
	return 0;
}

#include "rpn.h"
void freeStack(void);
int stackPosition =0;
int stackSize = 0;
double* stack;
int doClear = 1;
int print = 1;
void allocateStack(int size) {
	double* stacknew;
	if(stackSize == 0) {
			//We are allocating the initial stack.
			stacknew = malloc(size * sizeof(double));
	}
	else {
		//We are growing/shrinking the stack
		stacknew = realloc(stack, size * sizeof(double));
		if(stackPosition > size) {
			stackPosition = size;
		}
	}
	if (stacknew == NULL) {
		if (stackSize != 0) {
			free(stack);
		}
		printf("Error: Could not allocate memory for stack of size %d",size);
		exit(1);
	}
	else {
		//Memory allocation succeded
		stack = stacknew;
		stackSize = size;
	}
}
/* push value onto stack */
void push(double newValue) {
        if(stackPosition  < stackSize) { 
                  stack[stackPosition++] = newValue; 
	}
        else { 
                  allocateStack(stackSize+5);
                  stack[stackPosition++] = newValue; 
        }
}
double pop(void) {
 	double value; 	
        if(stackPosition  > 0) {// If there is data on the stack.
		stackPosition--;
		value = stack[stackPosition];
		freeStack();
		return value;
	}
	else {
		printf("error : pop() called, but stack empty");
		return 0.0;
	}
}
void dup(void) {
	if(stackPosition >  0) {// If there is data on the stack.
		push(stack[stackPosition-1]);
	}
}
void clearStack(void) {
	stackPosition = 0;
	freeStack();
}
int getStackSize(void) {
	return stackSize;
}
void setClear(int newDoClear) {
	doClear = newDoClear;
}
void setPrint(int newPrint) {
	print = newPrint;
}
void freeStack(void) {
	if((stackSize - stackPosition) > 15) {
		//Reduce the size of the stack to free some memory.
		allocateStack(stackPosition+5);
	}
}
void printStack(void) {
	int i,position=stackPosition+1;
	if(doClear) {
		clear();
	}
	if(print) {
		for (i=0; i

#include "rpn.h"
int getop(char s[]) {
	int i=0,c,d;
	while ((s[0] = c = getchb()) == ' ' || c =='\t')
		;
	s[1] = '\0';
	if(!isdigit(c) && c != '.' && c != 1 && c != 8) {
		if(c == 33) {
			i=-1;
			while ((s[++i] = d =  getchb()) && (d != 13))
				;
			ungetchb(d);
			s[i] = '\0';
			return FUNCTION;
		}
		return c;
	}
	if (c == 13) {
		return ' ';
	}
	if (c == 8) {
		return 'b';
	}
	if(isdigit(c)) {
		while (isdigit(s[++i] = c = getchb()))
			;
	}
	if (c == '.') {
		while (isdigit(s[++i] = c = getchb()))
			;
	}
	s[i] = '\0';
	if (i > 0) {
		ungetchb(c);
	}
	return NUMBER;
}

#include "rpn.h"
// If using the VC++ compiler, use unbuffered input. Otherwise, use normal buffered input.
// Ideally should write some ncurses code to allow for unbuffered input on unix platforms.
#if defined(_WIN32)
   // Use VC++ input.
	#define INPUT_FUNCTION getche()
#else
	#define INPUT_FUNCTION getchar()
#endif
static int buffer[BUFSIZE];
static int bufPos;
 
int getchb(void) {
	if (bufPos > 0) {
		return buffer[--bufPos];
	}
	else {
		return INPUT_FUNCTION;
	}
}
void ungetchb(int input) {
	if (bufPos < BUFSIZE) {
		if(input != 13 && input != 46) {
			buffer[bufPos++] = input;
		}
	}
	else {
		printf("Input buffer overrun... Not cool, guys!");
	}
}

#include "rpn.h"
void clear(void) {
	//Clear the screen. Hopefully this works on every os, not ANSI compliant.
	if (system("cls")) system("clear");
}
double radToDegrees(double radians) {
	return (radians/PI)*180;
}
double degreesToRad(double degrees) {
	return (degrees/180)*PI;
}