You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
99 lines
3.2 KiB
99 lines
3.2 KiB
/* Takes an AST and converts all of the functions into closures.
|
|
* A closure is a triple of:
|
|
* a mapping from names to expressions
|
|
* a mapping from names to type expressions
|
|
* a function (which includes the formal parameters and the body)
|
|
* The closure has the property that all of the free variables of the function
|
|
* are in the environment, or an exception is raised because the variable is not bound
|
|
* in the current environment.
|
|
* A free variable is simply those that are not in the list of formal parameters.
|
|
* We start with the global environment and traverse the AST. Every time a new function is entered
|
|
* the current environment gets extended with the formal parameters of the function.
|
|
* When a let is encountered the current environment also gets extended.
|
|
* The algorithm continues for any further function definitions in that branch
|
|
* otherwise it just stops for that particular branch and continues with the rest of the AST
|
|
*
|
|
* Therefore in order to call a closure one must first extract the actual function and then
|
|
* call the function with the environment associated with it.
|
|
* For the purposes of type checking it does not matter how the function gets called, the environment
|
|
* is only used for looking up the types of names. Formal parameters are given type variables.
|
|
*/
|
|
|
|
var rep = require("./representation.js");
|
|
var env = require("./environments.js");
|
|
var errors = require("./errors.js");
|
|
var parser = require("./parse.js");
|
|
var pprint = require("./pprint.js");
|
|
var tool = require("./tools.js");
|
|
|
|
/*function convert(stx, cur_types, cur_exprs) {
|
|
switch (stx.exprType) {
|
|
case "If":
|
|
case "Definition":
|
|
case "Name":
|
|
case "Application":
|
|
case "Function":
|
|
case "Let":
|
|
default:
|
|
return stx;
|
|
}
|
|
}*/
|
|
|
|
function fvs(stx) {
|
|
/*if (stx.exprType !== "Function" &&
|
|
stx.exprType !== "Let") {
|
|
throw errors.JInternalError(
|
|
["Tried to calculate the free variables of",
|
|
"something that was not a function or let.\n",
|
|
"That something was a: " + stx.exprType +"\n"].reduce(
|
|
function (a,b) {
|
|
return a+" "+b
|
|
}, ""));
|
|
}*/
|
|
|
|
switch (stx.exprType) {
|
|
case "Integer":
|
|
return [];
|
|
case "Float":
|
|
return [];
|
|
case "String":
|
|
return [];
|
|
case "Function":
|
|
return [];
|
|
case "Nil":
|
|
return [];
|
|
case "List":
|
|
return [];
|
|
case "Bool":
|
|
return [];
|
|
case "FunctionDefinition":
|
|
return [];
|
|
case "Let":
|
|
return stx.pairs.map(fvs);
|
|
case "Unary":
|
|
return fvs(stx.val);
|
|
case "Definition":
|
|
return [fvs(stx.val)];
|
|
case "Application":
|
|
var vs = fvs(stx.p);
|
|
var f_fvs = fvs(stx.func);
|
|
return [].concat.apply([], [vs, f_fvs]);
|
|
case "If":
|
|
if (stx.elseexp) {
|
|
var cond_fvs = fvs(stx.condition);
|
|
var then_fvs = fvs(stx.thenexp);
|
|
var else_fvs = fvs(stx.elseexp);
|
|
return [cond_fvs, then_fvs, else_fvs];
|
|
}
|
|
else {
|
|
return [fvs(stx.condition)] + [fvs(stx.thenexp)];
|
|
}
|
|
case "Name":
|
|
return stx.ident;
|
|
}
|
|
}
|
|
|
|
var ast = parser.parse("(^ wat (a+(ar*b*c^twerp+\"sdfdsfsdfsdfsdf\")*rt))")[0];
|
|
console.log(pprint.pprint(ast));
|
|
console.log(tool.unique(fvs(ast)));
|
|
//console.log(ast);
|
|
|