riyyi
/
blaze
1
0
Bifurcation 0
Code Tickets Demandes d'ajout Projets Versions Wiki Activité

Comparer les révisions

base: riyyi:3aa99d004579d9fd09aedfa7398066df3ce04bae
Branches Tags
riyyi:master
..
comparer: riyyi:ce0443a20e8350329e2d8750f87349f267044b37
Branches Tags
riyyi:master

Pas de révisions en commun. '3aa99d004579d9fd09aedfa7398066df3ce04bae' et 'ce0443a20e8350329e2d8750f87349f267044b37' ont des historiques entièrement différents.
3aa99d0045 ... ce0443a20e

13 fichiers modifiés avec 233 ajouts et 170 suppressions
Espace
Afficher toutes les modifications Ignorer les espaces lors de la comparaison des lignes Ignorer les changements quand ce sont des espaces Ignorer les changements quand ce sont des espaces à la fin de la ligne
Vue unifiée
Option de Diff
Voir les Statistiques
  1. 74
      CMakeLists.txt
  2. 46
      src/ast.cpp
  3. 11
      src/ast.h
  4. 134
      src/eval-special-form.cpp
  5. 53
      src/eval.cpp
  6. 7
      src/eval.h
  7. 32
      src/functions.cpp
  8. 6
      src/reader.cpp
  9. 8
      src/step6_file.cpp
  10. 8
      src/step7_quote.cpp
  11. 8
      src/step8_macros.cpp
  12. 8
      src/step9_try.cpp
  13. 8
      src/stepA_mal.cpp

74
CMakeLists.txt
Unescape Voir le fichier

@ -95,41 +95,49 @@ add_custom_target(run
# ------------------------------------------ # ------------------------------------------
# Test targets # Test targets
function(make_test_target target_name step_name) add_custom_target(test0
add_custom_target(${target_name} COMMAND ../vendor/mal/runtest.py --deferrable --optional ../tests/step0_repl.mal -- ./${PROJECT})
COMMAND ../vendor/mal/runtest.py --deferrable --optional ../tests/${step_name}.mal -- ./${step_name}) add_dependencies(test0 ${PROJECT})
add_dependencies(${target_name} ${step_name})
endfunction()
make_test_target("test0" "step0_repl") add_custom_target(test1
make_test_target("test1" "step1_read_print") COMMAND ../vendor/mal/runtest.py --deferrable --optional ../tests/step1_read_print.mal -- ./${PROJECT})
make_test_target("test2" "step2_eval") add_dependencies(test1 ${PROJECT})
make_test_target("test3" "step3_env")
make_test_target("test4" "step4_if_fn_do") add_custom_target(test2
make_test_target("test5" "step5_tco") COMMAND ../vendor/mal/runtest.py --deferrable --optional ../tests/step2_eval.mal -- ./${PROJECT})
make_test_target("test6" "step6_file") add_dependencies(test2 ${PROJECT})
make_test_target("test7" "step7_quote")
make_test_target("test8" "step8_macros") add_custom_target(test3
make_test_target("test9" "step9_try") COMMAND ../vendor/mal/runtest.py --deferrable --optional ../tests/step3_env.mal -- ./${PROJECT})
make_test_target("testA" "stepA_mal") add_dependencies(test3 ${PROJECT})
function(make_host_test_target target_name step_name) add_custom_target(test4
add_custom_target(${target_name} COMMAND ../vendor/mal/runtest.py --deferrable --optional ../tests/step4_if_fn_do.mal -- ./${PROJECT})
COMMAND ../vendor/mal/runtest.py --deferrable --optional ../tests/${step_name}.mal -- ./${PROJECT} ../mal/${step_name}.mal) add_dependencies(test4 ${PROJECT})
add_dependencies(${target_name} ${PROJECT})
endfunction() add_custom_target(test5
COMMAND ../vendor/mal/runtest.py --deferrable --optional ../tests/step5_tco.mal -- ./${PROJECT})
add_dependencies(test5 ${PROJECT})
add_custom_target(test6
COMMAND ../vendor/mal/runtest.py --deferrable --optional ../tests/step6_file.mal -- ./${PROJECT})
add_dependencies(test6 ${PROJECT})
add_custom_target(test7
COMMAND ../vendor/mal/runtest.py --deferrable --optional ../tests/step7_quote.mal -- ./${PROJECT})
add_dependencies(test7 ${PROJECT})
add_custom_target(test8
COMMAND ../vendor/mal/runtest.py --deferrable --optional ../tests/step8_macros.mal -- ./${PROJECT})
add_dependencies(test8 ${PROJECT})
add_custom_target(test9
COMMAND ../vendor/mal/runtest.py --deferrable --optional ../tests/step9_try.mal -- ./${PROJECT})
add_dependencies(test9 ${PROJECT})
make_host_test_target("host_test0" "step0_repl") add_custom_target(testA
make_host_test_target("host_test1" "step1_read_print") COMMAND ../vendor/mal/runtest.py --deferrable --optional ../tests/stepA_mal.mal -- ./${PROJECT})
make_host_test_target("host_test2" "step2_eval") add_dependencies(testA ${PROJECT})
make_host_test_target("host_test3" "step3_env")
make_host_test_target("host_test4" "step4_if_fn_do")
# make_host_test_target("host_test5" "step5_tco") # disabled
make_host_test_target("host_test6" "step6_file")
make_host_test_target("host_test7" "step7_quote")
make_host_test_target("host_test8" "step8_macros")
make_host_test_target("host_test9" "step9_try")
make_host_test_target("host_testA" "stepA_mal")
add_custom_target(perf add_custom_target(perf
COMMAND ./${PROJECT} ../tests/perf1.mal COMMAND ./${PROJECT} ../tests/perf1.mal

46
src/ast.cpp
Unescape Voir le fichier

@ -114,16 +114,36 @@ HashMap::HashMap(const HashMap& that, ValuePtr meta)
{ {
} }
std::string HashMap::getKeyString(ValuePtr key) void HashMap::add(const std::string& key, ValuePtr value)
{ {
if (!is<String>(key.get()) && !is<Keyword>(key.get())) { if (value == nullptr) {
Error::the().add(::format("wrong argument type: string or keyword, {}", key)); return;
return {};
} }
return is<String>(key.get()) m_elements.insert_or_assign(key, value);
? std::static_pointer_cast<String>(key)->data() }
: std::static_pointer_cast<Keyword>(key)->keyword();
void HashMap::add(ValuePtr key, ValuePtr value)
{
if (key == nullptr || value == nullptr) {
return;
}
m_elements.insert_or_assign(getKeyString(key), value);
}
void HashMap::remove(const std::string& key)
{
m_elements.erase(key);
}
void HashMap::remove(ValuePtr key)
{
if (key == nullptr) {
return;
}
m_elements.erase(getKeyString(key));
} }
bool HashMap::exists(const std::string& key) bool HashMap::exists(const std::string& key)
@ -150,6 +170,18 @@ ValuePtr HashMap::get(ValuePtr key)
return get(getKeyString(key)); return get(getKeyString(key));
} }
std::string HashMap::getKeyString(ValuePtr key)
{
if (!is<String>(key.get()) && !is<Keyword>(key.get())) {
Error::the().add(::format("wrong argument type: string or keyword, {}", key));
return {};
}
return is<String>(key.get())
? std::static_pointer_cast<String>(key)->data()
: std::static_pointer_cast<Keyword>(key)->keyword();
}
// ----------------------------------------- // -----------------------------------------
String::String(const std::string& data) String::String(const std::string& data)

11
src/ast.h
Unescape Voir le fichier

@ -174,17 +174,20 @@ private:
// ----------------------------------------- // -----------------------------------------
using Elements = std::map<std::string, ValuePtr>;
// {} // {}
class HashMap final : public Value { class HashMap final : public Value {
public: public:
using Elements = std::map<std::string, ValuePtr>;
HashMap() = default; HashMap() = default;
HashMap(const Elements& elements); HashMap(const Elements& elements);
HashMap(const HashMap& that, ValuePtr meta); HashMap(const HashMap& that, ValuePtr meta);
virtual ~HashMap() = default; virtual ~HashMap() = default;
static std::string getKeyString(ValuePtr key); void add(const std::string& key, ValuePtr value);
void add(ValuePtr key, ValuePtr value);
void remove(const std::string& key);
void remove(ValuePtr key);
bool exists(const std::string& key); bool exists(const std::string& key);
bool exists(ValuePtr key); bool exists(ValuePtr key);
@ -199,6 +202,8 @@ public:
private: private:
virtual bool isHashMap() const override { return true; } virtual bool isHashMap() const override { return true; }
std::string getKeyString(ValuePtr key);
Elements m_elements; Elements m_elements;
}; };

134
src/eval-special-form.cpp
Unescape Voir le fichier

@ -30,8 +30,8 @@ ValuePtr Eval::evalDef(const ValueVector& nodes, EnvironmentPtr env)
VALUE_CAST(symbol, Symbol, nodes.front()); VALUE_CAST(symbol, Symbol, nodes.front());
// Eval second argument // Eval second argument
m_ast = *std::next(nodes.begin()); m_ast_stack.push(*std::next(nodes.begin()));
m_env = env; m_env_stack.push(env);
ValuePtr value = evalImpl(); ValuePtr value = evalImpl();
// Dont overwrite symbols after an error // Dont overwrite symbols after an error
@ -52,8 +52,8 @@ ValuePtr Eval::evalDefMacro(const ValueVector& nodes, EnvironmentPtr env)
VALUE_CAST(symbol, Symbol, nodes.front()); VALUE_CAST(symbol, Symbol, nodes.front());
// Eval second argument // Eval second argument
m_ast = *std::next(nodes.begin()); m_ast_stack.push(*std::next(nodes.begin()));
m_env = env; m_env_stack.push(env);
ValuePtr value = evalImpl(); ValuePtr value = evalImpl();
VALUE_CAST(lambda, Lambda, value); VALUE_CAST(lambda, Lambda, value);
@ -111,55 +111,6 @@ ValuePtr Eval::evalQuote(const ValueVector& nodes)
return nodes.front(); return nodes.front();
} }
// (try* x (catch* y z))
ValuePtr Eval::evalTry(const ValueVector& nodes, EnvironmentPtr env)
{
CHECK_ARG_COUNT_AT_LEAST("try*", nodes.size(), 1);
// Try 'x'
m_ast = nodes.front();
m_env = env;
auto result = evalImpl();
if (!Error::the().hasAnyError()) {
return result;
}
if (nodes.size() == 1) {
return nullptr;
}
// Catch
// Get the error message
auto error = (Error::the().hasOtherError())
? makePtr<String>(Error::the().otherError())
: Error::the().exception();
Error::the().clearErrors();
VALUE_CAST(catch_list, List, nodes.back());
const auto& catch_nodes = catch_list->nodes();
CHECK_ARG_COUNT_IS("catch*", catch_nodes.size() - 1, 2);
VALUE_CAST(catch_symbol, Symbol, catch_nodes.front());
if (catch_symbol->symbol() != "catch*") {
Error::the().add("catch block must begin with catch*");
return nullptr;
}
VALUE_CAST(catch_binding, Symbol, (*std::next(catch_nodes.begin())));
// Create new Environment that binds 'y' to the value of the exception
auto catch_env = Environment::create(env);
catch_env->set(catch_binding->symbol(), error);
// Evaluate 'z' using the new Environment
m_ast = catch_nodes.back();
m_env = catch_env;
return evalImpl();
}
// -----------------------------------------
// (do 1 2 3) // (do 1 2 3)
void Eval::evalDo(const ValueVector& nodes, EnvironmentPtr env) void Eval::evalDo(const ValueVector& nodes, EnvironmentPtr env)
{ {
@ -167,14 +118,14 @@ void Eval::evalDo(const ValueVector& nodes, EnvironmentPtr env)
// Evaluate all nodes except the last // Evaluate all nodes except the last
for (auto it = nodes.begin(); it != std::prev(nodes.end(), 1); ++it) { for (auto it = nodes.begin(); it != std::prev(nodes.end(), 1); ++it) {
m_ast = *it; m_ast_stack.push(*it);
m_env = env; m_env_stack.push(env);
evalImpl(); evalImpl();
} }
// Eval last node // Eval last node
m_ast = nodes.back(); m_ast_stack.push(nodes.back());
m_env = env; m_env_stack.push(env);
return; // TCO return; // TCO
} }
@ -187,18 +138,18 @@ void Eval::evalIf(const ValueVector& nodes, EnvironmentPtr env)
auto second_argument = *std::next(nodes.begin()); auto second_argument = *std::next(nodes.begin());
auto third_argument = (nodes.size() == 3) ? *std::next(std::next(nodes.begin())) : makePtr<Constant>(Constant::Nil); auto third_argument = (nodes.size() == 3) ? *std::next(std::next(nodes.begin())) : makePtr<Constant>(Constant::Nil);
m_ast = first_argument; m_ast_stack.push(first_argument);
m_env = env; m_env_stack.push(env);
auto first_evaluated = evalImpl(); auto first_evaluated = evalImpl();
if (!is<Constant>(first_evaluated.get()) if (!is<Constant>(first_evaluated.get())
|| std::static_pointer_cast<Constant>(first_evaluated)->state() == Constant::True) { || std::static_pointer_cast<Constant>(first_evaluated)->state() == Constant::True) {
m_ast = second_argument; m_ast_stack.push(second_argument);
m_env = env; m_env_stack.push(env);
return; // TCO return; // TCO
} }
m_ast = third_argument; m_ast_stack.push(third_argument);
m_env = env; m_env_stack.push(env);
return; // TCO return; // TCO
} }
@ -222,16 +173,16 @@ void Eval::evalLet(const ValueVector& nodes, EnvironmentPtr env)
VALUE_CAST(elt, Symbol, (*it), void()); VALUE_CAST(elt, Symbol, (*it), void());
std::string key = elt->symbol(); std::string key = elt->symbol();
m_ast = *std::next(it); m_ast_stack.push(*std::next(it));
m_env = let_env; m_env_stack.push(let_env);
ValuePtr value = evalImpl(); ValuePtr value = evalImpl();
let_env->set(key, value); let_env->set(key, value);
} }
// TODO: Remove limitation of 3 arguments // TODO: Remove limitation of 3 arguments
// Eval all arguments in this new env, return last sexp of the result // Eval all arguments in this new env, return last sexp of the result
m_ast = *std::next(nodes.begin()); m_ast_stack.push(*std::next(nodes.begin()));
m_env = let_env; m_env_stack.push(let_env);
return; // TCO return; // TCO
} }
@ -326,8 +277,53 @@ void Eval::evalQuasiQuote(const ValueVector& nodes, EnvironmentPtr env)
auto result = evalQuasiQuoteImpl(nodes.front()); auto result = evalQuasiQuoteImpl(nodes.front());
m_ast = result; m_ast_stack.push(result);
m_env = env; m_env_stack.push(env);
return; // TCO
}
// (try* x (catch* y z))
void Eval::evalTry(const ValueVector& nodes, EnvironmentPtr env)
{
CHECK_ARG_COUNT_AT_LEAST("try*", nodes.size(), 1, void());
// Try 'x'
m_ast_stack.push(nodes.front());
m_env_stack.push(env);
auto result = evalImpl();
// Catch
if (nodes.size() == 2 && (Error::the().hasOtherError() || Error::the().hasException())) {
// Get the exception
auto error = (Error::the().hasOtherError())
? makePtr<String>(Error::the().otherError())
: Error::the().exception();
Error::the().clearErrors();
VALUE_CAST(catch_list, List, nodes.back(), void());
const auto& catch_nodes = catch_list->nodes();
CHECK_ARG_COUNT_IS("catch*", catch_nodes.size() - 1, 2, void());
VALUE_CAST(catch_symbol, Symbol, catch_nodes.front(), void());
if (catch_symbol->symbol() != "catch*") {
Error::the().add("catch block must begin with catch*");
return;
}
VALUE_CAST(catch_binding, Symbol, (*std::next(catch_nodes.begin())), void());
// Create new Environment that binds 'y' to the value of the exception
auto catch_env = Environment::create(env);
catch_env->set(catch_binding->symbol(), error);
// Evaluate 'z' using the new Environment
m_ast_stack.push(catch_nodes.back());
m_env_stack.push(catch_env);
return; // TCO
}
m_ast_stack.push(result);
m_env_stack.push(env);
return; // TCO return; // TCO
} }

53
src/eval.cpp
Unescape Voir le fichier

@ -23,7 +23,6 @@ namespace blaze {
Eval::Eval(ValuePtr ast, EnvironmentPtr env) Eval::Eval(ValuePtr ast, EnvironmentPtr env)
: m_ast(ast) : m_ast(ast)
, m_env(env) , m_env(env)
, m_outer_env(env)
{ {
} }
@ -31,6 +30,11 @@ Eval::Eval(ValuePtr ast, EnvironmentPtr env)
void Eval::eval() void Eval::eval()
{ {
m_ast_stack = std::stack<ValuePtr>();
m_env_stack = std::stack<EnvironmentPtr>();
m_ast_stack.push(m_ast);
m_env_stack.push(m_env);
m_ast = evalImpl(); m_ast = evalImpl();
} }
@ -44,13 +48,20 @@ ValuePtr Eval::evalImpl()
return nullptr; return nullptr;
} }
ast = m_ast; if (m_ast_stack.size() == 0) {
env = m_env; return nullptr;
}
if (env == nullptr) { if (m_env_stack.size() == 0) {
env = m_outer_env; m_env_stack.push(m_env);
} }
ast = m_ast_stack.top();
env = m_env_stack.top();
m_ast_stack.pop();
m_env_stack.pop();
if (!is<List>(ast.get())) { if (!is<List>(ast.get())) {
return evalAst(ast, env); return evalAst(ast, env);
} }
@ -89,9 +100,6 @@ ValuePtr Eval::evalImpl()
if (symbol == "quote") { if (symbol == "quote") {
return evalQuote(nodes); return evalQuote(nodes);
} }
if (symbol == "try*") {
return evalTry(nodes, env);
}
// Tail call optimized functions // Tail call optimized functions
if (symbol == "do") { if (symbol == "do") {
evalDo(nodes, env); evalDo(nodes, env);
@ -109,6 +117,10 @@ ValuePtr Eval::evalImpl()
evalQuasiQuote(nodes, env); evalQuasiQuote(nodes, env);
continue; // TCO continue; // TCO
} }
if (symbol == "try*") {
evalTry(nodes, env);
continue; // TCO
}
} }
auto evaluated_list = std::static_pointer_cast<List>(evalAst(ast, env)); auto evaluated_list = std::static_pointer_cast<List>(evalAst(ast, env));
@ -121,8 +133,8 @@ ValuePtr Eval::evalImpl()
if (is<Lambda>(evaluated_list->front().get())) { if (is<Lambda>(evaluated_list->front().get())) {
auto lambda = std::static_pointer_cast<Lambda>(evaluated_list->front()); auto lambda = std::static_pointer_cast<Lambda>(evaluated_list->front());
m_ast = lambda->body(); m_ast_stack.push(lambda->body());
m_env = Environment::create(lambda, evaluated_list->rest()); m_env_stack.push(Environment::create(lambda, evaluated_list->rest()));
continue; // TCO continue; // TCO
} }
@ -153,8 +165,8 @@ ValuePtr Eval::evalAst(ValuePtr ast, EnvironmentPtr env)
auto evaluated_nodes = ValueVector(count); auto evaluated_nodes = ValueVector(count);
for (size_t i = 0; i < count; ++i) { for (size_t i = 0; i < count; ++i) {
m_ast = nodes[i]; m_ast_stack.push(nodes[i]);
m_env = env; m_env_stack.push(env);
ValuePtr eval_node = evalImpl(); ValuePtr eval_node = evalImpl();
if (eval_node == nullptr) { if (eval_node == nullptr) {
return nullptr; return nullptr;
@ -169,19 +181,19 @@ ValuePtr Eval::evalAst(ValuePtr ast, EnvironmentPtr env)
return makePtr<Vector>(evaluated_nodes); return makePtr<Vector>(evaluated_nodes);
} }
else if (is<HashMap>(ast_raw_ptr)) { else if (is<HashMap>(ast_raw_ptr)) {
auto result = makePtr<HashMap>();
const auto& elements = std::static_pointer_cast<HashMap>(ast)->elements(); const auto& elements = std::static_pointer_cast<HashMap>(ast)->elements();
Elements evaluated_elements;
for (const auto& element : elements) { for (const auto& element : elements) {
m_ast = element.second; m_ast_stack.push(element.second);
m_env = env; m_env_stack.push(env);
ValuePtr element_node = evalImpl(); ValuePtr element_node = evalImpl();
if (element_node == nullptr) { if (element_node == nullptr) {
return nullptr; return nullptr;
} }
evaluated_elements.insert_or_assign(element.first, element_node); result->add(element.first, element_node);
} }
return makePtr<HashMap>(evaluated_elements); return result;
} }
return ast; return ast;
@ -219,19 +231,18 @@ ValuePtr Eval::macroExpand(ValuePtr ast, EnvironmentPtr env)
{ {
while (isMacroCall(ast, env)) { while (isMacroCall(ast, env)) {
auto list = std::static_pointer_cast<List>(ast); auto list = std::static_pointer_cast<List>(ast);
auto value = env->get(std::static_pointer_cast<Symbol>(list->front())->symbol()); auto value = env->get(std::static_pointer_cast<Symbol>(list->front())->symbol());
auto lambda = std::static_pointer_cast<Lambda>(value); auto lambda = std::static_pointer_cast<Lambda>(value);
m_ast = lambda->body(); m_ast_stack.push(lambda->body());
m_env = Environment::create(lambda, list->rest()); m_env_stack.push(Environment::create(lambda, list->rest()));
ast = evalImpl(); ast = evalImpl();
} }
return ast; return ast;
} }
// ----------------------------------------- //-----------------------------------------
ValuePtr Eval::apply(std::shared_ptr<List> evaluated_list) ValuePtr Eval::apply(std::shared_ptr<List> evaluated_list)
{ {

7
src/eval.h
Unescape Voir le fichier

@ -38,18 +38,19 @@ private:
ValuePtr evalMacroExpand(const ValueVector& nodes, EnvironmentPtr env); ValuePtr evalMacroExpand(const ValueVector& nodes, EnvironmentPtr env);
ValuePtr evalQuasiQuoteExpand(const ValueVector& nodes); ValuePtr evalQuasiQuoteExpand(const ValueVector& nodes);
ValuePtr evalQuote(const ValueVector& nodes); ValuePtr evalQuote(const ValueVector& nodes);
ValuePtr evalTry(const ValueVector& nodes, EnvironmentPtr env);
void evalDo(const ValueVector& nodes, EnvironmentPtr env); void evalDo(const ValueVector& nodes, EnvironmentPtr env);
void evalIf(const ValueVector& nodes, EnvironmentPtr env); void evalIf(const ValueVector& nodes, EnvironmentPtr env);
void evalLet(const ValueVector& nodes, EnvironmentPtr env); void evalLet(const ValueVector& nodes, EnvironmentPtr env);
void evalQuasiQuote(const ValueVector& nodes, EnvironmentPtr env); void evalQuasiQuote(const ValueVector& nodes, EnvironmentPtr env);
void evalTry(const ValueVector& nodes, EnvironmentPtr env);
ValuePtr apply(std::shared_ptr<List> evaluated_list); ValuePtr apply(std::shared_ptr<List> evaluated_list);
ValuePtr m_ast; ValuePtr m_ast;
EnvironmentPtr m_env; EnvironmentPtr m_env;
EnvironmentPtr m_outer_env;
std::stack<ValuePtr> m_ast_stack;
std::stack<EnvironmentPtr> m_env_stack;
}; };
} // namespace blaze } // namespace blaze

32
src/functions.cpp
Unescape Voir le fichier

@ -518,7 +518,7 @@ ADD_FUNCTION(
return makePtr<List>(collection->rest()); return makePtr<List>(collection->rest());
}); });
// (apply + 1 2 (list 3 4)) -> (+ 1 2 3 4) -> 10 // (apply + 1 2 (list 3 4)) -> (+ 1 2 3 4)
ADD_FUNCTION( ADD_FUNCTION(
"apply", "apply",
{ {
@ -712,16 +712,16 @@ ADD_FUNCTION(
{ {
CHECK_ARG_COUNT_EVEN("hash-map", SIZE()); CHECK_ARG_COUNT_EVEN("hash-map", SIZE());
Elements elements; auto result = makePtr<HashMap>();
for (auto it = begin; it != end; std::advance(it, 2)) { for (auto it = begin; it != end; std::advance(it, 2)) {
const ValuePtr& value = *(std::next(it)); // temporary instance to get around const result->add(*it, *(std::next(it)));
elements.insert_or_assign(HashMap::getKeyString(*it), value);
} }
return makePtr<HashMap>(elements); return result;
}); });
// (assoc {:a 1 :b 2} :a 3 :c 1) -> {:a 3 :b 2 :c 1} // (assoc {:a 1 :b 2} :a 3 :c 1)
ADD_FUNCTION( ADD_FUNCTION(
"assoc", "assoc",
{ {
@ -732,16 +732,15 @@ ADD_FUNCTION(
CHECK_ARG_COUNT_EVEN("assoc", SIZE()); CHECK_ARG_COUNT_EVEN("assoc", SIZE());
Elements elements(hash_map->elements()); auto result = makePtr<HashMap>(hash_map->elements());
for (auto it = begin; it != end; std::advance(it, 2)) { for (auto it = begin; it != end; std::advance(it, 2)) {
const ValuePtr& value = *(std::next(it)); // temporary instance to get around const result->add(*it, *(std::next(it)));
elements.insert_or_assign(HashMap::getKeyString(*it), value);
} }
return makePtr<HashMap>(elements); return result;
}); });
// (dissoc {:a 1 :b 2 :c 3} :a :c :d) -> {:b 2}
ADD_FUNCTION( ADD_FUNCTION(
"dissoc", "dissoc",
{ {
@ -750,12 +749,13 @@ ADD_FUNCTION(
VALUE_CAST(hash_map, HashMap, (*begin)); VALUE_CAST(hash_map, HashMap, (*begin));
begin++; begin++;
Elements elements(hash_map->elements()); auto result = makePtr<HashMap>(hash_map->elements());
for (auto it = begin; it != end; ++it) { for (auto it = begin; it != end; ++it) {
elements.erase(HashMap::getKeyString(*it)); result->remove(*it);
} }
return makePtr<HashMap>(elements); return result;
}); });
// (get {:kw "value"} :kw) -> "value" // (get {:kw "value"} :kw) -> "value"
@ -984,8 +984,8 @@ ADD_FUNCTION(
void installFunctions(EnvironmentPtr env) void installFunctions(EnvironmentPtr env)
{ {
for (const auto& [name, function] : s_functions) { for (const auto& [name, lambda] : s_functions) {
env->set(name, makePtr<Function>(name, function)); env->set(name, makePtr<Function>(name, lambda));
} }
} }

6
src/reader.cpp
Unescape Voir le fichier

@ -174,7 +174,7 @@ ValuePtr Reader::readHashMap()
{ {
ignore(); // { ignore(); // {
Elements elements; auto hash_map = makePtr<HashMap>();
while (!isEOF() && peek().type != Token::Type::BraceClose) { while (!isEOF() && peek().type != Token::Type::BraceClose) {
auto key = readImpl(); auto key = readImpl();
@ -193,7 +193,7 @@ ValuePtr Reader::readHashMap()
} }
auto value = readImpl(); auto value = readImpl();
elements.insert_or_assign(HashMap::getKeyString(key), value); hash_map->add(key, value);
} }
if (!consumeSpecific(Token { .type = Token::Type::BraceClose })) { // } if (!consumeSpecific(Token { .type = Token::Type::BraceClose })) { // }
@ -201,7 +201,7 @@ ValuePtr Reader::readHashMap()
return nullptr; return nullptr;
} }
return makePtr<HashMap>(elements); return hash_map;
} }
ValuePtr Reader::readQuote() ValuePtr Reader::readQuote()

8
src/step6_file.cpp
Unescape Voir le fichier

@ -94,9 +94,11 @@ static auto installLambdas(EnvironmentPtr env) -> void
static auto makeArgv(EnvironmentPtr env, std::vector<std::string> arguments) -> void static auto makeArgv(EnvironmentPtr env, std::vector<std::string> arguments) -> void
{ {
size_t count = arguments.size(); size_t count = arguments.size();
auto nodes = ValueVector(); auto nodes = ValueVector(count - 1);
for (size_t i = 1; i < count; ++i) { if (count > 1) {
nodes.push_back(makePtr<String>(arguments[i])); for (size_t i = 1; i < count; ++i) {
nodes.at(i) = makePtr<String>(arguments[i]);
}
} }
env->set("*ARGV*", makePtr<List>(nodes)); env->set("*ARGV*", makePtr<List>(nodes));
} }

8
src/step7_quote.cpp
Unescape Voir le fichier

@ -94,9 +94,11 @@ static auto installLambdas(EnvironmentPtr env) -> void
static auto makeArgv(EnvironmentPtr env, std::vector<std::string> arguments) -> void static auto makeArgv(EnvironmentPtr env, std::vector<std::string> arguments) -> void
{ {
size_t count = arguments.size(); size_t count = arguments.size();
auto nodes = ValueVector(); auto nodes = ValueVector(count - 1);
for (size_t i = 1; i < count; ++i) { if (count > 1) {
nodes.push_back(makePtr<String>(arguments[i])); for (size_t i = 1; i < count; ++i) {
nodes.at(i) = makePtr<String>(arguments[i]);
}
} }
env->set("*ARGV*", makePtr<List>(nodes)); env->set("*ARGV*", makePtr<List>(nodes));
} }

8
src/step8_macros.cpp
Unescape Voir le fichier

@ -101,9 +101,11 @@ static auto installLambdas(EnvironmentPtr env) -> void
static auto makeArgv(EnvironmentPtr env, std::vector<std::string> arguments) -> void static auto makeArgv(EnvironmentPtr env, std::vector<std::string> arguments) -> void
{ {
size_t count = arguments.size(); size_t count = arguments.size();
auto nodes = ValueVector(); auto nodes = ValueVector(count - 1);
for (size_t i = 1; i < count; ++i) { if (count > 1) {
nodes.push_back(makePtr<String>(arguments[i])); for (size_t i = 1; i < count; ++i) {
nodes.at(i) = makePtr<String>(arguments[i]);
}
} }
env->set("*ARGV*", makePtr<List>(nodes)); env->set("*ARGV*", makePtr<List>(nodes));
} }

8
src/step9_try.cpp
Unescape Voir le fichier

@ -101,9 +101,11 @@ static auto installLambdas(EnvironmentPtr env) -> void
static auto makeArgv(EnvironmentPtr env, std::vector<std::string> arguments) -> void static auto makeArgv(EnvironmentPtr env, std::vector<std::string> arguments) -> void
{ {
size_t count = arguments.size(); size_t count = arguments.size();
auto nodes = ValueVector(); auto nodes = ValueVector(count - 1);
for (size_t i = 1; i < count; ++i) { if (count > 1) {
nodes.push_back(makePtr<String>(arguments[i])); for (size_t i = 1; i < count; ++i) {
nodes.at(i) = makePtr<String>(arguments[i]);
}
} }
env->set("*ARGV*", makePtr<List>(nodes)); env->set("*ARGV*", makePtr<List>(nodes));
} }

8
src/stepA_mal.cpp
Unescape Voir le fichier

@ -113,9 +113,11 @@ static auto installLambdas(EnvironmentPtr env) -> void
static auto makeArgv(EnvironmentPtr env, std::vector<std::string> arguments) -> void static auto makeArgv(EnvironmentPtr env, std::vector<std::string> arguments) -> void
{ {
size_t count = arguments.size(); size_t count = arguments.size();
auto nodes = ValueVector(); auto nodes = ValueVector(count - 1);
for (size_t i = 1; i < count; ++i) { if (count > 1) {
nodes.push_back(makePtr<String>(arguments[i])); for (size_t i = 1; i < count; ++i) {
nodes.at(i) = makePtr<String>(arguments[i]);
}
} }
env->set("*ARGV*", makePtr<List>(nodes)); env->set("*ARGV*", makePtr<List>(nodes));
} }

Écrire Aperçu
Chargement…
Annuler
Enregistrer