首页 > 代码库 > Concurrent.Thread.js
Concurrent.Thread.js
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Stack module.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data‘;
function Stack ( )
{
this.length = 0;
}
var proto = Stack.prototype;
proto.pop = Array.prototype.pop;
proto.push = Array.prototype.push;
proto.peek = function ( )
{
return this.length > 0
? this[this.length-1]
: undefined;
};
proto.isEmpty = function ( )
{
return this.length == 0;
};
return {
Stack: Stack
};
}();
}
}.call(null) ) {
this.Data.Stack = Stack;
}
}).call(null);
(function(){
with ( function(){
return function () {
var VERSION = ‘0.1.0‘;
var NAMESPACE;
Function.prototype.bind = function ( o ) {
var f = this;
return function ( ) {
return f.apply(o, arguments);
};
};
return {
};
}();
}.call(null) ) {
}
}).call(null);
(function(){
if ( !this.WebBrowser || (typeof this.WebBrowser != ‘object‘ && typeof this.WebBrowser != ‘function‘) ) this.WebBrowser = new Object();
if ( !this.WebBrowser.GUI || (typeof this.WebBrowser.GUI != ‘object‘ && typeof this.WebBrowser.GUI != ‘function‘) ) this.WebBrowser.GUI = new Object();
if ( !this.WebBrowser.GUI.Event || (typeof this.WebBrowser.GUI.Event != ‘object‘ && typeof this.WebBrowser.GUI.Event != ‘function‘) ) this.WebBrowser.GUI.Event = new Object();
if ( this.WebBrowser.GUI.Event.attach === undefined ) this.WebBrowser.GUI.Event.attach = undefined;
if ( this.WebBrowser.GUI.Event.detach === undefined ) this.WebBrowser.GUI.Event.detach = undefined;
with ( function(){
with ( WebBrowser.GUI.Event ) {
return function () {
var VERSION = ‘0.0.0‘;
var NAMESPACE;
NAMESPACE = ‘WebBrowser.GUI.Event‘;
var listener_id = 0;
var registry = {};
attach(window, "unload", function(){
for ( var i in registry ) detach(Number(i));
});
function attach ( element, type, listener, useCapture ) {
if ( !element || typeof element !== "object" ) {
throw new TypeError("argument not a element: " + element);
}
type = String(type);
if ( typeof listener !== "function" ) {
throw new TypeError("argument not a function: " + listener);
}
useCapture = Boolean(useCapture);
function handler ( e ) {
e = e || window.event;
if ( !e.stopPropagation ) { // Sets standard properties for IE
e.target = e.srcElement;
e.currentTarget = this;
e.cancelable = true;
e.stopPropagation = function stopPropagation ( ) {
this.cancelBubble = true;
};
var prevent_default = false;
e.preventDefault = function preventDefault ( ) {
prevent_default = true;
};
}
var ret_val = listener.call(this, e);
return prevent_default ? false : ret_val;
}
if ( element.addEventListener ) {
element.addEventListener(type, handler, useCapture);
} else if ( element.attachEvent ) {
element.attachEvent("on"+type, handler);
} else {
element["on"+type] = handler;
}
var id = listener_id++;
registry[id] = {
element : element,
type : type,
listener : listener,
useCapture: useCapture,
handler : handler
};
return id;
}
function detach ( element, type, listener, useCapture ) {
if ( arguments.length === 1 && typeof element === "number" ) {
if ( !registry[element] ) return false;
var reg = registry[element];
delete registry[element];
return detach_aux(reg.element, reg.type, reg.handler, reg.useCapture);
} else {
if ( !element || typeof element !== "object" ) {
throw new TypeError("argument is not an element: " + element);
}
type = String(type);
if ( typeof listener !== "function" ) {
throw new TypeError("argument is not s function: " + listener);
}
useCapture = Boolean(useCapture);
var ret_val = false;
for ( var i in registry ) {
var reg = registry[i];
if ( reg.element === element
&& reg.type === type
&& reg.listener === listener
&& reg.useCapture === useCapture )
{
delete registry[i];
ret_val = detach_aux(reg.element, reg.type, reg.handler, reg.useCapture) || ret_val;
}
}
return ret_val;
}
};
function detach_aux ( element, type, listener, useCapture ) {
return element.removeEventListener ? element.removeEventListener(type, listener, useCapture) :
element.detachEvent ? element.detachEvent("on"+type, listener) :
delete element["on"+type] ;
}
return {
detach: detach, attach: attach
};
}();
}
}.call(null) ) {
this.WebBrowser.GUI.Event.detach = detach;
this.WebBrowser.GUI.Event.attach = attach;
}
}).call(null);
(function(){
this.GLOBAL = this;
}).call(null);
(function(){
if ( !this.Math || (typeof this.Math != ‘object‘ && typeof this.Math != ‘function‘) ) this.Math = new Object();
if ( this.Math.ToInteger === undefined ) this.Math.ToInteger = undefined;
if ( this.Math.ToInt32 === undefined ) this.Math.ToInt32 = undefined;
if ( this.Math.ToUInt32 === undefined ) this.Math.ToUInt32 = undefined;
if ( this.Math.ToUInt16 === undefined ) this.Math.ToUInt16 = undefined;
with ( function(){
with ( Math ) {
return function () {
var VERSION = ‘0.0.0‘;
var NAMESPACE;
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Math.ToInteger module.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Math‘;
// This module provides functions emulating the integral type
// conversions defined in ECMA-262 3rd.
function ToInteger ( n ) {
return n < 0 ? ceil(n)
: floor(n) || 0;
}
function ToInt32 ( n ) {
return n | 0;
}
function ToUInt32 ( n ) {
return n >>> 0;
}
function ToUInt16 ( n ) {
return n & 0xFFFF;
}
return {
ToUInt16: ToUInt16, ToUInt32: ToUInt32, ToInt32: ToInt32, ToInteger: ToInteger
};
}();
}
}.call(null) ) {
this.Math.ToUInt16 = ToUInt16;
this.Math.ToUInt32 = ToUInt32;
this.Math.ToInt32 = ToInt32;
this.Math.ToInteger = ToInteger;
}
}).call(null);
(function(){
if ( !this.WebBrowser || (typeof this.WebBrowser != ‘object‘ && typeof this.WebBrowser != ‘function‘) ) this.WebBrowser = new Object();
if ( !this.WebBrowser.ScriptExecuter || (typeof this.WebBrowser.ScriptExecuter != ‘object‘ && typeof this.WebBrowser.ScriptExecuter != ‘function‘) ) this.WebBrowser.ScriptExecuter = new Object();
if ( this.WebBrowser.ScriptExecuter.register === undefined ) this.WebBrowser.ScriptExecuter.register = undefined;
if ( this.WebBrowser.ScriptExecuter.exec === undefined ) this.WebBrowser.ScriptExecuter.exec = undefined;
with ( function(){
with ( WebBrowser.ScriptExecuter ) {
return function () {
var VERSION ;
var NAMESPACE;
NAMESPACE = ‘WebBrowser.ScriptExecuter‘;
var executers = {};
var default_type = "text/javascript";
function register ( type, exec ) {
if ( typeof exec != "function" ) throw new TypeError("function required, but got: " + exec);
executers[String(type).toLowerCase()] = exec;
}
function exec ( ) {
var metas = document.getElementsByTagName("META");
for ( var i=0; i < metas.length; i++ ) {
if ( String(metas[i].httpEquiv).match(/^Content-Script-Type$/i) ) {
default_type = metas[i].content;
}
}
var scripts = document.getElementsByTagName("SCRIPT");
for ( var i=0; i < scripts.length; i++ ) {
(function( el ){
setTimeout(function(){ exec_aux(el); }, 0);
})(scripts[i]);
}
}
function exec_aux ( el ) {
var mime = parseMIMEType(el.type ? el.type : default_type);
if ( executers[mime.type] ) {
if ( el.src ) {
var req = createXHR();
req.open("GET", el.src, true);
req.onreadystatechange = function ( ) {
if ( req.readyState == 4 ) rest(req.responseText);
};
req.send(null);
} else {
rest(el.innerHTML);
}
}
function rest ( source ) {
el.parentNode.removeChild(el);
executers[mime.type](source, mime.attr);
}
}
function createXHR ( ) {
try {
return new XMLHttpRequest();
} catch (_){
try {
return new ActiveXObject("Msxml2.XMLHTTP");
} catch (_){
return new ActiveXObject("Microsoft.XMLHTTP");
}
}
}
var NOT_TSPECIAL = ‘[^][()<>@,;:\\\\"/?=\\x00-\\x20]‘;
var TOKEN = "(?:" + NOT_TSPECIAL + "+)";
var MIME_TYPE = "(?:" + TOKEN + "/" + TOKEN + ")";
var QUOTED_STRING = ‘(?:"[^"]*(?:\\\\.[^"]*)*")‘;
var VALUE = "http://www.mamicode.com/(?:" + TOKEN + "|" + QUOTED_STRING + ")";
function parseMIMEType ( text ) {
text = String(text);
var re = new RegExp("^" + MIME_TYPE, "g");
re.lastIndex = 0;
var result = re.exec(text);
if ( !result ) return {type:text.toLowerCase(), attr:{}};
var type = result[0].toLowerCase();
var attr = {};
text = text.substring(re.lastIndex);
re = new RegExp("^\\s*;\\s*(" + TOKEN + ")\\s*=\\s*(" + VALUE + ")", "g");
re.lastIndex = 0;
while ( result = re.exec(text) ) {
attr[result[1].toLowerCase()] = result[2];
text = text.substring(re.lastIndex);
re.lastIndex = 0;
}
return {type:type, attr:attr};
}
if ( window.addEventListener ) {
window.addEventListener("load", exec, false);
} else if ( window.attachEvent ) {
window.attachEvent("onload", exec);
} else {
if ( window.onload ) {
var temp = window.onload;
window.onload = function ( ) {
var r = temp.apply(this, arguments);
exec();
return r;
};
} else {
window.onload = exec;
}
}
return {
register: register, exec: exec
};
}();
}
}.call(null) ) {
this.WebBrowser.ScriptExecuter.register = register;
this.WebBrowser.ScriptExecuter.exec = exec;
}
}).call(null);
(function(){
if ( !this.JSON || (typeof this.JSON != ‘object‘ && typeof this.JSON != ‘function‘) ) this.JSON = new Object();
if ( this.JSON.dump === undefined ) this.JSON.dump = undefined;
with ( function(){
with ( JSON ) {
return function () {
var VERSION = ‘0.0.0‘;
var NAMESPACE;
NAMESPACE = ‘JSON‘;
var DUMPER = "JSON.dumper";
function dump ( data, opts ) {
opts = opts || {};
var indent = String(opts.indent);
if ( !indent.match(/^\s*$/) ) indent = " ";
return dump_main(data, {pretty:opts.pretty, indent:indent, deflate:opts.deflate});
}
function dump_main ( data, opts ) {
switch ( typeof data ) {
case "undefined":
return opts.deflate ? ‘(void 0)‘ : ‘"undefined"‘;
case "boolean":
case "number":
return String(data);
case "string":
return dump_string(data);
case "function":
case "object":
if ( data =http://www.mamicode.com/== null ) {"null";
} else if ( typeof data[DUMPER] == "function" ){
return data[DUMPER](opts);
} else if ( data instanceof Array ) {
var arr = [];
for ( var i=0; i < data.length; i++ ) arr[i] = dump_main(data[i], opts);
if ( opts.pretty ) {
return "[\n" + arr.join(",\n").replace(/^/mg, opts.indent) + "\n]";
} else {
return "[" + arr.join(",") + "]";
}
} else {
var arr = [];
for ( var i in data ) {
if ( data.hasOwnProperty(i) ) {
arr.push(dump_string(i) + ":" + dump_main(data[i], opts));
}
}
if ( opts.pretty ) {
return "{\n" + arr.join(",\n").replace(/^/mg, opts.indent) + "\n}";
} else {
return "{" + arr.join(",") + "}";
}
}
}
}
function dump_string ( str ) {
return ‘"‘ + str.replace(/[^\u0020-\u0021\u0023-\u005B\u005D-\u007E]/g, function (c){
// any ASCII character except ‘"‘, ‘\‘ and control-character
c = c.charCodeAt(0);
switch ( c ) {
case ‘"‘ : return ‘\\"‘;
case ‘\\‘: return ‘\\\\‘;
case ‘\b‘: return ‘\\b‘;
case ‘\f‘: return ‘\\f‘;
case ‘\n‘: return ‘\\n‘;
case ‘\r‘: return ‘\\r‘;
case ‘\t‘: return ‘\\t‘;
default:
c = c.toString(16);
while ( c.length < 4 ) c = "0" + c;
return "\\u" + c;
}
}) + ‘"‘;
}
String.prototype[DUMPER] = function ( opts ) {
return opts.deflate ? "new String(" + dump_string(this.toString()) + ")"
: dump_string(this.toString());
};
Boolean.prototype[DUMPER] = function ( opts ) {
return opts.deflate ? "new Boolean(" + this.toString() + ")"
: this.toString();
};
Number.prototype[DUMPER] = function ( opts ) {
return opts.deflate ? "new Number(" + this.toString() + ")"
: this.toString();
};
Date.prototype[DUMPER] = function ( opts ) {
return opts.deflate ? "new Date(" + this.valueOf() + ")"
: dump_string(this.toString());
};
RegExp.prototype[DUMPER] = function ( opts ) {
return opts.deflate ? this.toString()
: dump_string(this.toString());
};
Function.prototype[DUMPER] = function ( opts ) {
return opts.deflate ? this.toString()
: dump_string(this.toString());
};
return {
dump: dump
};
}();
}
}.call(null) ) {
this.JSON.dump = dump;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Cons code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Cons‘;
function Cell ( car, cdr ) {
this.car = car;
this.cdr = cdr;
}
var proto = Cell.prototype;
proto.toString = function ( ) {
return "(" + this.car + " . " + this.cdr + ")";
};
proto.toLocaleString = function ( ) {
return "("
+ (this.car == null ? String(this.car) : this.car.toLocaleString)
+ " . "
+ (this.cdr == null ? String(this.cdr) : this.cdr.toLocaleString)
+ ")";
};
proto.isNil = function ( ) {
return false;
};
function Nil ( ) {
this.car = this;
this.cdr = this;
}
var proto = Nil.prototype = new Cell();
proto.constructor = Nil;
proto.toString =
proto.toLocaleString = function ( ) {
return "nil";
};
proto.isNil = function ( ) {
return true;
};
function nil ( ) {
return new Nil();
};
function cons ( car, cdr ) {
return new Cell(car, cdr);
}
function car ( cell ) {
return cell.car;
}
function cdr ( cell ) {
return cell.cdr;
}
return {
nil: nil, Nil: Nil, car: car, Cell: Cell, cdr: cdr, cons: cons
};
}();
}
}.call(null) ) {
this.Data.Cons.nil = nil;
this.Data.Cons.Nil = Nil;
this.Data.Cons.car = car;
this.Data.Cons.Cell = Cell;
this.Data.Cons.cdr = cdr;
this.Data.Cons.cons = cons;
}
}).call(null);
(function(){
if ( !this.Util || (typeof this.Util != ‘object‘ && typeof this.Util != ‘function‘) ) this.Util = new Object();
if ( !this.Util.Arrayize || (typeof this.Util.Arrayize != ‘object‘ && typeof this.Util.Arrayize != ‘function‘) ) this.Util.Arrayize = new Object();
if ( this.Util.Arrayize.arrayize === undefined ) this.Util.Arrayize.arrayize = undefined;
with ( function(){
with ( Util.Arrayize ) {
return function () {
var VERSION = ‘0.0.0‘;
var NAMESPACE;
NAMESPACE = ‘Util.Arrayize‘;
var slice = Array.prototype.slice;
function arrayize ( o ) {
if ( !o ) return [];
try {
return slice.call(o, 0);
} catch ( e ) {
var r = [];
for ( var i=0; i < o.length; i++ ) {
r[i] = o[i];
}
return r;
}
}
return {
arrayize: arrayize
};
}();
}
}.call(null) ) {
this.Util.Arrayize.arrayize = arrayize;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Functional code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2005-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Functional‘;
function discontinue ( /* variable arguments */ ) {
throw new DiscontinueException(arguments);
}
function DiscontinueException ( args ) {
this.args = args;
}
var proto = DiscontinueException.prototype;
proto.name = NAMESPACE + ".DiscontinueException";
proto.message = "unusual use of `discontinue‘ (this should be caught by `forEach‘ or other iteration-methods).";
function ignore ( /* variable arguments */ ) {
throw new IgnoreException(arguments);
}
function IgnoreException ( args ) {
this.args = args;
}
var proto = IgnoreException.prototype;
proto.name = NAMESPACE + ".IgnoreException";
proto.message = "unusual use of `ignore‘ (this should be caught by `forEach‘ or other iteration-methods).";
function return_list ( /* variable arguments */ ) {
throw new ReturnListException(arguments);
}
function ReturnListException ( args ) {
this.args = args;
}
var proto = ReturnListException.prototype;
proto.name = NAMESPACE + ".ReturnListException";
proto.message = "unusual use of `return_list‘ (this should be caught by `forEach‘ or other iteration-methods).";
NAMESPACE = ‘Data.Functional.Loop‘;
function EndOfLoopException ( v ) {
this.result = v;
}
var proto = EndOfLoopException.prototype;
proto.name = NAMESPACE + ".EndOfLoopException";
proto.message = "this should be caught by `forEach‘ or other iteration-methods";
function wrap_for_forEach ( t, f ) {
if ( typeof f != "function" ) throw new TypeError("argument to forEach must be function");
return function ( v ) {
try {
f.call(t, v);
} catch ( e ) {
if ( e instanceof DiscontinueException ) {
throw new EndOfLoopException();
} else if ( e instanceof IgnoreException ) {
// Do nothing.
} else if ( e instanceof ReturnListException ) {
// Do nothing.
} else {
throw e;
}
}
};
}
function wrap_for_fold ( t, f, s ) {
if ( typeof f != "function" ) throw new TypeError("argument to fold must be function");
return function ( v ) {
try {
return s = f.call(t, s, v);
} catch ( e ) {
if ( e instanceof DiscontinueException ) {
throw new EndOfLoopException(e.args[e.args.length-1]);
} else if ( e instanceof IgnoreException ) {
return s;
} else if ( e instanceof ReturnListException ) {
return s = f.call(t, s, e.args[e.args.length-1]);
} else {
throw e;
}
}
};
}
function wrap_for_map ( t, f, a ) {
if ( typeof f != "function" ) throw new TypeError("argument to map must be function");
if ( typeof a != "function" ) throw new TypeError("the third argument to wrap_for_map must be function");
return function ( v ) {
try {
a.call(null, f.call(t, v));
} catch ( e ) {
if ( e instanceof DiscontinueException ) {
a.apply(null, e.args);
throw new EndOfLoopException();
} else if ( e instanceof IgnoreException ) {
// Do nothing.
} else if ( e instanceof ReturnListException ) {
a.apply(null, e.args);
} else {
throw e;
}
}
};
}
return {
DiscontinueException: DiscontinueException, wrap_for_forEach: wrap_for_forEach, wrap_for_map: wrap_for_map, ignore: ignore, discontinue: discontinue, ReturnListException: ReturnListException, wrap_for_fold: wrap_for_fold, return_list: return_list, IgnoreException: IgnoreException, EndOfLoopException: EndOfLoopException
};
}();
}
}
}.call(null) ) {
this.Data.Functional.DiscontinueException = DiscontinueException;
this.Data.Functional.Loop.wrap_for_forEach = wrap_for_forEach;
this.Data.Functional.Loop.wrap_for_map = wrap_for_map;
this.Data.Functional.ignore = ignore;
this.Data.Functional.discontinue = discontinue;
this.Data.Functional.ReturnListException = ReturnListException;
this.Data.Functional.Loop.wrap_for_fold = wrap_for_fold;
this.Data.Functional.return_list = return_list;
this.Data.Functional.IgnoreException = IgnoreException;
this.Data.Functional.Loop.EndOfLoopException = EndOfLoopException;
}
}).call(null);
(function(){
if ( !this.Util || (typeof this.Util != ‘object‘ && typeof this.Util != ‘function‘) ) this.Util = new Object();
if ( !this.Util.Arrayize || (typeof this.Util.Arrayize != ‘object‘ && typeof this.Util.Arrayize != ‘function‘) ) this.Util.Arrayize = new Object();
with ( function(){
with ( Util.Arrayize ) {
return function () {
var VERSION = ‘0.0.0‘;
var NAMESPACE;
var null_constructor = function (){};
Function.prototype.extend = function extend ( init, props ) {
if ( typeof init !== "function" ) throw new TypeError("function is expected: " + init);
if ( props == null ) props = {};
var SuperClass = this;
var SubClass = function ( ) {
var self = this;
var super_is_called = false;
function super_call ( ) {
if ( super_is_called ) throw new Error("super-constructor has already been called");
super_is_called = true;
var ret_val = SuperClass.apply(self, arguments);
if ( ret_val instanceof Object ) {
for ( var i in ret_val ) {
if ( ret_val.hasOwnProperty(i) ) self[i] = ret_val[i];
}
}
return ret_val;
}
arguments = arrayize(arguments);
arguments.unshift(super_call);
return init.apply(self, arguments);
};
null_constructor.prototype = SuperClass.prototype;
var proto = SubClass.prototype = new null_constructor;
proto.constructor = SubClass;
proto.$super = function ( prop ) {
if ( !arguments.length ) return SuperClass;
var value = http://www.mamicode.com/SuperClass.prototype[prop];"function" ) {
return value.bind(this);
} else {
return value;
}
};
for ( var i in props ) proto[i] = props[i];
return SubClass;
};
return {
};
}();
}
}.call(null) ) {
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Error module.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2005-2006
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Error‘;
var Error = GLOBAL.Error.extend(
function ( $super, message ) {
$super(message);
},
{
name : NAMESPACE + ".Error",
message : "something‘s wrong",
toString: function ( ) {
var s = String(this.message);
s = s ? this.name + ": " + s
: this.name;
if ( this.fileName ) {
s += " @" + this.fileName + ":" + this.lineNumber;
}
return s;
}
}
);
var Exception = GLOBAL.Error.extend(
function ( $super, message ) {
$super(message);
},
{
name : NAMESPACE + ".Exception",
message : "an exception has occurred",
toString: function ( ) {
var s = String(this.message);
s = s ? this.name + ": " + s
: this.name;
if ( this.fileName ) {
s += " @" + this.fileName + ":" + this.lineNumber;
}
return s;
}
}
);
return {
Error: Error, Exception: Exception
};
}();
}
}.call(null) ) {
this.Data.Error.Error = Error;
this.Data.Error.Exception = Exception;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Error.IllegalStateError module.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Error‘;
var IllegalStateError = Error.extend(
function ( $super, message ) { $super(message); },
{
name : NAMESPACE + ".IllegalStateError",
message: "illegal state"
}
);
return {
IllegalStateError: IllegalStateError
};
}();
}
}.call(null) ) {
this.Data.Error.IllegalStateError = IllegalStateError;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Error.UnimplementedMethodError.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2005-2006
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Error‘;
var UnimplementedMethodError = Error.extend(
function ( $super, method, invocant, message ) {
if ( message !== undefined ) {
$super(message);
} else {
$super("an required method `" + method + "‘ has not been implemented");
}
this.method = method;
this.invocant = invocant;
},
{ name: NAMESPACE + ".UnimplementedMethodError" }
);
return {
UnimplementedMethodError: UnimplementedMethodError
};
}();
}
}.call(null) ) {
this.Data.Error.UnimplementedMethodError = UnimplementedMethodError;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Iterator code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Iterator‘;
var NoSuchElementError = Error.extend(
function ( $super, message ) { $super(message); },
{
name : NAMESPACE + ".NoSuchElementError",
message: "no such element"
}
);
return {
NoSuchElementError: NoSuchElementError
};
}();
}
}
}.call(null) ) {
this.Data.Iterator.NoSuchElementError = NoSuchElementError;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Functional code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2005-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Functional‘;
function Enumerable ( ) {
// This is a kind of abstract class.
}
var proto = Enumerable.prototype;
var obj_name = "[object " + NAMESPACE + ".Enumerable]";
proto.toString = function ( ) {
return obj_name;
};
proto.iterator = function ( ) {
throw new UnimplementedMethodError("iterator", this);
};
proto.forEach = function ( f ) {
var ret_val;
f = wrap_for_forEach(this, f);
for ( var it=this.iterator(); !it.isTail(); it=it.next() ) {
try {
f(it.value());
} catch ( e ) {
if ( e instanceof EndOfLoopException ) return;
else throw e;
}
}
};
proto.fold = function ( f, s ) {
f = wrap_for_fold(this, f, s);
for ( var it=this.iterator(); !it.isTail(); it=it.next() ) {
try {
s = f(it.value());
} catch ( e ) {
if ( e instanceof EndOfLoopException ) return e.result;
else throw e;
}
}
return s;
};
proto.fold1 = function ( f ) {
var it = this.iterator();
if ( it.isTail() ) throw new EmptyEnumerationError();
var s = it.value();
it = it.next();
f = wrap_for_fold(this, f, s);
for ( ; !it.isTail(); it=it.next() ) {
try {
s = f(it.value());
} catch ( e ) {
if ( e instanceof EndOfLoopException ) return e.result;
else throw e;
}
}
return s;
};
proto.and = function ( ) {
return this.fold(function ( x, y ) {
return y || discontinue(y);
}, true);
};
proto.or = function ( ) {
return this.fold(function ( x, y ) {
return y && discontinue(y);
}, false);
};
proto.all = function ( f ) {
return this.fold(function ( x, y ) {
y = f.call(this, y);
return y || discontinue(y);
}, true);
};
proto.any = function ( f ) {
return this.fold(function ( x, y ) {
y = f.call(this, y);
return y && discontinue(y);
}, false);
};
var EmptyEnumerationError = Error.extend(
function ( $super, message ) { $super(message); },
{
name : NAMESPACE + ".EmptyEnumerationError",
message: "empty enumeration"
}
);
return {
EmptyEnumerationError: EmptyEnumerationError, Enumerable: Enumerable
};
}();
}
}
}
}.call(null) ) {
this.Data.Functional.EmptyEnumerationError = EmptyEnumerationError;
this.Data.Functional.Enumerable = Enumerable;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Iterator code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Iterator‘;
function Iterator ( ) {
// This is a kind of abstract class.
// Sub-classes should implement appropreate methods.
}
var proto = Iterator.prototype;
var obj_name = "[object " + NAMESPACE + ".Iterator]";
proto.toString = function ( ) {
return obj_name;
};
// Returns true if this iterator points to the tail of a list,
// false othersise.
// The default implementation merely throws UnimplementedMethodError.
// Sub-classes must implement their own version of this method.
proto.isTail = function ( ) {
throw new UnimplementedMethodError("isTail", this);
};
// Returns value of the element which is just after the position
// this iterator points to.
// The default implementation merely throws UnimplementedMethodError.
// Sub-classes must implement their own version of this method,
// which may throws Data.Iterator.NoSuchElementError.
proto.value = http://www.mamicode.com/function ( ) {"value", this);
};
// Returns a new iterator that points to the next position to the
// one which this iterator points to.
// The default implementation merely throws UnimplementedMethodError.
// Sub-classes must implement their own version of this method,
// which may throws Data.Iterator.NoSuchElementError.
proto.next = function ( ) {
throw new UnimplementedMethodError("next", this);
};
// Returns true if and only if this iterator is associated with the
// object specified by the argument, false otherwise.
// The default implementation just returns false.
proto.isBoundTo = function ( list ) {
return false;
};
proto.find = function ( f ) {
for ( var it=this; !it.isTail(); it=it.next() ) {
if ( f(it.value()) ) break;
}
return it;
};
return {
Iterator: Iterator
};
}();
}
}
}.call(null) ) {
this.Data.Iterator.Iterator = Iterator;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Functional code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2005-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Functional‘;
function Collection ( ) {
// This is kind of abstract class.
}
var proto = Collection.prototype = new Enumerable();
proto.constructor = Collection;
var obj_name = "[object " + NAMESPACE + ".Collection]";
proto.toString = function ( ) {
return obj_name;
};
proto.toArray = function ( ) {
var a = [];
this.forEach(function( it ){
a.push(it);
});
return a;
};
proto.add = function ( /* variable args */ ) {
throw new UnimplementedMethodError("add", this);
};
proto.addAll = function ( /* variable arguments */ ) {
var self = this;
var changed = false;
for ( var i=0; i < arguments.length; i++ ) {
var c = arguments[i];
if ( c instanceof Collection ) {
c.forEach(function( it ){
changed = self.add(it) || changed;
});
} else if ( c instanceof Array ) {
changed = this.add.apply(this, c) || changed;
} else {
chagned = this.add(c) || changed;
}
}
return changed;
};
proto.removeAt = function ( it ) {
throw new UnimplementedMethodError("removeAt", this);
};
proto.isEmpty = function ( ) {
return this.iterator().isTail();
};
proto.empty = function ( ) {
var it;
while ( !(it=this.iterator()).isTail() ) this.removeAt(it);
};
proto.size = function ( ) {
var i = 0;
this.forEach(function(){ ++i; });
return i;
};
proto.emptyCopy = function ( ) {
return new this.constructor();
};
proto.copy = function ( ) {
var c = this.emptyCopy();
this.forEach(function( it ){
c.add(it);
});
return c;
};
proto.map = function ( f ) {
var c = this.emptyCopy();
f = wrap_for_map(this, f, function ( ) {
c.add.apply(c, arguments);
});
for ( var it=this.iterator(); !it.isTail(); it=it.next() ) {
try {
f(it.value());
} catch ( e ) {
if ( e instanceof EndOfLoopException ) return c;
else throw e;
}
}
return c;
};
proto.filter = function ( f ) {
return this.map(function( it ){
if ( f.call(this, it) ) return it;
else ignore();
});
};
proto.grep = function ( re ) {
if ( !(re instanceof RegExp) ) re = new Regex(re);
return this.filter(function(it){
return String(it).match(re);
});
};
return {
Collection: Collection
};
}();
}
}
}
}.call(null) ) {
this.Data.Functional.Collection = Collection;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Iterator code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Iterator‘;
function BidirectionalIterator ( ) {
// This is a kind of abstract class.
// Sub-classes should implement appropreate methods.
}
var proto = BidirectionalIterator.prototype = new Iterator();
proto.constructor = BidirectionalIterator;
var obj_name = "[object " + NAMESPACE + ".BidirectionalIterator]";
proto.toString = function ( ) {
return obj_name;
};
// Returns true if this iterator points to the head of a list,
// false othersise.
// The default implementation merely throws UnimplementedMethodError.
// Sub-classes must implement their own version of this method.
proto.isHead = function ( ) {
throw new UnimplementedMethodError("isHead", this);
};
// Returns a new iterator that points to the previous position to
// the one which this iterator points to.
// The default implementation merely throws UnimplementedMethodError.
// Sub-classes must implement their own version of this method.
proto.previous = function ( ) {
throw new UnimplementedMethodError("previous", this);
};
return {
BidirectionalIterator: BidirectionalIterator
};
}();
}
}
}.call(null) ) {
this.Data.Iterator.BidirectionalIterator = BidirectionalIterator;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Functional code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2005-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Functional‘;
function Set ( ) {
// This is kind of interface.
}
var proto = Set.prototype = new Collection();
proto.constructor = Set;
var obj_name = "[object " + NAMESPACE + ".Set]";
proto.toString = function ( ) {
return obj_name;
};
proto.contains = function ( /* variable args */ ) {
throw new UnimplementedMethodError("contains", this);
};
proto.containsAll = function ( /* variable args */ ) {
for ( var i=0; i < arguments.length; i++ ) {
var e = arguments[i];
if ( e instanceof Array ) {
if ( !this.contains.apply(this, e) ) return false;
} else if ( e instanceof Collection ) {
var self = this;
if ( !e.all(function(it){ return self.contains(it); }) ) return false;
} else {
if ( !this.contains(e) ) return false;
}
}
return true;
};
proto.remove = function ( /* variable args */ ) {
throw new UnimplementedMethodError("remove", this);
};
proto.removeAll = function ( /* variable args */ ) {
var changed = false;
for ( var i=0; i < arguments.length; i++ ) {
var e = arguments[i];
if ( e instanceof Array ) {
changed = this.remove.apply(this, e) || changed;
} else if ( e instanceof Collection ) {
var self = this;
e.forEach(function( it ){
changed = self.remove(it) || changed;
});
} else {
changed = this.remove(e) || changed;
}
}
return changed;
};
proto.removeAt = function ( it ) {
if ( !(it instanceof Iterator) ) throw new TypeError("the argument is not of type Data.Iterator.Iterator");
if ( !it.isBoundTo(this) ) throw new IllegalStateError();
var v = it.value();
this.remove(v);
return v;
};
proto.retainAll = function ( /* variable args */ ) {
var temp = this.emptyCopy();
temp.addAll.apply(temp, arguments);
return this.removeAll( this.filter(function(it){
return !temp.contains(it);
}) );
};
return {
Set: Set
};
}();
}
}
}
}.call(null) ) {
this.Data.Functional.Set = Set;
}
}).call(null);
(function(){
if ( !this.Math || (typeof this.Math != ‘object‘ && typeof this.Math != ‘function‘) ) this.Math = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Functional code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2005-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
// This module should not be required directly.
// Require Data.Functional.List instead.
NAMESPACE = ‘Data.Functional‘;
function List ( ) {
// This is a kind of abstract class.
}
var proto = List.prototype = new Collection();
proto.constructor = List;
// Iterator methods.
// Return an iterator pointing to just before the n‘th element
// (the first element is the 0th one). If there are only n elements
// in this list, return an iterator pointing to the tail.
// If n is negative, it is treated as size+n, where size is the length
// of this list. Thus, if n is negative, the result of head(n) and
// the one of tail(-n) should be equivalent.
// These methods can throw RangeError.
proto.head = function ( n ) {
if ( n < 0 ) return this.tail(-n);
return nNextFromHead(this.tail(), n);
};
proto.tail = function ( n ) {
if ( n < 0 ) return this.head(-n);
return nPreviousFromTail(this.head(), n);
};
proto.reverseHead = function ( n ) {
if ( n < 0 ) return this.reverseTail(-n);
return nNextFromHead(this.reverseTail(), n);
};
proto.reverseTail = function ( n ) {
if ( n < 0 ) return this.reverseHead(-n);
return nPreviousFromTail(this.reverseHead(), n);
};
function nNextFromHead ( it, n ) {
var q = [];
n = ToInteger(n);
if ( n == 0 ) { // simple optimization
while ( !it.isHead() ) it = it.previous();
return it;
} else {
while ( n-- > 0 ) {
if ( it.isHead() ) throw new RangeError();
q.push(it);
it = it.previous();
}
while ( !it.isHead() ) {
q.shift();
q.push(it);
it = it.previous();
}
q.push(it);
return q[0];
}
}
function nPreviousFromTail ( it, n ) {
var q = [];
n = ToInteger(n);
if ( n == 0 ) { // simple optimization
while ( !it.isTail() ) it = it.next();
return it;
} else {
while ( n-- > 0 ) {
if ( it.isTail() ) throw new RangeError();
q.push(it);
it = it.next();
}
while ( !it.isTail() ) {
q.shift();
q.push(it);
it = it.next();
}
q.push(it);
return q[0];
}
}
proto.iterator = function ( /* delegate */ ) {
return this.head.apply(this, arguments);
};
proto.add = function ( /* variable args */ ) {
if ( arguments.length == 0 ) return false;
for ( var i=0; i < arguments.length; i++ ) {
this.tail().insert(arguments[i]);
}
return true;
};
// Returns the value indexed by the argument.
// If there is no corresponding value in this list, returns undefined.
// The argument can be either number or iterator.
proto.get = function ( it ) {
if ( !(it instanceof List.Iterator && it.isBoundTo(this)) ) {
try {
it = this.head(it);
} catch ( e ) {
if ( e instanceof RangeError ) {
return undefined;
} else {
throw e;
}
}
}
if ( it.isTail() ) return undefined;
else return it.value();
};
// Assigns the second argument to the container indexed by the first
// argument.
// The argument can be either number or iterator.
proto.set = function ( it, v ) {
if ( !(it instanceof List.Iterator && it.isBoundTo(this)) ) {
it = this.head(it);
}
return it.assign(v);
};
// Inserts a new container at the position indexed by the first
// argument, and sets the second argument to the container, then,
// returns the value of the container.
// The argument can be either number or iterator.
// The position which this iterator points to after insertion is
// implementation-dependent.
proto.insertAt = function ( it, v ) {
if ( !(it instanceof List.Iterator && it.isBoundTo(this)) ) {
it = this.head(it);
}
return it.insert(v);
};
// Removes the container indexed by the argument, then, returns the
// value of the container.
// The argument can be either number or iterator.
// The position which this iterator points to after removal is
// implementation-dependent.
proto.removeAt = function ( it ) {
if ( !(it instanceof List.Iterator && it.isBoundTo(this)) ) {
it = this.head(it);
}
return it.remove();
};
proto.pop = function ( ) {
return this.reverseHead().remove();
};
proto.push = function ( /* variable args */ ) {
this.add.apply(this, arguments);
return this.size();
};
proto.shift = function ( ) {
return this.head().remove();
};
proto.unshift = function ( /* variable args */ ) {
for ( var i=arguments.length-1; i >= 0; i-- ) {
this.head().insert(arguments[i]);
}
return this.size();
};
proto.join = function ( /* delegate */ ) {
var arr = this.toArray();
return arr.join.apply(arr, arguments);
};
proto.toString = function ( /* delegate */ ) {
var arr = this.toArray();
return arr.toString.apply(arr, arguments);
};
proto.toLocaleString = function ( /* delegate */ ) {
var arr = this.toArray();
return arr.toLocaleString.apply(arr, arguments);
};
proto.reverse = function ( ) {
var r = this.emptyCopy();
for ( var it=this.reverseHead(); !it.isTail(); it=it.next() ) {
r.add(it.value());
}
return r;
};
proto.slice = function ( start, end ) {
if ( !( start instanceof List.Iterator
&& end instanceof List.Iterator
&& start.isBoundTo(this) && end.isBoundTo(this)
&& start.constructor === end.constructor ) ) // one might be reverse-iterator even though the other is iterator.
{
try {
start = this.head(start);
} catch ( e ) {
if ( e instanceof RangeError ) {
start = start < 0 ? this.head() : this.tail();
} else {
throw e;
}
}
if ( end === undefined ) {
end = this.tail();
} else {
try {
end = this.head(end);
} catch ( e ) {
if ( e instanceof RangeError ) {
end = end < 0 ? this.head() : this.tail();
} else {
throw e;
}
}
}
}
var l = this.emptyCopy();
if ( start.compareTo(end) >= 0 ) return l;
while ( !start.equals(end) ) {
l.add(start.value());
start = start.next();
}
return l;
};
proto.concat = function ( /* variable arguments */ ) {
var list = this.emptyCopy();
arguments[-1] = this;
for ( var i=-1; i < arguments.length; i++ ) {
var e = arguments[i];
if ( e instanceof List ) {
e.forEach(function(it){
list.add(it)
});
}
else if ( e instanceof Array ) {
for ( var j=0; j < e.length; j++ ) list.add(e[j])
}
else {
list.add(e);
}
}
return list;
};
proto.foldl = proto.fold;
proto.foldl1 = proto.fold1;
proto.foldr = function ( f, s ) {
var g = wrap_for_fold(this, function(x,y){return f.call(this,y,x);}, s);
for ( var it=this.reverseHead(); !it.isTail(); it=it.next() ) {
try {
s = g(it.value());
} catch ( e ) {
if ( e instanceof EndOfLoopException ) return e.result;
else throw e;
}
}
return s;
};
proto.foldr1 = function ( f ) {
var it = this.reverseHead();
if ( it.isTail() ) throw new EmptyEnumerationError();
var s = it.value();
it = it.next();
var g = wrap_for_fold(this, function(x,y){return f.call(this,y,x);}, s);
for ( ; !it.isTail(); it=it.next() ) {
try {
s = g(it.value());
} catch ( e ) {
if ( e instanceof EndOfLoopException ) return e.result;
else throw e;
}
}
return s;
};
return {
List: List
};
}();
}
}
}
}.call(null) ) {
this.Data.Functional.List = List;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Functional code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2005-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Functional.List‘;
function Iterator ( ) {
// This is a kind of abstract class.
}
var proto = Iterator.prototype = new BidirectionalIterator();
proto.constructor = Iterator;
var obj_name = "[object " + NAMESPACE + ".Iterator]";
proto.toString = function ( ) {
return obj_name;
};
// Assign the argument to the element which is just after the position
// this iterator points to, then returns the new value of the element,
// which can be defferent from the argument.
// The effect of assignment at the tail of a list should be identical
// to the one of insertion.
// The default implementation merely throws UnimplementedMethodError.
proto.assign = function ( v ) {
throw new UnimplementedMethodError("assign", this);
};
// Inserts a new container at the position which this iterator points
// to and sets the argument to the container, then, returns the value
// of the container, which can be defferent from the argument.
// The position which the iterator points to after insertion is
// implementation-dependent.
// The default implementation merely throws UnimplementedMethodError.
proto.insert = function ( v ) {
throw new UnimplementedMethodError("insert", this);
};
// Removes the container just after the position which this iterator
// points, then, returns the value of the container.
// The position which the iterator points to after removal is
// implementation-dependent.
// The default implementation merely throws UnimplementedMethodError.
proto.remove = function ( ) {
throw new UnimplementedMethodError("remove", this);
};
// Returns true if both this iterator and the argument points to the same position,
// false otherwise.
// The default implementation is based on `compareTo‘ method.
proto.equals = function ( that ) {
return this.compareTo(that) === 0;
};
// Returns the distance of this iterator and the argument,
// or undefined if the iterators seem to point to defferent list.
// A negative return value means the arguments succeeds this iterator
// and its magnitude represents the distance of them. Thus, this can be
// used as comparison-function.
// The default implementation is based on `next‘, `equals‘ and `isTail‘ method.
proto.distance =
proto.compareTo = function ( that ) {
if ( !(that instanceof Iterator) ) return undefined;
for ( var i=0, l=this, r=that; ; i--, l=l.next() ) {
if ( l.equals(r) ) return i;
if ( l.isTail() ) break;
}
for ( var i=1, l=that.next(), r=this; ; i++, l=l.next() ) {
if ( l.equals(r) ) return i;
if ( l.isTail() ) break;
}
return undefined;
};
return {
Iterator: Iterator
};
}();
}
}
}
}.call(null) ) {
this.Data.Functional.List.Iterator = Iterator;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Functional code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2005-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Functional.List‘;
// This module provides convinient wrapper to construct
// reverse iterator from normal list iterator.
function ReverseIterator ( it ) {
this._it = it;
}
var proto = ReverseIterator.prototype = new Iterator();
proto.constructor = ReverseIterator;
proto.isBoundTo = function ( that ) {
return this._it.isBoundTo(that);
};
proto.isTail = function ( ) {
return this._it.isHead();
};
proto.isHead = function ( ) {
return this._it.isTail();
};
proto.next = function ( ) {
return new ReverseIterator(this._it.previous());
};
proto.previous = function ( ) {
return new ReverseIterator(this._it.next());
};
proto.value = http://www.mamicode.com/function ( ) {"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Functional code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2005-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
// This is just a alias.
// See "Data.Functional.List.list" for the entity of "Data.Functional.List".
return {
};
}();
}.call(null) ) {
}
}).call(null);
(function(){
if ( !this.Math || (typeof this.Math != ‘object‘ && typeof this.Math != ‘function‘) ) this.Math = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Cons code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Cons‘;
var proto = new List();
proto.toString = Cell.prototype.toString;
proto.toLocaleString = Cell.prototype.toLocaleString;
proto.isNil = Cell.prototype.isNil;
Cell.prototype = proto;
proto.constructor = Cell;
proto = new Cell();
proto.toString = Nil.prototype.toString;
proto.toLocaleString = Nil.prototype.toLocaleString;
proto.isNil = Nil.prototype.isNil;
Nil.prototype = proto;
proto.constructor = Nil;
function list ( /* variable args */ ) {
var head, cell;
head = cell = new Cell(null, new Nil());
for ( var i=0; i < arguments.length; i++ ) {
cell = cell.cdr = new Cell(arguments[i], cell.cdr);
}
return head.cdr;
}
proto = Cell.prototype;
proto.iterator =
proto.head = function ( n ) {
n = ToInteger(n);
if ( n < 0 ) return this.tail(-n);
try {
for ( var it=new Iterator(this, this, null); n > 0; it=it.next(), n-- );
return it;
} catch ( e ) {
if ( e instanceof NoSuchElementError ) {
throw new RangeError();
} else {
throw e;
}
}
};
proto.tail = function ( n ) {
n = ToInteger(n);
if ( n < 0 ) return this.head(-n);
for ( var it=new Iterator(this, this, null); !it.isTail(); it=it.next() );
try {
for ( ; n > 0; it=it.previous(), n-- );
return it;
} catch ( e ) {
if ( e instanceof NoSuchElementError ) {
throw new RangeError();
} else {
throw e;
}
}
};
proto.reverseHead = function ( n ) {
return new ReverseIterator(this.tail(n));
};
proto.reverseTail = function ( n ) {
return new ReverseIterator(this.head(n));
};
proto.get = function ( n ) {
if ( n instanceof Iterator || n instanceof ReverseIterator ) {
if ( !n.isBoundTo(this) ) throw new IllegalStateError();
return n.value();
}
n = ToInteger(n);
if ( n < 0 ) return this.reverse().get(-n-1);
var c = this;
while ( n !== 0 ) {
c = c.cdr;
if ( c.isNil() ) return undefined;
n--;
}
return c.car;
};
proto.set = function ( n, v ) {
if ( n instanceof Iterator || n instanceof ReverseIterator ) {
if ( !n.isBoundTo(this) ) throw new IllegalStateError();
return n.assign(v);
}
return this.head(n).assign(v);
};
proto.add = function ( /* variable args */ ) {
if ( arguments.length == 0 ) return false;
if ( this.isNil() ) throw new InsertAtHeadError();
for ( var c=this; !c.cdr.isNil(); c=c.cdr );
for ( var i=0; i < arguments.length; i++ ) {
c = c.cdr = new Cell(arguments[i], new Nil());
}
return true;
};
proto.shift = function ( ) {
throw new RemoveHeadError();
};
proto.unshift = function ( ) {
throw new InsertAtHeadError();
};
proto.pop = function ( ) {
if ( this.isNil() ) return undefined;
if ( this.cdr.isNil() ) throw new RemoveHeadError();
for ( var c=this.cdr; !c.cdr.cdr.isNil(); c=c.cdr );
var r = c.cdr.car;
c.cdr = c.cdr.cdr;
return r;
};
proto.push = function ( /* variable args */ ) {
if ( arguments.length == 0 ) return this.size();
if ( this.isEmpty() ) throw new InsertAtHeadError();
for ( var l=1, c=this; !c.cdr.isNil(); l++, c=c.cdr );
for ( var i=0; i < arguments.length; i++, l++ ) {
c = c.cdr = new Cell(arguments[i], c.cdr);
}
return l;
};
proto.isEmpty = function ( ) {
return this.isNil();
};
proto.empty = function ( ) {
if ( this.isEmpty() ) return;
throw new RemoveHeadError();
};
proto.size = function ( ) {
for ( var i=0, c=this; !c.isNil(); i++, c=c.cdr );
return i;
};
proto.copy = function ( ) {
if ( this.isNil() ) return new Nil();
var head, cell;
head = cell = new Cell(this.car, new Nil());
for ( var c=this.cdr; !c.isNil(); c=c.cdr ) {
cell = cell.cdr = new Cell(c.car, cell.cdr);
}
return head;
};
proto.toArray = function ( ) {
var a = [];
for ( var c=this; !c.isNil(); c=c.cdr ) a.push(c.car);
return a;
};
proto.reverse = function ( ) {
var r = new Nil();
for ( var c=this; !c.isNil(); c=c.cdr ) r = new Cell(c.car, r);
return r;
};
proto.concat = function ( /* variable args */ ) {
var head, cell;
head = cell = new Cell(null, new Nil());
arguments[-1] = this;
for ( var i=-1; i < arguments.length; i++ ) {
var c = arguments[i];
if ( c instanceof List ) {
c.forEach(function( it ){
cell = cell.cdr = new Cell(it, cell.cdr);
});
} else if ( c instanceof Array ) {
for ( var j=0; j < c.length; j++ ) {
cell = cell.cdr = new Cell(c[j], cell.cdr);
}
} else {
cell = cell.cdr = new Cell(c, cell.cdr);
}
}
return head.cdr;
};
proto.slice = function ( start, end ) {
if ( !( ( start instanceof Iterator && end instanceof Iterator
|| start instanceof ReverseIterator && end instanceof ReverseIterator )
&& start.isBoundTo(this) && end.isBoundTo(this) ) )
{ try {
start = this.head(start);
} catch ( e ) {
if ( e instanceof RangeError ) {
start = start < 0 ? this.head() : this.tail();
} else {
throw e;
}
}
if ( end === undefined ) {
end = this.tail();
} else {
try {
end = this.head(end);
} catch ( e ) {
if ( e instanceof RangeError ) {
end = end < 0 ? this.head() : this.tail();
} else {
throw e;
}
}
}
}
if ( start.compareTo(end) >= 0 ) return new Nil();
var head, cell;
head = cell = new Cell(null, new Nil());
while ( !start.equals(end) ) {
cell = cell.cdr = new Cell(start.value(), cell.cdr);
start = start.next();
}
return head.cdr;
}
proto.forEach = function ( f ) {
f = wrap_for_forEach(this, f);
for ( var c=this; !c.isNil(); c=c.cdr ) {
try {
f(c.car);
} catch ( e ) {
if ( e instanceof EndOfLoopException ) {
return;
} else {
throw e;
}
}
}
};
proto.fold =
proto.foldl = function ( f, s ) {
f = wrap_for_fold(this, f, s);
for ( var c=this; !c.isNil(); c=c.cdr ) {
try {
s = f(c.car);
} catch ( e ) {
if ( e instanceof EndOfLoopException ) {
return e.result;
} else {
throw e;
}
}
}
return s;
};
proto.fold1 =
proto.foldl1 = function ( f ) {
if ( this.isEmpty() ) throw new EmptyEnumerationError();
var s = this.car;
f = wrap_for_fold(this, f, s);
for ( var c=this.cdr; !c.isNil(); c=c.cdr ) {
try {
s = f(c.car);
} catch ( e ) {
if ( e instanceof EndOfLoopException ) {
return e.result;
} else {
throw e;
}
}
}
return s;
};
proto.foldr = function ( f, s ) {
return this.reverse().foldl(function(x,y){return f.call(this,y,x);}, s);
};
proto.foldr1 = function ( f ) {
return this.reverse().foldl1(function(x,y){return f.call(this,y,x);});
};
proto.map = function ( f ) {
if ( this.isNil() ) return new Nil();
var head, cell;
head = cell = new Cell(null, new Nil());
f = wrap_for_map(this, f, function(){
for ( var i=0; i < arguments.length; i++ ) {
cell = cell.cdr = new Cell(arguments[i], cell.cdr);
}
});
for ( var c=this; !c.isNil(); c=c.cdr ) {
try {
f(c.car);
} catch ( e ) {
if ( e instanceof EndOfLoopException ) {
return head.cdr;
} else {
throw e;
}
}
}
return head.cdr;
}
function Iterator ( head, cell, prev ) {
this._head = head;
this._cell = cell;
this._prev = prev;
}
var proto = Iterator.prototype = new List.Iterator();
proto.constructor = Iterator;
proto.isBoundTo = function ( that ) {
return this._head === that;
};
proto.isHead = function ( ) {
return this._head === this._cell;
};
proto.isTail = function ( ) {
return this._cell.isNil();
};
proto.value = http://www.mamicode.com/function ( ) {"can‘t remove at tail");
var r = this._cell.car;
this._cell = this._prev._cell.cdr = this._cell.cdr;
return r;
};
proto.next = function ( ) {
if ( this.isTail() ) throw new NoSuchElementError("no next element");
return new Iterator(this._head, this._cell.cdr, this);
};
proto.previous = function ( ) {
if ( this.isHead() ) throw new NoSuchElementError("no previous element");
return this._prev;
};
proto.equals = function ( that ) {
return that instanceof Iterator
&& that.isBoundTo(this._head)
&& this._cell === that._cell;
};
proto.compareTo =
proto.distance = function ( that ) {
if ( !(that instanceof Iterator && that.isBoundTo(this._head)) ) return undefined;
for ( var i=0, l=this._cell, r=that._cell; !l.isNil(); i++, l=l.cdr ) {
if ( l === r ) return -i;
}
for ( var i=1, l=that._cell.cdr, r=this._cell; !l.isNil(); i++, l=l.cdr ) {
if ( l === r ) return i;
}
return void 0;
};
function ReverseIterator ( ) {
return List.ReverseIterator.apply(this, arguments);
}
var proto = ReverseIterator.prototype = new List.ReverseIterator();
proto.constructor = ReverseIterator;
var InsertAtHeadError = Error.extend(
function ( $super, message ) { $super(message); },
{
name : NAMESPACE + ".InsertAtHeadError",
message: "can‘t insert at head of cons-list"
}
);
var RemoveHeadError = Error.extend(
function ( $super, message ) { $super(message); },
{
name : NAMESPACE + ".RemoveHeadError",
message: "can‘t remove head of cons-list"
}
);
return {
InsertAtHeadError: InsertAtHeadError, RemoveHeadError: RemoveHeadError, list: list
};
}();
}
}
}
}
}
}
}.call(null) ) {
this.Data.Cons.InsertAtHeadError = InsertAtHeadError;
this.Data.Cons.RemoveHeadError = RemoveHeadError;
this.Data.Cons.list = list;
}
}).call(null);
(function(){
if ( !this.Math || (typeof this.Math != ‘object‘ && typeof this.Math != ‘function‘) ) this.Math = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Functional code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2005-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
var proto = Array.prototype;
for ( var i in List.prototype ) {
if ( typeof proto[i] != "function" ) proto[i] = List.prototype[i];
}
proto.head = function ( n ) {
if ( n < 0 ) return this.tail(-n);
n = ToInteger(n);
if ( n > this.length ) throw new RangeError();
return new Iterator(this, n);
};
proto.tail = function ( n ) {
if ( n < 0 ) return this.head(-n);
n = ToInteger(n);
if ( n > this.length ) throw new RangeError();
return new Iterator(this, this.length-n);
};
proto.iterator = proto.head;
proto.reverseHead = function ( n ) {
if ( n < 0 ) return this.reverseTail(-n);
n = ToInteger(n);
if ( n > this.length ) throw new RangeError();
return new ReverseIterator(this, n);
};
proto.reverseTail = function ( n ) {
if ( n < 0 ) return this.reverseHead(-n);
n = ToInteger(n);
if ( n > this.length ) throw new RangeError();
return new ReverseIterator(this, this.length-n);
};
proto.add = function ( /* variable args */ ) {
this.push.apply(this, arguments);
return true;
};
proto.get = function ( it ) {
if ( it instanceof Iterator || it instanceof ReverseIterator ) {
if ( it.isBoundTo(this) ) return it.value();
throw new IllegalStateError();
}
it = ToInteger(n);
if ( it < 0 ) it += this.length;
return this[it];
};
proto.set = function ( it, v ) {
if ( it instanceof Iterator || it instanceof ReverseIterator ) {
if ( it.isBoundTo(this) ) return it.assign(v);
throw new IllegalStateError();
}
var n = ToInteger(it);
if ( n < 0 ) n += this.length;
if ( n < 0 ) throw new RangeError("`" + it + "‘ is too small.");
if ( n >= this.length ) throw new RangeError("`" + it + "‘ is too large.");
return this[n] = v;
};
proto.insertAt = function ( it, v ) {
if ( it instanceof Iterator || it instanceof ReverseIterator ) {
if ( it.isBoundTo(this) ) return it.insert(v);
throw new IllegalStateError();
}
var n = ToInteger(it);
if ( n < 0 ) n += this.length;
if ( n < 0 ) throw new RangeError("`" + it + "‘ is too small.");
if ( n >= this.length ) throw new RangeError("`" + it + "‘ is too large.");
this.splice(n, 0, v);
return v;
};
proto.removeAt = function ( it ) {
if ( it instanceof Iterator || it instanceof ReverseIterator ) {
if ( it.isBoundTo(this) ) return it.remove();
throw new IllegalStateError();
}
var n = ToInteger(it);
if ( n < 0 ) n += this.length;
if ( n < 0 ) throw new RangeError("`" + it + "‘ is too small.");
if ( n >= this.length ) throw new RangeError("`" + it + "‘ is too large.");
return this.splice(n, 1)[0];
};
proto.isEmpty = function ( ) {
return this.length == 0;
};
proto.empty = function ( ) {
this.length = 0;
};
proto.size = function ( ) {
return this.length;
};
proto.copy =
proto.toArray = function ( ) {
var a = [];
for ( var i=0; i < this.length; i++ ) a[i] = this[i];
return a;
};
proto.forEach = function ( f ) {
f = wrap_for_forEach(this, f);
for ( var i=0; i < this.length; i++ ) {
try {
f(this[i]);
} catch ( e ) {
if ( e instanceof EndOfLoopException ) {
return;
} else {
throw e;
}
}
}
};
proto.fold =
proto.foldl = function ( f, s ) {
f = wrap_for_fold(this, f, s);
for ( var i=0; i < this.length; i++ ) {
try {
s = f(this[i]);
} catch ( e ) {
if ( e instanceof EndOfLoopException ) {
return e.result;
} else {
throw e;
}
}
}
return s;
};
proto.fold1 =
proto.foldl1 = function ( f ) {
if ( this.length == 0 ) throw new EmptyEnumerationError();
var s = this[0];
f = wrap_for_fold(this, f, s);
for ( var i=1; i < this.length; i++ ) {
try {
s = f(this[i]);
} catch ( e ) {
if ( e instanceof EndOfLoopException ) {
return e.result;
} else {
throw e;
}
}
}
return s;
};
proto.foldr = function ( f, s ) {
var g = wrap_for_fold(this, function(x,y){return f.call(this,y,x);}, s);
for ( var i=this.length-1; i >= 0; i-- ) {
try {
s = f(this[i]);
} catch ( e ) {
if ( e instanceof EndOfLoopException ) {
return e.result;
} else {
throw e;
}
}
}
return s;
};
proto.foldr1 = function ( f ) {
if ( this.length == 0 ) throw new EmptyEnumerationError();
var s = this[this.length-1];
var g = wrap_for_fold(this, function(x,y){return f.call(this,y,x);}, s);
for ( var i=this.length-2; i >= 0; i-- ) {
try {
s = g(this[i]);
} catch ( e ) {
if ( e instanceof EndOfLoopException ) {
return e.result;
} else {
throw e;
}
}
}
return s;
};
proto.map = function ( f ) {
var a = [];
f = wrap_for_map(this, f, function(){
a.push.apply(a, arguments);
});
for ( var i=0; i < this.length; i++ ) {
try {
f(this[i]);
} catch ( e ) {
if ( e instanceof EndOfLoopException ) return a;
else throw e;
}
}
return a;
};
// Re-define concat and slice
var original_concat = proto.concat;
proto.concat = function ( /* variable argumentes */ ) {
for ( var i=0; i < arguments.length; i++ ) {
var v = arguments[i];
if ( v instanceof List ) arguments[i] = v.toArray();
}
return original_concat.apply(this, arguments);
};
var original_slice = proto.slice;
proto.slice = function ( start, end ) {
if ( ( start instanceof Iterator && end instanceof Iterator
|| start instanceof ReverseIterator && end instanceof ReverseIterator )
&& start.isBoundTo(this) && end.isBoundTo(this) )
{
if ( start.compareTo(end) >= 0 ) return [];
var s = [];
do {
s.push(start.value());
start = start.next();
} while ( !start.equals(end) );
return s;
} else {
return original_slice.apply(this, arguments);
}
};
function Iterator ( a, n ) {
this._arr = a;
this._pos = n;
}
var proto = Iterator.prototype = new List.Iterator();
proto.constructor = Iterator;
proto.isBoundTo = function ( that ) {
return this._arr === that;
};
proto.isHead = function ( ) {
return ToInteger(this._pos) <= 0
|| this._arr.length == 0;
};
proto.isTail = function ( ) {
return ToInteger(this._pos) >= this._arr.length
|| this._arr.length == 0;
};
proto.value = http://www.mamicode.com/function ( ) {"can‘t remove at the tail of list");
else if ( this.isHead() ) return this._arr.aplice(0, 1)[0];
else return this._arr.splice(this._pos, 1)[0];
};
proto.next = function ( ) {
if ( this.isTail() ) throw new NoSuchElement("no next element");
if ( this.isHead() ) return new this.constructor(this._arr, 1);
else return new this.constructor(this._arr, this._pos+1);
};
proto.previous = function ( ) {
if ( this.isHead() ) throw new NoSuchElement("no previous element");
if ( this.isTail() ) return new this.constructor(this._arr, this._arr.length-1);
else return new this.constructor(this._arr, this._pos-1);
};
proto.compareTo =
proto.distance = function ( that ) {
if ( !(that instanceof this.constructor) ) return undefined;
if ( this._arr !== that._arr ) return undefined;
var s = this._arr.length;
var l = ToInteger(this._pos);
var r = ToInteger(that._pos);
if ( l <= 0 && r <= 0
|| l >= s && r >= s ) return 0;
return l - r;
};
function ReverseIterator ( a, n ) {
Iterator.apply(this, arguments);
}
var proto = ReverseIterator.prototype = new List.Iterator();
for ( var i in Iterator.prototype ) {
if ( Iterator.prototype.hasOwnProperty(i)
&& typeof Iterator.prototype[i] == "function" )
{
proto[i] = Iterator.prototype[i];
}
}
proto.constructor = ReverseIterator;
proto.value = http://www.mamicode.com/function ( ) {"can‘t remove at the tail of list");
if ( this.isHead() ) return this._arr.splice(this._arr.length-1, 1)[0];
else return this._arr.splice(this._arr.length-1-ToInteger(this._pos), 1)[0];
};
return {
};
}();
}
}
}
}
}.call(null) ) {
}
}).call(null);
(function(){
if ( !this.Math || (typeof this.Math != ‘object‘ && typeof this.Math != ‘function‘) ) this.Math = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.LinkedList module.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2005-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data‘;
function LinkedList ( /* variable arguments */ ) {
this._value = http://www.mamicode.com/undefined;"no next element");
return new Iterator(this._top, this._pos._next);
};
proto.previous = function ( ) {
if ( this.isHead() ) throw new NoSuchElementError("no previous element");
return new Iterator(this._top, this._pos._prev);
};
proto.value = http://www.mamicode.com/function ( ) {"can‘t remove at the tail of list");
this._pos._prev._next = this._pos._next;
this._pos._next._prev = this._pos._prev;
this._pos._removed = true;
return this._pos._value;
};
function ReverseIterator ( l, c ) {
this._top = l; // LinkedList object which this iterator belongs to.
this._pos = c; // Current position; abstractly iterator points to just before this container
}
var proto = ReverseIterator.prototype = new List.Iterator();
for ( var i in Iterator.prototype ) proto[i] = Iterator.prototype[i];
proto.constructor = ReverseIterator;
function rvalidate ( it ) {
while ( it._pos._removed ) {
it._pos = it._pos._prev;
}
}
proto.isBoundTo = Iterator.prototype.isBoundTo;
proto.equals = function ( that ) {
if ( !(that instanceof Iterator && that.isBoundTo(this._top)) ) return false;
rvalidate(this);
rvalidate(that);
return this._pos === that._pos;
};
proto.compareTo = function ( that ) {
if ( !(that instanceof Iterator && that.isBoundTo(this._top)) ) return undefined;
rvalidate(this);
rvalidate(that);
return -comp(this._top, this._pos, that._pos);
};
proto.distance = function ( that ) {
if ( !(that instanceof Iterator && that.isBoundTo(this._top)) ) return undefined;
rvalidate(this);
rvalidate(that);
var d = dist(this._top, this._pos, that._pos);
return isNaN(d) ? d : -d;
};
proto.isHead = function ( ) {
rvalidate(this);
return this._pos === this._top._prev;
};
proto.isTail = function ( ) {
rvalidate(this);
return this._pos === this._top;
};
proto.next = function ( ) {
if ( this.isTail() ) throw new NoSuchElementError("no next element");
return new ReverseIterator(this._top, this._pos._prev);
};
proto.previous = function ( ) {
if ( this.isHead() ) throw new NoSuchElementError("no previous element");
return new ReverseIterator(this._top, this._pos._next);
};
proto.value = http://www.mamicode.com/function ( ) {"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent‘;
var current_thread = null; // Retains the current thread.
function NoContinuationException ( r ) {
this.ret_val = r;
}
function initial_continuation_procedure ( ret_val ) {
throw new NoContinuationException(ret_val);
}
function NoExceptionHandlerException ( e ) {
this.thrown = e;
}
function initial_exception_handler ( e ) {
throw new NoExceptionHandlerException(e);
}
var initial_continuation = {
this_val : null,
procedure: initial_continuation_procedure,
exception: {
this_val : null,
procedure: initial_exception_handler
}
};
// Cyclic reference ensures that at least one exceptinal continuation always exists.
initial_continuation.exception.exception = initial_continuation.exception;
function Thread ( ) {
throw new Error("Thread cannot be instantiated directly.");
}
function THREAD ( t ) {
this._triplet = t; // {continuation:{...}, timeout:int|undefined, ret_val:any}
this._is_ended = 0; // 0:running, -1:throw, 1:return
this._join_thread = null;
this._joined_list = new Data.LinkedList();
this._timerID = undefined;
standBy.call(this, 0);
}
var proto = THREAD.prototype = Thread.prototype;
+function(){
var name = "[object " + NAMESPACE + ".Thread]"
proto.toString = function ( ) {
return name;
};
}();
// Cancel timeout event.
function cancel ( ) {
if ( this._timerID ) {
clearTimeout(this._timerID);
this._timerID = undefined;
}
}
// Reserve execution of the next step after t msec.
function standBy ( t ) {
cancel.call(this);
var self = this;
this._timerID = setTimeout(
function(){ doNext.call(self); },
Number(t) || 2 // some version of IE occationally fails to
// context-switch with timeout interval less than 2.
);
}
// Cut "join" link.
function unjoin ( ) {
if ( this._join_thread ) {
var self = this;
var it = this._join_thread._joined_list.head().find(function( it ){
return it === self;
});
it.remove();
this._join_thread = null;
}
}
Thread.TIME_SLICE = 20;
function doNext ( ) {
cancel.call(this);
var triplet = this._triplet;
this._triplet = null;
try {
current_thread = this;
var limit = (new Date).valueOf() + Thread.TIME_SLICE;
do {
try {
triplet = triplet.continuation.procedure.call(
triplet.continuation.this_val, triplet.ret_val
);
} catch ( e ) {
if ( e instanceof NoContinuationException ) {
this._is_ended = 1;
this._result = e.ret_val;
while ( !this._joined_list.isEmpty() ) {
var it = this._joined_list.head().value();
unjoin.call(it);
it._triplet.ret_val = e.ret_val;
standBy.call(it);
}
this._joined_list = null;
return;
} else if ( e instanceof NoExceptionHandlerException ) {
e = e.thrown;
var joined_list = this._joined_list;
this._joined_list = null;
this._is_ended = -1;
this._result = e;
if ( !joined_list.isEmpty() ) {
while ( !joined_list.isEmpty() ) {
joined_list.head().value().notify(e); // "notify" implies "unjoin".
}
} else if ( !(e instanceof KillException) ) {
throw e;
}
return;
} else {
triplet.continuation = triplet.continuation.exception;
triplet.ret_val = e;
}
}
} while ( triplet.timeout === undefined && (new Date).valueOf() < limit );
} finally {
current_thread = null;
}
this._triplet = triplet;
if ( triplet.timeout < 0 ) { /* Do nothing. */ }
else { standBy.call(this, triplet.timeout); }
}
proto.notify = function ( e ) {
if ( current_thread === this ) throw e;
if ( this._is_ended ) throw new NotAliveError();
cancel.call(this);
unjoin.call(this);
this._triplet.continuation = this._triplet.continuation.exception;
this._triplet.ret_val = e;
standBy.call(this);
return e;
};
proto.kill = function ( s ) {
return this.notify( arguments.length ? new KillException(s) : new KillException() );
};
proto.join = function ( ) {
throw new Error("can‘t `join‘ in non-compiled functions");
};
proto.join.$Concurrent_Thread_compiled = function ( this_val, args, cont ) {
//!TODO: check cyclic-join
if ( this_val._is_ended > 0 ) { // this thread has already ended normally
return { continuation:cont, ret_val:this_val._result, timeout:undefined };
} else if ( this_val._is_ended < 0 ) { // this thread has already ended by exception
throw this_val._result;
} else {
this_val._joined_list.add(current_thread);
current_thread._join_thread = this_val;
return { continuation:cont, timeout:-1 };
}
};
Thread.create = function ( f /* , ... */ ) {
if ( typeof f != "function" ) throw new TypeError("can‘t create new thread from non-function value");
if ( typeof f.$Concurrent_Thread_compiled !== "function" ) f = this.compile(f);
return f.async(null, Array.prototype.slice.call(arguments, 1, arguments.length));
};
Thread.self = function ( ) {
return current_thread;
};
Thread.sleep = function ( ) {
throw new Error("can‘t `sleep‘ in non-compiled functions");
};
Thread.sleep.$Concurrent_Thread_compiled = function ( this_val, args, cont ) {
return { continuation: cont,
ret_val : undefined,
timeout : args[0] > 0 ? args[0] : 0 };
};
Thread.stop = function ( ) {
throw new Error("can‘t `stop‘ in non-compiled functions");
};
Thread.stop.$Concurrent_Thread_compiled = function ( this_val, args, cont ) {
return { continuation: cont,
ret_val : undefined,
timeout : -1 };
};
Thread.yield = function ( ) {
throw new Error("can‘t `yield‘ in non-compiled functions");
};
Thread.yield.$Concurrent_Thread_compiled = function ( this_val, args, cont ) {
return { continuation: cont,
ret_val : undefined,
timeout : 0 };
};
var KillException = Thread.KillException = Exception.extend(
function ( $super, message ) { $super(message); },
{
name : NAMESPACE + ".Thread.KillException",
message: "thread killed"
}
);
var NotAliveError = Thread.NotAliveError = Error.extend(
function ( $super, message ) { $super(message); },
{
name : NAMESPACE + ".Thread.NotAliveError",
message: "thread not alive"
}
);
// Extends Function object.
var proto = Function.prototype;
proto.apply.$Concurrent_Thread_compiled = function ( this_val, args, cont ) {
if ( typeof this_val.$Concurrent_Thread_compiled == "function" ) {
return this_val.$Concurrent_Thread_compiled(args[0], args[1], cont);
} else {
return { continuation: cont,
ret_val : this_val.apply(args[0], args[1]) };
}
};
proto.call.$Concurrent_Thread_compiled = function ( this_val, args, cont ) {
if ( typeof this_val.$Concurrent_Thread_compiled == "function" ) {
return this_val.$Concurrent_Thread_compiled(args[0], Array.prototype.slice.call(args, 1, args.length), cont);
} else {
return { continuation: cont,
ret_val : this_val.apply(args[0], Array.prototype.slice.call(args, 1, args.length)) };
}
};
proto.async = function ( this_val, args ) {
if ( typeof this.$Concurrent_Thread_compiled != "function" ) throw new Error("this is not a compiled function");
if ( args === void 0 ) args = []; // IE6 does not allow null or undefined-value as the second argument of Function.prototype.apply. That does not conform to ECMA262-3!
return new THREAD(
this.$Concurrent_Thread_compiled(
this_val,
args,
initial_continuation
)
);
};
return {
Thread: Thread
};
}();
}
}
}.call(null) ) {
this.Concurrent.Thread = Thread;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Data.Cons code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Data.Cons.Util‘;
function last ( c ) {
if ( !(c instanceof Cell) ) throw new TypeError("argument is not cons-list");
if ( c.isNil() ) return c;
if ( !(c.cdr instanceof Cell) ) throw new TypeError("argument is not cons-list");
while ( !c.cdr.isNil() ) {
c = c.cdr;
if ( !(c.cdr instanceof Cell) ) throw new TypeError("argument is not cons-list");
}
return c;
}
function adder ( c ) {
c = last(c);
if ( c.isNil() ) throw new IllegalStateError("can‘t append to nil");
return function ( /* variable arguments */ ) {
c = last(c);
for ( var i=0; i < arguments.length; i++ ) {
c = c.cdr = new Cell(arguments[i], c.cdr);
}
};
}
function concat ( /* variable arguments */ ) {
if ( arguments.length == 0 ) return nil();
var head = arguments[0];
var cell = last(head);
for ( var i=1; i < arguments.length; i++ ) {
cell.cdr = arguments[i];
cell = last(cell);
}
return head;
}
return {
adder: adder, concat: concat, last: last
};
}();
}
}
}
}.call(null) ) {
this.Data.Cons.Util.adder = adder;
this.Data.Cons.Util.concat = concat;
this.Data.Cons.Util.last = last;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( !this.Concurrent.Thread.Compiler.Kit || (typeof this.Concurrent.Thread.Compiler.Kit != ‘object‘ && typeof this.Concurrent.Thread.Compiler.Kit != ‘function‘) ) this.Concurrent.Thread.Compiler.Kit = new Object();
if ( this.Concurrent.Thread.Compiler.Kit.printTrees === undefined ) this.Concurrent.Thread.Compiler.Kit.printTrees = undefined;
if ( this.Concurrent.Thread.Compiler.Kit.codeBug === undefined ) this.Concurrent.Thread.Compiler.Kit.codeBug = undefined;
with ( function(){
with ( Concurrent.Thread.Compiler.Kit ) {
return function () {
var VERSION = ‘0.0.0‘;
var NAMESPACE;
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Rhino code, released
* May 6, 1999.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1997-1999
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Igor Bukanov, igor@fastmail.fm
* Daisuke Maki
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License Version 2 or later (the "GPL"), in which
* case the provisions of the GPL are applicable instead of those above. If
* you wish to allow use of your version of this file only under the terms of
* the GPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replacing
* them with the notice and other provisions required by the GPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the GPL.
*
* ***** END LICENSE BLOCK ***** */
/**
* This file is based on the file Kit.java in Rhino 1.6R5.
*/
NAMESPACE = ‘Concurrent.Thread.Compiler.Kit‘;
var printTrees = false; // debug flag
function codeBug ( /* variable arguments */ ) {
var str = "";
for ( var i=0; i < arguments.length; i++ ) str += arguments[i];
var e = new Data.Error.IllegalStateError("FAILED ASSERTION: " + str);
var s = e.toString();
if ( e.stack ) s += "\n----------\n" + e.stack;
alert(s);
throw e;
}
return {
printTrees: printTrees, codeBug: codeBug
};
}();
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.Kit.printTrees = printTrees;
this.Concurrent.Thread.Compiler.Kit.codeBug = codeBug;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
var MIN_INT = Math.pow(-2, 53);
function IdentifierSet ( ) {
this._set = {};
this._state_no = MIN_INT;
}
var proto = IdentifierSet.prototype = new Set();
proto.constructor = IdentifierSet;
var hasOwnProperty = Object.prototype.hasOwnProperty;
proto.contains = function ( /* variable arguments */ ) {
for ( var i=0; i < arguments.length; i++ ) {
var id = arguments[i];
if ( !(id instanceof Identifier) ) throw new TypeError("arguments[" + i + "] is not of type Identifier");
// Because "hasOwnProperty" itself can be used as identifier,
// we need to avoid "this._set.hasOwnProperty".
if ( !hasOwnProperty.call(this._set, id.valueOf()) ) return false;
}
return true;
};
proto.add = function ( /* variable arguments */ ) {
var changed = false;
for ( var i=0; i < arguments.length; i++ ) {
var id = arguments[i];
if ( !(id instanceof Identifier) ) throw new TypeError("arguments[" + i + "] is not of type Identifier");
var p = id.valueOf();
if ( this._set[p] !== id ) {
this._set[p] = id;
this._state_no++;
changed = true;
}
}
return changed;
};
proto.remove = function ( /* variable arguments */ ) {
var changed = false;
for ( var i=0; i < arguments.length; i++ ) {
var id = arguments[i];
if ( !(id instanceof Identifier) ) throw new TypeError("argument is not of type Identifier");
var p = id.valueOf();
if ( hasOwnProperty.call(this._set, p) ) {
delete this._set[p];
this._state_no++;
changed = true;
}
}
return changed;
};
proto.toArray = function ( ) {
var arr = [];
for ( var i in this._set ) {
if ( hasOwnProperty.call(this._set, i) ) arr.push(this._set[i]);
}
return arr;
};
proto.iterator = function ( ) {
return new IdIterator(this, this.toArray(), 0);
};
function IdIterator ( parent, elems, index ) {
this._parent = parent;
this._elems = elems;
this._index = index;
this._state_no = parent._state_no;
}
var proto = IdIterator.prototype = new Iterator();
proto.constructor = IdIterator;
proto.isBoundTo = function ( o ) {
return this._parent === o;
};
proto.isTail = function ( ) {
if ( this._state_no !== this._parent._state_no ) throw new IllegalStateError("parent IdentifierSet object‘s state has been changed");
return this._index >= this._elems.length;
};
proto.next = function ( ) {
if ( this._state_no !== this._parent._state_no ) throw new IllegalStateError("parent IdentifierSet object‘s state has been changed");
if ( this.isTail() ) throw new NoSuchElementError("no more element after the tail");
return new IdIterator(this._parent, this._elems, this._index+1);
};
proto.value = http://www.mamicode.com/function ( ) {"parent IdentifierSet object‘s state has been changed");
return this._elems[this._index];
};
return {
IdentifierSet: IdentifierSet
};
}();
}
}
}
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.IdentifierSet = IdentifierSet;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Continuation || (typeof this.Concurrent.Thread.Continuation != ‘object‘ && typeof this.Concurrent.Thread.Continuation != ‘function‘) ) this.Concurrent.Thread.Continuation = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread.Continuation‘;
function callcc ( ) {
throw new Error("can‘t call `" + NAMESPACE + ".callcc‘ in non-threaded functions");
}
callcc.$Concurrent_Thread_compiled = function ( $this, $args, $cont ) {
function continuation ( ) {
throw new Error("can‘t call any captured continuation in non-threaded functions");
}
continuation.$Concurrent_Thread_compiled = function ( $this, $args, _ ) {
return { continuation: $cont ,
timeout : void 0,
ret_val : $args[0] };
};
var f = $args[0];
return f && typeof f.$Concurrent_Thread_compiled === "function"
? f.$Concurrent_Thread_compiled(null, [continuation], $cont)
: {continuation:$cont, ret_val:f(continuation), timeout:void 0};
};
function getCC ( ) {
throw new Error("can‘t call `" + NAMESPACE + ".getCC‘ in non-threaded functions");
}
getCC.$Concurrent_Thread_compiled = function ( $this, $args, $cont ) {
function continuation ( ) {
throw new Error("can‘t call any captured continuation in non-threaded functions");
}
continuation.$Concurrent_Thread_compiled = function ( $this, $args, _ ) {
return { continuation: $cont ,
timeout : void 0,
ret_val : $args[0] };
};
return {continuation:$cont, ret_val:continuation, timeout:void 0};
};
function currentContinuation ( ) {
throw new Error("can‘t call `" + NAMESPACE + ".currentContinuation‘ in non-threaded functions");
}
currentContinuation.$Concurrent_Thread_compiled = function ( $this, $args, $cont ) {
function continuation ( ) {
throw new Error("can‘t call any captured continuation in non-threaded functions");
}
continuation.$Concurrent_Thread_compiled = function ( $this, $args, _ ) {
return { continuation: $cont.exception,
timeout : void 0 ,
ret_val : new ContinuationCalledException($args) };
};
return { continuation: $cont ,
timeout : void 0,
ret_val : continuation };
};
var ContinuationCalledException = Exception.extend(
function ( $super, args ) {
$super("continuation called");
this.args = args;
},
{ name: NAMESPACE + ".ContinuationCalledException" }
);
return {
ContinuationCalledException: ContinuationCalledException, callcc: callcc, getCC: getCC, currentContinuation: currentContinuation
};
}();
}
}
}.call(null) ) {
this.Concurrent.Thread.Continuation.ContinuationCalledException = ContinuationCalledException;
this.Concurrent.Thread.Continuation.callcc = callcc;
this.Concurrent.Thread.Continuation.getCC = getCC;
this.Concurrent.Thread.Continuation.currentContinuation = currentContinuation;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( this.Concurrent.Thread.Compiler.ErrorReporter === undefined ) this.Concurrent.Thread.Compiler.ErrorReporter = undefined;
with ( function(){
with ( Concurrent.Thread.Compiler ) {
return function () {
var VERSION ;
var NAMESPACE;
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Rhino code, released
* May 6, 1999.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1997-1999
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Norris Boyd
* Daisuke Maki
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License Version 2 or later (the "GPL"), in which
* case the provisions of the GPL are applicable instead of those above. If
* you wish to allow use of your version of this file only under the terms of
* the GPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replacing
* them with the notice and other provisions required by the GPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the GPL.
*
* ***** END LICENSE BLOCK ***** */
/**
* This file is based on the file ErrorReporter.java in Rhino 1.6R5.
*/
// API class
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
/**
* This is interface defines a protocol for the reporting of
* errors during JavaScript translation or execution.
*
* @author Norris Boyd
*/
function ErrorReporter ( ) {
// This is kind of abstract class.
// It provides null-implementations for the methods as default.
}
var proto = ErrorReporter.prototype;
/**
* Report a warning.
*
* The implementing class may choose to ignore the warning
* if it desires.
*
* @param message a String describing the warning
* @param line the line number associated with the warning
* @param lineSource the text of the line (may be null)
* @param lineOffset the offset into lineSource where problem was detected
*/
proto.warning = function ( message, line, lineSource, lineOffset ) { };
/**
* Report an error.
*
* The implementing class is free to throw an exception if
* it desires.
*
* If execution has not yet begun, the JavaScript engine is
* free to find additional errors rather than terminating
* the translation. It will not execute a script that had
* errors, however.
*
* @param message a String describing the error
* @param line the line number associated with the error
* @param lineSource the text of the line (may be null)
* @param lineOffset the offset into lineSource where problem was detected
*/
proto.error = function ( message, line, lineSource, lineOffset ) { };
return {
ErrorReporter: ErrorReporter
};
}();
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.ErrorReporter = ErrorReporter;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( this.Concurrent.Thread.Compiler.isAlpha === undefined ) this.Concurrent.Thread.Compiler.isAlpha = undefined;
if ( this.Concurrent.Thread.Compiler.isDigit === undefined ) this.Concurrent.Thread.Compiler.isDigit = undefined;
if ( this.Concurrent.Thread.Compiler.isHexDigit === undefined ) this.Concurrent.Thread.Compiler.isHexDigit = undefined;
if ( this.Concurrent.Thread.Compiler.isLineTerminator === undefined ) this.Concurrent.Thread.Compiler.isLineTerminator = undefined;
if ( this.Concurrent.Thread.Compiler.isSpace === undefined ) this.Concurrent.Thread.Compiler.isSpace = undefined;
if ( this.Concurrent.Thread.Compiler.isFormatChar === undefined ) this.Concurrent.Thread.Compiler.isFormatChar = undefined;
if ( this.Concurrent.Thread.Compiler.isIdentifierStart === undefined ) this.Concurrent.Thread.Compiler.isIdentifierStart = undefined;
if ( this.Concurrent.Thread.Compiler.isIdentifierPart === undefined ) this.Concurrent.Thread.Compiler.isIdentifierPart = undefined;
with ( function(){
with ( Concurrent.Thread.Compiler ) {
return function () {
var VERSION = ‘0.0.0‘;
var NAMESPACE;
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
function isAlpha ( c )
{
c = c.charCodeAt(0);
// #generated# Last update: Tue, 01 Aug 2006 16:31:50 +0900
return c <= 0x5A ?
0x41 <= c :
0x61 <= c && c <= 0x7A;
// #/generated#
}
function isDigit ( c )
{
c = c.charCodeAt(0);
// #generated# Last update: Tue, 01 Aug 2006 21:02:15 +0900
return 0x30 <= c && c <= 0x39;
// #/generated#
}
function isHexDigit ( c )
{
c = c.charCodeAt(0);
// #generated# Last update: Tue, 01 Aug 2006 15:49:52 +0900
return c <= 0x46 ?
c <= 0x39 ?
0x30 <= c :
0x41 <= c :
0x61 <= c && c <= 0x66;
// #/generated#
}
function isLineTerminator ( c ) {
switch ( c.charCodeAt(0) ) {
case 0x000A: // Line Feed <LF>
case 0x000D: // Carriage Return <CR>
case 0x2028: // Line separator <LS>
case 0x2029: // Paragraph separator <PS>
return true;
default:
return false;
}
}
function isSpace ( c )
{
c = c.charCodeAt(0);
if ( c <= 255 ) {
switch ( c ) {
case 0x0009: // Tab <TAB>
case 0x000B: // Vertical Tab <VT>
case 0x000C: // Form Feed <FF>
case 0x0020: // Space <SP>
case 0x00A0: // No-break space <NBSP>
return true;
default:
return false;
}
}
else {
// the following code is derived from the Unicode category Zs based on:
// http://www.unicode.org/Public/UNIDATA/extracted/DerivedGeneralCategory.txt
// #generated# Last update: Tue, 01 Aug 2006 01:57:18 +0900
return c <= 0x180E ?
c <= 0xA0 ?
c <= 0x20 ?
0x20 <= c :
0xA0 <= c :
c <= 0x1680 ?
0x1680 <= c :
0x180E <= c :
c <= 0x202F ?
c <= 0x200A ?
0x2000 <= c :
0x202F <= c :
c <= 0x205F ?
0x205F <= c :
c === 0x3000;
// #/generated#
}
}
function isFormatChar ( c )
{
c = c.charCodeAt(0);
if ( c <= 127 ) return false; // optimization for ASCII characters
// the following code is derived from the Unicode category Cf based on:
// http://www.unicode.org/Public/UNIDATA/extracted/DerivedGeneralCategory.txt
// #generated# Last update: Tue, 01 Aug 2006 01:50:39 +0900
return c <= 0x202E ?
c <= 0x70F ?
c <= 0x603 ?
c <= 0xAD ?
0xAD <= c :
0x600 <= c :
c <= 0x6DD ?
0x6DD <= c :
0x70F <= c :
c <= 0x200F ?
c <= 0x17B5 ?
0x17B4 <= c :
0x200B <= c :
0x202A <= c :
c <= 0xFFFB ?
c <= 0x206F ?
c <= 0x2063 ?
0x2060 <= c :
0x206A <= c :
c <= 0xFEFF ?
0xFEFF <= c :
0xFFF9 <= c :
c <= 0xE0001 ?
c <= 0x1D17A ?
0x1D173 <= c :
0xE0001 <= c :
0xE0020 <= c && c <= 0xE007F;
// #/generated#
}
function isIdentifierStart ( c ) {
var c = c.charCodeAt(0);
switch ( c ) {
case 0x24: // ‘$‘
case 0x5F: // ‘_‘
return true;
}
// the following code is derived from the Unicode category Lu, Ll, Lt, Lm, Lo, and Nl based on:
// http://www.unicode.org/Public/UNIDATA/extracted/DerivedGeneralCategory.txt
// #generated# Last update: Tue, 01 Aug 2006 01:47:30 +0900
return c <= 0x1731 ?
c <= 0xB95 ?
c <= 0x961 ?
c <= 0x587 ?
c <= 0x37D ?
c <= 0xD6 ?
c <= 0xAA ?
c <= 0x7A ?
c <= 0x5A ?
0x41 <= c :
0x61 <= c :
0xAA <= c :
c <= 0xBA ?
c <= 0xB5 ?
0xB5 <= c :
0xBA <= c :
0xC0 <= c :
c <= 0x2D1 ?
c <= 0x2C1 ?
c <= 0xF6 ?
0xD8 <= c :
0xF8 <= c :
0x2C6 <= c :
c <= 0x2EE ?
c <= 0x2E4 ?
0x2E0 <= c :
0x2EE <= c :
0x37A <= c :
c <= 0x3F5 ?
c <= 0x38C ?
c <= 0x38A ?
c <= 0x386 ?
0x386 <= c :
0x388 <= c :
0x38C <= c :
c <= 0x3CE ?
c <= 0x3A1 ?
0x38E <= c :
0x3A3 <= c :
0x3D0 <= c :
c <= 0x556 ?
c <= 0x513 ?
c <= 0x481 ?
0x3F7 <= c :
0x48A <= c :
0x531 <= c :
c <= 0x559 ?
0x559 <= c :
0x561 <= c :
c <= 0x710 ?
c <= 0x6D3 ?
c <= 0x63A ?
c <= 0x5F2 ?
c <= 0x5EA ?
0x5D0 <= c :
0x5F0 <= c :
0x621 <= c :
c <= 0x66F ?
c <= 0x64A ?
0x640 <= c :
0x66E <= c :
0x671 <= c :
c <= 0x6EF ?
c <= 0x6E6 ?
c <= 0x6D5 ?
0x6D5 <= c :
0x6E5 <= c :
0x6EE <= c :
c <= 0x6FF ?
c <= 0x6FC ?
0x6FA <= c :
0x6FF <= c :
0x710 <= c :
c <= 0x7F5 ?
c <= 0x7A5 ?
c <= 0x76D ?
c <= 0x72F ?
0x712 <= c :
0x74D <= c :
0x780 <= c :
c <= 0x7EA ?
c <= 0x7B1 ?
0x7B1 <= c :
0x7CA <= c :
0x7F4 <= c :
c <= 0x93D ?
c <= 0x939 ?
c <= 0x7FA ?
0x7FA <= c :
0x904 <= c :
0x93D <= c :
c <= 0x950 ?
0x950 <= c :
0x958 <= c :
c <= 0xA8D ?
c <= 0x9F1 ?
c <= 0x9B2 ?
c <= 0x990 ?
c <= 0x98C ?
c <= 0x97F ?
0x97B <= c :
0x985 <= c :
0x98F <= c :
c <= 0x9B0 ?
c <= 0x9A8 ?
0x993 <= c :
0x9AA <= c :
0x9B2 <= c :
c <= 0x9CE ?
c <= 0x9BD ?
c <= 0x9B9 ?
0x9B6 <= c :
0x9BD <= c :
0x9CE <= c :
c <= 0x9E1 ?
c <= 0x9DD ?
0x9DC <= c :
0x9DF <= c :
0x9F0 <= c :
c <= 0xA36 ?
c <= 0xA28 ?
c <= 0xA10 ?
c <= 0xA0A ?
0xA05 <= c :
0xA0F <= c :
0xA13 <= c :
c <= 0xA33 ?
c <= 0xA30 ?
0xA2A <= c :
0xA32 <= c :
0xA35 <= c :
c <= 0xA5E ?
c <= 0xA5C ?
c <= 0xA39 ?
0xA38 <= c :
0xA59 <= c :
0xA5E <= c :
c <= 0xA74 ?
0xA72 <= c :
0xA85 <= c :
c <= 0xB28 ?
c <= 0xABD ?
c <= 0xAB0 ?
c <= 0xAA8 ?
c <= 0xA91 ?
0xA8F <= c :
0xA93 <= c :
0xAAA <= c :
c <= 0xAB9 ?
c <= 0xAB3 ?
0xAB2 <= c :
0xAB5 <= c :
0xABD <= c :
c <= 0xB0C ?
c <= 0xAE1 ?
c <= 0xAD0 ?
0xAD0 <= c :
0xAE0 <= c :
0xB05 <= c :
c <= 0xB10 ?
0xB0F <= c :
0xB13 <= c :
c <= 0xB61 ?
c <= 0xB39 ?
c <= 0xB33 ?
c <= 0xB30 ?
0xB2A <= c :
0xB32 <= c :
0xB35 <= c :
c <= 0xB5D ?
c <= 0xB3D ?
0xB3D <= c :
0xB5C <= c :
0xB5F <= c :
c <= 0xB8A ?
c <= 0xB83 ?
c <= 0xB71 ?
0xB71 <= c :
0xB83 <= c :
0xB85 <= c :
c <= 0xB90 ?
0xB8E <= c :
0xB92 <= c :
c <= 0xEB0 ?
c <= 0xD28 ?
c <= 0xC61 ?
c <= 0xBB9 ?
c <= 0xB9F ?
c <= 0xB9C ?
c <= 0xB9A ?
0xB99 <= c :
0xB9C <= c :
0xB9E <= c :
c <= 0xBAA ?
c <= 0xBA4 ?
0xBA3 <= c :
0xBA8 <= c :
0xBAE <= c :
c <= 0xC28 ?
c <= 0xC10 ?
c <= 0xC0C ?
0xC05 <= c :
0xC0E <= c :
0xC12 <= c :
c <= 0xC39 ?
c <= 0xC33 ?
0xC2A <= c :
0xC35 <= c :
0xC60 <= c :
c <= 0xCBD ?
c <= 0xCA8 ?
c <= 0xC90 ?
c <= 0xC8C ?
0xC85 <= c :
0xC8E <= c :
0xC92 <= c :
c <= 0xCB9 ?
c <= 0xCB3 ?
0xCAA <= c :
0xCB5 <= c :
0xCBD <= c :
c <= 0xD0C ?
c <= 0xCE1 ?
c <= 0xCDE ?
0xCDE <= c :
0xCE0 <= c :
0xD05 <= c :
c <= 0xD10 ?
0xD0E <= c :
0xD12 <= c :
c <= 0xE82 ?
c <= 0xDBD ?
c <= 0xD96 ?
c <= 0xD61 ?
c <= 0xD39 ?
0xD2A <= c :
0xD60 <= c :
0xD85 <= c :
c <= 0xDBB ?
c <= 0xDB1 ?
0xD9A <= c :
0xDB3 <= c :
0xDBD <= c :
c <= 0xE33 ?
c <= 0xE30 ?
c <= 0xDC6 ?
0xDC0 <= c :
0xE01 <= c :
0xE32 <= c :
c <= 0xE46 ?
0xE40 <= c :
0xE81 <= c :
c <= 0xE9F ?
c <= 0xE8A ?
c <= 0xE88 ?
c <= 0xE84 ?
0xE84 <= c :
0xE87 <= c :
0xE8A <= c :
c <= 0xE97 ?
c <= 0xE8D ?
0xE8D <= c :
0xE94 <= c :
0xE99 <= c :
c <= 0xEA7 ?
c <= 0xEA5 ?
c <= 0xEA3 ?
0xEA1 <= c :
0xEA5 <= c :
0xEA7 <= c :
c <= 0xEAB ?
0xEAA <= c :
0xEAD <= c :
c <= 0x1258 ?
c <= 0x102A ?
c <= 0xF00 ?
c <= 0xEC4 ?
c <= 0xEBD ?
c <= 0xEB3 ?
0xEB2 <= c :
0xEBD <= c :
0xEC0 <= c :
c <= 0xEDD ?
c <= 0xEC6 ?
0xEC6 <= c :
0xEDC <= c :
0xF00 <= c :
c <= 0xF8B ?
c <= 0xF6A ?
c <= 0xF47 ?
0xF40 <= c :
0xF49 <= c :
0xF88 <= c :
c <= 0x1027 ?
c <= 0x1021 ?
0x1000 <= c :
0x1023 <= c :
0x1029 <= c :
c <= 0x11A2 ?
c <= 0x10FA ?
c <= 0x10C5 ?
c <= 0x1055 ?
0x1050 <= c :
0x10A0 <= c :
0x10D0 <= c :
c <= 0x1159 ?
c <= 0x10FC ?
0x10FC <= c :
0x1100 <= c :
0x115F <= c :
c <= 0x124D ?
c <= 0x1248 ?
c <= 0x11F9 ?
0x11A8 <= c :
0x1200 <= c :
0x124A <= c :
c <= 0x1256 ?
0x1250 <= c :
0x1258 <= c :
c <= 0x1315 ?
c <= 0x12BE ?
c <= 0x128D ?
c <= 0x1288 ?
c <= 0x125D ?
0x125A <= c :
0x1260 <= c :
0x128A <= c :
c <= 0x12B5 ?
c <= 0x12B0 ?
0x1290 <= c :
0x12B2 <= c :
0x12B8 <= c :
c <= 0x12D6 ?
c <= 0x12C5 ?
c <= 0x12C0 ?
0x12C0 <= c :
0x12C2 <= c :
0x12C8 <= c :
c <= 0x1310 ?
0x12D8 <= c :
0x1312 <= c :
c <= 0x169A ?
c <= 0x13F4 ?
c <= 0x138F ?
c <= 0x135A ?
0x1318 <= c :
0x1380 <= c :
0x13A0 <= c :
c <= 0x1676 ?
c <= 0x166C ?
0x1401 <= c :
0x166F <= c :
0x1681 <= c :
c <= 0x170C ?
c <= 0x16F0 ?
c <= 0x16EA ?
0x16A0 <= c :
0x16EE <= c :
0x1700 <= c :
c <= 0x1711 ?
0x170E <= c :
0x1720 <= c :
c <= 0xA805 ?
c <= 0x2115 ?
c <= 0x1F4D ?
c <= 0x19A9 ?
c <= 0x17DC ?
c <= 0x1770 ?
c <= 0x176C ?
c <= 0x1751 ?
0x1740 <= c :
0x1760 <= c :
0x176E <= c :
c <= 0x17D7 ?
c <= 0x17B3 ?
0x1780 <= c :
0x17D7 <= c :
0x17DC <= c :
c <= 0x191C ?
c <= 0x18A8 ?
c <= 0x1877 ?
0x1820 <= c :
0x1880 <= c :
0x1900 <= c :
c <= 0x1974 ?
c <= 0x196D ?
0x1950 <= c :
0x1970 <= c :
0x1980 <= c :
c <= 0x1E9B ?
c <= 0x1B33 ?
c <= 0x1A16 ?
c <= 0x19C7 ?
0x19C1 <= c :
0x1A00 <= c :
0x1B05 <= c :
c <= 0x1DBF ?
c <= 0x1B4B ?
0x1B45 <= c :
0x1D00 <= c :
0x1E00 <= c :
c <= 0x1F1D ?
c <= 0x1F15 ?
c <= 0x1EF9 ?
0x1EA0 <= c :
0x1F00 <= c :
0x1F18 <= c :
c <= 0x1F45 ?
0x1F20 <= c :
0x1F48 <= c :
c <= 0x1FD3 ?
c <= 0x1FB4 ?
c <= 0x1F5B ?
c <= 0x1F59 ?
c <= 0x1F57 ?
0x1F50 <= c :
0x1F59 <= c :
0x1F5B <= c :
c <= 0x1F7D ?
c <= 0x1F5D ?
0x1F5D <= c :
0x1F5F <= c :
0x1F80 <= c :
c <= 0x1FC4 ?
c <= 0x1FBE ?
c <= 0x1FBC ?
0x1FB6 <= c :
0x1FBE <= c :
0x1FC2 <= c :
c <= 0x1FCC ?
0x1FC6 <= c :
0x1FD0 <= c :
c <= 0x207F ?
c <= 0x1FF4 ?
c <= 0x1FEC ?
c <= 0x1FDB ?
0x1FD6 <= c :
0x1FE0 <= c :
0x1FF2 <= c :
c <= 0x2071 ?
c <= 0x1FFC ?
0x1FF6 <= c :
0x2071 <= c :
0x207F <= c :
c <= 0x2107 ?
c <= 0x2102 ?
c <= 0x2094 ?
0x2090 <= c :
0x2102 <= c :
0x2107 <= c :
c <= 0x2113 ?
0x210A <= c :
0x2115 <= c :
c <= 0x2DBE ?
c <= 0x2C5E ?
c <= 0x2139 ?
c <= 0x2126 ?
c <= 0x2124 ?
c <= 0x211D ?
0x2119 <= c :
0x2124 <= c :
0x2126 <= c :
c <= 0x212D ?
c <= 0x2128 ?
0x2128 <= c :
0x212A <= c :
0x212F <= c :
c <= 0x214E ?
c <= 0x2149 ?
c <= 0x213F ?
0x213C <= c :
0x2145 <= c :
0x214E <= c :
c <= 0x2C2E ?
c <= 0x2184 ?
0x2160 <= c :
0x2C00 <= c :
0x2C30 <= c :
c <= 0x2D6F ?
c <= 0x2CE4 ?
c <= 0x2C77 ?
c <= 0x2C6C ?
0x2C60 <= c :
0x2C74 <= c :
0x2C80 <= c :
c <= 0x2D65 ?
c <= 0x2D25 ?
0x2D00 <= c :
0x2D30 <= c :
0x2D6F <= c :
c <= 0x2DAE ?
c <= 0x2DA6 ?
c <= 0x2D96 ?
0x2D80 <= c :
0x2DA0 <= c :
0x2DA8 <= c :
c <= 0x2DB6 ?
0x2DB0 <= c :
0x2DB8 <= c :
c <= 0x30FA ?
c <= 0x3029 ?
c <= 0x2DD6 ?
c <= 0x2DCE ?
c <= 0x2DC6 ?
0x2DC0 <= c :
0x2DC8 <= c :
0x2DD0 <= c :
c <= 0x3007 ?
c <= 0x2DDE ?
0x2DD8 <= c :
0x3005 <= c :
0x3021 <= c :
c <= 0x3096 ?
c <= 0x303C ?
c <= 0x3035 ?
0x3031 <= c :
0x3038 <= c :
0x3041 <= c :
c <= 0x309F ?
0x309D <= c :
0x30A1 <= c :
c <= 0x4DB5 ?
c <= 0x318E ?
c <= 0x312C ?
c <= 0x30FF ?
0x30FC <= c :
0x3105 <= c :
0x3131 <= c :
c <= 0x31FF ?
c <= 0x31B7 ?
0x31A0 <= c :
0x31F0 <= c :
0x3400 <= c :
c <= 0xA71A ?
c <= 0xA48C ?
c <= 0x9FBB ?
0x4E00 <= c :
0xA000 <= c :
0xA717 <= c :
c <= 0xA801 ?
0xA800 <= c :
0xA803 <= c :
c <= 0x1049D ?
c <= 0xFEFC ?
c <= 0xFB36 ?
c <= 0xFA6A ?
c <= 0xA873 ?
c <= 0xA822 ?
c <= 0xA80A ?
0xA807 <= c :
0xA80C <= c :
0xA840 <= c :
c <= 0xFA2D ?
c <= 0xD7A3 ?
0xAC00 <= c :
0xF900 <= c :
0xFA30 <= c :
c <= 0xFB17 ?
c <= 0xFB06 ?
c <= 0xFAD9 ?
0xFA70 <= c :
0xFB00 <= c :
0xFB13 <= c :
c <= 0xFB28 ?
c <= 0xFB1D ?
0xFB1D <= c :
0xFB1F <= c :
0xFB2A <= c :
c <= 0xFD3D ?
c <= 0xFB41 ?
c <= 0xFB3E ?
c <= 0xFB3C ?
0xFB38 <= c :
0xFB3E <= c :
0xFB40 <= c :
c <= 0xFBB1 ?
c <= 0xFB44 ?
0xFB43 <= c :
0xFB46 <= c :
0xFBD3 <= c :
c <= 0xFDFB ?
c <= 0xFDC7 ?
c <= 0xFD8F ?
0xFD50 <= c :
0xFD92 <= c :
0xFDF0 <= c :
c <= 0xFE74 ?
0xFE70 <= c :
0xFE76 <= c :
c <= 0x1003D ?
c <= 0xFFD7 ?
c <= 0xFFBE ?
c <= 0xFF5A ?
c <= 0xFF3A ?
0xFF21 <= c :
0xFF41 <= c :
0xFF66 <= c :
c <= 0xFFCF ?
c <= 0xFFC7 ?
0xFFC2 <= c :
0xFFCA <= c :
0xFFD2 <= c :
c <= 0x10026 ?
c <= 0x1000B ?
c <= 0xFFDC ?
0xFFDA <= c :
0x10000 <= c :
0x1000D <= c :
c <= 0x1003A ?
0x10028 <= c :
0x1003C <= c :
c <= 0x1034A ?
c <= 0x100FA ?
c <= 0x1005D ?
c <= 0x1004D ?
0x1003F <= c :
0x10050 <= c :
0x10080 <= c :
c <= 0x1031E ?
c <= 0x10174 ?
0x10140 <= c :
0x10300 <= c :
0x10330 <= c :
c <= 0x103CF ?
c <= 0x103C3 ?
c <= 0x1039D ?
0x10380 <= c :
0x103A0 <= c :
0x103C8 <= c :
c <= 0x103D5 ?
0x103D1 <= c :
0x10400 <= c :
c <= 0x1D505 ?
c <= 0x1236E ?
c <= 0x1083F ?
c <= 0x10835 ?
c <= 0x10808 ?
c <= 0x10805 ?
0x10800 <= c :
0x10808 <= c :
0x1080A <= c :
c <= 0x1083C ?
c <= 0x10838 ?
0x10837 <= c :
0x1083C <= c :
0x1083F <= c :
c <= 0x10A13 ?
c <= 0x10A00 ?
c <= 0x10915 ?
0x10900 <= c :
0x10A00 <= c :
0x10A10 <= c :
c <= 0x10A33 ?
c <= 0x10A17 ?
0x10A15 <= c :
0x10A19 <= c :
0x12000 <= c :
c <= 0x1D4A6 ?
c <= 0x1D49C ?
c <= 0x1D454 ?
c <= 0x12462 ?
0x12400 <= c :
0x1D400 <= c :
0x1D456 <= c :
c <= 0x1D4A2 ?
c <= 0x1D49F ?
0x1D49E <= c :
0x1D4A2 <= c :
0x1D4A5 <= c :
c <= 0x1D4BB ?
c <= 0x1D4B9 ?
c <= 0x1D4AC ?
0x1D4A9 <= c :
0x1D4AE <= c :
0x1D4BB <= c :
c <= 0x1D4C3 ?
0x1D4BD <= c :
0x1D4C5 <= c :
c <= 0x1D6DA ?
c <= 0x1D544 ?
c <= 0x1D51C ?
c <= 0x1D514 ?
c <= 0x1D50A ?
0x1D507 <= c :
0x1D50D <= c :
0x1D516 <= c :
c <= 0x1D53E ?
c <= 0x1D539 ?
0x1D51E <= c :
0x1D53B <= c :
0x1D540 <= c :
c <= 0x1D6A5 ?
c <= 0x1D550 ?
c <= 0x1D546 ?
0x1D546 <= c :
0x1D54A <= c :
0x1D552 <= c :
c <= 0x1D6C0 ?
0x1D6A8 <= c :
0x1D6C2 <= c :
c <= 0x1D788 ?
c <= 0x1D734 ?
c <= 0x1D714 ?
c <= 0x1D6FA ?
0x1D6DC <= c :
0x1D6FC <= c :
0x1D716 <= c :
c <= 0x1D76E ?
c <= 0x1D74E ?
0x1D736 <= c :
0x1D750 <= c :
0x1D770 <= c :
c <= 0x1D7CB ?
c <= 0x1D7C2 ?
c <= 0x1D7A8 ?
0x1D78A <= c :
0x1D7AA <= c :
0x1D7C4 <= c :
c <= 0x2A6D6 ?
0x20000 <= c :
0x2F800 <= c && c <= 0x2FA1D;
// #/generated#
}
function isIdentifierPart ( c ) {
var c = c.charCodeAt(0);
switch ( c ) {
case 0x24: // ‘$‘
case 0x5F: // ‘_‘
return true;
}
// the following code is derived from the Unicode category Lu, Ll, Lt, Lm, Lo, Nl, Mn, Mc, Nd, and Pc based on:
// http://www.unicode.org/Public/UNIDATA/extracted/DerivedGeneralCategory.txt
// #generated# Last update: Tue, 01 Aug 2006 02:00:01 +0900
return c <= 0x12B0 ?
c <= 0xB90 ?
c <= 0x990 ?
c <= 0x5BF ?
c <= 0x37D ?
c <= 0xD6 ?
c <= 0x7A ?
c <= 0x5A ?
c <= 0x39 ?
0x30 <= c :
0x41 <= c :
c <= 0x5F ?
0x5F <= c :
0x61 <= c :
c <= 0xB5 ?
c <= 0xAA ?
0xAA <= c :
0xB5 <= c :
c <= 0xBA ?
0xBA <= c :
0xC0 <= c :
c <= 0x2E4 ?
c <= 0x2C1 ?
c <= 0xF6 ?
0xD8 <= c :
0xF8 <= c :
c <= 0x2D1 ?
0x2C6 <= c :
0x2E0 <= c :
c <= 0x36F ?
c <= 0x2EE ?
0x2EE <= c :
0x300 <= c :
0x37A <= c :
c <= 0x481 ?
c <= 0x3A1 ?
c <= 0x38A ?
c <= 0x386 ?
0x386 <= c :
0x388 <= c :
c <= 0x38C ?
0x38C <= c :
0x38E <= c :
c <= 0x3F5 ?
c <= 0x3CE ?
0x3A3 <= c :
0x3D0 <= c :
0x3F7 <= c :
c <= 0x559 ?
c <= 0x513 ?
c <= 0x486 ?
0x483 <= c :
0x48A <= c :
c <= 0x556 ?
0x531 <= c :
0x559 <= c :
c <= 0x5BD ?
c <= 0x587 ?
0x561 <= c :
0x591 <= c :
0x5BF <= c :
c <= 0x6FF ?
c <= 0x63A ?
c <= 0x5EA ?
c <= 0x5C5 ?
c <= 0x5C2 ?
0x5C1 <= c :
0x5C4 <= c :
c <= 0x5C7 ?
0x5C7 <= c :
0x5D0 <= c :
c <= 0x615 ?
c <= 0x5F2 ?
0x5F0 <= c :
0x610 <= c :
0x621 <= c :
c <= 0x6DC ?
c <= 0x669 ?
c <= 0x65E ?
0x640 <= c :
0x660 <= c :
c <= 0x6D3 ?
0x66E <= c :
0x6D5 <= c :
c <= 0x6FC ?
c <= 0x6E8 ?
0x6DF <= c :
0x6EA <= c :
0x6FF <= c :
c <= 0x94D ?
c <= 0x7F5 ?
c <= 0x76D ?
c <= 0x74A ?
0x710 <= c :
0x74D <= c :
c <= 0x7B1 ?
0x780 <= c :
0x7C0 <= c :
c <= 0x939 ?
c <= 0x7FA ?
0x7FA <= c :
0x901 <= c :
0x93C <= c :
c <= 0x97F ?
c <= 0x963 ?
c <= 0x954 ?
0x950 <= c :
0x958 <= c :
c <= 0x96F ?
0x966 <= c :
0x97B <= c :
c <= 0x98C ?
c <= 0x983 ?
0x981 <= c :
0x985 <= c :
0x98F <= c :
c <= 0xA91 ?
c <= 0xA28 ?
c <= 0x9D7 ?
c <= 0x9B9 ?
c <= 0x9B0 ?
c <= 0x9A8 ?
0x993 <= c :
0x9AA <= c :
c <= 0x9B2 ?
0x9B2 <= c :
0x9B6 <= c :
c <= 0x9C8 ?
c <= 0x9C4 ?
0x9BC <= c :
0x9C7 <= c :
c <= 0x9CE ?
0x9CB <= c :
0x9D7 <= c :
c <= 0xA03 ?
c <= 0x9E3 ?
c <= 0x9DD ?
0x9DC <= c :
0x9DF <= c :
c <= 0x9F1 ?
0x9E6 <= c :
0xA01 <= c :
c <= 0xA10 ?
c <= 0xA0A ?
0xA05 <= c :
0xA0F <= c :
0xA13 <= c :
c <= 0xA48 ?
c <= 0xA39 ?
c <= 0xA33 ?
c <= 0xA30 ?
0xA2A <= c :
0xA32 <= c :
c <= 0xA36 ?
0xA35 <= c :
0xA38 <= c :
c <= 0xA42 ?
c <= 0xA3C ?
0xA3C <= c :
0xA3E <= c :
0xA47 <= c :
c <= 0xA74 ?
c <= 0xA5C ?
c <= 0xA4D ?
0xA4B <= c :
0xA59 <= c :
c <= 0xA5E ?
0xA5E <= c :
0xA66 <= c :
c <= 0xA8D ?
c <= 0xA83 ?
0xA81 <= c :
0xA85 <= c :
0xA8F <= c :
c <= 0xB28 ?
c <= 0xACD ?
c <= 0xAB9 ?
c <= 0xAB0 ?
c <= 0xAA8 ?
0xA93 <= c :
0xAAA <= c :
c <= 0xAB3 ?
0xAB2 <= c :
0xAB5 <= c :
c <= 0xAC9 ?
c <= 0xAC5 ?
0xABC <= c :
0xAC7 <= c :
0xACB <= c :
c <= 0xB03 ?
c <= 0xAE3 ?
c <= 0xAD0 ?
0xAD0 <= c :
0xAE0 <= c :
c <= 0xAEF ?
0xAE6 <= c :
0xB01 <= c :
c <= 0xB10 ?
c <= 0xB0C ?
0xB05 <= c :
0xB0F <= c :
0xB13 <= c :
c <= 0xB57 ?
c <= 0xB43 ?
c <= 0xB33 ?
c <= 0xB30 ?
0xB2A <= c :
0xB32 <= c :
c <= 0xB39 ?
0xB35 <= c :
0xB3C <= c :
c <= 0xB4D ?
c <= 0xB48 ?
0xB47 <= c :
0xB4B <= c :
0xB56 <= c :
c <= 0xB71 ?
c <= 0xB61 ?
c <= 0xB5D ?
0xB5C <= c :
0xB5F <= c :
c <= 0xB6F ?
0xB66 <= c :
0xB71 <= c :
c <= 0xB8A ?
c <= 0xB83 ?
0xB82 <= c :
0xB85 <= c :
0xB8E <= c :
c <= 0xDD6 ?
c <= 0xCB3 ?
c <= 0xC10 ?
c <= 0xBC2 ?
c <= 0xB9F ?
c <= 0xB9A ?
c <= 0xB95 ?
0xB92 <= c :
0xB99 <= c :
c <= 0xB9C ?
0xB9C <= c :
0xB9E <= c :
c <= 0xBAA ?
c <= 0xBA4 ?
0xBA3 <= c :
0xBA8 <= c :
c <= 0xBB9 ?
0xBAE <= c :
0xBBE <= c :
c <= 0xBEF ?
c <= 0xBCD ?
c <= 0xBC8 ?
0xBC6 <= c :
0xBCA <= c :
c <= 0xBD7 ?
0xBD7 <= c :
0xBE6 <= c :
c <= 0xC0C ?
c <= 0xC03 ?
0xC01 <= c :
0xC05 <= c :
0xC0E <= c :
c <= 0xC56 ?
c <= 0xC44 ?
c <= 0xC33 ?
c <= 0xC28 ?
0xC12 <= c :
0xC2A <= c :
c <= 0xC39 ?
0xC35 <= c :
0xC3E <= c :
c <= 0xC4D ?
c <= 0xC48 ?
0xC46 <= c :
0xC4A <= c :
0xC55 <= c :
c <= 0xC8C ?
c <= 0xC6F ?
c <= 0xC61 ?
0xC60 <= c :
0xC66 <= c :
c <= 0xC83 ?
0xC82 <= c :
0xC85 <= c :
c <= 0xCA8 ?
c <= 0xC90 ?
0xC8E <= c :
0xC92 <= c :
0xCAA <= c :
c <= 0xD43 ?
c <= 0xCE3 ?
c <= 0xCCD ?
c <= 0xCC4 ?
c <= 0xCB9 ?
0xCB5 <= c :
0xCBC <= c :
c <= 0xCC8 ?
0xCC6 <= c :
0xCCA <= c :
c <= 0xCDE ?
c <= 0xCD6 ?
0xCD5 <= c :
0xCDE <= c :
0xCE0 <= c :
c <= 0xD10 ?
c <= 0xD03 ?
c <= 0xCEF ?
0xCE6 <= c :
0xD02 <= c :
c <= 0xD0C ?
0xD05 <= c :
0xD0E <= c :
c <= 0xD39 ?
c <= 0xD28 ?
0xD12 <= c :
0xD2A <= c :
0xD3E <= c :
c <= 0xD96 ?
c <= 0xD61 ?
c <= 0xD4D ?
c <= 0xD48 ?
0xD46 <= c :
0xD4A <= c :
c <= 0xD57 ?
0xD57 <= c :
0xD60 <= c :
c <= 0xD83 ?
c <= 0xD6F ?
0xD66 <= c :
0xD82 <= c :
0xD85 <= c :
c <= 0xDC6 ?
c <= 0xDBB ?
c <= 0xDB1 ?
0xD9A <= c :
0xDB3 <= c :
c <= 0xDBD ?
0xDBD <= c :
0xDC0 <= c :
c <= 0xDD4 ?
c <= 0xDCA ?
0xDCA <= c :
0xDCF <= c :
0xDD6 <= c :
c <= 0xF39 ?
c <= 0xEA7 ?
c <= 0xE88 ?
c <= 0xE4E ?
c <= 0xDF3 ?
c <= 0xDDF ?
0xDD8 <= c :
0xDF2 <= c :
c <= 0xE3A ?
0xE01 <= c :
0xE40 <= c :
c <= 0xE82 ?
c <= 0xE59 ?
0xE50 <= c :
0xE81 <= c :
c <= 0xE84 ?
0xE84 <= c :
0xE87 <= c :
c <= 0xE9F ?
c <= 0xE8D ?
c <= 0xE8A ?
0xE8A <= c :
0xE8D <= c :
c <= 0xE97 ?
0xE94 <= c :
0xE99 <= c :
c <= 0xEA5 ?
c <= 0xEA3 ?
0xEA1 <= c :
0xEA5 <= c :
0xEA7 <= c :
c <= 0xED9 ?
c <= 0xEC4 ?
c <= 0xEB9 ?
c <= 0xEAB ?
0xEAA <= c :
0xEAD <= c :
c <= 0xEBD ?
0xEBB <= c :
0xEC0 <= c :
c <= 0xECD ?
c <= 0xEC6 ?
0xEC6 <= c :
0xEC8 <= c :
0xED0 <= c :
c <= 0xF29 ?
c <= 0xF00 ?
c <= 0xEDD ?
0xEDC <= c :
0xF00 <= c :
c <= 0xF19 ?
0xF18 <= c :
0xF20 <= c :
c <= 0xF37 ?
c <= 0xF35 ?
0xF35 <= c :
0xF37 <= c :
0xF39 <= c :
c <= 0x1059 ?
c <= 0xFC6 ?
c <= 0xF8B ?
c <= 0xF6A ?
c <= 0xF47 ?
0xF3E <= c :
0xF49 <= c :
c <= 0xF84 ?
0xF71 <= c :
0xF86 <= c :
c <= 0xFBC ?
c <= 0xF97 ?
0xF90 <= c :
0xF99 <= c :
0xFC6 <= c :
c <= 0x1032 ?
c <= 0x1027 ?
c <= 0x1021 ?
0x1000 <= c :
0x1023 <= c :
c <= 0x102A ?
0x1029 <= c :
0x102C <= c :
c <= 0x1049 ?
c <= 0x1039 ?
0x1036 <= c :
0x1040 <= c :
0x1050 <= c :
c <= 0x1248 ?
c <= 0x1159 ?
c <= 0x10FA ?
c <= 0x10C5 ?
0x10A0 <= c :
0x10D0 <= c :
c <= 0x10FC ?
0x10FC <= c :
0x1100 <= c :
c <= 0x11F9 ?
c <= 0x11A2 ?
0x115F <= c :
0x11A8 <= c :
0x1200 <= c :
c <= 0x125D ?
c <= 0x1256 ?
c <= 0x124D ?
0x124A <= c :
0x1250 <= c :
c <= 0x1258 ?
0x1258 <= c :
0x125A <= c :
c <= 0x128D ?
c <= 0x1288 ?
0x1260 <= c :
0x128A <= c :
0x1290 <= c :
c <= 0x30FF ?
c <= 0x1FB4 ?
c <= 0x180D ?
c <= 0x16EA ?
c <= 0x135A ?
c <= 0x12C5 ?
c <= 0x12BE ?
c <= 0x12B5 ?
0x12B2 <= c :
0x12B8 <= c :
c <= 0x12C0 ?
0x12C0 <= c :
0x12C2 <= c :
c <= 0x1310 ?
c <= 0x12D6 ?
0x12C8 <= c :
0x12D8 <= c :
c <= 0x1315 ?
0x1312 <= c :
0x1318 <= c :
c <= 0x166C ?
c <= 0x138F ?
c <= 0x135F ?
0x135F <= c :
0x1380 <= c :
c <= 0x13F4 ?
0x13A0 <= c :
0x1401 <= c :
c <= 0x169A ?
c <= 0x1676 ?
0x166F <= c :
0x1681 <= c :
0x16A0 <= c :
c <= 0x1770 ?
c <= 0x1734 ?
c <= 0x170C ?
c <= 0x16F0 ?
0x16EE <= c :
0x1700 <= c :
c <= 0x1714 ?
0x170E <= c :
0x1720 <= c :
c <= 0x176C ?
c <= 0x1753 ?
0x1740 <= c :
0x1760 <= c :
0x176E <= c :
c <= 0x17D7 ?
c <= 0x17B3 ?
c <= 0x1773 ?
0x1772 <= c :
0x1780 <= c :
c <= 0x17D3 ?
0x17B6 <= c :
0x17D7 <= c :
c <= 0x17E9 ?
c <= 0x17DD ?
0x17DC <= c :
0x17E0 <= c :
0x180B <= c :
c <= 0x1B59 ?
c <= 0x196D ?
c <= 0x191C ?
c <= 0x1877 ?
c <= 0x1819 ?
0x1810 <= c :
0x1820 <= c :
c <= 0x18A9 ?
0x1880 <= c :
0x1900 <= c :
c <= 0x193B ?
c <= 0x192B ?
0x1920 <= c :
0x1930 <= c :
0x1946 <= c :
c <= 0x19D9 ?
c <= 0x19A9 ?
c <= 0x1974 ?
0x1970 <= c :
0x1980 <= c :
c <= 0x19C9 ?
0x19B0 <= c :
0x19D0 <= c :
c <= 0x1B4B ?
c <= 0x1A1B ?
0x1A00 <= c :
0x1B00 <= c :
0x1B50 <= c :
c <= 0x1F45 ?
c <= 0x1EF9 ?
c <= 0x1DCA ?
c <= 0x1B73 ?
0x1B6B <= c :
0x1D00 <= c :
c <= 0x1E9B ?
0x1DFE <= c :
0x1EA0 <= c :
c <= 0x1F1D ?
c <= 0x1F15 ?
0x1F00 <= c :
0x1F18 <= c :
0x1F20 <= c :
c <= 0x1F5B ?
c <= 0x1F57 ?
c <= 0x1F4D ?
0x1F48 <= c :
0x1F50 <= c :
c <= 0x1F59 ?
0x1F59 <= c :
0x1F5B <= c :
c <= 0x1F7D ?
c <= 0x1F5D ?
0x1F5D <= c :
0x1F5F <= c :
0x1F80 <= c :
c <= 0x2149 ?
c <= 0x20DC ?
c <= 0x1FF4 ?
c <= 0x1FCC ?
c <= 0x1FBE ?
c <= 0x1FBC ?
0x1FB6 <= c :
0x1FBE <= c :
c <= 0x1FC4 ?
0x1FC2 <= c :
0x1FC6 <= c :
c <= 0x1FDB ?
c <= 0x1FD3 ?
0x1FD0 <= c :
0x1FD6 <= c :
c <= 0x1FEC ?
0x1FE0 <= c :
0x1FF2 <= c :
c <= 0x2071 ?
c <= 0x2040 ?
c <= 0x1FFC ?
0x1FF6 <= c :
0x203F <= c :
c <= 0x2054 ?
0x2054 <= c :
0x2071 <= c :
c <= 0x2094 ?
c <= 0x207F ?
0x207F <= c :
0x2090 <= c :
0x20D0 <= c :
c <= 0x211D ?
c <= 0x2107 ?
c <= 0x20EF ?
c <= 0x20E1 ?
0x20E1 <= c :
0x20E5 <= c :
c <= 0x2102 ?
0x2102 <= c :
0x2107 <= c :
c <= 0x2115 ?
c <= 0x2113 ?
0x210A <= c :
0x2115 <= c :
0x2119 <= c :
c <= 0x212D ?
c <= 0x2126 ?
c <= 0x2124 ?
0x2124 <= c :
0x2126 <= c :
c <= 0x2128 ?
0x2128 <= c :
0x212A <= c :
c <= 0x213F ?
c <= 0x2139 ?
0x212F <= c :
0x213C <= c :
0x2145 <= c :
c <= 0x2DB6 ?
c <= 0x2CE4 ?
c <= 0x2C5E ?
c <= 0x2184 ?
c <= 0x214E ?
0x214E <= c :
0x2160 <= c :
c <= 0x2C2E ?
0x2C00 <= c :
0x2C30 <= c :
c <= 0x2C77 ?
c <= 0x2C6C ?
0x2C60 <= c :
0x2C74 <= c :
0x2C80 <= c :
c <= 0x2D96 ?
c <= 0x2D65 ?
c <= 0x2D25 ?
0x2D00 <= c :
0x2D30 <= c :
c <= 0x2D6F ?
0x2D6F <= c :
0x2D80 <= c :
c <= 0x2DAE ?
c <= 0x2DA6 ?
0x2DA0 <= c :
0x2DA8 <= c :
0x2DB0 <= c :
c <= 0x302F ?
c <= 0x2DD6 ?
c <= 0x2DC6 ?
c <= 0x2DBE ?
0x2DB8 <= c :
0x2DC0 <= c :
c <= 0x2DCE ?
0x2DC8 <= c :
0x2DD0 <= c :
c <= 0x3007 ?
c <= 0x2DDE ?
0x2DD8 <= c :
0x3005 <= c :
0x3021 <= c :
c <= 0x309A ?
c <= 0x303C ?
c <= 0x3035 ?
0x3031 <= c :
0x3038 <= c :
c <= 0x3096 ?
0x3041 <= c :
0x3099 <= c :
c <= 0x30FA ?
c <= 0x309F ?
0x309D <= c :
0x30A1 <= c :
0x30FC <= c :
c <= 0x1049D ?
c <= 0xFE23 ?
c <= 0xFB06 ?
c <= 0xA71A ?
c <= 0x31FF ?
c <= 0x318E ?
c <= 0x312C ?
0x3105 <= c :
0x3131 <= c :
c <= 0x31B7 ?
0x31A0 <= c :
0x31F0 <= c :
c <= 0x9FBB ?
c <= 0x4DB5 ?
0x3400 <= c :
0x4E00 <= c :
c <= 0xA48C ?
0xA000 <= c :
0xA717 <= c :
c <= 0xFA2D ?
c <= 0xA873 ?
c <= 0xA827 ?
0xA800 <= c :
0xA840 <= c :
c <= 0xD7A3 ?
0xAC00 <= c :
0xF900 <= c :
c <= 0xFAD9 ?
c <= 0xFA6A ?
0xFA30 <= c :
0xFA70 <= c :
0xFB00 <= c :
c <= 0xFB44 ?
c <= 0xFB3C ?
c <= 0xFB28 ?
c <= 0xFB17 ?
0xFB13 <= c :
0xFB1D <= c :
c <= 0xFB36 ?
0xFB2A <= c :
0xFB38 <= c :
c <= 0xFB41 ?
c <= 0xFB3E ?
0xFB3E <= c :
0xFB40 <= c :
0xFB43 <= c :
c <= 0xFDC7 ?
c <= 0xFD3D ?
c <= 0xFBB1 ?
0xFB46 <= c :
0xFBD3 <= c :
c <= 0xFD8F ?
0xFD50 <= c :
0xFD92 <= c :
c <= 0xFE0F ?
c <= 0xFDFB ?
0xFDF0 <= c :
0xFE00 <= c :
0xFE20 <= c :
c <= 0x1000B ?
c <= 0xFF3F ?
c <= 0xFEFC ?
c <= 0xFE4F ?
c <= 0xFE34 ?
0xFE33 <= c :
0xFE4D <= c :
c <= 0xFE74 ?
0xFE70 <= c :
0xFE76 <= c :
c <= 0xFF3A ?
c <= 0xFF19 ?
0xFF10 <= c :
0xFF21 <= c :
0xFF3F <= c :
c <= 0xFFCF ?
c <= 0xFFBE ?
c <= 0xFF5A ?
0xFF41 <= c :
0xFF66 <= c :
c <= 0xFFC7 ?
0xFFC2 <= c :
0xFFCA <= c :
c <= 0xFFDC ?
c <= 0xFFD7 ?
0xFFD2 <= c :
0xFFDA <= c :
0x10000 <= c :
c <= 0x10174 ?
c <= 0x1004D ?
c <= 0x1003A ?
c <= 0x10026 ?
0x1000D <= c :
0x10028 <= c :
c <= 0x1003D ?
0x1003C <= c :
0x1003F <= c :
c <= 0x100FA ?
c <= 0x1005D ?
0x10050 <= c :
0x10080 <= c :
0x10140 <= c :
c <= 0x103C3 ?
c <= 0x1034A ?
c <= 0x1031E ?
0x10300 <= c :
0x10330 <= c :
c <= 0x1039D ?
0x10380 <= c :
0x103A0 <= c :
c <= 0x103D5 ?
c <= 0x103CF ?
0x103C8 <= c :
0x103D1 <= c :
0x10400 <= c :
c <= 0x1D4AC ?
c <= 0x10A3F ?
c <= 0x10915 ?
c <= 0x10835 ?
c <= 0x10805 ?
c <= 0x104A9 ?
0x104A0 <= c :
0x10800 <= c :
c <= 0x10808 ?
0x10808 <= c :
0x1080A <= c :
c <= 0x1083C ?
c <= 0x10838 ?
0x10837 <= c :
0x1083C <= c :
c <= 0x1083F ?
0x1083F <= c :
0x10900 <= c :
c <= 0x10A17 ?
c <= 0x10A06 ?
c <= 0x10A03 ?
0x10A00 <= c :
0x10A05 <= c :
c <= 0x10A13 ?
0x10A0C <= c :
0x10A15 <= c :
c <= 0x10A3A ?
c <= 0x10A33 ?
0x10A19 <= c :
0x10A38 <= c :
0x10A3F <= c :
c <= 0x1D1AD ?
c <= 0x1D172 ?
c <= 0x12462 ?
c <= 0x1236E ?
0x12000 <= c :
0x12400 <= c :
c <= 0x1D169 ?
0x1D165 <= c :
0x1D16D <= c :
c <= 0x1D18B ?
c <= 0x1D182 ?
0x1D17B <= c :
0x1D185 <= c :
0x1D1AA <= c :
c <= 0x1D49F ?
c <= 0x1D454 ?
c <= 0x1D244 ?
0x1D242 <= c :
0x1D400 <= c :
c <= 0x1D49C ?
0x1D456 <= c :
0x1D49E <= c :
c <= 0x1D4A6 ?
c <= 0x1D4A2 ?
0x1D4A2 <= c :
0x1D4A5 <= c :
0x1D4A9 <= c :
c <= 0x1D6C0 ?
c <= 0x1D51C ?
c <= 0x1D505 ?
c <= 0x1D4BB ?
c <= 0x1D4B9 ?
0x1D4AE <= c :
0x1D4BB <= c :
c <= 0x1D4C3 ?
0x1D4BD <= c :
0x1D4C5 <= c :
c <= 0x1D514 ?
c <= 0x1D50A ?
0x1D507 <= c :
0x1D50D <= c :
0x1D516 <= c :
c <= 0x1D546 ?
c <= 0x1D53E ?
c <= 0x1D539 ?
0x1D51E <= c :
0x1D53B <= c :
c <= 0x1D544 ?
0x1D540 <= c :
0x1D546 <= c :
c <= 0x1D6A5 ?
c <= 0x1D550 ?
0x1D54A <= c :
0x1D552 <= c :
0x1D6A8 <= c :
c <= 0x1D788 ?
c <= 0x1D734 ?
c <= 0x1D6FA ?
c <= 0x1D6DA ?
0x1D6C2 <= c :
0x1D6DC <= c :
c <= 0x1D714 ?
0x1D6FC <= c :
0x1D716 <= c :
c <= 0x1D76E ?
c <= 0x1D74E ?
0x1D736 <= c :
0x1D750 <= c :
0x1D770 <= c :
c <= 0x1D7FF ?
c <= 0x1D7C2 ?
c <= 0x1D7A8 ?
0x1D78A <= c :
0x1D7AA <= c :
c <= 0x1D7CB ?
0x1D7C4 <= c :
0x1D7CE <= c :
c <= 0x2FA1D ?
c <= 0x2A6D6 ?
0x20000 <= c :
0x2F800 <= c :
0xE0100 <= c && c <= 0xE01EF;
// #/generated#
}
return {
isDigit: isDigit, isIdentifierStart: isIdentifierStart, isHexDigit: isHexDigit, isAlpha: isAlpha, isSpace: isSpace, isLineTerminator: isLineTerminator, isFormatChar: isFormatChar, isIdentifierPart: isIdentifierPart
};
}();
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.isDigit = isDigit;
this.Concurrent.Thread.Compiler.isIdentifierStart = isIdentifierStart;
this.Concurrent.Thread.Compiler.isHexDigit = isHexDigit;
this.Concurrent.Thread.Compiler.isAlpha = isAlpha;
this.Concurrent.Thread.Compiler.isSpace = isSpace;
this.Concurrent.Thread.Compiler.isLineTerminator = isLineTerminator;
this.Concurrent.Thread.Compiler.isFormatChar = isFormatChar;
this.Concurrent.Thread.Compiler.isIdentifierPart = isIdentifierPart;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Http || (typeof this.Concurrent.Thread.Http != ‘object‘ && typeof this.Concurrent.Thread.Http != ‘function‘) ) this.Concurrent.Thread.Http = new Object();
if ( this.Concurrent.Thread.Http.send === undefined ) this.Concurrent.Thread.Http.send = undefined;
if ( this.Concurrent.Thread.Http.get === undefined ) this.Concurrent.Thread.Http.get = undefined;
if ( this.Concurrent.Thread.Http.post === undefined ) this.Concurrent.Thread.Http.post = undefined;
with ( function(){
with ( Concurrent.Thread.Http ) {
return function () {
var VERSION = ‘0.0.0‘;
var NAMESPACE;
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread.Http‘;
var createXMLHttpRequest; // Set up according to environment.
try {
new XMLHttpRequest();
createXMLHttpRequest = function ( ) {
return new XMLHttpRequest();
};
} catch ( e ) {
try {
// MSXML3 or later
new ActiveXObject("Msxml2.XMLHTTP");
createXMLHttpRequest = function ( ) {
return new ActiveXObject("Msxml2.XMLHTTP");
};
} catch ( e ) {
try {
// MSXML up to 2
new ActiveXObject("Microsoft.XMLHTTP");
createXMLHttpRequest = function ( ) {
return new ActiveXObject("Microsoft.XMLHTTP");
};
} catch ( e ) {
throw new Error(NAMESPACE + ": can‘t load XMLHttpRequest object");
}
}
}
function send ( method, url, body, headers ) {
throw new Error(NAMESPACE + ".send is unusable in non-compiled function");
}
var LoadedException = {};
send.$Concurrent_Thread_compiled = function ( $this, $args, $cont ) {
var method=$args[0], url=$args[1], body=$args[2], headers=$args[3];
if ( !headers || !(headers instanceof Array) ) headers = [];
var req = createXMLHttpRequest();
req.open(method, url, true);
for ( var i=0; i < headers.length; i+=2 ) {
req.setRequestHeader(headers[i], headers[i+1]);
}
var self = Concurrent.Thread.self();
var loaded = false;
var cache_hit = true;
req.onreadystatechange = function ( ) {
if ( req.readyState == 4 ) {
loaded = true;
if ( !cache_hit ) self.notify(LoadedException);
}
};
req.send(body); // Firefox occasionally causes "onload" event here. Maybe, it occurs in case of cache-hit.
cache_hit = false;
if ( loaded ) {
return {
continuation: $cont,
ret_val : req,
timeout : undefined
};
} else {
var ex_handler = {
procedure: function ( e ) {
if ( e === LoadedException ) {
return {
continuation: $cont,
ret_val : req,
timeout : undefined
};
} else {
try{ req.abort(); }catch(_){} // IE less than 7 does not support "abort".
return {
continuation: $cont.exception,
ret_val : e,
timeout : undefined
};
}
},
this_val : null
};
ex_handler.exception = ex_handler; // Cyclic reference assures to abort request.
return {
timeout : -1,
continuation: {
procedure: null,
this_val : null,
exception: ex_handler
}
};
}
};
function get ( url, headers ) {
throw new Error(NAMESPACE + ".get is unusable in non-compiled function");
}
get.$Concurrent_Thread_compiled = function ($this, $args, $cont) {
return send.$Concurrent_Thread_compiled(
null,
["GET", $args[0], $args[1], null],
$cont
);
}
function post ( url, body, headers ) {
throw new Error(NAMESPACE + ".post is unusable in non-compiled function");
}
post.$Concurrent_Thread_compiled = function ( $this, $args, $cont ) {
var url=$args[0], body=$args[1], headers=$args[2];
if ( typeof body == "object" ) {
var vals = [];
for ( var i in body ) {
if ( body.hasOwnProperty(i) ) {
vals.push( encodeURIComponent(i) + "=" + encodeURIComponent(body[i]) );
}
}
body = vals.join("&");
}
if ( !headers || !(headers instanceof Array) ) headers = [];
var content_type_exists = false;
for ( var i=0; i < headers.length; i+=2 ) {
if ( String(headers[i]).match(/^Content-type$/i) ) {
content_type_exists = true;
break;
}
}
if ( !content_type_exists ) {
headers = headers.concat("Content-type", "application/x-www-form-urlencoded");
}
return send.$Concurrent_Thread_compiled(
null,
["POST", url, body, headers],
$cont
);
};
return {
send: send, post: post, get: get
};
}();
}
}.call(null) ) {
this.Concurrent.Thread.Http.send = send;
this.Concurrent.Thread.Http.post = post;
this.Concurrent.Thread.Http.get = get;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread‘;
function Mutex ( ) {
this._acquiring = null;
this._waiting = new LinkedList();
}
var proto = Mutex.prototype;
proto.isAcquirable = function ( ) {
return !this._acquiring && this._waiting.isEmpty();
};
proto.acquire = function ( ) {
throw new Error("can‘t `acquire‘ in non-converted function");
};
proto.acquire.$Concurrent_Thread_compiled = function ( $this, $args, $cont ) {
if ( $this.isAcquirable() ) {
$this._acquiring = Thread.self();
return {
continuation: $cont ,
ret_val : void 0,
timeout : void 0
};
} else {
$this._waiting.push(Thread.self());
var callee = arguments.callee;
return {
continuation: {
procedure: null,
this_val : null,
exception: {
procedure: function( e ){
if ( e === releasedException ) {
if ( $this._waiting.shift() !== Thread.self() ) {
return {
continuation: $cont.exception,
ret_val : new IllegalStateError("unknown state (maybe bug)"),
timeout : void 0
};
}
$this._acquiring = Thread.self();
return {
continuation: $cont,
ret_val : void 0,
timeout : void 0
};
} else {
$this._waiting.head().find(function( it ){
return it === Thread.self();
}).remove();
return {
continuation: $cont.exception,
ret_val : e,
timeout : void 0
};
}
},
this_val : null,
exception: $cont.exception
}
},
ret_val: void 0,
timeout: -1
};
}
};
proto.release = function ( ) {
if ( !this._acquiring ) {
throw new IllegalStateError("mutex is not locked");
}
if ( this._acquiring !== Thread.self() ) {
throw new IllegalStateError("mutex can be released only by the thread locking it");
}
this._acquiring = null;
if ( !this._waiting.isEmpty() ) {
this._waiting.head().value().notify(releasedException);
}
};
var releasedException = {};
return {
Mutex: Mutex
};
}();
}
}
}
}
}.call(null) ) {
this.Concurrent.Thread.Mutex = Mutex;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
function Expression ( ) {
// This is kind of abstract class.
}
var proto = Expression.prototype;
proto.toString = function ( ) {
Kit.codeBug("Unimplemented method `toString‘ of class: " + this.constructor);
};
proto.containsFunctionCall = function ( ) {
Kit.codeBug("Unimplemented method `containsFunctionCall‘ of class: " + this.constructor);
};
proto.hasSideEffect = function ( ) {
Kit.codeBug("Unimplemented method `hasSideEffect‘ of class: " + this.constructor);
};
proto.hasLvalue = http://www.mamicode.com/function ( ) {"this";
};
proto.containsFunctionCall = function ( ) {
return false;
};
proto.hasSideEffect = function ( ) {
return false;
};
function temp ( ) { }
temp.prototype = ThisExpression.prototype;
var THIS_EXPRESSION = new temp();
function Identifier ( s ) {
this.string = String(s);
this.value = http://www.mamicode.com/eval(‘"‘ + this.string + ‘"‘);
}
var proto = Identifier.prototype = new Expression();
proto.constructor = Identifier;
proto.toString = function ( ) {
return this.string;
};
proto.valueOf = function ( ) {
return this.value;
};
proto.hasLvalue = http://www.mamicode.com/function ( ) {"null";
proto.vakue = null;
proto.toString = function ( ) {
return "null";
};
proto.valueOf = function ( ) {
return null;
};
function temp ( ) { }
temp.prototype = NullLiteral.prototype;
var NULL_LITERAL = new temp();
function BooleanLiteral ( ) { }
var proto = BooleanLiteral.prototype = new Literal();
proto.constructor = BooleanLiteral;
function TrueLiteral ( ) {
return TRUE_LITERAL; // Reuse object.
}
var proto = TrueLiteral.prototype = new BooleanLiteral();
proto.constructor = TrueLiteral;
proto.string = "true";
proto.vakue = true;
proto.toString = function ( ) {
return "true";
};
proto.valueOf = function ( ) {
return true;
};
function temp ( ) { }
temp.prototype = TrueLiteral.prototype;
var TRUE_LITERAL = new temp();
function FalseLiteral ( ) {
return FALSE_LITERAL; // Reuse object.
}
var proto = FalseLiteral.prototype = new BooleanLiteral();
proto.constructor = FalseLiteral;
proto.string = "false";
proto.vakue = false;
proto.toString = function ( ) {
return "false";
};
proto.valueOf = function ( ) {
return false;
};
function temp ( ) { }
temp.prototype = FalseLiteral.prototype;
var FALSE_LITERAL = new temp();
function ArrayInitializer ( elems ) {
this.elems = elems; // array of Expression
}
var proto = ArrayInitializer.prototype = new Expression();
proto.constructor = ArrayInitializer;
proto.toString = function ( ) {
return "[" + this.elems.join(", ") + "]";
};
proto.containsFunctionCall = function ( ) {
for ( var i=0; i < this.elems.length; i++ ) {
if ( this.elems[i].containsFunctionCall() ) return true;
}
return false;
};
proto.hasSideEfect = function ( ) {
for ( var i=0; i < this.elems.length; i++ ) {
if ( this.elems[i].hasSideEffect() ) return true;
}
return false;
};
function Elision ( ) { }
var proto = Elision.prototype = new Expression();
proto.constructor = Elision;
proto.toString = function ( ) {
return "";
};
proto.containsFunctionCall = function ( ) {
return false;
};
proto.hasSideEffect = function ( ) {
return false;
};
function ObjectInitializer ( v ) {
this.pairs = v; // array of {prop: Identifier or Literal, exp: Expression}
}
var proto = ObjectInitializer.prototype = new Expression();
proto.constructor = ObjectInitializer;
proto.toString = function ( ) {
var buf = [];
for ( var i=0; i < this.pairs.length; i++ ) {
buf.push( String(this.pairs[i].prop) + ":" + String(this.pairs[i].exp) );
}
return "{" + buf.join(", ") + "}";
};
proto.containsFunctionCall = function ( ) {
for ( var i=0; i < this.pairs.length; i++ ) {
if ( this.pairs[i].exp.containsFunctionCall() ) return true;
}
return false;
};
proto.hasSideEffect = function ( ) {
for ( var i=0; i < this.pairs.length; i++ ) {
if ( this.pairs[i].exp.hasSideEffect() ) return true;
}
return false;
};
function FunctionExpression ( name, params, body ) {
this.name = name; // Identifier or null
this.params = params; // array of Identifier
this.body = body; // cons-list of Statement
}
var proto = FunctionExpression.prototype = new Expression();
proto.constructor = FunctionExpression;
proto.toString = function ( ) {
var buf = ["(function "];
if ( this.name ) buf.push(this.name);
buf.push( "(", this.params.join(", "), ") {\n");
this.body.forEach(function( it ){
buf.push(it, "\n");
});
buf.push("})");
return buf.join("");
};
proto.containsFunctionCall = function ( ) {
return false;
};
proto.hasSideEffect = function ( ) {
return false;
};
function DotAccessor ( base, prop ) {
this.base = base; // Expression
this.prop = prop; // Identifier
}
var proto = DotAccessor.prototype = new Expression();
proto.constructor = DotAccessor;
proto.toString = function ( ) {
return String(this.base) + "." + String(this.prop);
};
proto.hasLvalue = http://www.mamicode.com/function ( ) {"[", this.right, "]" ].join("");
};
proto.hasLvalue = http://www.mamicode.com/function ( ) {"new ", this.func, "(", this.args.join(", "), ")" ].join("");
};
proto.containsFunctionCall = function ( ) {
return true;
};
proto.hasSideEffect = function ( ) {
return true;
};
function CallExpression ( func, args ) {
this.func = func; // Expression
this.args = args; // array of Expression
}
var proto = CallExpression.prototype = new Expression();
proto.constructor = CallExpression;
proto.toString = function ( ) {
return [ this.func, "(", this.args.join(", "), ")" ].join("");
};
proto.containsFunctionCall = function ( ) {
return true;
};
proto.hasSideEffect = function ( ) {
return true;
};
function PostIncExpression ( e ) {
UnaryExpression.apply(this, arguments);
}
var proto = PostIncExpression.prototype = new UnaryExpression();
proto.constructor = PostIncExpression;
proto.toString = function ( ) {
return String(this.exp) + "++";
};
proto.hasSideEffect = function ( ) {
return true;
};
function PostDecExpression ( e ) {
UnaryExpression.apply(this, arguments);
}
var proto = PostDecExpression.prototype = new UnaryExpression();
proto.constructor = PostDecExpression;
proto.toString = function ( ) {
return String(this.exp) + "--";
};
proto.hasSideEffect = function ( ) {
return true;
};
function PreIncExpression ( e ) {
UnaryExpression.apply(this, arguments);
}
var proto = PreIncExpression.prototype = new UnaryExpression();
proto.constructor = PreIncExpression;
proto.toString = function ( ) {
return "++" + String(this.exp);
};
proto.hasSideEffect = function ( ) {
return true;
};
function PreDecExpression ( e ) {
UnaryExpression.apply(this, arguments);
}
var proto = PreDecExpression.prototype = new UnaryExpression();
proto.constructor = PreDecExpression;
proto.toString = function ( ) {
return "--" + String(this.exp);
};
proto.hasSideEffect = function ( ) {
return true;
};
function DeleteExpression ( e ) {
UnaryExpression.apply(this, arguments);
}
var proto = DeleteExpression.prototype = new UnaryExpression();
proto.constructor = DeleteExpression;
proto.toString = function ( ) {
return "delete " + String(this.exp);
};
proto.hasSideEffect = function ( ) {
return true;
};
function VoidExpression ( e ) {
UnaryExpression.apply(this, arguments);
}
var proto = VoidExpression.prototype = new UnaryExpression();
proto.constructor = VoidExpression;
proto.toString = function ( ) {
return "void " + String(this.exp);
};
function TypeofExpression ( e ) {
UnaryExpression.apply(this, arguments);
}
var proto = TypeofExpression.prototype = new UnaryExpression();
proto.constructor = TypeofExpression;
proto.toString = function ( ) {
return "typeof " + String(this.exp);
};
function PosExpression ( e ) {
UnaryExpression.apply(this, arguments);
}
var proto = PosExpression.prototype = new UnaryExpression();
proto.constructor = PosExpression;
proto.toString = function ( ) {
return "+ " + String(this.exp);
};
function NegExpression ( e ) {
UnaryExpression.apply(this, arguments);
}
var proto = NegExpression.prototype = new UnaryExpression();
proto.constructor = NegExpression;
proto.toString = function ( ) {
return "- " + String(this.exp);
};
function BitNotExpression ( e ) {
UnaryExpression.apply(this, arguments);
}
var proto = BitNotExpression.prototype = new UnaryExpression();
proto.constructor = BitNotExpression;
proto.toString = function ( ) {
return "~" + String(this.exp);
};
function NotExpression ( e ) {
UnaryExpression.apply(this, arguments);
}
var proto = NotExpression.prototype = new UnaryExpression();
proto.constructor = NotExpression;
proto.toString = function ( ) {
return "!" + String(this.exp);
};
function MulExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = MulExpression.prototype = new BinaryExpression();
proto.constructor = MulExpression;
proto.toString = function ( ) {
return [ "(", this.left, " * ", this.right, ")" ].join("");
};
function DivExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = DivExpression.prototype = new BinaryExpression();
proto.constructor = DivExpression;
proto.toString = function ( ) {
return [ "(", this.left, " / ", this.right, ")" ].join("");
};
function ModExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = ModExpression.prototype = new BinaryExpression();
proto.constructor = ModExpression;
proto.toString = function ( ) {
return [ "(", this.left, " % ", this.right, ")" ].join("");
};
function AddExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = AddExpression.prototype = new BinaryExpression();
proto.constructor = AddExpression;
proto.toString = function ( ) {
return [ "(", this.left, " + ", this.right, ")" ].join("");
};
function SubExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = SubExpression.prototype = new BinaryExpression();
proto.constructor = SubExpression;
proto.toString = function ( ) {
return [ "(", this.left, " - ", this.right, ")" ].join("");
};
function LShiftExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = LShiftExpression.prototype = new BinaryExpression();
proto.constructor = LShiftExpression;
proto.toString = function ( ) {
return [ "(", this.left, " << ", this.right, ")" ].join("");
};
function RShiftExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = RShiftExpression.prototype = new BinaryExpression();
proto.constructor = RShiftExpression;
proto.toString = function ( ) {
return [ "(", this.left, " >> ", this.right, ")" ].join("");
};
function URShiftExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = URShiftExpression.prototype = new BinaryExpression();
proto.constructor = URShiftExpression;
proto.toString = function ( ) {
return [ "(", this.left, " >>> ", this.right, ")" ].join("");
};
function LessThanExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = LessThanExpression.prototype = new BinaryExpression();
proto.constructor = LessThanExpression;
proto.toString = function ( ) {
return [ "(", this.left, " < ", this.right, ")" ].join("");
};
function GreaterThanExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = GreaterThanExpression.prototype = new BinaryExpression();
proto.constructor = GreaterThanExpression;
proto.toString = function ( ) {
return [ "(", this.left, " > ", this.right, ")" ].join("");
};
function LessEqualExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = LessEqualExpression.prototype = new BinaryExpression();
proto.constructor = LessEqualExpression;
proto.toString = function ( ) {
return [ "(", this.left, " <= ", this.right, ")" ].join("");
};
function GreaterEqualExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = GreaterEqualExpression.prototype = new BinaryExpression();
proto.constructor = GreaterEqualExpression;
proto.toString = function ( ) {
return [ "(", this.left, " >= ", this.right, ")" ].join("");
};
function InstanceofExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = InstanceofExpression.prototype = new BinaryExpression();
proto.constructor = InstanceofExpression;
proto.toString = function ( ) {
return [ "(", this.left, " instanceof ", this.right, ")" ].join("");
};
function InExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = InExpression.prototype = new BinaryExpression();
proto.constructor = InExpression;
proto.toString = function ( ) {
return [ "(", this.left, " in ", this.right, ")" ].join("");
};
function EqualExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = EqualExpression.prototype = new BinaryExpression();
proto.constructor = EqualExpression;
proto.toString = function ( ) {
return [ "(", this.left, " == ", this.right, ")" ].join("");
};
function NotEqualExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = NotEqualExpression.prototype = new BinaryExpression();
proto.constructor = NotEqualExpression;
proto.toString = function ( ) {
return [ "(", this.left, " != ", this.right, ")" ].join("");
};
function StrictEqualExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = StrictEqualExpression.prototype = new BinaryExpression();
proto.constructor = StrictEqualExpression;
proto.toString = function ( ) {
return [ "(", this.left, " === ", this.right, ")" ].join("");
};
function StrictNotEqualExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = StrictNotEqualExpression.prototype = new BinaryExpression();
proto.constructor = StrictNotEqualExpression;
proto.toString = function ( ) {
return [ "(", this.left, " !== ", this.right, ")" ].join("");
};
function BitAndExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = BitAndExpression.prototype = new BinaryExpression();
proto.constructor = BitAndExpression;
proto.toString = function ( ) {
return [ "(", this.left, " & ", this.right, ")" ].join("");
};
function BitXorExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = BitXorExpression.prototype = new BinaryExpression();
proto.constructor = BitXorExpression;
proto.toString = function ( ) {
return [ "(", this.left, " ^ ", this.right, ")" ].join("");
};
function BitOrExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = BitOrExpression.prototype = new BinaryExpression();
proto.constructor = BitOrExpression;
proto.toString = function ( ) {
return [ "(", this.left, " | ", this.right, ")" ].join("");
};
function AndExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = AndExpression.prototype = new BinaryExpression();
proto.constructor = AndExpression;
proto.toString = function ( ) {
return [ "(", this.left, " && ", this.right, ")" ].join("");
};
function OrExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = OrExpression.prototype = new BinaryExpression();
proto.constructor = OrExpression;
proto.toString = function ( ) {
return [ "(", this.left, " || ", this.right, ")" ].join("");
};
function ConditionalExpression ( c, t, f ) {
this.cond = c; // Expression
this.texp = t; // Expression
this.fexp = f; // Expression
}
var proto = ConditionalExpression.prototype = new Expression();
proto.constructor = ConditionalExpression;
proto.toString = function ( ) {
return [ "(", this.cond, " ? ", this.texp, " : ", this.fexp, ")" ].join("");
};
proto.containsFunctionCall = function ( ) {
return this.cond.containsFunctionCall()
|| this.texp.containsFunctionCall()
|| this.fexp.containsFunctionCall();
};
proto.hasSideEffect = function ( ) {
return this.cond.hasSideEffect()
|| this.texp.hasSideEffect()
|| this.fexp.hasSideEffect();
};
function AssignExpression ( left, right ) {
// This is kind of interface. It just represents a set of classes.
BinaryExpression.apply(this, arguments);
}
var proto = AssignExpression.prototype = new BinaryExpression();
proto.constructor = AssignExpression;
proto.hasSideEffect = function ( ) {
return true;
};
function SimpleAssignExpression ( left, right ) {
AssignExpression.apply(this, arguments);
}
var proto = SimpleAssignExpression.prototype = new AssignExpression();
proto.constructor = SimpleAssignExpression;
proto.toString = function ( ) {
return [ "(", this.left, " = ", this.right, ")" ].join("");
};
function MulAssignExpression ( left, right ) {
AssignExpression.apply(this, arguments);
}
var proto = MulAssignExpression.prototype = new AssignExpression();
proto.constructor = MulAssignExpression;
proto.toString = function ( ) {
return [ "(", this.left, " *= ", this.right, ")" ].join("");
};
function DivAssignExpression ( left, right ) {
AssignExpression.apply(this, arguments);
}
var proto = DivAssignExpression.prototype = new AssignExpression();
proto.constructor = DivAssignExpression;
proto.toString = function ( ) {
return [ "(", this.left, " /= ", this.right, ")" ].join("");
};
function ModAssignExpression ( left, right ) {
AssignExpression.apply(this, arguments);
}
var proto = ModAssignExpression.prototype = new AssignExpression();
proto.constructor = ModAssignExpression;
proto.toString = function ( ) {
return [ "(", this.left, " %= ", this.right, ")" ].join("");
};
function AddAssignExpression ( left, right ) {
AssignExpression.apply(this, arguments);
}
var proto = AddAssignExpression.prototype = new AssignExpression();
proto.constructor = AddAssignExpression;
proto.toString = function ( ) {
return [ "(", this.left, " += ", this.right, ")" ].join("");
};
function SubAssignExpression ( left, right ) {
AssignExpression.apply(this, arguments);
}
var proto = SubAssignExpression.prototype = new AssignExpression();
proto.constructor = SubAssignExpression;
proto.toString = function ( ) {
return [ "(", this.left, " -= ", this.right, ")" ].join("");
};
function LShiftAssignExpression ( left, right ) {
AssignExpression.apply(this, arguments);
}
var proto = LShiftAssignExpression.prototype = new AssignExpression();
proto.constructor = LShiftAssignExpression;
proto.toString = function ( ) {
return [ "(", this.left, " <<= ", this.right, ")" ].join("");
};
function RShiftAssignExpression ( left, right ) {
AssignExpression.apply(this, arguments);
}
var proto = RShiftAssignExpression.prototype = new AssignExpression();
proto.constructor = RShiftAssignExpression;
proto.toString = function ( ) {
return [ "(", this.left, " >>= ", this.right, ")" ].join("");
};
function URShiftAssignExpression ( left, right ) {
AssignExpression.apply(this, arguments);
}
var proto = URShiftAssignExpression.prototype = new AssignExpression();
proto.constructor = URShiftAssignExpression;
proto.toString = function ( ) {
return [ "(", this.left, " >>>= ", this.right, ")" ].join("");
};
function BitAndAssignExpression ( left, right ) {
AssignExpression.apply(this, arguments);
}
var proto = BitAndAssignExpression.prototype = new AssignExpression();
proto.constructor = BitAndAssignExpression;
proto.toString = function ( ) {
return [ "(", this.left, " &= ", this.right, ")" ].join("");
};
function BitXorAssignExpression ( left, right ) {
AssignExpression.apply(this, arguments);
}
var proto = BitXorAssignExpression.prototype = new AssignExpression();
proto.constructor = BitXorAssignExpression;
proto.toString = function ( ) {
return [ "(", this.left, " ^= ", this.right, ")" ].join("");
};
function BitOrAssignExpression ( left, right ) {
AssignExpression.apply(this, arguments);
}
var proto = BitOrAssignExpression.prototype = new AssignExpression();
proto.constructor = BitOrAssignExpression;
proto.toString = function ( ) {
return [ "(", this.left, " |= ", this.right, ")" ].join("");
};
function CommaExpression ( left, right ) {
BinaryExpression.apply(this, arguments);
}
var proto = CommaExpression.prototype = new BinaryExpression();
proto.constructor = CommaExpression;
proto.toString = function ( ) {
return [ "(", this.left, ", ", this.right, ")" ].join("");
};
return {
StrictEqualExpression: StrictEqualExpression, BooleanLiteral: BooleanLiteral, OrExpression: OrExpression, NotExpression: NotExpression, ThisExpression: ThisExpression, BitAndAssignExpression: BitAndAssignExpression, DivExpression: DivExpression, BracketAccessor: BracketAccessor, CommaExpression: CommaExpression, BitAndExpression: BitAndExpression, MulExpression: MulExpression, EqualExpression: EqualExpression, CallExpression: CallExpression, FunctionExpression: FunctionExpression, Elision: Elision, PostIncExpression: PostIncExpression, InstanceofExpression: InstanceofExpression, NullLiteral: NullLiteral, BitXorAssignExpression: BitXorAssignExpression, URShiftExpression: URShiftExpression, ConditionalExpression: ConditionalExpression, Identifier: Identifier, UnaryExpression: UnaryExpression, BitOrAssignExpression: BitOrAssignExpression, DivAssignExpression: DivAssignExpression, VoidExpression: VoidExpression, TypeofExpression: TypeofExpression, NewExpression: NewExpression, MulAssignExpression: MulAssignExpression, BinaryExpression: BinaryExpression, TrueLiteral: TrueLiteral, AssignExpression: AssignExpression, SubExpression: SubExpression, PreDecExpression: PreDecExpression, RegExpLiteral: RegExpLiteral, DeleteExpression: DeleteExpression, FalseLiteral: FalseLiteral, BitNotExpression: BitNotExpression, GreaterEqualExpression: GreaterEqualExpression, LessEqualExpression: LessEqualExpression, ModExpression: ModExpression, StringLiteral: StringLiteral, LShiftAssignExpression: LShiftAssignExpression, SubAssignExpression: SubAssignExpression, LShiftExpression: LShiftExpression, ModAssignExpression: ModAssignExpression, URShiftAssignExpression: URShiftAssignExpression, NegExpression: NegExpression, PosExpression: PosExpression, AddAssignExpression: AddAssignExpression, ArrayInitializer: ArrayInitializer, LessThanExpression: LessThanExpression, NumberLiteral: NumberLiteral, StrictNotEqualExpression: StrictNotEqualExpression, RShiftExpression: RShiftExpression, InExpression: InExpression, BitOrExpression: BitOrExpression, AndExpression: AndExpression, PostDecExpression: PostDecExpression, ObjectInitializer: ObjectInitializer, RShiftAssignExpression: RShiftAssignExpression, Expression: Expression, DotAccessor: DotAccessor, Literal: Literal, SimpleAssignExpression: SimpleAssignExpression, BitXorExpression: BitXorExpression, AddExpression: AddExpression, GreaterThanExpression: GreaterThanExpression, NotEqualExpression: NotEqualExpression, PreIncExpression: PreIncExpression
};
}();
}
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.StrictEqualExpression = StrictEqualExpression;
this.Concurrent.Thread.Compiler.BooleanLiteral = BooleanLiteral;
this.Concurrent.Thread.Compiler.OrExpression = OrExpression;
this.Concurrent.Thread.Compiler.NotExpression = NotExpression;
this.Concurrent.Thread.Compiler.ThisExpression = ThisExpression;
this.Concurrent.Thread.Compiler.BitAndAssignExpression = BitAndAssignExpression;
this.Concurrent.Thread.Compiler.DivExpression = DivExpression;
this.Concurrent.Thread.Compiler.BracketAccessor = BracketAccessor;
this.Concurrent.Thread.Compiler.CommaExpression = CommaExpression;
this.Concurrent.Thread.Compiler.BitAndExpression = BitAndExpression;
this.Concurrent.Thread.Compiler.MulExpression = MulExpression;
this.Concurrent.Thread.Compiler.EqualExpression = EqualExpression;
this.Concurrent.Thread.Compiler.CallExpression = CallExpression;
this.Concurrent.Thread.Compiler.FunctionExpression = FunctionExpression;
this.Concurrent.Thread.Compiler.Elision = Elision;
this.Concurrent.Thread.Compiler.PostIncExpression = PostIncExpression;
this.Concurrent.Thread.Compiler.InstanceofExpression = InstanceofExpression;
this.Concurrent.Thread.Compiler.NullLiteral = NullLiteral;
this.Concurrent.Thread.Compiler.BitXorAssignExpression = BitXorAssignExpression;
this.Concurrent.Thread.Compiler.URShiftExpression = URShiftExpression;
this.Concurrent.Thread.Compiler.ConditionalExpression = ConditionalExpression;
this.Concurrent.Thread.Compiler.Identifier = Identifier;
this.Concurrent.Thread.Compiler.UnaryExpression = UnaryExpression;
this.Concurrent.Thread.Compiler.BitOrAssignExpression = BitOrAssignExpression;
this.Concurrent.Thread.Compiler.DivAssignExpression = DivAssignExpression;
this.Concurrent.Thread.Compiler.VoidExpression = VoidExpression;
this.Concurrent.Thread.Compiler.TypeofExpression = TypeofExpression;
this.Concurrent.Thread.Compiler.NewExpression = NewExpression;
this.Concurrent.Thread.Compiler.MulAssignExpression = MulAssignExpression;
this.Concurrent.Thread.Compiler.BinaryExpression = BinaryExpression;
this.Concurrent.Thread.Compiler.TrueLiteral = TrueLiteral;
this.Concurrent.Thread.Compiler.AssignExpression = AssignExpression;
this.Concurrent.Thread.Compiler.SubExpression = SubExpression;
this.Concurrent.Thread.Compiler.PreDecExpression = PreDecExpression;
this.Concurrent.Thread.Compiler.RegExpLiteral = RegExpLiteral;
this.Concurrent.Thread.Compiler.DeleteExpression = DeleteExpression;
this.Concurrent.Thread.Compiler.FalseLiteral = FalseLiteral;
this.Concurrent.Thread.Compiler.BitNotExpression = BitNotExpression;
this.Concurrent.Thread.Compiler.GreaterEqualExpression = GreaterEqualExpression;
this.Concurrent.Thread.Compiler.LessEqualExpression = LessEqualExpression;
this.Concurrent.Thread.Compiler.ModExpression = ModExpression;
this.Concurrent.Thread.Compiler.StringLiteral = StringLiteral;
this.Concurrent.Thread.Compiler.LShiftAssignExpression = LShiftAssignExpression;
this.Concurrent.Thread.Compiler.SubAssignExpression = SubAssignExpression;
this.Concurrent.Thread.Compiler.LShiftExpression = LShiftExpression;
this.Concurrent.Thread.Compiler.ModAssignExpression = ModAssignExpression;
this.Concurrent.Thread.Compiler.URShiftAssignExpression = URShiftAssignExpression;
this.Concurrent.Thread.Compiler.NegExpression = NegExpression;
this.Concurrent.Thread.Compiler.PosExpression = PosExpression;
this.Concurrent.Thread.Compiler.AddAssignExpression = AddAssignExpression;
this.Concurrent.Thread.Compiler.ArrayInitializer = ArrayInitializer;
this.Concurrent.Thread.Compiler.LessThanExpression = LessThanExpression;
this.Concurrent.Thread.Compiler.NumberLiteral = NumberLiteral;
this.Concurrent.Thread.Compiler.StrictNotEqualExpression = StrictNotEqualExpression;
this.Concurrent.Thread.Compiler.RShiftExpression = RShiftExpression;
this.Concurrent.Thread.Compiler.InExpression = InExpression;
this.Concurrent.Thread.Compiler.BitOrExpression = BitOrExpression;
this.Concurrent.Thread.Compiler.AndExpression = AndExpression;
this.Concurrent.Thread.Compiler.PostDecExpression = PostDecExpression;
this.Concurrent.Thread.Compiler.ObjectInitializer = ObjectInitializer;
this.Concurrent.Thread.Compiler.RShiftAssignExpression = RShiftAssignExpression;
this.Concurrent.Thread.Compiler.Expression = Expression;
this.Concurrent.Thread.Compiler.DotAccessor = DotAccessor;
this.Concurrent.Thread.Compiler.Literal = Literal;
this.Concurrent.Thread.Compiler.SimpleAssignExpression = SimpleAssignExpression;
this.Concurrent.Thread.Compiler.BitXorExpression = BitXorExpression;
this.Concurrent.Thread.Compiler.AddExpression = AddExpression;
this.Concurrent.Thread.Compiler.GreaterThanExpression = GreaterThanExpression;
this.Concurrent.Thread.Compiler.NotEqualExpression = NotEqualExpression;
this.Concurrent.Thread.Compiler.PreIncExpression = PreIncExpression;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( this.Concurrent.Thread.Compiler.Token === undefined ) this.Concurrent.Thread.Compiler.Token = undefined;
with ( function(){
with ( Concurrent.Thread.Compiler ) {
return function () {
var VERSION = ‘0.0.0‘;
var NAMESPACE;
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Rhino code, released
* May 6, 1999.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1997-1999
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Roger Lawrence
* Mike McCabe
* Igor Bukanov
* Milen Nankov
* Daisuke Maki
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License Version 2 or later (the "GPL"), in which
* case the provisions of the GPL are applicable instead of those above. If
* you wish to allow use of your version of this file only under the terms of
* the GPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replacing
* them with the notice and other provisions required by the GPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the GPL.
*
* ***** END LICENSE BLOCK ***** */
/**
* This file is based on the file Token.java in Rhino 1.6R5.
*/
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
var Token = {};
// Although Token is in fact a namespace, we here implements it
// "manually" because of efficiency.
// start enum
Token.ERROR = -1; // well-known as the only code < EOF
Token.EOF = 0; // end of file token - (not EOF_CHAR)
Token.EOL = 1; // end of line
// Interpreter reuses the following as bytecodes
Token.FIRST_BYTECODE_TOKEN = 2;
Token.ENTERWITH = 2;
Token.LEAVEWITH = 3;
Token.RETURN = 4;
Token.GOTO = 5;
Token.IFEQ = 6;
Token.IFNE = 7;
Token.SETNAME = 8;
Token.BITOR = 9;
Token.BITXOR = 10;
Token.BITAND = 11;
Token.EQ = 12;
Token.NE = 13;
Token.LT = 14;
Token.LE = 15;
Token.GT = 16;
Token.GE = 17;
Token.LSH = 18;
Token.RSH = 19;
Token.URSH = 20;
Token.ADD = 21;
Token.SUB = 22;
Token.MUL = 23;
Token.DIV = 24;
Token.MOD = 25;
Token.NOT = 26;
Token.BITNOT = 27;
Token.POS = 28;
Token.NEG = 29;
Token.NEW = 30;
Token.DELPROP = 31;
Token.TYPEOF = 32;
Token.GETPROP = 33;
Token.SETPROP = 34;
Token.GETELEM = 35;
Token.SETELEM = 36;
Token.CALL = 37;
Token.NAME = 38;
Token.NUMBER = 39;
Token.STRING = 40;
Token.NULL = 41;
Token.THIS = 42;
Token.FALSE = 43;
Token.TRUE = 44;
Token.SHEQ = 45; // shallow equality (===)
Token.SHNE = 46; // shallow inequality (!==)
Token.REGEXP = 47;
Token.BINDNAME = 48;
Token.THROW = 49;
Token.RETHROW = 50; // rethrow caught execetion: catch (e if ) use it
Token.IN = 51;
Token.INSTANCEOF = 52;
Token.LOCAL_LOAD = 53;
Token.GETVAR = 54;
Token.SETVAR = 55;
Token.CATCH_SCOPE = 56;
Token.ENUM_INIT_KEYS = 57;
Token.ENUM_INIT_VALUES = 58;
Token.ENUM_NEXT = 59;
Token.ENUM_ID = 60;
Token.THISFN = 61;
Token.RETURN_RESULT = 62; // to return prevoisly stored return result
Token.ARRAYLIT = 63; // array literal
Token.OBJECTLIT = 64; // object literal
Token.GET_REF = 65; // *reference
Token.SET_REF = 66; // *reference : something
Token.DEL_REF = 67; // delete reference
Token.REF_CALL = 68; // f(args) = something or f(args)++
Token.REF_SPECIAL = 69; // reference for special properties like __proto
// For XML support:
Token.DEFAULTNAMESPACE = 70; // default xml namespace =
Token.ESCXMLATTR = 71;
Token.ESCXMLTEXT = 72;
Token.REF_MEMBER = 73; // Reference for x.@y, x..y etc.
Token.REF_NS_MEMBER = 74; // Reference for x.ns::y, x..ns::y etc.
Token.REF_NAME = 75; // Reference for @y, @[y] etc.
Token.REF_NS_NAME = 76; // Reference for ns::y, @ns::y@[y] etc.
// End of interpreter bytecodes
Token.LAST_BYTECODE_TOKEN = Token.REF_NS_NAME;
Token.TRY = 77;
Token.SEMI = 78; // semicolon
Token.LB = 79; // left and right brackets
Token.RB = 80;
Token.LC = 81; // left and right curlies (braces)
Token.RC = 82;
Token.LP = 83; // left and right parentheses
Token.RP = 84;
Token.COMMA = 85; // comma operator
Token.ASSIGN = 86; // simple assignment (=)
Token.ASSIGN_BITOR = 87; // |=
Token.ASSIGN_BITXOR = 88; // ^=
Token.ASSIGN_BITAND = 89; // |=
Token.ASSIGN_LSH = 90; // <<=
Token.ASSIGN_RSH = 91; // >>=
Token.ASSIGN_URSH = 92; // >>>=
Token.ASSIGN_ADD = 93; // +=
Token.ASSIGN_SUB = 94; // -=
Token.ASSIGN_MUL = 95; // *=
Token.ASSIGN_DIV = 96; // /=
Token.ASSIGN_MOD = 97; // %=
Token.FIRST_ASSIGN = Token.ASSIGN;
Token.LAST_ASSIGN = Token.ASSIGN_MOD;
Token.HOOK = 98; // conditional (?:)
Token.COLON = 99;
Token.OR = 100; // logical or (||)
Token.AND = 101; // logical and (&&)
Token.INC = 102; // increment/decrement (++ --)
Token.DEC = 103;
Token.DOT = 104; // member operator (.)
Token.FUNCTION = 105; // function keyword
Token.EXPORT = 106; // export keyword
Token.IMPORT = 107; // import keyword
Token.IF = 108; // if keyword
Token.ELSE = 109; // else keyword
Token.SWITCH = 110; // switch keyword
Token.CASE = 111; // case keyword
Token.DEFAULT = 112; // default keyword
Token.WHILE = 113; // while keyword
Token.DO = 114; // do keyword
Token.FOR = 115; // for keyword
Token.BREAK = 116; // break keyword
Token.CONTINUE = 117; // continue keyword
Token.VAR = 118; // var keyword
Token.WITH = 119; // with keyword
Token.CATCH = 120; // catch keyword
Token.FINALLY = 121; // finally keyword
Token.VOID = 122; // void keyword
Token.RESERVED = 123; // reserved keywords
Token.EMPTY = 124;
/* types used for the parse tree - these never get returned
* by the scanner.
*/
Token.BLOCK = 125; // statement block
Token.LABEL = 126; // label
Token.TARGET = 127;
Token.LOOP = 128;
Token.EXPR_VOID = 129; // expression statement in functions
Token.EXPR_RESULT = 130; // expression statement in scripts
Token.JSR = 131;
Token.SCRIPT = 132; // top-level node for entire script
Token.TYPEOFNAME = 133; // for typeof(simple-name)
Token.USE_STACK = 134;
Token.SETPROP_OP = 135; // x.y op= something
Token.SETELEM_OP = 136; // x[y] op= something
Token.LOCAL_BLOCK = 137;
Token.SET_REF_OP = 138; // *reference op= something
// For XML support:
Token.DOTDOT = 139; // member operator (..)
Token.COLONCOLON = 140; // namespace::name
Token.XML = 141; // XML type
Token.DOTQUERY = 142; // .() -- e.g., x.emps.emp.(name == "terry")
Token.XMLATTR = 143; // @
Token.XMLEND = 144;
// Optimizer-only-tokens
Token.TO_OBJECT = 145;
Token.TO_DOUBLE = 146;
Token.LAST_TOKEN = 146;
Token.name = function ( token )
{
if ( !Kit.printTrees ) return String(token);
with ( Token ) {
switch ( token ) {
case ERROR: return "ERROR";
case EOF: return "EOF";
case EOL: return "EOL";
case ENTERWITH: return "ENTERWITH";
case LEAVEWITH: return "LEAVEWITH";
case RETURN: return "RETURN";
case GOTO: return "GOTO";
case IFEQ: return "IFEQ";
case IFNE: return "IFNE";
case SETNAME: return "SETNAME";
case BITOR: return "BITOR";
case BITXOR: return "BITXOR";
case BITAND: return "BITAND";
case EQ: return "EQ";
case NE: return "NE";
case LT: return "LT";
case LE: return "LE";
case GT: return "GT";
case GE: return "GE";
case LSH: return "LSH";
case RSH: return "RSH";
case URSH: return "URSH";
case ADD: return "ADD";
case SUB: return "SUB";
case MUL: return "MUL";
case DIV: return "DIV";
case MOD: return "MOD";
case NOT: return "NOT";
case BITNOT: return "BITNOT";
case POS: return "POS";
case NEG: return "NEG";
case NEW: return "NEW";
case DELPROP: return "DELPROP";
case TYPEOF: return "TYPEOF";
case GETPROP: return "GETPROP";
case SETPROP: return "SETPROP";
case GETELEM: return "GETELEM";
case SETELEM: return "SETELEM";
case CALL: return "CALL";
case NAME: return "NAME";
case NUMBER: return "NUMBER";
case STRING: return "STRING";
case NULL: return "NULL";
case THIS: return "THIS";
case FALSE: return "FALSE";
case TRUE: return "TRUE";
case SHEQ: return "SHEQ";
case SHNE: return "SHNE";
case REGEXP: return "OBJECT";
case BINDNAME: return "BINDNAME";
case THROW: return "THROW";
case RETHROW: return "RETHROW";
case IN: return "IN";
case INSTANCEOF: return "INSTANCEOF";
case LOCAL_LOAD: return "LOCAL_LOAD";
case GETVAR: return "GETVAR";
case SETVAR: return "SETVAR";
case CATCH_SCOPE: return "CATCH_SCOPE";
case ENUM_INIT_KEYS: return "ENUM_INIT_KEYS";
case ENUM_INIT_VALUES: return "ENUM_INIT_VALUES";
case ENUM_NEXT: return "ENUM_NEXT";
case ENUM_ID: return "ENUM_ID";
case THISFN: return "THISFN";
case RETURN_RESULT: return "RETURN_RESULT";
case ARRAYLIT: return "ARRAYLIT";
case OBJECTLIT: return "OBJECTLIT";
case GET_REF: return "GET_REF";
case SET_REF: return "SET_REF";
case DEL_REF: return "DEL_REF";
case REF_CALL: return "REF_CALL";
case REF_SPECIAL: return "REF_SPECIAL";
case DEFAULTNAMESPACE:return "DEFAULTNAMESPACE";
case ESCXMLTEXT: return "ESCXMLTEXT";
case ESCXMLATTR: return "ESCXMLATTR";
case REF_MEMBER: return "REF_MEMBER";
case REF_NS_MEMBER: return "REF_NS_MEMBER";
case REF_NAME: return "REF_NAME";
case REF_NS_NAME: return "REF_NS_NAME";
case TRY: return "TRY";
case SEMI: return "SEMI";
case LB: return "LB";
case RB: return "RB";
case LC: return "LC";
case RC: return "RC";
case LP: return "LP";
case RP: return "RP";
case COMMA: return "COMMA";
case ASSIGN: return "ASSIGN";
case ASSIGN_BITOR: return "ASSIGN_BITOR";
case ASSIGN_BITXOR: return "ASSIGN_BITXOR";
case ASSIGN_BITAND: return "ASSIGN_BITAND";
case ASSIGN_LSH: return "ASSIGN_LSH";
case ASSIGN_RSH: return "ASSIGN_RSH";
case ASSIGN_URSH: return "ASSIGN_URSH";
case ASSIGN_ADD: return "ASSIGN_ADD";
case ASSIGN_SUB: return "ASSIGN_SUB";
case ASSIGN_MUL: return "ASSIGN_MUL";
case ASSIGN_DIV: return "ASSIGN_DIV";
case ASSIGN_MOD: return "ASSIGN_MOD";
case HOOK: return "HOOK";
case COLON: return "COLON";
case OR: return "OR";
case AND: return "AND";
case INC: return "INC";
case DEC: return "DEC";
case DOT: return "DOT";
case FUNCTION: return "FUNCTION";
case EXPORT: return "EXPORT";
case IMPORT: return "IMPORT";
case IF: return "IF";
case ELSE: return "ELSE";
case SWITCH: return "SWITCH";
case CASE: return "CASE";
case DEFAULT: return "DEFAULT";
case WHILE: return "WHILE";
case DO: return "DO";
case FOR: return "FOR";
case BREAK: return "BREAK";
case CONTINUE: return "CONTINUE";
case VAR: return "VAR";
case WITH: return "WITH";
case CATCH: return "CATCH";
case FINALLY: return "FINALLY";
case RESERVED: return "RESERVED";
case EMPTY: return "EMPTY";
case BLOCK: return "BLOCK";
case LABEL: return "LABEL";
case TARGET: return "TARGET";
case LOOP: return "LOOP";
case EXPR_VOID: return "EXPR_VOID";
case EXPR_RESULT: return "EXPR_RESULT";
case JSR: return "JSR";
case SCRIPT: return "SCRIPT";
case TYPEOFNAME: return "TYPEOFNAME";
case USE_STACK: return "USE_STACK";
case SETPROP_OP: return "SETPROP_OP";
case SETELEM_OP: return "SETELEM_OP";
case LOCAL_BLOCK: return "LOCAL_BLOCK";
case SET_REF_OP: return "SET_REF_OP";
case DOTDOT: return "DOTDOT";
case COLONCOLON: return "COLONCOLON";
case XML: return "XML";
case DOTQUERY: return "DOTQUERY";
case XMLATTR: return "XMLATTR";
case XMLEND: return "XMLEND";
case TO_OBJECT: return "TO_OBJECT";
case TO_DOUBLE: return "TO_DOUBLE";
}
}
// Token without name
Kit.codeBug(token);
};
return {
Token: Token
};
}();
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.Token = Token;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
function Statement ( labels, lineno, source ) {
// This is kind of abstract class.
this.labels = labels; // array of Identifier # labels directly qualifying this statement
this.lineno = lineno; // Number (optional) # line no.
this.source = source; // String (optional) # file-name, URL, ...etc
}
Statement.prototype.toString = function ( ) {
Kit.codeBug();
};
// kind of final protected method.
// Use this like: labelsToString.call(obj, arg0, arg1 ...)
function labelsToString ( ) {
var buf = [];
for ( var i=0; i < this.labels.length; i++ ) {
buf.push(this.labels[i], ": ");
}
return buf.join("");
}
function EmptyStatement ( labels, lineno, source ) {
Statement.call(this, labels, lineno, source);
}
var proto = EmptyStatement.prototype = new Statement();
proto.constructor = EmptyStatement;
proto.toString = function ( ) {
return labelsToString.call(this) + ";";
};
function Block ( labels, body, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.body = body; // cons-list of Statement
}
var proto = Block.prototype = new Statement();
proto.constructor = Block;
proto.toString = function ( ) {
var buf = [labelsToString.call(this), "{"];
this.body.forEach(function( it ){
buf.push(it);
});
buf.push("}");
return buf.join("\n");
};
function ExpStatement ( labels, exp, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.exp = exp; // Expression
}
var proto = ExpStatement.prototype = new Statement();
proto.constructor = ExpStatement;
proto.toString = function ( ) {
return labelsToString.call(this) + String(this.exp) + ";";
};
proto.containsFunctionCall = function ( ) {
return this.exp.containsFunctionCall();
};
function VarStatement ( labels, decls, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.decls = decls; // array of {id: Identifier, exp: Expression or null}
}
var proto = VarStatement.prototype = new Statement();
proto.constructor = VarStatement;
proto.toString = function ( ) {
var buf = [];
for ( var i=0; i < this.decls.length; i++ ) {
if ( this.decls[i].exp ) {
buf.push( [ this.decls[i].id, "=", this.decls[i].exp ].join("") );
}
else {
buf.push( this.decls[i].id );
}
}
return [ labelsToString.call(this),
"var ",
buf.join(", "),
";",
].join("");
};
proto.containsFunctionCall = function ( ) {
for ( var i=0; i < this.decls.length; i++ ) {
if ( this.decls[i].exp && this.decls[i].exp.containsFunctionCall() ) {
return true;
}
}
return false;
};
function IfStatement ( labels, cond, body, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.cond = cond; // Expression
this.body = body; // Statement
}
var proto = IfStatement.prototype = new Statement();
proto.constructor = IfStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"if (",
this.cond,
") ",
this.body
].join("");
};
function IfElseStatement ( labels, cond, tbody, fbody, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.cond = cond; // Expression
this.tbody = tbody; // Statement
this.fbody = fbody; // Statement
}
var proto = IfElseStatement.prototype = new Statement();
proto.constructor = IfElseStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"if (",
this.cond,
") ",
this.tbody,
"\n",
"else ",
this.fbody
].join("");
};
function DoWhileStatement ( labels, body, cond, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.body = body; // Statement
this.cond = cond; // Expression
}
var proto = DoWhileStatement.prototype = new Statement();
proto.constructor = DoWhileStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"do ",
this.body,
" while (",
this.cond,
");"
].join("");
};
function WhileStatement ( labels, cond, body, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.cond = cond; // Expression
this.body = body; // Statement
}
var proto = WhileStatement.prototype = new Statement();
proto.constructor = WhileStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"while (",
this.cond,
") ",
this.body
].join("");
};
function ForStatement ( labels, init, cond, incr, body, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.init = init; // Expression or null
this.cond = cond; // Expression or null
this.incr = incr; // Expression or null
this.body = body; // Statement
}
var proto = ForStatement.prototype = new Statement();
proto.constructor = ForStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"for (",
this.init ? this.init : "", "; ",
this.cond ? this.cond : "", "; ",
this.incr ? this.incr : "",
") ",
this.body
].join("");
};
function ForVarStatement ( labels, decls, cond, incr, body, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.decls = decls; // array of {id: Identifier, exp: Expression or null}
this.cond = cond; // Expression or null
this.incr = incr; // Expression or null
this.body = body; // Statement
}
var proto = ForVarStatement.prototype = new Statement();
proto.constructor = ForVarStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"for (",
(this.decls.length ? new VarStatement([], this.decls) : ";"), " ",
this.cond ? this.cond : "", "; ",
this.incr ? this.incr : "",
") ",
this.body
].join("");
};
function ForInStatement ( labels, lhs, exp, body, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.lhs = lhs; // Identifier or DotAccessor or BracketAccessor
this.exp = exp; // Expression
this.body = body; // Statement
}
var proto = ForInStatement.prototype = new Statement();
proto.constructor = ForInStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"for (", this.lhs, " in ", this.exp, ") ",
this.body
].join("");
};
function ForInVarStatement ( labels, decl, exp, body, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.decl = decl; // {id: Identifier, exp: Expression or null}
this.exp = exp; // Expression
this.body = body; // Statement
}
var proto = ForInVarStatement.prototype = new Statement();
proto.constructor = ForInVarStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"for ( var ",
this.decl.exp ? String(this.decl.id) + "=" + String(this.decl.exp)
: String(this.decl.id),
" in ",
this.exp,
") ",
this.body
].join("");
};
// Mozilla extention "for each ( ... in ... )"
function ForEachStatement ( labels, lhs, exp, body, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.lhs = lhs; // Identifier or DotAccessor or BracketAccessor
this.exp = exp; // Expression
this.body = body; // Statement
}
var proto = ForEachStatement.prototype = new Statement();
proto.constructor = ForEachStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"for each (", this.lhs, " in ", this.exp, ") ",
this.body
].join("");
};
function ForEachVarStatement ( labels, decl, exp, body, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.decl = decl; // {id: Identifier, exp: Expression or null}
this.exp = exp; // Expression
this.body = body; // Statement
}
var proto = ForEachVarStatement.prototype = new Statement();
proto.constructor = ForEachVarStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"for each ( var ",
this.decl.exp ? String(this.decl.id) + "=" + String(this.decl.exp)
: String(this.decl.id),
" in ",
this.exp,
") ",
this.body
].join("");
};
function ContinueStatement ( labels, target, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.target = target; // Identifier or null
}
var proto = ContinueStatement.prototype = new Statement();
proto.constructor = ContinueStatement;
proto.toString = function ( ) {
var buf = [labelsToString.call(this), "continue"];
if ( this.target ) buf.push(" ", this.target);
buf.push(";");
return buf.join("");
};
function BreakStatement ( labels, target, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.target = target; // Identifier or null
}
var proto = BreakStatement.prototype = new Statement();
proto.constructor = BreakStatement;
proto.toString = function ( ) {
var buf = [labelsToString.call(this), "break"];
if ( this.target ) buf.push(" ", this.target);
buf.push(";");
return buf.join("");
};
function ReturnStatement ( labels, exp, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.exp = exp; // Expression or null
}
var proto = ReturnStatement.prototype = new Statement();
proto.constructor = ReturnStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"return ",
this.exp ? this.exp : "",
";"
].join("");
};
function WithStatement ( labels, exp, body, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.exp = exp; // Expression
this.body = body; // Statement
}
var proto = WithStatement.prototype = new Statement();
proto.constructor = WithStatement;
proto.toString = function ( ) {
return [ "with (", this.exp, ") ", this.body ].join("");
};
function SwitchStatement ( labels, exp, clauses, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.exp = exp; // Expression
this.clauses = clauses; // cons-list of (CaseClause or DefaultClause)
}
var proto = SwitchStatement.prototype = new Statement();
proto.constructor = SwitchStatement;
proto.toString = function ( ) {
var buf = [ "switch ( ", this.exp, ") {\n"];
this.clauses.forEach(function( it ){
buf.push(it, "\n");
});
buf.push("}");
return buf.join("");
};
function CaseClause ( exp, body, lineno, source ) {
this.exp = exp; // Expression
this.body = body; // cons-list of Statement
this.lineno = lineno; // Number (optional)
this.source = source; // String (optional)
}
CaseClause.prototype.toString = function ( ) {
var buf = ["case ", this.exp, ":\n"];
this.body.forEach(function( it ){
buf.push(it, "\n");
});
return buf.join("");
};
function DefaultClause ( body, lineno, source ) {
this.body = body; // cons-list of Statement
this.lineno = lineno; // Number (optional)
this.source = source; // String (optional)
}
DefaultClause.prototype.toString = function ( ) {
var buf = ["default:\n"];
this.body.forEach(function( it ){
buf.push(it, "\n");
});
return buf.join("");
};
function ThrowStatement ( labels, exp, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.exp = exp; // Expression
}
var proto = ThrowStatement.prototype = new Statement();
proto.constructor = ThrowStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"throw ", this.exp, ";"
].join("");
};
function TryCatchStatement ( labels, tryBlock, variable, catchBlock, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.tryBlock = tryBlock; // Block
this.variable = variable; // Identifier
this.catchBlock = catchBlock; // Block
}
var proto = TryCatchStatement.prototype = new Statement();
proto.constructor = TryCatchStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"try ", this.tryBlock, "\n",
"catch (", this.variable, ") ", this.catchBlock
].join("");
};
function TryFinallyStatement ( labels, tryBlock, finallyBlock, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.tryBlock = tryBlock; // Block
this.finallyBlock = finallyBlock; // Block
}
var proto = TryFinallyStatement.prototype = new Statement();
proto.constructor = TryFinallyStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"try ", this.tryBlock, "\n",
"finally ", this.finallyBlock
].join("");
};
function TryCatchFinallyStatement ( labels, tryBlock, variable, catchBlock, finallyBlock, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.tryBlock = tryBlock; // Block
this.variable = variable; // Identifier
this.catchBlock = catchBlock; // Block
this.finallyBlock = finallyBlock; // Block
}
var proto = TryCatchFinallyStatement.prototype = new Statement();
proto.constructor = TryCatchFinallyStatement;
proto.toString = function ( ) {
return [ labelsToString.call(this),
"try ", this.tryBlock, "\n",
"catch (", this.variable, ") ", this.catchBlock, "\n",
"finally ", this.finallyBlock
].join("");
};
function TryCatchListStatement ( labels, tryBlock, catchList, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.tryBlock = tryBlock; // Block
this.catchList = catchList; // cons-list of CatchGuard
}
var proto = TryCatchListStatement.prototype = new Statement();
proto.constructor = TryCatchListStatement;
proto.toString = function ( ) {
var buf = [ labelsToString.call(this),
"try ", this.tryBlock, "\n" ];
this.catchList.forEach(function( it ){
buf.push(it);
});
return buf.join("");
};
function TryCatchListFinallyStatement ( labels, tryBlock, catchList, finallyBlock, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.tryBlock = tryBlock; // Block
this.catchList = catchList; // cons-list of CatchGuard
this.finallyBlock = finallyBlock; // Block
}
var proto = TryCatchListFinallyStatement.prototype = new Statement();
proto.constructor = TryCatchListFinallyStatement;
proto.toString = function ( ) {
var buf = [ labelsToString.call(this),
"try ", this.tryBlock, "\n" ];
this.catchList.forEach(function( it ){
buf.push(it);
});
buf.push("finally ", this.finallyBlock);
return buf.join("");
};
function CatchGuard ( variable, cond, block, lineno, source ) {
this.variable = variable; // Identifier
this.cond = cond; // Expression or null (null means this is default catch clause)
this.block = block; // Block
this.lineno = lineno; // Number (optional)
this.source = source; // String (optional)
}
CatchGuard.prototype.toString = function ( ) {
var buf = ["catch ( ", this.variable];
if ( this.cond ) buf.push(" if ", this.cond);
buf.push(" )", this.block);
return buf.join("");
};
function FunctionDeclaration ( labels, name, params, body, lineno, source ) {
Statement.call(this, labels, lineno, source);
this.name = name; // Identifier
this.params = params; // array of Identifier
this.body = body; // cons-list of Statement
}
var proto = FunctionDeclaration.prototype = new Statement();
proto.constructor = FunctionDeclaration;
proto.toString = function ( ) {
var buf = [ "function ", this.name,
" (", this.params.join(", "), ") {\n" ];
this.body.forEach(function( it ){
buf.push(it, "\n");
});
buf.push("}");
return buf.join("");
};
return {
CatchGuard: CatchGuard, Block: Block, IfStatement: IfStatement, FunctionDeclaration: FunctionDeclaration, ForVarStatement: ForVarStatement, IfElseStatement: IfElseStatement, TryFinallyStatement: TryFinallyStatement, TryCatchFinallyStatement: TryCatchFinallyStatement, ThrowStatement: ThrowStatement, ForEachStatement: ForEachStatement, EmptyStatement: EmptyStatement, TryCatchStatement: TryCatchStatement, WithStatement: WithStatement, ExpStatement: ExpStatement, ReturnStatement: ReturnStatement, Statement: Statement, ForInVarStatement: ForInVarStatement, BreakStatement: BreakStatement, TryCatchListStatement: TryCatchListStatement, DoWhileStatement: DoWhileStatement, ForInStatement: ForInStatement, DefaultClause: DefaultClause, VarStatement: VarStatement, ContinueStatement: ContinueStatement, TryCatchListFinallyStatement: TryCatchListFinallyStatement, WhileStatement: WhileStatement, SwitchStatement: SwitchStatement, ForEachVarStatement: ForEachVarStatement, CaseClause: CaseClause, ForStatement: ForStatement
};
}();
}
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.CatchGuard = CatchGuard;
this.Concurrent.Thread.Compiler.Block = Block;
this.Concurrent.Thread.Compiler.IfStatement = IfStatement;
this.Concurrent.Thread.Compiler.FunctionDeclaration = FunctionDeclaration;
this.Concurrent.Thread.Compiler.ForVarStatement = ForVarStatement;
this.Concurrent.Thread.Compiler.IfElseStatement = IfElseStatement;
this.Concurrent.Thread.Compiler.TryFinallyStatement = TryFinallyStatement;
this.Concurrent.Thread.Compiler.TryCatchFinallyStatement = TryCatchFinallyStatement;
this.Concurrent.Thread.Compiler.ThrowStatement = ThrowStatement;
this.Concurrent.Thread.Compiler.ForEachStatement = ForEachStatement;
this.Concurrent.Thread.Compiler.EmptyStatement = EmptyStatement;
this.Concurrent.Thread.Compiler.TryCatchStatement = TryCatchStatement;
this.Concurrent.Thread.Compiler.WithStatement = WithStatement;
this.Concurrent.Thread.Compiler.ExpStatement = ExpStatement;
this.Concurrent.Thread.Compiler.ReturnStatement = ReturnStatement;
this.Concurrent.Thread.Compiler.Statement = Statement;
this.Concurrent.Thread.Compiler.ForInVarStatement = ForInVarStatement;
this.Concurrent.Thread.Compiler.BreakStatement = BreakStatement;
this.Concurrent.Thread.Compiler.TryCatchListStatement = TryCatchListStatement;
this.Concurrent.Thread.Compiler.DoWhileStatement = DoWhileStatement;
this.Concurrent.Thread.Compiler.ForInStatement = ForInStatement;
this.Concurrent.Thread.Compiler.DefaultClause = DefaultClause;
this.Concurrent.Thread.Compiler.VarStatement = VarStatement;
this.Concurrent.Thread.Compiler.ContinueStatement = ContinueStatement;
this.Concurrent.Thread.Compiler.TryCatchListFinallyStatement = TryCatchListFinallyStatement;
this.Concurrent.Thread.Compiler.WhileStatement = WhileStatement;
this.Concurrent.Thread.Compiler.SwitchStatement = SwitchStatement;
this.Concurrent.Thread.Compiler.ForEachVarStatement = ForEachVarStatement;
this.Concurrent.Thread.Compiler.CaseClause = CaseClause;
this.Concurrent.Thread.Compiler.ForStatement = ForStatement;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( this.Concurrent.Thread.Compiler.IdentifierMap === undefined ) this.Concurrent.Thread.Compiler.IdentifierMap = undefined;
with ( function(){
with ( Concurrent.Thread.Compiler ) {
return function () {
var VERSION ;
var NAMESPACE;
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
var hasOwnProperty = Object.prototype.hasOwnProperty;
function IdentifierMap ( ) {
this._map = {};
}
var proto = IdentifierMap.prototype;
proto.clone = function clone ( ) {
var c = new IdentifierMap();
for ( var i in this._map ) {
if ( hasOwnProperty.call(this._map, i) ) c._map[i] = this._map[i];
}
return c;
};
proto.exists = function ( /* variable arguments */ ) {
for ( var i=0; i < arguments.length; i++ ) {
var key = arguments[i];
if ( !(key instanceof Identifier) ) throw new TypeError("arguments[" + i + "] is not of type Identifier");
if ( !hasOwnProperty.call(this._map, key.valueOf()) ) return false;
}
return true;
};
proto.get = function ( k ) {
if ( !(k instanceof Identifier) ) throw new TypeError("arguments[0] is not of type Identifier");
var s = k.valueOf();
if ( !hasOwnProperty.call(this._map, s) ) return undefined;
return this._map[s].value;
};
proto.put = function ( k, v ) {
if ( !(k instanceof Identifier) ) throw new TypeError("arguments[0] is not of type Identifier");
this._map[k.valueOf()] = {id: k, value: v};
};
proto.remove = function ( k ) {
if ( !(k instanceof Identifier) ) throw new TypeError("arguments[0] is not of type Identifier");
return delete this._map[k.valueOf()];
};
proto.keys = function ( ) {
var set = new IdentifierSet();
for ( var i in this._map ) {
if ( hasOwnProperty.call(this._map, i) ) set.add(this._map[i].id);
}
return set;
};
proto.values = function ( ) {
var vals = [];
for ( var i in this._map ) {
if ( hasOwnProperty.call(this._map, i) ) vals.push(this._map[i].value);
}
return vals;
};
return {
IdentifierMap: IdentifierMap
};
}();
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.IdentifierMap = IdentifierMap;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( this.Concurrent.Thread.Compiler.TokenStream === undefined ) this.Concurrent.Thread.Compiler.TokenStream = undefined;
with ( function(){
with ( Concurrent.Thread.Compiler ) {
return function () {
var VERSION = ‘0.0.0‘;
var NAMESPACE;
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Rhino code, released
* May 6, 1999.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1997-1999
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Roger Lawrence
* Mike McCabe
* Igor Bukanov
* Ethan Hugg
* Terry Lucas
* Milen Nankov
* Daisuke Maki
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License Version 2 or later (the "GPL"), in which
* case the provisions of the GPL are applicable instead of those above. If
* you wish to allow use of your version of this file only under the terms of
* the GPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replacing
* them with the notice and other provisions required by the GPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the GPL.
*
* ***** END LICENSE BLOCK ***** */
/**
* This file is based on the file TokenStream.java in Rhino 1.6R5.
*/
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
/*
* For chars - because we need something out-of-range
* to check. (And checking EOF by exception is annoying.)
* Fortunatelly, U+FFFF is guaranteed not to be assigned
* for any character.
* Note distinction from EOF token type!
*/
var EOF_CHAR = String.fromCharCode(0xFFFF);
function TokenStream( parser, sourceString, lineno )
{
this.parser = parser;
this.sourceString = String(sourceString);
this.sourceEnd = this.sourceString.length;
this.sourceCursor = 0;
// stuff other than whitespace since start of line
this.dirtyLine = false;
this.string = "";
this.stringBuffer = [];
this.ungetBuffer = [];
this.hitEOF = false;
this.lineStart = 0;
this.lineno = Number(lineno) || 1;
this.lineEndChar = undefined;
// for xml tokenizer
this.xmlIsAttribute = false;
this.xmlIsTagContent = false;
this.xmlOpenTagsCount = 0;
}
var proto = TokenStream.prototype;
/* This function uses the cached op, string and number fields in
* TokenStream; if getToken has been called since the passed token
* was scanned, the op or string printed may be incorrect.
*/
proto.tokenToString = function ( token )
{
if (Token.printTrees) {
var name = Token.name(token);
switch ( token ) {
case Token.STRING:
case Token.REGEXP:
case Token.NAME:
return name + " `" + this.string + "‘";
case Token.NUMBER:
return "NUMBER " + this.number;
}
return name;
}
return "";
};
function isKeyword ( s )
{
return Token.EOF != stringToKeyword(s);
}
var strIdMap = {
"break" : Token.BREAK,
"case" : Token.CASE,
"catch" : Token.CATCH,
"continue" : Token.CONTINUE,
"default" : Token.DEFAULT,
"delete" : Token.DELPROP,
"do" : Token.DO,
"else" : Token.ELSE,
"export" : Token.EXPORT,
"false" : Token.FALSE,
"finally" : Token.FINALLY,
"for" : Token.FOR,
"function" : Token.FUNCTION,
"if" : Token.IF,
"in" : Token.IN,
"instanceof" : Token.INSTANCEOF,
"new" : Token.NEW,
"null" : Token.NULL,
"return" : Token.RETURN,
"switch" : Token.SWITCH,
"this" : Token.THIS,
"throw" : Token.THROW,
"true" : Token.TRUE,
"try" : Token.TRY,
"typeof" : Token.TYPEOF,
"var" : Token.VAR,
"void" : Token.VOID,
"while" : Token.WHILE,
"with" : Token.WITH,
// Future Reserved Words
"abstract" : Token.RESERVED,
"boolean" : Token.RESERVED,
"byte" : Token.RESERVED,
"char" : Token.RESERVED,
"class" : Token.RESERVED,
"const" : Token.RESERVED,
"debugger" : Token.RESERVED,
"double" : Token.RESERVED,
"enum" : Token.RESERVED,
"extends" : Token.RESERVED,
"final" : Token.RESERVED,
"float" : Token.RESERVED,
"goto" : Token.RESERVED,
"implements" : Token.RESERVED,
"import" : Token.IMPORT,
"int" : Token.RESERVED,
"interface" : Token.RESERVED,
"long" : Token.RESERVED,
"native" : Token.RESERVED,
"package" : Token.RESERVED,
"private" : Token.RESERVED,
"protected" : Token.RESERVED,
"public" : Token.RESERVED,
"short" : Token.RESERVED,
"static" : Token.RESERVED,
"super" : Token.RESERVED,
"synchronized" : Token.RESERVED,
"throws" : Token.RESERVED,
"transient" : Token.RESERVED,
"volatile" : Token.RESERVED
};
function stringToKeyword ( name )
{
return strIdMap.hasOwnProperty(name) ? strIdMap[name] : Token.EOF;
}
proto.getLineno = function ( ) { return this.lineno; };
proto.getString = function ( ) { return this.string; };
proto.eof = function ( ) { return this.hitEOF; };
proto.getToken = function ( )
{
var c;
retry:
for (;;) {
// Eat whitespace, possibly sensitive to newlines.
for (;;) {
c = this.getChar();
if ( c === EOF_CHAR ) {
return Token.EOF;
} else if ( c === ‘\n‘ ) {
this.dirtyLine = false;
return Token.EOL;
} else if ( !isSpace(c) ) {
if ( c !== ‘-‘ ) {
this.dirtyLine = true;
}
break;
}
}
// identifier/keyword/instanceof?
// watch out for starting with a <backslash>
var identifierStart = false;
var isUnicodeEscapeStart = false;
if ( c === ‘\\‘ ) {
c = this.getChar();
if ( c === ‘u‘ ) {
identifierStart = true;
isUnicodeEscapeStart = true;
this.stringBuffer = ["\\u"];
} else {
identifierStart = false;
this.ungetChar(c);
c = ‘\\‘;
}
} else if ( isIdentifierStart(c) ) {
identifierStart = true;
this.stringBuffer = [c];
}
if ( identifierStart ) {
var containsEscape = isUnicodeEscapeStart;
for (;;) {
if ( isUnicodeEscapeStart ) {
// strictly speaking we should probably push-back
// all the bad characters if the <backslash>uXXXX
// sequence is malformed. But since there isn‘t a
// correct context(is there?) for a bad Unicode
// escape sequence in an identifier, we can report
// an error here.
for ( var i=0; i != 4; ++i ) {
c = this.getChar();
if ( isHexDigit(c) ) {
this.addToString(c);
} else {
this.parser.addError("msg.invalid.escape");
return Token.ERROR;
}
}
isUnicodeEscapeStart = false;
} else {
c = this.getChar();
if (c == ‘\\‘) {
c = this.getChar();
if (c == ‘u‘) {
this.addToString("\\u");
isUnicodeEscapeStart = true;
containsEscape = true;
} else {
this.parser.addError("msg.illegal.character");
return Token.ERROR;
}
} else {
if ( !isIdentifierPart(c) ) break;
this.addToString(c);
}
}
}
this.ungetChar(c);
var str = this.getStringFromBuffer();
if ( !containsEscape ) {
// OPT we shouldn‘t have to make a string to
// check if it‘s a keyword.
// Return the corresponding token if it‘s a keyword
var result = stringToKeyword(str);
if ( result != Token.EOF ) return result;
}
this.string = str;
return Token.NAME;
}
// is it a number?
if ( isDigit(c) || (c===‘.‘ && isDigit(this.peekChar())) ) {
this.stringBuffer = [];
var base = 10;
if ( c === ‘0‘ ) {
this.addToString(‘0‘);
c = this.getChar();
if ( c === ‘x‘ || c === ‘X‘ ) {
this.addToString(c);
base = 16;
c = this.getChar();
} else if ( isDigit(c) ) {
base = 8;
}
}
if ( base === 16 ) {
while ( isHexDigit(c) ) {
this.addToString(c);
c = this.getChar();
}
} else {
while ( isDigit(c) ) {
/*
* We permit 08 and 09 as decimal numbers, which
* makes our behavior a superset of the ECMA
* numeric grammar. We might not always be so
* permissive, so we warn about it.
*/
if ( base === 8 && (c===‘8‘ || c===‘9‘) ) {
this.parser.addWarning("msg.bad.octal.literal", c == ‘8‘ ? "8" : "9");
base = 10;
}
this.addToString(c);
c = this.getChar();
}
}
if ( base === 10 ) {
if ( c === ‘.‘ ) {
do {
this.addToString(c);
c = this.getChar();
} while ( isDigit(c) );
}
if ( c === ‘e‘ || c === ‘E‘ ) {
this.addToString(c);
c = this.getChar();
if ( c === ‘+‘ || c === ‘-‘ ) {
this.addToString(c);
c = this.getChar();
}
if ( !isDigit(c) ) {
this.parser.addError("msg.missing.exponent");
return Token.ERROR;
}
do {
this.addToString(c);
c = this.getChar();
} while ( isDigit(c) );
}
}
this.ungetChar(c);
this.string = this.getStringFromBuffer();
return Token.NUMBER;
}
// is it a string?
if ( c === ‘"‘ || c === "‘" ) {
var quoteChar = c;
this.stringBuffer = [c];
c = this.getChar();
while ( c !== quoteChar ) {
if ( c === ‘\n‘ || c === EOF_CHAR ) {
this.ungetChar(c);
this.parser.addError("msg.unterminated.string.lit");
return Token.ERROR;
}
if ( c === ‘\\‘ ) {
this.addToString(‘\\‘);
c = this.getChar();
if ( c === ‘\n‘ ) {
// Remove line terminator after escape to follow
// SpiderMonkey and C/C++
// But, issue warning since ECMA262-3 does not allow that.
this.parser.addWarning("msg.unsafe.string.lit");
} else {
this.addToString(c);
}
} else {
this.addToString(c);
}
c = this.getChar();
}
this.addToString(quoteChar);
this.string = this.getStringFromBuffer();
return Token.STRING;
}
switch ( c.charCodeAt(0) ) {
case 0x3B: // ‘;‘
return Token.SEMI;
case 0x5B: // ‘[‘
return Token.LB;
case 0x5D: // ‘]‘
return Token.RB;
case 0x7B: // ‘{‘
return Token.LC;
case 0x7D: // ‘}‘
return Token.RC;
case 0x28: // ‘(‘
return Token.LP;
case 0x29: // ‘)‘
return Token.RP;
case 0x2C: // ‘,‘
return Token.COMMA;
case 0x3F: // ‘?‘
return Token.HOOK;
case 0x40: // ‘@‘
return Token.XMLATTR;
case 0x3A: // ‘:‘
if ( this.matchChar(‘:‘) ) {
return Token.COLONCOLON;
} else {
return Token.COLON;
}
case 0x2E: // ‘.‘
if ( this.matchChar(‘.‘) ) {
return Token.DOTDOT;
} else if ( this.matchChar(‘(‘) ) {
return Token.DOTQUERY;
} else {
return Token.DOT;
}
case 0x7C: // ‘|‘
if ( this.matchChar(‘|‘) ) {
return Token.OR;
} else if ( this.matchChar(‘=‘) ) {
return Token.ASSIGN_BITOR;
} else {
return Token.BITOR;
}
case 0x5E: // ‘^‘
if ( this.matchChar(‘=‘) ) {
return Token.ASSIGN_BITXOR;
} else {
return Token.BITXOR;
}
case 0x26: // ‘&‘
if ( this.matchChar(‘&‘) ) {
return Token.AND;
} else if ( this.matchChar(‘=‘) ) {
return Token.ASSIGN_BITAND;
} else {
return Token.BITAND;
}
case 0x3D: // ‘=‘
if ( this.matchChar(‘=‘) ) {
if ( this.matchChar(‘=‘) ) {
return Token.SHEQ;
} else {
return Token.EQ;
}
} else {
return Token.ASSIGN;
}
case 0x21: // ‘!‘
if ( this.matchChar(‘=‘) ) {
if ( this.matchChar(‘=‘) ) {
return Token.SHNE;
} else {
return Token.NE;
}
} else {
return Token.NOT;
}
case 0x3C: // ‘<‘
/* NB:treat HTML begin-comment as comment-till-eol */
if ( this.matchChar(‘!‘) ) {
if ( this.matchChar(‘-‘) ) {
if ( this.matchChar(‘-‘) ) {
this.skipLine();
continue retry;
}
this.ungetChar(‘-‘);
}
this.ungetChar(‘!‘);
}
if ( this.matchChar(‘<‘) ) {
if ( this.matchChar(‘=‘) ) {
return Token.ASSIGN_LSH;
} else {
return Token.LSH;
}
} else {
if ( this.matchChar(‘=‘) ) {
return Token.LE;
} else {
return Token.LT;
}
}
case 0x3E: // ‘>‘
if ( this.matchChar(‘>‘) ) {
if ( this.matchChar(‘>‘) ) {
if ( this.matchChar(‘=‘) ) {
return Token.ASSIGN_URSH;
} else {
return Token.URSH;
}
} else {
if ( this.matchChar(‘=‘) ) {
return Token.ASSIGN_RSH;
} else {
return Token.RSH;
}
}
} else {
if ( this.matchChar(‘=‘) ) {
return Token.GE;
} else {
return Token.GT;
}
}
case 0x2A: // ‘*‘
if ( this.matchChar(‘=‘) ) {
return Token.ASSIGN_MUL;
} else {
return Token.MUL;
}
case 0x2F: // ‘/‘
// is it a // comment?
if ( this.matchChar(‘/‘) ) {
this.skipLine();
continue retry;
} else if ( this.matchChar(‘*‘) ) {
for (;;) {
c = this.getChar();
if ( c === EOF_CHAR ) {
this.parser.addError("msg.unterminated.comment");
return Token.ERROR;
} else if ( c === ‘*‘ ) {
c = this.getChar();
if ( c === ‘/‘ ) {
continue retry;
}
}
}
} else if ( this.matchChar(‘=‘) ) {
return Token.ASSIGN_DIV;
} else {
return Token.DIV;
}
case 0x25: // ‘%‘
if ( this.matchChar(‘=‘) ) {
return Token.ASSIGN_MOD;
} else {
return Token.MOD;
}
case 0x7E: // ‘~‘
return Token.BITNOT;
case 0x2B: // ‘+‘
if ( this.matchChar(‘=‘) ) {
return Token.ASSIGN_ADD;
} else if ( this.matchChar(‘+‘) ) {
return Token.INC;
} else {
return Token.ADD;
}
case 0x2D: // ‘-‘
if ( this.matchChar(‘=‘) ) {
c = Token.ASSIGN_SUB;
} else if ( this.matchChar(‘-‘) ) {
if ( !this.dirtyLine ) {
// treat HTML end-comment after possible whitespace
// after line start as comment-untill-eol
if ( this.matchChar(‘>‘)) {
this.skipLine();
continue retry;
}
}
c = Token.DEC;
} else {
c = Token.SUB;
}
this.dirtyLine = true;
return c;
default:
parser.addError("msg.illegal.character");
return Token.ERROR;
}
}
};
/**
* Parser calls the method when it gets / or /= in literal context.
*/
proto.readRegExp = function ( startToken )
{
if ( startToken === Token.ASSIGN_DIV ) {
// Miss-scanned /=
this.stringBuffer = ["/="];
} else if ( startToken === Token.DIV ) {
this.stringBuffer = ["/"];
} else {
Kit.codeBug();
}
var c;
while ( (c = this.getChar()) !== ‘/‘ ) {
if ( c === ‘\n‘ || c === EOF_CHAR ) {
this.ungetChar(c);
throw this.parser.reportError("msg.unterminated.re.lit");
}
if ( c === ‘\\‘ ) {
this.addToString(c);
c = this.getChar();
}
this.addToString(c);
}
this.addToString("/");
while ( isIdentifierPart(c = this.getChar()) ) {
this.addToString(c);
}
this.ungetChar(c);
this.string = this.getStringFromBuffer();
}
proto.isXMLAttribute = function ( )
{
return this.xmlIsAttribute;
};
proto.getFirstXMLToken = function ( )
{
this.xmlOpenTagsCount = 0;
this.xmlIsAttribute = false;
this.xmlIsTagContent = false;
this.ungetChar(‘<‘);
return this.getNextXMLToken();
};
proto.getNextXMLToken = function ( )
{
this.stringBuffer = []; // remember the XML
for ( var c=this.getChar(); c !== EOF_CHAR; c=this.getChar() ) {
if ( this.xmlIsTagContent ) {
switch ( c.charCodeAt(0) ) {
case 0x3E: // ‘>‘
this.addToString(‘>‘);
this.xmlIsTagContent = false;
this.xmlIsAttribute = false;
break;
case 0x2F: // ‘/‘
this.addToString(‘/‘);
if ( this.matchChar(‘>‘) ) {
this.addToString(‘>‘);
this.xmlIsTagContent = false;
this.xmlOpenTagsCount--;
}
break;
case 0x7B: // ‘{‘
this.ungetChar(‘{‘);
this.string = this.getStringFromBuffer();
return Token.XML;
case 0x27: // "‘"
case 0x22: // ‘"‘
this.addToString(c);
if ( !this.readQuotedString(c) ) return Token.ERROR;
break;
case 0x3D: // ‘=‘
this.addToString(‘=‘);
this.xmlIsAttribute = true;
break;
case 0x20: // ‘ ‘
case 0x09: // ‘\t‘
// case 0x0D: // ‘\r‘ CR never comes here because of the implementation of getChar().
case 0x0A: // ‘\n‘
this.addToString(c);
break;
default:
this.addToString(c);
this.xmlIsAttribute = false;
break;
}
if ( !this.xmlIsTagContent && this.xmlOpenTagsCount === 0 ) {
this.string = this.getStringFromBuffer();
return Token.XMLEND;
}
} else {
switch ( c.charCodeAt(0) ) {
case 0x3C: // ‘<‘
this.addToString(‘<‘);
c = this.getChar();
switch ( c.charCodeAt(0) ) {
case 0x21: // ‘!‘
this.addToString(‘!‘);
c = this.getChar();
switch ( c.charCodeAt(0) ) {
case 0x2D: // ‘-‘
if ( this.getChar() === ‘-‘ ) {
this.addToString(‘--‘);
if ( !this.readXmlComment() ) return Token.ERROR;
} else {
this.parser.addError("msg.XML.bad.form");
return Token.ERROR;
}
break;
case 0x5B: // ‘[‘
if ( this.getChar() === ‘C‘ &&
this.getChar() === ‘D‘ &&
this.getChar() === ‘A‘ &&
this.getChar() === ‘T‘ &&
this.getChar() === ‘A‘ &&
this.getChar() === ‘[‘ )
{
this.addToString(‘[CDATA[‘);
if ( !this.readCDATA() ) return Token.ERROR;
} else {
this.parser.addError("msg.XML.bad.form");
return Token.ERROR;
}
break;
default:
this.ungetChar(c);
if( !this.readEntity() ) return Token.ERROR;
break;
}
break;
case 0x3F: // ‘?‘
this.addToString(‘?‘);
if ( !this.readPI() ) return Token.ERROR;
break;
case 0x2F: // ‘/‘
// End tag
this.addToString(‘/‘);
if ( this.xmlOpenTagsCount === 0 ) {
this.parser.addError("msg.XML.bad.form");
return Token.ERROR;
}
this.xmlIsTagContent = true;
this.xmlOpenTagsCount--;
break;
default:
// Start tag
this.ungetChar(c);
this.xmlIsTagContent = true;
this.xmlOpenTagsCount++;
break;
}
break;
case 0x7B: // ‘{‘
this.ungetChar(‘{‘);
this.string = this.getStringFromBuffer();
return Token.XML;
default:
this.addToString(c);
break;
}
}
}
this.parser.addError("msg.XML.bad.form");
return Token.ERROR;
};
proto.readQuotedString = function ( quote )
{
for ( var c=this.getChar(); c !== EOF_CHAR; c=this.getChar() ) {
this.addToString(c);
if ( c === quote ) return true;
}
parser.addError("msg.XML.bad.form");
return false;
};
proto.readXmlComment = function ( )
{
for ( var c=this.getChar(); c !== EOF_CHAR; ) {
this.addToString(c);
if ( c === ‘-‘ && this.matchChar(‘-‘) ) {
this.addToString(‘-‘);
if ( this.matchChar(‘>‘) ) {
this.addToString(‘>‘);
return true;
} else {
// Strictly, XMLComment MUST NOT include the sequence "--".
// So, if the program execution is here, the source is
// syntactically wrong, according to ECMA367. However, we
// allow the sequence here, so that our syntax is super-set
// of the specification.
c = ‘-‘;
continue;
}
}
c = this.getChar();
}
this.parser.addError("msg.XML.bad.form");
return false;
};
proto.readCDATA = http://www.mamicode.com/function ( )"msg.XML.bad.form");
return false;
};
proto.readEntity = function ( )
{
var declTags = 1;
for ( var c=this.getChar(); c !== EOF_CHAR; c=this.getChar() ) {
this.addToString(c);
switch ( c ) {
case ‘<‘:
declTags++;
break;
case ‘>‘:
declTags--;
if ( declTags === 0 ) return true;
break;
}
}
this.parser.addError("msg.XML.bad.form");
return false;
};
proto.readPI = function ( )
{
for ( var c=this.getChar(); c !== EOF_CHAR; c=this.getChar() ) {
this.addToString(c);
if ( c === ‘?‘ && this.matchChar(‘>‘) ) {
this.addToString(‘>‘);
return true;
}
}
this.parser.addError("msg.XML.bad.form");
return false;
};
proto.getStringFromBuffer = function ( )
{
return this.stringBuffer.join("");
};
proto.addToString = function ( /* variable arguments */ )
{
this.stringBuffer.push.apply(this.stringBuffer, arguments);
};
proto.ungetChar = function ( c )
{
// can not unread past across line boundary
if ( this.ungetBuffer.length && this.ungetBuffer[this.ungetBuffer.length-1] == ‘\n‘) Kit.codeBug();
this.ungetBuffer.push(c);
};
proto.matchChar = function ( test )
{
var c = this.getChar();
if ( c === test ) {
return true;
} else {
this.ungetChar(c);
return false;
}
};
proto.peekChar = function ( )
{
var c = this.getChar();
this.ungetChar(c);
return c;
};
proto.getChar = function ( )
{
if ( this.ungetBuffer.length ) return this.ungetBuffer.pop();
for ( ;; ) {
if ( this.sourceCursor == this.sourceEnd ) {
this.hitEOF = true;
return EOF_CHAR;
}
var c = this.sourceString.charAt(this.sourceCursor++);
if ( this.lineEndChar ) {
if ( this.lineEndChar == ‘\r‘ && c == ‘\n‘) {
this.lineEndChar = ‘\n‘;
continue;
}
this.lineEndChar = undefined;
this.lineStart = this.sourceCursor - 1;
this.lineno++;
}
if ( isLineTerminator(c) ) {
this.lineEndChar = c;
c = ‘\n‘;
}
if ( isFormatChar(c) ) {
continue;
}
return c;
}
};
proto.skipLine = function ( )
{
// skip to end of line
var c;
while ((c=this.getChar()) != EOF_CHAR && c != ‘\n‘) { }
this.ungetChar(c);
};
proto.getOffset = function ( )
{
var n = this.sourceCursor - this.lineStart;
if ( this.lineEndChar ) { --n; }
return n;
};
proto.getLine = function ( )
{
var lineEnd = this.sourceCursor;
if ( this.lineEndChar ) {
--lineEnd;
} else {
for (; lineEnd != this.sourceEnd; ++lineEnd) {
var c = this.sourceString.charAt(lineEnd);
if ( isLineTerminator(c) ) {
break;
}
}
}
return this.sourceString.substring(this.lineStart, lineEnd);
};
return {
TokenStream: TokenStream
};
}();
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.TokenStream = TokenStream;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( !this.Concurrent.Thread.Compiler.IntermediateLanguage || (typeof this.Concurrent.Thread.Compiler.IntermediateLanguage != ‘object‘ && typeof this.Concurrent.Thread.Compiler.IntermediateLanguage != ‘function‘) ) this.Concurrent.Thread.Compiler.IntermediateLanguage = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread.Compiler.IntermediateLanguage‘;
function Function ( name, params, vars, body, start ) {
this.name = name; // Identifier | Null
this.params = params; // [Identifier]
this.vars = vars; // [Identifier]
this.body = body; // <Block>
this.start = start; // Block
}
Function.prototype.toString = function ( ) {
return [ "function ", this.name, "( ", this.params.join(", "), " ) {\n",
" var ", this.vars.join(", "), ";\n",
this.body.join("\n").replace(/^/mg, " "),
"\n}" ].join("");
};
var block_id = 0;
function Block ( scopes, body, target, exception ) {
this.id = "label" + block_id++;
this.scopes = scopes; // [Expression]
this.body = body; // <Statement>
this.target = target; // Block | "return" | "throw"
this.exception = exception; // Block | "return" | "throw"
}
var proto = Block.prototype;
proto.toString = function ( ) {
Kit.codeBug(‘"toString" is not implemented for ‘, this.constructor);
};
proto.appendStatement = function ( /* variable arguments */ ) {
var args = arguments;
if ( this.body.isNil() ) {
this.body = cons(arguments[0], this.body);
args = Array.prototype.slice.call(arguments, 1, arguments.length);
} else {
adder(this.body).apply(null, args);
}
};
proto.prependStatement = function ( /* variable arguments */ ) {
for ( var i=arguments.length-1; i >= 0; i-- ) {
this.body = cons(arguments[i], this.body);
}
};
function stringify ( b ) {
if ( b instanceof Block ) {
return b.id;
} else {
return ‘"‘ + b + ‘"‘;
}
}
function GotoBlock ( scopes, body, arg, target, exception ) {
Block.call(this, scopes, body, target, exception);
this.arg = arg;
}
var proto = GotoBlock.prototype = new Block();
proto.constructor = GotoBlock;
proto.toString = function ( ) {
return [ this.id, "([", this.scopes.join(", "), "], ", stringify(this.exception), "): {\n",
this.body.join("\n").replace(/^/mg, " "), "\n",
" goto ", this.arg, " -> ", stringify(this.target), "\n",
"}" ].join("");
};
function CallBlock ( scopes, body, this_val, func, args, target, exception ) {
Block.call(this, scopes, body, target, exception);
this.this_val = this_val; // Expression
this.func = func; // Expression
this.args = args; // [Expression]
}
var proto = CallBlock.prototype = new Block();
proto.constructor = CallBlock;
proto.toString = function ( ) {
return [ this.id, "([", this.scopes.join(", "), "], ", stringify(this.exception), "): {\n",
this.body.join("\n").replace(/^/mg, " "), "\n",
" call ", this.this_val, ".", this.func, "(", this.args.join(", "), ") -> ", stringify(this.target), "\n",
"}" ].join("");
};
function NewBlock ( scopes, body, func, args, target, exception ) {
Block.call(this, scopes, body, target, exception);
this.func = func; // Expression
this.args = args; // [Expression]
}
var proto = NewBlock.prototype = new Block();
proto.constructor = NewBlock;
proto.toString = function ( ) {
return [ this.id, "([", this.scopes.join(", "), "], ", stringify(this.exception), "): {\n",
this.body.join("\n").replace(/^/mg, " "), "\n",
" new ", this.func, "(", this.args.join(", "), ") -> ", stringify(this.target), "\n",
"}" ].join("");
};
function Statement ( ) {
// This is kind of interface.
}
Statement.prototype.toString = function ( ) {
Kit.codeBug(‘"toString" is not implemented for ‘, this.constructor);
};
function ExpStatement ( e ) {
this.exp = e; // Expression
}
var proto = ExpStatement.prototype = new Statement();
proto.constructor = ExpStatement;
proto.toString = function ( ) {
return this.exp + ";";
};
function CondStatement ( c, t ) {
this.cond = c; // Expression
this.target = t; // Block
}
var proto = CondStatement.prototype = new Statement();
proto.constructor = CondStatement;
proto.toString = function ( ) {
return [ "if ", this.cond, " -> ", stringify(this.target), ";" ].join("");
};
function RecvStatement ( a ) {
this.assignee = a; // Identifier | DotAccessor | BracketAccessor
}
var proto = RecvStatement.prototype = new Statement();
proto.constructor = RecvStatement;
proto.toString = function ( ) {
return [ "recv ", this.assignee, ";" ].join("");
};
function EnumStatement ( e, a ) {
this.exp = e; // Expression
this.assignee = a; // Identifier | DotAccessor | BracketAccessor
}
var proto = EnumStatement.prototype = new Statement();
proto.constructor = EnumStatement;
proto.toString = function ( ) {
return [ "enum ", this.assignee, " <- ", this.exp, ";" ].join("");
};
return {
Block: Block, RecvStatement: RecvStatement, GotoBlock: GotoBlock, Function: Function, NewBlock: NewBlock, ExpStatement: ExpStatement, CallBlock: CallBlock, EnumStatement: EnumStatement, Statement: Statement, CondStatement: CondStatement
};
}();
}
}
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.IntermediateLanguage.Block = Block;
this.Concurrent.Thread.Compiler.IntermediateLanguage.RecvStatement = RecvStatement;
this.Concurrent.Thread.Compiler.IntermediateLanguage.GotoBlock = GotoBlock;
this.Concurrent.Thread.Compiler.IntermediateLanguage.Function = Function;
this.Concurrent.Thread.Compiler.IntermediateLanguage.NewBlock = NewBlock;
this.Concurrent.Thread.Compiler.IntermediateLanguage.ExpStatement = ExpStatement;
this.Concurrent.Thread.Compiler.IntermediateLanguage.CallBlock = CallBlock;
this.Concurrent.Thread.Compiler.IntermediateLanguage.EnumStatement = EnumStatement;
this.Concurrent.Thread.Compiler.IntermediateLanguage.Statement = Statement;
this.Concurrent.Thread.Compiler.IntermediateLanguage.CondStatement = CondStatement;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
var Css = "Concurrent.Thread.Compiler.CssConvert";
function CssConvert ( func ) {
return func[Css]();
}
Statement.prototype[Css] = function ( ) {
Kit.codeBug("unimplemented ‘" + Css + "‘ method for: " + this);
};
EmptyStatement.prototype[Css] = function ( ) {
return this;
};
Block.prototype[Css] = function ( ) {
var head = last = cons(null, nil());
for ( var c=this.body; !c.isNil(); c=c.cdr ) {
last = last.cdr = cons(c.car[Css](), last.cdr);
}
return new Block(this.labels, head.cdr, this.lineno, this.source);
};
ExpStatement.prototype[Css] = function ( ) {
return new ExpStatement(this.labels, this.exp[Css](), this.lineno, this.source);
};
VarStatement.prototype[Css] = function ( ) {
var decls = [];
for ( var i=0; i < this.decls.length; i++ ) {
decls[i] = {
id : this.decls[i].id,
exp: this.decls[i].exp ? this.decls[i].exp[Css]() : null
};
}
return new VarStatement(this.labels, decls, this.lineno, this.source);
};
IfStatement.prototype[Css] = function ( ) {
return new IfStatement(this.labels, this.cond[Css](), this.body[Css](), this.lineno, this.source);
};
IfElseStatement.prototype[Css] = function ( ) {
return new IfElseStatement(this.labels, this.cond[Css](), this.tbody[Css](), this.fbody[Css](), this.lineno, this.source);
};
DoWhileStatement.prototype[Css] = function ( ) {
return new DoWhileStatement(this.labels, this.body[Css](), this.cond[Css](), this.lineno, this.source);
};
WhileStatement.prototype[Css] = function ( ) {
return new WhileStatement(this.labels, this.cond[Css](), this.body[Css](), this.lineno, this.source);
};
ForStatement.prototype[Css] = function ( ) {
return new ForStatement(
this.labels,
this.init ? this.init[Css]() : null,
this.cond ? this.cond[Css]() : null,
this.incr ? this.incr[Css]() : null,
this.body[Css](),
this.lineno,
this.source
);
};
ForVarStatement.prototype[Css] = function ( ) {
var decls = [];
for ( var i=0; i < this.decls.length; i++ ) {
decls[i] = {
id : this.decls[i].id,
exp: this.decls[i].exp ? this.decls[i].exp[Css]() : null
};
}
return new ForVarStatement(
this.labels,
decls,
this.cond ? this.cond[Css]() : null,
this.incr ? this.incr[Css]() : null,
this.body[Css](),
this.lineno,
this.source
);
};
ForInStatement.prototype[Css] = function ( ) {
return new ForInStatement(this.labels, this.lhs[Css](), this.exp[Css](), this.body[Css](), this.lineno, this.source);
};
ForInVarStatement.prototype[Css] = function ( ) {
var decl = {
id : this.decl.id,
exp: this.decl.exp ? this.decl.exp[Css]() : null
};
return new ForInVarStatement(this.labels, decl, this.exp[Css](), this.body[Css](), this.lineno, this.source);
};
ForEachStatement.prototype[Css] = function ( ) {
return new ForEachStatement(this.labels, this.lhs[Css](), this.exp[Css](), this.body[Css](), this.lineno, this.source);
};
ForEachVarStatement.prototype[Css] = function ( ) {
var decl = {
id : this.decl.id,
exp: this.decl.exp ? this.decl.exp[Css]() : null
};
return new ForEachVarStatement(this.labels, decl, this.exp[Css](), this.body[Css](), this.lineno, this.source);
};
ContinueStatement.prototype[Css] = function ( ) {
return this;
};
BreakStatement.prototype[Css] = function ( ) {
return this;
};
ReturnStatement.prototype[Css] = function ( ) {
if ( !this.exp ) return this;
return new ReturnStatement(this.labels, this.exp[Css](), this.lineno, this.source);
};
WithStatement.prototype[Css] = function ( ) {
return new WithStatement(this.labels, this.exp[Css](), this.body[Css](), this.lineno, this.source);
};
SwitchStatement.prototype[Css] = function ( ) {
var head = last = cons(null, nil());
for ( var c=this.clauses; !c.isNil(); c=c.cdr ) {
last = last.cdr = cons(c.car[Css](), last.cdr);
}
return new SwitchStatement(this.labels, this.exp[Css](), head.cdr, this.lineno, this.source);
};
CaseClause.prototype[Css] = function ( ) {
var head = last = cons(null, nil());
for ( var c=this.body; !c.isNil(); c=c.cdr ) {
last = last.cdr = cons(c.car[Css](), last.cdr);
}
return new CaseClause(this.exp[Css](), head.cdr, this.lineno, this.source);
};
DefaultClause.prototype[Css] = function ( ) {
var head = last = cons(null, nil());
for ( var c=this.body; !c.isNil(); c=c.cdr ) {
last = last.cdr = cons(c.car[Css](), last.cdr);
}
return new DefaultClause(head.cdr, this.lineno, this.source);
};
ThrowStatement.prototype[Css] = function ( ) {
return new ThrowStatement(this.labels, this.exp[Css](), this.lineno, this.source);
};
TryCatchStatement.prototype[Css] = function ( ) {
return new TryCatchStatement(this.labels, this.tryBlock[Css](), this.variable, this.catchBlock[Css](), this.lineno, this.source);
};
TryFinallyStatement.prototype[Css] = function ( ) {
return new TryFinallyStatement(this.labels, this.tryBlock[Css](), this.finallyBlock[Css](), this.lineno, this.source);
};
TryCatchFinallyStatement.prototype[Css] = function ( ) {
return new TryCatchFinallyStatement(this.labels, this.tryBlock[Css](), this.variable, this.catchBlock[Css](), this.finallyBlock[Css](), this.lineno, this.source);
};
TryCatchListStatement.prototype[Css] = function ( ) {
if ( this.catchList.isNil() ) { // no more catch-guard
var block = this.tryBlock[Css]();
block.labels = this.labels;
return block;
} else if ( this.catchList.car.cond ) { // one or more qualified catch-guard
var guard = this.catchList.car;
return new TryCatchStatement(
this.labels,
this.tryBlock[Css](),
guard.variable,
new Block([], list(
new IfElseStatement(
[],
guard.cond[Css](),
guard.block[Css](),
(new TryCatchListStatement(
[],
new Block([], list(new ThrowStatement([], guard.variable))),
this.catchList.cdr,
this.catchList.cdr.lineno, this.cdr.cdr.source
))[Css](),
guard.lineno, guard.source
)
))
);
} else { // (only one) default catch-guard
var guard = this.catchList.car;
return new TryCatchStatement(this.labels, this.tryBlock[Css](), guard.variable, guard.block[Css](), this.lineno, this.source);
}
};
TryCatchListFinallyStatement.prototype[Css] = function ( ) {
return new TryFinallyStatement(
this.labels,
new Block([], list(
(new TryCatchListStatement([],
this.tryBlock,
this.catchList,
this.lineno,
this.source
))[Css]()
), this.lineno, this.source),
this.finallyBlock[Css](),
this.lineno, this.source
);
};
FunctionDeclaration.prototype[Css] = function ( ) {
var head = last = cons(null, nil());
for ( var c=this.body; !c.isNil(); c=c.cdr ) {
last = last.cdr = cons(c.car[Css](), last.cdr);
}
return new FunctionDeclaration(this.labels, this.name, this.params, head.cdr, this.lineno, this.source);
};
Expression.prototype[Css] = Statement.prototype[Css];
UnaryExpression.prototype[Css] = function ( ) {
return new this.constructor( this.exp[Css]() );
};
BinaryExpression.prototype[Css] = function ( ) {
return new this.constructor(this.left[Css](), this.right[Css]());
};
Literal.prototype[Css] =
Identifier.prototype[Css] =
ThisExpression.prototype[Css] =
Elision.prototype[Css] = function ( ) {
return this;
};
ArrayInitializer.prototype[Css] = function ( ) {
var elems = [];
for ( var i=0; i < this.elems.length; i++ ) {
elems[i] = this.elems[i][Css]();
}
return new ArrayInitializer(elems);
};
ObjectInitializer.prototype[Css] = function ( ) {
var pairs = [];
for ( var i=0; i < this.pairs.length; i++ ) {
pairs[i] = {prop:this.pairs[i].prop, exp:this.pairs[i].exp[Css]()};
}
return new ObjectInitializer(pairs);
};
FunctionExpression.prototype[Css] = function ( ) {
var head = last = cons(null, nil());
for ( var c=this.body; !c.isNil(); c=c.cdr ) {
last = last.cdr = cons(c.car[Css](), last.cdr);
}
return new FunctionExpression(this.name, this.params, head.cdr);
};
DotAccessor.prototype[Css] = function ( ) {
return new DotAccessor(this.base[Css](), this.prop);
};
NewExpression.prototype[Css] =
CallExpression.prototype[Css] = function ( ) {
var args = [];
for ( var i=0; i < this.args.length; i++ ) {
args[i] = this.args[i][Css]();
}
return new this.constructor(this.func[Css](), args);
};
ConditionalExpression.prototype[Css] = function ( ) {
return new ConditionalExpression(this.cond[Css](), this.texp[Css](), this.fexp[Css]());
};
return {
CssConvert: CssConvert
};
}();
}
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.CssConvert = CssConvert;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Rhino code, released
* May 6, 1999.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1997-1999
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Mike Ang
* Igor Bukanov
* Yuh-Ruey Chen
* Ethan Hugg
* Terry Lucas
* Mike McCabe
* Milen Nankov
* Daisuke Maki
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License Version 2 or later (the "GPL"), in which
* case the provisions of the GPL are applicable instead of those above. If
* you wish to allow use of your version of this file only under the terms of
* the GPL and not to allow others to use your version of this file under the
* MPL, indicate your decision by deleting the provisions above and replacing
* them with the notice and other provisions required by the GPL. If you do
* not delete the provisions above, a recipient may use your version of this
* file under either the MPL or the GPL.
*
* ***** END LICENSE BLOCK ***** */
/**
* This file is based on the file Parser.java in Rhino 1.6R5.
*/
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
// TokenInformation flags : flaggedTokenBuffer stores them together
// with token type
var CLEAR_TI_MASK = 0xFFFF; // mask to clear token information bits
var TI_AFTER_EOL = 1 << 16; // first token of the source line
var TI_CHECK_LABEL = 1 << 17; // indicates to check for label
// Exception to unwind
var ParserException = Exception.extend(
function($super, message){ $super(message); },
{ name: NAMESPACE + ".ParserException" }
);
// Exception to return statement-label
function LabelException ( label ) {
this.label = label; // Identifier
}
// default error reporter
var defaultReporter = new ErrorReporter();
defaultReporter.error = function ( message, line, lineSource, lineOffset ) {
throw new SyntaxError("(" + line + ", " + lineOffset + "): " + message + "\nline: " + lineSource);
};
function Parser ( errorReporter )
{
this.errorReporter = errorReporter instanceof ErrorReporter
? errorReporter : defaultReporter;
this.ts = undefined; // TokenStream
this.source = undefined; // String # file-name, URL, ...etc
this.flaggedTokenBuffer = null; // Stack
this.syntaxErrorCount = 0;
this.nestingOfFunction = 0;
// The following are per function variables and should be saved/restored
// during function parsing.
this.nestingOfLoop = 0;
this.nestingOfSwitch = 0;
this.allLabelSet = null; // contains all labels in current scope
this.loopLabelSet = null; // contains only labels qualifying IterationStatement in current scope
}
var proto = Parser.prototype;
proto.getMessage = function ( messageId /* optional args */ )
{
//!! fake implementation
return messageId;
};
proto.addWarning = function ( messageId /* optional args */ )
{
this.errorReporter.warning(this.getMessage.apply(this, arguments),
this.ts.getLineno() ,
this.ts.getLine() ,
this.ts.getOffset() );
};
proto.addError = function ( messageId /* optional args */ )
{
++this.syntaxErrorCount;
this.errorReporter.error(this.getMessage.apply(this, arguments),
this.ts.getLineno() ,
this.ts.getLine() ,
this.ts.getOffset() );
};
proto.reportError = function ( messageId /* optional args */ )
{
this.addError.apply(this, arguments);
// Throw a ParserException exception to unwind the recursive descent
// parse.
throw new ParserException();
};
proto.peekToken = function ( )
{
var tt;
if ( this.flaggedTokenBuffer.isEmpty() ) {
tt = this.ts.getToken();
if ( tt === Token.EOL ) {
do {
tt = this.ts.getToken();
} while ( tt === Token.EOL );
tt |= TI_AFTER_EOL;
}
this.flaggedTokenBuffer.push(tt);
} else {
tt = this.flaggedTokenBuffer.peek();
}
return tt & CLEAR_TI_MASK;
};
proto.peekFlaggedToken = function ( )
{
this.peekToken();
return this.flaggedTokenBuffer.peek();
};
proto.consumeToken = function ( )
{
this.flaggedTokenBuffer.pop();
};
proto.nextToken = function ( )
{
var tt = this.peekToken();
this.consumeToken();
return tt;
};
proto.nextFlaggedToken = function ( )
{
this.peekToken();
var ttFlagged = this.flaggedTokenBuffer.peek();
this.consumeToken();
return ttFlagged;
};
proto.matchToken = function ( toMatch )
{
if ( this.peekToken() !== toMatch ) return false;
this.consumeToken();
return true;
};
proto.peekTokenOrEOL = function ( )
{
var tt = this.peekToken();
// Check for last peeked token flags
if ( this.flaggedTokenBuffer.peek() & TI_AFTER_EOL ) return Token.EOL;
return tt;
};
// Since we need to backtrack to properly parse "default xml namespace"
// in switch-statement.
proto.ungetToken = function ( token )
{
this.flaggedTokenBuffer.push(token);
};
proto.setCheckForLabel = function ( )
{
var tt = this.flaggedTokenBuffer.pop();
if ( (tt & CLEAR_TI_MASK) !== Token.NAME ) throw Kit.codeBug();
this.flaggedTokenBuffer.push(tt | TI_CHECK_LABEL);
};
proto.mustMatchToken = function ( toMatch, messageId /* optional args */ )
{
if ( !this.matchToken(toMatch) ) {
var args = [];
for ( var i=1; i < arguments.length; i++ ) args.push(arguments[i]);
this.reportError.apply(this, args);
}
};
proto.eof = function ( )
{
return this.ts.eof();
};
proto.insideFunction = function ( )
{
return this.nestingOfFunction !== 0;
};
proto.insideLoop = function ( )
{
return this.nestingOfLoop !== 0;
};
proto.enterLoop = function ( labels )
{
for ( var i=0; i < labels.length; i++ ) this.loopLabelSet.add(labels[i]);
this.nestingOfLoop++;
};
proto.exitLoop = function ( labels )
{
for ( var i=0; i < labels.length; i++ ) this.loopLabelSet.remove(labels[i]);
this.nestingOfLoop--;
};
proto.parse = function ( sourceString, lineno, source )
{
this.ts = new TokenStream(this, sourceString, lineno);
this.source = source; // optional
this.flaggedTokenBuffer = new Stack();
this.syntaxErrorCount = 0;
this.nestingOfFunction = 0;
this.nestingOfLoop = 0;
this.nestingOfSwitch = 0;
this.allLabelSet = new IdentifierSet();
this.loopLabelSet = new IdentifierSet();
try {
var body = this.statements();
this.mustMatchToken(Token.EOF, "msg.syntax");
} catch ( e ) {
if ( e instanceof ParserException ) {
// Ignore it.
} else {
// Maybe stack overflow.
//!!fake implementation
throw e;
}
}
if ( this.syntaxErrorCount ) {
var msg = "msg.got.syntax.errors";
this.addError(msg);
throw new SyntaxError(this.getMessage("msg.got.syntax.errors"));
}
this.ts = null; // It helps GC
return body;
};
proto.statements = function ( )
{
var head, cell;
cell = head = cons(null, nil());
bodyLoop: for (;;) {
var n;
switch ( this.peekToken() ) {
case Token.ERROR:
case Token.EOF:
case Token.RC:
break bodyLoop;
case Token.FUNCTION: // save the stack
this.consumeToken();
n = this.functionDecl([]);
break;
default:
n = this.statement();
break;
}
cell = cell.cdr = cons(n, cell.cdr);
}
return head.cdr;
};
proto.functionDecl = function ( labels )
{
var baseLineno = this.ts.getLineno(); // line number where source starts
this.mustMatchToken(Token.NAME, "msg.no.func.name");
var name = new Identifier(this.ts.getString());
var params = this.parameterList();
var body = this.functionBody();
return new FunctionDeclaration(labels, name, params, body, baseLineno, this.source);
};
proto.functionExpr = function ( )
{
var name = null;
if ( this.matchToken(Token.NAME) ) name = new Identifier(this.ts.getString());
var params = this.parameterList();
var body = this.functionBody();
return new FunctionExpression(name, params, body);
};
proto.parameterList = function ( )
{
this.mustMatchToken(Token.LP, "msg.no.paren.parms");
if ( this.matchToken(Token.RP) ) return [];
var params = [];
var exists = new IdentifierSet();
do {
this.mustMatchToken(Token.NAME, "msg.no.parm");
var p = new Identifier(this.ts.getString());
if ( exists.contains(p) ) this.addWarning("msg.dup.parms", s);
params.push(p);
exists.add(p);
} while ( this.matchToken(Token.COMMA) );
this.mustMatchToken(Token.RP, "msg.no.paren.after.parms");
return params;
};
proto.functionBody = function ( )
{
this.mustMatchToken(Token.LC, "msg.no.brace.body");
var saveAllLabel = this.allLabelSet;
var saveLoopLabel = this.loopLabelSet;
var saveLoop = this.nestingOfLoop;
var saveSwitch = this.nestingOfSwitch;
this.allLabelSet = new IdentifierSet();
this.loopLabelSet = new IdentifierSet();
this.nestingOfLoop = 0;
this.nestingOfSwitch = 0;
this.nestingOfFunction++;
try {
var body = this.statements();
} catch ( e ) {
if ( e instanceof ParserException ) {
// Ignore it
} else {
throw e;
}
} finally {
this.allLabelSet = saveAllLabel;
this.loopLabelSet = saveLoopLabel;
this.nestingOfLoop = saveLoop;
this.nestingOfSwitch = saveSwitch;
this.nestingOfFunction--;
}
this.mustMatchToken(Token.RC, "msg.no.brace.after.body");
return body;
};
proto.statement = function ( )
{
try {
var n = this.statementHelper([]);
if ( n != null ) return n;
} catch ( e ) {
if ( e instanceof ParserException ) {
// Ignore it.
} else {
throw e;
}
}
// skip to end of statement
guessingStatementEnd: for (;;) {
var tt = this.peekTokenOrEOL();
this.consumeToken();
switch ( tt ) {
case Token.ERROR:
case Token.EOF:
case Token.EOL:
case Token.SEMI:
break guessingStatementEnd;
}
}
return null;
};
proto.statementHelper = function ( labels )
{
var statement = null;
switch ( this.peekToken() ) {
case Token.IF: {
this.consumeToken();
var lineno = this.ts.getLineno();
var cond = this.condition();
var tstat = this.statement();
if ( this.matchToken(Token.ELSE) ) {
return new IfElseStatement(labels, cond, tstat, this.statement(), lineno, this.source);
} else {
return new IfStatement(labels, cond, tstat, lineno, this.source);
}
}
case Token.SWITCH: {
this.consumeToken();
var lineno = this.ts.getLineno();
this.mustMatchToken(Token.LP, "msg.no.paren.switch");
var exp = this.expr(false);
this.mustMatchToken(Token.RP, "msg.no.paren.after.switch");
this.mustMatchToken(Token.LC, "msg.no.brace.switch");
var switchStatement = new SwitchStatement(labels, exp, nil(), lineno, this.source);
var clauses = cons(nil(), nil());
var last = clauses;
this.nestingOfSwitch++;
try {
var hasDefault = false;
switchLoop: for (;;) {
var lineno = this.ts.getLineno();
var caseExpression;
switch ( this.nextToken() ) {
case Token.RC:
break switchLoop;
case Token.CASE:
caseExpression = this.expr(false);
this.mustMatchToken(Token.COLON, "msg.no.colon.case");
break;
case Token.DEFAULT:
if ( hasDefault ) this.reportError("msg.double.switch.default");
hasDefault = true;
caseExpression = null;
this.mustMatchToken(Token.COLON, "msg.no.colon.case");
break;
default:
this.reportError("msg.bad.switch");
break switchLoop;
}
var c = caseExpression
? new CaseClause(caseExpression, this.statementsInSwitch(), lineno, this.source)
: new DefaultClause(this.statementsInSwitch(), lineno, this.source);
last = last.cdr = cons(c, last.cdr);
}
} finally {
this.nestingOfSwitch--;
}
switchStatement.clauses = clauses.cdr;
return switchStatement;
}
case Token.WHILE: {
this.consumeToken();
var lineno = this.ts.getLineno();
this.enterLoop(labels);
try {
return new WhileStatement(labels, this.condition(), this.statement(), lineno, this.source);
} finally {
this.exitLoop(labels);
}
}
case Token.DO: {
this.consumeToken();
var lineno = this.ts.getLineno();
this.enterLoop(labels);
try {
var body = this.statement();
} finally {
this.exitLoop(labels);
}
this.mustMatchToken(Token.WHILE, "msg.no.while.do");
var cond = this.condition();
// Always auto-insert semicon to follow SpiderMonkey:
// It is required by EMAScript but is ignored by the rest of
// world, see bug 238945
this.matchToken(Token.SEMI);
return new DoWhileStatement(labels, body, cond, lineno, this.source);
}
case Token.FOR: {
this.consumeToken();
var lineno = this.ts.getLineno();
var init; // init is also foo in ‘foo in Object‘
var cond; // cond is also object in ‘foo in Object‘
var incr = null;
var body;
var isForEach = false;
var isForIn = false;
var isVar = false;
// See if this is a for each () instead of just a for ()
if ( this.matchToken(Token.NAME) ) {
if ( this.ts.getString() === "each" ) {
isForEach = true;
} else {
this.reportError("msg.no.paren.for");
}
}
this.mustMatchToken(Token.LP, "msg.no.paren.for");
var tt = this.peekToken();
if ( tt === Token.SEMI ) {
init = null;
} else {
if ( tt === Token.VAR ) {
// set init to a var list or initial
this.consumeToken(); // consume the ‘var‘ token
init = this.variables(true);
isVar = true;
}
else {
init = this.expr(true);
}
}
if ( this.matchToken(Token.IN) ) {
isForIn = true;
// ‘cond‘ is the object over which we‘re iterating
cond = this.expr(false);
} else { // ordinary for loop
this.mustMatchToken(Token.SEMI, "msg.no.semi.for");
if ( this.peekToken() === Token.SEMI ) {
// no loop condition
cond = null;
} else {
cond = this.expr(false);
}
this.mustMatchToken(Token.SEMI, "msg.no.semi.for.cond");
if ( this.peekToken() === Token.RP ) {
incr = null;
} else {
incr = this.expr(false);
}
}
this.mustMatchToken(Token.RP, "msg.no.paren.for.ctrl");
this.enterLoop(labels);
try {
body = this.statement();
} finally {
this.exitLoop(labels);
}
if ( !isForIn ) {
// Although SpiderMonkey doesn‘t allow "for each ( ...; ...; ... )",
// Rhino1.6R5 allowed it. We follow Rhino‘s position here.
if ( isVar ) return new ForVarStatement(labels, init, cond, incr, body, lineno, this.source);
else return new ForStatement(labels, init, cond, incr, body, lineno, this.source);
} else {
if ( isVar ) {
// Check if init (var declarations) contains only one.
if ( init.length != 1 ) this.reportError("msg.mult.index");
if ( isForEach ) return new ForEachVarStatement(labels, init[0], cond, body, lineno, this.source);
else return new ForInVarStatement(labels, init[0], cond, body, lineno, this.source);
} else {
// Check if init (an expression left-hand-side of "in") has lvalue.
if ( !init.hasLvalue() ) this.reportError("msg.bad.for.in.lhs");
if ( isForEach ) return new ForEachStatement(labels, init, cond, body, lineno, this.source);
else return new ForInStatement(labels, init, cond, body, lineno, this.source);
}
}
}
case Token.TRY: {
this.consumeToken();
var lineno = this.ts.getLineno();
// Although ECMA262-3 requires a block here, Rhino1.6R5 allows any kind of statement.
// We follow Rhino‘s style, but issue warning when a statement is not a block.
var tryBlock = this.statement();
if ( !(tryBlock instanceof Block) ) {
this.addWarning("msg.no.brace.tryblock");
tryBlock = new Block([], cons(tryBlock, nil()), tryBlock.lineno, tryBlock.source);
}
var catchList;
var cell = catchList = cons(null, nil());
var sawDefaultCatch = false;
var peek = this.peekToken();
if ( peek === Token.CATCH ) {
while ( this.matchToken(Token.CATCH) ) {
if ( sawDefaultCatch ) this.reportError("msg.catch.unreachable");
var line = this.ts.getLineno();
this.mustMatchToken(Token.LP, "msg.no.paren.catch");
this.mustMatchToken(Token.NAME, "msg.bad.catchcond");
var variable = new Identifier(this.ts.getString());
var cond = null;
if ( this.matchToken(Token.IF) ) {
cond = this.expr(false);
} else {
sawDefaultCatch = true;
}
this.mustMatchToken(Token.RP, "msg.bad.catchcond");
this.mustMatchToken(Token.LC, "msg.no.brace.catchblock");
var block = new Block([], this.statements(), line, this.source);
this.mustMatchToken(Token.RC, "msg.no.brace.after.body");
var clause = new CatchGuard(variable, cond, block, line, this.source);
cell = cell.cdr = cons(clause, cell.cdr);
}
} else if ( peek !== Token.FINALLY ) {
this.mustMatchToken(Token.FINALLY, "msg.try.no.catchfinally");
}
catchList = catchList.cdr;
var finallyBlock = null;
if ( this.matchToken(Token.FINALLY) ) {
// Rhino also allows any kind of statement here.
finallyBlock = this.statement();
if ( !(finallyBlock instanceof Block) ) {
this.addWarning("msg.no.brace.finallyblock");
finallyBlock = new Block([], cons(finallyBlock, nil()), finallyBlock.lineno, finallyBlock.source);
}
}
return finallyBlock
? new TryCatchListFinallyStatement(labels, tryBlock, catchList, finallyBlock, lineno, this.source)
: new TryCatchListStatement(labels, tryBlock, catchList, lineno, this.source);
}
case Token.THROW: {
this.consumeToken();
if ( this.peekTokenOrEOL() === Token.EOL ) {
// ECMAScript does not allow new lines before throw expression,
// see bug 256617
this.reportError("msg.bad.throw.eol");
}
var lineno = this.ts.getLineno();
statement = new ThrowStatement(labels, this.expr(false), lineno, this.source);
break;
}
case Token.BREAK: {
this.consumeToken();
var lineno = this.ts.getLineno();
var target = this.matchJumpLabelName(Token.BREAK);
if ( target == null ) {
if ( !this.nestingOfLoop && !this.nestingOfSwitch ) this.reportError("msg.bad.break");
}
statement = new BreakStatement(labels, target, lineno, this.source);
break;
}
case Token.CONTINUE: {
this.consumeToken();
var lineno = this.ts.getLineno();
var target = this.matchJumpLabelName(Token.CONTINUE);
if ( target == null ) {
if ( !this.nestingOfLoop ) reportError("msg.continue.outside");
}
statement = new ContinueStatement(labels, target, lineno, this.source);
break;
}
case Token.WITH: {
this.consumeToken();
var lineno = this.ts.getLineno();
this.mustMatchToken(Token.LP, "msg.no.paren.with");
var exp = this.expr(false);
this.mustMatchToken(Token.RP, "msg.no.paren.after.with");
var body = this.statement();
return new WithStatement(labels, exp, body, lineno, this.source);
}
case Token.VAR: {
this.consumeToken();
statement = new VarStatement(labels, this.variables(false), lineno, this.source);
break;
}
case Token.RETURN: {
if ( !this.insideFunction() ) this.reportError("msg.bad.return");
this.consumeToken();
var lineno = this.ts.getLineno();
var exp;
/* This is ugly, but we don‘t want to require a semicolon. */
switch ( this.peekTokenOrEOL() ) {
case Token.SEMI:
case Token.RC:
case Token.EOF:
case Token.EOL:
case Token.ERROR:
exp = null;
break;
default:
exp = this.expr(false);
}
statement = new ReturnStatement(labels, exp, lineno, this.source);
break;
}
case Token.LC:
this.consumeToken();
var block = new Block(labels, this.statements(), lineno, this.source);
this.mustMatchToken(Token.RC, "msg.no.brace.block");
return block;
case Token.ERROR:
// Fall thru, to have a node for error recovery to work on
case Token.SEMI:
this.consumeToken();
return new EmptyStatement(labels, lineno, this.source);
case Token.FUNCTION: {
this.consumeToken();
return this.functionDecl(labels);
}
case Token.DEFAULT: {
this.consumeToken();
this.reportError("msg.XML.not.available");
}
case Token.NAME: {
var lineno = this.ts.getLineno();
this.setCheckForLabel();
try {
statement = new ExpStatement(labels, this.expr(false), lineno, this.source);
} catch ( e ) {
if ( e instanceof LabelException ) {
// Label found!
if ( this.allLabelSet.contains(e.label) ) this.reportError("msg.dup.label");
this.allLabelSet.add(e.label);
labels.push(e.label);
try {
statement = this.statementHelper(labels);
} finally {
this.allLabelSet.remove(e.label);
}
return statement;
} else {
throw e;
}
}
break;
}
default: {
var lineno = this.ts.getLineno();
statement = new ExpStatement(labels, this.expr(false), lineno, this.source);
break;
}
}
switch ( this.peekTokenOrEOL() ) {
case Token.SEMI:
// Consume ‘;‘ as a part of statement
this.consumeToken();
break;
case Token.ERROR:
case Token.EOF:
case Token.EOL:
case Token.RC:
// Autoinsert ;
break;
default:
// Report error if no EOL or autoinsert ; otherwise
this.reportError("msg.no.semi.stmt");
}
return statement;
};
proto.condition = function ( )
{
this.mustMatchToken(Token.LP, "msg.no.paren.cond");
var exp = this.expr(false);
this.mustMatchToken(Token.RP, "msg.no.paren.after.cond");
if ( exp instanceof SimpleAssignExpression ) this.addWarning("msg.assign.cond");
return exp;
};
// match a NAME; return null if no match.
proto.matchJumpLabelName = function ( token )
{
if ( this.peekTokenOrEOL() !== Token.NAME ) return null;
var label = new Identifier(this.ts.getString());
this.consumeToken();
switch ( token ) {
case Token.CONTINUE:
if ( !this.loopLabelSet.contains(label) ) {
this.reportError("msg.undef.label");
}
break;
case Token.BREAK:
if ( !this.allLabelSet.contains(label) ) {
this.reportError("msg.undef.label");
}
break;
default:
throw Kit.codeBug();
}
return label;
};
proto.statementsInSwitch = function ( )
{
var head, cell;
head = cell = cons(null, nil());
clauseLoop: for (;;) {
switch ( this.peekToken() ) {
case Token.ERROR:
case Token.EOF:
case Token.RC:
case Token.CASE:
break clauseLoop;
case Token.DEFAULT:
this.consumeToken();
var tt = this.peekToken();
this.ungetToken(Token.DEFAULT);
if ( tt === Token.COLON ) break clauseLoop;
// fall thru
default:
cell = cell.cdr = cons(this.statement(), cell.cdr);
}
}
return head.cdr;
};
proto.variables = function ( inForInit )
{
var decls = [];
for (;;) {
this.mustMatchToken(Token.NAME, "msg.bad.var");
var name = new Identifier(this.ts.getString());
var init = this.matchToken(Token.ASSIGN)
? this.assignExpr(inForInit)
: null;
decls.push({id: name, exp: init});
if ( !this.matchToken(Token.COMMA) ) break;
}
return decls;
};
proto.expr = function ( inForInit )
{
var exp = this.assignExpr(inForInit);
while ( this.matchToken(Token.COMMA) ) {
exp = new CommaExpression(exp, this.assignExpr(inForInit));
}
return exp;
};
proto.assignExpr = function ( inForInit )
{
var exp = this.condExpr(inForInit);
var tt = this.peekToken();
if ( tt < Token.FIRST_ASSIGN || Token.LAST_ASSIGN < tt ) return exp;
if ( !exp.hasLvalue() ) this.reportError("msg.bad.assign.left");
switch ( this.nextToken() ) {
case Token.ASSIGN:
return new SimpleAssignExpression(exp, this.assignExpr(inForInit));
case Token.ASSIGN_BITOR:
return new BitOrAssignExpression(exp, this.assignExpr(inForInit));
case Token.ASSIGN_BITXOR:
return new BitXorAssignExpression(exp, this.assignExpr(inForInit));
case Token.ASSIGN_BITAND:
return new BitAndAssignExpression(exp, this.assignExpr(inForInit));
case Token.ASSIGN_LSH:
return new LShiftAssignExpression(exp, this.assignExpr(inForInit));
case Token.ASSIGN_RSH:
return new RShiftAssignExpression(exp, this.assignExpr(inForInit));
case Token.ASSIGN_URSH:
return new URShiftAssignExpression(exp, this.assignExpr(inForInit));
case Token.ASSIGN_ADD:
return new AddAssignExpression(exp, this.assignExpr(inForInit));
case Token.ASSIGN_SUB:
return new SubAssignExpression(exp, this.assignExpr(inForInit));
case Token.ASSIGN_MUL:
return new MulAssignExpression(exp, this.assignExpr(inForInit));
case Token.ASSIGN_DIV:
return new DivAssignExpression(exp, this.assignExpr(inForInit));
case Token.ASSIGN_MOD:
return new ModAssignExpression(exp, this.assignExpr(inForInit));
default:
throw Kit.codeBug();
}
};
proto.condExpr = function ( inForInit )
{
var exp = this.orExpr(inForInit);
if ( !this.matchToken(Token.HOOK) ) return exp;
var ifTrue = this.assignExpr(false);
this.mustMatchToken(Token.COLON, "msg.no.colon.cond");
var ifFalse = this.assignExpr(inForInit);
return new ConditionalExpression(exp, ifTrue, ifFalse);
};
proto.orExpr = function ( inForInit )
{
var exp = this.andExpr(inForInit);
while ( this.matchToken(Token.OR) ) {
exp = new OrExpression(exp, this.andExpr(inForInit));
}
return exp;
};
proto.andExpr = function ( inForInit )
{
var exp = this.bitOrExpr(inForInit);
while ( this.matchToken(Token.AND) ) {
exp = new AndExpression(exp, this.bitOrExpr(inForInit));
}
return exp;
};
proto.bitOrExpr = function ( inForInit )
{
var exp = this.bitXorExpr(inForInit);
while ( this.matchToken(Token.BITOR) ) {
exp = new BitOrExpression(exp, this.bitXorExpr(inForInit));
}
return exp;
};
proto.bitXorExpr = function ( inForInit )
{
var exp = this.bitAndExpr(inForInit);
while ( this.matchToken(Token.BITXOR) ) {
exp = new BitXorExpression(exp, this.bitAndExpr(inForInit));
}
return exp;
};
proto.bitAndExpr = function ( inForInit )
{
var exp = this.eqExpr(inForInit);
while ( this.matchToken(Token.BITAND) ) {
exp = new BitAndExpression(exp, this.eqExpr(inForInit));
}
return exp;
};
proto.eqExpr = function ( inForInit )
{
var exp = this.relExpr(inForInit);
for (;;) {
var constructor;
switch ( this.peekToken() ) {
case Token.EQ:
constructor = EqualExpression;
break;
case Token.NE:
constructor = NotEqualExpression;
break;
case Token.SHEQ:
constructor = StrictEqualExpression;
break;
case Token.SHNE:
constructor = StrictNotEqualExpression;
break;
default:
return exp;
}
this.consumeToken();
exp = new constructor(exp, this.relExpr(inForInit));
}
};
proto.relExpr = function ( inForInit )
{
var exp = this.shiftExpr();
for (;;) {
var constructor;
switch ( this.peekToken() ) {
case Token.IN:
if ( inForInit ) return exp;
constructor = InExpression;
break;
case Token.INSTANCEOF:
constructor = InstanceofExpression;
break;
case Token.LE:
constructor = LessEqualExpression;
break;
case Token.LT:
constructor = LessThanExpression;
break;
case Token.GE:
constructor = GreaterEqualExpression;
break;
case Token.GT:
constructor = GreaterThanExpression;
break;
default:
return exp;
}
this.consumeToken();
exp = new constructor(exp, this.shiftExpr());
}
};
proto.shiftExpr = function ( )
{
var exp = this.addExpr();
for (;;) {
var constructor;
switch ( this.peekToken() ) {
case Token.LSH:
constructor = LShiftExpression;
break;
case Token.RSH:
constructor = RShiftExpression;
break;
case Token.URSH:
constructor = URShiftExpression;
break;
default:
return exp;
}
this.consumeToken();
exp = new constructor(exp, this.addExpr());
}
};
proto.addExpr = function ( )
{
var exp = this.mulExpr();
for (;;) {
var constructor;
switch ( this.peekToken() ) {
case Token.ADD:
constructor = AddExpression;
break;
case Token.SUB:
constructor = SubExpression;
break;
default:
return exp;
}
this.consumeToken();
exp = new constructor(exp, this.mulExpr());
}
};
proto.mulExpr = function ( )
{
var exp = this.unaryExpr();
for (;;) {
var constructor;
switch ( this.peekToken() ) {
case Token.MUL:
constructor = MulExpression;
break;
case Token.DIV:
constructor = DivExpression;
break;
case Token.MOD:
constructor = ModExpression;
break;
default:
return exp;
}
this.consumeToken();
exp = new constructor(exp, this.unaryExpr());
}
};
proto.unaryExpr = function ( )
{
var constructor;
var needLvalue = http://www.mamicode.com/null;"msg.bad.incr";
break;
case Token.DEC:
constructor = PreDecExpression;
needLvalue = "http://www.mamicode.com/msg.bad.decr";
break;
case Token.DELPROP:
constructor = DeleteExpression;
break;
default:
var exp = this.memberExpr(true);
// Don‘t look across a newline boundary for a postfix incop.
switch ( this.peekTokenOrEOL() ) {
case Token.INC:
if ( !exp.hasLvalue() ) this.reportError("msg.bad.incr");
this.consumeToken();
return new PostIncExpression(exp);
case Token.DEC:
if ( !exp.hasLvalue() ) this.reportError("msg.bad.decr");
this.consumeToken();
return new PostDecExpression(exp);
default:
return exp;
}
}
this.consumeToken();
var exp = this.unaryExpr();
if ( needLvalue && !exp.hasLvalue() ) this.reportError(needLvalue);
return new constructor(exp);
};
proto.argumentList = function ( )
{
if ( this.matchToken(Token.RP) ) return [];
var args = [];
do {
args.push( this.assignExpr(false) );
} while ( this.matchToken(Token.COMMA) );
this.mustMatchToken(Token.RP, "msg.no.paren.arg");
return args;
};
proto.memberExpr = function ( allowCallSyntax )
{
var base;
if ( this.matchToken(Token.NEW) ) {
var func = this.memberExpr(false);
var args = this.matchToken(Token.LP)
? this.argumentList()
: [];
base = new NewExpression(func, args);
} else {
base = this.primaryExpr();
}
return this.memberExprTail(allowCallSyntax, base);
}
proto.memberExprTail = function ( allowCallSyntax, base )
{
tailLoop: for (;;) {
switch ( this.peekToken() ) {
case Token.DOTDOT:
this.reportError("msg.XML.not.available");
case Token.DOT: {
this.consumeToken();
switch ( this.nextToken() ) {
case Token.NAME:
base = new DotAccessor(base, new Identifier(this.ts.getString()));
break;
case Token.MUL:
this.reportError("msg.XML.not.available");
case Token.XMLATTR:
this.reportError("msg.XML.not.available");
default:
this.reportError("msg.no.name.after.dot");
}
}
break;
case Token.DOTQUERY:
this.reportError("msg.XML.not.available");
case Token.LB:
this.consumeToken();
base = new BracketAccessor(base, this.expr(false));
this.mustMatchToken(Token.RB, "msg.no.bracket.index");
break;
case Token.LP:
if ( !allowCallSyntax ) break tailLoop;
this.consumeToken();
base = new CallExpression(base, this.argumentList());
break;
default:
break tailLoop;
}
}
return base;
};
proto.primaryExpr = function ( )
{
var exp;
var ttFlagged = this.nextFlaggedToken();
var tt = ttFlagged & CLEAR_TI_MASK;
switch ( tt ) {
case Token.FUNCTION:
return this.functionExpr();
case Token.LB: {
var elems = [];
elemLoop: for (;;) {
switch ( this.peekToken() ) {
case Token.RB:
this.consumeToken();
break elemLoop;
case Token.COMMA:
while ( this.matchToken(Token.COMMA) ) {
elems.push(new Elision());
}
break;
default:
elems.push(this.assignExpr(false));
if ( this.matchToken(Token.COMMA) ) {
continue elemLoop;
} else if ( this.matchToken(Token.RB) ) {
break elemLoop;
} else {
this.reportError("msg.no.bracket.arg");
}
}
}
return new ArrayInitializer(elems);
}
case Token.LC: {
var pairs = [];
commaloop: do {
var prop;
switch ( this.peekToken() ) {
case Token.NAME:
this.consumeToken();
prop = new Identifier(this.ts.getString());
break;
case Token.STRING:
this.consumeToken();
prop = new StringLiteral(this.ts.getString());
break;
case Token.NUMBER:
this.consumeToken();
prop = new NumberLiteral(this.ts.getString());
break;
case Token.RC:
// trailing comma is OK.
break commaloop;
default:
this.reportError("msg.bad.prop");
break commaloop;
}
this.mustMatchToken(Token.COLON, "msg.no.colon.prop");
pairs.push({prop:prop, exp:this.assignExpr(false)});
} while ( this.matchToken(Token.COMMA) );
this.mustMatchToken(Token.RC, "msg.no.brace.prop");
return new ObjectInitializer(pairs);
}
case Token.LP:
var exp = this.expr(false);
this.mustMatchToken(Token.RP, "msg.no.paren");
return exp;
case Token.XMLATTR:
this.reportError("msg.XML.not.available");
case Token.NAME:
var name = new Identifier(this.ts.getString());
if ( ttFlagged & TI_CHECK_LABEL ) {
if ( this.matchToken(Token.COLON) ) throw new LabelException(name);
}
return name;
case Token.NUMBER:
return new NumberLiteral(this.ts.getString());
case Token.STRING:
return new StringLiteral(this.ts.getString());
case Token.DIV:
case Token.ASSIGN_DIV:
// Got / or /= which should be treated as regexp in fact
this.ts.readRegExp(tt);
return new RegExpLiteral(this.ts.getString());
case Token.NULL:
return new NullLiteral();
case Token.THIS:
return new ThisExpression();
case Token.TRUE:
return new TrueLiteral();
case Token.FALSE:
return new FalseLiteral();
case Token.RESERVED:
this.reportError("msg.reserved.id");
break;
case Token.ERROR:
/* the scanner or one of its subroutines reported the error. */
break;
case Token.EOF:
this.reportError("msg.unexpected.eof");
break;
default:
this.reportError("msg.syntax");
break;
}
return null; // should never reach here
}
return {
Parser: Parser
};
}();
}
}
}
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.Parser = Parser;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
var IL = Concurrent.Thread.Compiler.IntermediateLanguage;
var Cf = "$Concurrent_Thread_Compiler_Cf";
function CfConvert ( func ) {
var cache = new IdentifierMap();
var start = CfTarget(func.start, cache);
var cache2 = new IdentifierMap();
cache.values().forEach(function( it ){
cache2.put(new Identifier(it.id), it);
});
var body = cons(null, nil());
append = adder(body);
cacheToList(cache2).forEach(function( it ){
return append(cache2.get(it));
});
return new IL.Function(func.name, func.params, func.vars, body.cdr, start);
}
function cacheToList ( cache ) {
// Resolves exception-dependency and sort blocks in valid order.
var blocks = [];
var depends = new IdentifierMap();
cache.values().forEach(function( it ){
blocks.push(it);
depends.put(
new Identifier(it.id),
it.exception instanceof IL.Block ? new Identifier(it.exception.id) : undefined
);
});
return check_cyclic(depends);
}
var CyclicExceptionHandlerError = Error.extend(
function ( $super, message ) { $super(message); },
{name: NAMESPACE + ".CyclicExceptionHandlerError"}
);
function check_cyclic ( depends ) {
var ok = {};
function traverse ( id, path ) {
if ( ok[id] ) return "OK";
var next = depends.get(id);
if ( !next ) {
ok[id] = true;
path.push(id);
return "OK";
}
path.forEach(function( it ){
if ( it.valueOf() == id.valueOf() ) {
throw new CyclicExceptionHandlerError("cyclic exception handler: " + path.concat([id]).join(" -> "));
}
});
path.push(id);
traverse(next, path);
ok[id] = true;
return "OK";
}
var result = [];
depends.keys().forEach(function( it ){
var path = [];
traverse(it, path);
result = path.concat(result);
});
return result.reverse();
}
function CfTarget ( b, cache ) {
if ( b === "return" || b === "throw" ) return b;
if ( cache.get(new Identifier(b.id)) ) return cache.get(new Identifier(b.id));
return b[Cf](cache);
}
IL.GotoBlock.prototype[Cf] = function ( cache ) {
var block = new IL.GotoBlock();
cache.put(new Identifier(this.id), block);
block.scopes = this.scopes.map(function( it ){ return it[Cf](cache); });
block.body = this.body.map(function( it ){ return it[Cf](cache); });
block.arg = this.arg[Cf](cache);
block.target = CfTarget(this.target, cache);
block.exception = CfTarget(this.exception, cache);
return block;
};
IL.CallBlock.prototype[Cf] = function ( cache ) {
var block = new IL.CallBlock();
cache.put(new Identifier(this.id), block);
block.scopes = this.scopes.map(function( it ){ return it[Cf](cache); });
block.body = this.body.map(function( it ){ return it[Cf](cache); });
block.this_val = this.this_val[Cf](cache);
block.func = this.func[Cf](cache);
block.args = this.args.map(function( it ){ return it[Cf](cache); });
block.target = CfTarget(this.target, cache);
block.exception = CfTarget(this.exception, cache);
return block;
};
IL.NewBlock.prototype[Cf] = function ( cache ) {
var block = new IL.NewBlock();
cache.put(new Identifier(this.id), block);
block.scopes = this.scopes.map(function( it ){ return it[Cf](cache); });
block.body = this.body.map(function( it ){ return it[Cf](cache); });
block.func = this.func[Cf](cache);
block.args = this.args.map(function( it ){ return it[Cf](cache); });
block.target = CfTarget(this.target, cache);
block.exception = CfTarget(this.exception, cache);
return block;
};
IL.ExpStatement.prototype[Cf] = function ( cache ) {
return new IL.ExpStatement(
this.exp[Cf](cache)
);
};
IL.CondStatement.prototype[Cf] = function ( cache ) {
return new IL.CondStatement(
this.cond[Cf](cache),
CfTarget(this.target, cache)
);
};
IL.RecvStatement.prototype[Cf] = function ( cache ) {
return new IL.RecvStatement(
this.assignee[Cf](cache)
);
};
IL.EnumStatement.prototype[Cf] = function ( cache ) {
return new IL.EnumStatement(
this.exp[Cf](cache),
this.assignee[Cf](cache)
);
};
Expression.prototype[Cf] = function ( cache ) {
return this;
};
UnaryExpression.prototype[Cf] = function ( cache ) {
return new this.constructor(this.exp[Cf](cache));
};
BinaryExpression.prototype[Cf] = function ( cache ) {
return new this.constructor(this.left[Cf](cache), this.right[Cf](cache));
};
ArrayInitializer.prototype[Cf] = function ( cache ) {
return new ArrayInitializer(this.elems.map(function( it ){
return it[Cf](cache);
}));
};
FunctionExpression.prototype[Cf] = function ( cache ) {
return prepareTree(this);
};
ObjectInitializer.prototype[Cf] = function ( cache ) {
return new ObjectInitializer(this.pairs.map(function( it ){
return { prop: it.prop, exp: it.exp[Cf](cache) };
}));
};
DotAccessor.prototype[Cf] = function ( cache ) {
return new DotAccessor(this.base[Cf](cache), this.prop);
};
ConditionalExpression.prototype[Cf] = function ( cache ) {
return new ConditionalExpression(
this.cond[Cf](cache),
this.texp[Cf](cache),
this.fexp[Cf](cache)
);
};
return {
CfConvert: CfConvert, CyclicExceptionHandlerError: CyclicExceptionHandlerError
};
}();
}
}
}
}
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.CfConvert = CfConvert;
this.Concurrent.Thread.Compiler.CyclicExceptionHandlerError = CyclicExceptionHandlerError;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
var IL = Concurrent.Thread.Compiler.IntermediateLanguage;
var Cs = "Concurrent.Thread.Compiler.CsConvert";
var STACK_VAR = "$Concurrent_Thread_stack";
var undefinedExp = new VoidExpression(new NumberLiteral(0));
var emptyLabel = new Identifier("");
function isStackVar ( v ) {
return v instanceof Identifier
&& v.valueOf().match(/^$Concurrent_Thread_stack/);
}
function Context ( ) {
this.stackVars = [];
this.contBreak = new IdentifierMap();
this.contContinue = new IdentifierMap();
this.contReturn = "return";
this.contThrow = "throw";
this.scopes = [];
}
var proto = Context.prototype;
proto.getStackVar = function ( n ) {
n = Math.floor(n);
if ( isNaN(n) || n < 0 ) Kit.codeBug("must be integer greater than zero");
for ( var i=this.stackVars.length; i <= n; i++ ) {
this.stackVars[i] = new Identifier(STACK_VAR + i);
}
return this.stackVars[n];
};
proto.putBreakLabels = function ( labels, target ) {
if ( !labels.length ) return this.contBreak;
var restore = this.contBreak;
this.contBreak = this.contBreak.clone();
for ( var i=0; i < labels.length; i++ ) {
this.contBreak.put(labels[i], target);
}
return restore;
};
proto.putBreakAndContinueLabels = function ( labels, breakTarget, continueTarget ) {
if ( !labels.length ) {
return {
contBreak : this.contBreak,
contContinue: this.contContinue
};
}
var restore = {
contBreak : this.contBreak,
contContinue: this.contContinue
};
this.contBreak = this.contBreak.clone();
this.contContinue = this.contContinue.clone();
for ( var i=0; i < labels.length; i++ ) {
this.contBreak.put(labels[i], breakTarget);
this.contContinue.put(labels[i], continueTarget);
}
return restore;
};
proto.getScopes = function ( ) {
return this.scopes.slice(0, this.scopes.length);
};
proto.pushScope = function ( /* variable args */ ) {
return this.scopes.push.apply(this.scopes, arguments);
};
proto.popScope = function ( ) {
return this.scopes.pop();
};
proto.makeGotoBlock = function ( arg, target ) {
return new IL.GotoBlock(this.getScopes(), nil(), arg, target, this.contThrow);
};
function CsConvert ( func ) {
var context = new Context();
var last_block = new IL.GotoBlock([], nil(), undefinedExp, "return", "throw");
func.body = CsStatements(func.body, list(last_block), context, 0);
func.start = func.body.car;
func.vars = func.vars.concat(context.stackVars);
return func;
}
function CsStatements ( stmts, follows, ctxt, sttop ) {
if ( stmts.isNil() ) return follows;
follows = CsStatements(stmts.cdr, follows, ctxt, sttop);
return stmts.car[Cs](follows, ctxt, sttop);
}
function CsReference ( exp, ctxt, sttop, rest ) { // Expression -> Context -> Int -> (Expression -> <Block>) -> <Block>
if ( exp instanceof DotAccessor ) {
var e = new DotAccessor(ctxt.getStackVar(sttop), exp.prop);
var follows = rest(e, sttop+1);
return exp.base[Cs](follows, ctxt, sttop);
} else if ( exp instanceof BracketAccessor ) {
var e = new BracketAccessor(ctxt.getStackVar(sttop), ctxt.getStackVar(sttop+1));
var follows = rest(e, sttop+2);
follows = exp.right[Cs](follows, ctxt, sttop+1);
return exp.left[Cs](follows, ctxt, sttop);
} else if ( exp instanceof Identifier ) {
return rest(exp, sttop);
} else {
var follows = rest(ctxt.getStackVar(sttop), sttop+1);
return exp[Cs](follows, ctxt, sttop);
}
}
EmptyStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
return follows;
};
Block.prototype[Cs] = function ( follows, ctxt, sttop ) {
var restore = ctxt.putBreakLabels(this.labels, follows.car);
follows = cons( ctxt.makeGotoBlock(undefinedExp, follows.car), follows);
try {
return CsStatements(this.body, follows, ctxt, sttop);
} finally {
ctxt.contBreak = restore;
}
};
ExpStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
return this.exp[Cs](follows, ctxt, sttop);
};
IfStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
var next_block = follows.car;
follows = cons( ctxt.makeGotoBlock(undefinedExp, next_block), follows);
var restore = ctxt.putBreakLabels(this.labels, next_block);
try {
follows = this.body[Cs](follows, ctxt, sttop);
follows.car.prependStatement( new IL.CondStatement(new NotExpression(ctxt.getStackVar(sttop)), next_block) );
return this.cond[Cs](follows, ctxt, sttop);
} finally {
ctxt.contBreak = restore;
}
};
IfElseStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
var next_block = follows.car;
follows = cons( ctxt.makeGotoBlock(undefinedExp, next_block), follows);
var restore = ctxt.putBreakLabels(this.labels, next_block);
try {
follows = this.tbody[Cs](follows, ctxt, sttop);
var true_block = follows.car;
follows = cons( ctxt.makeGotoBlock(undefinedExp, next_block), follows);
follows = this.fbody[Cs](follows, ctxt, sttop);
follows.car.prependStatement( new IL.CondStatement(ctxt.getStackVar(sttop), true_block) );
return this.cond[Cs](follows, ctxt, sttop);
} finally {
ctxt.contBreak = restore;
}
};
DoWhileStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
var next_block = follows.car;
var first_block = ctxt.makeGotoBlock(undefinedExp, null);
follows = cons( ctxt.makeGotoBlock(undefinedExp, next_block), follows );
if ( this.cond.containsFunctionCall() ) {
follows.car.prependStatement( new IL.CondStatement(ctxt.getStackVar(sttop), first_block) );
follows = this.cond[Cs](follows, ctxt, sttop);
} else {
follows.car.prependStatement( new IL.CondStatement(this.cond, first_block) );
}
var continue_block = follows.car;
follows = cons( ctxt.makeGotoBlock(undefinedExp, follows.car), follows );
var restore = ctxt.putBreakAndContinueLabels(this.labels.concat(emptyLabel), next_block, continue_block);
try {
follows = this.body[Cs](follows, ctxt, sttop);
} finally {
ctxt.contBreak = restore.contBreak;
ctxt.contContinue = restore.contContinue;
}
first_block.target = follows.car;
return cons( ctxt.makeGotoBlock(undefinedExp, first_block),
cons(first_block, follows) );
};
WhileStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
var next_block = follows.car;
var first_block = ctxt.makeGotoBlock(undefinedExp, null);
follows = cons( ctxt.makeGotoBlock(undefinedExp, first_block), follows );
var restore = ctxt.putBreakAndContinueLabels(this.labels.concat(emptyLabel), next_block, first_block);
try {
follows = this.body[Cs](follows, ctxt, sttop);
} finally {
ctxt.contBreak = restore.contBreak;
ctxt.contContinue = restore.contContinue;
}
if ( this.cond.containsFunctionCall() ) {
follows.car.prependStatement( new IL.CondStatement(new NotExpression(ctxt.getStackVar(sttop)), next_block) );
follows = this.cond[Cs](follows, ctxt, sttop);
} else {
follows.car.prependStatement( new IL.CondStatement(new NotExpression(this.cond), next_block) );
}
first_block.target = follows.car;
return cons( ctxt.makeGotoBlock(undefinedExp, first_block),
cons(first_block, follows) );
};
ForStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
var next_block = follows.car;
var last_block = ctxt.makeGotoBlock(undefinedExp, null);
follows = cons(last_block, follows);
if ( this.incr ) follows = this.incr[Cs](follows, ctxt, sttop);
var incr_block = follows.car;
follows = cons( ctxt.makeGotoBlock(undefinedExp, follows.car), follows );
var restore = ctxt.putBreakAndContinueLabels(this.labels.concat(emptyLabel), next_block, incr_block);
try {
follows = this.body[Cs](follows, ctxt, sttop);
} finally {
ctxt.contBreak = restore.contBreak;
ctxt.contContinue = restore.contContinue;
}
if ( this.cond ) {
if ( this.cond.containsFunctionCall() ) {
follows.car.prependStatement( new IL.CondStatement(new NotExpression(ctxt.getStackVar(sttop)), next_block) );
follows = this.cond[Cs](follows, ctxt, sttop);
} else {
follows.car.prependStatement( new IL.CondStatement(new NotExpression(this.cond), next_block) );
}
}
last_block.target = follows.car;
follows = cons( ctxt.makeGotoBlock(undefinedExp, follows.car), follows );
if ( this.init ) {
follows = this.init[Cs](follows, ctxt, sttop);
}
return follows;
};
ForInStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
if ( !this.lhs.hasLvalue() ) Kit.codeBug(‘for-in requires lvalue on the left hand side of "in": ‘ + this);
var next_block = follows.car;
var loop_block = ctxt.makeGotoBlock(undefinedExp, null);
follows = cons( ctxt.makeGotoBlock(undefinedExp, loop_block), follows );
var restore = ctxt.putBreakAndContinueLabels(this.labels.concat(emptyLabel), next_block, loop_block);
try {
follows = this.body[Cs](follows, ctxt, sttop+2);
} finally {
ctxt.contBreak = restore.contBreak;
ctxt.contContinue = restore.contContinue;
}
if ( this.lhs.containsFunctionCall() ) {
follows = CsReference(this.lhs, ctxt, sttop+2, function( exp ){
follows.car.prependStatement( make_assign(
exp,
new BracketAccessor(
ctxt.getStackVar(sttop),
new PostIncExpression(ctxt.getStackVar(sttop+1))
)
) );
return follows;
});
} else {
follows.car.prependStatement( make_assign(
this.lhs,
new BracketAccessor(
ctxt.getStackVar(sttop),
new PostIncExpression(ctxt.getStackVar(sttop+1))
)
) );
}
follows.car.prependStatement( new IL.CondStatement(
new GreaterEqualExpression(
ctxt.getStackVar(sttop+1),
new DotAccessor(ctxt.getStackVar(sttop), new Identifier("length"))
),
next_block
) );
loop_block.target = follows.car;
follows = cons( loop_block, follows );
follows = cons( ctxt.makeGotoBlock(undefinedExp, loop_block), follows );
follows.car.prependStatement( make_assign(ctxt.getStackVar(sttop+1), new NumberLiteral(0)) );
if ( this.exp.containsFunctionCall() ) {
follows.car.prependStatement( new IL.EnumStatement(ctxt.getStackVar(sttop), ctxt.getStackVar(sttop)) );
follows = this.exp[Cs](follows, ctxt, sttop);
} else {
follows.car.prependStatement( new IL.EnumStatement(this.exp, ctxt.getStackVar(sttop)) );
}
return follows;
};
ContinueStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
return cons(
ctxt.makeGotoBlock(
undefinedExp,
ctxt.contContinue.get( this.target ? this.target : emptyLabel )
),
follows
);
};
BreakStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
var restore = ctxt.putBreakLabels(this.labels, follows.car);
try {
return cons(
ctxt.makeGotoBlock(
undefinedExp,
ctxt.contBreak.get( this.target ? this.target : emptyLabel )
),
follows
);
} finally {
ctxt.contBreak = restore;
}
};
ReturnStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
if ( this.exp ) {
if ( this.exp.containsFunctionCall() ) {
follows = cons( ctxt.makeGotoBlock(ctxt.getStackVar(sttop), ctxt.contReturn), follows );
return this.exp[Cs](follows, ctxt, sttop);
} else {
return cons( ctxt.makeGotoBlock(this.exp, ctxt.contReturn), follows );
}
} else {
return cons( ctxt.makeGotoBlock(undefinedExp, ctxt.contReturn), follows );
}
};
WithStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
var next_block = follows.car;
var restore = ctxt.putBreakLabels(this.labels, next_block);
try {
ctxt.pushScope(ctxt.getStackVar(sttop));
try {
follows = cons( ctxt.makeGotoBlock(undefinedExp, next_block), follows );
follows = this.body[Cs](follows, ctxt, sttop+1);
} finally {
ctxt.popScope();
}
follows = cons( ctxt.makeGotoBlock(undefinedExp, follows.car), follows );
return this.exp[Cs](follows, ctxt, sttop);
} finally {
ctxt.contBreak = restore;
}
};
SwitchStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
var next_block = follows.car;
var restore = ctxt.putBreakLabels(this.labels.concat(emptyLabel) , next_block);
try {
var default_target = next_block;
var cond_and_target = this.clauses.reverse().map(function( clause ){
follows = cons( ctxt.makeGotoBlock(undefinedExp, follows.car), follows );
follows = CsStatements(clause.body, follows, ctxt, sttop);
var clause_block = follows.car;
if ( clause instanceof DefaultClause ) {
default_target = clause_block;
ignore();
} else {
return {cond:clause.exp, target:clause_block};
}
});
follows = cons( ctxt.makeGotoBlock(undefinedExp, default_target), follows );
cond_and_target.forEach(function( it ){
if ( it.cond.containsFunctionCall() ) {
follows.car.prependStatement(
new IL.CondStatement(
new StrictEqualExpression(ctxt.getStackVar(sttop), ctxt.getStackVar(sttop+1)),
it.target
)
);
follows = it.cond[Cs](follows, ctxt, sttop+1);
} else {
follows.car.prependStatement(
new IL.CondStatement(
new StrictEqualExpression(ctxt.getStackVar(sttop), it.cond),
it.target
)
);
}
});
return this.exp[Cs](follows, ctxt,sttop);
} finally {
ctxt.contBreak = restore;
}
};
ThrowStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
if ( this.exp.containsFunctionCall() ) {
follows = cons( ctxt.makeGotoBlock(ctxt.getStackVar(sttop), ctxt.contThrow), follows );
return this.exp[Cs](follows, ctxt, sttop);
} else {
return cons( ctxt.makeGotoBlock(this.exp, ctxt.contThrow), follows );
}
};
TryCatchStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
var next_block = follows.car;
follows = cons( ctxt.makeGotoBlock(undefinedExp, next_block), follows );
var restore = ctxt.putBreakLabels(this.labels, next_block);
try {
follows = this.catchBlock[Cs](follows, ctxt, sttop);
follows.car.prependStatement( new IL.RecvStatement(this.variable) );
var storeContThrow = ctxt.contThrow;
ctxt.contThrow = follows.car;
try {
follows = cons( ctxt.makeGotoBlock(undefinedExp, next_block), follows );
return this.tryBlock[Cs](follows, ctxt, sttop);
} finally {
ctxt.contThrow = storeContThrow;
}
} finally {
ctxt.contBreak = restore;
}
};
TryFinallyStatement.prototype[Cs] = function ( follows, ctxt, sttop ) {
var next_block = follows.car;
follows = cons( ctxt.makeGotoBlock(undefinedExp, next_block), follows );
var restoreBreak = ctxt.putBreakLabels(this.labels, next_block);
try {
var self = this;
var contBreak = new IdentifierMap();
ctxt.contBreak.keys().forEach(function( label ){
follows = cons( ctxt.makeGotoBlock(undefinedExp, ctxt.contBreak.get(label)), follows );
follows = self.finallyBlock[Cs](follows, ctxt, sttop);
contBreak.put(label, follows.car);
});
var contContinue = new IdentifierMap();
ctxt.contContinue.keys().forEach(function( label ){
follows = cons( ctxt.makeGotoBlock(undefinedExp, ctxt.contContinue.get(label)), follows );
follows = self.finallyBlock[Cs](follows, ctxt, sttop);
contContinue.put(label, follows.car);
});
follows = cons( ctxt.makeGotoBlock(ctxt.getStackVar(sttop), ctxt.contReturn), follows );
follows = this.finallyBlock[Cs](follows, ctxt, sttop+1);
follows.car.prependStatement( new IL.RecvStatement(ctxt.getStackVar(sttop)) );
var contReturn = follows.car;
follows = cons( ctxt.makeGotoBlock(ctxt.getStackVar(sttop), ctxt.contThrow), follows );
follows = this.finallyBlock[Cs](follows, ctxt, sttop+1);
follows.car.prependStatement( new IL.RecvStatement(ctxt.getStackVar(sttop)) );
var contThrow = follows.car;
follows = cons( ctxt.makeGotoBlock(undefinedExp, next_block), follows );
follows = this.finallyBlock[Cs](follows, ctxt, sttop);
var restoreContinue = ctxt.contContinue;
var restoreReturn = ctxt.contReturn;
var restoreThrow = ctxt.contThrow;
ctxt.contBreak = contBreak;
ctxt.contContinue = contContinue;
ctxt.contReturn = contReturn;
ctxt.contThrow = contThrow;
try {
return this.tryBlock[Cs](follows, ctxt, sttop);
} finally {
ctxt.contContinue = restoreContinue;
ctxt.contReturn = restoreReturn;
ctxt.contThrow = restoreThrow;
}
} finally {
ctxt.contBreak = restoreBreak;
}
};
function make_assign ( left, right ) {
return new IL.ExpStatement( new SimpleAssignExpression(left, right) );
}
Expression.prototype[Cs] = function ( follows, ctxt, sttop ) {
follows.car.prependStatement( make_assign(ctxt.getStackVar(sttop), this) );
return follows;
};
ArrayInitializer.prototype[Cs] = function ( follows, ctxt, sttop ) {
for ( var asis_from=this.elems.length-1; asis_from >= 0; asis_from-- ) {
if ( this.elems[asis_from].containsFunctionCall() ) break;
}
asis_from++;
var elems = [];
for ( var i=0; i < asis_from; i++ ) {
elems[i] = ctxt.getStackVar(sttop+i);
}
for ( ; i < this.elems.length; i++ ) {
elems[i] = this.elems[i];
}
follows.car.prependStatement( make_assign(ctxt.getStackVar(sttop), new ArrayInitializer(elems)) );
for ( var i=asis_from-1; i >= 0; i-- ) {
follows = this.elems[i][Cs](follows, ctxt, sttop+i);
}
return follows;
};
ObjectInitializer.prototype[Cs] = function ( follows, ctxt, sttop ) {
for ( var asis_from=this.pairs.length-1; asis_from >= 0; asis_from-- ) {
if ( this.pairs[asis_from].exp.containsFunctionCall() ) break;
}
asis_from++;
var pairs = [];
for ( var i=0; i < asis_from; i++ ) {
pairs[i] = {prop:this.pairs[i].prop, exp:ctxt.getStackVar(sttop+i)};
}
for ( ; i < this.pairs.length; i++ ) {
pairs[i] = this.pairs[i];
}
follows.car.prependStatement( make_assign(ctxt.getStackVar(sttop), new ObjectInitializer(pairs)) );
for ( var i=asis_from-1; i >= 0; i-- ) {
follows = this.pairs[i].exp[Cs](follows, ctxt, sttop+i);
}
return follows;
};
UnaryExpression.prototype[Cs] = function ( follows, ctxt, sttop ) {
if ( this.exp.containsFunctionCall() ) {
follows.car.prependStatement( make_assign(ctxt.getStackVar(sttop), new this.constructor(ctxt.getStackVar(sttop))) );
return this.exp[Cs](follows, ctxt, sttop);
} else {
return Expression.prototype[Cs].apply(this, arguments);
}
};
BinaryExpression.prototype[Cs] = function ( follows, ctxt, sttop ) {
if ( this.right.containsFunctionCall() ) {
follows.car.prependStatement( make_assign(
ctxt.getStackVar(sttop),
new this.constructor(ctxt.getStackVar(sttop), ctxt.getStackVar(sttop+1))
) );
follows = this.right[Cs](follows, ctxt, sttop+1);
return this.left[Cs](follows, ctxt, sttop);
} else if ( this.left.containsFunctionCall() ) {
follows.car.prependStatement( make_assign(
ctxt.getStackVar(sttop),
new this.constructor(ctxt.getStackVar(sttop), this.right)
) );
return this.left[Cs](follows, ctxt, sttop);
} else {
return Expression.prototype[Cs].apply(this, arguments);
}
};
DotAccessor.prototype[Cs] = function ( follows, ctxt, sttop ) {
if ( this.base.containsFunctionCall() ) {
follows.car.prependStatement( make_assign(
ctxt.getStackVar(sttop),
new DotAccessor(ctxt.getStackVar(sttop), this.prop)
) );
return this.base[Cs](follows, ctxt, sttop);
} else {
return Expression.prototype[Cs].apply(this, arguments);
}
};
CallExpression.prototype[Cs] = function ( follows, ctxt, sttop ) {
var self = this;
return CsReference(this.func, ctxt, sttop, function ( func, sttop2 ) {
for ( var asis_from=self.args.length-1; asis_from >= 0; asis_from-- ) {
if ( self.args[asis_from].containsFunctionCall() ) break;
}
asis_from++;
var args = [];
for ( var i=0; i < asis_from; i++ ) {
args[i] = ctxt.getStackVar(sttop2+i);
}
for ( ; i < self.args.length; i++ ) {
args[i] = self.args[i];
}
follows.car.prependStatement( new IL.RecvStatement(ctxt.getStackVar(sttop)) );
follows = cons( new IL.CallBlock(
ctxt.getScopes(),
nil(),
func instanceof DotAccessor ? func.base :
func instanceof BracketAccessor ? func.left : new NullLiteral(),
func,
args,
follows.car,
ctxt.contThrow
), follows );
for ( var i=asis_from-1; i >= 0; i-- ) {
follows = self.args[i][Cs](follows, ctxt, sttop2+i);
}
return follows;
});
};
NewExpression.prototype[Cs] = function ( follows, ctxt, sttop ) {
for ( var asis_from=this.args.length-1; asis_from >= 0; asis_from-- ) {
if ( this.args[asis_from].containsFunctionCall() ) break;
}
asis_from++;
var args = [];
for ( var i=0; i < asis_from; i++ ) {
args[i] = ctxt.getStackVar(sttop+1+i);
}
for ( ; i < this.args.length; i++ ) {
args[i] = this.args[i];
}
follows.car.prependStatement( new IL.RecvStatement(ctxt.getStackVar(sttop)) );
follows = cons( new IL.NewBlock(
ctxt.getScopes(),
nil(),
ctxt.getStackVar(sttop),
args,
follows.car,
ctxt.contThrow
), follows );
for ( var i=asis_from-1; i >= 0; i-- ) {
follows = this.args[i][Cs](follows, ctxt, sttop+1+i);
}
this.func[Cs](follows, ctxt, sttop);
return follows;
};
AssignExpression.prototype[Cs] = function ( follows, ctxt, sttop ) {
var self = this;
if ( this.right.containsFunctionCall() ) {
return CsReference(this.left, ctxt, sttop, function ( left, sttop2 ) {
follows.car.prependStatement( make_assign(
ctxt.getStackVar(sttop),
new self.constructor(left, ctxt.getStackVar(sttop2))
) );
return self.right[Cs](follows, ctxt, sttop2);
});
} else if ( this.left.containsFunctionCall() ) {
return CsReference(this.left, ctxt, sttop, function ( left, sttop2 ) {
follows.car.prependStatement( make_assign(
ctxt.getStackVar(sttop),
new self.constructor(left, self.right)
) );
return follows;
});
} else {
return Expression.prototype[Cs].apply(this, arguments);
}
};
AndExpression.prototype[Cs] = function ( follows, ctxt, sttop ) {
if ( this.right.containsFunctionCall() ) {
var next_block = follows.car;
follows = cons( ctxt.makeGotoBlock(undefinedExp, next_block), follows );
follows = this.right[Cs](follows, ctxt, sttop);
follows.car.prependStatement( new IL.CondStatement(new NotExpression(ctxt.getStackVar(sttop)), next_block) );
return this.left[Cs](follows, ctxt, sttop);
} else if ( this.left.containsFunctionCall() ) {
follows.car.prependStatement( make_assign(ctxt.getStackVar(sttop), new AndExpression(ctxt.getStackVar(sttop), this.right)) );
return this.left[Cs](follows, ctxt, sttop);
} else {
return Expression.prototype[Cs].apply(this, arguments);
}
};
OrExpression.prototype[Cs] = function ( follows, ctxt, sttop ) {
if ( this.right.containsFunctionCall() ) {
var next_block = follows.car;
follows = cons( ctxt.makeGotoBlock(undefinedExp, next_block), follows );
follows = this.right[Cs](follows, ctxt, sttop);
follows.car.prependStatement( new IL.CondStatement(ctxt.getStackVar(sttop), next_block) );
return this.left[Cs](follows, ctxt, sttop);
} else if ( this.left.containsFunctionCall() ) {
follows.car.prependStatement( make_assign(ctxt.getStackVar(sttop), new OrExpression(ctxt.getStackVar(sttop), this.right)) );
return this.left[Cs](follows, ctxt, sttop);
} else {
return Expression.prototype[Cs].apply(this, arguments);
}
};
ConditionalExpression.prototype[Cs] = function ( follows, ctxt, sttop ) {
if ( this.texp.containsFunctionCall() || this.fexp.containsFunctionCall() ) {
var next_block = follows.car;
follows = cons( ctxt.makeGotoBlock(undefinedExp, next_block), follows );
follows = this.texp[Cs](follows, ctxt, sttop);
var true_block = follows.car;
follows = cons( ctxt.makeGotoBlock(undefinedExp, next_block), follows );
follows = this.fexp[Cs](follows, ctxt, sttop);
follows.car.prependStatement(new IL.CondStatement(ctxt.getStackVar(sttop), true_block));
return this.cond[Cs](follows, ctxt, sttop);
} else if ( this.cond.containsFunctionCall() ) {
follows.car.prependStatement( make_assign(ctxt.getStackVar(sttop), new ConditionalExpression(ctxt.getStackVar(sttop), this.texp, this.fexp)) );
return this.cond[Cs](follows, ctxt, sttop);
} else {
return Expression.prototype[Cs].apply(this, arguments);
}
};
return {
CsConvert: CsConvert
};
}();
}
}
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.CsConvert = CsConvert;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
var IL = IntermediateLanguage;
var Cv = "$Concurrent_Thread_Compiler_CvConvert";
function CvConvert ( func ) {
var vars = new IdentifierSet()
function add_vars ( /* variable arguments */ ) {
return vars.add.apply(vars, arguments);
}
var decls = cons(null, nil());
var add_decls = adder(decls);
for ( var c=func.body; !c.isNil(); c=c.cdr ) {
c.car = c.car[Cv](add_vars, add_decls);
}
return new IL.Function(func.name, func.params, vars.toArray(), concat(decls, func.body).cdr);
}
Statement.prototype[Cv] = function ( add_vars, add_decls ) {
return this;
};
Block.prototype[Cv] = function ( add_vars, add_decls ) {
for ( var c=this.body; !c.isNil(); c=c.cdr ) {
c.car = c.car[Cv](add_vars, add_decls);
}
return this;
};
VarStatement.prototype[Cv] = function ( add_vars, add_decls ) {
var assigns = [];
for ( var i=0; i < this.decls.length; i++ ) {
add_vars(this.decls[i].id);
if ( this.decls[i].exp ) {
assigns.push( new SimpleAssignExpression(this.decls[i].id, this.decls[i].exp) );
}
}
if ( !assigns.length ) {
return new EmptyStatement([], this.lineno, this.source);
} else {
var exp = assigns[0];
for ( var i=1; i < assigns.length; i++ ) {
exp = new CommaExpression(exp, assigns[i]);
}
return new ExpStatement([], exp, this.lineno, this.source);
}
};
IfStatement.prototype[Cv] = function ( add_vars, add_decls ) {
this.body = this.body[Cv](add_vars, add_decls);
return this;
};
IfElseStatement.prototype[Cv] = function ( add_vars, add_decls ) {
this.tbody = this.tbody[Cv](add_vars, add_decls);
this.fbody = this.fbody[Cv](add_vars, add_decls);
return this;
};
DoWhileStatement.prototype[Cv] = IfStatement.prototype[Cv];
WhileStatement.prototype[Cv] = IfStatement.prototype[Cv];
ForStatement.prototype[Cv] = IfStatement.prototype[Cv];
ForVarStatement.prototype[Cv] = function ( add_vars, add_decls ) {
var init = (new VarStatement([], this.decls))[Cv](add_vars, add_decls);
if ( init instanceof EmptyStatement ) {
init = null;
} else {
init = init.exp;
}
return new ForStatement(this.labels, init, this.cond, this.incr, this.body[Cv](add_vars, add_decls), this.lineno, this.source);
};
ForInStatement.prototype[Cv] = IfStatement.prototype[Cv];
ForInVarStatement.prototype[Cv] = function ( add_vars, add_decls ) {
add_vars(this.decl.id);
var for_in = new ForInStatement(this.labels, this.decl.id, this.exp, this.body[Cv](add_vars, add_decls), this.lineno, this.source);
if ( this.decl.exp ) {
return new Block([], list(
new ExpStatement([], new SimpleAssignExpression(this.decl.id, this.decl.exp), this.lineno, this.source),
for_in
), this.lineno, this.source);
} else {
return for_in;
}
};
ForEachStatement.prototype[Cv] = IfStatement.prototype[Cv];
ForEachVarStatement.prototype[Cv] = ForInVarStatement.prototype[Cv];
WithStatement.prototype[Cv] = IfStatement.prototype[Cv];
SwitchStatement.prototype[Cv] = function ( add_vars, add_decls ) {
for ( var c=this.clauses; !c.isNil(); c=c.cdr ) {
c.car = c.car[Cv](add_vars, add_decls);
}
return this;
};
CaseClause.prototype[Cv] = Block.prototype[Cv];
DefaultClause.prototype[Cv] = Block.prototype[Cv];
TryCatchStatement.prototype[Cv] = function ( add_vars, add_decls ) {
add_vars(this.variable);
this.tryBlock = this.tryBlock[Cv](add_vars, add_decls);
this.catchBlock = this.catchBlock[Cv](add_vars, add_decls);
return this;
};
TryFinallyStatement.prototype[Cv] = function ( add_vars, add_decls ) {
this.tryBlock = this.tryBlock[Cv](add_vars, add_decls);
this.finallyBlock = this.finallyBlock[Cv](add_vars, add_decls);
return this;
};
TryCatchFinallyStatement.prototype[Cv] = function ( add_vars, add_decls ) {
add_vars(this.variable);
this.tryBlock = this.tryBlock[Cv](add_vars, add_decls);
this.catchBlock = this.catchBlock[Cv](add_vars, add_decls);
this.finallyBlock = this.finallyBlock[Cv](add_vars, add_decls);
return this;
};
FunctionDeclaration.prototype[Cv] = function ( add_vars, add_decls ) {
add_vars(this.name);
add_decls( new ExpStatement(
[],
new SimpleAssignExpression(
this.name,
new FunctionExpression(null, this.params, this.body)
),
this.lineno,
this.source
));
return new EmptyStatement([]);
};
return {
CvConvert: CvConvert
};
}();
}
}
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.CvConvert = CvConvert;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
var IL = Concurrent.Thread.Compiler.IntermediateLanguage;
var Cz = "$Concurrent_Thread_Compiler_CzConvert";
var PREFIX = "$Concurrent_Thread_";
var var_this = new Identifier(PREFIX+"this");
var var_args = new Identifier(PREFIX+"arguments");
var var_cont = new Identifier(PREFIX+"continuation");
var var_self = new Identifier(PREFIX+"self");
var var_compiled = new Identifier(PREFIX+"compiled");
var var_intermediate = new Identifier(PREFIX+"intermediate");
var name_arguments = new Identifier("arguments");
var name_prototype = new Identifier("prototype");
var name_apply = new Identifier("apply");
var name_procedure = new Identifier("procedure");
var name_this_val = new Identifier("this_val");
var name_exception = new Identifier("exception");
var var_null_function = new Identifier(PREFIX+"null_function");
var null_function = new FunctionDeclaration([], var_null_function, [], nil());
function CzConvert ( func ) {
var body = inner_function(func);
return new FunctionExpression(
null,
[var_this, var_args, var_cont],
list(
new ReturnStatement([],
new CallExpression(
new DotAccessor(body, name_apply),
[var_this, var_args]
)
)
)
);
}
var arguments_callee = new DotAccessor(name_arguments, new Identifier("callee"));
function inner_function ( func ) {
var blocks = func.body.map(function(it){ return it[Cz](); });
blocks = cons( var_declaration(func.vars),
cons( null_function,
cons( make_assign(var_args, name_arguments),
cons( make_assign(arguments_callee, var_self),
blocks ) ) ) );
adder(blocks)( make_return(func.start) );
return new FunctionExpression(null, func.params, blocks);
}
function var_declaration ( vars ) {
if ( !vars.length ) return new EmptyStatement([]);
var decls = [];
vars.forEach(function( it ){
decls.push({ id:it, exp:null });
});
return new VarStatement([], decls);
}
function make_assign ( lhs, rhs ) {
return new ExpStatement( [], new SimpleAssignExpression(lhs, rhs) );
}
var var_cont_ex = new DotAccessor(var_cont, name_exception);
function target_to_name ( b ) {
if ( b instanceof IL.Block ) {
return new Identifier(PREFIX + b.id);
} else if ( b === "return" ) {
return var_cont;
} else if ( b === "throw" ) {
return var_cont_ex;
} else {
Kit.codeBug("invalid target");
}
}
var undefinedExp = new VoidExpression(new Literal(0));
var name_continuation = new Identifier("continuation");
var name_timeout = new Identifier("timeout");
var name_ret_val = new Identifier("ret_val");
function make_return ( continuation, ret_val ) {
return new ReturnStatement([], new ObjectInitializer([
{ prop: name_continuation, exp: target_to_name(continuation) },
{ prop: name_ret_val , exp: ret_val || undefinedExp },
{ prop: name_timeout , exp: undefinedExp }
]) );
}
var assign_arguments = make_assign(name_arguments, var_args);
function make_continuation ( block, body ) {
body = new Block([], body);
for ( var i=block.scopes.length-1; i >= 0; i-- ) {
body = new WithStatement([], block.scopes[i], body);
}
return new VarStatement([], [{
id : target_to_name(block),
exp: new ObjectInitializer([
{prop: name_procedure, exp: new FunctionExpression(null, [var_intermediate], list(assign_arguments, body))},
{prop: name_this_val , exp: new ThisExpression() },
{prop: name_exception, exp: target_to_name(block.exception) }
])
}]);
}
IL.GotoBlock.prototype[Cz] = function ( ) {
var body = this.body.map(function( it ) {
return it[Cz]();
});
body = cons(null, body);
adder(body)( make_return(this.target, this.arg) );
return make_continuation(this, body.cdr);
};
var string_object = new StringLiteral(‘"object"‘);
var string_function = new StringLiteral(‘"function"‘);
IL.CallBlock.prototype[Cz] = function ( ) {
var body = this.body.map(function( it ) {
return it[Cz]();
});
body = cons(null, body);
adder(body)( new IfElseStatement([],
new AndExpression(
this.func,
new StrictEqualExpression(
new TypeofExpression(
new DotAccessor(this.func, var_compiled)
),
string_function
)
),
new ReturnStatement([],
new CallExpression(
new DotAccessor(this.func, var_compiled),
[
this.this_val,
new ArrayInitializer(this.args),
target_to_name(this.target)
]
)
),
make_return(
this.target,
new CallExpression(this.func, this.args)
)
) );
return make_continuation(this, body.cdr);
};
IL.NewBlock.prototype[Cz] = function ( ) {
var body = this.body.map(function( it ) {
return it[Cz]();
});
body = cons(null, body);
/* // Construct the following code-tree.
if ( CONSTRUCTOR && typeof CONSTRUCTOR.$Concurrent_Thread_compiled == "function" ) {
$Concurrent_Thread_null_function.prototype = CONSTRUCTOR.prototype;
$Concurrent_Thread_this = new $Concurrent_Thread_null_function();
return CONSTRUCTOR.$Concurrent_Thread_compiled(
$Concurrent_Thread_this,
[ARG1, ARG2, ...],
{ procedure: function($Concurrent_Thread_intermediate){
if ( !($Concurrent_Thread_intermediate && (typeof $Concurrent_Thread_intermediate === "object" || typeof $Concurrent_Thread_intermediate === "function") )
$Concurrent_Thread_intermediate = $Concurrent_Thread_this;
$Concurrent_Thread_this = null; // encourages GC
return { continuation: CONTINUATION,
ret_val : $Concurrent_Thread_intermediate,
timeout : void 0 };
}, this_val: this, exception: EXCEPTION }
);
} else {
return { continuation: CONTINUATION,
ret_val : new CONSTRUCTOR(ARG1, ARG2...),
timeout : void 0
};
}
*/
adder(body)( new IfElseStatement([],
new AndExpression(
this.func,
new StrictEqualExpression(
new TypeofExpression(
new DotAccessor(this.func, var_compiled)
),
string_function
)
),
new Block([],
list(
make_assign( new DotAccessor(var_null_function, name_prototype),
new DotAccessor(this.func , name_prototype) ),
make_assign( var_this, new NewExpression(var_null_function, []) ),
new ReturnStatement([],
new CallExpression(
new DotAccessor(this.func, var_compiled),
[
var_this,
new ArrayInitializer(this.args),
new ObjectInitializer([
{prop: name_procedure, exp: new FunctionExpression(null, [var_intermediate], list(
new IfStatement([],
new NotExpression(
new AndExpression(
var_intermediate,
new OrExpression(
new StrictEqualExpression(new TypeofExpression(var_intermediate), string_object),
new StrictEqualExpression(new TypeofExpression(var_intermediate), string_function)
)
)
),
make_assign(var_intermediate, var_this)
),
make_assign(var_this, new NullLiteral()),
make_return(this.target, var_intermediate)
))},
{prop: name_this_val , exp: new ThisExpression()},
{prop: name_exception, exp: target_to_name(this.exception)}
])
]
)
)
)
),
make_return(this.target, new NewExpression(this.func, this.args))
) );
return make_continuation(this, body.cdr);
};
IL.ExpStatement.prototype[Cz] = function ( ) {
return new ExpStatement([], this.exp);
};
IL.CondStatement.prototype[Cz] = function ( ) {
return new IfStatement([], this.cond, make_return(this.target));
};
IL.RecvStatement.prototype[Cz] = function ( ) {
return make_assign(this.assignee, var_intermediate);
};
var name_push = new Identifier("push");
IL.EnumStatement.prototype[Cz] = function ( ) {
return new Block([], list(
make_assign(var_this, new ArrayInitializer([])),
new ForInStatement([], var_intermediate, this.exp,
new ExpStatement([],
new CallExpression(
new DotAccessor(var_this, name_push),
[var_intermediate]
)
)
),
make_assign(this.assignee, var_this),
make_assign(var_this, new NullLiteral())
));
};
return {
CzConvert: CzConvert
};
}();
}
}
}
}.call(null) ) {
this.Concurrent.Thread.Compiler.CzConvert = CzConvert;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread code.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2006-2007
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread‘;
var IL = Concurrent.Thread.Compiler.IntermediateLanguage;
var PREFIX = "$Concurrent_Thread_";
var var_self = new Identifier(PREFIX + "self");
var var_compiled = new Identifier(PREFIX + "compiled");
function compile ( f ) {
return eval(prepare(f));
}
CACHE_LIMIT = 50;
var prepare_cache = {};
var cache_history = [];
function prepare ( f ) {
if ( typeof f != "function" ) throw new TypeError("argument must be a function");
f = f.toString();
var c = prepare_cache[f];
if ( c ) return c;
c = prepareTree(parseFunction(f)).toString();
while ( cache_history.length >= CACHE_LIMIT && cache_history.length > 0 ) { // avoid endless loop
delete prepare_cache[cache_history.shift()];
}
if ( CACHE_LIMIT >= 1 ) {
prepare_cache[f] = c;
cache_history.push(f);
}
return c;
}
function parseFunction ( f ) {
var stmts = (new Parser()).parse("(" + f + ");");
if ( !(stmts.car instanceof ExpStatement) ) throw new Error("not exp-statement!");
if ( !(stmts.car.exp instanceof FunctionExpression) ) throw new Error("not function-expression!");
return stmts.car.exp;
}
function prepareTree ( f ) {
if ( !(f instanceof FunctionExpression) ) Kit.codeBug("not FunctionalExpression");
var name = f.name;
f.name = null;
var g = CssConvert(f);
g = CvConvert(g);
g = CsConvert(g);
g = CfConvert(g);
g = CzConvert(g);
return new CallExpression(
new FunctionExpression(null, [], list(
new VarStatement([], [{id:var_self, exp:f}]),
name ? new VarStatement([], [{id:name, exp:var_self}]) : new EmptyStatement([]),
new ExpStatement([], new SimpleAssignExpression(new DotAccessor(var_self, var_compiled), g)),
new ReturnStatement([], var_self)
)),
[]
);
/* Constructs the following structure:
"(function(){",
" var $Concurrent_Thread_self = ", f, ";",
name ? "var " + name + " = " + "$Concurrent_Thread_self;" : "",
" $Concurrent_Thread_self.$Concurrent_Thread_compiled = ", func, ";",
" return $Concurrent_Thread_self;",
"})()"
*/
}
return {
compile: compile, prepareTree: prepareTree, prepare: prepare
};
}();
}
}
}
}.call(null) ) {
this.Concurrent.Thread.compile = compile;
this.Concurrent.Thread.prepareTree = prepareTree;
this.Concurrent.Thread.prepare = prepare;
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Compiler || (typeof this.Concurrent.Thread.Compiler != ‘object‘ && typeof this.Concurrent.Thread.Compiler != ‘function‘) ) this.Concurrent.Thread.Compiler = new Object();
with ( function(){
with ( Concurrent.Thread.Compiler ) {
return function () {
var VERSION ;
var NAMESPACE;
NAMESPACE = ‘Concurrent.Thread.Compiler‘;
WebBrowser.ScriptExecuter.register("text/x-script.multithreaded-js", function ( src ){
eval(compile(src)).async(null);
});
function compile ( src ) {
var prog = (new Parser).parse(src);
prog = new FunctionExpression(null, [], prog);
prog = CssConvert(prog);
prog = CvConvert(prog);
prog = CsConvert(prog);
prog = CfConvert(prog);
prog.vars.forEach(function( it ){
// Incredibly, window does not have hasOwnProperty method on IE!!
if ( !Object.prototype.hasOwnProperty.call(window, it) ) window[it] = undefined;
});
prog.vars = [];
prog = CzConvert(prog);
return [
"1, function(){",
" var $Concurrent_Thread_self = function(){};",
" $Concurrent_Thread_self.$Concurrent_Thread_compiled = ", prog, ";",
" return $Concurrent_Thread_self;",
"}()"
].join("");
}
return {
};
}();
}
}.call(null) ) {
}
}).call(null);
(function(){
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Continuation || (typeof this.Concurrent.Thread.Continuation != ‘object‘ && typeof this.Concurrent.Thread.Continuation != ‘function‘) ) this.Concurrent.Thread.Continuation = new Object();
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( this.Concurrent.Thread.Generator === undefined ) this.Concurrent.Thread.Generator = undefined;
with ( function(){
with ( Concurrent.Thread.Continuation ) {
with ( Concurrent ) {
with ( Concurrent.Thread ) {
return function () {
var VERSION = ‘0.0.0‘;
var NAMESPACE;
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Concurrent.Thread.Generator module.
*
* The Initial Developer of the Original Code is
* Daisuke Maki.
* Portions created by the Initial Developer are Copyright (C) 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
NAMESPACE = ‘Concurrent.Thread‘;
function Generator ( f ) {
if ( typeof f != "function" ) throw new TypeError("not a function");
if ( typeof f.$Concurrent_Thread_compiled != "function" ) f = Thread.compile(f);
this._mutex = new Mutex();
this._cont_caller = null;
this._buf = null;
this._got = false;
var self = this;
var generate = eval(Thread.prepare(function( x ){
self._buf = x;
self._got = true;
try {
self._cont_iter = currentContinuation();
self._cont_caller();
} catch ( e ) {
self._cont_iter = null;
if ( e instanceof ContinuationCalledException ) {
return; // resume iteration
} else {
throw e;
}
}
// execution never reaches here
}));
this._cont_iter = eval(Thread.prepare(function(){
f(generate);
self._got = false;
self._cont_iter = null; // null means that the iteration function has finished
self._cont_caller();
}));
}
var proto = Generator.prototype;
proto.hasNext = function ( ) {
// This definition is called when generator is used in non-converted context.
// The implementation is quite tricky and strongly dependent on the internal
// implementation of Concurrent.Thread.
if ( !this._mutex.isAcquirable() ) this._mutex.acquire(); // must throw an error
if ( this._got ) return true;
if ( !this._cont_iter ) return false;
var is_called = false;
this._cont_caller = eval(Thread.prepare(function(){
is_called = true;
Thread.stop();
}));
var triplet = Thread.create(this._cont_iter)._triplet;
triplet.timeout = void 0;
while ( 1 ) {
while ( triplet.timeout === void 0 ) {
try {
triplet = triplet.continuation.procedure.call(
triplet.continuation.this_val, triplet.ret_val
);
} catch ( e ) {
if ( e instanceof NoContinuationException ) {
return this._got;
} else if ( e instanceof NoExceptionHandlerException ) {
throw e.thrown;
} else {
triplet.continuation = triplet.continuation.exception;
triplet.ret_val = e;
}
}
}
if ( is_called ) {
break;
} else {
triplet.continuation = triplet.continuation.exception;
triplet.ret_val = new Error("can‘t suspend in non-converted context");
}
}
this._cont_caller = null;
return this._got;
};
proto.hasNext.$Concurrent_Thread_compiled = eval(Thread.prepare(
function ( ) {
this._mutex.acquire();
try {
if ( this._got ) return true;
if ( !this._cont_iter ) return false;
try {
this._cont_caller = currentContinuation();
this._cont_iter();
} catch ( e ) {
this._cont_caller = null;
if ( e instanceof ContinuationCalledException ) {
return this._got;
} else {
throw e;
}
}
} finally {
this._mutex.release();
}
// execution never reaches here
}
)).$Concurrent_Thread_compiled;
proto.next = eval(Thread.prepare(
function ( ) {
if ( this.hasNext() ) {
var x = this._buf;
this._buf = void 0;
this._got = false;
return x;
} else {
return void 0;
}
}
));
return {
Generator: Generator
};
}();
}
}
}
}.call(null) ) {
this.Concurrent.Thread.Generator = Generator;
}
}).call(null);
(function(){
if ( !this.Data || (typeof this.Data != ‘object‘ && typeof this.Data != ‘function‘) ) this.Data = http://www.mamicode.com/new Object();"argument for " + NAMESPACE + ".bind must be a hash.");
var request = opts.request;
if ( request != null ) {
if ( !String(request).match(/^(?:GET|POST)$/i) ) throw new Error(‘"request" option must be "GET" or "POST".‘);
} else {
request = "POST";
}
var params = opts.params;
if ( params != null ) {
if ( !String(params).match(/^(?:Named|Positioned)$/i) ) throw new Error(‘"params" option must be "Named" or "Positioned".‘);
} else {
params = "Named";
}
var body;
if ( request.match(/^POST$/i) ) {
if ( params.match(/^Named$/i) ) {
body = makeNamedPost(opts.url, opts.method);
} else {
body = makePositionedPost(opts.url, opts.method);
}
} else {
if ( params.match(/^Named$/i) ) {
body = makeNamedGet(opts.url, opts.method);
} else {
body = makePositionedGet(opts.url, opts.method);
}
}
var with_pre;
var pre = opts.preprocess;
if ( pre != null ) {
if ( typeof pre != "function" ) throw new TypeError(‘"preprocess" option must be function‘);
with_pre = eval(Thread.prepare(function(){
return body.apply(this, pre.apply(this, arguments));
}));
} else {
with_pre = body;
}
var post = opts.postprocess;
if ( post != null ) {
if ( typeof post != "function" ) throw new TypeError(‘"preprocess" option must be function‘);
return eval(Thread.prepare(function(){
return post(with_pre.apply(this, arguments));
}));
} else {
return with_pre;
}
}
var COMMON_HEADERS = [
‘User-Agent‘ , ‘Concurrent.Thread.JSON.RPC‘,
‘Accept‘ , ‘application/json‘
];
var POST_HEADERS = COMMON_HEADERS.concat(
‘Content-type‘, ‘application/json‘
);
function makeNamedPost( url, method ) {
return eval(Thread.prepare(
function ( /* variable arguments */ ) {
var res = Thread.Http.post(url, dump({
version: "1.1",
method : method,
params : args2params(arguments)
}), POST_HEADERS);
res = eval("(" + res.responseText + ")");
if ( res.error ) throw new JSONRPCError(res.error);
return res.result;
}
));
};
function makePositionedPost ( url, method ) {
return eval(Thread.prepare(
function ( /* variable arguments */ ) {
var res = Thread.Http.post(url, dump({
version: "1.1",
method : method,
params : arrayize(arguments)
}), POST_HEADERS);
res = eval("(" + res.responseText + ")");
if ( res.error ) throw new JSONRPCError(res.error);
return res.result;
}
));
};
function makeNamedGet ( url, method ) {
url = url.replace(/\/+$/, "") + "/" + encodeURIComponent(method) + "?";
return eval(Thread.prepare(
function ( /* variable arguments */ ) {
var res = Thread.Http.get(url + params2query(args2params(arguments)), COMMON_HEADERS);
res = eval("(" + res.responseText + ")");
if ( res.error ) throw new JSONRPCError(res.error);
return res.result;
}
));
};
function makePositionedGet ( url, method ) {
url = url.replace(/\/+$/, "") + "/" + encodeURIComponent(method) + "?";
return eval(Thread.prepare(
function ( /* variable arguments */ ) {
arguments[arguments.length] = {};
arguments.length++;
var res = Thread.Http.get(url + params2query(args2params(arguments)), COMMON_HEADERS);
res = eval("(" + res.responseText + ")");
if ( res.error ) throw new JSONRPCError(res.error);
return res.result;
}
));
};
function args2params ( args ) {
var params = {};
if ( args.length ) {
var hash = args[args.length-1];
if ( !(hash instanceof Object) ) throw new Error("the last argument must be a hash");
for ( var i in hash ) {
if ( hash.hasOwnProperty(i) ) params[i] = hash[i];
}
for ( var i=0; i < args.length-1; i++ ) {
params[i] = args[i];
}
}
return params;
}
function params2query ( params ) {
var query = [];
for ( var i in params ) {
if ( !params.hasOwnProperty(i) ) continue;
if ( params[i] instanceof Array ) {
var arr = params[i];
for ( var j=0; j < arr.length; j++ ) {
query.push(encodeURIComponent(i) + "=" + encodeURIComponent(arr[j]));
}
} else {
query.push(encodeURIComponent(i) + "=" + encodeURIComponent(params[i]));
}
}
return query.join("&");
}
var JSONRPCError = Error.extend(
function ( $super, e ) {
if ( e instanceof Object ) {
$super(e.message);
for ( var i in e ) this[i] = e[i];
} else {
$super(e);
}
},
{name: NAMESPACE + ".JSONRPCError"}
);
return {
JSONRPCError: JSONRPCError, bind: bind
};
}();
}
}
}
}
}
}.call(null) ) {
this.Concurrent.Thread.JSON.RPC.JSONRPCError = JSONRPCError;
this.Concurrent.Thread.JSON.RPC.bind = bind;
}
}).call(null);
(function(){
if ( !this.WebBrowser || (typeof this.WebBrowser != ‘object‘ && typeof this.WebBrowser != ‘function‘) ) this.WebBrowser = new Object();
if ( !this.WebBrowser.GUI || (typeof this.WebBrowser.GUI != ‘object‘ && typeof this.WebBrowser.GUI != ‘function‘) ) this.WebBrowser.GUI = new Object();
if ( !this.WebBrowser.GUI.Event || (typeof this.WebBrowser.GUI.Event != ‘object‘ && typeof this.WebBrowser.GUI.Event != ‘function‘) ) this.WebBrowser.GUI.Event = new Object();
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent || (typeof this.Concurrent != ‘object‘ && typeof this.Concurrent != ‘function‘) ) this.Concurrent = new Object();
if ( !this.Concurrent.Thread || (typeof this.Concurrent.Thread != ‘object‘ && typeof this.Concurrent.Thread != ‘function‘) ) this.Concurrent.Thread = new Object();
if ( !this.Concurrent.Thread.Event || (typeof this.Concurrent.Thread.Event != ‘object‘ && typeof this.Concurrent.Thread.Event != ‘function‘) ) this.Concurrent.Thread.Event = new Object();
if ( !this.Util || (typeof this.Util != ‘object‘ && typeof this.Util != ‘function‘) ) this.Util = new Object();
if ( !this.Util.Arrayize || (typeof this.Util.Arrayize != ‘object‘ && typeof this.Util.Arrayize != ‘function‘) ) this.Util.Arrayize = new Object();
if ( this.Concurrent.Thread.Event.waitFor === undefined ) this.Concurrent.Thread.Event.waitFor = undefined;
if ( this.Concurrent.Thread.Event.select === undefined ) this.Concurrent.Thread.Event.select = undefined;
with ( function(){
with ( Util.Arrayize ) {
with ( WebBrowser.GUI.Event ) {
with ( Concurrent ) {
with ( Concurrent.Thread.Event ) {
return function () {
var VERSION = ‘0.0.0‘;
var NAMESPACE;
NAMESPACE = ‘Concurrent.Thread.Event‘;
var waitFor = eval(Concurrent.Thread.prepare(
function waitFor ( target, type, options ) {
var arg = {};
for ( var i in options ) arg[i] = options[i];
arg.target = target;
arg.type = type;
return select(arg);
}
));
var select = eval(Concurrent.Thread.prepare(
function select ( /* variable args */ ) {
try {
var signal = {};
set_handlers(arrayize(arguments), signal);
Concurrent.Thread.stop();
} catch ( e ) {
if ( e === signal ) {
return signal.event;
} else {
throw e;
}
}
}
));
function set_handlers ( args, signal ) {
var self = Concurrent.Thread.self();
args = args.map(function( arg ){
if ( !arg.target || typeof arg.target !== "object" ) {
throw new TypeError("not a object: " + target);
}
return {
target : arg.target,
type : String(arg.type),
useCapture : Boolean(arg.useCapture),
preventDefault : Boolean(arg.preventDefault),
stopPropagation: Boolean(arg.stopPropagation)
};
});
var lsn_ids = args.map(function( arg ){
function handler ( e ) {
if ( arg.preventDefault ) e.preventDefault();
if ( arg.stopPropagation ) e.stopPropagation();
lsn_ids.forEach(function( id ){
detach(id);
});
// IE invalidates event properties after leaving the event handler.
// So, we pass a copy of the current event object (but DO NOT copy its methods).
var evt = {};
for ( var i in e ) {
if ( typeof e[i] !== "function" ) evt[i] = e[i];
}
signal.event = evt;
self.notify(signal);
}
return attach(arg.target, arg.type, handler, arg.useCapture);
});
}
return {
waitFor: waitFor, select: select
};
}();
}
}
}
}
}.call(null) ) {
this.Concurrent.Thread.Event.waitFor = waitFor;
this.Concurrent.Thread.Event.select = select;
}
}).call(null);
Concurrent.Thread.js
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。