Merge branch 'master' into flatdecl

Author: rachitnigam

src/callcc/fudgeRuntime.ts

@@ -0,0 +1,62 @@
+import * as common from './runtime';
+export * from './runtime';
+
+class FudgedContinuationError {
+  
+  constructor(public v: any) { }
+
+  toString() {
+    return `FudgedContinuationError(${this.v})`;
+  }  
+
+}
+
+/** This runtime system doesn't actually implement any control operators.
+ * Functions such as 'captureCC' are defined and will call their argument, 
+ * but don't save the stack.
+ * 
+ * Unfortunately, all our program end by invoking the top continuation with
+ * "done". Therefore, a program that runs correctly will terminate with
+ * 'FudgedContinuationError(done)'. This is unfortunate. But, this
+ * transformation still helps with debugging.
+ */
+export class FudgeRuntime extends common.Runtime {
+  constructor() {
+    super();
+  }
+
+  captureCC(f: (k: any) => any): void {
+    throw new common.Capture(f, []);
+  }
+
+  abortCC(f: () => any) {
+    throw new common.Discard(f);
+  }
+
+  makeCont(stack: common.Stack) {
+    return (v: any) => {
+      throw new FudgedContinuationError(v);
+    };
+  }
+
+  runtime(body: () => any): any {
+    try {
+      body();
+    }
+    catch (exn) {
+      if (exn instanceof common.Capture) {
+        return this.runtime(() => exn.f.call(global, this.makeCont(exn.stack)));
+      } else if (exn instanceof common.Discard) {
+        return this.runtime(() => exn.f());
+      } else {
+        throw exn; // userland exception
+      }
+    }
+  }
+
+  handleNew(constr: any, ...args: any[]) {
+    return new constr(...args);
+  }
+}
+
+export default FudgeRuntime;

src/callcc/jumper.ts

@@ -12,7 +12,7 @@ type Labeled<T> = T & {
 }
 type CaptureFun = (path: NodePath<t.AssignmentExpression>) => void;
 
-export type CaptureLogic = 'lazy' | 'eager' | 'retval';
+export type CaptureLogic = 'lazy' | 'eager' | 'retval' | 'fudge';
 
 interface State {
   opts: {
@@ -24,6 +24,7 @@ const captureLogics: { [key: string]: CaptureFun } = {
   lazy: lazyCaptureLogic,
   eager: eagerCaptureLogic,
   retval: retvalCaptureLogic,
+  fudge: fudgeCaptureLogic,
 };
 
 function split<T>(arr: T[], index: number): { pre: T[], post: T[] } {
@@ -175,6 +176,10 @@ function reapplyExpr(path: NodePath<Labeled<t.Function>>): t.Expression {
   }
 }
 
+function fudgeCaptureLogic(path: NodePath<t.AssignmentExpression>): void {
+  return;
+}
+
 /**
  * Wrap callsites in try/catch block, lazily building the stack on catching a
  * Capture exception, then rethrowing.

src/compile.ts

@@ -16,7 +16,7 @@ const srcPath = args._[0];
 const dstPath = args._[1];
 const transform = args.transform;
 
-const validTransforms = [ 'eager', 'lazy', 'retval', 'original' ];
+const validTransforms = [ 'eager', 'lazy', 'retval', 'original', 'fudge' ];
 if (validTransforms.includes(transform) === false) {
   stderr.write(`--transform must be one of ${validTransforms.join(', ')}, got ${transform}.\n`);
   process.exit(1);

src/rts.ts

@@ -4,6 +4,7 @@ import { Runtime, YieldInterval, Latency } from './callcc/runtime';
 import eager from './callcc/eagerRuntime';
 import lazy from './callcc/lazyRuntime';
 import retval from './callcc/retvalRuntime';
+import fudge from './callcc/fudgeRuntime';
 
 function modeToBase(mode: string) {
  if (mode === 'eager') {
@@ -15,6 +16,9 @@ function modeToBase(mode: string) {
   else if (mode === 'retval') {
     return retval;
   }
+  else if (mode === 'fudge') {
+    return fudge;
+  }
   else {
     throw new Error(`unknown runtime system mode: ${mode}`);
   }