748 lines
18 KiB
JavaScript
Executable File
748 lines
18 KiB
JavaScript
Executable File
// the internal primitive mechanism
|
|
primitive = new Primitives();
|
|
|
|
// core definitions needed to make anything work, even what follows
|
|
Object = primitive("NewObject");
|
|
var local_function = primitive("NewFunction");
|
|
Function = local_function;
|
|
var local_array = primitive("NewArray");
|
|
Array = local_array;
|
|
var local_string = primitive("NewString");
|
|
String = local_string;
|
|
var local_number = primitive("NewNumber");
|
|
Number = local_number;
|
|
var local_regexp = primitive("NewRegExp");
|
|
RegExp = local_regexp;
|
|
|
|
/************************************************************************/
|
|
/* Global properties, see spec 15.1 */
|
|
/************************************************************************/
|
|
NaN = primitive("GlobalNaN");
|
|
|
|
Infinity = primitive("GlobalInfinity");
|
|
|
|
undefined = primitive("NewUndefined");
|
|
$$undefined = undefined;
|
|
|
|
eval = function eval (x) {
|
|
return primitive("GlobalEval", x);
|
|
};
|
|
|
|
parseInt = function parseInt (string, radix) {
|
|
return primitive("GlobalParseInt", string, radix);
|
|
};
|
|
|
|
parseFloat = function parseFloat (string) {
|
|
return primitive("GlobalParseFloat", string);
|
|
};
|
|
|
|
isNaN = function isNaN (number) {
|
|
return primitive("GlobalIsNaN", number)
|
|
};
|
|
|
|
isFinite = function isFinite (number) {
|
|
return primitive("GlobalIsFinite", number);
|
|
};
|
|
|
|
decodeURI = function decodeURI(str) {
|
|
return new String(primitive("GlobalDecodeURI", str));
|
|
};
|
|
|
|
decodeURIComponent = function decodeURIComponent(str) {
|
|
return new String(primitive("GlobalDecodeURIComponent", str));
|
|
};
|
|
|
|
encodeURI = function encodeURI(str) {
|
|
return new String(primitive("GlobalEncodeURI", str));
|
|
};
|
|
|
|
encodeURIComponent = function encodeURIComponent(str) {
|
|
return new String(primitive("GlobalEncodeURIComponent", str));
|
|
};
|
|
|
|
unescape = function unescape(str){
|
|
return new String(primitive("GlobalUnEscape", str));
|
|
};
|
|
|
|
escape = function escape(str){
|
|
return new String(primitive("GlobalEscape", str));
|
|
};
|
|
|
|
/************************************************************************/
|
|
/* Object properties, see spec 15.2 */
|
|
/************************************************************************/
|
|
|
|
Object$proto$__WALA__ = {
|
|
|
|
prototype: null,
|
|
|
|
__proto__: null,
|
|
|
|
constructor: Object,
|
|
|
|
toString: function Object_prototype_toString() {
|
|
return primitive("ObjectToString", this);
|
|
},
|
|
|
|
toLocaleString: function Object_prototype_toLocaleString() {
|
|
return primitive("ObjectToLocaleString", this);
|
|
},
|
|
|
|
valueOf: function valueOf() { return this },
|
|
|
|
hasOwnProperty: function Object_prototype_hasOwnProperty (V) {
|
|
return primitive("ObjectHasOwnProperty", this, V);
|
|
},
|
|
|
|
isPrototypeOf: function Object_prototype_isPrototypeOf (V) {
|
|
return primitive("ObjectIsPrototypeOf", this, V);
|
|
},
|
|
|
|
propertyIsEnumerable: function Object_prototype_propertyIsEnumerable (V) {
|
|
return primitive("ObjectPropertyIsEnumerable", this, V);
|
|
}
|
|
};
|
|
|
|
Object.prototype = Object$proto$__WALA__;
|
|
|
|
/************************************************************************/
|
|
/* Function properties, see spec 15.3 */
|
|
/************************************************************************/
|
|
|
|
Function$proto$__WALA__ = {
|
|
|
|
constructor: Function,
|
|
|
|
__proto__: Object.prototype,
|
|
|
|
toString: function Function_prototype_toString() {
|
|
return primitive("FunctionToString", this);
|
|
},
|
|
|
|
apply: function Function_prototype_apply (thisArg, argArray) {
|
|
return primitive("FunctionApply", this, thisArg, argArray);
|
|
},
|
|
|
|
call: function Function_prototype_call (thisArg) {
|
|
arguments.shift();
|
|
return primitive("FunctionCall", this, thisArg, arguments);
|
|
},
|
|
|
|
bind: function Function_prototype_bind (thisArg) {
|
|
arguments.shift();
|
|
return primitive("FunctionBind", this, thisArg, arguments);
|
|
}
|
|
};
|
|
|
|
local_function.prototype = Function$proto$__WALA__;
|
|
|
|
local_function.__proto__ = Function.prototype;
|
|
|
|
/************************************************************************/
|
|
/* Array properties, see spec 15.4 */
|
|
/************************************************************************/
|
|
|
|
local_array.__proto__ = Function.prototype;
|
|
|
|
Array$proto$__WALA__ = {
|
|
|
|
__proto__: Object.prototype,
|
|
|
|
constructor: Array,
|
|
|
|
toString: function Array_prototype_toString () {
|
|
return this.join(",");
|
|
},
|
|
|
|
toLocaleString: function Array_prototype_toLocaleString () {
|
|
var result = "";
|
|
var limit = this.length;
|
|
for(var k = 0; k < limit; k++) {
|
|
result = result.concat( this[k].toLocaleString() );
|
|
result = result.concat( "," );
|
|
}
|
|
|
|
return result;
|
|
},
|
|
|
|
concat: function Array_prototype_concat () {
|
|
var result = new Array();
|
|
var n = 0;
|
|
|
|
for(var i = 0; i < this.length; i++)
|
|
result[n++] = this[i];
|
|
|
|
for(i = 0; i < arguments.length; i++)
|
|
for(var j = 0; j < arguments[i].length; j++)
|
|
result[n++] = arguments[i][j];
|
|
|
|
result.length = n;
|
|
|
|
return result;
|
|
},
|
|
|
|
join: function Array_prototype_join (separator) {
|
|
var result = "";
|
|
var limit = this.length;
|
|
for(var k = 0; k < limit; k++) {
|
|
result = result.concat( this[k].toString() );
|
|
result = result.concat( separator );
|
|
}
|
|
|
|
return result;
|
|
},
|
|
|
|
pop: function Array_prototype_pop () {
|
|
var n0 = this.length;
|
|
if (n0) {
|
|
var n1 = this[n0-1];
|
|
this.length = n0-1;
|
|
// needed for non-arrays
|
|
delete this[n0-1];
|
|
return n1;
|
|
} else {
|
|
// needed for non-arrays
|
|
this.length = 0;
|
|
}
|
|
},
|
|
|
|
push: function Array_prototype_push () {
|
|
var n = this.length;
|
|
|
|
// nasty hack for field-sensitive builders
|
|
// TODO: fix this somehow
|
|
if (n == 0) {
|
|
this[0] = arguments[0];
|
|
}
|
|
|
|
for(var i = 0; i < arguments.length; i++) {
|
|
this[ n++ ] = arguments[i];
|
|
}
|
|
|
|
this.length = n;
|
|
return n;
|
|
},
|
|
|
|
reverse: function Array_prototype_reverse () {
|
|
var n = this.length;
|
|
for (var k = 0; k < (n/2); k++) {
|
|
var tmp = this[k];
|
|
this[k] = this[n-k];
|
|
this[n-k] = tmp;
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
shift: function Array_prototype_shift () {
|
|
var result = this[ 0 ];
|
|
for(var i = 0; i < this.length-1; i++)
|
|
this[i] = this[i+1];
|
|
|
|
this.length--;
|
|
|
|
return result;
|
|
},
|
|
|
|
unshift: function Array_prototype_unshift () {
|
|
var n = arguments.length;
|
|
for(var i=this.length+n-1;i>=n;--i)
|
|
this[i] = this[i-n];
|
|
for(;i>=0;--i)
|
|
this[i] = arguments[i];
|
|
this.length += n;
|
|
return this.length;
|
|
},
|
|
|
|
slice: function Array_prototype_slice (start, end) {
|
|
var j = 0;
|
|
if (start < 0) start = this.length + start;
|
|
if (end < 0) end = this.length + end;
|
|
var result = new Array();
|
|
for(var i = start; i < end; i++)
|
|
result[j++] = this[i];
|
|
|
|
result.length = j;
|
|
|
|
return result;
|
|
},
|
|
|
|
sort: function Array_prototype_sort (fn) {
|
|
for(var l = 0; i < this.length; l++) {
|
|
var mindex = l;
|
|
for(var i = l; i < this.length; i++) {
|
|
if (fn(this[mindex], this[i]) < 0) {
|
|
mindex = i;
|
|
}
|
|
}
|
|
|
|
if (mindex != l) {
|
|
var tmp = this[l];
|
|
this[l] = this[mindex];
|
|
this[mindex] = this[l];
|
|
}
|
|
}
|
|
},
|
|
|
|
splice: function Array_prototype_splice(start, delete_count) {
|
|
var old_len = arguments.length,
|
|
new_count = arguments.length - 2;
|
|
new_len = old_len - deleteCount + new_count;
|
|
|
|
var deleted = this.slice(start, start + delete_count),
|
|
remainder = this.slice(start + delete_count, old_len);
|
|
|
|
for(var i=start;i<start+new_count;++i)
|
|
this[i] = arguments[2+start-i];
|
|
|
|
for(var k=0;k<remainder.length;++k,++i)
|
|
this[i] = remainder[k];
|
|
|
|
for(;i<old_len;++i)
|
|
delete this[i];
|
|
|
|
this.length = new_len;
|
|
|
|
return deleted;
|
|
},
|
|
|
|
indexOf: function Array_prototype_indexOf(elt, start) {
|
|
if(arguments.length < 2)
|
|
start = 0;
|
|
if(start < 0) start += this.length;
|
|
if(start < 0) start = 0;
|
|
for(var i=start;i<this.length;++i)
|
|
if(this[i] === elt)
|
|
return i;
|
|
return -1;
|
|
},
|
|
|
|
forEach: function Array_prototype_forEach(callback, thisArg) {
|
|
for(var i=0;i<this.length;++i)
|
|
callback.call(thisArg, this[i], i, this);
|
|
},
|
|
|
|
map: function Array_prototype_map(callback, thisArg) {
|
|
var res = [];
|
|
for(var i=0;i<this.length;++i)
|
|
res[i] = callback.call(thisArg, this[i], i, this);
|
|
res.length = this.length;
|
|
return res;
|
|
},
|
|
|
|
item: function Array_prototype_item(index) {
|
|
return this[index];
|
|
},
|
|
|
|
every: function Array_prototype_every(arg1, arg2) {
|
|
var n0 = this.length;
|
|
var n3 = true;
|
|
for (var i = 0; i < n0; i += 1) {
|
|
var n1 = i in this;
|
|
if (n1) {
|
|
var n2 = this[i];
|
|
n3 = arg1.call(arg2, n2, i, this);
|
|
if (!n3) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return n3;
|
|
},
|
|
|
|
some: function Array_prototype_some(arg1, arg2) {
|
|
var n0 = this.length;
|
|
var n3 = false;
|
|
for (var i = 0; i < n0; i += 1) {
|
|
var n1 = i in this;
|
|
if (n1) {
|
|
var n2 = this[i];
|
|
n3 = arg1.call(arg2, n2, i, this);
|
|
if (n3) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return n3;
|
|
},
|
|
|
|
reduce: function Array_prototype_reduce(arg1, arg2) {
|
|
var result = arg2;
|
|
var n0 = this.length;
|
|
for (var i = 0; i < n0; i += 1) {
|
|
var n1 = i in this;
|
|
if (n1) {
|
|
var n2 = this[i];
|
|
var n3 = arg1.call(undefined, result, n2, i, this);
|
|
result = n3;
|
|
}
|
|
}
|
|
return result;
|
|
},
|
|
|
|
reduceRight: function Array_prototype_reduceRight(arg1, arg2) {
|
|
var result = arg2;
|
|
var n0 = this.length;
|
|
for (var i = 0; i < n0; i += 1) {
|
|
var n1 = ((n0-i)-1) in this;
|
|
if (n1) {
|
|
var n2 = this[(n0-i)-1];
|
|
var n3 = arg1.call(undefined, result, n2, (n0-i)-1, this);
|
|
result = n3;
|
|
}
|
|
}
|
|
return result;
|
|
},
|
|
|
|
filter: function Array_prototype_filter(arg1, arg2) {
|
|
var result = [];
|
|
var n0 = this.length;
|
|
for (var i = 0; i < n0; i += 1) {
|
|
var n1 = i in this;
|
|
if (n1) {
|
|
var n2 = this[i];
|
|
var n3 = arg1.call(arg2, n2, i, this);
|
|
if (n3) {
|
|
result[result.length] = n2;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
};
|
|
|
|
Array.isArray = function Array_isArray(a) {
|
|
return true || false;
|
|
};
|
|
|
|
local_array.prototype = Array$proto$__WALA__;
|
|
|
|
/************************************************************************/
|
|
/* String properties, see spec 15.4 */
|
|
/************************************************************************/
|
|
|
|
local_string.__proto__ = Function.prototype;
|
|
|
|
String$proto$__WALA__ = {
|
|
|
|
__proto__: Object.prototype,
|
|
|
|
constructor: String,
|
|
|
|
$value: "",
|
|
|
|
toString: function String_prototype_toString() {
|
|
return this.$value;
|
|
},
|
|
|
|
valueOf: function stringValueOf() {
|
|
return this.$value;
|
|
},
|
|
|
|
charAt: function String_prototype_charAt(pos) {
|
|
return new String(primitive("StringCharAt", pos));
|
|
},
|
|
|
|
charCodeAt: function String_prototype_charCodeAt(pos) {
|
|
return new Number(primitive("StringCharCodeAt", pos));
|
|
},
|
|
|
|
concat: function String_prototype_concat () {
|
|
var result = this;
|
|
|
|
for(i = 0; i < arguments.length; i++)
|
|
result = result + arguments[i];
|
|
|
|
return result;
|
|
},
|
|
|
|
toUpperCase: function String_prototype_toUpperCase() {
|
|
return new String(primitive("StringToUpperCase", this));
|
|
},
|
|
|
|
toLocaleUpperCase: function String_prototype_toLocaleUpperCase() {
|
|
return new String(primitive("StringToLocaleUpperCase", this));
|
|
},
|
|
|
|
toLowerCase: function String_prototype_toLowerCase() {
|
|
return new String(primitive("StringToLowerCase", this));
|
|
},
|
|
|
|
toLocaleLowerCase: function String_prototype_toLocaleLowerCase() {
|
|
return new String(primitive("StringToLocaleLowerCase", this));
|
|
},
|
|
|
|
indexOf: function String_prototype_indexOf(str) {
|
|
return new Number(primitive("StringIndexOf", this, str));
|
|
},
|
|
|
|
split: function String_prototype_split(separator, limit) {
|
|
var y = primitive("splitCount", this, separator, limit);
|
|
var x = new Array(y);
|
|
for(var i = 0; i < y; i++) {
|
|
x[i] = new String( primitive("splitNth", this, separator, limit, i) );
|
|
}
|
|
return x;
|
|
},
|
|
|
|
substring: function String_prototype_substring(from, to) {
|
|
return new String(primitive("StringSubString", this, from, to));
|
|
},
|
|
|
|
slice: function String_prototype_slice(from, to) {
|
|
if(from < 0) from += this.length;
|
|
if(to < 0) to += this.length;
|
|
return this.substring(from, to);
|
|
},
|
|
|
|
substr: function String_prototype_substr(from, to) {
|
|
return new String(primitive("StringSubStr", this, from, to));
|
|
},
|
|
|
|
replace: function String_prototype_replace(regex, withStr) {
|
|
// return new String(primitive("StringReplace", this, regex, withStr));
|
|
return this || withStr;
|
|
},
|
|
|
|
match: function String_prototype_match(regexp) {
|
|
return new Array(primitive("StringMatch", this, regexp));
|
|
},
|
|
|
|
trim: function String_prototype_trim() {
|
|
return new String(primitive("StringTrim", this));
|
|
},
|
|
|
|
loadFile: function loadFile() {
|
|
// magic function body handled in analysis.
|
|
},
|
|
|
|
link: function String_prototype_link(url) {
|
|
},
|
|
|
|
anchor: function String_prototype_anchor(url) {
|
|
return new String();
|
|
}
|
|
|
|
};
|
|
|
|
local_string.prototype = String$proto$__WALA__;
|
|
|
|
/************************************************************************/
|
|
/* Number properties, see spec 15.7 */
|
|
/************************************************************************/
|
|
|
|
local_number.__proto__ = Function.prototype;
|
|
|
|
Number$proto$__WALA__ = {
|
|
|
|
__proto__: Object.prototype,
|
|
|
|
constructor: Number,
|
|
|
|
$value: 0,
|
|
|
|
toString: function Number_prototype_toString() {
|
|
return primitive("NumberToString", this);
|
|
}
|
|
|
|
};
|
|
|
|
local_number.prototype = Number$proto$__WALA__;
|
|
|
|
/************************************************************************/
|
|
/* Math properties, see spec 15.8 */
|
|
/************************************************************************/
|
|
Math = {
|
|
|
|
E: primitive("MathE"),
|
|
|
|
LN10: primitive("MathLN10"),
|
|
|
|
LN2: primitive("MathLN2"),
|
|
|
|
LOG2E: primitive("MathLOG2E"),
|
|
|
|
LOG10E: primitive("MathLOG10E"),
|
|
|
|
PI: primitive("PI"),
|
|
|
|
SQRT1_2: primitive("MathSQRT1_2"),
|
|
|
|
SQRT2: primitive("MathSQRT2"),
|
|
|
|
abs: function Math_abs (x) { return (x<0)? -x: x; },
|
|
|
|
acos: function Math_acos (x) { return primitive("MathACos", x); },
|
|
|
|
asin: function Math_asin (x) { return primitive("MathASin", x); },
|
|
|
|
atan: function Math_atan (x) { return primitive("MathATan", x); },
|
|
|
|
atan2: function Math_atan2 (y, x) { return primitive("MathATan2", y, x); },
|
|
|
|
ceil: function Math_ceil (x) { return primitive("MathCeil", x); },
|
|
|
|
cos: function Math_cos (x) { return primitive("MathCos", x); },
|
|
|
|
exp: function Math_exp (x) { return primitive("MathExp", x); },
|
|
|
|
floor: function Math_floor (x) { return primitive("MathFloor", x); },
|
|
|
|
log: function Math_log (x) { return primitive("MathLog", x); },
|
|
|
|
max: function Math_max () {
|
|
var i = -Infinity;
|
|
for(var j = 0; j < arguments.length; j++)
|
|
if (arguments[j] > i)
|
|
i = arguments[j];
|
|
|
|
return i;
|
|
},
|
|
|
|
min: function Math_min () {
|
|
var i = Infinity;
|
|
for(var j = 0; j < arguments.length; j++)
|
|
if (arguments[j] < i)
|
|
i = arguments[j];
|
|
|
|
return i;
|
|
},
|
|
|
|
pow: function Math_pow (x, y) { return primitive("MathPow", x, y); },
|
|
|
|
random: function Math_random() { return primitive("MathRandom"); },
|
|
|
|
round: function Math_round (x) { return primitive("MathRound", x); },
|
|
|
|
sin: function Math_sin (x) { return primitive("MathSin", x); },
|
|
|
|
sqrt: function Math_sqrt (x) { return primitive("MathSqrt", x);},
|
|
|
|
tan: function Math_tan (x) { return primitive("MathTan", x); }
|
|
};
|
|
|
|
|
|
/************************************************************************/
|
|
/* RegExp properties, see spec 15.10 */
|
|
/************************************************************************/
|
|
|
|
local_regexp.__proto__ = Function.prototype;
|
|
|
|
RegExp$proto$__WALA__ = {
|
|
|
|
__proto__: Object.prototype,
|
|
|
|
constructor: RegExp,
|
|
|
|
exec: function RegExp_prototype_exec(string) {
|
|
return [ string, string, string, string, string ] || null;
|
|
},
|
|
|
|
test: function RegExp_prototype_test(string) {
|
|
return true || false;
|
|
}
|
|
|
|
};
|
|
|
|
local_regexp.prototype = RegExp$proto$__WALA__;
|
|
|
|
/************************************************************************/
|
|
/* Date properties, see spec 15.9 */
|
|
/************************************************************************/
|
|
|
|
Date = function Date() {};
|
|
|
|
Data$proto$__WALA__ = {
|
|
|
|
__proto__: Object.prototype,
|
|
|
|
constructor: Date,
|
|
|
|
getTime: function Date_prototype_getTime() {
|
|
return primitive("DateGetTime", this);
|
|
},
|
|
|
|
getDate: function Date_prototype_getDate() {
|
|
// TODO: model me
|
|
},
|
|
|
|
setDate: function Date_prototype_setDate() {
|
|
// TODO: model me
|
|
},
|
|
|
|
getDay: function Date_prototype_getDay() {
|
|
// TODO: model me
|
|
},
|
|
|
|
setDay: function Date_prototype_setDay() {
|
|
// TODO: model me
|
|
},
|
|
|
|
getMonth: function Date_prototype_getMonth() {
|
|
// TODO: model me
|
|
},
|
|
|
|
setMonth: function Date_prototype_setMonth() {
|
|
// TODO: model me
|
|
},
|
|
|
|
getHours: function Date_prototype_getHours() {
|
|
// TODO: model me
|
|
},
|
|
|
|
setHours: function Date_prototype_setHours() {
|
|
// TODO: model me
|
|
},
|
|
|
|
getMinutes: function Date_prototype_getMinutes() {
|
|
// TODO: model me
|
|
},
|
|
|
|
setMinutes: function Date_prototype_setMinutes() {
|
|
// TODO: model me
|
|
},
|
|
|
|
getSeconds: function Date_prototype_getSeconds() {
|
|
// TODO: model me
|
|
},
|
|
|
|
setSeconds: function Date_prototype_setSeconds() {
|
|
// TODO: model me
|
|
},
|
|
|
|
getMilliseconds: function Date_prototype_getMilliseconds() {
|
|
// TODO: model me
|
|
},
|
|
|
|
setMilliseconds: function Date_prototype_setMilliseconds() {
|
|
// TODO: model me
|
|
},
|
|
|
|
getFullYear: function Date_prototype_getFullYear() {
|
|
// TODO: model me
|
|
}
|
|
|
|
};
|
|
|
|
Date.now = function Date_now() {
|
|
return new Date().valueOf();
|
|
};
|
|
|
|
Date.prototype = Data$proto$__WALA__;
|
|
|
|
|
|
/************************************************************************/
|
|
/* internal stuff
|
|
/************************************************************************/
|
|
|
|
function Error(str) {
|
|
this.message = new String();
|
|
}
|
|
|
|
function EvalError(str) {
|
|
this.message = new String();
|
|
}
|
|
|
|
|