339 lines
9.3 KiB
C
339 lines
9.3 KiB
C
#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;
|
|
}
|