├── .gitignore
├── bench
    ├── .gitignore
    ├── try.sl
    ├── stack1.sl
    ├── stack2.sl
    ├── task.sl
    ├── fib2.sl
    ├── stack1.py
    ├── fib1.sl
    ├── bench.py
    ├── fib1.py
    ├── try.py
    ├── fib3.py
    └── task.py
├── logo.png
├── src
    ├── snabl
    │   ├── sym.cpp
    │   ├── try.cpp
    │   ├── file.hpp
    │   ├── repl.hpp
    │   ├── libs
    │   │   ├── abc.hpp
    │   │   └── abc.cpp
    │   ├── runtime_error.cpp
    │   ├── async.hpp
    │   ├── pos.hpp
    │   ├── lambda.cpp
    │   ├── target.cpp
    │   ├── macro.cpp
    │   ├── ptrs.hpp
    │   ├── types.hpp
    │   ├── types
    │   │   ├── time.hpp
    │   │   ├── meta.cpp
    │   │   ├── meta.hpp
    │   │   ├── time.cpp
    │   │   ├── error.hpp
    │   │   ├── file.hpp
    │   │   ├── rwfile.hpp
    │   │   ├── error.cpp
    │   │   ├── float.hpp
    │   │   ├── nil.hpp
    │   │   ├── async.hpp
    │   │   ├── lambda.hpp
    │   │   ├── bool.hpp
    │   │   ├── async.cpp
    │   │   ├── sym.hpp
    │   │   ├── file.cpp
    │   │   ├── byte.hpp
    │   │   ├── char.hpp
    │   │   ├── nil.cpp
    │   │   ├── i64.hpp
    │   │   ├── iter.hpp
    │   │   ├── float.cpp
    │   │   ├── lambda.cpp
    │   │   ├── sym.cpp
    │   │   ├── byte.cpp
    │   │   ├── bin.hpp
    │   │   ├── bool.cpp
    │   │   ├── stack.hpp
    │   │   ├── enum.hpp
    │   │   ├── str.hpp
    │   │   ├── iter.cpp
    │   │   ├── char.cpp
    │   │   ├── enum.cpp
    │   │   ├── i64.cpp
    │   │   ├── stack.cpp
    │   │   ├── bin.cpp
    │   │   └── str.cpp
    │   ├── iter.cpp
    │   ├── stack.hpp
    │   ├── try.hpp
    │   ├── timer.hpp
    │   ├── timer.cpp
    │   ├── var.hpp
    │   ├── def.hpp
    │   ├── fmt.hpp
    │   ├── stack.cpp
    │   ├── iter.hpp
    │   ├── user_error.hpp
    │   ├── cmp.hpp
    │   ├── target.hpp
    │   ├── state.hpp
    │   ├── time.hpp
    │   ├── call.cpp
    │   ├── call.hpp
    │   ├── runtime_error.hpp
    │   ├── scope.hpp
    │   ├── atype.cpp
    │   ├── macro.hpp
    │   ├── lambda.hpp
    │   ├── std.hpp
    │   ├── type.hpp
    │   ├── fmt.cpp
    │   ├── task.hpp
    │   ├── repl.cpp
    │   ├── state.cpp
    │   ├── fimp.hpp
    │   ├── sym.hpp
    │   ├── parser.hpp
    │   ├── error.hpp
    │   ├── mpool.hpp
    │   ├── bset.hpp
    │   ├── lib.cpp
    │   ├── func.hpp
    │   ├── fimp.cpp
    │   ├── lib.hpp
    │   ├── atype.hpp
    │   ├── ptr.hpp
    │   ├── box.hpp
    │   ├── env.cpp
    │   ├── form.hpp
    │   ├── parser.cpp
    │   ├── op.hpp
    │   ├── form.cpp
    │   ├── env.hpp
    │   └── op.cpp
    ├── tests.hpp
    ├── tests.cpp
    └── main.cpp
├── CMakeLists.txt
├── LICENSE.txt
├── todo.org
├── tests
    └── all.sl
├── README.md
└── logo.svg


/.gitignore:
--------------------------------------------------------------------------------
1 | *.*~
2 | build
3 | 


--------------------------------------------------------------------------------
/bench/.gitignore:
--------------------------------------------------------------------------------
1 | __pycache__
2 | 


--------------------------------------------------------------------------------
/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codr4life/snabl/HEAD/logo.png


--------------------------------------------------------------------------------
/src/snabl/sym.cpp:
--------------------------------------------------------------------------------
1 | #include "snabl/sym.hpp"
2 | 
3 | namespace snabl {
4 | }
5 | 


--------------------------------------------------------------------------------
/bench/try.sl:
--------------------------------------------------------------------------------
1 | 10000 bench: (
2 |   10 times: (
3 |     try: (42 throw!)
4 |     drop!
5 |   )
6 | ) ms say


--------------------------------------------------------------------------------
/bench/stack1.sl:
--------------------------------------------------------------------------------
1 | 10000 bench: {
2 |   [] let: lst
3 |   100 times: (@lst [] push)
4 |   100 times: (@lst pop)
5 | } ms say


--------------------------------------------------------------------------------
/bench/stack2.sl:
--------------------------------------------------------------------------------
1 | 10000 bench: (
2 |   []
3 |   100 times: (dup! [] push)
4 |   100 times: (dup! pop)
5 |   drop!
6 | ) ms say


--------------------------------------------------------------------------------
/bench/task.sl:
--------------------------------------------------------------------------------
1 | 10000 bench: (
2 |   task: (100 times: yield!)
3 |   task: (100 times: yield!)
4 |   100 times: yield!
5 | ) ms say


--------------------------------------------------------------------------------
/src/tests.hpp:
--------------------------------------------------------------------------------
1 | #ifndef SNABL_TESTS_HPP
2 | #define SNABL_TESTS_HPP
3 | 
4 | namespace snabl {
5 | 	void all_tests();
6 | }
7 | 
8 | #endif
9 | 


--------------------------------------------------------------------------------
/bench/fib2.sl:
--------------------------------------------------------------------------------
1 | 10000 bench: (
2 |   20 0 1 &(
3 |     rswap! switch:,
4 |       0? sdrop!
5 |       1? drop!,
6 |       -- rswap! dup! rot! + recall!
7 |   ) call! drop!
8 | ) ms say


--------------------------------------------------------------------------------
/src/snabl/try.cpp:
--------------------------------------------------------------------------------
1 | #include "snabl/env.hpp"
2 | #include "snabl/try.hpp"
3 | 
4 | namespace snabl {
5 |   Try::Try(Env &env, ops::Try &op): prev(env._try()), op(op), state(env) { }
6 | }
7 | 


--------------------------------------------------------------------------------
/bench/stack1.py:
--------------------------------------------------------------------------------
1 | from bench import bench
2 | 
3 | def test():
4 |     lst = []
5 |     for _ in range(100): lst.append([])
6 |     for _ in range(100): lst.pop()
7 | 
8 | print(int(bench(10000)))
9 | 


--------------------------------------------------------------------------------
/bench/fib1.sl:
--------------------------------------------------------------------------------
 1 | func: tail-fib<I64 I64 I64> {
 2 |   let: (n a b)
 3 | 
 4 |   @n switch:,
 5 |     0? @a
 6 |     1? @b,
 7 |     -- @b dup! @a + recall!
 8 | }
 9 | 
10 | 10000 bench: (20 0 1 tail-fib drop!) ms say


--------------------------------------------------------------------------------
/bench/bench.py:
--------------------------------------------------------------------------------
1 | from timeit import Timer
2 | 
3 | setup = 'gc.enable(); from __main__ import test'
4 | 
5 | def bench(reps):
6 |     Timer('test()', setup).timeit(reps)
7 |     return Timer('test()', setup).timeit(reps)*1000
8 | 


--------------------------------------------------------------------------------
/bench/fib1.py:
--------------------------------------------------------------------------------
 1 | from bench import bench
 2 | 
 3 | def fib(n, a, b):
 4 |     return a if n == 0 else b if n == 1 else fib(n-1, b, a+b)
 5 | 
 6 | def test():
 7 |     fib(20, 0, 1)
 8 |     
 9 | print(int(bench(10000)))
10 | 


--------------------------------------------------------------------------------
/bench/try.py:
--------------------------------------------------------------------------------
 1 | from bench import bench
 2 | 
 3 | def test():
 4 |     for _ in range(10):
 5 |         try:
 6 |             raise 42
 7 |         except Exception as e:
 8 |             pass
 9 | 
10 | print(int(bench(10000)))
11 | 


--------------------------------------------------------------------------------
/src/snabl/file.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_FILE_HPP
 2 | #define SNABL_FILE_HPP
 3 | 
 4 | #include "snabl/ptrs.hpp"
 5 | 
 6 | namespace snabl {
 7 |   using File = fstream;
 8 |   using FilePtr = Ptr<File>; 
 9 | }
10 | 
11 | #endif
12 | 


--------------------------------------------------------------------------------
/src/snabl/repl.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_REPL_HPP
 2 | #define SNABL_REPL_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | 
 6 | namespace snabl { 
 7 |   struct Env;
 8 | 
 9 |   void repl(Env &env, istream &in, ostream &out);
10 | }
11 | 
12 | #endif
13 | 


--------------------------------------------------------------------------------
/src/snabl/libs/abc.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_LIB_ABC_HPP
 2 | #define SNABL_LIB_ABC_HPP
 3 | 
 4 | #include "snabl/lib.hpp"
 5 | 
 6 | namespace snabl::libs {
 7 |   struct Abc: Lib {
 8 |     Abc(Env &env);
 9 |     void init();
10 |   };
11 | }
12 | 
13 | #endif
14 | 


--------------------------------------------------------------------------------
/bench/fib3.py:
--------------------------------------------------------------------------------
 1 | from bench import bench
 2 | 
 3 | def fib(n):
 4 |     a, b = 0, 1
 5 | 
 6 |     for _ in range(n):
 7 |         a, b = b, a
 8 |         b += a
 9 | 
10 |     return b
11 | 
12 | def test():
13 |     fib(20)
14 | 
15 | print(int(bench(10000)))
16 | 


--------------------------------------------------------------------------------
/src/snabl/runtime_error.cpp:
--------------------------------------------------------------------------------
1 | #include "snabl/env.hpp"
2 | #include "snabl/runtime_error.hpp"
3 | 
4 | namespace snabl {
5 |   RuntimeError::RuntimeError(Env &env, const string &msg):
6 |     Error(), run_msg(msg), pos(env.pos()), stack(env.task->stack) { }
7 | }
8 | 


--------------------------------------------------------------------------------
/src/snabl/async.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_ASYNC_HPP
 2 | #define SNABL_ASYNC_HPP
 3 | 
 4 | #include "snabl/box.hpp"
 5 | #include "snabl/ptr.hpp"
 6 | 
 7 | namespace snabl {
 8 |   using Async = future<optional<Box>>;
 9 |   using AsyncPtr = Ptr<Async>;  
10 | }
11 | 
12 | #endif
13 | 


--------------------------------------------------------------------------------
/src/snabl/pos.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_POS_HPP
 2 | #define SNABL_POS_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | #include "snabl/types.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct Pos {
 9 |     I64 row, col;
10 |     Pos(I64 row, I64 col): row(row), col(col) { } 
11 |   };
12 | }
13 | 
14 | #endif
15 | 


--------------------------------------------------------------------------------
/src/snabl/lambda.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/env.hpp"
 2 | #include "snabl/lambda.hpp"
 3 | 
 4 | namespace snabl {
 5 |   void Lambda::call(Env &env, Pos pos) const {
 6 |     if (vars) { env.begin_scope(*vars); }
 7 |     env.begin_call(*this, pos, env.pc());
 8 |     env.jump(start_pc);
 9 |   }
10 | }
11 | 


--------------------------------------------------------------------------------
/src/snabl/target.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/scope.hpp"
 2 | #include "snabl/target.hpp"
 3 | 
 4 | namespace snabl {
 5 |   Target::Target(Scope *parent_scope, PC start_pc, I64 end_pc):
 6 |     start_pc(start_pc), end_pc(end_pc) {
 7 |     if (parent_scope) { vars.emplace(parent_scope->vars.vals); }
 8 |   }
 9 | }
10 | 


--------------------------------------------------------------------------------
/bench/task.py:
--------------------------------------------------------------------------------
 1 | from bench import bench
 2 | 
 3 | def test():
 4 |     def task():
 5 |         for _ in range(100): yield
 6 |         
 7 |     t1, t2, t3 = task(), task(), task()
 8 |     
 9 |     for _ in range(100):
10 |         next(t1)
11 |         next(t2)
12 |         next(t3)
13 | 
14 | print(int(bench(10000)))
15 | 


--------------------------------------------------------------------------------
/src/snabl/macro.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/macro.hpp"
 2 | 
 3 | namespace snabl {
 4 |   Macro::Macro(Lib &lib, Sym id, const Imp &imp): Def(id), lib(lib), imp(imp) { }
 5 | 
 6 |   void Macro::call(Forms::const_iterator &in,
 7 |                    Forms::const_iterator end,
 8 |                    Env &env) { imp(in, end, env); }
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/snabl/ptrs.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_PTRS_HPP
 2 | #define SNABL_PTRS_HPP
 3 | 
 4 | #include "snabl/ptr.hpp"
 5 | #include "snabl/std.hpp"
 6 | #include "snabl/types.hpp"
 7 | 
 8 | namespace snabl {
 9 |   using BinPtr = Ptr<Bin>;
10 |   using StrPtr = Ptr<Str>;
11 | 
12 |   struct Op;
13 |   using PC = Op *;
14 | }
15 | 
16 | #endif
17 | 


--------------------------------------------------------------------------------
/src/snabl/types.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPES_HPP
 2 | #define SNABL_TYPES_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | 
 6 | namespace snabl {
 7 |   using Byte = uint8_t;
 8 |   using Bin = vector<Byte>;
 9 |   using Char = char;
10 |   using Float = long double;
11 |   using I64 = int64_t;
12 |   using Str = string;
13 | }
14 | 
15 | #endif
16 | 


--------------------------------------------------------------------------------
/src/snabl/types/time.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_TIME_HPP
 2 | #define SNABL_TYPE_TIME_HPP
 3 | 
 4 | #include "snabl/time.hpp"
 5 | 
 6 | namespace snabl {
 7 |   struct TimeType: Type<Time> {
 8 |     TimeType(Lib &lib, Sym id, const vector<AType *> &parents);
 9 |     void dump(const Box &val, ostream &out) const override;
10 |   };
11 | }
12 | 
13 | #endif
14 | 


--------------------------------------------------------------------------------
/src/snabl/iter.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/iter.hpp"
 2 | #include "snabl/runtime_error.hpp"
 3 | 
 4 | namespace snabl {
 5 |   bool Iter::call(Env &env) {
 6 |     if (is_done) { throw RuntimeError(env, "Iter is done"); }
 7 |     
 8 |     if (!imp()) {
 9 |       is_done = true;
10 |       return false;
11 |     }
12 |     
13 |     return true;
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/snabl/stack.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_STACK_HPP
 2 | #define SNABL_STACK_HPP
 3 | 
 4 | #include "snabl/box.hpp"
 5 | #include "snabl/ptr.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct Iter;
 9 |   
10 |   using Stack = vector<Box>;
11 |   using StackPtr = Ptr<Stack>;
12 |   
13 |   ostream &operator <<(ostream &out, const Stack &stack);
14 | }
15 | 
16 | #endif
17 | 


--------------------------------------------------------------------------------
/src/snabl/try.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TRY_HPP
 2 | #define SNABL_TRY_HPP
 3 | 
 4 | #include "snabl/state.hpp"
 5 | 
 6 | namespace snabl {
 7 |   struct Env;
 8 |   namespace ops { struct Try; }
 9 | 
10 |   struct Try {
11 |     Try *prev;
12 |     ops::Try &op;
13 |     State state;
14 | 
15 |     Try(Env &env, ops::Try &op);
16 |   };
17 | }
18 | 
19 | #endif
20 | 


--------------------------------------------------------------------------------
/src/snabl/timer.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TIMER_HPP
 2 | #define SNABL_TIMER_HPP
 3 | 
 4 | #include "snabl/types.hpp"
 5 | 
 6 | namespace snabl {
 7 |   struct Timer {
 8 |     static steady_clock::time_point now();
 9 | 
10 |     steady_clock::time_point start;
11 |     
12 |     Timer();
13 |     void reset();
14 |     I64 ns() const;
15 |   };
16 | }
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/src/snabl/types/meta.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/box.hpp"
 2 | #include "snabl/types/meta.hpp"
 3 | 
 4 | namespace snabl {
 5 |   MetaType::MetaType(Lib &lib, Sym id, const vector<AType *> &parents):
 6 |     Type<AType *>(lib, id, parents) { }
 7 | 
 8 |   void MetaType::dump(const Box &val, ostream &out) const {
 9 |     out << val.as<AType *>()->id;
10 |   }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/snabl/timer.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/timer.hpp"
 2 | 
 3 | namespace snabl {
 4 |   steady_clock::time_point Timer::now() { return steady_clock::now(); }
 5 | 
 6 |   Timer::Timer(): start(now()) { }
 7 | 
 8 |   void Timer::reset() { start = now(); }
 9 |   
10 |   I64 Timer::ns() const {
11 |     return duration_cast<nanoseconds>(now() - start).count();
12 |   }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/snabl/var.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_VAR_HPP
 2 | #define SNABL_VAR_HPP
 3 | 
 4 | #include "snabl/box.hpp"
 5 | #include "snabl/sym.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct Var {
 9 |     Sym key;
10 |     Box val;
11 | 
12 |     template <typename...ArgsT>
13 |     Var(Sym key, ArgsT &&...args): key(key), val(forward<ArgsT>(args)...) { }
14 |   };
15 | }
16 | 
17 | #endif
18 | 


--------------------------------------------------------------------------------
/src/snabl/types/meta.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_META_HPP
 2 | #define SNABL_TYPE_META_HPP
 3 | 
 4 | #include "snabl/type.hpp"
 5 | #include "snabl/ptrs.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct MetaType: Type<AType *> {
 9 |     MetaType(Lib &lib, Sym id, const vector<AType *> &parents);
10 |     void dump(const Box &val, ostream &out) const override;
11 |   };
12 | }
13 | 
14 | #endif
15 | 


--------------------------------------------------------------------------------
/src/snabl/types/time.cpp:
--------------------------------------------------------------------------------
 1 | #include <ostream>
 2 | 
 3 | #include "snabl/box.hpp"
 4 | #include "snabl/types/time.hpp"
 5 | 
 6 | namespace snabl {
 7 |   TimeType::TimeType(Lib &lib, Sym id, const vector<AType *> &parents):
 8 |     Type<Time>(lib, id, parents) { }
 9 | 
10 |   void TimeType::dump(const Box &val, ostream &out) const {
11 |     out << val.as_time.ns << "ns";
12 |   }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/snabl/def.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_DEF_HPP
 2 | #define SNABL_DEF_HPP
 3 | 
 4 | #include "snabl/sym.hpp"
 5 | 
 6 | namespace snabl {
 7 |   struct Def {
 8 |     const Sym id;
 9 | 
10 |     Def(Sym id): id(id) { }
11 |     virtual ~Def() { }
12 |   };
13 | 
14 |   inline ostream &operator <<(ostream &out, const Def &x) {
15 |     out << x.id;
16 |     return out;
17 |   }
18 | }
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/src/snabl/fmt.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_FMT_HPP
 2 | #define SNABL_FMT_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | 
 6 | namespace snabl {	
 7 | 	struct fmt_conv {
 8 | 		template <typename T>
 9 | 		fmt_conv(const T& v): print([&v](ostream &out) { out << v; }) { }
10 | 		const function<void (ostream &)> print;
11 | 	};
12 | 	
13 | 	string fmt(string_view spec, const vector<fmt_conv> &args);
14 | }
15 | 
16 | #endif
17 | 


--------------------------------------------------------------------------------
/src/tests.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/fmt.hpp"
 2 | #include "snabl/std.hpp"
 3 | 
 4 | namespace snabl {
 5 | 	void fmt_tests() {
 6 | 		assert(fmt("%0 %1 %2", {"foo", "bar", 42}) == "foo bar 42");
 7 | 		assert(fmt("%0 %%1 %1", {"foo", "bar"}) == "foo %1 bar");
 8 | 		assert(fmt("%0 %0", {""}) == " ");
 9 | 		assert(fmt("%%0", {}) == "%0");
10 | 	}
11 | 
12 | 	void all_tests() {
13 | 		fmt_tests();
14 | 	}
15 | }
16 | 


--------------------------------------------------------------------------------
/src/snabl/stack.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/iter.hpp"
 2 | #include "snabl/stack.hpp"
 3 | 
 4 | namespace snabl {
 5 |   ostream &operator <<(ostream &out, const Stack &stack) {
 6 |     out << '[';
 7 |     char sep(0);
 8 |     
 9 |     for (auto &v: stack) {
10 |       if (sep) { out << sep; }
11 |       v.dump(out);
12 |       sep = ' ';
13 |     }
14 |     
15 |     out << ']';
16 |     return out;
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/snabl/types/error.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_ERROR_HPP
 2 | #define SNABL_TYPE_ERROR_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | #include "snabl/type.hpp"
 6 | #include "snabl/user_error.hpp"
 7 | 
 8 | namespace snabl {
 9 |   struct ErrorType: Type<UserError> {
10 |     ErrorType(Lib &lib, Sym id, const vector<AType *> &parents);
11 |     void dump(const Box &val, ostream &out) const override;
12 |   };
13 | }
14 | 
15 | #endif
16 | 


--------------------------------------------------------------------------------
/src/snabl/types/file.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_FILE_HPP
 2 | #define SNABL_TYPE_FILE_HPP
 3 | 
 4 | #include "snabl/file.hpp"
 5 | #include "snabl/type.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct FileType: PtrType<File> {
 9 |     FileType(Lib &lib, Sym id, const vector<AType *> &parents);
10 |     bool as_bool(const Box &val) const override;
11 |     void dump(const Box &val, ostream &out) const override;
12 |   };
13 | }
14 | 
15 | #endif
16 | 


--------------------------------------------------------------------------------
/src/snabl/types/rwfile.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_RWFILE_HPP
 2 | #define SNABL_TYPE_RWFILE_HPP
 3 | 
 4 | #include "snabl/file.hpp"
 5 | #include "snabl/std.hpp"
 6 | #include "snabl/type.hpp"
 7 | 
 8 | namespace snabl {
 9 |   struct RWFileType: Type<RWFilePtr> {
10 |     RWFileType(Lib &lib, Sym id);
11 |     bool as_bool(const Box &val) const;
12 |     void dump(const Box &val, ostream &out) const override;
13 |   };
14 | }
15 | 
16 | #endif
17 | 


--------------------------------------------------------------------------------
/src/snabl/types/error.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/box.hpp"
 2 | #include "snabl/env.hpp"
 3 | #include "snabl/types/error.hpp"
 4 | 
 5 | namespace snabl {
 6 |   ErrorType::ErrorType(Lib &lib, Sym id, const vector<AType *> &parents):
 7 |     Type<UserError>(lib, id, parents) { }
 8 | 
 9 |   void ErrorType::dump(const Box &val, ostream &out) const {
10 |     out << "(Error ";
11 |     val.as<UserError>().val.dump(out);
12 |     out << ')';
13 |   }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/snabl/iter.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_ITER_HPP
 2 | #define SNABL_ITER_HPP
 3 | 
 4 | #include "snabl/ptr.hpp"
 5 | #include "snabl/std.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct Env;
 9 |   
10 |   struct Iter {
11 |     using Imp = function<bool ()>;
12 | 
13 |     Imp imp;
14 |     bool is_done;
15 | 
16 |     Iter(Imp imp): imp(imp), is_done(false) { }
17 |     bool call(Env &env);
18 |   };
19 | 
20 |   using IterPtr = Ptr<Iter>;
21 | }
22 | 
23 | #endif
24 | 


--------------------------------------------------------------------------------
/src/snabl/types/float.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_FLOAT_HPP
 2 | #define SNABL_TYPE_FLOAT_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | #include "snabl/type.hpp"
 6 | 
 7 | namespace snabl {  
 8 |   struct FloatType: Type<Float> {
 9 |     FloatType(Lib &lib, Sym id, const vector<AType *> &parents);
10 |     Cmp cmp(const Box &lhs, const Box &rhs) const override;   
11 |     void dump(const Box &val, ostream &out) const override;
12 |   };
13 | }
14 | 
15 | #endif
16 | 


--------------------------------------------------------------------------------
/src/snabl/types/nil.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_NIL_HPP
 2 | #define SNABL_TYPE_NIL_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | #include "snabl/type.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct Nil { };
 9 |   
10 |   struct NilType: Type<Nil> {
11 |     NilType(Lib &lib, Sym id, const vector<AType *> &parents);
12 |     bool as_bool(const Box &val) const override;
13 |     void dump(const Box &val, ostream &out) const override;
14 |   };
15 | }
16 | 
17 | #endif
18 | 


--------------------------------------------------------------------------------
/src/snabl/types/async.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_ASYNC_HPP
 2 | #define SNABL_TYPE_ASYNC_HPP
 3 | 
 4 | #include "snabl/async.hpp"
 5 | #include "snabl/std.hpp"
 6 | #include "snabl/type.hpp"
 7 | 
 8 | namespace snabl {
 9 |   struct AsyncType: PtrType<Async> {
10 |     AsyncType(Lib &lib, Sym id, const vector<AType *> &parents);
11 |     bool as_bool(const Box &val) const override;
12 |     void dump(const Box &val, ostream &out) const override;
13 |   };
14 | }
15 | 
16 | #endif
17 | 


--------------------------------------------------------------------------------
/src/snabl/types/lambda.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_LAMBDA_HPP
 2 | #define SNABL_TYPE_LAMBDA_HPP
 3 | 
 4 | #include "snabl/ptrs.hpp"
 5 | #include "snabl/std.hpp"
 6 | #include "snabl/type.hpp"
 7 | 
 8 | namespace snabl {
 9 |   struct LambdaType: Type<Lambda> {
10 |     LambdaType(Lib &lib, Sym id, const vector<AType *> &parents);
11 |     void call(const Box &val, Pos pos) const override;
12 |     void dump(const Box &val, ostream &out) const override;
13 |   };
14 | }
15 | 
16 | #endif
17 | 


--------------------------------------------------------------------------------
/src/snabl/user_error.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_USER_ERROR_HPP
 2 | #define SNABL_USER_ERROR_HPP
 3 | 
 4 | #include "snabl/runtime_error.hpp"
 5 | 
 6 | namespace snabl {
 7 |   struct UserError: RuntimeError {
 8 |     const Box val;
 9 |     
10 |     UserError(Env &env, const Box &val): RuntimeError(env, ""), val(val) { }
11 | 
12 |     string generate_msg() const override {
13 |       stringstream buf;
14 |       buf << val;
15 |       return buf.str();
16 |     }
17 |   };
18 | }
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/src/snabl/cmp.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_CMP_HPP
 2 | #define SNABL_CMP_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | 
 6 | namespace snabl { 
 7 |   enum struct Cmp {LT, EQ, GT};
 8 | 
 9 |   template <typename ValueT>
10 |   Cmp cmp(const ValueT &lhs, const ValueT &rhs) {
11 |     if (lhs < rhs) { return Cmp::LT; }
12 |     return (lhs == rhs) ? Cmp::EQ : Cmp::GT;
13 |   }
14 | 
15 |   template <>
16 |   inline Cmp cmp(const nullptr_t &lhs, const nullptr_t &rhs) { return Cmp::EQ; }
17 | }
18 | 
19 | #endif
20 | 


--------------------------------------------------------------------------------
/src/snabl/types/bool.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_BOOL_HPP
 2 | #define SNABL_TYPE_BOOL_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | #include "snabl/type.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct BoolType: Type<bool> {
 9 |     BoolType(Lib &lib, Sym id, const vector<AType *> &parents);
10 |     bool as_bool(const Box &val) const override;
11 |     Cmp cmp(const Box &lhs, const Box &rhs) const override;
12 |     void dump(const Box &val, ostream &out) const override;
13 |   };
14 | }
15 | 
16 | #endif
17 | 


--------------------------------------------------------------------------------
/src/snabl/types/async.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/box.hpp"
 2 | #include "snabl/types/async.hpp"
 3 | 
 4 | namespace snabl {
 5 |   AsyncType::AsyncType(Lib &lib, Sym id, const vector<AType *> &parents):
 6 |     PtrType<Async>(lib, id, parents) { }
 7 | 
 8 |   bool AsyncType::as_bool(const Box &val) const {
 9 |     return !val.as<AsyncPtr>()->valid();
10 |   }
11 | 
12 |   void AsyncType::dump(const Box &val, ostream &out) const {
13 |     out << "(Async " << val.as<AsyncPtr>().get() << ')';
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/snabl/types/sym.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_SYM_HPP
 2 | #define SNABL_TYPE_SYM_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | #include "snabl/type.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct SymType: Type<Sym> {
 9 |     SymType(Lib &lib, Sym id, const vector<AType *> &parents);
10 |     Cmp cmp(const Box &lhs, const Box &rhs) const override;
11 |     void dump(const Box &val, ostream &out) const override;
12 |     void print(const Box &val, ostream &out) const override;
13 |   };
14 | }
15 | 
16 | #endif
17 | 


--------------------------------------------------------------------------------
/src/snabl/types/file.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/box.hpp"
 2 | #include "snabl/types/file.hpp"
 3 | 
 4 | namespace snabl {
 5 |   FileType::FileType(Lib &lib, Sym id, const vector<AType *> &parents):
 6 |     PtrType<File>(lib, id, parents) { }
 7 | 
 8 |   bool FileType::as_bool(const Box &val) const {
 9 |     return !val.as<FilePtr>()->eof();
10 |   }
11 | 
12 |   void FileType::dump(const Box &val, ostream &out) const {
13 |     out << '(' << val.type->id << ' ' << val.as<FilePtr>().get() << ')';
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/snabl/types/byte.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_BYTE_HPP
 2 | #define SNABL_TYPE_BYTE_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | #include "snabl/type.hpp"
 6 | #include "snabl/types.hpp"
 7 | 
 8 | namespace snabl { 
 9 |   struct ByteType: Type<Byte> {
10 |     ByteType(Lib &lib, Sym id, const vector<AType *> &parents);
11 |     bool as_bool(const Box &val) const override;
12 |     Cmp cmp(const Box &lhs, const Box &rhs) const override;
13 |     void dump(const Box &val, ostream &out) const override;
14 |   };
15 | }
16 | 
17 | #endif
18 | 


--------------------------------------------------------------------------------
/src/snabl/types/char.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_CHAR_HPP
 2 | #define SNABL_TYPE_CHAR_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | #include "snabl/type.hpp"
 6 | #include "snabl/types.hpp"
 7 | 
 8 | namespace snabl { 
 9 |   struct CharType: Type<Char> {
10 |     CharType(Lib &lib, Sym id, const vector<AType *> &parents);
11 |     Cmp cmp(const Box &lhs, const Box &rhs) const override;
12 |     bool as_bool(const Box &val) const override;
13 |     void dump(const Box &val, ostream &out) const override;
14 |   };
15 | }
16 | 
17 | #endif
18 | 


--------------------------------------------------------------------------------
/src/snabl/types/nil.cpp:
--------------------------------------------------------------------------------
 1 | #include <ostream>
 2 | 
 3 | #include "snabl/box.hpp"
 4 | #include "snabl/pos.hpp"
 5 | #include "snabl/types/nil.hpp"
 6 | 
 7 | namespace snabl {
 8 |   NilType::NilType(Lib &lib, Sym id, const vector<AType *> &parents):
 9 |     Type<Nil>(lib, id, parents) {
10 |     eqval = [](auto &lhs, auto &rhs) { return true; };
11 |   }
12 | 
13 |   bool NilType::as_bool(const Box &val) const { return false; }
14 | 
15 |   void NilType::dump(const Box &val, ostream &out) const {
16 |     out << "nil";
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/snabl/target.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TARGET_HPP
 2 | #define SNABL_TARGET_HPP
 3 | 
 4 | #include "snabl/ptrs.hpp"
 5 | #include "snabl/state.hpp"
 6 | #include "snabl/types.hpp"
 7 | 
 8 | namespace snabl {
 9 |   struct Scope;
10 |   struct Var;
11 |   
12 |   struct Target {
13 |     optional<vector<Var>> vars;
14 |     PC start_pc;
15 |     I64 end_pc;
16 | 
17 |     Target(Scope *parent_scope=nullptr, PC start_pc=nullptr, I64 end_pc=-1);
18 | 
19 |     virtual ~Target() { }
20 |     virtual string target_id() const=0;
21 |   };
22 | }
23 | 
24 | #endif
25 | 


--------------------------------------------------------------------------------
/src/snabl/state.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_STATE_HPP
 2 | #define SNABL_STATE_HPP
 3 | 
 4 | namespace snabl {
 5 |   struct Call;
 6 |   struct Env;
 7 |   struct Lib;
 8 |   struct Scope;
 9 |   struct Try;
10 |   
11 |   struct State {
12 |     Lib &lib;
13 |     Scope *const scope;
14 |     Call *const call;
15 |     Try *const _try;
16 |     const I64 nstack, nsplits, async_depth;
17 | 
18 |     State(const Env &env);
19 |     void restore_env(Env &env) const;
20 |     void restore_call(Env &env) const;
21 |     void restore_try(Env &env) const;
22 |   };
23 | }
24 | 
25 | #endif
26 | 


--------------------------------------------------------------------------------
/src/snabl/time.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TIME_HPP
 2 | #define SNABL_TIME_HPP
 3 | 
 4 | #include "snabl/types.hpp"
 5 | 
 6 | namespace snabl {
 7 |   struct Time {
 8 |     static Time ms(I64 n) { return Time(n*1000000); }
 9 | 
10 |     I64 ns;
11 | 
12 |     Time(I64 ns=0): ns(ns) { }
13 |     I64 as_ms() const { return ns / 1000000; }
14 |   };
15 | 
16 |   inline bool operator ==(const Time &lhs, const Time &rhs) {
17 |     return lhs.ns == rhs.ns;
18 |   }
19 |   
20 |   inline bool operator <(const Time &lhs, const Time &rhs) { return lhs.ns < rhs.ns; }
21 | }
22 | 
23 | #endif
24 | 


--------------------------------------------------------------------------------
/src/snabl/types/i64.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_I64_HPP
 2 | #define SNABL_TYPE_I64_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | #include "snabl/type.hpp"
 6 | #include "snabl/types.hpp"
 7 | 
 8 | namespace snabl { 
 9 |   struct I64Type: Type<I64> {
10 |     I64Type(Lib &lib, Sym id, const vector<AType *> &parents);
11 |     bool as_bool(const Box &val) const override;
12 |     Cmp cmp(const Box &lhs, const Box &rhs) const override;
13 |     IterPtr iter(const Box &val) const override;
14 |     void dump(const Box &val, ostream &out) const override;
15 |   };
16 | }
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/src/snabl/types/iter.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_ITER_HPP
 2 | #define SNABL_TYPE_ITER_HPP
 3 | 
 4 | #include "snabl/iter.hpp"
 5 | #include "snabl/std.hpp"
 6 | #include "snabl/type.hpp"
 7 | 
 8 | namespace snabl { 
 9 |   struct IterType: PtrType<Iter> {
10 |     IterType(Lib &lib, Sym id, const vector<AType *> &parents);
11 |     bool as_bool(const Box &val) const override;
12 |     void call(const Box &val, Pos pos) const override;
13 |     IterPtr iter(const Box &val) const override;
14 |     void dump(const Box &val, ostream &out) const override;
15 |   };
16 | }
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/src/snabl/types/float.cpp:
--------------------------------------------------------------------------------
 1 | #include <ostream>
 2 | 
 3 | #include "snabl/box.hpp"
 4 | #include "snabl/types/float.hpp"
 5 | 
 6 | namespace snabl {
 7 |   FloatType::FloatType(Lib &lib, Sym id, const vector<AType *> &parents):
 8 |     Type<Float>(lib, id, parents) {
 9 |     eqval = [](auto &lhs, auto &rhs) { return lhs.as_float == rhs.as_float; };
10 |   }
11 | 
12 |   Cmp FloatType::cmp(const Box &lhs, const Box &rhs) const {
13 |     return snabl::cmp(lhs.as_float, rhs.as_float);
14 |   }
15 | 
16 |   void FloatType::dump(const Box &val, ostream &out) const {
17 |     out << val.as_float;
18 |   }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/snabl/types/lambda.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/env.hpp"
 2 | #include "snabl/box.hpp"
 3 | #include "snabl/lambda.hpp"
 4 | #include "snabl/lib.hpp"
 5 | #include "snabl/types/lambda.hpp"
 6 | 
 7 | namespace snabl {
 8 |   LambdaType::LambdaType(Lib &lib, Sym id, const vector<AType *> &parents):
 9 |     Type<Lambda>(lib, id, parents) { }
10 | 
11 |   void LambdaType::call(const Box &val, Pos pos) const {
12 |     val.as<Lambda>().call(val.type->lib.env, pos);
13 |   }
14 |   
15 |   void LambdaType::dump(const Box &val, ostream &out) const {
16 |     out << "(Lambda " << val.as<Lambda>().start_pc << ')';
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/snabl/types/sym.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/box.hpp"
 2 | #include "snabl/types/sym.hpp"
 3 | 
 4 | namespace snabl {
 5 |   SymType::SymType(Lib &lib, Sym id, const vector<AType *> &parents):
 6 |     Type<Sym>(lib, id, parents) {
 7 |     eqval = [](auto &lhs, auto &rhs) { return lhs.as_sym == rhs.as_sym; };
 8 |   }
 9 | 
10 |   Cmp SymType::cmp(const Box &lhs, const Box &rhs) const {
11 |     return snabl::cmp(lhs.as_sym, rhs.as_sym);
12 |   }
13 |   
14 |   void SymType::dump(const Box &val, ostream &out) const {
15 |     out << '\'' << val.as_sym;
16 |   }
17 | 
18 |   void SymType::print(const Box &val, ostream &out) const {
19 |     out << val.as_sym;
20 |   }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/snabl/call.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/call.hpp"
 2 | #include "snabl/env.hpp"
 3 | #include "snabl/fimp.hpp"
 4 | 
 5 | namespace snabl {
 6 |   Call::Call(Env &env, Fimp &fimp, Pos pos, PC return_pc):
 7 |     prev(env.call()), target(&fimp), pos(pos), state(env), return_pc(return_pc) { }
 8 | 
 9 |   Call::Call(Env &env, const Lambda &lambda, Pos pos, PC return_pc):
10 |     prev(env.call()),
11 |     target(move(lambda)),
12 |     pos(pos),
13 |     state(env),
14 |     return_pc(return_pc) { }
15 | 
16 |   const Target &Call::get_target() const {
17 |     if (holds_alternative<Lambda>(target)) { return get<Lambda>(target); }
18 |     return *get<Fimp *>(target);
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/snabl/call.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_CALL_HPP
 2 | #define SNABL_CALL_HPP
 3 | 
 4 | #include "snabl/lambda.hpp"
 5 | #include "snabl/pos.hpp"
 6 | #include "snabl/ptrs.hpp"
 7 | #include "snabl/state.hpp"
 8 | #include "snabl/std.hpp"
 9 | 
10 | namespace snabl {
11 |   struct Fimp;
12 |   
13 |   struct Call {
14 |     Call *const prev;
15 |     const variant<Fimp *, Lambda> target;
16 |     const Pos pos;
17 |     const State state;
18 |     const PC return_pc;
19 | 
20 |     Call(Env &env, Fimp &fimp, Pos pos, PC return_pc=nullptr);
21 |     Call(Env &env, const Lambda &lambda, Pos pos, PC return_pc);
22 |     const Target &get_target() const;
23 |   };
24 | }
25 | 
26 | #endif
27 | 


--------------------------------------------------------------------------------
/src/snabl/types/byte.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/box.hpp"
 2 | #include "snabl/env.hpp"
 3 | #include "snabl/types/byte.hpp"
 4 | 
 5 | namespace snabl {
 6 |   ByteType::ByteType(Lib &lib, Sym id, const vector<AType *> &parents):
 7 |     Type<Byte>(lib, id, parents) {
 8 |     eqval = [](auto &lhs, auto &rhs) { return lhs.as_byte == rhs.as_byte; };
 9 |   }
10 | 
11 |   bool ByteType::as_bool(const Box &val) const { return val.as_byte; }
12 | 
13 |   Cmp ByteType::cmp(const Box &lhs, const Box &rhs) const {
14 |     return snabl::cmp(lhs.as_byte, rhs.as_byte);
15 |   }
16 |   
17 |   void ByteType::dump(const Box &val, ostream &out) const {
18 |     out << val.as_byte;
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/snabl/runtime_error.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_RUNTIME_ERROR_HPP
 2 | #define SNABL_RUNTIME_ERROR_HPP
 3 | 
 4 | #include "snabl/error.hpp"
 5 | #include "snabl/stack.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct RuntimeError: Error {
 9 |     const string run_msg;
10 |     const Pos pos;
11 |     const Stack stack;
12 |     
13 |     RuntimeError(Env &env, const string &msg);
14 | 
15 |     string generate_msg() const override {
16 |       stringstream buf;
17 |       
18 |       buf << stack << endl
19 |           << "Error in row " << pos.row << ", col " << pos.col << ":\n"
20 |           << run_msg;
21 |       
22 |       return buf.str();
23 |     }
24 |   };
25 | }
26 | 
27 | #endif
28 | 


--------------------------------------------------------------------------------
/src/snabl/types/bin.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_BIN_HPP
 2 | #define SNABL_TYPE_BIN_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | #include "snabl/type.hpp"
 6 | #include "snabl/types.hpp"
 7 | 
 8 | namespace snabl {
 9 |   struct BinType: PtrType<Bin> {
10 |     BinType(Lib &lib, Sym id, const vector<AType *> &parents);
11 |     bool as_bool(const Box &val) const override;
12 |     void push(Box &sink, const Box &val) const override;
13 |     optional<Box> peek(const Box &source) const override;
14 |     void pop(Box &source) const override;
15 |     IterPtr iter(const Box &val) const override;
16 |     void dump(const Box &val, ostream &out) const override;
17 |   };
18 | }
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/src/snabl/types/bool.cpp:
--------------------------------------------------------------------------------
 1 | #include <ostream>
 2 | 
 3 | #include "snabl/box.hpp"
 4 | #include "snabl/types/bool.hpp"
 5 | 
 6 | namespace snabl {
 7 |   BoolType::BoolType(Lib &lib, Sym id, const vector<AType *> &parents):
 8 |     Type<bool>(lib, id, parents) {
 9 |     eqval = [](auto &lhs, auto &rhs) { return lhs.as_bool == rhs.as_bool; };
10 |   }
11 | 
12 |   bool BoolType::as_bool(const Box &val) const { return val.as_bool; }
13 | 
14 |   Cmp BoolType::cmp(const Box &lhs, const Box &rhs) const {
15 |     return snabl::cmp(lhs.as_bool, rhs.as_bool);
16 |   }
17 | 
18 |   void BoolType::dump(const Box &val, ostream &out) const {
19 |     out << (val.as_bool ? 't' : 'f');
20 |   }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/snabl/scope.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_SCOPE_HPP
 2 | #define SNABL_SCOPE_HPP
 3 | 
 4 | #include "snabl/bset.hpp"
 5 | #include "snabl/ptrs.hpp"
 6 | #include "snabl/stack.hpp"
 7 | #include "snabl/std.hpp"
 8 | #include "snabl/sym.hpp"
 9 | #include "snabl/var.hpp"
10 | 
11 | namespace snabl {  
12 |   struct Scope {
13 |     static const I64 MaxRegs = 32;
14 |     
15 |     Scope *prev;
16 |     array<any, MaxRegs> regs;
17 |     BSet<Sym, Var> vars;
18 |     
19 |     Scope(Scope *prev, const vector<Var> &source):
20 |       prev(prev), vars(&Var::key, source) { }
21 | 
22 |     Scope(const Scope &) = delete;
23 |     const Scope &operator=(const Scope &) = delete;
24 |   };
25 | }
26 | 
27 | #endif
28 | 


--------------------------------------------------------------------------------
/src/snabl/types/stack.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_STACK_HPP
 2 | #define SNABL_TYPE_STACK_HPP
 3 | 
 4 | #include "snabl/stack.hpp"
 5 | #include "snabl/std.hpp"
 6 | #include "snabl/type.hpp"
 7 | 
 8 | namespace snabl {
 9 |   struct StackType: PtrType<Stack> {
10 |     StackType(Lib &lib, Sym id, const vector<AType *> &parents);
11 |     bool as_bool(const Box &val) const override;
12 |     void push(Box &sink, const Box &val) const override;
13 |     optional<Box> peek(const Box &source) const override;
14 |     void pop(Box &source) const override;
15 |     IterPtr iter(const Box &val) const override;
16 |     void dump(const Box &val, ostream &out) const override;
17 |   };
18 | }
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/src/snabl/atype.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/env.hpp"
 2 | #include "snabl/lib.hpp"
 3 | #include "snabl/atype.hpp"
 4 | 
 5 | namespace snabl {
 6 |   AType::AType(Lib &lib, Sym id, I64 size, const vector<AType *> &parents):
 7 |     Def(id), lib(lib), size(size), tag(lib.env.next_type_tag()) {
 8 |     eqval = [&lib](auto &lhs, auto &rhs) {
 9 |       throw RuntimeError(lib.env,
10 |                          fmt("eqval() is not implemented for %0", {lhs.type->id}));
11 |       return false;
12 |     };
13 | 
14 |     for (auto &pt: parents) { derive(*pt); }
15 |   }
16 |   
17 |   optional<Box> AType::peek(const Box &source) const {
18 |     throw Error("peek() is not implemented");
19 |     return nullopt;
20 |   }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/snabl/macro.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_MACRO_HPP
 2 | #define SNABL_MACRO_HPP
 3 | 
 4 | #include "snabl/def.hpp"
 5 | #include "snabl/form.hpp"
 6 | #include "snabl/std.hpp"
 7 | #include "snabl/sym.hpp"
 8 | 
 9 | namespace snabl {
10 |   struct Lib;
11 |   
12 |   struct Macro: Def {
13 |     using Imp = function<void (Forms::const_iterator &in,
14 |                                Forms::const_iterator end,
15 |                                Env &env)>;
16 |     
17 |     Lib &lib;
18 |     const Imp imp;
19 | 
20 |     Macro(Lib &lib, Sym id, const Imp &imp);
21 |     
22 |     void call(Forms::const_iterator &in,
23 |               Forms::const_iterator end,
24 |               Env &env);
25 |   };
26 | }
27 | 
28 | #endif
29 | 


--------------------------------------------------------------------------------
/src/snabl/types/enum.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_ENUM_HPP
 2 | #define SNABL_TYPE_ENUM_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | #include "snabl/type.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct Enum {
 9 |     I64 i;
10 |     Sym id;
11 | 
12 |     Enum(I64 i, Sym id): i(i), id(id) { }
13 |   };
14 |   
15 |   struct EnumType: Type<Enum> {
16 |     EnumType(Lib &lib,
17 |              Sym id,
18 |              const vector<AType *> &parents,
19 |              const vector<Sym> &alts={});
20 |     
21 |     Cmp cmp(const Box &lhs, const Box &rhs) const override;
22 |     void print(const Box &val, ostream &out) const override;
23 |     void dump(const Box &val, ostream &out) const override;
24 |   };
25 | }
26 | 
27 | #endif
28 | 


--------------------------------------------------------------------------------
/src/snabl/lambda.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_LAMBDA_HPP
 2 | #define SNABL_LAMBDA_HPP
 3 | 
 4 | #include "snabl/fmt.hpp"
 5 | #include "snabl/pos.hpp"
 6 | #include "snabl/ptrs.hpp"
 7 | #include "snabl/std.hpp"
 8 | #include "snabl/target.hpp"
 9 | 
10 | namespace snabl {
11 |   struct Lambda: Target {    
12 |     Lambda(Scope *parent_scope, PC start_pc, I64 end_pc):
13 |       Target(parent_scope, start_pc, end_pc) { }
14 |     
15 |     string target_id() const override { return fmt("(Lambda %0)", {this}); }
16 |     void call(Env &env, Pos pos) const;
17 |   };
18 | 
19 |   inline bool operator ==(const Lambda &lhs, const Lambda &rhs) {
20 |     return &lhs == &rhs;
21 |   }
22 | 
23 |   inline bool operator <(const Lambda &lhs, const Lambda &rhs) {
24 |     return &lhs < &rhs;
25 |   }
26 | }
27 | 
28 | #endif
29 | 


--------------------------------------------------------------------------------
/src/snabl/std.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_STD_HPP
 2 | #define SNABL_STD_HPP
 3 | 
 4 | #include <cassert>
 5 | #include <cmath>
 6 | #include <cstdint>
 7 | 
 8 | #include <algorithm>
 9 | #include <any>
10 | #include <chrono>
11 | #include <deque>
12 | #include <fstream>
13 | #include <functional>
14 | #include <future>
15 | #include <iomanip>
16 | #include <iostream>
17 | #include <list>
18 | #include <optional>
19 | #include <map>
20 | #include <memory>
21 | #include <set>
22 | #include <sstream>
23 | #include <string>
24 | #include <string_view>
25 | #include <thread>
26 | #include <type_traits>
27 | #include <unordered_map>
28 | #include <unordered_set>
29 | #include <variant>
30 | #include <vector>
31 | 
32 | namespace snabl {
33 |   using namespace std;
34 |   using namespace std::chrono;
35 | }
36 | 
37 | #endif
38 | 


--------------------------------------------------------------------------------
/src/snabl/type.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_HPP
 2 | #define SNABL_TYPE_HPP
 3 | 
 4 | #include "snabl/atype.hpp"
 5 | #include "snabl/mpool.hpp"
 6 | #include "snabl/ptr.hpp"
 7 | 
 8 | namespace snabl {
 9 |   template <typename T>
10 |   struct Type: AType {
11 |     Type(Lib &lib, Sym id, const vector<AType *> &parents={}):
12 |       AType(lib, id, sizeof(T), parents) { }
13 |   };
14 | 
15 |   template <typename T>
16 |   struct PtrType: Type<Ptr<T>> {
17 |     MPool<typename Ptr<T>::Imp> pool;
18 |     PtrType(Lib &lib, Sym id, const vector<AType *> &parents={}):
19 |       Type<Ptr<T>>(lib, id, parents) { }
20 |   };
21 |   
22 |   struct Trait: Type<nullptr_t> {
23 |     Trait(Lib &lib, Sym id, const vector<AType *> &parents={}):
24 |       Type<nullptr_t>(lib, id, parents) { }
25 |   };
26 | }
27 | 
28 | #endif
29 | 


--------------------------------------------------------------------------------
/src/snabl/types/str.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TYPE_STR_HPP
 2 | #define SNABL_TYPE_STR_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | #include "snabl/type.hpp"
 6 | #include "snabl/types.hpp"
 7 | 
 8 | namespace snabl {
 9 |   struct StrType: PtrType<Str> {
10 |     StrType(Lib &lib, Sym id, const vector<AType *> &parents);
11 |     bool as_bool(const Box &val) const override;
12 |     Cmp cmp(const Box &lhs, const Box &rhs) const override;
13 |     void push(Box &sink, const Box &val) const override;
14 |     optional<Box> peek(const Box &source) const override;
15 |     void pop(Box &source) const override;
16 |     IterPtr iter(const Box &val) const override;
17 |     void dump(const Box &val, ostream &out) const override;
18 |     void print(const Box &val, ostream &out) const override;
19 |   };
20 | }
21 | 
22 | #endif
23 | 


--------------------------------------------------------------------------------
/src/snabl/types/iter.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/box.hpp"
 2 | #include "snabl/env.hpp"
 3 | #include "snabl/lib.hpp"
 4 | #include "snabl/types/iter.hpp"
 5 | 
 6 | namespace snabl {
 7 |   IterType::IterType(Lib &lib, Sym id, const vector<AType *> &parents):
 8 |     PtrType<Iter>(lib, id, parents) { }
 9 | 
10 |   bool IterType::as_bool(const Box &val) const {
11 |     return !val.as<IterPtr>()->is_done;
12 |   }
13 | 
14 |   void IterType::call(const Box &val, Pos pos) const {
15 |     Env &env(val.type->lib.env);
16 |     if (!val.as<IterPtr>()->call(env)) { env.push(env.nil_type); }
17 |   }
18 | 
19 |   IterPtr IterType::iter(const Box &val) const {
20 |     return val.as<IterPtr>();
21 |   }
22 | 
23 |   void IterType::dump(const Box &val, ostream &out) const {
24 |     out << "(Iter " << val.as<IterPtr>().get() << ')';
25 |   }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/snabl/fmt.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/error.hpp"
 2 | #include "snabl/fmt.hpp"
 3 | 
 4 | namespace snabl {
 5 | 	string fmt(string_view spec, const vector<fmt_conv> &args) {
 6 | 		stringstream out;
 7 | 		string::size_type i(0), j;
 8 | 		
 9 | 		while ((j = spec.find('%', i)) != string_view::npos) {
10 | 			if (j < spec.length()-1 && spec[j+1] == '%') {
11 | 				j++;
12 | 				out << spec.substr(i, j-i);
13 | 				i = j+1;
14 | 			} else {
15 | 				out << spec.substr(i, j-i);
16 | 				size_t len(0);
17 | 				const auto arg(stoul(string(spec.substr(j+1)), &len));
18 | 
19 | 				if (arg >= args.size()) {
20 | 					throw Error("Invalid fmt arg: " + to_string(arg));
21 | 				}
22 | 
23 | 				args[arg].print(out);
24 | 				i = j+len+1;
25 | 			}
26 | 		}
27 | 
28 | 		if (i < spec.length()) { out << spec.substr(i); }
29 | 		return out.str();
30 | 	}
31 | }
32 | 


--------------------------------------------------------------------------------
/src/snabl/types/char.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/box.hpp"
 2 | #include "snabl/env.hpp"
 3 | #include "snabl/types/char.hpp"
 4 | 
 5 | namespace snabl {
 6 |   CharType::CharType(Lib &lib, Sym id, const vector<AType *> &parents):
 7 |     Type<Char>(lib, id, parents) {
 8 |     eqval = [](auto &lhs, auto &rhs) { return lhs.as_char == rhs.as_char; };
 9 |   }
10 | 
11 |   bool CharType::as_bool(const Box &val) const { return val.as_char; }
12 | 
13 |   Cmp CharType::cmp(const Box &lhs, const Box &rhs) const {
14 |     return snabl::cmp(lhs.as_char, rhs.as_char);
15 |   }
16 | 
17 |   void CharType::dump(const Box &val, ostream &out) const {
18 |     Env &env(val.type->lib.env);
19 |     const auto c(val.as_char);
20 |     const auto sc(env.find_char_special(c));
21 |     
22 |     if (sc) {
23 |       out << '~' << *sc;
24 |     } else {
25 |       out << '#' << c;
26 |     }
27 |   }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/snabl/task.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_TASK_HPP
 2 | #define SNABL_TASK_HPP
 3 | 
 4 | #include "snabl/call.hpp"
 5 | #include "snabl/op.hpp"
 6 | #include "snabl/ptr.hpp"
 7 | #include "snabl/try.hpp"
 8 | 
 9 | namespace snabl {
10 |   struct Env;
11 |   
12 |   struct Task {
13 |     enum struct Status {New, Running, Yielding, Done};
14 |     
15 |     Scope *scope;    
16 |     Task *prev, *next;
17 |     Status status=Status::New;
18 |     I64 stack_offs=0;
19 |     Lib *lib=nullptr;
20 |     Call *call = nullptr;
21 |     Try *_try = nullptr;
22 |     I64 async_depth=0;
23 |     Stack stack;
24 |     vector<I64> splits;
25 |     PC pc;
26 | 
27 |     Task(const Task &)=delete;
28 |     const Task &operator =(const Task &)=delete;
29 |     
30 |     Task(Env &env, PC start_pc=nullptr, Scope *scope=nullptr):
31 |       scope(scope), prev(this), next(this), pc(start_pc) { }
32 |   };
33 | }
34 | 
35 | #endif
36 | 


--------------------------------------------------------------------------------
/src/snabl/repl.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/env.hpp"
 2 | #include "snabl/repl.hpp"
 3 | #include "snabl/stack.hpp"
 4 | 
 5 | namespace snabl {
 6 | 	void repl(Env &env, istream &in, ostream &out) {
 7 | 		out << "Snabl v";
 8 | 		char sep(0);
 9 | 	
10 | 		for (auto v: version) {
11 | 			if (sep) { out << sep; }
12 | 			out << v;
13 | 			sep = '.';
14 | 		}
15 | 
16 | 		out << endl << endl
17 | 				<< "Press Return on empty line to eval."
18 | 				<< endl << endl;
19 | 		
20 | 		stringstream buf;
21 | 		std::string l;
22 | 		int row(1);
23 | 		
24 | 		while (std::getline(in, l)) {
25 | 			if (l == "") {
26 | 				try {
27 | 					env.run(buf.str());
28 | 					out << env.stack() << endl << endl;
29 | 				} catch (const exception &e) {
30 | 					out << e.what() << endl;
31 | 				}
32 | 				
33 | 				stringstream().swap(buf);
34 | 				row = 1;
35 | 			} else {
36 | 				buf << l << endl;
37 | 				row++;
38 | 			}
39 | 		} 
40 | 	}
41 | }
42 | 


--------------------------------------------------------------------------------
/src/snabl/state.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/env.hpp"
 2 | #include "snabl/state.hpp"
 3 | 
 4 | namespace snabl {
 5 |   State::State(const Env &env):
 6 |     lib(*env.task->lib),
 7 |     scope(env.task->scope),
 8 |     call(env.task->call),
 9 |     _try(env.task->_try),
10 |     nstack(env.task->stack.size()),
11 |     nsplits(env.task->splits.size()),
12 |     async_depth(env.task->async_depth) { }
13 | 
14 |   void State::restore_env(Env &env) const {
15 |     env.task->lib = &lib;
16 |     env.task->scope = scope;
17 |     auto &s(env.task->stack);
18 |     while (I64(s.size()) > nstack) { s.erase(s.begin()+nstack, s.end()); }
19 |     if (I64(env.task->splits.size()) > nsplits) { env.task->splits.resize(nsplits); }
20 |     env.task->async_depth = async_depth;
21 |   }
22 | 
23 |   void State::restore_call(Env &env) const { env.task->call = call; }
24 | 
25 |   void State::restore_try(Env &env) const { env.task->_try = _try; }
26 | }
27 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.0)
 2 | 
 3 | project(snabl)
 4 | 
 5 | set(CMAKE_CXX_COMPILER g++)
 6 | 
 7 | add_compile_options(-std=c++17 -Wall -Werror -O2 -g)
 8 | 
 9 | file(GLOB_RECURSE src src/snabl/*.cpp)
10 | 
11 | add_library(libsnabl STATIC ${src})
12 | target_include_directories(libsnabl PUBLIC src/)
13 | 
14 | set_target_properties(libsnabl PROPERTIES PREFIX "")
15 | 
16 | add_executable(snabl ${src} src/tests.cpp src/main.cpp)
17 | target_include_directories(snabl PUBLIC src/)
18 | target_link_libraries(snabl pthread)
19 | 
20 | file(GLOB inc src/snabl/*.hpp)
21 | install(FILES ${inc} DESTINATION include/snabl)
22 | 
23 | file(GLOB inc src/snabl/libs/*.hpp)
24 | install(FILES ${inc} DESTINATION include/snabl/libs)
25 | 
26 | file(GLOB inc src/snabl/types/*.hpp)
27 | install(FILES ${inc} DESTINATION include/snabl/types)
28 | 
29 | install(FILES build/libsnabl.a DESTINATION lib)
30 | install(FILES build/snabl DESTINATION bin PERMISSIONS WORLD_EXECUTE)
31 | 


--------------------------------------------------------------------------------
/src/snabl/types/enum.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/box.hpp"
 2 | #include "snabl/env.hpp"
 3 | #include "snabl/form.hpp"
 4 | #include "snabl/types/enum.hpp"
 5 | 
 6 | namespace snabl {
 7 |   EnumType::EnumType(Lib &lib,
 8 |                      Sym id,
 9 |                      const vector<AType *> &parents,
10 |                      const vector<Sym> &alts):
11 |     Type<Enum>(lib, id, parents) {
12 |     eqval = [](auto &lhs, auto &rhs) { return lhs.as_enum.i == rhs.as_enum.i; };
13 |     
14 |     I64 i(0);
15 |     for (auto &a: alts) { lib.add_macro(a, *this, Enum(i++, a)); }
16 |   }
17 | 
18 |   Cmp EnumType::cmp(const Box &lhs, const Box &rhs) const {
19 |     return snabl::cmp(lhs.as_enum.i, rhs.as_enum.i);
20 |   }
21 | 
22 |   void EnumType::print(const Box &val, ostream &out) const {
23 |     out << val.as_enum.id;
24 |   }
25 |   
26 |   void EnumType::dump(const Box &val, ostream &out) const {
27 |     out << '(' << val.type->id << ' ' << val.as_enum.id << ')';
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/snabl/types/i64.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/box.hpp"
 2 | #include "snabl/env.hpp"
 3 | #include "snabl/types/i64.hpp"
 4 | 
 5 | namespace snabl {
 6 |   I64Type::I64Type(Lib &lib, Sym id, const vector<AType *> &parents):
 7 |     Type<I64>(lib, id, parents) {
 8 |     eqval = [](auto &lhs, auto &rhs) { return lhs.as_i64 == rhs.as_i64; };
 9 |   }
10 | 
11 |   bool I64Type::as_bool(const Box &val) const { return val.as_i64; }
12 | 
13 |   Cmp I64Type::cmp(const Box &lhs, const Box &rhs) const {
14 |     return snabl::cmp(lhs.as_i64, rhs.as_i64);
15 |   }
16 |   
17 |   IterPtr I64Type::iter(const Box &val) const {
18 |     Env &env(val.type->lib.env);
19 | 
20 |     I64 i(0);
21 |     const I64 max(val.as_i64);
22 |     
23 |     return IterPtr::make(&env.iter_type.pool, [&env, i, max]() mutable {
24 |         if (i == max) { return false; }
25 |         env.push(env.i64_type, i++);
26 |         return true;
27 |       });
28 |   }
29 | 
30 |   void I64Type::dump(const Box &val, ostream &out) const {
31 |     out << val.as_i64;
32 |   }
33 | }
34 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
1 | Copyright 2018 codr4life
2 | 
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
4 | 
5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
6 | 
7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
8 | 


--------------------------------------------------------------------------------
/src/snabl/fimp.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_FIMP_HPP
 2 | #define SNABL_FIMP_HPP
 3 | 
 4 | #include "snabl/def.hpp"
 5 | #include "snabl/form.hpp"
 6 | #include "snabl/op.hpp"
 7 | #include "snabl/ptrs.hpp"
 8 | #include "snabl/std.hpp"
 9 | #include "snabl/stack.hpp"
10 | #include "snabl/target.hpp"
11 | 
12 | namespace snabl {
13 |   struct Fimp: Def, Target {
14 |     using Args = vector<Box>;
15 |     using Imp = function<void (Fimp &)>;
16 |     
17 |     static Sym get_id(const Func &func, const Args &args);
18 | 
19 |     Func &func;
20 |     const Args args;
21 |     const optional<Form> form;
22 |     const Imp imp;
23 | 
24 |     Fimp(const Fimp &)=delete;
25 |     const Fimp &operator =(const Fimp &)=delete;
26 |     
27 |     Fimp(Func &func, const Args &args, Imp imp);
28 |     Fimp(Func &func, const Args &args, const Form &form);
29 |     string target_id() const override { return id.name(); }   
30 |     I64 score(Stack::const_iterator begin, Stack::const_iterator end) const;
31 |     bool compile(Pos pos);
32 |     void call(Pos pos);
33 |   };
34 | }
35 | 
36 | #endif
37 | 


--------------------------------------------------------------------------------
/src/snabl/sym.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_SYM_HPP
 2 | #define SNABL_SYM_HPP
 3 | 
 4 | #include "snabl/std.hpp"
 5 | #include "snabl/types.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct Sym;
 9 |   
10 |   struct SymImp {
11 |     const string name;
12 |     const I64 hash;
13 | 
14 |     SymImp(const string &name): name(name), hash(std::hash<string>{}(name)) { }
15 |   };
16 | 
17 |   struct Sym {
18 |     const SymImp *imp;
19 | 
20 |     Sym(const SymImp *imp): imp(imp) { }
21 |     const string &name() const { return imp->name; }
22 |   };
23 | 
24 |   inline bool operator ==(Sym x, Sym y) { return x.imp == y.imp; }
25 | 
26 |   inline bool operator !=(Sym x, Sym y) { return x.imp != y.imp; }
27 | 
28 |   inline bool operator <(Sym x, Sym y) { return x.imp < y.imp; }
29 | 
30 |   inline ostream &operator <<(ostream &out, const Sym &x) {
31 |     out << x.name();
32 |     return out;
33 |   }
34 | 
35 | }
36 | 
37 | namespace std {
38 |   template<>
39 |   struct hash<snabl::Sym> {
40 |     size_t operator ()(const snabl::Sym &x) const { return x.imp->hash; }
41 |   };
42 | }
43 | 
44 | #endif
45 | 


--------------------------------------------------------------------------------
/src/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/env.hpp"
 2 | #include "snabl/repl.hpp"
 3 | #include "tests.hpp"
 4 | 
 5 | using namespace snabl;
 6 | 
 7 | enum class Mode { Compile, Default, Repl, Run };
 8 | 
 9 | int main(int argc, const char *argv[]) {
10 |   Env env;
11 |   env.use(env.sym("s.abc"));
12 |   Mode mode(Mode::Default);
13 |   argc--;
14 |   
15 |   for (const char **ap(argv+1); argc; argc--, ap++) {
16 |     const string a(*ap);
17 |     
18 |     if (a[0] == '-') {
19 |       switch (a[1]) {
20 |       case 'c':
21 |         mode = Mode::Compile;
22 |         break;
23 |       default:
24 |         throw Error(fmt("Invalid flag: %0", {a}));
25 |       }
26 |     } else {
27 |       env.load(a);
28 |       if (mode == Mode::Default) { mode = Mode::Run; }
29 |     }
30 |   }
31 |   
32 |   switch (mode) {
33 |   case Mode::Compile: {
34 |     I64 row(0);
35 |     for (const auto &op: env.ops) {
36 |       cout << row++ << '\t';
37 |       op->dump(cout);
38 |     }
39 |     break;
40 |   }
41 |   case Mode::Default:
42 |   case Mode::Repl:
43 |     all_tests();
44 |     repl(env, cin, cout);
45 |     break;
46 |   case Mode::Run:
47 |     if (!env.ops.empty()) {
48 |       env.jump(I64(0));
49 |       env.run();
50 |     }
51 |     
52 |     break;
53 |   }
54 |   
55 |   return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/src/snabl/types/stack.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/box.hpp"
 2 | #include "snabl/env.hpp"
 3 | #include "snabl/iter.hpp"
 4 | #include "snabl/lib.hpp"
 5 | #include "snabl/types/stack.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct Env;
 9 |   
10 |   StackType::StackType(Lib &lib, Sym id, const vector<AType *> &parents):
11 |     PtrType<Stack>(lib, id, parents) { }
12 | 
13 |   bool StackType::as_bool(const Box &val) const {
14 |     return !val.as<StackPtr>()->empty();
15 |   }
16 | 
17 |   void StackType::push(Box &sink, const Box &val) const {
18 |     sink.as<StackPtr>()->push_back(val);
19 |   }
20 | 
21 |   optional<Box> StackType::peek(const Box &source) const {
22 |     auto &s(*source.as<StackPtr>());
23 |     return s.empty() ? nullopt : make_optional(s.back());
24 |   }
25 | 
26 |   void StackType::pop(Box &source) const { source.as<StackPtr>()->pop_back(); }
27 | 
28 |   IterPtr StackType::iter(const Box &val) const {
29 |     Env &env(val.type->lib.env);
30 | 
31 |     const StackPtr s(val.as<StackPtr>());
32 |     auto i(s->begin());
33 |     
34 |     return IterPtr::make(&env.iter_type.pool, [&env, s, i]() mutable {
35 |         if (i == s->end()) { return false; }
36 |         env.push(*i++);
37 |         return true;
38 |       });
39 |   }
40 | 
41 |   void StackType::dump(const Box &val, ostream &out) const {
42 |     out << *val.as<StackPtr>();
43 |   }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/snabl/parser.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_PARSER_HPP
 2 | #define SNABL_PARSER_HPP
 3 | 
 4 | #include "snabl/form.hpp"
 5 | #include "snabl/pos.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct Env;
 9 | 
10 |   struct Parser {
11 |     static const Pos home;
12 |     Env &env;
13 |     Pos pos;
14 |     
15 |     Parser(Env &env): env(env), pos(home) { }
16 |     void parse(istream &in, Forms &out);
17 |     bool parse(istream &in, Pos start_pos, char end, Forms &out);   
18 |     bool parse_form(istream &in, char end, Forms &out);
19 | 
20 |     template <typename FormT>
21 |     bool parse_body(istream &in, char end, Forms &out) {
22 |       auto start_pos(pos);
23 |       Forms body;
24 |       if (!parse(in, start_pos, end, body) && end) { return false; }
25 |       out.emplace_back(FormT::type, start_pos, body.cbegin(), body.cend());
26 |       return true;
27 |     }
28 | 
29 |     void parse_id(istream &in, Forms &out);
30 |     void parse_num(istream &in, Forms &out);
31 |     void parse_scope(istream &in, Forms &out);
32 |     void parse_sexpr(istream &in, Forms &out);
33 |     void parse_stack(istream &in, Forms &out);
34 |     void parse_special_char(istream &in, Forms &out);
35 |     void parse_char(istream &in, Forms &out);
36 |     void parse_str(istream &in, Forms &out);
37 |     void parse_fimp(Pos pos, Sym id, istream &in, Forms &out);
38 |   };
39 | }
40 | 
41 | #endif
42 | 


--------------------------------------------------------------------------------
/src/snabl/types/bin.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/box.hpp"
 2 | #include "snabl/env.hpp"
 3 | #include "snabl/iter.hpp"
 4 | #include "snabl/lib.hpp"
 5 | #include "snabl/types/bin.hpp"
 6 | 
 7 | namespace snabl {
 8 |   struct Env;
 9 |   
10 |   BinType::BinType(Lib &lib, Sym id, const vector<AType *> &parents): 
11 |     PtrType<Bin>(lib, id, parents) { }
12 | 
13 |   bool BinType::as_bool(const Box &val) const {
14 |     return !val.as<BinPtr>()->empty();
15 |   }
16 | 
17 |   void BinType::push(Box &sink, const Box &val) const {
18 |     sink.as<BinPtr>()->push_back(val.as_byte);
19 |   }
20 | 
21 |   optional<Box> BinType::peek(const Box &source) const {
22 |     Env &env(source.type->lib.env);
23 |     auto &s(*source.as<BinPtr>());
24 |     return s.empty() ? nullopt : make_optional<Box>(env.byte_type, s.back());
25 |   }
26 | 
27 |   void BinType::pop(Box &source) const { source.as<BinPtr>()->pop_back(); }
28 | 
29 |   IterPtr BinType::iter(const Box &val) const {
30 |     Env &env(val.type->lib.env);
31 |     const BinPtr b(val.as<BinPtr>());
32 |     auto i(b->begin());
33 |     
34 |     return IterPtr::make(&env.iter_type.pool, [&env, b, i]() mutable {
35 |         if (i == b->end()) { return false; }
36 |         env.push(env.byte_type, Byte(*i++));
37 |         return true;
38 |       });
39 |   }
40 | 
41 |   void BinType::dump(const Box &val, ostream &out) const {
42 |     out << "(Bin " << val.as<BinPtr>().get() << ')';
43 |   }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/snabl/error.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_ERROR_HPP
 2 | #define SNABL_ERROR_HPP
 3 | 
 4 | #include <stdexcept>
 5 | 
 6 | #include "snabl/fmt.hpp"
 7 | #include "snabl/pos.hpp"
 8 | #include "snabl/std.hpp"
 9 | 
10 | namespace snabl {
11 |   struct Error: runtime_error {
12 |     string msg;
13 |     
14 |     Error(const string &msg=""): runtime_error(""), msg(msg) { }
15 | 
16 |     const char* what() const throw() override {
17 |       if (msg.empty()) { const_cast<Error *>(this)->msg = generate_msg(); }
18 |       return msg.c_str();
19 |     }
20 | 
21 |     virtual string generate_msg() const { return "Undefined error"; }
22 |   };
23 | 
24 |   struct CompileError: Error {
25 |     const string compile_msg;
26 |     const Pos pos;
27 |     
28 |     CompileError(Pos pos, const string &msg): compile_msg(msg), pos(pos) { }
29 | 
30 |     string generate_msg() const override {
31 |       return fmt("Compile error in row %0, col %1: %2",
32 |                  {pos.row, pos.col, compile_msg});
33 |     }
34 |   };
35 | 
36 |   struct SyntaxError: CompileError {
37 |     SyntaxError(Pos pos, const string &msg): CompileError(pos, msg) { }
38 | 
39 |     string generate_msg() const override {
40 |       return fmt("Syntax error in row %0, col %1: %2",
41 |                  {pos.row, pos.col, compile_msg});
42 |     }
43 |   };
44 | 
45 |   inline bool operator ==(const Error &lhs, const Error &rhs) {
46 |     return false;
47 |   }
48 | 
49 |   inline bool operator <(const Error &lhs, const Error &rhs) {
50 |     throw Error("Errors are not comparable");
51 |   }
52 | }
53 | 
54 | #endif
55 | 


--------------------------------------------------------------------------------
/src/snabl/mpool.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_MPOOL_HPP
 2 | #define SNABL_MPOOL_HPP
 3 | 
 4 | #include "snabl/types.hpp"
 5 | 
 6 | namespace snabl {
 7 |   template <typename T>
 8 |   struct MPool {
 9 |     static const I64 NSLOTS = 64;
10 | 
11 |     struct Slot {
12 |       typename aligned_storage<sizeof(T), alignof(T)>::type val;
13 |       Slot *next = nullptr;
14 |     };
15 |     
16 |     struct Slab {
17 |       Slot slots[NSLOTS];
18 |       Slab *next = nullptr;
19 | 
20 |       Slab(Slab *next): next(next) { }
21 |     };
22 |     
23 |     Slab *slab = nullptr;
24 |     size_t offs = NSLOTS;
25 |     Slot *free = nullptr;;
26 | 
27 |     MPool(const MPool &)=delete;
28 |     const MPool &operator =(const MPool &)=delete;
29 | 
30 |     MPool() { }
31 |     
32 |     ~MPool() {
33 |       for (Slab *s(slab), *ns = s ? s->next : nullptr;
34 |            s;
35 |            s = ns, ns = s ? s->next : nullptr) { delete s; }
36 |     }
37 | 
38 |     template <typename...ArgsT>
39 |     T *acquire(ArgsT &&...args) {
40 |       T *p(nullptr);
41 |       
42 |       if (free) {
43 |         p = reinterpret_cast<T *>(&free->val);
44 |         free = free->next;
45 |       } else {
46 |         if (offs == NSLOTS) {
47 |           slab = new Slab(slab);
48 |           offs = 0;
49 |         }
50 | 
51 |         p = reinterpret_cast<T *>(&slab->slots[offs++].val);
52 |       }
53 | 
54 |       return new (p) T(forward<ArgsT>(args)...);
55 |     }
56 | 
57 |     void release(T *ptr) {
58 |       auto s(reinterpret_cast<Slot *>(ptr));
59 |       s->next = free;
60 |       free = s;
61 | 
62 |       ptr->~T();
63 |     }
64 |   };
65 | }
66 | 
67 | #endif
68 | 


--------------------------------------------------------------------------------
/src/snabl/bset.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_BSET_HPP
 2 | #define SNABL_BSET_HPP
 3 | 
 4 | #include "snabl/cmp.hpp"
 5 | #include "snabl/std.hpp"
 6 | #include "snabl/types.hpp"
 7 | 
 8 | namespace snabl {
 9 |   template <typename KeyT, typename ValT>
10 |   struct BSet {
11 |     using Vals = vector<ValT>;
12 |     Vals vals;
13 |     KeyT ValT::*key_ptr;
14 |     
15 |     BSet(KeyT ValT::*key_ptr): key_ptr(key_ptr) { }
16 | 
17 |     BSet(KeyT ValT::*key_ptr, const Vals &source):
18 |       vals(source), key_ptr(key_ptr) { }
19 | 
20 |     I64 find(const KeyT &key, I64 min, ValT **found=nullptr) const {
21 |       I64 max = vals.size();
22 |       
23 |       while (min < max) {
24 |         const I64 i = (max+min) / 2;
25 |         const ValT &v(vals[i]);
26 |         const KeyT &k = v.*key_ptr;
27 |         
28 |         switch (cmp(key, k)) {
29 |         case Cmp::LT:
30 |           max = i;
31 |           break;
32 |         case Cmp::EQ:
33 |           if (found) { *found = const_cast<ValT *>(&v); }
34 |           return i;
35 |         case Cmp::GT:
36 |           min = i+1;
37 |           break;
38 |         }
39 |       }
40 |       
41 |       return min;
42 |     }
43 |     
44 |     ValT *find(const KeyT &key) const {
45 |       ValT *found(nullptr);
46 |       find(key, 0, &found);
47 |       return found;
48 |     }
49 | 
50 |     template <typename...ArgsT>
51 |     ValT *emplace(const KeyT &key, ArgsT &&...args) {
52 |       ValT *found(nullptr);
53 |       const I64 i(find(key, 0, &found));
54 |       if (found) { return nullptr; }
55 |       return &*vals.emplace(vals.begin()+i, forward<ArgsT>(args)...);
56 |     }
57 | 
58 |     void clear() { vals.clear(); }
59 |   };
60 | }
61 | 
62 | #endif
63 | 


--------------------------------------------------------------------------------
/src/snabl/lib.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/env.hpp"
 2 | #include "snabl/lib.hpp"
 3 | 
 4 | namespace snabl {
 5 |   Lib::Lib(Env &env, Sym id, Lib *parent):
 6 |     Def(id),
 7 |     env(env),
 8 |     qid(parent ? env.sym(fmt("%0.%1", {parent->qid, id})) : id) { }
 9 | 
10 |   Macro &Lib::add_macro(Sym id, const Macro::Imp &imp) {
11 |     auto found(lib_defs.find(id));
12 | 
13 |     if (found != lib_defs.end()) {
14 |       auto m(dynamic_cast<Macro *>(found->second.get()));
15 |       m->~Macro();
16 |       new (m) Macro(*this, id, imp);
17 |       return *m;
18 |     }
19 | 
20 |     auto m(new Macro(*this, id, imp));
21 |     defs.emplace(id, m);
22 |     lib_defs.emplace(id, unique_ptr<Def>(m));
23 |     return *m;
24 |   }
25 |   
26 |   EnumType &Lib::add_enum_type(Sym id, const vector<Sym> &alts) {
27 |     return add_type<EnumType>(id, {&env.enum_type}, alts);
28 |   }
29 | 
30 |   Func &Lib::add_func(Sym id, I64 nargs) {
31 |     auto found(lib_defs.find(id));
32 |     
33 |     if (found != lib_defs.end()) {
34 |       return *dynamic_cast<Func *>(found->second.get());
35 |     }
36 | 
37 |     auto f(new Func(*this, id, nargs));
38 |     defs.emplace(id, f);
39 |     lib_defs.emplace(id, unique_ptr<Def>(f)).first->second;
40 |     return *f;
41 |   }
42 |   
43 |   Def *Lib::get_def(Sym id) {
44 |     auto found(defs.find(id));
45 |     return (found == defs.end()) ? nullptr : found->second;
46 |   }
47 | 
48 |   bool Lib::use_def(Def &def) {
49 |     auto found(defs.find(def.id));
50 | 
51 |     if (found != defs.end()) {
52 |       if (found->second == &def) { return false; }
53 |       throw CompileError(env.pos(), fmt("Name conflict: %0", {def.id}));
54 |     }
55 |       
56 |     defs.emplace(def.id, &def);
57 |     return true;
58 |   }
59 | 
60 | }
61 | 


--------------------------------------------------------------------------------
/todo.org:
--------------------------------------------------------------------------------
 1 | * remove MPool::Slot
 2 | ** add T *mpool_next=nullptr to pooled structs
 3 | ** remove casts where possible
 4 | * remove Ptr::Imp
 5 | ** add I64 ptr_nrefs=nullptr to pointed structs
 6 | *** grep types/PtrType
 7 | ** remove casts where possible
 8 | * add Split struct
 9 | ** offs & prev
10 | ** replaces task.splits
11 | ** compare Scope struct size
12 | * ---
13 | * add derived type methods
14 | ** convert remaining methods
15 | *** copy on derive
16 | * add or: macro
17 | ** get first operand from stack
18 | ** treat body forms as multiple operands
19 | * change ddrop! to ndrop!
20 | ** take n as arg
21 | ** use erase
22 | ** update bench/readme
23 | * add and: macro
24 | ** like or:
25 | * add include: macro
26 | ** one arg
27 | ** load all files into ops
28 | ** add bench/all.sl
29 | * replace Func.fimps with BSet
30 | * add clear! macro
31 | ** Clear op
32 | * add for: loop
33 | ** Iter ... IterNext
34 | ** keep iter in Iter op
35 | ** step and jump to start in IterNext
36 | * eval fimps at compile time
37 | ** <3 times: Int>
38 | ** begin/end_scope
39 | ** use stack as args
40 | * add define: macro
41 | * add support for str special chars
42 | * add support for func/fimp refs with &
43 | ** add func/fimp type
44 | * add Ref support
45 | ** add bench/fib3.sl
46 | * add Pair type
47 | ** use std::pair<Box, Box>
48 | * implement push for sinks
49 | ** Str
50 | * implement peek/pop for sources
51 | ** Str/Iter
52 | * add alias: Foo Int macro
53 | ** allow aliasing funcs/fimps/types
54 | ** enable macro processing for all ids
55 | * add type: Foo Int macro
56 | ** derive new type from parent
57 | ** generate constructor 
58 | * drop MacroPtr
59 | * add use: macro
60 | * add lib: macro
61 | * convert Forms to <unique_ptr<Form>> like ops
62 | 
63 | ''test.sl'' r fopen await: str
64 | 


--------------------------------------------------------------------------------
/tests/all.sl:
--------------------------------------------------------------------------------
 1 | 42 I64 is t test=
 2 | I64 Num? t test=
 3 | 
 4 | 42 nil? f test=
 5 | nil nil? t test=
 6 | nil bool f test=
 7 | 
 8 | t bool t test=
 9 | f bool f test=
10 | 
11 | 0 bool f test=
12 | 1 bool t test=
13 | 
14 | 1 1 = t test=
15 | 1 3 = f test=
16 | 
17 | 1 1? t test=
18 | 1 3? f test=
19 | 
20 | 'foo 'foo? t test=
21 | 'foo 'bar? f test=
22 | 
23 | 1 3 < t test=
24 | 1 1 < f test=
25 | 3 1 < f test=
26 | 
27 | 3.14 int 3 test=
28 | 
29 | 1 3 + 4 test=
30 | 1 3 +<_ I64> 4 test=
31 | 
32 | ''foo'bar'' ''foo'bar'' test=
33 | ''abc'' iter call! #a test=
34 | 
35 | 1 3 5 drop! + 4 test=
36 | 21 dup! + 42 test=
37 | 1 3 swap! - 2 test=
38 | 1 2 3 rot! - - 4 test=
39 | 
40 | 1 2 [3 4 5] len 3 test=
41 | |1 2 [..3 4 5] len 5 test=
42 | |3.. [..] len 3 test=
43 | 42 stack peek 41 test=
44 | 
45 | {42 let: foo @foo} 42 test=
46 | {21 let: foo &{@foo}} call! 21 test=
47 | 
48 | t if: 1 3 1 test=
49 | f if: 1 3 3 test=
50 | 
51 | 7 switch: (, 3 -) 4 test=
52 | 
53 | 35 switch: (
54 |   (42 <) 'foo,
55 |   drop! 'bar
56 | ) 'foo test=
57 | 
58 | 35 switch: (
59 |   (7 <) 'foo,
60 |   drop! 'bar
61 | ) 'bar test=
62 | 
63 | 35 switch: (
64 |   (7 <) 'foo
65 |   (42 <) 'bar,
66 |   drop! 'baz
67 | ) 'bar test= 
68 | 
69 | 2 3 times: ++ 5 test=
70 | 0 while: (++ dup! 42 <) 42 test=
71 | 
72 | &(1 2 +) call! 3 test=
73 | 
74 | func: double<T> (2 *)
75 | 21 double 42 test=
76 | 
77 | 42 let: result
78 | func: closure<> @result
79 | closure 42 test=
80 | 
81 | func: early<> ('before return! 'after)
82 | early 'before test=
83 | 
84 | try: 42 nil test=
85 | try: 42 drop! 42 test=
86 | 
87 | try: (41 throw!) catch ++ 42 test=
88 | try: (try: (41 throw!) throw!) catch ++ 42 test=
89 | 
90 | 3 iter
91 | dup! call! swap! dup! call! swap!
92 | call! + + 3 test=
93 | 
94 | enum: Foo (foo/bar foo/baz)
95 | foo/bar Foo is t test=
96 | foo/bar foo/baz = f test=
97 | foo/bar foo/baz < t test=
98 | foo/bar sym 'foo/bar test=


--------------------------------------------------------------------------------
/src/snabl/types/str.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/box.hpp"
 2 | #include "snabl/env.hpp"
 3 | #include "snabl/iter.hpp"
 4 | #include "snabl/ptr.hpp"
 5 | #include "snabl/types/str.hpp"
 6 | 
 7 | namespace snabl {
 8 |   StrType::StrType(Lib &lib, Sym id, const vector<AType *> &parents):
 9 |     PtrType<Str>(lib, id, parents) {
10 |     equid = [](const Box &lhs, const Box &rhs) {
11 |       return lhs.as<StrPtr>() == rhs.as<StrPtr>();
12 |     };
13 |     
14 |     eqval = [](const Box &lhs, const Box &rhs) {
15 |       return *lhs.as<StrPtr>() == *rhs.as<StrPtr>();
16 |     };
17 |   }
18 | 
19 |   bool StrType::as_bool(const Box &val) const { return !val.as<StrPtr>()->empty(); }
20 | 
21 |   Cmp StrType::cmp(const Box &lhs, const Box &rhs) const {
22 |     return snabl::cmp(*lhs.as<StrPtr>(), *rhs.as<StrPtr>());
23 |   }
24 | 
25 |   void StrType::push(Box &sink, const Box &val) const {
26 |     sink.as<BinPtr>()->push_back(val.as_char);
27 |   }
28 | 
29 |   optional<Box> StrType::peek(const Box &source) const {
30 |     Env &env(source.type->lib.env);
31 |     auto &s(*source.as<StrPtr>());
32 |     return s.empty() ? nullopt : make_optional<Box>(env.char_type, s.back());
33 |   }
34 | 
35 |   void StrType::pop(Box &source) const { source.as<StrPtr>()->pop_back(); }
36 |   
37 |   IterPtr StrType::iter(const Box &val) const {
38 |     Env &env(val.type->lib.env);
39 | 
40 |     const StrPtr s(val.as<StrPtr>());
41 |     auto i(s->begin());
42 |     
43 |     return IterPtr::make(&env.iter_type.pool, [&env, s, i]() mutable {
44 |         if (i == s->end()) { return false; }
45 |         env.push(env.char_type, Char(*i++));
46 |         return true;
47 |       });
48 |   }
49 | 
50 |   void StrType::dump(const Box &val, ostream &out) const {
51 |     out << "''" << *val.as<StrPtr>() << "''";
52 |   }
53 | 
54 |   void StrType::print(const Box &val, ostream &out) const {
55 |     out << *val.as<StrPtr>();
56 |   }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/snabl/func.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_FUNC_HPP
 2 | #define SNABL_FUNC_HPP
 3 | 
 4 | #include "snabl/def.hpp"
 5 | #include "snabl/fimp.hpp"
 6 | #include "snabl/ptrs.hpp"
 7 | #include "snabl/stack.hpp"
 8 | #include "snabl/std.hpp"
 9 | 
10 | namespace snabl {
11 |   struct Lib;
12 | 
13 |   struct Func: Def {
14 |     Lib &lib;
15 |     const I64 nargs;
16 |     unordered_map<Sym, unique_ptr<Fimp>> fimps;
17 |     
18 |     Func(const Func &)=delete;
19 |     const Func &operator =(const Func &)=delete;
20 | 
21 |     Func(Lib &lib, Sym id, I64 nargs): Def(id), lib(lib), nargs(nargs) { }
22 | 
23 |     template <typename... ImpT>
24 |     Fimp &add_fimp(const Fimp::Args &args, ImpT &&... imp);
25 | 
26 |     Fimp &get_fimp() const { return *fimps.begin()->second; }
27 | 
28 |     Fimp *get_best_fimp(Stack::const_iterator begin,
29 |                         Stack::const_iterator end) const {
30 |       I64 best_score(-1);
31 |       Fimp *best_fimp(nullptr);
32 |       
33 |       for (auto &fp: fimps) {
34 |         auto &f(*fp.second);
35 |         auto fs(f.score(begin, end));
36 |         
37 |         if (fs != -1) {
38 |           if (fs == 0) { return &f; }
39 |           
40 |           if (best_score == -1 || fs < best_score) {
41 |             best_score = fs;
42 |             best_fimp = &f;
43 |           }
44 |         }
45 |       }
46 |       
47 |       return best_fimp;
48 |     }
49 |   };
50 | 
51 |   template <typename... ImpT>
52 |   Fimp &Func::add_fimp(const Fimp::Args &args, ImpT &&... imp) {
53 |     auto id(Fimp::get_id(*this, args));
54 |     auto found = fimps.find(id);
55 |     
56 |     if (found == fimps.end()) {
57 |       return *fimps.emplace(id, make_unique<Fimp>(*this, args, forward<ImpT>(imp)...))
58 |         .first->second;
59 |     }
60 | 
61 |     auto *fi(found->second.get());
62 |     fi->~Fimp();
63 |     new (fi) Fimp(*this, args, forward<ImpT>(imp)...);
64 |     return *fi;
65 |   }
66 | }
67 | 
68 | #endif
69 | 


--------------------------------------------------------------------------------
/src/snabl/fimp.cpp:
--------------------------------------------------------------------------------
 1 | #include "snabl/call.hpp"
 2 | #include "snabl/env.hpp"
 3 | #include "snabl/fimp.hpp"
 4 | #include "snabl/lib.hpp"
 5 | 
 6 | namespace snabl {
 7 |   Sym Fimp::get_id(const Func &func, const Args &args) {
 8 |     stringstream buf;
 9 |     buf << func.id.name() << '<';
10 |     char sep = 0;
11 | 
12 |     for (auto &a: args) {
13 |       if (sep) {
14 |         buf << sep;
15 |       } else {
16 |         sep = ' ';
17 |       }
18 | 
19 |       if (a.is_valid) {
20 |         a.write(buf);
21 |       } else {
22 |         buf << a.type->id.name();
23 |       }
24 |     }
25 | 
26 |     buf << '>';
27 |     return func.lib.env.sym(buf.str());
28 |   }
29 | 
30 |   Fimp::Fimp(Func &func, const Args &args, Imp imp):
31 |     Def(get_id(func, args)), func(func), args(args), imp(imp) { }
32 | 
33 |   Fimp::Fimp(Func &func, const Args &args, const Form &form):
34 |     Def(get_id(func, args)), func(func), args(args), form(form) { }
35 | 
36 |   I64 Fimp::score(Stack::const_iterator begin, Stack::const_iterator end) const {
37 |     auto &env(func.lib.env);
38 |     auto no_type(&env.no_type);
39 |     auto i(begin), j(args.begin());
40 |     I64 score(0);
41 | 
42 |     for (; j != args.end(); i++, j++) {
43 |       if (i == end) { return -1; }
44 |       const Box &iv(*i), &jv(*j);
45 |       const AType *it(iv.type), &jt(*jv.type);
46 |       if (it == no_type) { continue; }
47 | 
48 |       if (jv.is_valid) {
49 |         if (!iv.is_valid || !iv.eqval(jv)) { return -1; }
50 |       } else if (!it->is(jt)) {
51 |         return -1;
52 |       }
53 |       
54 |       score += abs(static_cast<I64>(it->tag-jt.tag));
55 |     }
56 | 
57 |     return score;
58 |   }
59 | 
60 |   bool Fimp::compile(Pos pos) {
61 |     if (start_pc) { return false; }
62 |     auto &env(func.lib.env);
63 |     bool is_scope(&form->type == &forms::Scope::type);
64 |     auto &start_op(env.emit<ops::Fimp>(pos, *this, is_scope));      
65 | 
66 |     if (is_scope) {
67 |       env.begin_regs();
68 |       auto &b(form->as<forms::Scope>().body);
69 |       env.compile(b);
70 |       env.end_regs();
71 |     } else {
72 |       env.compile(*form);
73 |     }
74 |     
75 |     env.emit<ops::Return>(pos);
76 |     start_pc = start_op.next;
77 |     end_pc = env.ops.size();
78 |     return true;
79 |   }
80 | 
81 |   void Fimp::call(Pos pos) {
82 |     auto &env(func.lib.env);
83 |     
84 |     if (imp) {
85 |       env.begin_call(*this, pos, env.pc());
86 |       imp(*this);
87 |       env.end_call();
88 |     } else {
89 |       compile(pos);
90 |       if (vars) { env.begin_scope(*vars); }
91 |       env.begin_split(func.nargs);    
92 |       env.begin_call(*this, pos, env.pc());
93 |       env.jump(start_pc);
94 |     }
95 |   }
96 | }
97 | 


--------------------------------------------------------------------------------
/src/snabl/lib.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_LIB_HPP
 2 | #define SNABL_LIB_HPP
 3 | 
 4 | #include "snabl/def.hpp"
 5 | #include "snabl/error.hpp"
 6 | #include "snabl/func.hpp"
 7 | #include "snabl/macro.hpp"
 8 | #include "snabl/std.hpp"
 9 | #include "snabl/sym.hpp"
10 | #include "snabl/type.hpp"
11 | #include "snabl/types/enum.hpp"
12 | 
13 | namespace snabl {
14 |   struct Env;
15 |   
16 |   struct Lib: Def {
17 |     Env &env;
18 |     const Sym qid;
19 |     unordered_map<Sym, unique_ptr<Def>> lib_defs;
20 |     unordered_map<Sym, Def *> defs;
21 | 
22 |     Lib(const Lib &)=delete;
23 |     const Lib &operator=(const Lib &)=delete;
24 |     
25 |     Lib(Env &env, Sym id, Lib *parent=nullptr);
26 |     
27 |     template <typename ValT, typename... ArgsT>
28 |     Macro &add_macro(Sym id, Type<ValT> &type, ArgsT &&... args);
29 | 
30 |     template <typename OpT, typename... ArgsT>
31 |     Macro &add_macro(Sym id, ArgsT &&... args);
32 | 
33 |     Macro &add_macro(Sym id, const Macro::Imp &imp);
34 | 
35 |     template <typename TypeT, typename... ArgsT>
36 |     TypeT &add_type(Sym id, const vector<AType *> &parents={}, ArgsT &&... args);
37 | 
38 |     EnumType &add_enum_type(Sym id, const vector<Sym> &alts);
39 |     
40 |     Func &add_func(Sym id, I64 nargs);
41 | 
42 |     template <typename... ImpT>
43 |     Fimp &add_fimp(Sym id, const Fimp::Args &args, ImpT &&... imp);
44 | 
45 |     Def *get_def(Sym id);
46 |     bool use_def(Def &def);
47 |     
48 |     Macro *get_macro(Sym id) {
49 |       auto d(get_def(id));
50 |       return d ? dynamic_cast<Macro *>(d) : nullptr;
51 |     }
52 | 
53 |     AType *get_type(Sym id) {
54 |       auto d(get_def(id));
55 |       return d ? dynamic_cast<AType *>(d) : nullptr;
56 |     }
57 | 
58 |     Func *get_func(Sym id) {
59 |       auto d(get_def(id));
60 |       return d ? dynamic_cast<Func *>(d) : nullptr;
61 |     }
62 |   };
63 | 
64 |   template <typename TypeT, typename... ArgsT>
65 |   TypeT &Lib::add_type(Sym id, const vector<AType *> &parents, ArgsT &&... args) {
66 |     auto found(lib_defs.find(id));
67 | 
68 |     if (found != lib_defs.end()) {
69 |       auto t(dynamic_cast<TypeT *>(found->second.get()));
70 |       t->~TypeT();
71 |       new (t) TypeT(*this, id, parents, forward<ArgsT>(args)...);
72 |       return *t;
73 |     }
74 | 
75 |     auto t(new TypeT(*this, id, parents, forward<ArgsT>(args)...));
76 |     defs.emplace(t->id, t);
77 |     lib_defs.emplace(t->id, unique_ptr<Def>(t));
78 |     return *t;
79 |   }
80 | 
81 |   template <typename... ImpT>
82 |   Fimp &Lib::add_fimp(Sym id, const Fimp::Args &args, ImpT &&... imp) {
83 |     auto &fn(add_func(id, args.size()));
84 |     return fn.add_fimp(args, forward<ImpT>(imp)...);
85 |   }
86 | }
87 | 
88 | #endif
89 | 


--------------------------------------------------------------------------------
/src/snabl/atype.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_ATYPE_HPP
 2 | #define SNABL_ATYPE_HPP
 3 | 
 4 | #include "snabl/cmp.hpp"
 5 | #include "snabl/def.hpp"
 6 | #include "snabl/error.hpp"
 7 | #include "snabl/fmt.hpp"
 8 | #include "snabl/iter.hpp"
 9 | #include "snabl/ptrs.hpp"
10 | #include "snabl/pos.hpp"
11 | #include "snabl/std.hpp"
12 | 
13 | namespace snabl {
14 |   struct Box;
15 |   struct Lib;
16 | 
17 |   struct AType: Def {
18 |     Lib &lib;
19 |     const I64 size;
20 |     const I64 tag;
21 |     vector<AType *> parents;
22 |     unordered_set<AType *> children;
23 | 
24 |     function<bool (const Box &, const Box &)> equid =
25 |       [this](const Box &lhs, const Box &rhs) {
26 |       return eqval(lhs, rhs);
27 |     };
28 |     
29 |     function<bool (const Box &, const Box &)> eqval;
30 | 
31 |     AType(const AType &)=delete;
32 |     const AType &operator =(const AType &)=delete;
33 |     
34 |     AType(Lib &lib, Sym id, I64 size, const vector<AType *> &parents);
35 | 
36 |     virtual ~AType() { }
37 | 
38 |     void derive(AType &parent) {
39 |       if (I64(parents.size()) <= parent.tag) { parents.resize(parent.tag+1); }
40 |       
41 |       if (!parents[parent.tag]) {
42 |         parents[parent.tag] = &parent;
43 |         for (auto &c: children) { c->derive(parent); }
44 |         parent.children.insert(this);
45 |         
46 |         for (auto &p: parent.parents) {
47 |           if (p) { derive(*p); }
48 |         }
49 | 
50 |         equid = parent.equid;
51 |         eqval = parent.eqval;
52 |       }
53 |     }
54 |     
55 |     bool is(const AType &parent) const {
56 |       return
57 |         &parent == this ||
58 |         (I64(parents.size()) > parent.tag && parents[parent.tag]);
59 |     }
60 |                                                              
61 |     virtual Cmp cmp(const Box &lhs, const Box &rhs) const {
62 |       throw Error("cmp() is not implemented");
63 |       return Cmp::LT;
64 |     }
65 |     
66 |     virtual bool as_bool(const Box &val) const { return true; }
67 |     
68 |     virtual void call(const Box &val, Pos pos) const {
69 |       throw Error("call() is not implemented");
70 |     }
71 |     
72 | 
73 |     virtual void push(Box &sink, const Box &val) const {
74 |       throw Error("push() is not implemented");
75 |     }
76 | 
77 |     virtual optional<Box> peek(const Box &source) const;
78 | 
79 |     virtual void pop(Box &source) const {
80 |       throw Error("pop() is not implemented");
81 |     }
82 | 
83 |     virtual IterPtr iter(const Box &val) const {
84 |       throw Error("iter() is not implemented");
85 |     }
86 |     
87 |     virtual void dump(const Box &val, ostream &out) const {
88 |       out << '(' << id.name() << ')';
89 |     }
90 |     
91 |     virtual void print(const Box &val, ostream &out) const { dump(val, out); }
92 |     virtual void write(const Box &val, ostream &out) const { print(val, out); }
93 |   };
94 | }
95 | 
96 | #endif
97 | 


--------------------------------------------------------------------------------
/src/snabl/ptr.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef SNABL_PTR_HPP
  2 | #define SNABL_PTR_HPP
  3 | 
  4 | #include "snabl/mpool.hpp"
  5 | #include "snabl/std.hpp"
  6 | 
  7 | namespace snabl {
  8 |   template <typename T>
  9 |   struct Ptr {
 10 |     struct Imp {
 11 |       T val;
 12 |       size_t nrefs;
 13 |       
 14 |       template <typename...ArgsT>
 15 |       Imp(ArgsT &&...args): val(forward<ArgsT>(args)...), nrefs(0) { }
 16 |     };
 17 | 
 18 |     struct Make {};
 19 |     
 20 |     MPool<Imp> *pool=nullptr;
 21 |     Imp *imp=nullptr;
 22 | 
 23 |     template <typename... ArgsT>
 24 |     static Ptr<T> make(MPool<Imp> *pool, ArgsT &&... args) {
 25 |       return Ptr<T>(Make(), pool, forward<ArgsT>(args)...);
 26 |     }
 27 |     
 28 |     Ptr(nullptr_t _ = nullptr) { }
 29 | 
 30 |     Ptr(const Ptr<T> &src): pool(src.pool), imp(src.imp) {
 31 |       if (imp) { imp->nrefs++; }
 32 |     }
 33 |     
 34 |     Ptr(Ptr<T> &&src): pool(src.pool), imp(src.imp) { src.imp = nullptr; }
 35 |     
 36 |     template <typename... ArgsT>
 37 |     Ptr(const Make &_, MPool<Imp> *pool, ArgsT &&... args):
 38 |       pool(pool),
 39 |       imp(pool
 40 |           ? pool->acquire(forward<ArgsT>(args)...)
 41 |           : new Imp(forward<ArgsT>(args)...)) { }
 42 |     
 43 |     ~Ptr() {
 44 |       if (imp) { decr(); }
 45 |     }
 46 |     
 47 |     const Ptr<T> &operator =(const Ptr<T> &src) {
 48 |       if (imp != src.imp) {
 49 |         if (imp) { decr(); }
 50 |         pool = src.pool;
 51 |         if ((imp = src.imp)) { imp->nrefs++; }
 52 |       }
 53 | 
 54 |       return *this;
 55 |     }
 56 | 
 57 |     Ptr<T> &operator =(Ptr<T> &&src) {
 58 |       if (imp != src.imp) {
 59 |         if (imp) { decr(); }
 60 |         pool = src.pool;
 61 |         imp = src.imp;        
 62 |         src.imp = nullptr;
 63 |       }
 64 |       
 65 |       return *this;
 66 |     }
 67 | 
 68 |     T *get() const { return const_cast<T *>(&imp->val); }    
 69 |     T *get() { return &imp->val; }
 70 | 
 71 |     T &operator *() const { return const_cast<T &>(imp->val); }    
 72 |     T &operator *() { return imp->val; }
 73 | 
 74 |     T *operator ->() const { return const_cast<T *>(&imp->val); }    
 75 |     T *operator ->() { return &imp->val; }
 76 | 
 77 |     operator bool() const { return imp; }
 78 |     
 79 |     size_t nrefs() const { return imp ? imp->nrefs : 0; }
 80 | 
 81 |     void decr() {
 82 |       if (!imp->nrefs) {
 83 |         if (pool) {
 84 |           pool->release(imp);
 85 |         } else {
 86 |           delete imp;
 87 |         }
 88 |           
 89 |         imp = nullptr;
 90 |       } else {
 91 |         imp->nrefs--;
 92 |       }
 93 |     }
 94 |   };
 95 | 
 96 |   template <typename T>
 97 |   bool operator ==(const Ptr<T> &lhs, const Ptr<T> &rhs) {
 98 |     return lhs.imp == rhs.imp;
 99 |   }
100 | 
101 |   template <typename T>
102 |   ostream &operator <<(ostream &out, const Ptr<T> &x) {
103 |     out << x.get() ? "null" : *x;
104 |     return out;
105 |   }
106 | }
107 | 
108 | #endif
109 | 


--------------------------------------------------------------------------------
/src/snabl/box.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SNABL_BOX_HPP
 2 | #define SNABL_BOX_HPP
 3 | 
 4 | #include "snabl/atype.hpp"
 5 | #include "snabl/cmp.hpp"
 6 | #include "snabl/error.hpp"
 7 | #include "snabl/ptrs.hpp"
 8 | #include "snabl/std.hpp"
 9 | #include "snabl/sym.hpp"
10 | #include "snabl/time.hpp"
11 | #include "snabl/type.hpp"
12 | #include "snabl/types/byte.hpp"
13 | #include "snabl/types/enum.hpp"
14 | #include "snabl/types/nil.hpp"
15 | 
16 | namespace snabl {
17 |   struct Box {
18 |     AType *type;
19 | 
20 |     union {
21 |       bool as_bool;
22 |       Byte as_byte;
23 |       Char as_char;
24 |       Enum as_enum;
25 |       Float as_float;
26 |       I64 as_i64;
27 |       Sym as_sym;
28 |       Time as_time;
29 |     };
30 | 
31 |     any val;
32 |     bool is_valid=true;
33 |       
34 |     Box(AType &type): type(&type), is_valid(false) { }
35 |     Box(Type<Nil> &type): type(&type) { }
36 |     Box(Type<bool> &type, bool val): type(&type), as_bool(val) { }
37 |     Box(Type<Byte> &type, Byte val): type(&type), as_byte(val) { }
38 |     Box(Type<Char> &type, Char val): type(&type), as_char(val) { }
39 |     Box(Type<Enum> &type, Enum val): type(&type), as_enum(val) { }
40 |     Box(Type<Float> &type, Float val): type(&type), as_float(val) { }
41 |     Box(Type<I64> &type, I64 val): type(&type), as_i64(val) { }
42 |     Box(Type<Sym> &type, Sym val): type(&type), as_sym(val) { }
43 |     Box(Type<Time> &type, Time val): type(&type), as_time(val) { }
44 |     
45 |     template <typename ValT>
46 |     Box(Type<ValT> &type, const ValT &val): type(&type), val(val) { }
47 | 
48 |     template <typename ValT>
49 |     const ValT &as() const {
50 |       assert(sizeof(ValT) == type->size);
51 |       return any_cast<const ValT &>(val);
52 |     }
53 | 
54 |     template <typename ValT>
55 |     ValT &as() {
56 |       assert(sizeof(ValT) == type->size);
57 |       return any_cast<ValT &>(val);
58 |     }
59 | 
60 |     bool is(const AType &rhs) const;
61 |     
62 |     bool equid(const Box &rhs) const {
63 |       if (rhs.type != type) { return false; }
64 |       return type->equid(*this, rhs);
65 |     }
66 |     
67 |     bool eqval(const Box &rhs) const {
68 |       if (rhs.type != type) { return false; }
69 |       return type->eqval(*this, rhs);
70 |     }
71 |     
72 |     Cmp cmp(const Box &rhs) const {
73 |       auto rt(rhs.type);
74 |       if (rt != type) { return snabl::cmp(type->tag, rt->tag); }
75 |       return type->cmp(*this, rhs);
76 |     }
77 | 
78 |     operator bool() const { return type->as_bool(*this); }
79 |     void call(Pos pos) const { type->call(*this, pos); }
80 |     void push(const Box &val) { type->push(*this, val); }
81 |     optional<Box> peek() const { return type->peek(*this); }
82 |     void pop() { type->pop(*this); }
83 |     IterPtr iter() const { return type->iter(*this); }
84 |     void dump(ostream &out) const { type->dump(*this, out); }
85 |     void print(ostream &out) const { type->print(*this, out); }
86 |     void write(ostream &out) const { type->write(*this, out); }
87 |   };
88 | 
89 |   inline ostream &operator <<(ostream &out, const Box &x) {
90 |     x.print(out);
91 |     return out;
92 |   }
93 | }
94 | 
95 | #endif
96 | 


--------------------------------------------------------------------------------
/src/snabl/env.cpp:
--------------------------------------------------------------------------------
  1 | #include <ctype.h>
  2 | 
  3 | #include "snabl/env.hpp"
  4 | #include "snabl/parser.hpp"
  5 | 
  6 | namespace snabl {
  7 |   void Env::use(Sym lib_id, const vector<Sym> def_ids) {
  8 |     Lib *lib(get_lib(lib_id));
  9 |     if (!lib) { throw CompileError(pos(), fmt("Unknown lib: %0", {lib_id})); }
 10 | 
 11 |     if (def_ids.empty()) {
 12 |       for (auto &d: lib->lib_defs) { task->lib->use_def(*d.second); }
 13 |     } else {
 14 |       for (auto did: def_ids) {
 15 |         auto d(lib->get_def(did));
 16 |         if (!d) { throw CompileError(pos(), fmt("Unknown def: %0", {lib_id})); }
 17 |         task->lib->use_def(*d);
 18 |       }
 19 |     }
 20 |   }
 21 |   
 22 |   void Env::compile(string_view in) {
 23 |     const string s(in);
 24 |     istringstream ss(s);
 25 |     compile(ss);
 26 |   }
 27 | 
 28 |   void Env::compile(istream &in) {
 29 |     Forms forms;
 30 |     Parser(*this).parse(in, forms);   
 31 |     compile(forms);
 32 |   }
 33 | 
 34 |   void Env::compile(const Forms &forms) { compile(forms.begin(), forms.end()); }
 35 |   
 36 |   void Env::compile(const Form &form) {
 37 |     Forms fs {form};
 38 |     auto i(fs.cbegin());
 39 |     i->imp->compile(i, i+1, *this);
 40 |   }
 41 | 
 42 |   void Env::compile(Forms::const_iterator begin, Forms::const_iterator end) {
 43 |     for (auto i(begin); i != end;) { i->imp->compile(i, end, *this); }
 44 |   }
 45 | 
 46 |     void Env::run(string_view in) {
 47 |     const string s(in);
 48 |     istringstream ss(s);
 49 |     run(ss);
 50 |   }
 51 | 
 52 |   void Env::run(istream &in) {
 53 |     Forms fs;
 54 |     Parser(*this).parse(in, fs);
 55 | 
 56 |     const auto start_pc(ops.size());
 57 |     compile(fs.begin(), fs.end());
 58 |     
 59 |     if (!ops.empty()) {
 60 |       jump(start_pc);
 61 |       run();
 62 |     }
 63 |   }
 64 | 
 65 |   void Env::run() {
 66 |   start:    
 67 |     try {
 68 |       while (task->pc) { task->pc->run(*this); }
 69 | 
 70 |       if (task != &main_task) {
 71 |         task->status = Task::Status::Done;
 72 |         auto next(task->next);
 73 |         task->prev->next = task->next;
 74 |         task->next->prev = task->prev;
 75 |         task_pool.release(task);
 76 |         task = next;
 77 |         goto start;
 78 |       }
 79 |     } catch (const UserError &e) {
 80 |       if (!task->_try) { throw e; }
 81 |       auto &t(*task->_try);
 82 |       auto &s(t.state);
 83 |       s.restore_env(*this);
 84 |       s.restore_call(*this);
 85 |       end_try();
 86 |       
 87 |       push(error_type, e);
 88 |       jump(t.op.end_pc);
 89 |     }
 90 | 
 91 |     if (task->pc) { goto start; }
 92 |   }
 93 | 
 94 |   optional<Box> Env::async(const function<optional<Box> ()> &fn) {
 95 |     return (is_async())
 96 |       ? Box(async_type, AsyncPtr::make(&async_type.pool, 
 97 |                                        std::async(launch::async, fn)))
 98 |       : fn();
 99 |   }
100 | 
101 |   void Env::push_async(const function<optional<Box> ()> &fn) {
102 |     const auto v(async(fn));
103 |     if (v) { push(*v); }
104 |   }
105 | 
106 |   void Env::fopen(const string &name, fstream::openmode mode) {
107 |     return push_async([this, name, mode]() {
108 |         auto f(FilePtr::make(&file_type.pool, name, mode | ios::binary));
109 |         
110 |         if (f->fail()) {
111 |           throw RuntimeError(*this, fmt("File not found: %0", {name}));
112 |         }
113 |         
114 |         return Box(rfile_type, f);
115 |       });
116 |   }
117 | }
118 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ![Logo](logo.png?raw=true)
  2 | 
  3 | ### Concatenation
  4 | Like Forth, Snabl supports manipulating the parameter stack.
  5 | 
  6 | ```
  7 | 1 2 3 swap! 
  8 | 
  9 | [1 3 2]
 10 | 
 11 | dup!
 12 | 
 13 | [1 3 2 2]
 14 | 
 15 | drop!
 16 | 
 17 | [1 3 2]
 18 | ```
 19 | 
 20 | ### Namespacing
 21 | Snabl uses sigils to simplify local reasoning. Types start with uppcercase letters, variables are prefixed with `@`, macros use `!` or `:` as suffix. Apart from literals; anything else is either a constant such as `t`, `f` and `nil`; or a function.
 22 | 
 23 | ```
 24 | {41 let: foo @foo ++}
 25 | 
 26 | [42]
 27 | ```
 28 | 
 29 | ### Typing
 30 | Snabl provides strong, static, gradual, first class types. The root type ```T``` may refer to anything except ```nil```.
 31 | 
 32 | ```
 33 | 42 I64?
 34 | 
 35 | [t]
 36 | 
 37 | I64 T?
 38 | 
 39 | [t]
 40 | 
 41 | 42 Nil?
 42 | 
 43 | [f]
 44 | 
 45 | nil T?
 46 | 
 47 | [f]
 48 | ```
 49 | 
 50 | ### Function
 51 | Snabl borrows many ideas from functional languages;  first class multi methods, pattern matching, lambdas, tail recursion and more. The following example implements a tail recursive fibonacci.
 52 | 
 53 | ```
 54 | func: my-fib<I64 I64 I64> {
 55 |   let: (n a b)
 56 | 
 57 |   @n switch:,
 58 |     0? @a
 59 |     1? @b,
 60 |     -- @b dup! @a + recall!
 61 | } 20 0 1 my-fib
 62 | 
 63 | [6765]
 64 | ```
 65 | 
 66 | The same algorithm may be implemented anonymously in a single scope using a lambda with stack manipulation.
 67 | 
 68 | ```
 69 | 20 0 1 &(
 70 |   rswap! switch:,
 71 |     0? sdrop!
 72 |     1? drop!,
 73 |     -- rswap! dup! rot! + recall!
 74 | ) call!
 75 | 
 76 | [6765]
 77 | ```
 78 | 
 79 | ### Multitasking
 80 | Snabl supports cooperative multitasking using green threads, or tasks. By default, code runs in the main task. New tasks may be started using ```task:```.
 81 | 
 82 | ```
 83 | task: (3 times:, 'pong say yield!)
 84 | 3 times:, 'ping say yield!
 85 | 
 86 | ping
 87 | pong
 88 | ping
 89 | pong
 90 | ping
 91 | pong
 92 | []
 93 | ```
 94 | 
 95 | ### Synchronicity
 96 | Snabl supports executing any calls that might hang asynchronously in a separate thread using `async:`, `await!` yields until the call returns and push any results.
 97 | 
 98 | foo.txt:
 99 | ```
100 | foo bar baz
101 | ```
102 | 
103 | ```
104 | ''foo.txt'' r fopen
105 | 
106 | [(RFile 0x125b850)]
107 | 
108 | async: str
109 | 
110 | [(Async 0x126b550)]
111 | 
112 | await!
113 | 
114 | [''foo bar baz'']
115 | ```
116 | 
117 | ### Failure
118 | Snabl offers two flavors of error handling, ```Maybe``` and ```throw!```/```catch```. Any value may be passed as ```Maybe```, stray ```nil```'s are usually caught in the next function call.
119 | 
120 | ```
121 | func: foo<T> _
122 | foo 42
123 | 
124 | [42]
125 | 
126 | nil foo
127 | 
128 | [nil]
129 | Error in row 1, col 0:
130 | 'Func not applicable: foo'
131 | 
132 | func: bar<Maybe> _
133 | 42 bar
134 | 
135 | [42]
136 | 
137 | nil bar
138 | 
139 | [nil]
140 | ```
141 | 
142 | Any value may be thrown. ```try:``` runs its argument and pushes an error or ```nil``` on the stack, ```catch``` may be used to retrieve the thrown value.
143 | 
144 | ```
145 | try: (41 throw!)
146 | catch ++
147 | 
148 | [42]
149 | ```
150 | 
151 | ### Integration
152 | Snabl integrates deeply into C++ and the STL, and is relatively trivial to embed.
153 | 
154 | Example 5
155 | ```
156 | snabl::Env env;
157 | 
158 | env.home.add_fimp(
159 |   env.sym("my-fib"),
160 |   {snabl::Box(env.int_type)},
161 |   [&env](snabl::Fimp &fimp) {
162 |     snabl::Box &v(env.peek());
163 |     snabl::I64 n(v.as_i64), a(0), b(1);
164 | 
165 |     while (n-- > 1) {
166 |       std::swap(a, b);
167 |       b += a;
168 |     }
169 | 
170 |     v.as_i64 = b;
171 |   });
172 | 
173 | env.run("10 my-fib say");
174 | ```
175 | 
176 | ### Portability
177 | Snabl requires a C++17-capable compiler and CMake to build.
178 | 
179 | ```
180 | $ git clone https://github.com/codr4life/snabl.git
181 | $ cd snabl
182 | $ mkdir build
183 | $ cd build
184 | $ cmake ..
185 | $ sudo make install
186 | $ snabl
187 | 
188 | Snabl v0.4.1
189 | 
190 | Press Return on empty line to eval.
191 | 
192 | 1 2 +
193 |  
194 | [3]
195 | ```
196 | 
197 | ### License
198 | MIT


--------------------------------------------------------------------------------
/src/snabl/form.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef SNABL_FORM_HPP
  2 | #define SNABL_FORM_HPP
  3 | 
  4 | #include "snabl/box.hpp"
  5 | #include "snabl/fmt.hpp"
  6 | #include "snabl/pos.hpp"
  7 | #include "snabl/ptrs.hpp"
  8 | #include "snabl/std.hpp"
  9 | #include "snabl/sym.hpp"
 10 | 
 11 | namespace snabl {
 12 |   struct Env;
 13 |   struct Form;
 14 | 
 15 |   using Forms = deque<Form>;
 16 | 
 17 |   struct AFormType {
 18 |     const string id;
 19 |     AFormType(string_view id);
 20 |     AFormType(const AFormType &) = delete;
 21 |   };
 22 | 
 23 |   template <typename ImpT>
 24 |   struct FormType: AFormType {
 25 |     FormType(string_view id);
 26 |   };
 27 | 
 28 |   template <typename ImpT>
 29 |   FormType<ImpT>::FormType(string_view id): AFormType(id) { }
 30 |   
 31 |   struct FormImp {
 32 |     virtual ~FormImp();
 33 |     virtual FormImp *clone() const=0;
 34 |     virtual void dump(ostream &out) const=0;
 35 | 
 36 |     virtual void compile(Forms::const_iterator &in,
 37 |                          Forms::const_iterator end,
 38 |                          Env &env) const=0;
 39 |   };
 40 |   
 41 |   struct Form {
 42 |     const AFormType &type;
 43 |     const Pos pos;
 44 |     const unique_ptr<FormImp> imp;
 45 |     
 46 |     template <typename ImpT, typename... ArgsT>
 47 |     Form(const FormType<ImpT> &type, Pos pos, ArgsT &&... args);
 48 | 
 49 |     Form(const Form &source);
 50 |     
 51 |     virtual ~Form() { }
 52 |     template <typename ImpT>
 53 |     ImpT &as() const;
 54 |   };
 55 |   
 56 |   template <typename ImpT, typename... ArgsT>
 57 |   Form::Form(const FormType<ImpT> &type, Pos pos, ArgsT &&... args):
 58 |     type(type), pos(pos), imp(new ImpT(forward<ArgsT>(args)...)) { }
 59 | 
 60 |   template <typename ImpT>
 61 |   ImpT &Form::as() const {
 62 |     return *dynamic_cast<ImpT *>(imp.get());
 63 |   }
 64 | 
 65 |   namespace forms {
 66 |     struct Body: FormImp {     
 67 |       const Forms body;
 68 |       Body(Forms::const_iterator begin, Forms::const_iterator end):
 69 |         body(begin, end) { }
 70 |       void dump(ostream &out) const override;
 71 |     };
 72 | 
 73 |     struct Fimp: FormImp {
 74 |       using Ids = vector<Sym>;
 75 |         
 76 |       static const FormType<Fimp> type;
 77 |       const Sym id;
 78 |       Ids type_ids;
 79 |       
 80 |       Fimp(Sym id, Forms::const_iterator begin, Forms::const_iterator end);
 81 |       Fimp(Sym id, const Ids &type_ids);
 82 |       FormImp *clone() const override;
 83 |       void dump(ostream &out) const override;
 84 | 
 85 |       void compile(Forms::const_iterator &in,
 86 |                    Forms::const_iterator end,
 87 |                    Env &env) const override;      
 88 |     };
 89 |     
 90 |     struct Id: FormImp {
 91 |       static const FormType<Id> type;
 92 |       const Sym id;
 93 |       
 94 |       Id(Sym id);
 95 |       FormImp *clone() const override;
 96 |       void dump(ostream &out) const override;
 97 | 
 98 |       void compile(Forms::const_iterator &in,
 99 |                    Forms::const_iterator end,
100 |                    Env &env) const override;
101 |     };
102 | 
103 |     struct Lit: FormImp {      
104 |       static const FormType<Lit> type;
105 |       const Box val;
106 | 
107 |       Lit(const Box &val);
108 |       FormImp *clone() const override;
109 |       void dump(ostream &out) const override;
110 | 
111 |       void compile(Forms::const_iterator &in,
112 |                    Forms::const_iterator end,
113 |                    Env &env) const override;
114 |     };
115 | 
116 |     struct Query: FormImp {      
117 |       static const FormType<Query> type;
118 |       const Form form;
119 |       
120 |       Query(const Form &form);
121 |       FormImp *clone() const override;
122 |       void dump(ostream &out) const override;
123 | 
124 |       void compile(Forms::const_iterator &in,
125 |                    Forms::const_iterator end,
126 |                    Env &env) const override;
127 |     };
128 | 
129 |     struct Ref: FormImp {      
130 |       static const FormType<Ref> type;
131 |       const Form form;
132 |       
133 |       Ref(const Form &form);
134 |       FormImp *clone() const override;
135 |       void dump(ostream &out) const override;
136 | 
137 |       void compile(Forms::const_iterator &in,
138 |                    Forms::const_iterator end,
139 |                    Env &env) const override;
140 |     };
141 | 
142 |     struct Rest: Body {      
143 |       static const FormType<Rest> type;
144 | 
145 |       Rest(Forms::const_iterator begin, Forms::const_iterator end):
146 |         Body(begin, end) { }
147 |       
148 |       FormImp *clone() const override;
149 |       void dump(ostream &out) const override;
150 | 
151 |       void compile(Forms::const_iterator &in,
152 |                    Forms::const_iterator end,
153 |                    Env &env) const override;
154 |     };
155 | 
156 |     struct Scope: Body {     
157 |       static const FormType<Scope> type;
158 | 
159 |       Scope(Forms::const_iterator begin, Forms::const_iterator end):
160 |         Body(begin, end) { }
161 |       
162 |       FormImp *clone() const override;
163 |       void dump(ostream &out) const override;
164 | 
165 |       void compile(Forms::const_iterator &in,
166 |                    Forms::const_iterator end,
167 |                    Env &env) const override;
168 |     };
169 | 
170 |     struct Sexpr: Body {     
171 |       static const FormType<Sexpr> type;
172 | 
173 |       Sexpr(Forms::const_iterator begin, Forms::const_iterator end):
174 |         Body(begin, end) { }
175 |       
176 |       FormImp *clone() const override;
177 |       void dump(ostream &out) const override;
178 | 
179 |       void compile(Forms::const_iterator &in,
180 |                    Forms::const_iterator end,
181 |                    Env &env) const override;
182 |     };
183 | 
184 |     struct Split: Body {     
185 |       static const FormType<Split> type;
186 |       I64 offs=0;
187 |       
188 |       Split(Forms::const_iterator begin, Forms::const_iterator end):
189 |         Body(begin, end) { }
190 |       
191 |       FormImp *clone() const override;
192 |       void dump(ostream &out) const override;
193 | 
194 |       void compile(Forms::const_iterator &in,
195 |                    Forms::const_iterator end,
196 |                    Env &env) const override;
197 |     };
198 | 
199 |     struct Stack: Body {     
200 |       static const FormType<Stack> type;
201 | 
202 |       Stack(Forms::const_iterator begin, Forms::const_iterator end):
203 |         Body(begin, end) { }
204 |       
205 |       FormImp *clone() const override;
206 |       void dump(ostream &out) const override;
207 | 
208 |       void compile(Forms::const_iterator &in,
209 |                    Forms::const_iterator end,
210 |                    Env &env) const override;
211 |     };
212 |   }
213 | }
214 | 
215 | #endif
216 | 


--------------------------------------------------------------------------------
/src/snabl/parser.cpp:
--------------------------------------------------------------------------------
  1 | #include "snabl/env.hpp"
  2 | #include "snabl/error.hpp"
  3 | #include "snabl/parser.hpp"
  4 | #include "snabl/types.hpp"
  5 | 
  6 | namespace snabl {
  7 |   const Pos Parser::home(1, 0);
  8 |   
  9 |   void Parser::parse(istream &in, Forms &out) {
 10 |     parse(in, home, 0, out);
 11 |   }
 12 | 
 13 |   bool Parser::parse(istream &in, Pos start_pos, char end, Forms &out) {
 14 |     while (!in.eof()) {
 15 |       if (parse_form(in, end, out)) { return true; }
 16 |     }
 17 | 
 18 |     return false;
 19 |   }
 20 |   
 21 |   bool Parser::parse_form(istream &in, char end, Forms &out) {
 22 |     char c;
 23 |     if (!in.get(c)) { return false; }
 24 |     
 25 |     if (c == end) {
 26 |       pos.col++;
 27 |       return true;
 28 |     }
 29 |       
 30 |     switch(c) {
 31 |     case ' ':
 32 |     case '\t':
 33 |       pos.col++;
 34 |       break;  
 35 |     case '\n':
 36 |       pos.row++;
 37 |       pos.col = home.col;
 38 |       break;
 39 |     case ',':
 40 |       pos.col++;
 41 |       return parse_body<forms::Rest>(in, end, out);
 42 |     case '|':
 43 |       pos.col++;
 44 |       return parse_body<forms::Split>(in, end, out);
 45 |     case '?': {
 46 |       if (out.empty()) { throw CompileError(pos, "Nothing to query"); }
 47 |       auto form(out.back());
 48 |       out.pop_back();
 49 |       out.emplace_back(forms::Query::type, pos, form);
 50 |       pos.col++;
 51 |       break;
 52 |     }
 53 |     case '&': {
 54 |       auto start(pos);
 55 |       pos.col++;       
 56 |       parse_form(in, end, out);
 57 |       if (out.empty()) { throw CompileError(start, "Nothing to ref"); }
 58 |       auto form(out.back());
 59 |       out.pop_back();
 60 |       out.emplace_back(forms::Ref::type, start, form);
 61 |       break;
 62 |     }
 63 |     case '(':
 64 |       pos.col++;
 65 |       parse_sexpr(in, out);
 66 |       break;
 67 |     case '{':
 68 |       pos.col++;
 69 |       parse_scope(in, out);
 70 |       break;
 71 |     case '[':
 72 |       pos.col++;
 73 |       parse_stack(in, out);
 74 |       break;
 75 |     case '~':
 76 |       pos.col++;
 77 |       parse_special_char(in, out);
 78 |       break;
 79 |     case '#':
 80 |       pos.col++;
 81 |       parse_char(in, out);
 82 |       break;
 83 |     case '\'': {
 84 |       char nc(0);
 85 |         
 86 |       if (in.get(nc) && nc == '\'') {
 87 |         pos.col += 2;
 88 |         parse_str(in,out);
 89 |       } else {
 90 |         in.clear();
 91 |         if (nc) { in.putback(nc); }
 92 |         in.putback(c);
 93 |         parse_id(in, out);
 94 |       }
 95 | 
 96 |       break;
 97 |     }
 98 |     default:
 99 |       bool is_num = isdigit(c);
100 | 
101 |       if (c == '-') {
102 |         char nc;
103 |           
104 |         if (in.get(nc)) {
105 |           in.clear();
106 |           in.putback(nc);
107 |           is_num |= isdigit(nc);
108 |         }
109 |       }
110 |         
111 |       if (is_num) {
112 |         in.clear();
113 |         in.putback(c);
114 |         parse_num(in, out);
115 |       } else if (isgraph(c)) {
116 |         in.clear();
117 |         in.putback(c);
118 |         parse_id(in, out);
119 |       } else {
120 |         throw Error("Invalid input");
121 |       }
122 |     }
123 |   
124 |     return false;
125 |   }
126 |   
127 |   void Parser::parse_id(istream &in, Forms &out) {
128 |     const auto start_pos(pos);
129 |     stringstream buf;
130 |     char c, pc(0);
131 |     bool pc_sep;
132 |     
133 |     while (in.get(c)) {
134 |       bool c_sep(env.separators.find(c) != env.separators.end());
135 |       
136 |       if (c != ' ' && c != '\n' && (!pc || (!c_sep && !pc_sep) || c == pc)) {
137 |         buf << c;
138 |         pos.col++;
139 |       } else {
140 |         break;
141 |       }
142 | 
143 |       if (c == '.' && pc == '.') {
144 |         c = 0;
145 |         break;
146 |       }
147 | 
148 |       pc = c;
149 |       pc_sep = c_sep;      
150 |       c = 0;
151 |     }
152 | 
153 |     const auto id(buf.str());
154 |     
155 |     if (id.front() == '\'') {
156 |       out.emplace_back(forms::Lit::type,
157 |                        start_pos,
158 |                        Box(env.sym_type, env.sym(id.substr(1))));
159 |     } else if (c == '<') {
160 |       parse_fimp(start_pos, env.sym(buf.str()), in, out);
161 |       c = 0;
162 |     } else {
163 |       out.emplace_back(forms::Id::type, start_pos, env.sym(id));
164 |     }
165 | 
166 |     if (c) {
167 |       in.clear();
168 |       in.putback(c);
169 |     }
170 |   }
171 | 
172 |   void Parser::parse_scope(istream &in, Forms &out) {
173 |     const auto start_pos(pos);
174 | 
175 |     if (!parse_body<forms::Scope>(in, '}', out)) {
176 |       throw SyntaxError(start_pos, "Open scope");
177 |     }
178 |   }
179 | 
180 |   void Parser::parse_num(istream &in, Forms &out) {
181 |     const auto start_pos(pos);
182 |     stringstream buf;
183 |     bool is_float(false);
184 |     char c;
185 |     
186 |     while (in.get(c)) {
187 |       if (c == '.') {
188 |         char nc;
189 |         
190 |         if (in.get(nc) && nc == '.') {
191 |           in.clear();
192 |           in.putback('.');
193 |           in.putback('.');
194 |           break;
195 |         }
196 | 
197 |         is_float = true;
198 |         buf << '.';
199 |         pos.col++;
200 |       } else if (isdigit(c) || c == '-') {
201 |         buf << c;
202 |         pos.col++;
203 |       } else {
204 |         in.clear();
205 |         in.putback(c);
206 |         break;
207 |       }
208 |     }
209 |    
210 |     out.emplace_back(forms::Lit::type,
211 |                      start_pos,
212 |                      is_float
213 |                      ? Box(env.float_type, stold(buf.str()))
214 |                      : Box(env.i64_type, I64(stoll(buf.str()))));
215 |   }
216 | 
217 |   void Parser::parse_sexpr(istream &in, Forms &out) {
218 |     const auto start_pos(pos);
219 | 
220 |     if (!parse_body<forms::Sexpr>(in, ')', out)) {
221 |       throw SyntaxError(start_pos, "Open sexpr");
222 |     }
223 |   }
224 | 
225 |   void Parser::parse_stack(istream &in, Forms &out) {
226 |     const auto start_pos(pos);
227 | 
228 |     if (!parse_body<forms::Stack>(in, ']', out)) {
229 |       throw SyntaxError(start_pos, "Open stack");
230 |     }
231 |   }
232 |   
233 |   void Parser::parse_special_char(istream &in, Forms &out) {
234 |     auto p(pos);
235 |     p.col--;
236 | 
237 |     char c(0);
238 |     if (!in.get(c)) { throw SyntaxError(p, "Missing special char"); }
239 |     auto sc(env.find_special_char(c));
240 |     if (!sc) { throw SyntaxError(p, fmt("Unknown special char: %0", {c})); }
241 |     out.emplace_back(forms::Lit::type, p, Box(env.char_type, *sc));
242 |   }
243 | 
244 |   void Parser::parse_char(istream &in, Forms &out) {
245 |     auto p(pos);
246 |     p.col--;
247 | 
248 |     char c(0);
249 |     if (!in.get(c)) { throw SyntaxError(p, "Missing char"); }
250 |     out.emplace_back(forms::Lit::type, p, Box(env.char_type, Char(c)));
251 |   }
252 | 
253 |   void Parser::parse_str(istream &in, Forms &out) {
254 |     auto p(pos);
255 |     p.col--;
256 |     stringstream s;
257 |     char c(0);
258 |     
259 |     while (in.get(c)) {
260 |       if (c == '\'') {
261 |         char nc(0);
262 |         
263 |         if (in.get(nc) && nc == '\'') {
264 |           pos.col++;
265 |           break;
266 |         }
267 |         else {
268 |           s << c;
269 |           
270 |           if (nc) {
271 |             pos.col++;
272 |             s << nc;
273 |           }
274 |         }
275 | 
276 |         pos.col++;
277 |       } else {
278 |         s << c;
279 |       }
280 | 
281 |       pos.col++;
282 |       c = 0;
283 |     }
284 | 
285 |     if (!c) { throw SyntaxError(p, "Open string"); }
286 |     
287 |     out.emplace_back(forms::Lit::type, p,
288 |                      Box(env.str_type, StrPtr::make(&env.str_type.pool, s.str())));
289 |   }
290 | 
291 |   void Parser::parse_fimp(Pos pos, Sym id, istream &in, Forms &out) {
292 |     Forms body;
293 |     if (!parse(in, pos, '>', body)) { throw SyntaxError(pos, "Open fimp"); }
294 |     out.emplace_back(forms::Fimp::type, pos, id, body.cbegin(), body.cend());
295 |   }
296 | 
297 | }
298 | 


--------------------------------------------------------------------------------
/src/snabl/op.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef SNABL_OP_HPP
  2 | #define SNABL_OP_HPP
  3 | 
  4 | #include "snabl/box.hpp"
  5 | #include "snabl/pos.hpp"
  6 | #include "snabl/ptrs.hpp"
  7 | #include "snabl/scope.hpp"
  8 | #include "snabl/state.hpp"
  9 | #include "snabl/std.hpp"
 10 | #include "snabl/sym.hpp"
 11 | #include "snabl/target.hpp"
 12 | #include "snabl/type.hpp"
 13 | #include "snabl/types.hpp"
 14 | 
 15 | namespace snabl {    
 16 |   struct Fimp;
 17 |   struct Func;
 18 |   
 19 |   struct Op {
 20 |     const Sym type;
 21 |     const Pos pos;
 22 |     PC next;
 23 | 
 24 |     Op(const Op &)=delete;
 25 |     const Op &operator =(const Op &)=delete;
 26 | 
 27 |     Op(Env &env, const string &type, Pos pos);
 28 |     virtual ~Op() { }
 29 |     virtual void run(Env &env)=0;
 30 |     virtual void dump_args(ostream &out) const {}
 31 |     void dump(ostream &out) const;
 32 |   };
 33 | 
 34 |   using Ops = deque<unique_ptr<Op>>;
 35 | 
 36 |   namespace ops {    
 37 |     struct Async: Op {
 38 |       static const string type;
 39 |       I64 delta;
 40 |       Async(Env &env, Pos pos, I64 delta);
 41 |       void run(Env &env) override;
 42 |     };
 43 | 
 44 |     struct Await: Op {
 45 |       static const string type;
 46 |       Await(Env &env, Pos pos);
 47 |       void run(Env &env) override;
 48 |     };
 49 |     
 50 |     struct Bench: Op {
 51 |       static const string type;
 52 |       I64 end_pc;
 53 |       Bench(Env &env, Pos pos);
 54 |       void run(Env &env) override;
 55 |     };
 56 | 
 57 |     struct Call: Op {       
 58 |       static const string type;
 59 |       Call(Env &env, Pos pos);
 60 |       void run(Env &env) override;
 61 |     };
 62 | 
 63 |     struct DDrop: Op {
 64 |       static const string type;
 65 |       DDrop(Env &env, Pos pos);
 66 |       void run(Env &env) override;
 67 |     };
 68 | 
 69 |     struct Drop: Op {
 70 |       static const string type;
 71 |       Drop(Env &env, Pos pos);
 72 |       void run(Env &env) override;
 73 |     };
 74 | 
 75 |     struct Dup: Op {
 76 |       static const string type;
 77 |       Dup(Env &env, Pos pos);
 78 |       void run(Env &env) override;
 79 |     };
 80 | 
 81 |     struct Else: Op {
 82 |       static const string type;
 83 |       I64 skip_pc;
 84 |       Else(Env &env, Pos pos, I64 skip_pc=-1);
 85 |       void run(Env &env) override;
 86 |     };
 87 |     
 88 |     struct Eqval: Op {
 89 |       static const string type;
 90 |       const optional<const Box> rhs;
 91 |       Eqval(Env &env, Pos pos, const optional<const Box> rhs=nullopt);
 92 |       void run(Env &env) override;
 93 |       void dump_args(ostream &out) const override;
 94 |     };
 95 | 
 96 |     struct Fimp: Op {
 97 |       static const string type;
 98 |       snabl::Fimp &fimp;
 99 |       const bool is_scope;
100 |       Fimp(Env &env, Pos pos, snabl::Fimp &fimp, bool is_scope);
101 |       void run(Env &env) override;
102 |       void dump_args(ostream &out) const override;
103 |     };
104 | 
105 |     struct Funcall: Op {
106 |       static const string type;
107 |       Func &func;
108 |       snabl::Fimp *const fimp, *prev_fimp;
109 |       Funcall(Env &env, Pos pos, Func &func);
110 |       Funcall(Env &env, Pos pos, snabl::Fimp &fimp);
111 |       void run(Env &env) override;
112 |       void dump_args(ostream &out) const override;
113 |   };
114 |     
115 |     struct Get: Op {
116 |       static const string type;
117 |       const Sym id;
118 |       Get(Env &env, Pos pos, Sym id);
119 |       void run(Env &env) override;
120 |     };
121 | 
122 |     struct If: Op {
123 |       static const string type;
124 |       I64 skip_pc;
125 |       If(Env &env, Pos pos, I64 skip_pc=-1);
126 |       void run(Env &env) override;
127 |     };
128 | 
129 |     struct Is: Op {
130 |       static const string type;
131 |       const AType &rhs;
132 |       Is(Env &env, Pos pos, const AType &rhs);
133 |       void run(Env &env) override;
134 |       void dump_args(ostream &out) const override;
135 |     };
136 | 
137 |     struct Jump: Op {
138 |       static const string type;
139 |       I64 end_pc;
140 |       Jump(Env &env, Pos pos, I64 end_pc=-1);
141 |       void run(Env &env) override;
142 |     };
143 | 
144 |     struct JumpIf: Op {
145 |       static const string type;
146 |       function<bool ()> cond;
147 |       I64 end_pc;
148 |       JumpIf(Env &env, Pos pos, function<bool ()> &&cond);
149 |       void run(Env &env) override;
150 |     };
151 | 
152 |     struct Lambda: Op {
153 |       static const string type;
154 |       const bool is_scope;
155 |       PC start_pc;
156 |       I64 end_pc;
157 |       Lambda(Env &env, Pos pos, bool is_scope);
158 |       void run(Env &env) override;
159 |     };
160 | 
161 |     struct Let: Op {
162 |       static const string type;
163 |       const Sym id;
164 |       Let(Env &env, Pos pos, Sym id);
165 |       void run(Env &env) override;
166 |       void dump_args(ostream &out) const override;
167 |     };
168 | 
169 |     struct Nop: Op {
170 |       static const string type;
171 |       Nop(Env &env, Pos pos);
172 |       void run(Env &env) override;
173 |     };
174 | 
175 |     struct Push: Op {
176 |       static const string type;     
177 |       const Box val;
178 |       Push(Env &env, Pos pos, const Box &val);
179 |       
180 |       template <typename ValT, typename... ArgsT>
181 |       Push(Env &env, Pos pos, Type<ValT> &type, ArgsT &&...args):
182 |         Op(env, Push::type, pos), val(type, forward<ArgsT>(args)...) { }
183 | 
184 |       void run(Env &env) override;
185 |       void dump_args(ostream &out) const override;
186 |     };
187 | 
188 |     struct Recall: Op {
189 |       static const string type;
190 |       Recall(Env &env, Pos pos);
191 |       void run(Env &env) override;
192 |     };
193 | 
194 |     struct Return: Op {
195 |       static const string type;
196 |       Return(Env &env, Pos pos);
197 |       void run(Env &env) override;
198 |     };
199 | 
200 |     struct Rot: Op {
201 |       static const string type;
202 |       Rot(Env &env, Pos pos);
203 |       void run(Env &env) override;
204 |     };
205 | 
206 |     struct RSwap: Op {
207 |       static const string type;
208 |       RSwap(Env &env, Pos pos);
209 |       void run(Env &env) override;
210 |     };
211 | 
212 |     struct Scope: Op {
213 |       static const string type;
214 |       Scope(Env &env, Pos pos);
215 |       void run(Env &env) override;
216 |     };
217 | 
218 |     struct ScopeEnd: Op {
219 |       static const string type;
220 |       ScopeEnd(Env &env, Pos pos);
221 |       void run(Env &env) override;
222 |     };
223 | 
224 |     struct SDrop: Op {
225 |       static const string type;
226 |       SDrop(Env &env, Pos pos);
227 |       void run(Env &env) override;
228 |     };
229 | 
230 |     struct Split: Op {
231 |       static const string type;
232 |       const I64 offs;
233 |       Split(Env &env, Pos pos, I64 offs=0);
234 |       void run(Env &env) override;
235 |     };
236 | 
237 |     struct SplitEnd: Op {
238 |       static const string type;
239 |       SplitEnd(Env &env, Pos pos);
240 |       void run(Env &env) override;
241 |     };
242 | 
243 |     struct Stack: Op {
244 |       static const string type;
245 |       const bool end_split;
246 |       Stack(Env &env, Pos pos, bool end_split);
247 |       void run(Env &env) override;
248 |     };
249 | 
250 |     struct Stop: Op {
251 |       static const string type;
252 |       Stop(Env &env, Pos pos);
253 |       void run(Env &env) override;
254 |     };
255 | 
256 |     struct Swap: Op {
257 |       static const string type;
258 |       Swap(Env &env, Pos pos);
259 |       void run(Env &env) override;
260 |     };
261 | 
262 |     struct Task: Op {
263 |       static const string type;
264 |       PC start_pc;
265 |       I64 end_pc;
266 |       Task(Env &env, Pos pos);
267 |       void run(Env &env) override;
268 |     };
269 | 
270 |     struct Throw: Op {
271 |       static const string type;
272 |       Throw(Env &env, Pos pos);
273 |       void run(Env &env) override;
274 |     };
275 |     
276 |     struct Times: Op {
277 |       static const string type;
278 |       const I64 i_reg;
279 |       Times(Env &env, Pos pos, I64 i_reg);
280 |       void run(Env &env) override;
281 |     };
282 | 
283 |     struct Try: Op {
284 |       static const string type;
285 |       I64 end_pc;
286 |       Try(Env &env, Pos pos);
287 |       void run(Env &env) override;
288 |     };
289 | 
290 |     struct TryEnd: Op {
291 |       static const string type;
292 |       TryEnd(Env &env, Pos pos);
293 |       void run(Env &env) override;
294 |     };
295 | 
296 |     struct Yield: Op {
297 |       static const string type;
298 |       Yield(Env &env, Pos pos);
299 |       void run(Env &env) override;
300 |     };
301 |   } 
302 | }
303 | 
304 | #endif
305 | 


--------------------------------------------------------------------------------
/src/snabl/form.cpp:
--------------------------------------------------------------------------------
  1 | #include "snabl/env.hpp"
  2 | #include "snabl/form.hpp"
  3 | 
  4 | namespace snabl {
  5 |   AFormType::AFormType(string_view id): id(id) { }
  6 | 
  7 |   FormImp::~FormImp() { }
  8 | 
  9 |   Form::Form(const Form &source):
 10 |     type(source.type),
 11 |     pos(source.pos),
 12 |     imp(source.imp->clone()) { }
 13 | 
 14 |   namespace forms {
 15 |     const FormType<Fimp> Fimp::type("fimp");
 16 |     const FormType<Id> Id::type("id");
 17 |     const FormType<Lit> Lit::type("lit");
 18 |     const FormType<Query> Query::type("query");
 19 |     const FormType<Ref> Ref::type("ref");
 20 |     const FormType<Rest> Rest::type("rest");
 21 |     const FormType<Scope> Scope::type("scope");
 22 |     const FormType<Sexpr> Sexpr::type("sexpr");
 23 |     const FormType<Split> Split::type("split");
 24 |     const FormType<Stack> Stack::type("stack");
 25 | 
 26 |     void Body::dump(ostream &out) const {
 27 |       char sep(0);
 28 |       
 29 |       for (auto &f: body) {
 30 |         if (sep) { out << sep; }
 31 |         f.imp->dump(out);
 32 |         sep = ' ';
 33 |       }
 34 |     }   
 35 | 
 36 |     Fimp::Fimp(Sym id,
 37 |                Forms::const_iterator begin,
 38 |                Forms::const_iterator end): id(id) {
 39 |       transform(begin, end, back_inserter(type_ids),
 40 |                 [](const Form &f) -> Sym { return f.as<Id>().id; });
 41 |     }
 42 | 
 43 |     Fimp::Fimp(Sym id, const Ids &type_ids): id(id), type_ids(type_ids) { }
 44 | 
 45 |     FormImp *Fimp::clone() const { return new Fimp(id, type_ids); }
 46 | 
 47 |     void Fimp::dump(ostream &out) const {
 48 |       out << id << '<';
 49 |       char sep(0);
 50 |       
 51 |       for (auto &id: type_ids) {
 52 |         if (sep) { out << sep; }
 53 |         out << id.name();
 54 |         sep = ' ';
 55 |       }
 56 |       
 57 |       out << '>';
 58 |     }
 59 |     
 60 |     void Fimp::compile(Forms::const_iterator &in,
 61 |                        Forms::const_iterator end,
 62 |                        Env &env) const {
 63 |       auto &lib(env.lib());
 64 |       auto pos(in->pos);
 65 |       auto &form((in++)->as<Fimp>());
 66 |       snabl::Stack args;
 67 |         
 68 |       transform(form.type_ids.begin(), form.type_ids.end(), back_inserter(args),
 69 |                 [&env, &lib, pos](Sym id) {
 70 |                   auto &idn(id.name());
 71 | 
 72 |                   auto t((idn.size() == 1 && idn[0] == '_')
 73 |                          ? &env.no_type
 74 |                          : lib.get_type(id));
 75 |                   
 76 |                   if (!t) {
 77 |                     throw CompileError(pos, "Unknown type: " + id.name());
 78 |                   }
 79 |                   
 80 |                   return Box(*t);
 81 |                 });
 82 |       
 83 |       auto fn(lib.get_func(id));
 84 |       if (!fn) { throw CompileError(pos, fmt("Unknown func: '%0'", {id.name()})); }
 85 |       
 86 |       if (I64(args.size()) != fn->nargs) {
 87 |         throw CompileError(pos, fmt("Wrong number of args: %0", {fn->id}));
 88 |       }
 89 |       
 90 |       auto fip(fn->get_best_fimp(args.begin(), args.end()));
 91 |       if (!fip) { throw CompileError(pos, fmt("Unknown fimp: %0", {fn->id})); }
 92 | 
 93 |       auto &fi(*fip);               
 94 |       if (!fi.imp) { fi.compile(pos); }
 95 |       env.emit<ops::Funcall>(pos, fi);
 96 |     }
 97 | 
 98 |     Id::Id(Sym id): id(id) { }
 99 | 
100 |     FormImp *Id::clone() const { return new Id(id); }
101 | 
102 |     void Id::dump(ostream &out) const { out << id.name(); }
103 |     
104 |     void Id::compile(Forms::const_iterator &in,
105 |                      Forms::const_iterator end,
106 |                      Env &env) const {
107 |       auto &form(*in);
108 |       auto id(form.as<Id>().id);
109 |       auto &idn(id.name());
110 |       auto found_lib(idn.rfind('.'));
111 |       Lib *lib(&env.lib());
112 |       
113 |       if (found_lib != string::npos && found_lib > 0 && idn[found_lib-1] != '.') {
114 |         const auto lib_id(env.sym(idn.substr(0, found_lib)));
115 |         lib = env.get_lib(lib_id);
116 |         if (!lib) { throw CompileError(form.pos, fmt("Unknown lib: %0", {lib_id})); }
117 |         id = env.sym(idn.substr(found_lib+1));
118 |       }
119 |       
120 |       if (idn.front() == '@') {
121 |         in++;
122 |         env.emit<ops::Get>(form.pos, env.sym(idn.substr(1)));
123 |       } else if (isupper(idn.front())) {
124 |         in++;
125 |         auto t(lib->get_type(id));
126 |         if (!t) { throw CompileError(form.pos, fmt("Unknown type: %0", {id})); }
127 |         env.emit<ops::Push>(form.pos, env.meta_type, t);
128 |       } else {
129 |         auto m(lib->get_macro(id));
130 |         
131 |         if (m) {
132 |           m->call(in, end, env);
133 |         } else {
134 |           in++;
135 |           auto fn(lib->get_func(id));
136 | 
137 |           if (!fn) {
138 |             throw CompileError(form.pos, fmt("Unknown id: '%0'", {id}));
139 |           }
140 |           
141 |           env.emit<ops::Funcall>(form.pos, *fn);
142 |         }
143 |       }
144 |     }
145 |     
146 |     Lit::Lit(const Box &val): val(val) { }
147 | 
148 |     FormImp *Lit::clone() const { return new Lit(val); }
149 | 
150 |     void Lit::dump(ostream &out) const { val.dump(out); }
151 | 
152 |     void Lit::compile(Forms::const_iterator &in,
153 |                       Forms::const_iterator end,
154 |                       Env &env) const {
155 |       auto &form(*in++);
156 |       env.emit<ops::Push>(form.pos, form.as<Lit>().val);
157 |     }
158 | 
159 |     Query::Query(const Form &form): form(form) {}
160 |     
161 |     FormImp *Query::clone() const {
162 |       return new Query(form);
163 |     }
164 | 
165 |     void Query::dump(ostream &out) const {
166 |       form.imp->dump(out);
167 |       out << '?';
168 |     }   
169 | 
170 |     void Query::compile(Forms::const_iterator &in,
171 |                         Forms::const_iterator end,
172 |                         Env &env) const {
173 |       auto &form(*in);
174 |       auto &qf(form.as<forms::Query>().form);
175 |       
176 |       if (&qf.type == &forms::Lit::type) {
177 |         env.emit<ops::Eqval>(qf.pos, qf.as<Lit>().val);
178 |       } else if (&qf.type == &forms::Id::type) {
179 |         if (isupper(qf.as<forms::Id>().id.name().front())) {
180 |           auto &id(qf.as<forms::Id>().id);
181 |           auto t(env.lib().get_type(id));
182 |           if (!t) { throw CompileError(qf.pos, fmt("Unknown type: %0", {id})); }
183 |           env.emit<ops::Is>(qf.pos, *t);
184 |         } else {
185 |           env.compile(qf);
186 |           env.emit<ops::Eqval>(qf.pos);
187 |         }
188 |       } else {
189 |         throw CompileError(qf.pos, fmt("Invalid query: %0", {qf.type.id}));
190 |       }
191 | 
192 |       in++;
193 |     }
194 | 
195 |     Ref::Ref(const Form &form): form(form) {}
196 |     
197 |     FormImp *Ref::clone() const {
198 |       return new Ref(form);
199 |     }
200 | 
201 |     void Ref::dump(ostream &out) const {
202 |       out << '&';
203 |       form.imp->dump(out);
204 |     }   
205 | 
206 |     void Ref::compile(Forms::const_iterator &in,
207 |                       Forms::const_iterator end,
208 |                       Env &env) const {
209 |       auto &f(*in++);
210 |       auto &rf(f.as<forms::Ref>().form);
211 |       
212 |       if (&rf.type == &Scope::type || &rf.type == &Sexpr::type) {
213 |         const auto is_scope(&rf.type == &Scope::type);
214 |         auto &start(env.emit<ops::Lambda>(f.pos, is_scope));
215 |         if (is_scope) { env.begin_regs(); }
216 |         env.compile(rf.as<Body>().body);
217 |         if (is_scope) { env.end_regs(); }
218 |         env.emit<ops::Return>(f.pos);
219 |         start.start_pc = start.next;
220 |         start.end_pc = env.ops.size();
221 |       } else {
222 |         throw CompileError(rf.pos, fmt("Invalid ref: %0", {rf.type.id}));
223 |       }
224 |     }
225 |     
226 |     FormImp *Rest::clone() const { return new Rest(body.begin(), body.end()); }
227 | 
228 |     void Rest::dump(ostream &out) const {
229 |       out << ", ";
230 |       Body::dump(out);
231 |     }   
232 | 
233 |     void Rest::compile(Forms::const_iterator &in,
234 |                        Forms::const_iterator end,
235 |                        Env &env) const {
236 |       env.compile((in++)->as<Rest>().body);
237 |     }
238 | 
239 |     FormImp *Scope::clone() const { return new Scope(body.begin(), body.end()); }
240 | 
241 |     void Scope::dump(ostream &out) const {
242 |       out << '{';
243 |       Body::dump(out);
244 |       out << '}';
245 |     }   
246 | 
247 |     void Scope::compile(Forms::const_iterator &in,
248 |                         Forms::const_iterator end,
249 |                         Env &env) const {
250 |       auto &f(*in++);
251 |       auto &sf(f.as<Scope>());
252 |       env.emit<ops::Scope>(f.pos);
253 |       env.begin_regs();
254 |       env.compile(sf.body);
255 |       env.end_regs();
256 |       env.emit<ops::ScopeEnd>(f.pos);
257 |     }
258 | 
259 |     FormImp *Sexpr::clone() const { return new Sexpr(body.begin(), body.end()); }
260 | 
261 |     void Sexpr::dump(ostream &out) const {
262 |       out << '(';
263 |       Body::dump(out);
264 |       out << ')';
265 |     }   
266 | 
267 |     void Sexpr::compile(Forms::const_iterator &in,
268 |                         Forms::const_iterator end,
269 |                         Env &env) const {
270 |       env.compile((in++)->as<Sexpr>().body);
271 |     }
272 |     
273 |     FormImp *Split::clone() const { return new Split(body.begin(), body.end()); }
274 | 
275 |     void Split::dump(ostream &out) const {
276 |       out << '|';
277 |       Body::dump(out);
278 |     }   
279 | 
280 |     void Split::compile(Forms::const_iterator &in,
281 |                         Forms::const_iterator end,
282 |                         Env &env) const {
283 |       auto &f(*in++);
284 |       auto &sf(f.as<Split>());
285 |       env.emit<ops::Split>(f.pos, sf.offs);
286 |       env.compile(sf.body);
287 |       env.emit<ops::SplitEnd>(f.pos);
288 |     }
289 | 
290 |     FormImp *Stack::clone() const { return new Stack(body.begin(), body.end()); }
291 | 
292 |     void Stack::dump(ostream &out) const {
293 |       out << '[';
294 |       Body::dump(out);
295 |       out << ']';
296 |     } 
297 | 
298 |     void Stack::compile(Forms::const_iterator &in,
299 |                         Forms::const_iterator end,
300 |                         Env &env) const {
301 |       auto &f(*in++);
302 |       auto &b(f.as<Stack>().body);
303 | 
304 |       bool split(b.empty() ||
305 |                  &b.front().type != &forms::Id::type ||
306 |                  b.front().as<forms::Id>().id != env.sym(".."));
307 |       
308 |       if (split) { env.emit<ops::Split>(f.pos); }
309 |       env.compile(split ? b.begin() : b.begin()+1, b.end());
310 |       env.emit<ops::Stack>(f.pos, split);
311 |     }
312 |   }
313 | }
314 | 


--------------------------------------------------------------------------------
/src/snabl/env.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef SNABL_ENV_HPP
  2 | #define SNABL_ENV_HPP
  3 | 
  4 | #include "snabl/lib.hpp"
  5 | #include "snabl/libs/abc.hpp"
  6 | #include "snabl/mpool.hpp"
  7 | #include "snabl/pos.hpp"
  8 | #include "snabl/scope.hpp"
  9 | #include "snabl/stack.hpp"
 10 | #include "snabl/state.hpp"
 11 | #include "snabl/std.hpp"
 12 | #include "snabl/sym.hpp"
 13 | #include "snabl/task.hpp"
 14 | #include "snabl/types.hpp"
 15 | #include "snabl/types/async.hpp"
 16 | #include "snabl/types/bin.hpp"
 17 | #include "snabl/types/bool.hpp"
 18 | #include "snabl/types/byte.hpp"
 19 | #include "snabl/types/char.hpp"
 20 | #include "snabl/types/enum.hpp"
 21 | #include "snabl/types/error.hpp"
 22 | #include "snabl/types/file.hpp"
 23 | #include "snabl/types/float.hpp"
 24 | #include "snabl/types/i64.hpp"
 25 | #include "snabl/types/iter.hpp"
 26 | #include "snabl/types/lambda.hpp"
 27 | #include "snabl/types/meta.hpp"
 28 | #include "snabl/types/nil.hpp"
 29 | #include "snabl/types/stack.hpp"
 30 | #include "snabl/types/str.hpp"
 31 | #include "snabl/types/sym.hpp"
 32 | #include "snabl/types/time.hpp"
 33 | #include "snabl/user_error.hpp"
 34 | 
 35 | namespace snabl {
 36 |   template <typename ValT>
 37 |   struct Type;
 38 | 
 39 |   const array<int, 3> version {0, 4, 1};
 40 |   
 41 |   struct Env {
 42 |     list<SymImp> syms;
 43 |     unordered_map<string, Sym> sym_table;
 44 |     I64 type_tag;
 45 |     set<char> separators;
 46 |     MPool<Call> call_pool;
 47 |     MPool<Task> task_pool;
 48 |     MPool<Try> try_pool;
 49 |     MPool<Scope> scope_pool;
 50 |     Task main_task;
 51 |     Task *task;
 52 |     unordered_map<Sym, unique_ptr<Lib>> libs;
 53 |     Lib &home_lib, &s_lib;
 54 |     libs::Abc &abc_lib;
 55 | 
 56 |     Trait &no_type, &maybe_type, &root_type, &cmp_type, &num_type, &seq_type,
 57 |       &source_type, &sink_type;
 58 |     
 59 |     Type<AType *> &meta_type;
 60 |     Type<Nil> &nil_type;
 61 | 
 62 |     AsyncType &async_type;
 63 |     BinType &bin_type;
 64 |     BoolType &bool_type;
 65 |     ByteType &byte_type;
 66 |     CharType &char_type;
 67 |     ErrorType &error_type;
 68 |     FileType &file_type;
 69 |     FloatType &float_type;
 70 |     I64Type &i64_type;
 71 |     IterType &iter_type;
 72 |     LambdaType &lambda_type;
 73 |     FileType &rfile_type;
 74 |     StackType &stack_type;
 75 |     StrType &str_type;
 76 |     SymType &sym_type;
 77 |     TimeType &time_type;
 78 | 
 79 |     EnumType &enum_type, &io_type;
 80 | 
 81 |     Scope root_scope;
 82 | 
 83 |     map<char, Char> special_chars;
 84 |     map<Char, char> char_specials;
 85 |     vector<I64> nregs;
 86 |     Ops ops;
 87 | 
 88 |     istream *stdin;
 89 |     ostream *stdout, *stderr;
 90 |     
 91 |     Env():
 92 |       type_tag(1),
 93 |       separators {
 94 |         ' ', '\t', '\n',
 95 |         ',', '?', '&', '|',
 96 |         '<', '>', '(', ')', '{', '}', '[', ']'
 97 |       },
 98 |       main_task(*this),
 99 |       task(&main_task),
100 |       home_lib(add_lib<Lib>(sym(""))),
101 |       s_lib(add_lib<Lib>(sym("s"))),
102 |       abc_lib(add_lib<libs::Abc>()),
103 |       no_type(abc_lib.add_type<Trait>(sym("No"))),
104 |       maybe_type(abc_lib.add_type<Trait>(sym("Maybe"))),
105 |       root_type(abc_lib.add_type<Trait>(sym("T"), {&maybe_type})),
106 |       cmp_type(abc_lib.add_type<Trait>(sym("Cmp"), {&root_type})),
107 |       num_type(abc_lib.add_type<Trait>(sym("Num"), {&cmp_type})),
108 |       seq_type(abc_lib.add_type<Trait>(sym("Seq"), {&root_type})),
109 |       source_type(abc_lib.add_type<Trait>(sym("Source"), {&root_type})),
110 |       sink_type(abc_lib.add_type<Trait>(sym("Sink"), {&root_type})),
111 | 
112 |       meta_type(abc_lib.add_type<MetaType>(sym("Type"), {&root_type})),
113 |       nil_type(abc_lib.add_type<NilType>(sym("Nil"), {&maybe_type})),
114 | 
115 |       async_type(abc_lib.add_type<AsyncType>(sym("Async"), {&root_type})),
116 |       bin_type(abc_lib.add_type<BinType>(sym("Bin"),
117 |         {&seq_type, &sink_type, &source_type})),
118 |       bool_type(abc_lib.add_type<BoolType>(sym("Bool"), {&cmp_type})),
119 |       byte_type(abc_lib.add_type<ByteType>(sym("Byte"), {&num_type})),
120 |       char_type(abc_lib.add_type<CharType>(sym("Char"), {&cmp_type})),
121 |       error_type(abc_lib.add_type<ErrorType>(sym("Error"), {&root_type})),
122 |       file_type(abc_lib.add_type<FileType>(sym("File"), {&root_type})),
123 |       float_type(abc_lib.add_type<FloatType>(sym("Float"), {&num_type})),
124 |       i64_type(abc_lib.add_type<I64Type>(sym("I64"),
125 |         {&num_type, &seq_type})),
126 |       iter_type(abc_lib.add_type<IterType>(sym("Iter"),
127 |         {&seq_type, &source_type})),
128 |       lambda_type(abc_lib.add_type<LambdaType>(sym("Lambda"), {&root_type})),
129 |       rfile_type(abc_lib.add_type<FileType>(sym("RFile"), {&file_type})),
130 |       stack_type(abc_lib.add_type<StackType>(sym("Stack"),
131 |         {&seq_type, &sink_type, &source_type})),
132 |       str_type(abc_lib.add_type<StrType>(sym("Str"),
133 |         {&cmp_type, &seq_type, &sink_type, &source_type})),
134 |       sym_type(abc_lib.add_type<SymType>(sym("Sym"), {&cmp_type})),
135 |       time_type(abc_lib.add_type<TimeType>(sym("Time"), {&cmp_type})),
136 | 
137 |       enum_type(abc_lib.add_type<EnumType>(sym("Enum"), {&cmp_type})),
138 |       io_type(abc_lib.add_enum_type(sym("IO"), {sym("r"), sym("w"), sym("rw")})),
139 | 
140 |       root_scope(nullptr, {}),
141 |       stdin(&cin),
142 |       stdout(&cout),
143 |       stderr(&cerr) {
144 |         add_special_char('t', 8);
145 |         add_special_char('n', 10);
146 |         add_special_char('r', 13);
147 |         add_special_char('e', 27);
148 |         add_special_char('s', 32);
149 |         begin_regs();
150 |         task->lib = &home_lib;
151 |         task->scope = &root_scope;
152 |         abc_lib.init();
153 |       }
154 | 
155 |     template <typename LibT, typename...ArgsT>
156 |     LibT &add_lib(ArgsT &&...args) {
157 |       auto l(new LibT(*this, forward<ArgsT>(args)...));
158 |       libs.emplace(l->qid, l);
159 |       return *l;
160 |     }
161 | 
162 |     Lib *get_lib(Sym id) const {
163 |       const auto found(libs.find(id));
164 |       return (found == libs.end()) ? nullptr : found->second.get();
165 |     }
166 | 
167 |     void use(Sym lib_id, const vector<Sym> def_ids={});
168 |     
169 |     Task &start_task(PC start_pc=nullptr, Scope *scope=nullptr) {
170 |       auto t(task_pool.acquire(*this, start_pc, scope));
171 |       t->next = task;
172 |       t->prev = task->prev;
173 |       t->prev->next = t;
174 |       task->prev = t;
175 |       return *t;
176 |     }
177 | 
178 |     bool yield() {
179 |       if (task->next == task) { return false; }
180 |       task = task->next; 
181 |       return true;
182 |     }
183 | 
184 |     Env(const Env &) = delete;
185 |     const Env &operator=(const Env &) = delete;
186 | 
187 |     I64 next_type_tag() { return type_tag++; }
188 | 
189 |     void add_special_char(char in, Char out) {
190 |       special_chars.emplace(in, out);
191 |       char_specials.emplace(out, in);
192 |     }
193 | 
194 |     optional<Char> find_special_char(char in) {
195 |       auto found(special_chars.find(in));
196 |       return (found == special_chars.end()) ? nullopt : make_optional(found->second);
197 |     }
198 | 
199 |     optional<char> find_char_special(Char in) {
200 |       auto found(char_specials.find(in));
201 |       return (found == char_specials.end()) ? nullopt : make_optional(found->second);
202 |     }
203 |     
204 |     Sym sym(const string &name) {
205 |       const auto found(sym_table.find(name));
206 |       if (found != sym_table.end()) { return found->second; }
207 |       syms.emplace_back(name);
208 |       const auto imp(&syms.back());
209 |       return sym_table.emplace(name, Sym(imp)).first->second;
210 |     }
211 | 
212 |     void begin_regs() { nregs.push_back(0); }
213 |     
214 |     I64 end_regs() {
215 |       const I64 n(nregs.back());
216 |       nregs.pop_back();
217 |       return n;
218 |     }
219 | 
220 |     I64 next_reg(Pos pos) {
221 |       auto &n(nregs.back());
222 | 
223 |       if (n == Scope::MaxRegs) {
224 |         throw CompileError(pos, "No more regs, consider adding additional scopes");
225 |       }
226 | 
227 |       return n++;
228 |     }
229 |     
230 |     template <typename T>
231 |     T &get_reg(I64 idx) { return any_cast<T &>(task->scope->regs[idx]); }
232 | 
233 |     template <typename T>
234 |     const T &get_reg(I64 idx) const {
235 |       return any_cast<const T &>(task->scope->regs[idx]);
236 |     }
237 | 
238 |     void let_reg(I64 idx, any &&val) { task->scope->regs[idx] = move(val); }
239 |     void clear_reg(I64 idx) const { task->scope->regs[idx].reset(); }
240 |     
241 |     template <typename OpT, typename...ArgsT>
242 |     OpT &emit(ArgsT &&...args) {
243 |       Op *prev(ops.empty() ? nullptr : ops.back().get());
244 |       auto op(new OpT(*this, forward<ArgsT>(args)...));
245 |       ops.emplace_back(op);
246 |       if (prev) { prev->next = op; }
247 |       return *op;
248 |     }
249 | 
250 |     void compile(string_view in);
251 |     void compile(istream &in);
252 |     void compile(const Forms &forms);
253 |     void compile(const Form &form);
254 |     void compile(Forms::const_iterator begin, Forms::const_iterator end);
255 |     
256 |     void run(string_view in);
257 |     void run(istream &in);
258 |     void run();
259 | 
260 |     void load(const string &path) {
261 |       ifstream f(path);
262 |       if (f.fail()) { throw Error(fmt("File not found: %0", {path})); }
263 |       compile(f);
264 |     }
265 |     
266 |     Lib &lib() const { return *task->lib; }
267 |     PC pc() const { return task->pc; }
268 |     
269 |     void begin_scope(const vector<Var> &vars) {
270 |       task->scope = scope_pool.acquire(task->scope, vars);
271 |     }
272 | 
273 |     Scope &scope() const { return *task->scope; }
274 | 
275 |     void end_scope() {
276 |       auto prev(task->scope->prev);
277 |       scope_pool.release(task->scope);
278 |       task->scope = prev;
279 |     }
280 | 
281 |     void jump(PC pc) { task->pc = pc; }
282 | 
283 |     void jump(I64 pc) {
284 |       task->pc = (pc == I64(ops.size())) ? nullptr : ops[pc].get();
285 |     }
286 | 
287 |     Pos pos() const { return task->pc ? task->pc->pos : Pos(-1, -1); }
288 |     
289 |     template <typename TargetT>
290 |     void begin_call(TargetT &target, Pos pos, PC return_pc=nullptr) {
291 |       task->call = call_pool.acquire(*this, target, pos, return_pc);
292 |     }
293 | 
294 |     Call *call() const { return task->call; }
295 | 
296 |     void end_call() {
297 |       auto prev(task->call->prev);
298 |       call_pool.release(task->call);
299 |       task->call = prev;
300 |     }
301 |     
302 |     void recall(Pos pos) {
303 |       if (!task->call) { throw RuntimeError(*this, "Nothing to recall"); }
304 |       const auto &c(*task->call);
305 |       const auto &t(c.get_target());
306 |       const auto &s(c.state);
307 |       s.restore_env(*this);
308 |       s.restore_try(*this);
309 |       if (t.vars) { task->scope->vars.clear(); }
310 |       jump(t.start_pc);
311 |     }
312 | 
313 |     void _return(Pos pos) {
314 |       if (!task->call) { throw RuntimeError(*this, "Nothing to return from"); }
315 |       auto &c(*task->call);
316 |       auto &t(c.get_target());
317 |       if (t.vars) { end_scope(); }
318 |       task->pc = c.return_pc;
319 |       auto fi(dynamic_cast<const Fimp *>(&t));
320 |       if (fi && !fi->imp) { end_split(); }
321 |       end_call();
322 |     }
323 |     
324 |     void begin_try(ops::Try &op) { task->_try = try_pool.acquire(*this, op); }
325 |     Try *_try() { return task->_try; }
326 | 
327 |     void end_try() {
328 |       auto prev(task->_try->prev);
329 |       try_pool.release(task->_try);
330 |       task->_try = prev;
331 |     }
332 | 
333 |     void push(const Box &val) { task->stack.push_back(val); }
334 | 
335 |     template <typename ValT, typename...ArgsT>
336 |     void push(Type<ValT> &type, ArgsT &&...args) {
337 |       task->stack.emplace_back(type, ValT(forward<ArgsT>(args)...));
338 |     }
339 | 
340 |     Box &peek() {
341 |       if (I64(task->stack.size()) <= task->stack_offs) {
342 |         throw Error("Nothing to peek");
343 |       }
344 |       
345 |       return task->stack.back();
346 |     }
347 | 
348 |     Box pop() {
349 |       if (I64(task->stack.size()) <= task->stack_offs) {
350 |         throw Error("Nothing to pop");
351 |       }
352 |       
353 |       Box v(task->stack.back());
354 |       task->stack.pop_back();
355 |       return v;
356 |     }
357 | 
358 |     const Stack &stack() { return task->stack; }
359 | 
360 |     void begin_split(I64 offs=0) {
361 |       task->stack_offs = task->stack.size()-offs;
362 |       task->splits.push_back(task->stack_offs);
363 |     }
364 | 
365 |     void end_split() {
366 |       task->splits.pop_back();
367 |       task->stack_offs = task->splits.empty() ? 0 : task->splits.back();
368 |     }
369 | 
370 |     const Box *get(Sym id) const {
371 |       const auto found(task->scope->vars.find(id));
372 |       return found ? &found->val : nullptr;
373 |     }
374 |     
375 |     template <typename...ArgsT>
376 |     void let(Sym id, ArgsT &&...args) {
377 |       if (!task->scope->vars.emplace(id, id, forward<ArgsT>(args)...)) {
378 |         throw RuntimeError(*this, "Duplicate var: " + id.name());
379 |       }
380 |     }
381 | 
382 |     optional<Box> async(const function<optional<Box> ()> &fn);
383 |     void push_async(const function<optional<Box> ()> &fn);
384 |     bool is_async() const { return task->async_depth > 0; }
385 |     void fopen(const string &name, fstream::openmode mode);
386 |   };
387 | 
388 |   inline bool Box::is(const AType &rhs) const {
389 |     auto &lhs((type == &type->lib.env.meta_type) ? *as<AType *>() : *type);
390 |     return lhs.is(rhs);
391 |   }
392 | 
393 |   template <typename ValT, typename...ArgsT>
394 |   Macro &Lib::add_macro(Sym id,
395 |                                  Type<ValT> &type,
396 |                                  ArgsT &&...args) {
397 |     return add_macro(id, [&type, args...](Forms::const_iterator &in,
398 |                                          Forms::const_iterator end,
399 |                                          Env &env) {
400 |                        env.emit<ops::Push>((in++)->pos, type, args...);     
401 |                      });
402 |   }
403 | 
404 |   template <typename OpT, typename...ArgsT>
405 |   Macro &Lib::add_macro(Sym id, ArgsT &&...args) {
406 |     return add_macro(id, [args...](Forms::const_iterator &in,
407 |                                    Forms::const_iterator end,
408 |                                    Env &env) {
409 |                        env.emit<OpT>((in++)->pos, args...);
410 |                      });
411 |   }
412 | }
413 | 
414 | #endif
415 | 


--------------------------------------------------------------------------------
/src/snabl/op.cpp:
--------------------------------------------------------------------------------
  1 | #include "snabl/env.hpp"
  2 | #include "snabl/fimp.hpp"
  3 | #include "snabl/func.hpp"
  4 | #include "snabl/lambda.hpp"
  5 | #include "snabl/op.hpp"
  6 | #include "snabl/timer.hpp"
  7 | 
  8 | namespace snabl {
  9 |   Op::Op(Env &env, const string &type, Pos pos):
 10 |     type(env.sym(type)), pos(pos), next(nullptr) { }
 11 | 
 12 |   void Op::dump(ostream &out) const {
 13 |     out << type;
 14 |     dump_args(out);
 15 |     out << endl;
 16 |   }
 17 | 
 18 |   namespace ops {
 19 |     const string Async::type("async"), Await::type("await"), Bench::type("bench"),
 20 |       Call::type("call"), DDrop::type("ddrop"),
 21 |       Drop::type("drop"), Dup::type("dup"), Else::type("else"), Eqval::type("eqval"),
 22 |       Fimp::type("fimp"), Funcall::type("funcall"), Get::type("get"),
 23 |       If::type("if"), Is::type("is"), Jump::type("jump"), JumpIf::type("jump-if"),
 24 |       Lambda::type("lambda"), Let::type("let"), Nop::type("nop"), Push::type("push"),
 25 |       Recall::type("recall"), Return::type("return"), Rot::type("rot"),
 26 |       RSwap::type("rswap"), Scope::type("scope"), ScopeEnd::type("scope-end"),
 27 |       SDrop::type("sdrop"), Split::type("split"), SplitEnd::type("split-end"),
 28 |       Stack::type("stack"), Stop::type("stop"), Swap::type("swap"),
 29 |       Task::type("task"), Throw::type("throw"),
 30 |       Times::type("times"), Try::type("try"), TryEnd::type("try-end"),
 31 |       Yield::type("yield");
 32 | 
 33 |     Async::Async(Env &env, Pos pos, I64 delta): Op(env, type, pos), delta(delta) { }
 34 | 
 35 |     void Async::run(Env &env) {
 36 |       env.task->async_depth += delta;
 37 |       env.jump(next);
 38 |     }
 39 | 
 40 |     Await::Await(Env &env, Pos pos): Op(env, type, pos) { }
 41 | 
 42 |     void Await::run(Env &env) {
 43 |       auto &v(env.peek());
 44 | 
 45 |       if (v.type != &env.async_type) {
 46 |         throw RuntimeError(env, fmt("Expected Async, was:", {v.type->id}));
 47 |       }
 48 | 
 49 |       auto a(v.as<AsyncPtr>());
 50 |       if (!a->valid() && !env.yield()) { a->wait(); }
 51 |         
 52 |       env.pop();
 53 |       auto r(a->get());
 54 |       if (r) { env.push(*r); }
 55 |       env.jump(next);
 56 |     }
 57 | 
 58 |     Bench::Bench(Env &env, Pos pos): Op(env, type, pos), end_pc(-1) { }
 59 | 
 60 |     void Bench::run(Env &env) {
 61 |       const I64 reps(env.pop().as_i64);
 62 |         
 63 |       for (I64 i(0); i < reps; i++) {
 64 |         env.jump(next);
 65 |         env.run();
 66 |       }
 67 |         
 68 |       Timer t;
 69 |         
 70 |       for (int i(0); i < reps; i++) {
 71 |         env.jump(next);
 72 |         env.run();
 73 |       }
 74 |         
 75 |       env.push(env.time_type, t.ns());
 76 |       env.jump(end_pc);
 77 |     }
 78 |     
 79 |     Call::Call(Env &env, Pos pos): Op(env, type, pos) { }
 80 | 
 81 |     void Call::run(Env &env) {
 82 |       env.jump(next);
 83 |       env.pop().call(pos);
 84 |     }
 85 |     
 86 |     DDrop::DDrop(Env &env, Pos pos): Op(env, type, pos) { }
 87 |     
 88 |     void DDrop::run(Env &env) {
 89 |       auto &t(*env.task);
 90 |       auto &s(t.stack);
 91 |         
 92 |       if (I64(s.size()) <= t.stack_offs) {
 93 |         throw Error("Nothing to ddrop");
 94 |       }
 95 |         
 96 |       s.pop_back();
 97 |       s.pop_back();
 98 |       env.jump(next);
 99 |     }
100 |     
101 |     Drop::Drop(Env &env, Pos pos): Op(env, type, pos) { }
102 | 
103 |     void Drop::run(Env &env) {
104 |       auto &t(*env.task);
105 |       auto &s(t.stack);
106 |         
107 |       if (I64(s.size()) <= t.stack_offs) {
108 |         throw RuntimeError(env,
109 |                            fmt("Nothing to drop: %0/%1", {s.size(), t.stack_offs}));
110 |       }
111 |         
112 |       s.pop_back();
113 |       env.jump(next);
114 |     }
115 |     
116 |     Dup::Dup(Env &env, Pos pos): Op(env, type, pos) { }
117 | 
118 |     void Dup::run(Env &env) {
119 |       auto &t(*env.task);
120 |       auto &s(t.stack);
121 |       if (I64(s.size()) <= t.stack_offs) { throw Error("Nothing to dup"); }
122 |       env.push(s.back());
123 |       env.jump(next);
124 |     }
125 |     
126 |     Else::Else(Env &env, Pos pos, I64 skip_pc):
127 |       Op(env, type, pos), skip_pc(skip_pc) { }
128 | 
129 |     void Else::run(Env &env) {
130 |       if (env.peek()) {
131 |         env.jump(next);
132 |       } else {
133 |         env.jump(skip_pc);
134 |       }
135 | 
136 |       env.pop();
137 |     }
138 |     
139 |     Eqval::Eqval(Env &env, Pos pos, const optional<const Box> rhs):
140 |       Op(env, type, pos), rhs(rhs) { }
141 | 
142 |     void Eqval::run(Env &env) {
143 |       auto &t(*env.task);
144 |       auto &s(t.stack);
145 | 
146 |       if (I64(s.size()) <= t.stack_offs+(rhs ? 0 : 1)) {
147 |         throw Error("Nothing to eqval");
148 |       }
149 |         
150 |       const auto lhs(env.pop());
151 |       const auto _rhs(rhs ? *rhs : s.back());
152 |       env.push(env.bool_type, lhs.eqval(_rhs));
153 |       env.jump(next);
154 | 
155 |     }
156 |     
157 |     void Eqval::dump_args(ostream &out) const {
158 |       if (rhs) {
159 |         out << ' ';
160 |         rhs->dump(out);
161 |       }
162 |     }
163 | 
164 |     Fimp::Fimp(Env &env, Pos pos, snabl::Fimp &fimp, bool is_scope):
165 |       Op(env, type, pos), fimp(fimp), is_scope(is_scope) { }
166 | 
167 |     void Fimp::run(Env &env) {
168 |       if (is_scope) { fimp.vars.emplace(env.scope().vars.vals); }
169 |       env.jump(fimp.end_pc);
170 |     }
171 |     
172 |     void Fimp::dump_args(ostream &out) const { out << ' ' << fimp.id; }
173 |     
174 |     Funcall::Funcall(Env &env, Pos pos, Func &func):
175 |       Op(env, type, pos), func(func), fimp(nullptr), prev_fimp(nullptr) { }
176 | 
177 |     Funcall::Funcall(Env &env, Pos pos, snabl::Fimp &fimp):
178 |       Op(env, type, pos),
179 |       func(fimp.func), fimp(&fimp), prev_fimp(nullptr) { }
180 | 
181 |     void Funcall::run(Env &env) {
182 |       auto &t(*env.task);
183 |       auto &s(t.stack);
184 | 
185 |       snabl::Fimp *f(nullptr);
186 | 
187 |       if (I64(s.size()) >= t.stack_offs+func.nargs) {
188 |         if (fimp) { f = fimp; }
189 |         if (!f && prev_fimp) { f = prev_fimp; }
190 | 
191 |         if (f) {
192 |           if (func.nargs &&
193 |               f->score(s.begin()+(s.size()-func.nargs),
194 |                        s.end()) == -1) { f = nullptr; }
195 |         }
196 | 
197 |         if (!fimp && !f) {
198 |           f = func.get_best_fimp(s.begin()+(s.size()-func.nargs), s.end());
199 |         }
200 |       } 
201 |       
202 |       if (!f) {
203 |         throw RuntimeError(env, fmt("Func not applicable: %0", {func.id}));
204 |       }
205 |       
206 |       if (!fimp) { prev_fimp = f; }
207 |       env.jump(next);
208 |       f->call(pos);
209 |     }
210 |     
211 |     void Funcall::dump_args(ostream &out) const {
212 |       out << ' ' << (fimp ? fimp->id : func.id);
213 |       if (prev_fimp) { out << " (" << prev_fimp->id << ')'; }
214 |     }
215 | 
216 |     Get::Get(Env &env, Pos pos, Sym id): Op(env, type, pos), id(id) { }
217 | 
218 |     void Get::run(Env &env) {
219 |       auto v(env.get(id));
220 |       if (!v) { throw RuntimeError(env, fmt("Unknown var: %0", {id})); }
221 |       env.push(*v);
222 |       env.jump(next);
223 |     }
224 | 
225 |     If::If(Env &env, Pos pos, I64 skip_pc):
226 |       Op(env, type, pos), skip_pc(skip_pc) { }
227 | 
228 |     void If::run(Env &env) {
229 |       if (env.peek()) {
230 |         env.jump(skip_pc);
231 |       } else {
232 |         env.jump(next);
233 |       }
234 | 
235 |       env.pop();
236 |     }
237 |     
238 |     Is::Is(Env &env, Pos pos, const AType &rhs):
239 |       Op(env, type, pos), rhs(rhs) { }
240 |     
241 |     void Is::run(Env &env) {
242 |       auto &t(*env.task);
243 |       auto &s(t.stack);
244 | 
245 |       if (I64(s.size()) <= t.stack_offs) {
246 |         throw RuntimeError(env, "Nothing to is");
247 |       }
248 |           
249 |       const bool ok(s.back().is(rhs));
250 |       s.pop_back();
251 |       env.push(env.bool_type, ok);
252 |       env.jump(next);
253 |     }
254 |     
255 |     void Is::dump_args(ostream &out) const { out << ' ' << rhs.id; }
256 | 
257 |     Jump::Jump(Env &env, Pos pos, I64 end_pc):
258 |       Op(env, type, pos), end_pc(end_pc) { }
259 | 
260 |     void Jump::run(Env &env) { env.jump(end_pc); }
261 |     
262 |     JumpIf::JumpIf(Env &env, Pos pos, function<bool ()> &&cond):
263 |       Op(env, type, pos), cond(move(cond)), end_pc(-1) { } 
264 |     
265 |     void JumpIf::run(Env &env) {
266 |       if (cond()) {
267 |         env.jump(end_pc);
268 |       } else {
269 |         env.jump(next);
270 |       }
271 |     }
272 |     
273 |     Lambda::Lambda(Env &env, Pos pos, bool is_scope):
274 |       Op(env, type, pos),
275 |       is_scope(is_scope), start_pc(nullptr), end_pc(-1) { }
276 |     
277 |     void Lambda::run(Env &env) {      
278 |       env.push(env.lambda_type,
279 |                snabl::Lambda(is_scope ? &env.scope() : nullptr, start_pc, end_pc));
280 |       
281 |       env.jump(end_pc);
282 |     }
283 |     
284 |     Let::Let(Env &env, Pos pos, Sym id): Op(env, type, pos), id(id) { }
285 | 
286 |     void Let::run(Env &env) {
287 |       auto &t(*env.task);
288 |       auto &s(t.stack);
289 |       if (I64(s.size()) <= t.stack_offs) { throw Error("Nothing to let"); }
290 |       auto &v(s.back());
291 |       env.let(id, v);
292 |       s.pop_back();
293 |       env.jump(next);
294 |     }
295 |     
296 |     void Let::dump_args(ostream &out) const { out << ' ' << id; }
297 | 
298 |     Nop::Nop(Env &env, Pos pos): Op(env, type, pos) { }
299 | 
300 |     void Nop::run(Env &env) { env.jump(next); }
301 |     
302 |     Push::Push(Env &env, Pos pos, const Box &val):
303 |       Op(env, type, pos), val(val) { }
304 |     
305 |     void Push::run(Env &env) {
306 |       env.push(val);
307 |       env.jump(next);
308 |     }
309 | 
310 |     void Push::dump_args(ostream &out) const {
311 |       out << ' ';
312 |       val.dump(out);
313 |     }
314 | 
315 |     Recall::Recall(Env &env, Pos pos): Op(env, type, pos) { } 
316 | 
317 |     void Recall::run(Env &env) { env.recall(pos); }
318 |     
319 |     Return::Return(Env &env, Pos pos): Op(env, type, pos) { } 
320 | 
321 |     void Return::run(Env &env) { env._return(pos); }
322 |     
323 |     Rot::Rot(Env &env, Pos pos): Op(env, type, pos) { }
324 | 
325 |     void Rot::run(Env &env) {
326 |       auto &t(*env.task);
327 |       auto &s(t.stack);
328 | 
329 |       if (I64(s.size()) <= t.stack_offs+2) {
330 |         throw RuntimeError(env, "Nothing to rot");
331 |       }
332 |         
333 |       auto i(s.size()-1);
334 |       swap(s[i], s[i-2]);
335 |       swap(s[i], s[i-1]);
336 |       env.jump(next);
337 |     }
338 |     
339 |     RSwap::RSwap(Env &env, Pos pos): Op(env, type, pos) { }
340 | 
341 |     void RSwap::run(Env &env) {
342 |       auto &t(*env.task);
343 |       auto &s(t.stack);
344 | 
345 |       if (I64(s.size()) <= t.stack_offs+2) {
346 |         throw RuntimeError(env, "Nothing to rswap");
347 |       }
348 | 
349 |       const auto i(s.size()-1);
350 |       swap(s[i], s[i-2]);
351 |       env.jump(next);
352 |     }
353 |     
354 |     Scope::Scope(Env &env, Pos pos): Op(env, type, pos) { }
355 | 
356 |     void Scope::run(Env &env) {
357 |       env.begin_scope(env.scope().vars.vals);
358 |       env.jump(next);
359 |     }
360 |     
361 |     ScopeEnd::ScopeEnd(Env &env, Pos pos): Op(env, type, pos) { }
362 | 
363 |     void ScopeEnd::run(Env &env) {
364 |       env.end_scope();
365 |       env.jump(next);
366 |     }
367 |     
368 |     SDrop::SDrop(Env &env, Pos pos): Op(env, type, pos) { }
369 | 
370 |     void SDrop::run(Env &env) {
371 |       auto &t(*env.task);
372 |       auto &s(t.stack);
373 | 
374 |       if (I64(s.size()) <= t.stack_offs+1) {
375 |         throw RuntimeError(env, "Nothing to sdrop");
376 |       }
377 |         
378 |       const auto i(s.size()-1);
379 |       s[i-1] = s[i];  
380 |       s.pop_back();
381 |       env.jump(next);
382 |     }
383 |     
384 |     Split::Split(Env &env, Pos pos, I64 offs):
385 |       Op(env, type, pos), offs(offs) { }
386 | 
387 |     void Split::run(Env &env) {
388 |       env.begin_split(offs);
389 |       env.jump(next);
390 |     }
391 |     
392 |     SplitEnd::SplitEnd(Env &env, Pos pos): Op(env, type, pos) { }
393 | 
394 |     void SplitEnd::run(Env &env) {
395 |       env.end_split();
396 |       env.jump(next);
397 |     }
398 |     
399 |     Stack::Stack(Env &env, Pos pos, bool end_split):
400 |       Op(env, type, pos), end_split(end_split) { }
401 | 
402 |     void Stack::run(Env &env) {
403 |       auto &t(*env.task);
404 |       auto &s(t.stack);
405 | 
406 |       const I64 offs(t.stack_offs);
407 |       if (end_split) { env.end_split(); }
408 |       auto ss(StackPtr::make(&env.stack_type.pool));
409 |         
410 |       if (I64(s.size()) > offs) {
411 |         const auto i(s.begin()+offs), j(s.end());
412 |         move(i, j, back_inserter(*ss));
413 |         s.erase(i, j);
414 |       }
415 |         
416 |       env.push(env.stack_type, ss);
417 |       env.jump(next);
418 |     }
419 |     
420 |     Stop::Stop(Env &env, Pos pos): Op(env, type, pos) { }
421 | 
422 |     void Stop::run(Env &env) { env.jump(nullptr); }
423 |     
424 |     Swap::Swap(Env &env, Pos pos): Op(env, type, pos) { }
425 | 
426 |     void Swap::run(Env &env) {
427 |       auto &t(*env.task);
428 |       auto &s(t.stack);
429 | 
430 |       if (I64(s.size()) <= t.stack_offs+1) {
431 |         throw RuntimeError(env, "Nothing to swap");
432 |       }
433 |         
434 |       const auto i(s.size()-1);
435 |       swap(s[i], s[i-1]);
436 |       env.jump(next);
437 |     }
438 |         
439 |     Task::Task(Env &env, Pos pos):
440 |       Op(env, type, pos), start_pc(nullptr), end_pc(-1) { }
441 | 
442 |     void Task::run(Env &env) {
443 |       env.start_task(next, env.task->scope);
444 |       env.jump(end_pc);
445 |     }
446 |     
447 |     Throw::Throw(Env &env, Pos pos): Op(env, type, pos) { }
448 | 
449 |     void Throw::run(Env &env) {
450 |       auto &v(env.peek());
451 |       auto e((v.type == &env.error_type)
452 |              ? v.as<UserError>()
453 |              : UserError(env, v));
454 |       env.pop();
455 |       throw e;
456 |     }
457 |     
458 |     Times::Times(Env &env, Pos pos, I64 i_reg):
459 |       Op(env, type, pos), i_reg(i_reg) { }
460 | 
461 |     void Times::run(Env &env) {
462 |       env.let_reg(i_reg, env.pop().as_i64);
463 |       env.jump(next);
464 |     }
465 |     
466 |     Try::Try(Env &env, Pos pos):
467 |       Op(env, type, pos), end_pc(-1) { }
468 | 
469 |     void Try::run(Env &env) {
470 |       env.begin_try(*this);
471 |       env.jump(next);
472 |     }
473 |     
474 |     TryEnd::TryEnd(Env &env, Pos pos): Op(env, type, pos) { }
475 | 
476 |     void TryEnd::run(Env &env) {
477 |       env.end_try();
478 |       env.jump(next);
479 |     }
480 |     
481 |     Yield::Yield(Env &env, Pos pos): Op(env, type, pos) { }
482 | 
483 |     void Yield::run(Env &env) {
484 |       env.jump(next);
485 |       env.yield();
486 |     }
487 |   }
488 | }
489 | 


--------------------------------------------------------------------------------
/logo.svg:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8" standalone="no"?>
  2 | <!-- Created with Inkscape (http://www.inkscape.org/) -->
  3 | 
  4 | <svg
  5 |    xmlns:dc="http://purl.org/dc/elements/1.1/"
  6 |    xmlns:cc="http://creativecommons.org/ns#"
  7 |    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  8 |    xmlns:svg="http://www.w3.org/2000/svg"
  9 |    xmlns="http://www.w3.org/2000/svg"
 10 |    xmlns:xlink="http://www.w3.org/1999/xlink"
 11 |    xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
 12 |    xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
 13 |    width="1000"
 14 |    height="1000"
 15 |    id="svg2"
 16 |    version="1.1"
 17 |    inkscape:version="0.91 r13725"
 18 |    sodipodi:docname="logo.svg"
 19 |    inkscape:export-filename="/home/a/Dev/snabl/logo.png"
 20 |    inkscape:export-xdpi="13.61"
 21 |    inkscape:export-ydpi="13.61">
 22 |   <defs
 23 |      id="defs4" />
 24 |   <sodipodi:namedview
 25 |      id="base"
 26 |      pagecolor="#ffffff"
 27 |      bordercolor="#666666"
 28 |      borderopacity="1.0"
 29 |      inkscape:pageopacity="0.0"
 30 |      inkscape:pageshadow="2"
 31 |      inkscape:zoom="0.50000001"
 32 |      inkscape:cx="466.00003"
 33 |      inkscape:cy="515.37115"
 34 |      inkscape:document-units="px"
 35 |      inkscape:current-layer="layer5"
 36 |      showgrid="false"
 37 |      inkscape:window-width="1440"
 38 |      inkscape:window-height="871"
 39 |      inkscape:window-x="0"
 40 |      inkscape:window-y="0"
 41 |      inkscape:window-maximized="1"
 42 |      fit-margin-top="0"
 43 |      fit-margin-left="0"
 44 |      fit-margin-right="0"
 45 |      fit-margin-bottom="0"
 46 |      inkscape:snap-bbox="false"
 47 |      inkscape:snap-bbox-midpoints="true"
 48 |      showguides="true"
 49 |      inkscape:guide-bbox="true" />
 50 |   <metadata
 51 |      id="metadata7">
 52 |     <rdf:RDF>
 53 |       <cc:Work
 54 |          rdf:about="">
 55 |         <dc:format>image/svg+xml</dc:format>
 56 |         <dc:type
 57 |            rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
 58 |         <dc:title></dc:title>
 59 |       </cc:Work>
 60 |     </rdf:RDF>
 61 |   </metadata>
 62 |   <g
 63 |      inkscape:groupmode="layer"
 64 |      id="layer3"
 65 |      inkscape:label="test"
 66 |      style="display:none">
 67 |     <path
 68 |        id="path4192"
 69 |        d="M 499.9453,805.43939 368.46864,577.66774 236.96463,349.84138 l 263.03536,0 263.03538,0 L 631.504,577.66774 499.9453,805.43939 Z"
 70 |        style="opacity:1;fill:#880000;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
 71 |        inkscape:connector-curvature="0" />
 72 |     <circle
 73 |        style="opacity:1;fill:#ffff00;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
 74 |        id="path4219"
 75 |        cx="499.99911"
 76 |        cy="501.70731"
 77 |        r="25.455843" />
 78 |   </g>
 79 |   <g
 80 |      inkscape:groupmode="layer"
 81 |      id="layer1"
 82 |      inkscape:label="S"
 83 |      style="display:none"
 84 |      sodipodi:insensitive="true">
 85 |     <flowRoot
 86 |        xml:space="preserve"
 87 |        id="flowRoot4161"
 88 |        style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:#d45500;stroke-width:5.61403513;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
 89 |        transform="matrix(1.78125,0,0,1.78125,-313.86292,-437.2425)"><flowRegion
 90 |          id="flowRegion4163"><rect
 91 |            id="rect4165"
 92 |            width="261.99997"
 93 |            height="311.99997"
 94 |            x="397.99997"
 95 |            y="434.00003"
 96 |            style="stroke:#d45500;stroke-width:5.61403513;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" /></flowRegion><flowPara
 97 |          id="flowPara4167"
 98 |          style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:180px;font-family:COCOGOOSE;-inkscape-font-specification:COCOGOOSE;fill:#ffffff;stroke:#d45500;stroke-width:5.61403513;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1">S</flowPara></flowRoot>  </g>
 99 |   <g
100 |      inkscape:groupmode="layer"
101 |      id="layer5"
102 |      inkscape:label="Snackis"
103 |      transform="translate(0,500)"
104 |      style="display:inline">
105 |     <path
106 |        style="opacity:1;fill:#640000;fill-opacity:0.39215687;fill-rule:nonzero;stroke:#640000;stroke-width:10;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:0.19607843"
107 |        d="M 236.71997,-150.75025 368.2239,77.075926 499.70048,304.8474 631.25906,77.075926 762.7903,-150.75025 l -263.03513,0 -263.0352,0 z m 265.51957,28.7461 c 9.72563,0 19.0239,1.12281 27.89452,3.36718 8.9775,2.13751 17.7943,5.61055 26.45118,10.41992 3.63375,2.13751 7.05353,4.38117 10.25977,6.73243 3.31313,2.244366 6.19812,4.434756 8.65625,6.572256 2.45812,2.1375 4.38211,4.16805 5.77148,6.0918 1.49624,1.92375 2.24414,3.58133 2.24414,4.9707 0,1.38938 -0.37297,2.67203 -1.12109,3.84766 -0.64125,1.17563 -1.6575,2.51157 -3.04687,4.00781 l -24.52735,26.13086 c -1.81687,1.81688 -3.63429,2.72461 -5.45117,2.72461 -1.49624,0 -2.88548,-0.42625 -4.16797,-1.28125 -1.17562,-0.855 -2.51156,-1.92453 -4.00781,-3.20703 l -1.44141,-1.2832 c -2.13749,-1.81688 -4.54297,-3.68563 -7.21484,-5.60938 -2.565,-1.92375 -5.34344,-3.63461 -8.33594,-5.13086 -2.9925,-1.60312 -6.14585,-2.88578 -9.45898,-3.84765 -3.31313,-1.06876 -6.67961,-1.60352 -10.09961,-1.60352 -3.52687,0 -6.84008,0.32164 -9.93945,0.96289 -3.09938,0.53438 -5.82454,1.44211 -8.17578,2.72461 -2.35125,1.2825 -4.22195,2.99336 -5.61133,5.13086 -1.38938,2.03063 -2.08399,4.5407 -2.08399,7.5332 0,2.9925 0.74789,5.6111 2.24414,7.85547 1.49625,2.1375 3.74188,4.16805 6.73438,6.0918 2.9925,1.81688 6.67867,3.58101 11.06055,5.29101 4.48875,1.60312 9.67266,3.36727 15.55077,5.29102 11.32876,3.74063 21.74984,7.69516 31.26172,11.86328 9.61875,4.06126 17.90079,8.9235195 24.84766,14.5878895 6.94687,5.5575 12.34391,12.2371905 16.19141,20.0390705 3.95437,7.80187 5.93164,17.25999 5.93164,28.375 0,11.75624 -2.40547,22.44374 -7.21485,32.0625 -4.80937,9.51187 -11.43382,17.63406 -19.87695,24.367184 -8.33624,6.73312 -18.16929,11.97031 -29.49805,15.71093 -11.32874,3.63376 -23.51202,5.45118 -36.55078,5.45118 -12.29062,0 -24.3693,-2.19235 -36.23243,-6.57422 -11.86312,-4.38188 -22.92359,-10.25844 -33.18359,-17.63281 -4.275,-3.099374 -7.90985,-6.146174 -10.90235,-9.138674 -2.88562,-2.9925 -5.18257,-5.39796 -6.89257,-7.21485 l -0.48047,-0.48046 c -0.10687,-0.21376 -0.21344,-0.32032 -0.32032,-0.32032 l -0.32226,-0.32031 c -0.10687,-0.21375 -0.21344,-0.32031 -0.32031,-0.32031 l -0.32032,-0.32031 c -2.45812,-2.67188 -3.6875,-4.81095 -3.6875,-6.41407 0,-1.81688 1.22938,-3.84742 3.6875,-6.09179 l 27.73438,-26.45117 c 2.24437,-1.60313 4.0618,-2.4043 5.45117,-2.4043 0.96187,0 1.97617,0.31968 3.04492,0.96094 1.06875,0.64124 2.35141,1.60421 3.84766,2.88671 1.81687,1.49626 4.11578,3.5268 6.89453,6.0918 2.88563,2.45812 6.1436,4.91687 9.77734,7.375 5.45064,3.63375 10.84963,6.46548 16.19337,8.49609 5.34376,2.03063 10.95391,3.04493 16.83203,3.04493 5.45063,0 9.9932,-0.58805 13.62696,-1.76367 3.74062,-1.28251 6.6789,-2.93813 8.8164,-4.96876 2.1375,-2.03062 3.63329,-4.38281 4.48829,-7.05468 0.96188,-2.67188 1.44336,-5.5036 1.44335,-8.4961 0,-3.31312 -1.28265,-6.2514 -3.84765,-8.8164 -2.45813,-2.67188 -5.50297,-5.02407 -9.13672,-7.05469 -3.63375,-2.03063 -7.42844,-3.73953 -11.38281,-5.12891 -3.95438,-1.49625 -7.37415,-2.72562 -10.25977,-3.6875 -12.825,-4.48875 -24.04726,-9.29773 -33.66602,-14.4277305 -9.61875,-5.23687 -17.63438,-11.00883 -24.04688,-17.31445 -6.41249,-6.4124995 -11.22148,-13.4118795 -14.42773,-20.9999995 -3.20625,-7.695 -4.81055,-16.24539 -4.81055,-25.65039 0,-9.93938 1.97727,-18.97125 5.93164,-27.09375 4.06125,-8.1225 9.77992,-15.0686 17.1543,-20.839856 7.48124,-5.77124 16.45788,-10.20726 26.93164,-13.30664 10.47375,-3.20625 22.17751,-4.80858 35.10938,-4.80858 z"
108 |        id="path4200-5"
109 |        inkscape:connector-curvature="0"
110 |        inkscape:export-xdpi="12"
111 |        inkscape:export-ydpi="12" />
112 |   </g>
113 |   <g
114 |      style="display:none"
115 |      transform="translate(0,500)"
116 |      inkscape:label="Snackis copy"
117 |      id="g4180"
118 |      inkscape:groupmode="layer"
119 |      sodipodi:insensitive="true">
120 |     <g
121 |        id="g4182">
122 |       <path
123 |          inkscape:connector-curvature="0"
124 |          style="opacity:1;fill:#d45500;fill-opacity:1;fill-rule:nonzero;stroke:#880000;stroke-width:10;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
125 |          d="M 465.11328,348.3418 C 288.8647,330.89301 151.64453,182.62098 151.64453,1.70704 c 0,-51.11908 10.94072,-99.62299 30.63672,-143.3125 L 323.79102,103.4629 465.11328,348.3418 Z"
126 |          id="path4184" />
127 |       <path
128 |          inkscape:connector-curvature="0"
129 |          style="opacity:1;fill:#d45500;fill-opacity:1;fill-rule:nonzero;stroke:#880000;stroke-width:10;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
130 |          d="M 534.85938,348.3418 676.23633,103.4629 817.71875,-141.57812 c 19.68968,43.68369 30.63672,92.17485 30.63672,143.28516 0,180.92304 -137.2347,329.19825 -313.49609,346.63476 z"
131 |          id="path4186" />
132 |       <path
133 |          inkscape:connector-curvature="0"
134 |          style="opacity:1;fill:#d45500;fill-opacity:1;fill-rule:nonzero;stroke:#880000;stroke-width:10;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
135 |          d="M 217.08789,-201.83007 C 280.27969,-289.58936 383.35598,-346.62109 500,-346.62109 c 116.64405,0 219.72032,57.03173 282.91211,144.79102 l -282.91211,0 -282.91211,0 z"
136 |          id="path4188" />
137 |     </g>
138 |     <g
139 |        transform="translate(-2043.9999,-43.999999)"
140 |        id="g4190">
141 |       <path
142 |          inkscape:connector-curvature="0"
143 |          id="path4194"
144 |          d="m 0,-500 1000,0 0,1000 -1000,0 z"
145 |          style="opacity:1;fill:#d45500;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:2;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1" />
146 |       <path
147 |          inkscape:connector-curvature="0"
148 |          id="path4196"
149 |          d="m 499.99998,-399.98654 c -220.60136,0 -399.99996,179.39866 -399.99996,400.000005 0,220.601315 179.3986,399.973075 399.99996,399.973075 220.60135,0 400,-179.37176 400,-399.973075 0,-220.601355 -179.39865,-400.000005 -400,-400.000005 z m -34.88668,53.3656 -141.32208,244.87929 -141.5103,245.0676 c -19.696,-43.689515 -30.6368,-92.193405 -30.6368,-143.312485 0,-180.913945 137.2206,-329.185615 313.46918,-346.634405 z m 69.74649,0 c 176.26139,17.43651 313.49607,165.71136 313.49607,346.634405 0,51.11031 -10.94713,99.60191 -30.63681,143.285595 L 676.23562,-101.74165 534.85979,-346.62094 Z m -34.91359,42.90229 131.55806,227.772195 131.53116,227.825955 -263.03544,0 -263.03546,0 L 368.46883,-75.946455 499.9462,-303.71865 Z m -282.85928,507.26918 282.91306,0 282.91307,0 c -63.19179,87.75929 -166.26902,144.79185 -282.91307,144.79185 -116.64402,0 -219.72126,-57.03256 -282.91306,-144.79185 z"
150 |          style="color:#000000;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:medium;line-height:normal;font-family:Sans;-inkscape-font-specification:Sans;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;letter-spacing:normal;word-spacing:normal;text-transform:none;direction:ltr;block-progression:tb;writing-mode:lr-tb;baseline-shift:baseline;text-anchor:start;display:inline;overflow:visible;visibility:visible;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:4;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;marker:none;enable-background:accumulate" />
151 |     </g>
152 |     <image
153 |        width="398.2301"
154 |        height="402.2124"
155 |        preserveAspectRatio="none"
156 |        xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAABlCAYAAAC7vkbxAAAABmJLR0QA/wD/AP+gvaeTAAAACXBI WXMAAAN4AAADeAHZXM4yAAAAB3RJTUUH4QgNEiAijJDjwwAAAKZJREFUeNrt0UERADAIBLGj6nEN Ljo8shI21clEZ3oWABEQIAICRECACAgQAREQIAICRECACAgQAREQIAICRECACAgQAREQIAICRECA CAgQAREQIAICRECACAgQAREQIAICRECACAgQAREQIAICRECACAgQAREQIAICRECACAgQAREQIAIC RECACAgQAREQIAICRECACAgQAQEiIAICRECACAgQfW0BuV0CUXZCWRMAAAAASUVORK5CYII= "
157 |        id="image4198"
158 |        x="-665.80554"
159 |        y="-155.06874" />
160 |     <path
161 |        id="path4201"
162 |        d="M 499.94531,305.43946 368.46875,77.66798 236.96484,-150.1582 l 263.03516,0 263.03516,0 -131.53125,227.82618 -131.5586,227.77148 z"
163 |        style="opacity:1;fill:#880000;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:10;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
164 |        inkscape:connector-curvature="0" />
165 |     <g
166 |        id="g4203"
167 |        style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;display:inline;fill:#000000;fill-opacity:1;stroke:none;stroke-width:5.61403513;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
168 |        transform="matrix(1.78125,0,0,1.78125,-313.86292,-937.2425)">
169 |       <path
170 |          inkscape:connector-curvature="0"
171 |          id="path4205"
172 |          style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:180px;font-family:COCOGOOSE;-inkscape-font-specification:COCOGOOSE;fill:#ffffff;stroke:none;stroke-width:5.61403513;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
173 |          d="m 429.32,551.42971 q 1.53,1.26 3.87,3.42 2.43,2.07 5.49,4.14 4.59,3.06 9.09,4.77 4.5,1.71 9.45,1.71 4.59,0 7.65,-0.99 3.15,-1.08 4.95,-2.79 1.8,-1.71 2.52,-3.96 0.81,-2.25 0.81,-4.77 0,-2.79 -2.16,-4.95 -2.07,-2.25 -5.13,-3.96 -3.06,-1.71 -6.39,-2.88 -3.33,-1.26 -5.76,-2.07 -10.8,-3.78 -18.9,-8.1 -8.1,-4.41 -13.5,-9.72 -5.4,-5.4 -8.1,-11.79 -2.7,-6.48 -2.7,-14.4 0,-8.37 3.33,-15.21 3.42,-6.84 9.63,-11.7 6.3,-4.86 15.12,-7.47 8.82,-2.7 19.71,-2.7 8.19,0 15.66,1.89 7.56,1.8 14.85,5.85 3.06,1.8 5.76,3.78 2.79,1.89 4.86,3.69 2.07,1.8 3.24,3.42 1.26,1.62 1.26,2.79 0,1.17 -0.63,2.16 -0.54,0.99 -1.71,2.25 l -13.77,14.67 q -1.53,1.53 -3.06,1.53 -1.26,0 -2.34,-0.72 -0.99,-0.72 -2.25,-1.8 l -0.81,-0.72 q -1.8,-1.53 -4.05,-3.15 -2.16,-1.62 -4.68,-2.88 -2.52,-1.35 -5.31,-2.16 -2.79,-0.9 -5.67,-0.9 -2.97,0 -5.58,0.54 -2.61,0.45 -4.59,1.53 -1.98,1.08 -3.15,2.88 -1.17,1.71 -1.17,4.23 0,2.52 1.26,4.41 1.26,1.8 3.78,3.42 2.52,1.53 6.21,2.97 3.78,1.35 8.73,2.97 9.54,3.15 17.55,6.66 8.1,3.42 13.95,8.19 5.85,4.68 9.09,11.25 3.33,6.57 3.33,15.93 0,9.9 -4.05,18 -4.05,8.01 -11.16,13.68 -7.02,5.67 -16.56,8.82 -9.54,3.06 -20.52,3.06 -10.35,0 -20.34,-3.69 -9.99,-3.69 -18.63,-9.9 -3.6,-2.61 -6.12,-5.13 -2.43,-2.52 -3.87,-4.05 l -0.27,-0.27 q -0.09,-0.18 -0.18,-0.18 -0.09,-0.09 -0.18,-0.18 -0.09,-0.18 -0.18,-0.18 -0.09,-0.09 -0.18,-0.18 -2.07,-2.25 -2.07,-3.6 0,-1.53 2.07,-3.42 l 15.57,-14.85 q 1.89,-1.35 3.06,-1.35 0.81,0 1.71,0.54 0.9,0.54 2.16,1.62 z" />
174 |     </g>
175 |   </g>
176 |   <g
177 |      style="display:none"
178 |      inkscape:label="S (to path)"
179 |      id="g4149"
180 |      inkscape:groupmode="layer" />
181 | </svg>
182 | 


--------------------------------------------------------------------------------
/src/snabl/libs/abc.cpp:
--------------------------------------------------------------------------------
  1 | #include "snabl/call.hpp"
  2 | #include "snabl/env.hpp"
  3 | #include "snabl/libs/abc.hpp"
  4 | #include "snabl/std.hpp"
  5 | #include "snabl/timer.hpp"
  6 | 
  7 | namespace snabl {
  8 |   namespace libs {
  9 |     Abc::Abc(Env &env): Lib(env, env.sym("abc"), &env.s_lib) { }
 10 | 
 11 |     void Abc::init() {
 12 |       add_macro(env.sym("t"), env.bool_type, true);     
 13 |       add_macro(env.sym("f"), env.bool_type, false);      
 14 |       add_macro(env.sym("nil"), env.nil_type);      
 15 | 
 16 |       add_macro<ops::Await>(env.sym("await!"));
 17 |       add_macro<ops::Call>(env.sym("call!"));
 18 |       add_macro<ops::DDrop>(env.sym("ddrop!"));
 19 |       add_macro<ops::Drop>(env.sym("drop!"));
 20 |       add_macro<ops::Dup>(env.sym("dup!"));
 21 |       add_macro<ops::Nop>(env.sym("_"));
 22 |       add_macro<ops::Recall>(env.sym("recall!"));
 23 |       add_macro<ops::Return>(env.sym("return!"));
 24 |       add_macro<ops::Rot>(env.sym("rot!"));
 25 |       add_macro<ops::RSwap>(env.sym("rswap!"));
 26 |       add_macro<ops::SDrop>(env.sym("sdrop!"));
 27 |       add_macro<ops::Swap>(env.sym("swap!"));
 28 |       add_macro<ops::Throw>(env.sym("throw!"));
 29 |       add_macro<ops::Yield>(env.sym("yield!"));
 30 | 
 31 |       add_macro(env.sym("async:"),
 32 |                 [](Forms::const_iterator &in,
 33 |                    Forms::const_iterator end,
 34 |                    Env &env) {
 35 |                   const auto form(*in++);                 
 36 |                   env.emit<ops::Async>(form.pos, 1);
 37 |                   
 38 |                   if (in == end) {
 39 |                     throw SyntaxError(form.pos, "Missing async body");
 40 |                   }
 41 |                   
 42 |                   env.compile(*in++);
 43 |                   env.emit<ops::Async>(form.pos, -1);
 44 |                 });
 45 | 
 46 |       add_macro(env.sym("await:"),
 47 |                 [](Forms::const_iterator &in,
 48 |                    Forms::const_iterator end,
 49 |                    Env &env) {
 50 |                   const auto form(*in++);                 
 51 |                   env.emit<ops::Async>(form.pos, 1);
 52 |                   if (in == end) { throw SyntaxError(form.pos, "Missing sync body"); }
 53 |                   env.compile(*in++);
 54 |                   env.emit<ops::Async>(form.pos, -1);
 55 |                   env.emit<ops::Await>(form.pos);
 56 |                 });
 57 | 
 58 |       add_macro(env.sym("bench:"),
 59 |                 [](Forms::const_iterator &in,
 60 |                    Forms::const_iterator end,
 61 |                    Env &env) {
 62 |                   const auto form(*in++);                 
 63 |                   auto &op(env.emit<ops::Bench>(form.pos));
 64 |                   
 65 |                   if (in == end) {
 66 |                     throw SyntaxError(form.pos, "Missing bench body");
 67 |                   }
 68 |                   
 69 |                   env.compile(*in++);
 70 |                   env.emit<ops::Stop>(form.pos);
 71 |                   op.end_pc = env.ops.size();
 72 |                 }); 
 73 | 
 74 |       add_macro(env.sym("enum:"),
 75 |                 [this](Forms::const_iterator &in,
 76 |                        Forms::const_iterator end,
 77 |                        Env &env) {
 78 |                   const auto form(*in++);
 79 |                   auto id((in++)->as<forms::Id>().id);
 80 |                   auto body(*in++);
 81 |                   
 82 |                   vector<Sym> alts;
 83 |                   for (auto &f: body.as<forms::Body>().body) {
 84 |                     alts.push_back(f.as<forms::Id>().id);
 85 |                   }
 86 | 
 87 |                   env.lib().add_enum_type(id, alts);
 88 |                 }); 
 89 | 
 90 |       add_macro(env.sym("if:"),
 91 |                 [](Forms::const_iterator &in,
 92 |                    Forms::const_iterator end,
 93 |                    Env &env) {
 94 |                   auto &form(*in++);
 95 |                   auto &else_skip(env.emit<ops::Else>(form.pos));
 96 |                   env.compile(*in++);
 97 |                   auto &if_skip(env.emit<ops::Jump>(form.pos));
 98 |                   else_skip.skip_pc = env.ops.size();
 99 |                   env.compile(*in++);
100 |                   if_skip.end_pc = env.ops.size();
101 |                 }); 
102 | 
103 |       add_macro(env.sym("func:"),
104 |                 [](Forms::const_iterator &in,
105 |                    Forms::const_iterator end,
106 |                    Env &env) {
107 |                   auto &lib(env.lib());
108 |                   const auto &form(*in++);
109 |                   
110 |                   auto &id_form((in++)->as<forms::Fimp>());
111 |                   vector<Box> args;
112 |                   
113 |                   for (const auto id: id_form.type_ids) {
114 |                     const auto t(lib.get_type(id));
115 | 
116 |                     if (!t) {
117 |                       throw CompileError(form.pos, fmt("Unknown type: %0", {id}));
118 |                     }
119 |                     
120 |                     args.emplace_back(*t);
121 |                   }
122 |                   
123 |                   auto &fi = lib.add_fimp(id_form.id, args, *in++);
124 |                   fi.compile(form.pos);
125 |                 });
126 | 
127 |       add_macro(env.sym("let:"),
128 |                 [](Forms::const_iterator &in,
129 |                    Forms::const_iterator end,
130 |                    Env &env) {
131 |                   auto &form(*in++);
132 | 
133 |                   if (in == end) {
134 |                     throw SyntaxError(form.pos, "Missing let place");
135 |                   }
136 |                   
137 |                   auto &p(*in++);
138 | 
139 |                   if (&p.type == &forms::Id::type) {
140 |                     env.emit<ops::Let>(form.pos, p.as<forms::Id>().id);
141 |                   } else {
142 |                     auto &b(p.as<forms::Body>().body);
143 | 
144 |                     for (auto pp = b.rbegin(); pp != b.rend(); pp++) {
145 |                       env.emit<ops::Let>(form.pos, pp->as<forms::Id>().id);
146 |                     }
147 |                   }
148 |                 });
149 |             
150 |       add_macro(env.sym("switch:"),
151 |                 [](Forms::const_iterator &in,
152 |                    Forms::const_iterator end,
153 |                    Env &env) {
154 |                   auto &form(*in++);
155 | 
156 |                   vector<ops::Jump *> skips;
157 |                   auto &cases((in++)->as<forms::Body>());
158 | 
159 |                   for (auto f(cases.body.begin()); f != cases.body.end();) {
160 |                     if (f+1 != cases.body.end()) { env.emit<ops::Dup>(form.pos); }
161 |                     env.compile(*f++);
162 | 
163 |                     if (f != cases.body.end()) {
164 |                       auto &else_op(env.emit<ops::Else>(form.pos));
165 |                       env.emit<ops::Drop>(form.pos);
166 |                       env.compile(*f++);
167 |                       
168 |                       if (f != cases.body.end()) {
169 |                         skips.push_back(&env.emit<ops::Jump>(form.pos));
170 |                       }
171 | 
172 |                       else_op.skip_pc = env.ops.size();
173 |                     }
174 |                   }
175 | 
176 |                   for (auto &s: skips) { s->end_pc = env.ops.size(); }
177 |                 }); 
178 |       
179 |       add_macro(env.sym("task:"),
180 |                 [](Forms::const_iterator &in,
181 |                    Forms::const_iterator end,
182 |                    Env &env) {
183 |                   auto &form(*in++);
184 | 
185 |                   if (in == end) {
186 |                     throw SyntaxError(form.pos, "Missing task body");
187 |                   }
188 |                   
189 |                   auto &op(env.emit<ops::Task>(form.pos));
190 |                   
191 |                   env.compile(*in++);
192 |                   env.emit<ops::Stop>(form.pos);
193 |                   op.end_pc = env.ops.size();
194 |                 }); 
195 | 
196 |       add_macro(env.sym("times:"),
197 |                 [](Forms::const_iterator &in,
198 |                    Forms::const_iterator end,
199 |                    Env &env) {
200 |                   auto &form(*in++);
201 |                   const I64 i_reg(env.next_reg(form.pos));
202 |                   env.emit<ops::Times>(form.pos, i_reg);
203 |                   const auto start_pc(env.ops.size());
204 | 
205 |                   auto &jump(env.emit<ops::JumpIf>(form.pos, [&env, i_reg]() {
206 |                         return !env.get_reg<I64>(i_reg)--;
207 |                       }));
208 |                   
209 |                   env.compile(*in++);
210 |                   env.emit<ops::Jump>(form.pos, start_pc);
211 |                   jump.end_pc = env.ops.size();
212 |                 }); 
213 | 
214 |       add_macro(env.sym("try:"),
215 |                 [](Forms::const_iterator &in,
216 |                    Forms::const_iterator end,
217 |                    Env &env) {
218 |                   const auto form(*in++);
219 |                   auto &op(env.emit<ops::Try>(form.pos));
220 |                   if (in == end) { throw SyntaxError(form.pos, "Missing try body"); }
221 |                   env.compile(*in++);
222 |                   env.emit<ops::TryEnd>(form.pos);
223 |                   env.emit<ops::Push>(form.pos, env.nil_type);
224 |                   op.end_pc = env.ops.size();
225 |                 });
226 | 
227 |       add_macro(env.sym("while:"),
228 |                 [](Forms::const_iterator &in,
229 |                    Forms::const_iterator end,
230 |                    Env &env) {
231 |                   auto &form(*in++);               
232 | 
233 |                   if (in == end) {
234 |                     throw SyntaxError(form.pos, "Missing while body");
235 |                   }
236 | 
237 |                   const auto start_pc(env.ops.size());
238 |                   env.compile(*in++);
239 |                   env.emit<ops::If>(form.pos, start_pc);
240 |                 });; 
241 |       
242 |       add_fimp(env.sym("catch"),
243 |                {Box(env.error_type)},
244 |                [this](Fimp &fimp) {
245 |                  env.push(env.pop().as<UserError>().val);
246 |                });
247 | 
248 |       add_fimp(env.sym("is"),
249 |                {Box(env.maybe_type), Box(env.meta_type)},
250 |                [this](Fimp &fimp) {
251 |                  Box y(env.pop()), x(env.pop());
252 |                  env.push(env.bool_type, x.is(*y.as<AType *>()));
253 |                });
254 | 
255 |       add_fimp(env.sym("="),
256 |                {Box(env.maybe_type), Box(env.maybe_type)},
257 |                [this](Fimp &fimp) {
258 |                  Box y(env.pop()), x(env.pop());
259 |                  env.push(env.bool_type, x.eqval(y));
260 |                });
261 | 
262 |       add_fimp(env.sym("!="),
263 |                {Box(env.maybe_type), Box(env.maybe_type)},
264 |                [this](Fimp &fimp) {
265 |                  Box y(env.pop()), x(env.pop());
266 |                  env.push(env.bool_type, !x.eqval(y));
267 |                });
268 | 
269 |       add_fimp(env.sym("=="),
270 |                {Box(env.maybe_type), Box(env.maybe_type)},
271 |                [this](Fimp &fimp) {
272 |                  Box y(env.pop()), x(env.pop());
273 |                  env.push(env.bool_type, x.equid(y));
274 |                });
275 | 
276 |       add_fimp(env.sym("!=="),
277 |                {Box(env.maybe_type), Box(env.maybe_type)},
278 |                [this](Fimp &fimp) {
279 |                  Box y(env.pop()), x(env.pop());
280 |                  env.push(env.bool_type, !x.equid(y));
281 |                });
282 | 
283 |       add_fimp(env.sym("<"),
284 |                {Box(env.cmp_type), Box(env.cmp_type)},
285 |                [this](Fimp &fimp) {
286 |                  Box y(env.pop()), x(env.pop());
287 |                  env.push(env.bool_type, x.cmp(y) == Cmp::LT);
288 |                });
289 | 
290 |       add_fimp(env.sym(">"),
291 |                {Box(env.cmp_type), Box(env.cmp_type)},
292 |                [this](Fimp &fimp) {
293 |                  Box y(env.pop()), x(env.pop());
294 |                  env.push(env.bool_type, x.cmp(y) == Cmp::GT);
295 |                });
296 | 
297 |       add_fimp(env.sym("int"),
298 |                {Box(env.float_type)},
299 |                [this](Fimp &fimp) {
300 |                  const Float v(env.pop().as_float);
301 |                  env.push(env.i64_type, I64(v));
302 |                });
303 | 
304 |       add_fimp(env.sym("float"),
305 |                {Box(env.i64_type)},
306 |                [this](Fimp &fimp) {
307 |                  const I64 v(env.pop().as_i64);
308 |                  env.push(env.float_type, Float(v));
309 |                });
310 | 
311 |       add_fimp(env.sym("++"),
312 |                {Box(env.i64_type)},
313 |                [this](Fimp &fimp) {
314 |                  env.peek().as_i64++;
315 |                });
316 | 
317 |       add_fimp(env.sym("--"),
318 |                {Box(env.i64_type)},
319 |                [this](Fimp &fimp) {
320 |                  env.peek().as_i64--;
321 |                });
322 |       
323 |       add_fimp(env.sym("+"),
324 |                {Box(env.i64_type), Box(env.i64_type)},
325 |                [this](Fimp &fimp) {
326 |                  I64 y(env.pop().as_i64);
327 |                  env.peek().as_i64 += y;
328 |                });
329 | 
330 |       add_fimp(env.sym("-"),
331 |                {Box(env.i64_type), Box(env.i64_type)},
332 |                [this](Fimp &fimp) {
333 |                  I64 y(env.pop().as_i64);
334 |                  env.peek().as_i64 -= y;
335 |                });
336 |       
337 |       add_fimp(env.sym("*"),
338 |                {Box(env.i64_type), Box(env.i64_type)},
339 |                [this](Fimp &fimp) {
340 |                  I64 y(env.pop().as_i64);
341 |                  env.peek().as_i64 *= y;
342 |                });
343 | 
344 |       add_fimp(env.sym("bool"),
345 |                {Box(env.maybe_type)},
346 |                [this](Fimp &fimp) { env.push(env.bool_type, env.pop()); });
347 | 
348 |       add_fimp(env.sym("push"),
349 |                {Box(env.sink_type), Box(env.root_type)},
350 |                [this](Fimp &fimp) {
351 |                  auto v(env.pop());
352 |                  env.pop().push(v);
353 |                });
354 |       
355 |       add_fimp(env.sym("peek"),
356 |                {Box(env.source_type)},
357 |                [this](Fimp &fimp) {
358 |                  auto v(env.pop().peek());
359 |                  env.push(v ? *v : Box(env.nil_type));
360 |                });
361 | 
362 |       add_fimp(env.sym("pop"),
363 |                {Box(env.source_type)},
364 |                [this](Fimp &fimp) {
365 |                  env.pop().pop();
366 |                });
367 | 
368 |       add_fimp(env.sym("iter"),
369 |                {Box(env.seq_type)},
370 |                [this](Fimp &fimp) {
371 |                  env.push(env.iter_type, env.pop().iter());
372 |                });
373 | 
374 |       add_fimp(env.sym(".."),
375 |                {Box(env.seq_type)},
376 |                [this](Fimp &fimp) {
377 |                  auto in(env.pop().iter());
378 |                  while (in->call(env));
379 |                });
380 | 
381 |       add_fimp(env.sym("stack"),
382 |                {Box(env.seq_type)},
383 |                [this](Fimp &fimp) {
384 |                  auto in(env.pop().iter());
385 |                  auto &s(env.task->stack);
386 |                  const auto offs(s.size());
387 |                  while (in->call(env));
388 |                  auto i(s.begin()+offs), j(s.end());
389 |                  auto out(StackPtr::make(&env.stack_type.pool, i, j));
390 |                  s.erase(i, j);
391 |                  env.push(env.stack_type, out);
392 |                });
393 | 
394 |       add_fimp(env.sym("dump"),
395 |                {Box(env.maybe_type)},
396 |                [this](Fimp &fimp) {
397 |                  env.pop().dump(cerr);
398 |                  cerr << endl;
399 |                });
400 | 
401 |       add_fimp(env.sym("say"),
402 |                {Box(env.maybe_type)},
403 |                [this](Fimp &fimp) {
404 |                  auto &out(*env.stdout);
405 |                  env.pop().print(out);
406 |                  out << endl;
407 |                });
408 |       
409 |       add_fimp(env.sym("len"),
410 |                {Box(env.str_type)},
411 |                [this](Fimp &fimp) {
412 |                  env.push(env.i64_type, env.pop().as<StrPtr>()->size());
413 |                });
414 | 
415 |       add_fimp(env.sym("len"),
416 |                {Box(env.stack_type)},
417 |                [this](Fimp &fimp) {
418 |                  env.push(env.i64_type, env.pop().as<StackPtr>()->size());
419 |                });
420 | 
421 |       add_fimp(env.sym("sym"),
422 |                {Box(env.enum_type)},
423 |                [this](Fimp &fimp) {
424 |                  env.push(env.sym_type, env.pop().as_enum.id);
425 |                });
426 | 
427 |       add_fimp(env.sym("ns"),
428 |                {Box(env.i64_type)},
429 |                [this](Fimp &fimp) {
430 |                  env.push(env.time_type, env.pop().as_i64);
431 |                });      
432 | 
433 |       add_fimp(env.sym("ms"),
434 |                {Box(env.i64_type)},
435 |                [this](Fimp &fimp) {
436 |                  env.push(env.time_type, Time::ms(env.pop().as_i64));
437 |                });      
438 | 
439 |       add_fimp(env.sym("ms"),
440 |                {Box(env.time_type)},
441 |                [this](Fimp &fimp) {
442 |                  env.push(env.i64_type, env.pop().as_time.as_ms());
443 |                });
444 |       
445 |       add_fimp(env.sym("sleep"),
446 |                {Box(env.time_type)},
447 |                [this](Fimp &fimp) {
448 |                  const Time time(env.pop().as_time);
449 |                  
450 |                  env.push_async([time]() {
451 |                      this_thread::sleep_for(nanoseconds(time.ns));
452 |                      return nullopt;
453 |                    });
454 |                });
455 | 
456 |       add_fimp(env.sym("bin"),
457 |                {Box(env.str_type)},
458 |                [this](Fimp &fimp) {
459 |                  auto &in(*env.pop().as<StrPtr>());
460 |                  env.push(env.bin_type,
461 |                           BinPtr::make(&env.bin_type.pool, in.begin(), in.end()));
462 |                });
463 | 
464 |       add_fimp(env.sym("str"),
465 |                {Box(env.bin_type)},
466 |                [this](Fimp &fimp) {
467 |                  auto &in(*env.pop().as<BinPtr>());
468 |                  env.push(env.str_type,
469 |                           StrPtr::make(&env.str_type.pool, in.begin(), in.end()));
470 |                });
471 | 
472 |       add_fimp(env.sym("fopen"),
473 |                {Box(env.str_type), Box(env.io_type)},
474 |                [this](Fimp &fimp) {
475 |                  auto m(env.pop().as_enum.id);
476 |                  auto fn(env.pop().as<StrPtr>());
477 | 
478 |                  if (m == env.sym("r")) {
479 |                    env.fopen(*fn, ios::in);
480 |                  } else if (m == env.sym("w")) {
481 |                    env.fopen(*fn, ios::out);
482 |                  } else if (m == env.sym("rw")) {
483 |                    env.fopen(*fn, ios::in | ios::out);
484 |                  } else {
485 |                    throw RuntimeError(env, fmt("Invalid mode: %0", {m}));
486 |                  }
487 |                });
488 | 
489 |       add_fimp(env.sym("str"),
490 |                {Box(env.rfile_type)},
491 |                [this](Fimp &fimp) {
492 |                  auto fp(env.pop().as<FilePtr>());
493 |                  
494 |                  env.push_async([this, fp]() {
495 |                      auto &f(*fp);
496 |                      f.seekg(0, ios::end);
497 |                      const auto size = f.tellg();
498 |                      f.seekg(0, ios::beg);
499 |                      vector<char> buf(size);
500 |                      f.read(buf.data(), size);
501 |                      return Box(env.str_type,
502 |                                 StrPtr::make(&env.str_type.pool, buf.data(), size));
503 |                    });
504 |                });
505 | 
506 |       add_fimp(env.sym("test="),
507 |                {Box(env.maybe_type), Box(env.maybe_type)},
508 |                [this](Fimp &fimp) {
509 |                  Box y(env.pop()), x(env.pop());
510 |                  
511 |                  if (!x.eqval(y)) {
512 |                    throw RuntimeError(env, fmt("Expected (%0), was (%1)", {y, x}));
513 |                  }
514 |                });
515 | 
516 |       add_fimp(env.sym("fib"),
517 |                {Box(env.i64_type)},
518 |                [this](Fimp &fimp) {
519 |                  Box &v(env.peek());
520 |                  I64 n(v.as_i64), a(0), b(1);
521 |                  
522 |                  while (n-- > 1) {
523 |                    swap(a, b);
524 |                    b += a;
525 |                  }
526 | 
527 |                  v.as_i64 = b;
528 |                });
529 |     }
530 |   }
531 | }
532 | 


--------------------------------------------------------------------------------