参考

{% collapse title=”error_handling.c” %}

  1. #include "mpc.h"
  3. #ifdef _WIN32
  5. static char buffer[2048];
  7. char* readline(char* prompt) {
  8.   fputs(prompt, stdout);
  9.   fgets(buffer, 2048, stdin);
  10.   char* cpy = malloc(strlen(buffer)+1);
  11.   strcpy(cpy, buffer);
  12.   cpy[strlen(cpy)-1] = '\0';
  13.   return cpy;
  14. }
  16. void add_history(char* unused) {}
  18. #else
  19. #include <editline/readline.h>
  20. #include <editline/history.h>
  21. #endif
  23. /* Create Enumeration of Possible Error Types */
  24. enum { LERR_DIV_ZERO, LERR_BAD_OP, LERR_BAD_NUM };
  26. /* Create Enumeration of Possible lval Types */
  27. enum { LVAL_NUM, LVAL_ERR };
  29. /* Declare New lval Struct */
  30. typedef struct {
  31.   int type;
  32.   long num;
  33.   int err;
  34. } lval;
  36. /* Create a new number type lval */
  37. lval lval_num(long x) {
  38.   lval v;
  39.   v.type = LVAL_NUM;
  40.   v.num = x;
  41.   return v;
  42. }
  44. /* Create a new error type lval */
  45. lval lval_err(int x) {
  46.   lval v;
  47.   v.type = LVAL_ERR;
  48.   v.err = x;
  49.   return v;
  50. }
  52. /* Print an "lval" */
  53. void lval_print(lval v) {
  54.   switch (v.type) {
  55.     /* In the case the type is a number print it */
  56.     /* Then 'break' out of the switch. */
  57.     case LVAL_NUM: printf("%li", v.num); break;
  59.     /* In the case the type is an error */
  60.     case LVAL_ERR:
  61.       /* Check what type of error it is and print it */
  62.       if (v.err == LERR_DIV_ZERO) {
  63.         printf("Error: Division By Zero!");
  64.       }
  65.       if (v.err == LERR_BAD_OP)   {
  66.         printf("Error: Invalid Operator!");
  67.       }
  68.       if (v.err == LERR_BAD_NUM)  {
  69.         printf("Error: Invalid Number!");
  70.       }
  71.     break;
  72.   }
  73. }
  75. /* Print an "lval" followed by a newline */
  76. void lval_println(lval v) { lval_print(v); putchar('\n'); }
  78. lval eval_op(lval x, char* op, lval y) {
  80.   /* If either value is an error return it */
  81.   if (x.type == LVAL_ERR) { return x; }
  82.   if (y.type == LVAL_ERR) { return y; }
  84.   /* Otherwise do maths on the number values */
  85.   if (strcmp(op, "+") == 0) { return lval_num(x.num + y.num); }
  86.   if (strcmp(op, "-") == 0) { return lval_num(x.num - y.num); }
  87.   if (strcmp(op, "*") == 0) { return lval_num(x.num * y.num); }
  88.   if (strcmp(op, "/") == 0) {
  89.     /* If second operand is zero return error */
  90.     return y.num == 0 
  91.       ? lval_err(LERR_DIV_ZERO) 
  92.       : lval_num(x.num / y.num);
  93.   }
  95.   return lval_err(LERR_BAD_OP);
  96. }
  98. lval eval(mpc_ast_t* t) {
  100.   if (strstr(t->tag, "number")) {
  101.     /* Check if there is some error in conversion */
  102.     errno = 0;
  103.     long x = strtol(t->contents, NULL, 10);
  104.     return errno != ERANGE ? lval_num(x) : lval_err(LERR_BAD_NUM);
  105.   }
  107.   char* op = t->children[1]->contents;  
  108.   lval x = eval(t->children[2]);
  110.   int i = 3;
  111.   while (strstr(t->children[i]->tag, "expr")) {
  112.     x = eval_op(x, op, eval(t->children[i]));
  113.     i++;
  114.   }
  116.   return x;  
  117. }
  119. int main(int argc, char** argv) {
  121.   mpc_parser_t* Number = mpc_new("number");
  122.   mpc_parser_t* Operator = mpc_new("operator");
  123.   mpc_parser_t* Expr = mpc_new("expr");
  124.   mpc_parser_t* Lispy = mpc_new("lispy");
  126.   mpca_lang(MPCA_LANG_DEFAULT,
  127.     "                                                     \
  128.       number   : /-?[0-9]+/ ;                             \
  129.       operator : '+' | '-' | '*' | '/' ;                  \
  130.       expr     : <number> | '(' <operator> <expr>+ ')' ;  \
  131.       lispy    : /^/ <operator> <expr>+ /$/ ;             \
  132.     ",
  133.     Number, Operator, Expr, Lispy);
  135.   puts("Lispy Version 0.0.0.0.4");
  136.   puts("Press Ctrl+c to Exit\n");
  138.   while (1) {
  140.     char* input = readline("lispy> ");
  141.     add_history(input);
  143.     mpc_result_t r;
  144.     if (mpc_parse("<stdin>", input, Lispy, &r)) {
  145.       lval result = eval(r.output);
  146.       lval_println(result);
  147.       mpc_ast_delete(r.output);
  148.     } else {    
  149.       mpc_err_print(r.error);
  150.       mpc_err_delete(r.error);
  151.     }
  153.     free(input);
  155.   }
  157.   mpc_cleanup(4, Number, Operator, Expr, Lispy);
  159.   return 0;
  160. }

{% endcollapse %}