#include <stdio.h>
#include <stdlib.h>     /* for atof() */
#include <ctype.h>
#include <math.h>       /* adds access to f(x)'s sin, exp, and pow. */

#define MAXOP  100      /* max size of operand or operator */
#define NUMBER '0'      /* signal that a number was found */
#define MAXVAL 100      /* max depth of val stack */

#define BUFSIZE 100

#define IDENTIFIER 1    /* identifier for maths functions */

char buf[BUFSIZE];      /* buffer for ungetch */
int bufp = 0;           /* next free position in buf */

int sp = 0;             /* next free stack position */
double val[MAXVAL];     /* value stack */

int getops(char []);        /* function protos */
void push(double);
double pop(void);

void printStack(void);
void dupeStack(void);
void swapStack(void);
void clearStack();

void expStack(void);
void pwrStack(void);
void sinStack(void);
void dealWithName(char s[]);

int getch(void);
void ungetch(int);

/* reverse Polish notation calculator */
main()
{
    int type;
    double op2;
    char s[MAXOP];

    printf("To print the top element of the stack type 'p'. \n To duplicate it, type 'd'. \n To swap the top two elements type 's'. \n To clear the stack type 'c'. (Case sensitive)");
    printf("To use exponents, type ! \n to use power, type ~ \n To use sine use # \n");

    while ((type = getops(s)) != EOF)
    {
        switch (type)
        {
            case NUMBER:
                push(atof(s));
                break;

            case IDENTIFIER:
                dealWithName(s);
                break;

            case '+':
                push(pop() + pop());
                break;

            case '*':
                push(pop() * pop());
                break;

            case '-':
                op2 = pop();
                push(pop() - op2);
                break;

            case '/':
                op2 = pop();
                if (op2 != 0.0)
                    push(pop() / op2);
                else
                    printf("error: zero divisor\n");
                break;

            case '%':
                op2 = pop();
                if (op2 != 0.0)
                    push(fmod(pop(), op2));
                else
                    printf("error: zero division\n");

            case 'p': case 'P':
                printStack();
                break;

            case 'd': case 'D':
                dupeStack();
                break;

            case 's': case 'S':
                swapStack();
                break;

            case 'c': case 'C':
                clearStack();
                break;

            case '\n':
                printf("\t%.8g\n", pop());
                break;

            default:
                printf("error: unknown command %s\n", s);
                break;
        }
    }
    return 0;
}

/* push(): push f onto value stack */

void push(double f)
{
    if (sp < MAXVAL)
    {
        val[sp++] = f;
    }

    else
        printf("error: stack full, can't push %g\n", f);
}

/* pop(): pop and return top val from stack */

double pop(void)
{
    if (sp > 0)
    {
        return val[--sp];
    }
    else
    {
        printf("error: stack empty\n");
        return 0.0;
    }
}

/* printStack(): print the first item in the stack */
void printStack(void)
{
    if (sp > 0)
    {
        printf("Top of stack contains: %8g\n", val[sp-1]);
    }
    else
        printf("The stack is empty.\n");
}

/* dupeStack(): duplicate the first item in the stack */
void dupeStack(void)
{
    double temp = pop();
    push(temp);
    push(temp);
}

/* swapStack(): swap the first and second item in the stack */
void swapStack(void)
{
    double temp1 = pop();
    double temp2 = pop();
    push(temp1);
    push(temp2);
}

/* clearStack(): clear the stack empty */
void clearStack()
{
    sp = 0;
}

/* dealWithName(): identify pwr, exp, or sin, and handle accordingly */
void dealWithName(char s[])
{
    double op2;

    if (0 == strcmp(s, "sin"))
    {
        push(sin(pop()));
    }
    else if (0 == strmcp(s, "cos"))
    {
        push(cos(pop()));
    }
    else if (0 == strcmp(s, "exp"))
    {
        push(exp(pop()));
    }
    else if (0 == strcmp(s, "pow"))
    {
        op2 = pop();
        push(pow(pop(), op2));
    }
    else
        printf("%s is not a supported function.\n", s);
}

/* getop(): get next operator or numeric operand */
int getops(char s[])
{
    int i, c;

    while ((s[0] = c = getch()) == ' ' || c == '\t')
        ;

    s[1] = '\0';

    if (!isdigit(c) && c != '.')
    {
        return c;       /* NaN */
    }

    i = 0;

    if (isdigit(c))     /* collect int part */
    {
        while (isdigit(s[++i] = c = getch()))
            ;
    }
    if (c == '.')       /* collect fraction part */
    {
        while (isdigit(s[++i] = c = getch()))
            ;
    }

    s[i] = '\0';

    if (c != EOF)
    {
        ungetch(c);
    }

    return NUMBER;
}

int getch(void)             /* get a (possibly pushed back) char */
{
    return (bufp > 0) ? buf[--bufp] : getchar();
}

void ungetch(int c)         /* push char back on input */
{
    if (bufp >= BUFSIZE)
        printf("ungetch: too many chars\n");
    else
        buf[bufp++] = c;
}