implement expression handling further

+ Add some notes about returning functions that I started thinking about
  as a result of the fib example

5 files changed, 96 insertions, 1 deletions

diff --git a/README.md b/README.md
index f61dfdb..9e40e96 100644
--- a/README.md
+++ b/README.md
@@ -83,3 +83,36 @@ If (big if) this experiment turns out to be useful on some level I'll probably
 slowly try to make it more self-reliant. My target would be systems programming,
 possibly even embedded systems, though I don't yet know if this 'paradigm' is
 powerful enough or if I might need some escape hatches like `unsafe` in Rust.
+
+### Really, not returns?
+
+Semantically, yes, although it is useful to convert certain closure calls to
+equivalent return statements where possible. This reduces stack usage if nothing
+else, and existing compilers are more used to return-oriented programming so it
+might also be possible that the produced assembly is more efficient.
+
+As an example, see `examples/fib.fwd`. The naive C++ currently generated
+(besides not actually compiling due to template instantiation depth, heh)
+converts what's usually a binary tree of successive calls into a linear sequence
+that takes up a huge amount of stack memory. However, we can note that a closure
+call is equivalent to a return when
+
+1. the function has only one closure parameter
+2. all code paths end in the closure call
+3. the closure call does not reference any local variables by reference
+    (except references that were taken as parameters)
+
+Our fibonacci function matches all these cases, and could theoretically be
+turned into a more typical return-oriented function for great benefit. Checking
+these requirements should be relatively straightforward.
+
+We could potentially loosen up these requirements, for example we could allow
+multiple closure parameters and just return a variant, although the caller now
+has to pattern match on the result. Taking things even further, we could start
+treating functions more as macros and just replace the function call with the
+function body, although this has some other, more fuzzy, requirements like not
+allowing recursion.
+
+We might even want to require that a function can be turned into a 'returning'
+function (being pretentious we might prefer calling it 'folding' but anyway) so
+that it can be interfaced from C code, for example.
diff --git a/examples/fib.fwd b/examples/fib.fwd
new file mode 100644
index 0000000..8b0e055
--- /dev/null
+++ b/examples/fib.fwd
@@ -0,0 +1,23 @@
+/* heh, this technically speaking would work but the templating turns out to be
+ * too much for both GCC and clang. With some manual intervention on the
+ * generated code I can get fibonacci numbers up to about 35 to work, but then
+ * I run out of stack space. I guess the compiler can't collapse frames so the
+ * bifurcating nature of fibonacci just gets mapped to a linear sequence of
+ * calls? */
+
+fib(n, res)
+{
+	fwd_if(n < 2) => {
+		res(1);
+	} => {
+		fib(n - 1) => f1;
+		fib(n - 2) => f2;
+		res(f1 + f2);
+	}
+}
+
+main()
+{
+	fib(6) => n;
+	fwd_println(n);
+}
diff --git a/include/fwd/ast.h b/include/fwd/ast.h
index 909137d..c124ac1 100644
--- a/include/fwd/ast.h
+++ b/include/fwd/ast.h
@@ -166,6 +166,7 @@ static inline bool is_binop(struct ast *x)
 static inline bool is_unop(struct ast *x)
 {
 	switch (x->k) {
+	case AST_LNOT:
 	case AST_NOT:
 	case AST_NEG:
 		return true;
diff --git a/lib/fwdlib.hpp b/lib/fwdlib.hpp
index 0462c52..034c91a 100644
--- a/lib/fwdlib.hpp
+++ b/lib/fwdlib.hpp
@@ -9,7 +9,15 @@
 
 using namespace std;
 
-static inline void fwd_getline(auto next)
+static void fwd_if(auto cond, auto ok, auto fail)
+{
+	if (cond)
+		ok();
+	else
+		fail();
+}
+
+static void fwd_getline(auto next)
 {
 	if (cin.eof())
 		next(optional<string>{});
diff --git a/src/lower.c b/src/lower.c
index ad3d1b9..46ce2c3 100644
--- a/src/lower.c
+++ b/src/lower.c
@@ -44,6 +44,13 @@ static int lower_binop(struct state *state, struct ast *binop)
 		return -1;
 
 	switch (binop->k) {
+	case AST_ADD:	printf(" + "); break;
+	case AST_SUB:	printf(" - "); break;
+	case AST_MUL:	printf(" * "); break;
+	case AST_DIV:	printf(" / "); break;
+	case AST_REM:	printf(" %% "); break;
+	case AST_LSHIFT:	printf(" << "); break;
+	case AST_RSHIFT:	printf(" >> "); break;
 	default:
 		internal_error("missing binop lowering");
 		return -1;
@@ -63,6 +70,12 @@ static int lower_comparison(struct state *state, struct ast *comp)
 		return -1;
 
 	switch (comp->k) {
+	case AST_LT: printf(" < "); break;
+	case AST_GT: printf(" > "); break;
+	case AST_LE: printf(" <= "); break;
+	case AST_GE: printf(" <= "); break;
+	case AST_NE: printf(" != "); break;
+	case AST_EQ: printf(" == "); break;
 	default:
 		internal_error("missing comparison lowering");
 		return -1;
@@ -148,8 +161,25 @@ static int lower_init(struct state *state, struct ast *init)
 	return 0;
 }
 
+static int lower_unop(struct state *state, struct ast *expr)
+{
+	switch (expr->k) {
+	case AST_LNOT:	printf("-"); break;
+	case AST_NOT:	printf("~"); break;
+	case AST_NEG:	printf("-"); break;
+	default:
+		internal_error("missing unop lowering");
+		return -1;
+	}
+
+	return lower_expr(state, unop_expr(expr));
+}
+
 static int lower_expr(struct state *state, struct ast *expr)
 {
+	if (is_unop(expr))
+		return lower_unop(state, expr);
+
 	if (is_binop(expr))
 		return lower_binop(state, expr);