suzanne.soy/whalesong
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

jslint on structs

Browse Source
This commit is contained in:
Danny Yoo 2011-08-07 21:53:02 -04:00
parent 7d89299827
commit d6cf8236e2
1 changed files with 151 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

358
js-assembler/runtime-src/baselib-structs.js
View File

@ -1,45 +1,102 @@
// Structure types /*jslint browser: true, unparam: true, vars: true, white: true, nomen: true, plusplus: true, maxerr: 50, indent: 4 */
/*globals $*/
(function(baselib) { (function (baselib) {
"use strict";
var exports = {}; var exports = {};
baselib.structs = exports; baselib.structs = exports;
//////////////////////////////////////////////////////////////////////
var Struct = function (constructorName, fields) {
this._constructorName = constructorName;
this._fields = [];
};
Struct.prototype.toWrittenString = function (cache) {
var buffer = [], i;
cache.put(this, true);
buffer.push("(");
buffer.push(this._constructorName);
for(i = 0; i < this._fields.length; i++) {
buffer.push(" ");
buffer.push(baselib.format.toWrittenString(this._fields[i], cache));
}
buffer.push(")");
return buffer.join("");
};
var StructType = function(name, // string Struct.prototype.toDisplayedString = function (cache) {
type, // StructType return baselib.format.toWrittenString(this, cache);
numberOfArgs, // number };
numberOfFields, // number
firstField,
applyGuard,
constructor,
predicate,
accessor,
mutator) {
this.name = name;
this.type = type;
this.numberOfArgs = numberOfArgs;
this.numberOfFields = numberOfFields;
this.firstField = firstField;
this.applyGuard = applyGuard; Struct.prototype.toDomNode = function (params) {
this.constructor = constructor; var node = document.createElement("span"), i;
this.predicate = predicate; params.put(this, true);
this.accessor = accessor; $(node).append(document.createTextNode("("));
this.mutator = mutator; $(node).append(document.createTextNode(this._constructorName));
for(i = 0; i < this._fields.length; i++) {
$(node).append(document.createTextNode(" "));
$(node).append(baselib.format.toDomNode(this._fields[i], params));
}
$(node).append(document.createTextNode(")"));
return node;
}; };
StructType.prototype.toString = function(cache) { Struct.prototype.equals = function (other, aUnionFind) {
return '#<struct-type:' + this.name + '>'; var i;
if (!(other instanceof this.type)) {
return false;
}
for (i = 0; i < this._fields.length; i++) {
if (! baselib.equality.equals(this._fields[i],
other._fields[i],
aUnionFind)) {
return false;
}
}
return true;
};
Struct.prototype.type = Struct;
//////////////////////////////////////////////////////////////////////
var StructType = function (name, // string
type, // StructType
numberOfArgs, // number
numberOfFields, // number
firstField,
applyGuard,
constructor,
predicate,
accessor,
mutator) {
this.name = name;
this.type = type;
this.numberOfArgs = numberOfArgs;
this.numberOfFields = numberOfFields;
this.firstField = firstField;
this.applyGuard = applyGuard;
this.constructor = constructor;
this.predicate = predicate;
this.accessor = accessor;
this.mutator = mutator;
}; };
StructType.prototype.equals = function(other, aUnionFind) { StructType.prototype.toString = function (cache) {
return this === other; return '#<struct-type:' + this.name + '>';
};
StructType.prototype.equals = function (other, aUnionFind) {
return this === other;
}; };
@ -52,17 +109,34 @@
// Default structure guard just calls the continuation argument.
var DEFAULT_GUARD = function (args, name, k) {
return k(args);
};
// The default parent type refers to the toplevel Struct.
var DEFAULT_PARENT_TYPE = { type: Struct,
numberOfArgs: 0,
numberOfFields: 0,
firstField: 0,
applyGuard: DEFAULT_GUARD };
// makeStructureType: string StructType number number boolean // makeStructureType: string StructType number number boolean
// guard-function -> StructType // guard-function -> StructType
// //
// Creates a new structure type. // Creates a new structure type.
var makeStructureType = function(theName, var makeStructureType = function (theName,
parentType, parentType,
initFieldCnt, initFieldCnt,
autoFieldCnt, autoFieldCnt,
autoV, autoV,
guard) { guard) {
// Defaults // Defaults
autoFieldCnt = autoFieldCnt || 0; autoFieldCnt = autoFieldCnt || 0;
parentType = parentType || DEFAULT_PARENT_TYPE; parentType = parentType || DEFAULT_PARENT_TYPE;
@ -70,66 +144,67 @@
// rawConstructor creates a new struct type inheriting from // RawConstructor creates a new struct type inheriting from
// the parent, with no guard checks. // the parent, with no guard checks.
var rawConstructor = function(name, args) { var RawConstructor = function (name, args) {
parentType.type.call(this, name, args); var i;
for (var i = 0; i < initFieldCnt; i++) { parentType.type.call(this, name, args);
this._fields.push(args[i+parentType.numberOfArgs]); for (i = 0; i < initFieldCnt; i++) {
} this._fields.push(args[i+parentType.numberOfArgs]);
for (var i = 0; i < autoFieldCnt; i++) { }
this._fields.push(autoV); for (i = 0; i < autoFieldCnt; i++) {
} this._fields.push(autoV);
}
}; };
rawConstructor.prototype = baselib.heir(parentType.type.prototype); RawConstructor.prototype = baselib.heir(parentType.type.prototype);
// Set type, necessary for equality checking // Set type, necessary for equality checking
rawConstructor.prototype.type = rawConstructor; RawConstructor.prototype.type = RawConstructor;
// The structure type consists of the name, its constructor, a // The structure type consists of the name, its constructor, a
// record of how many argument it and its parent type contains, // record of how many argument it and its parent type contains,
// the list of autofields, the guard, and functions corresponding // the list of autofields, the guard, and functions corresponding
// to the constructor, the predicate, the accessor, and mutators. // to the constructor, the predicate, the accessor, and mutators.
var newType = new StructType( var newType = new StructType(
theName, theName,
rawConstructor, RawConstructor,
initFieldCnt + parentType.numberOfArgs, initFieldCnt + parentType.numberOfArgs,
initFieldCnt + autoFieldCnt, initFieldCnt + autoFieldCnt,
parentType.firstField + parentType.numberOfFields, parentType.firstField + parentType.numberOfFields,
function(args, name, k) { function (args, name, k) {
return guard(args, name, return guard(args, name,
function(result) { function (result) {
var parentArgs = result.slice(0, parentType.numberOfArgs); var parentArgs = result.slice(0, parentType.numberOfArgs);
var restArgs = result.slice(parentType.numberOfArgs); var restArgs = result.slice(parentType.numberOfArgs);
return parentType.applyGuard( return parentType.applyGuard(
parentArgs, name, parentArgs, name,
function(parentRes) { function (parentRes) {
return k( parentRes.concat(restArgs) ); }); return k( parentRes.concat(restArgs) ); });
}); });
}, },
// constructor // constructor
function() { function () {
var args = [].slice.call(arguments); var args = [].slice.call(arguments);
return newType.applyGuard( return newType.applyGuard(
args, args,
baselib.symbols.Symbol.makeInstance(theName), baselib.symbols.Symbol.makeInstance(theName),
function(res) { function (res) {
return new rawConstructor(theName, res); }); return new RawConstructor(theName, res); });
}, },
// predicate // predicate
function(x) { function (x) {
return x instanceof rawConstructor; return x instanceof RawConstructor;
}, },
// accessor // accessor
function(x, i) { return x._fields[i + this.firstField]; }, function (x, i) { return x._fields[i + this.firstField]; },
// mutator // mutator
function(x, i, v) { x._fields[i + this.firstField] = v; }); function (x, i, v) { x._fields[i + this.firstField] = v; });
return newType; return newType;
}; };
@ -137,129 +212,10 @@
//////////////////////////////////////////////////////////////////////
var isStruct = function (x) { return x instanceof Struct; };
var Struct = function(constructorName, fields) { var isStructType = function (x) { return x instanceof StructType; };
this._constructorName = constructorName;
this._fields = [];
};
Struct.prototype.toWrittenString = function(cache) {
cache.put(this, true);
var buffer = [];
buffer.push("(");
buffer.push(this._constructorName);
for(var i = 0; i < this._fields.length; i++) {
buffer.push(" ");
buffer.push(plt.baselib.format.toWrittenString(this._fields[i], cache));
}
buffer.push(")");
return buffer.join("");
};
Struct.prototype.toDisplayedString = function(cache) {
return plt.baselib.format.toWrittenString(this, cache);
};
Struct.prototype.toDomNode = function(params) {
params.put(this, true);
var node = document.createElement("span");
$(node).append(document.createTextNode("("));
$(node).append(document.createTextNode(this._constructorName));
for(var i = 0; i < this._fields.length; i++) {
$(node).append(document.createTextNode(" "));
$(node).append(plt.baselib.format.toDomNode(this._fields[i], params));
}
$(node).append(document.createTextNode(")"));
return node;
};
Struct.prototype.equals = function(other, aUnionFind) {
if ( other.type == undefined ||
this.type !== other.type ||
!(other instanceof this.type) ) {
return false;
}
for (var i = 0; i < this._fields.length; i++) {
if (! equals(this._fields[i],
other._fields[i],
aUnionFind)) {
return false;
}
}
return true;
}
Struct.prototype.type = Struct;
// // Struct Procedure types
// var StructProc = function(type, name, numParams, isRest, usesState, impl) {
// PrimProc.call(this, name, numParams, isRest, usesState, impl);
// this.type = type;
// };
// StructProc.prototype = baselib.heir(PrimProc.prototype);
// var StructConstructorProc = function() {
// StructProc.apply(this, arguments);
// };
// StructConstructorProc.prototype = baselib.heir(StructProc.prototype);
// var StructPredicateProc = function() {
// StructProc.apply(this, arguments);
// };
// StructPredicateProc.prototype = baselib.heir(StructProc.prototype);
// var StructAccessorProc = function() {
// StructProc.apply(this, arguments);
// };
// StructAccessorProc.prototype = baselib.heir(StructProc.prototype);
// var StructMutatorProc = function() {
// StructProc.apply(this, arguments);
// };
// StructMutatorProc.prototype = baselib.heir(StructProc.prototype);
// Default structure guard just calls the continuation argument.
var DEFAULT_GUARD = function(args, name, k) {
return k(args);
};
// The default parent type refers to the toplevel Struct.
var DEFAULT_PARENT_TYPE = { type: Struct,
numberOfArgs: 0,
numberOfFields: 0,
firstField: 0,
applyGuard: DEFAULT_GUARD };
var isStruct = function(x) { return x instanceof Struct; };
var isStructType = function(x) { return x instanceof StructType; };
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
@ -271,16 +227,4 @@
exports.isStruct = isStruct; exports.isStruct = isStruct;
exports.isStructType = isStructType; exports.isStructType = isStructType;
// exports.StructProc = StructProc; }(this.plt.baselib));
// exports.StructConstructorProc = StructConstructorProc;
// exports.StructPredicateProc = StructPredicateProc;
// exports.StructAccessorProc = StructAccessorProc;
// exports.StructMutatorProc = StructMutatorProc;
})(this['plt'].baselib);