MORPH
SIGN IN SIGN UP
kanaka / mal UNCLAIMED

mal - Make a Lisp

0 0 0 Assembly
Normal View History Raw
c++11: step 2 Note that the optional tests for step 1 now fail because I no longer create a hash directly in the reader, rather handle this as a reader macro: { LIST } -> ( hash-map LIST ) This way, once the constructor has built the hash-map, the hash is now evaluated, and its evaluation procedure is a no-op. I'd like to do the same with vectors, but this isn't so easy, as we use vectors as parameter lists in fn* later on. ie. we'd have this situation, which is incorrect (and I don't see an obvious workaround) (fn* [params] body) -> (fn* (vector params) body)
2015-03-27 09:04:35 +11:00
#include "Environment.h"
#include "Types.h"
#include <algorithm>
c++11: step 3
2015-03-27 11:03:28 +11:00
malEnv::malEnv(malEnvPtr outer)
: m_outer(outer)
{
TRACE_ENV("Creating malEnv %p, outer=%p\n", this, m_outer.ptr());
}
c++11: step 4
2015-03-27 12:52:07 +11:00
malEnv::malEnv(malEnvPtr outer, const StringVec& bindings,
malValueIter argsBegin, malValueIter argsEnd)
: m_outer(outer)
{
TRACE_ENV("Creating malEnv %p, outer=%p\n", this, m_outer.ptr());
int n = bindings.size();
auto it = argsBegin;
for (int i = 0; i < n; i++) {
if (bindings[i] == "&") {
Split ASSERT into ASSERT and MAL_CHECK/MAL_FAIL * ASSERT is to check for internal errors * MAL_CHECK / MAL_FAIL is to check mal code errors
2015-03-28 22:54:26 +11:00
MAL_CHECK(i == n - 2, "There must be one parameter after the &");
c++11: step 4
2015-03-27 12:52:07 +11:00
set(bindings[n-1], mal::list(it, argsEnd));
return;
}
Split ASSERT into ASSERT and MAL_CHECK/MAL_FAIL * ASSERT is to check for internal errors * MAL_CHECK / MAL_FAIL is to check mal code errors
2015-03-28 22:54:26 +11:00
MAL_CHECK(it != argsEnd, "Not enough parameters");
c++11: step 4
2015-03-27 12:52:07 +11:00
set(bindings[i], *it);
++it;
}
Split ASSERT into ASSERT and MAL_CHECK/MAL_FAIL * ASSERT is to check for internal errors * MAL_CHECK / MAL_FAIL is to check mal code errors
2015-03-28 22:54:26 +11:00
MAL_CHECK(it == argsEnd, "Too many parameters");
c++11: step 4
2015-03-27 12:52:07 +11:00
}
c++11: step 3
2015-03-27 11:03:28 +11:00
malEnv::~malEnv()
{
TRACE_ENV("Destroying malEnv %p, outer=%p\n", this, m_outer.ptr());
}
malEnvPtr malEnv::find(const String& symbol)
{
for (malEnvPtr env = this; env; env = env->m_outer) {
if (env->m_map.find(symbol) != env->m_map.end()) {
return env;
}
}
return NULL;
}
c++11: step 2 Note that the optional tests for step 1 now fail because I no longer create a hash directly in the reader, rather handle this as a reader macro: { LIST } -> ( hash-map LIST ) This way, once the constructor has built the hash-map, the hash is now evaluated, and its evaluation procedure is a no-op. I'd like to do the same with vectors, but this isn't so easy, as we use vectors as parameter lists in fn* later on. ie. we'd have this situation, which is incorrect (and I don't see an obvious workaround) (fn* [params] body) -> (fn* (vector params) body)
2015-03-27 09:04:35 +11:00
malValuePtr malEnv::get(const String& symbol)
{
c++11: step 3
2015-03-27 11:03:28 +11:00
for (malEnvPtr env = this; env; env = env->m_outer) {
auto it = env->m_map.find(symbol);
if (it != env->m_map.end()) {
return it->second;
}
c++11: step 2 Note that the optional tests for step 1 now fail because I no longer create a hash directly in the reader, rather handle this as a reader macro: { LIST } -> ( hash-map LIST ) This way, once the constructor has built the hash-map, the hash is now evaluated, and its evaluation procedure is a no-op. I'd like to do the same with vectors, but this isn't so easy, as we use vectors as parameter lists in fn* later on. ie. we'd have this situation, which is incorrect (and I don't see an obvious workaround) (fn* [params] body) -> (fn* (vector params) body)
2015-03-27 09:04:35 +11:00
}
Split ASSERT into ASSERT and MAL_CHECK/MAL_FAIL * ASSERT is to check for internal errors * MAL_CHECK / MAL_FAIL is to check mal code errors
2015-03-28 22:54:26 +11:00
MAL_FAIL("'%s' not found", symbol.c_str());
c++11: step 2 Note that the optional tests for step 1 now fail because I no longer create a hash directly in the reader, rather handle this as a reader macro: { LIST } -> ( hash-map LIST ) This way, once the constructor has built the hash-map, the hash is now evaluated, and its evaluation procedure is a no-op. I'd like to do the same with vectors, but this isn't so easy, as we use vectors as parameter lists in fn* later on. ie. we'd have this situation, which is incorrect (and I don't see an obvious workaround) (fn* [params] body) -> (fn* (vector params) body)
2015-03-27 09:04:35 +11:00
}
malValuePtr malEnv::set(const String& symbol, malValuePtr value)
{
m_map[symbol] = value;
return value;
}
c++11: step 6
2015-03-27 16:07:46 +11:00
malEnvPtr malEnv::getRoot()
{
// Work our way down the the global environment.
for (malEnvPtr env = this; ; env = env->m_outer) {
if (!env->m_outer) {
return env;
}
}
}
Reference in New Issue Copy Permalink