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


/* --------- ERROR MESSAGES */
#define printerr(format, ...) printf("error: " format "\n", ##__VA_ARGS__)
#define ZERODIV_ERR "zero divisor"
#define DOMAIN_ERR "operand not in domain [%d, %d]"
#define NEG_ERR "negative operand %g"
#define FULL_STACK_ERR  "stack full, can't push %g"
#define EMPTY_STACK_ERR "stack empty" 
#define SHORT_STACK_ERR "not enough elements on stack"
#define UNKNOWN_TOKEN_ERR "unknown token %s"
#define VAR_NOT_SET_ERR "variable %c has no value"


/* --------- PROMPT FORMATS */
#define PROMPT_F     ">> "
#define POP_PRINT_F  "pop -> %.8g\n"
#define PEEK_PRINT_F "peek -> %.8g\n"
#define INITIAL_PROMPT_F \
    "A simple polish notation calculator.\n" \
    "Type 'help' for a list of available commands\n" \
    PROMPT_F


/* ------ GLOBAL VALUE STACK */
#define MAXVAL 100 /* maximum depth of val stack */

int sp = 0;
double val[MAXVAL];

/* length: current length of stack */
#define length() sp
/* push: push f onto value stack */
#define push(x) \
    ((sp < MAXVAL) ? val[sp++] = x : printerr(FULL_STACK_ERR, (double) (x)))
/* pop: pop and return top value from stack */
double pop(void)
{
    return sp ? val[--sp] : (printerr(EMPTY_STACK_ERR), 0);
}
/* peek: return top value from stack, leave stack unchanged */
#define peek() (sp ? val[sp-1] : (printerr(EMPTY_STACK_ERR), 0))
/* clear: clear stack */
#define clear() (sp = 0)
/* dup: duplicate top element */
#define dup() do { double tmp = peek(); push(tmp); } while (0) 
/* swap: swap top two elements */
#define swap() \
   do { if (sp < 2) printerr(SHORT_STACK_ERR); else { \
            double tmp = peek(); \
            val[sp-1] = val[sp-2], val[sp-2] = tmp; \
        } \
   } while (0) 


/* -------- STACK PRINTING FUNCTIONS */
double lst_print;
/* print_peek: print top element, leave stack unchanged */
#define print_peek() printf(PEEK_PRINT_F, lst_print = peek())
/* print_pop: pop top element and print it */
#define print_pop() printf(POP_PRINT_F, lst_print = pop())


/* ------- GLOBAL VARIABLE NAMESPACE */
#define NS_SIZE ('z' - 'a' + 1)
    
char var_flags[NS_SIZE];
double var_vals[NS_SIZE];

/* is_var: return 0 if c is not a variable name */
#define is_var(c) isalpha(c)

/* set_var: pop val from stack, set variable c to val */
#define set_var(c) \
    do { \
        int i = tolower(c) - 'a'; \
        var_flags[i] = 1; \
        var_vals[i] = pop(); \
    } while (0)

/* get_var: push value of c to stack */
#define get_var(c) \
    do { \
        int i = tolower(c) - 'a'; \
        if (!var_flags[i]) \
            printerr(VAR_NOT_SET_ERR, i+'a'); \
        else \
            push(var_vals[i]); \
    } while (0)

/* print_vars: print all set variables and their values */
void print_vars(void)
{
    int i;
    for (i = 0; i < NS_SIZE; i++)
        if (var_flags[i])
            printf("%c = %.8g\n", i+'a', var_vals[i]);
}

/* --------- CALCULATOR FUNCTION TYPES */
/* the following macros allow us to call native c constructs 
 * in a declarative style */

/* value */
#define VALUE(ID) push(ID)
/* command */
#define COMMAND(CMD) CMD()
/* commutative operator */
#define COMM_OP(OP) push(pop() OP pop()) 
/* non-commutative operator */
#define NONC_OP(OP, ...) \
    do { double op = pop(); __VA_ARGS__ push(pop() OP op); } while (0)
/* unary function */
#define UNARY_FUN(F) push(F(pop()))
/* unary function with tests */
#define UNARY_T_FUN(F, T, ...) \
    do { double op = pop(); __VA_ARGS__ push(F(op)); } while (0)
/* commutative function */
#define COMM_FUN(F) push(F(pop(), pop()))
/* non-commutative function */
#define NONC_FUN(F, ...) \
    do { double op = pop(); __VA_ARGS__ push(F(pop(), op)); } while (0)

/* OPERAND TESTS */
/* nonzero operand */
#define NONZ_SND_OP if (!op) printerr(ZERODIV_ERR); else
/* operator in range */
#define IN_RANGE(A, B) if (op < A || op > B) printerr(DOMAIN_ERR, A, B); else
/* non-negative operand  */
#define NON_NEG if (op < 0) printerr(NEG_ERR, op); else


/* --------- CALCULATOR FUNCTIONS */
/* renaming macro */
#define CALL(TOKEN, F, APPLY, ...) APPLY(F, ##__VA_ARGS__)

#define COMMANDS \
    X(_, "last printed value", CALL, lst_print, VALUE) \
    X(ENTER, "pop top of stack and print it", CALL, print_pop, COMMAND) \
    X(print, "print top of stack", CALL, print_peek, COMMAND) \
    X(dup, "duplicate top of stack", COMMAND) \
    X(swap, "swap top two elements of stack", COMMAND) \
    X(clear, "clear stack", COMMAND) \
    X(help, "print all available commands", COMMAND) \
    X(vars, "print defined variables and their values", CALL, print_vars, COMMAND)

#define MOD(x, y) ((int) (x) % (int) (y))

#define OPERATORS \
    X(+, "add operands", COMM_OP) \
    X(*, "multiply operands", COMM_OP) \
    X(-, "substact operands", NONC_OP) \
    X(/, "divide operands", NONC_OP, NONZ_SND_OP) \
    X(%, "apply modulo to operands", CALL, MOD, NONC_FUN, NONZ_SND_OP) \
    X(>, "greater than", NONC_OP) \
    X(<, "less than", NONC_OP) \
    X(<=, "less than or equal", NONC_OP) \
    X(>=, "greater than or equal", NONC_OP) \
    X(==, "test equality", COMM_OP)

#define MATH_H_BINDINGS \
    X(sin, "sine", UNARY_FUN) \
    X(cos, "cosine", UNARY_FUN) \
    X(tan, "tangent", UNARY_FUN) \
    X(acos, "arc cosine", UNARY_T_FUN, IN_RANGE(-1, 1)) \
    X(asin, "arc sine", UNARY_T_FUN, IN_RANGE(-1, 1)) \
    X(atan, "arc tangent", UNARY_FUN) \
    X(exp, "exponentional function", UNARY_FUN) \
    X(log, "natural logarithm", UNARY_T_FUN, NON_NEG) \
    X(log10, "logarithm of base 10", UNARY_T_FUN, NON_NEG) \
    X(log2, "logarithm of base 2", UNARY_T_FUN, NON_NEG) \
    X(pow, "power function", NONC_FUN) \
    X(sqrt, "square root", UNARY_T_FUN, NON_NEG) \
    X(ceil, "round up value", UNARY_FUN) \
    X(floor, "round down value", UNARY_FUN) \
    X(round, "round to nearest", UNARY_FUN) \
    X(abs, "absolute value", CALL, fabs, UNARY_FUN) \
    X(max, "maximum value", CALL, fmax, COMM_FUN) \
    X(min, "minimum value", CALL, fmin, COMM_FUN) \
    X(pi, "value of pi", CALL, M_PI, VALUE)
    
#define TOKENS \
    COMMANDS \
    OPERATORS \
    MATH_H_BINDINGS

/* variable manipulation tokens */
#define VAR_TOKENS \
    X('=', "pop value top from stack and set %s to value", set_var) \
    X('$', "push value of %s to top of stack", get_var)


/* --------- MAIN PROGRAM */ 
#define MAXTOKEN 100
int gettoken(char *token, int max_t);
char * parsef(char *s, double *x);
void help(void);

/* reverse Polish calculator */
int main()
{
    char token[MAXTOKEN + 1];
    double x;
    int t_len;
    
    printf(INITIAL_PROMPT_F);
    while ((t_len = gettoken(token, MAXTOKEN))) {
        if (t_len < 0) { /* newline token */
            if (length())
                print_pop();
            printf(PROMPT_F);
        } else
    #define X(F, DESC, APPLY, ...) \
        if (t_len == sizeof(#F) / sizeof(char) - 1 && !strcmp(#F, token)) \
            APPLY(F, ##__VA_ARGS__); \
        else
        TOKENS
    #undef X
    #define X(C, DESC, F) \
        if (t_len == 2 && token[0] == C && is_var(token[1])) \
            F(token[1]); \
        else
        VAR_TOKENS
    #undef X
        if (*parsef(token, &x) == '\0')
                    push(x);
        else
            printerr(UNKNOWN_TOKEN_ERR, token);
    }

    putchar('\n');
    while (length())
        print_pop();

    return 0;
}


/* ---------- HELP COMMAND */
#define MAX_CMD_W 10 /* token padding */
#define VAR_STR "X"  /* string to represent variable */

/* we verify that no token is to large to be pretty printed */
#define X(TOKEN, ...) \
    static_assert(sizeof(#TOKEN) / sizeof(char) <= MAX_CMD_W, \
        "size of " #TOKEN " is to large for pretty printing " \
        "in help command");
    TOKENS
#undef X

/* help: prints all available calculator functions */
void help(void)
{
#define X(C, DESC, ...) \
    printf("%c%-*s" DESC "\n", C, MAX_CMD_W-1, VAR_STR, VAR_STR);
    VAR_TOKENS
#undef X
#define X(F, DESC, ...) printf("%-*s" DESC "\n", MAX_CMD_W, #F);
    TOKENS
#undef X
}


/* -------- PARSING FUNCTIONS */
#define BLANK ' '

/* gettoken: get next space delimited token from input
 * return token length, -1 on newline and 0 on EOF */
int gettoken(char *token, int t_max) 
{
    static int c = BLANK;
    
    while (isspace(c) && c != '\n') /* remove leading whitespace */
        c = getchar();

    if (c == '\n') { /* newline is a token */
        c = BLANK;
        return -1;
    }

    /* fetch token */
    int i;
    for (i = 0; i < t_max && c != EOF && !isspace(c); c = getchar(), i++) 
        token[i] = c;

    token[i] = '\0';
    return i;
}

#define DEC_SEP X('.') X(',')
#define EXP_SEP X('e') X('E')

/* macros for parsef */
#define SIGN(s) \
    ((*s == '-') ? (s++, -1) : ((*s == '+') ? (s++, 1) : 1))
#define ATOI(s, x, ...) \
    for (; isdigit(*s); s++, ##__VA_ARGS__) \
        (x) = 10 * (x) + (*s - '0')

/* parsef: convert string s to double, write it to *x
 * return pointer of last read char in s  */
char * parsef(char s[], double *x)
{
    *x = 0;
    /* integer part */
    int sign = SIGN(s);    
    ATOI(s, *x);

#define X(sep) *s != sep && 
    if (DEC_SEP 1) {
        *x *= sign;
        return s;
    }
#undef X
    s++;
    /* fractional part */
    int exp = 0; 
    ATOI(s, *x, exp--);
    *x *= sign * pow(10, exp);

#define X(sep) *s != sep && 
    if (EXP_SEP 1)
        return s;
#undef X
    s++;
    /* exponent */
    sign = SIGN(s);
    exp = 0;
    ATOI(s, exp);
    *x *= pow(10, sign * exp);
    return s;
}