October 4, 2014 00:39 · Oct 4, 2014
diff --git a/gistfile1.c b/gistfile1.c
@@ -0,0 +1,169 @@
+#include "stdio.h"
+#include "stdlib.h"
+
+typedef struct {
+  void* apply_func;  // pointer to function apply this closure w/ correct number of args and free-vars
+  void* func;        // pointer to lifted function that implements this closure
+  int num_freevars;  // number of bound variables (for GC use)
+  char* str;         // string representation of this function
+  void* forwarded;   // forward pointer (for GC use)
+  void* args[];      // bound variables
+} clos;
+
+// halt function
+void halt_func(clos* halt, clos* val) {
+  printf("%s\n", val->str);
+  exit(0);
+}
+
+// halt continuation
+clos halt_impl = {&halt_func, // just use the apply function
+                  NULL,
+                  2,
+                  "halt func",
+                  NULL,
+                  NULL}; // no bound args
+static clos* halt = &halt_impl;
+
+/* function pointer typedefs */
+typedef void (*fp_typedef2032)(clos*, clos*);
+typedef void (*fp_typedef2028)(clos*, clos*, clos*, clos*);
+typedef void (*fp_typedef2025)(clos*, clos*, clos*);
+
+/* apply function definitions */
+// apply_funcs do not allocate any important stack variables,
+// so we can use a return and save some memory
+
+// there is one apply function for each used combination of (num-args, num-free-vars)
+// note functions only take one argument in vanilla lambda calculus
+void apply_func22052(clos* cls, clos* arg2051) {
+  // use a return here, we don't have to worry about blowing important stack variables
+  return ((fp_typedef2032)(cls->func))(arg2051,((clos*)(cls->args[0])));
+}
+
+void apply_func22038(clos* cls, clos* arg2036,clos* arg2037) {
+  return ((fp_typedef2032)(cls->func))(arg2036,arg2037);
+}
+
+void apply_func32035(clos* cls, clos* arg2033,clos* arg2034) {
+  return ((fp_typedef2025)(cls->func))(arg2033,arg2034,((clos*)(cls->args[0])));
+}
+
+void apply_func42031(clos* cls, clos* arg2029,clos* arg2030) {
+  return ((fp_typedef2028)(cls->func))(arg2029,arg2030,((clos*)(cls->args[0])),((clos*)(cls->args[1])));
+}
+
+void apply_func32027(clos* cls, clos* arg2026) {
+  return ((fp_typedef2025)(cls->func))(arg2026,((clos*)(cls->args[0])),((clos*)(cls->args[1])));
+}
+
+
+/* forward declarations */
+void func2049(clos*, clos*);
+void func2047(clos*, clos*);
+void func2045(clos*, clos*);
+void func2043(clos*, clos*);
+void func2041(clos*, clos*, clos*);
+void func2039(clos*, clos*);
+void func2023(clos*, clos*, clos*);
+void func2021(clos*, clos*, clos*, clos*);
+void func2019(clos*, clos*, clos*);
+void func2017(clos*, clos*);
+
+/* lifted function definitions */
+// allocate all values (just closures) on the stack
+// never return from a lifted lambda function
+// so all stack pointers remain valid (until overflow, of course)
+void func2043(clos* rv2009, clos* halt) {
+  clos* clos2046 = alloca(sizeof(clos)+(sizeof(clos*)*0)+(sizeof(char)*16));
+  clos2046->num_args = 0;
+  clos2046->func = &func2045;
+  clos2046->apply_func = &apply_func22038;
+  clos2046->str = "(LAMBDA (B3) B3)";
+  clos* clos2048 = alloca(sizeof(clos)+(sizeof(clos*)*1)+(sizeof(char)*0));
+  clos2048->num_args = 1;
+  clos2048->func = &func2047;
+  clos2048->apply_func = &apply_func22052;
+  clos2048->str = NULL;
+  clos2048->args[0] = (void*)halt;
+  ((fp_typedef2025)(rv2009->apply_func))(rv2009,clos2046,clos2048);
+}
+  void func2047(clos* rv2007, clos* halt) {
+  clos* clos2050 = alloca(sizeof(clos)+(sizeof(clos*)*0)+(sizeof(char)*16));
+  clos2050->num_args = 0;
+  clos2050->func = &func2049;
+  clos2050->apply_func = &apply_func22038;
+  clos2050->str = "(LAMBDA (C2) C2)";
+  ((fp_typedef2025)(rv2007->apply_func))(rv2007,clos2050,halt);
+  }
+  void func2049(clos* C2, clos* k2008) {
+  ((fp_typedef2032)(k2008->apply_func))(k2008,C2);
+  }
+  void func2045(clos* B3, clos* k2010) {
+  ((fp_typedef2032)(k2010->apply_func))(k2010,B3);
+  }
+void func2039(clos* B2, clos* k2015) {
+  clos* clos2042 = alloca(sizeof(clos)+(sizeof(clos*)*1)+(sizeof(char)*16));
+  clos2042->num_args = 1;
+  clos2042->func = &func2041;
+  clos2042->apply_func = &apply_func32035;
+  clos2042->str = "(LAMBDA (C3) B2)";
+  clos2042->args[0] = (void*)B2;
+  ((fp_typedef2032)(k2015->apply_func))(k2015,clos2042);
+}
+  void func2041(clos* C3, clos* k2016, clos* B2) {
+  ((fp_typedef2032)(k2016->apply_func))(k2016,B2);
+  }
+void func2017(clos* A, clos* k2011) {
+  clos* clos2020 = alloca(sizeof(clos)+(sizeof(clos*)*1)+(sizeof(char)*35));
+  clos2020->num_args = 1;
+  clos2020->func = &func2019;
+  clos2020->apply_func = &apply_func32035;
+  clos2020->str = "(LAMBDA (B) (LAMBDA (C) ((A B) C)))";
+  clos2020->args[0] = (void*)A;
+  ((fp_typedef2032)(k2011->apply_func))(k2011,clos2020);
+}
+  void func2019(clos* B, clos* k2012, clos* A) {
+  clos* clos2022 = alloca(sizeof(clos)+(sizeof(clos*)*2)+(sizeof(char)*22));
+  clos2022->num_args = 2;
+  clos2022->func = &func2021;
+  clos2022->apply_func = &apply_func42031;
+  clos2022->str = "(LAMBDA (C) ((A B) C))";
+  clos2022->args[0] = (void*)A;
+  clos2022->args[1] = (void*)B;
+  ((fp_typedef2032)(k2012->apply_func))(k2012,clos2022);
+  }
+  void func2021(clos* C, clos* k2013, clos* A, clos* B) {
+  clos* clos2024 = alloca(sizeof(clos)+(sizeof(clos*)*2)+(sizeof(char)*0));
+  clos2024->num_args = 2;
+  clos2024->func = &func2023;
+  clos2024->apply_func = &apply_func32027;
+  clos2024->str = NULL;
+  clos2024->args[0] = (void*)k2013;
+  clos2024->args[1] = (void*)C;
+  ((fp_typedef2025)(A->apply_func))(A,B,clos2024);
+  }
+  void func2023(clos* rv2014, clos* k2013, clos* C) {
+  ((fp_typedef2025)(rv2014->apply_func))(rv2014,C,k2013);
+  }
+
+int main() { 
+  clos* clos2040 = alloca(sizeof(clos)+(sizeof(clos*)*0)+(sizeof(char)*30));
+  clos2040->num_args = 0;
+  clos2040->func = &func2039;
+  clos2040->apply_func = &apply_func22038;
+  clos2040->str = "(LAMBDA (B2) (LAMBDA (C3) B2))";
+  clos* clos2044 = alloca(sizeof(clos)+(sizeof(clos*)*1)+(sizeof(char)*0));
+  clos2044->num_args = 1;
+  clos2044->func = &func2043;
+  clos2044->apply_func = &apply_func22052;
+  clos2044->str = NULL;
+  clos2044->args[0] = (void*)halt;
+  clos* clos2018 = alloca(sizeof(clos)+(sizeof(clos*)*0)+(sizeof(char)*48));
+  clos2018->num_args = 0;
+  clos2018->func = &func2017;
+  clos2018->apply_func = &apply_func22038;
+  clos2018->str = "(LAMBDA (A) (LAMBDA (B) (LAMBDA (C) ((A B) C))))";
+  ((fp_typedef2025)(clos2018->apply_func))(clos2018,clos2040,clos2044);
+  return 0;
+}