cpp/step2_eval.cpp

   1 #include "MAL.h"
   2
   3 #include "Environment.h"
   4 #include "ReadLine.h"
   5 #include "Types.h"
   6
   7 #include <iostream>
   8 #include <memory>
   9
  10 malValuePtr READ(const String& input);
  11 String PRINT(malValuePtr ast);
  12
  13 static ReadLine s_readLine("~/.mal-history");
  14 static malBuiltIn::ApplyFunc
  15     builtIn_add, builtIn_sub, builtIn_mul, builtIn_div;
  16
  17 int main(int argc, char* argv[])
  18 {
  19     String prompt = "user> ";
  20     String input;
  21     malEnvPtr replEnv(new malEnv);
  22     replEnv->set("+", mal::builtin("+", &builtIn_add));
  23     replEnv->set("-", mal::builtin("-", &builtIn_sub));
  24     replEnv->set("*", mal::builtin("+", &builtIn_mul));
  25     replEnv->set("/", mal::builtin("/", &builtIn_div));
  26     while (s_readLine.get(prompt, input)) {
  27         String out;
  28         try {
  29             out = rep(input, replEnv);
  30         }
  31         catch (malEmptyInputException&) {
  32             continue; // no output
  33         }
  34         catch (String& s) {
  35             out = s;
  36         };
  37         std::cout << out << "\n";
  38     }
  39     return 0;
  40 }
  41
  42 String rep(const String& input, malEnvPtr env)
  43 {
  44     return PRINT(EVAL(READ(input), env));
  45 }
  46
  47 malValuePtr READ(const String& input)
  48 {
  49     return readStr(input);
  50 }
  51
  52 malValuePtr EVAL(malValuePtr ast, malEnvPtr env)
  53 {
  54     return ast->eval(env);
  55 }
  56
  57 String PRINT(malValuePtr ast)
  58 {
  59     return ast->print(true);
  60 }
  61
  62 malValuePtr APPLY(malValuePtr op, malValueIter argsBegin, malValueIter argsEnd,
  63                   malEnvPtr env)
  64 {
  65     const malApplicable* handler = DYNAMIC_CAST(malApplicable, op);
  66     MAL_CHECK(handler != NULL,
  67               "\"%s\" is not applicable", op->print(true).c_str());
  68
  69     return handler->apply(argsBegin, argsEnd, env);
  70 }
  71
  72 #define ARG(type, name) type* name = VALUE_CAST(type, *argsBegin++)
  73
  74 #define CHECK_ARGS_IS(expected) \
  75     checkArgsIs(name.c_str(), expected, std::distance(argsBegin, argsEnd))
  76
  77 #define CHECK_ARGS_BETWEEN(min, max) \
  78     checkArgsBetween(name.c_str(), min, max, std::distance(argsBegin, argsEnd))
  79
  80
  81 static malValuePtr builtIn_add(const String& name,
  82     malValueIter argsBegin, malValueIter argsEnd, malEnvPtr env)
  83 {
  84         CHECK_ARGS_IS(2);
  85         ARG(malInteger, lhs);
  86         ARG(malInteger, rhs);
  87         return mal::integer(lhs->value() + rhs->value());
  88 }
  89
  90 static malValuePtr builtIn_sub(const String& name,
  91     malValueIter argsBegin, malValueIter argsEnd, malEnvPtr env)
  92 {
  93         int argCount = CHECK_ARGS_BETWEEN(1, 2);
  94         ARG(malInteger, lhs);
  95         if (argCount == 1) {
  96             return mal::integer(- lhs->value());
  97         }
  98         ARG(malInteger, rhs);
  99         return mal::integer(lhs->value() - rhs->value());
 100 }
 101
 102 static malValuePtr builtIn_mul(const String& name,
 103     malValueIter argsBegin, malValueIter argsEnd, malEnvPtr env)
 104 {
 105         CHECK_ARGS_IS(2);
 106         ARG(malInteger, lhs);
 107         ARG(malInteger, rhs);
 108         return mal::integer(lhs->value() * rhs->value());
 109 }
 110
 111 static malValuePtr builtIn_div(const String& name,
 112     malValueIter argsBegin, malValueIter argsEnd, malEnvPtr env)
 113 {
 114         CHECK_ARGS_IS(2);
 115         ARG(malInteger, lhs);
 116         ARG(malInteger, rhs);
 117         MAL_CHECK(rhs->value() != 0, "Division by zero"); \
 118         return mal::integer(lhs->value() / rhs->value());
 119 }