ch4

ch4/interpreter-cpp/schint/environment.cpp

@@ -7,11 +7,46 @@
 
 #include "environment.h"
 
+#include "expression.h"
+
 Environment::Environment(Environment *baseEnv)
     : m_baseEnvironment(baseEnv)
 {
 }
 
+shared_ptr<Expression> Environment::lookupVariableValue(const Var var) const
+{
+    if (m_frame.find(var) == m_frame.end())
+    {
+        if (m_baseEnvironment)
+            return m_baseEnvironment->lookupVariableValue(var);
+    }
+    else
+        return m_frame.find(var)->second;
+
+    return nullexpr;
+}
+
+void Environment::addBindingForFrame(const Var var, const Val val)
+{
+    m_frame[var] = val;
+}
+
+Environment *Environment::extendEnvironment(std::list<Var> vars, std::list<Val> vals)
+{
+    if (vars.size() != vals.size())
+        throw std::runtime_error("Sizes doesn't match.");
+
+    Environment *newEnv = new Environment(this);
+
+    auto var = vars.begin();
+    auto val = vals.begin();
+    for ( ; var != vars.end(); var++, val++)
+        newEnv->addBindingForFrame(*var, *val);
+
+    return newEnv;
+}
+
 Environment *globalEnvironment()
 {
     static Environment globalEnv(nullptr);

ch4/interpreter-cpp/schint/environment.h

@@ -8,19 +8,37 @@
 #ifndef ENVIRONMENT_H
 #define ENVIRONMENT_H
 
-#include <map>
-#include <string>
+#include "utils.h"
+#include "expression.h"
 
-class Evaluable;
+// WHY std::less<VariableExpression> doesn't work?????
+struct compare
+{
+    bool operator() (const shared_ptr<VariableExpression> &a, const shared_ptr<VariableExpression> &b) const
+    {
+        return *a < *b;
+    }
+};
 
 class Environment
 {
     Environment *m_baseEnvironment;
 
-    std::map<std::string, Evaluable *> m_frame;
+    typedef shared_ptr<VariableExpression> Var;
+    typedef shared_ptr<Expression> Val;
+
+    std::map<Var, Val, compare> m_frame;
 
 public:
     Environment(Environment *baseEnv);
+
+    shared_ptr<Expression> lookupVariableValue(const Var var) const;
+    void addBindingForFrame(const Var var, const Val val);
+
+    Environment *extendEnvironment(std::list<Var> vars, std::list<Val> vals);
+
+private:
+//    static boost::function
 };
 
 Environment *globalEnvironment();

ch4/interpreter-cpp/schint/expression.cpp

@@ -6,46 +6,94 @@
  */
 
 #include "expression.h"
+
 #include "schemelist.h"
+#include "environment.h"
 
-#include <stdexcept>
+/*
+;; lambdas
+(define (lambda? exp) (tagged-list? exp 'lambda))
+(define (lambda-parameters exp) (cadr exp))
+(define (lambda-body exp) (cddr exp))
+(define (make-lambda parameters body)
+  (cons 'lambda (cons parameters body)))
+  */
 
-Expression::Expression()
-{
-}
+/*
+(define (analyze-lambda exp)
+  (let ((vars (lambda-parameters exp))
+        (bproc (analyze-sequence (lambda-body exp))))
+    (lambda (env) (make-procedure vars bproc env))))
+
+(define (analyze-sequence exps)
+  (define (sequentially proc1 proc2)
+    (lambda (env) (proc1 env) (proc2 env)))
+  (define (loop first-proc rest-procs)
+    (if (null? rest-procs)
+        first-proc                                       ;; only one combination
+        (loop (sequentially first-proc (car rest-procs)) ;; otherwise, loop through combinations
+              (cdr rest-procs))))
+  (let ((procs (map analyze exps)))
+    (if (null? procs)
+        (error "Empty sequence -- ANALYZE"))
+    (loop (car procs) (cdr procs))))
+    */
 
-//Expression::ExpressionType Expression::typeBySExpression(const std::string &sexpr)
-//{
-//    std::string tag = sexpr.substr(1, sexpr.find(' ') - 1);
+/*
+(define (make-procedure parameters body env)
+  (list 'procedure parameters body env))
 
+(define (compound-procedure? p)
+  (tagged-list? p 'procedure))
 
+(define (procedure-parameters p) (cadr p))
+(define (procedure-body p) (caddr p))
+(define (procedure-environment p) (cadddr p))
+*/
 
-//    throw std::runtime_error(std::string("Unknown expression type ") + tag + " .");
-//}
+shared_ptr<DefinitionExpression> analyzeDefinition(const SchemeList &str)
+{
+    SchemeList defVarStr = str.car();
 
-Expression *Expression::analyzeExpression(const std::string &str)
+    return make_shared<DefinitionExpression>(make_shared<VariableExpression>(defVarStr),
+                                             Expression::analyzeExpression(str.cdr()));
+}
+
+Expression::Expression()
+{
+}
+
+shared_ptr<Expression> Expression::analyzeExpression(const std::string &str)
 {
     SchemeList lst(str);
 
-    std::string tag = lst.car();
+    SchemeList tag = lst.car();
 
     if (tag == "\'")
-        return nullptr;
+        return nullexpr;
     if (tag == "set!")
-        return nullptr;
+        return nullexpr;
     if (tag == "define")
-        return new DefinitionExpression(0 /* analyze (rest) */, 0);
+        return analyzeDefinition(lst.cdr());
     if (tag == "if")
-        return nullptr;
+        return nullexpr;
     if (tag == "lambda")
-        return nullptr;
+        return nullexpr;
     if (tag == "begin")
-        return nullptr;
+        return nullexpr;
+    if (isDouble(tag))
+        return make_shared<NumberExpression<double> >(toDouble(tag));
+    if (isInt(tag))
+        return make_shared<NumberExpression<int> >(toInt(tag));
+    if (isLispString(tag))
+        return nullexpr;
+
+//    std::isxdigit
 //        if (tag == number);
 //        if (tag == symbol);
 //        if (tag == pair);
 
-    throw std::runtime_error(std::string("Unknown expression type ") + tag + " .");
+//    throw std::runtime_error(std::string("Unknown expression type ") + tag + " .");
 //    ExpressionType exprType = typeBySExpression(expr);
 
 //    new DefinitionExpr(cadr(expr), createExpression(caddr(expr)));
@@ -63,7 +111,7 @@ Expression *Expression::analyzeExpression(const std::string &str)
 //    if (exprType == Begin)
 //        return new BeginExpression("");
 
-//    return nullptr;
+    return nullexpr;
 }
 
 Expression *Expression::car() const
@@ -74,19 +122,23 @@ Expression *Expression::cdr() const
 {
 }
 
-/*
-VariableExpression::VariableExpression(const std::string &value)
+
+VariableExpression::VariableExpression(const std::string &varSymbol)
+    : m_symbol(varSymbol)
 {
 }
 
-Expression *VariableExpression::eval(Environment *env)
+shared_ptr<Expression> VariableExpression::eval(Environment *env)
 {
+//    auto var = make_shared<VariableExpression>(this);
+//    return env->lookupVariableValue(var);
+//    env->lookupVariableValue
 }
 
 std::string VariableExpression::toString() const
 {
 }
-
+/*
 QuotedExpression::QuotedExpression(const std::string &value)
 {
 }
@@ -111,11 +163,12 @@ std::string AssignmentExpression::toString() const
 {
 }*/
 
-DefinitionExpression::DefinitionExpression(Expression *variable, Expression *value)
+DefinitionExpression::DefinitionExpression(shared_ptr<VariableExpression> variable, shared_ptr<Expression> value)
+    : m_var(variable), m_value(value)
 {
 }
 
-Expression *DefinitionExpression::eval(Environment *env)
+shared_ptr<Expression> DefinitionExpression::eval(Environment *env)
 {
 }