43034 lines
1.4 MiB
43034 lines
1.4 MiB
<!DOCTYPE html>
|
|
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
|
|
<head>
|
|
<meta charset="utf-8"/>
|
|
<title>Rain</title>
|
|
</head>
|
|
<script>
|
|
<![CDATA[(function(window, undefined) {
|
|
// dyoo: this library has been modified slightly so it checks to see
|
|
// if window.jQuery has already been installed. This is to prevent an ugly issue
|
|
// with regards to a memory leak if one tries to repeatedly load jQuery.
|
|
// NOTE: this portion of the file (jquery-protect-header.js) is intentionally
|
|
// unbalanced. It'll be closed up by jquery-protect-footer.js.
|
|
if (!window.jQuery) {
|
|
/*!
|
|
* jQuery JavaScript Library v1.6.2
|
|
* http://jquery.com/
|
|
*
|
|
* Copyright 2011, John Resig
|
|
* Dual licensed under the MIT or GPL Version 2 licenses.
|
|
* http://jquery.org/license
|
|
*
|
|
* Includes Sizzle.js
|
|
* http://sizzlejs.com/
|
|
* Copyright 2011, The Dojo Foundation
|
|
* Released under the MIT, BSD, and GPL Licenses.
|
|
*
|
|
* Date: Thu Jun 30 14:16:56 2011 -0400
|
|
*/
|
|
(function( window, undefined ) {
|
|
|
|
// Use the correct document accordingly with window argument (sandbox)
|
|
var document = window.document,
|
|
navigator = window.navigator,
|
|
location = window.location;
|
|
var jQuery = (function() {
|
|
|
|
// Define a local copy of jQuery
|
|
var jQuery = function( selector, context ) {
|
|
// The jQuery object is actually just the init constructor 'enhanced'
|
|
return new jQuery.fn.init( selector, context, rootjQuery );
|
|
},
|
|
|
|
// Map over jQuery in case of overwrite
|
|
_jQuery = window.jQuery,
|
|
|
|
// Map over the $ in case of overwrite
|
|
_$ = window.$,
|
|
|
|
// A central reference to the root jQuery(document)
|
|
rootjQuery,
|
|
|
|
// A simple way to check for HTML strings or ID strings
|
|
// (both of which we optimize for)
|
|
quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
|
|
|
|
// Check if a string has a non-whitespace character in it
|
|
rnotwhite = /\S/,
|
|
|
|
// Used for trimming whitespace
|
|
trimLeft = /^\s+/,
|
|
trimRight = /\s+$/,
|
|
|
|
// Check for digits
|
|
rdigit = /\d/,
|
|
|
|
// Match a standalone tag
|
|
rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
|
|
|
|
// JSON RegExp
|
|
rvalidchars = /^[\],:{}\s]*$/,
|
|
rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
|
|
rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
|
|
rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
|
|
|
|
// Useragent RegExp
|
|
rwebkit = /(webkit)[ \/]([\w.]+)/,
|
|
ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
|
|
rmsie = /(msie) ([\w.]+)/,
|
|
rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
|
|
|
|
// Matches dashed string for camelizing
|
|
rdashAlpha = /-([a-z])/ig,
|
|
|
|
// Used by jQuery.camelCase as callback to replace()
|
|
fcamelCase = function( all, letter ) {
|
|
return letter.toUpperCase();
|
|
},
|
|
|
|
// Keep a UserAgent string for use with jQuery.browser
|
|
userAgent = navigator.userAgent,
|
|
|
|
// For matching the engine and version of the browser
|
|
browserMatch,
|
|
|
|
// The deferred used on DOM ready
|
|
readyList,
|
|
|
|
// The ready event handler
|
|
DOMContentLoaded,
|
|
|
|
// Save a reference to some core methods
|
|
toString = Object.prototype.toString,
|
|
hasOwn = Object.prototype.hasOwnProperty,
|
|
push = Array.prototype.push,
|
|
slice = Array.prototype.slice,
|
|
trim = String.prototype.trim,
|
|
indexOf = Array.prototype.indexOf,
|
|
|
|
// [[Class]] -> type pairs
|
|
class2type = {};
|
|
|
|
jQuery.fn = jQuery.prototype = {
|
|
constructor: jQuery,
|
|
init: function( selector, context, rootjQuery ) {
|
|
var match, elem, ret, doc;
|
|
|
|
// Handle $(""), $(null), or $(undefined)
|
|
if ( !selector ) {
|
|
return this;
|
|
}
|
|
|
|
// Handle $(DOMElement)
|
|
if ( selector.nodeType ) {
|
|
this.context = this[0] = selector;
|
|
this.length = 1;
|
|
return this;
|
|
}
|
|
|
|
// The body element only exists once, optimize finding it
|
|
if ( selector === "body" && !context && document.body ) {
|
|
this.context = document;
|
|
this[0] = document.body;
|
|
this.selector = selector;
|
|
this.length = 1;
|
|
return this;
|
|
}
|
|
|
|
// Handle HTML strings
|
|
if ( typeof selector === "string" ) {
|
|
// Are we dealing with HTML string or an ID?
|
|
if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
|
|
// Assume that strings that start and end with <> are HTML and skip the regex check
|
|
match = [ null, selector, null ];
|
|
|
|
} else {
|
|
match = quickExpr.exec( selector );
|
|
}
|
|
|
|
// Verify a match, and that no context was specified for #id
|
|
if ( match && (match[1] || !context) ) {
|
|
|
|
// HANDLE: $(html) -> $(array)
|
|
if ( match[1] ) {
|
|
context = context instanceof jQuery ? context[0] : context;
|
|
doc = (context ? context.ownerDocument || context : document);
|
|
|
|
// If a single string is passed in and it's a single tag
|
|
// just do a createElement and skip the rest
|
|
ret = rsingleTag.exec( selector );
|
|
|
|
if ( ret ) {
|
|
if ( jQuery.isPlainObject( context ) ) {
|
|
selector = [ document.createElement( ret[1] ) ];
|
|
jQuery.fn.attr.call( selector, context, true );
|
|
|
|
} else {
|
|
selector = [ doc.createElement( ret[1] ) ];
|
|
}
|
|
|
|
} else {
|
|
ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
|
|
selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
|
|
}
|
|
|
|
return jQuery.merge( this, selector );
|
|
|
|
// HANDLE: $("#id")
|
|
} else {
|
|
elem = document.getElementById( match[2] );
|
|
|
|
// Check parentNode to catch when Blackberry 4.6 returns
|
|
// nodes that are no longer in the document #6963
|
|
if ( elem && elem.parentNode ) {
|
|
// Handle the case where IE and Opera return items
|
|
// by name instead of ID
|
|
if ( elem.id !== match[2] ) {
|
|
return rootjQuery.find( selector );
|
|
}
|
|
|
|
// Otherwise, we inject the element directly into the jQuery object
|
|
this.length = 1;
|
|
this[0] = elem;
|
|
}
|
|
|
|
this.context = document;
|
|
this.selector = selector;
|
|
return this;
|
|
}
|
|
|
|
// HANDLE: $(expr, $(...))
|
|
} else if ( !context || context.jquery ) {
|
|
return (context || rootjQuery).find( selector );
|
|
|
|
// HANDLE: $(expr, context)
|
|
// (which is just equivalent to: $(context).find(expr)
|
|
} else {
|
|
return this.constructor( context ).find( selector );
|
|
}
|
|
|
|
// HANDLE: $(function)
|
|
// Shortcut for document ready
|
|
} else if ( jQuery.isFunction( selector ) ) {
|
|
return rootjQuery.ready( selector );
|
|
}
|
|
|
|
if (selector.selector !== undefined) {
|
|
this.selector = selector.selector;
|
|
this.context = selector.context;
|
|
}
|
|
|
|
return jQuery.makeArray( selector, this );
|
|
},
|
|
|
|
// Start with an empty selector
|
|
selector: "",
|
|
|
|
// The current version of jQuery being used
|
|
jquery: "1.6.2",
|
|
|
|
// The default length of a jQuery object is 0
|
|
length: 0,
|
|
|
|
// The number of elements contained in the matched element set
|
|
size: function() {
|
|
return this.length;
|
|
},
|
|
|
|
toArray: function() {
|
|
return slice.call( this, 0 );
|
|
},
|
|
|
|
// Get the Nth element in the matched element set OR
|
|
// Get the whole matched element set as a clean array
|
|
get: function( num ) {
|
|
return num == null ?
|
|
|
|
// Return a 'clean' array
|
|
this.toArray() :
|
|
|
|
// Return just the object
|
|
( num < 0 ? this[ this.length + num ] : this[ num ] );
|
|
},
|
|
|
|
// Take an array of elements and push it onto the stack
|
|
// (returning the new matched element set)
|
|
pushStack: function( elems, name, selector ) {
|
|
// Build a new jQuery matched element set
|
|
var ret = this.constructor();
|
|
|
|
if ( jQuery.isArray( elems ) ) {
|
|
push.apply( ret, elems );
|
|
|
|
} else {
|
|
jQuery.merge( ret, elems );
|
|
}
|
|
|
|
// Add the old object onto the stack (as a reference)
|
|
ret.prevObject = this;
|
|
|
|
ret.context = this.context;
|
|
|
|
if ( name === "find" ) {
|
|
ret.selector = this.selector + (this.selector ? " " : "") + selector;
|
|
} else if ( name ) {
|
|
ret.selector = this.selector + "." + name + "(" + selector + ")";
|
|
}
|
|
|
|
// Return the newly-formed element set
|
|
return ret;
|
|
},
|
|
|
|
// Execute a callback for every element in the matched set.
|
|
// (You can seed the arguments with an array of args, but this is
|
|
// only used internally.)
|
|
each: function( callback, args ) {
|
|
return jQuery.each( this, callback, args );
|
|
},
|
|
|
|
ready: function( fn ) {
|
|
// Attach the listeners
|
|
jQuery.bindReady();
|
|
|
|
// Add the callback
|
|
readyList.done( fn );
|
|
|
|
return this;
|
|
},
|
|
|
|
eq: function( i ) {
|
|
return i === -1 ?
|
|
this.slice( i ) :
|
|
this.slice( i, +i + 1 );
|
|
},
|
|
|
|
first: function() {
|
|
return this.eq( 0 );
|
|
},
|
|
|
|
last: function() {
|
|
return this.eq( -1 );
|
|
},
|
|
|
|
slice: function() {
|
|
return this.pushStack( slice.apply( this, arguments ),
|
|
"slice", slice.call(arguments).join(",") );
|
|
},
|
|
|
|
map: function( callback ) {
|
|
return this.pushStack( jQuery.map(this, function( elem, i ) {
|
|
return callback.call( elem, i, elem );
|
|
}));
|
|
},
|
|
|
|
end: function() {
|
|
return this.prevObject || this.constructor(null);
|
|
},
|
|
|
|
// For internal use only.
|
|
// Behaves like an Array's method, not like a jQuery method.
|
|
push: push,
|
|
sort: [].sort,
|
|
splice: [].splice
|
|
};
|
|
|
|
// Give the init function the jQuery prototype for later instantiation
|
|
jQuery.fn.init.prototype = jQuery.fn;
|
|
|
|
jQuery.extend = jQuery.fn.extend = function() {
|
|
var options, name, src, copy, copyIsArray, clone,
|
|
target = arguments[0] || {},
|
|
i = 1,
|
|
length = arguments.length,
|
|
deep = false;
|
|
|
|
// Handle a deep copy situation
|
|
if ( typeof target === "boolean" ) {
|
|
deep = target;
|
|
target = arguments[1] || {};
|
|
// skip the boolean and the target
|
|
i = 2;
|
|
}
|
|
|
|
// Handle case when target is a string or something (possible in deep copy)
|
|
if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
|
|
target = {};
|
|
}
|
|
|
|
// extend jQuery itself if only one argument is passed
|
|
if ( length === i ) {
|
|
target = this;
|
|
--i;
|
|
}
|
|
|
|
for ( ; i < length; i++ ) {
|
|
// Only deal with non-null/undefined values
|
|
if ( (options = arguments[ i ]) != null ) {
|
|
// Extend the base object
|
|
for ( name in options ) {
|
|
src = target[ name ];
|
|
copy = options[ name ];
|
|
|
|
// Prevent never-ending loop
|
|
if ( target === copy ) {
|
|
continue;
|
|
}
|
|
|
|
// Recurse if we're merging plain objects or arrays
|
|
if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
|
|
if ( copyIsArray ) {
|
|
copyIsArray = false;
|
|
clone = src && jQuery.isArray(src) ? src : [];
|
|
|
|
} else {
|
|
clone = src && jQuery.isPlainObject(src) ? src : {};
|
|
}
|
|
|
|
// Never move original objects, clone them
|
|
target[ name ] = jQuery.extend( deep, clone, copy );
|
|
|
|
// Don't bring in undefined values
|
|
} else if ( copy !== undefined ) {
|
|
target[ name ] = copy;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Return the modified object
|
|
return target;
|
|
};
|
|
|
|
jQuery.extend({
|
|
noConflict: function( deep ) {
|
|
if ( window.$ === jQuery ) {
|
|
window.$ = _$;
|
|
}
|
|
|
|
if ( deep && window.jQuery === jQuery ) {
|
|
window.jQuery = _jQuery;
|
|
}
|
|
|
|
return jQuery;
|
|
},
|
|
|
|
// Is the DOM ready to be used? Set to true once it occurs.
|
|
isReady: false,
|
|
|
|
// A counter to track how many items to wait for before
|
|
// the ready event fires. See #6781
|
|
readyWait: 1,
|
|
|
|
// Hold (or release) the ready event
|
|
holdReady: function( hold ) {
|
|
if ( hold ) {
|
|
jQuery.readyWait++;
|
|
} else {
|
|
jQuery.ready( true );
|
|
}
|
|
},
|
|
|
|
// Handle when the DOM is ready
|
|
ready: function( wait ) {
|
|
// Either a released hold or an DOMready/load event and not yet ready
|
|
if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
|
|
// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
|
|
if ( !document.body ) {
|
|
return setTimeout( jQuery.ready, 1 );
|
|
}
|
|
|
|
// Remember that the DOM is ready
|
|
jQuery.isReady = true;
|
|
|
|
// If a normal DOM Ready event fired, decrement, and wait if need be
|
|
if ( wait !== true && --jQuery.readyWait > 0 ) {
|
|
return;
|
|
}
|
|
|
|
// If there are functions bound, to execute
|
|
readyList.resolveWith( document, [ jQuery ] );
|
|
|
|
// Trigger any bound ready events
|
|
if ( jQuery.fn.trigger ) {
|
|
jQuery( document ).trigger( "ready" ).unbind( "ready" );
|
|
}
|
|
}
|
|
},
|
|
|
|
bindReady: function() {
|
|
if ( readyList ) {
|
|
return;
|
|
}
|
|
|
|
readyList = jQuery._Deferred();
|
|
|
|
// Catch cases where $(document).ready() is called after the
|
|
// browser event has already occurred.
|
|
if ( document.readyState === "complete" ) {
|
|
// Handle it asynchronously to allow scripts the opportunity to delay ready
|
|
return setTimeout( jQuery.ready, 1 );
|
|
}
|
|
|
|
// Mozilla, Opera and webkit nightlies currently support this event
|
|
if ( document.addEventListener ) {
|
|
// Use the handy event callback
|
|
document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
|
|
|
|
// A fallback to window.onload, that will always work
|
|
window.addEventListener( "load", jQuery.ready, false );
|
|
|
|
// If IE event model is used
|
|
} else if ( document.attachEvent ) {
|
|
// ensure firing before onload,
|
|
// maybe late but safe also for iframes
|
|
document.attachEvent( "onreadystatechange", DOMContentLoaded );
|
|
|
|
// A fallback to window.onload, that will always work
|
|
window.attachEvent( "onload", jQuery.ready );
|
|
|
|
// If IE and not a frame
|
|
// continually check to see if the document is ready
|
|
var toplevel = false;
|
|
|
|
try {
|
|
toplevel = window.frameElement == null;
|
|
} catch(e) {}
|
|
|
|
if ( document.documentElement.doScroll && toplevel ) {
|
|
doScrollCheck();
|
|
}
|
|
}
|
|
},
|
|
|
|
// See test/unit/core.js for details concerning isFunction.
|
|
// Since version 1.3, DOM methods and functions like alert
|
|
// aren't supported. They return false on IE (#2968).
|
|
isFunction: function( obj ) {
|
|
return jQuery.type(obj) === "function";
|
|
},
|
|
|
|
isArray: Array.isArray || function( obj ) {
|
|
return jQuery.type(obj) === "array";
|
|
},
|
|
|
|
// A crude way of determining if an object is a window
|
|
isWindow: function( obj ) {
|
|
return obj && typeof obj === "object" && "setInterval" in obj;
|
|
},
|
|
|
|
isNaN: function( obj ) {
|
|
return obj == null || !rdigit.test( obj ) || isNaN( obj );
|
|
},
|
|
|
|
type: function( obj ) {
|
|
return obj == null ?
|
|
String( obj ) :
|
|
class2type[ toString.call(obj) ] || "object";
|
|
},
|
|
|
|
isPlainObject: function( obj ) {
|
|
// Must be an Object.
|
|
// Because of IE, we also have to check the presence of the constructor property.
|
|
// Make sure that DOM nodes and window objects don't pass through, as well
|
|
if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
|
|
return false;
|
|
}
|
|
|
|
// Not own constructor property must be Object
|
|
if ( obj.constructor &&
|
|
!hasOwn.call(obj, "constructor") &&
|
|
!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
|
|
return false;
|
|
}
|
|
|
|
// Own properties are enumerated firstly, so to speed up,
|
|
// if last one is own, then all properties are own.
|
|
|
|
var key;
|
|
for ( key in obj ) {}
|
|
|
|
return key === undefined || hasOwn.call( obj, key );
|
|
},
|
|
|
|
isEmptyObject: function( obj ) {
|
|
for ( var name in obj ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
},
|
|
|
|
error: function( msg ) {
|
|
throw msg;
|
|
},
|
|
|
|
parseJSON: function( data ) {
|
|
if ( typeof data !== "string" || !data ) {
|
|
return null;
|
|
}
|
|
|
|
// Make sure leading/trailing whitespace is removed (IE can't handle it)
|
|
data = jQuery.trim( data );
|
|
|
|
// Attempt to parse using the native JSON parser first
|
|
if ( window.JSON && window.JSON.parse ) {
|
|
return window.JSON.parse( data );
|
|
}
|
|
|
|
// Make sure the incoming data is actual JSON
|
|
// Logic borrowed from http://json.org/json2.js
|
|
if ( rvalidchars.test( data.replace( rvalidescape, "@" )
|
|
.replace( rvalidtokens, "]" )
|
|
.replace( rvalidbraces, "")) ) {
|
|
|
|
return (new Function( "return " + data ))();
|
|
|
|
}
|
|
jQuery.error( "Invalid JSON: " + data );
|
|
},
|
|
|
|
// Cross-browser xml parsing
|
|
// (xml & tmp used internally)
|
|
parseXML: function( data , xml , tmp ) {
|
|
|
|
if ( window.DOMParser ) { // Standard
|
|
tmp = new DOMParser();
|
|
xml = tmp.parseFromString( data , "text/xml" );
|
|
} else { // IE
|
|
xml = new ActiveXObject( "Microsoft.XMLDOM" );
|
|
xml.async = "false";
|
|
xml.loadXML( data );
|
|
}
|
|
|
|
tmp = xml.documentElement;
|
|
|
|
if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
|
|
jQuery.error( "Invalid XML: " + data );
|
|
}
|
|
|
|
return xml;
|
|
},
|
|
|
|
noop: function() {},
|
|
|
|
// Evaluates a script in a global context
|
|
// Workarounds based on findings by Jim Driscoll
|
|
// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
|
|
globalEval: function( data ) {
|
|
if ( data && rnotwhite.test( data ) ) {
|
|
// We use execScript on Internet Explorer
|
|
// We use an anonymous function so that context is window
|
|
// rather than jQuery in Firefox
|
|
( window.execScript || function( data ) {
|
|
window[ "eval" ].call( window, data );
|
|
} )( data );
|
|
}
|
|
},
|
|
|
|
// Converts a dashed string to camelCased string;
|
|
// Used by both the css and data modules
|
|
camelCase: function( string ) {
|
|
return string.replace( rdashAlpha, fcamelCase );
|
|
},
|
|
|
|
nodeName: function( elem, name ) {
|
|
return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
|
|
},
|
|
|
|
// args is for internal usage only
|
|
each: function( object, callback, args ) {
|
|
var name, i = 0,
|
|
length = object.length,
|
|
isObj = length === undefined || jQuery.isFunction( object );
|
|
|
|
if ( args ) {
|
|
if ( isObj ) {
|
|
for ( name in object ) {
|
|
if ( callback.apply( object[ name ], args ) === false ) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
for ( ; i < length; ) {
|
|
if ( callback.apply( object[ i++ ], args ) === false ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// A special, fast, case for the most common use of each
|
|
} else {
|
|
if ( isObj ) {
|
|
for ( name in object ) {
|
|
if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
for ( ; i < length; ) {
|
|
if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return object;
|
|
},
|
|
|
|
// Use native String.trim function wherever possible
|
|
trim: trim ?
|
|
function( text ) {
|
|
return text == null ?
|
|
"" :
|
|
trim.call( text );
|
|
} :
|
|
|
|
// Otherwise use our own trimming functionality
|
|
function( text ) {
|
|
return text == null ?
|
|
"" :
|
|
text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
|
|
},
|
|
|
|
// results is for internal usage only
|
|
makeArray: function( array, results ) {
|
|
var ret = results || [];
|
|
|
|
if ( array != null ) {
|
|
// The window, strings (and functions) also have 'length'
|
|
// The extra typeof function check is to prevent crashes
|
|
// in Safari 2 (See: #3039)
|
|
// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
|
|
var type = jQuery.type( array );
|
|
|
|
if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
|
|
push.call( ret, array );
|
|
} else {
|
|
jQuery.merge( ret, array );
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
},
|
|
|
|
inArray: function( elem, array ) {
|
|
|
|
if ( indexOf ) {
|
|
return indexOf.call( array, elem );
|
|
}
|
|
|
|
for ( var i = 0, length = array.length; i < length; i++ ) {
|
|
if ( array[ i ] === elem ) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
},
|
|
|
|
merge: function( first, second ) {
|
|
var i = first.length,
|
|
j = 0;
|
|
|
|
if ( typeof second.length === "number" ) {
|
|
for ( var l = second.length; j < l; j++ ) {
|
|
first[ i++ ] = second[ j ];
|
|
}
|
|
|
|
} else {
|
|
while ( second[j] !== undefined ) {
|
|
first[ i++ ] = second[ j++ ];
|
|
}
|
|
}
|
|
|
|
first.length = i;
|
|
|
|
return first;
|
|
},
|
|
|
|
grep: function( elems, callback, inv ) {
|
|
var ret = [], retVal;
|
|
inv = !!inv;
|
|
|
|
// Go through the array, only saving the items
|
|
// that pass the validator function
|
|
for ( var i = 0, length = elems.length; i < length; i++ ) {
|
|
retVal = !!callback( elems[ i ], i );
|
|
if ( inv !== retVal ) {
|
|
ret.push( elems[ i ] );
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
},
|
|
|
|
// arg is for internal usage only
|
|
map: function( elems, callback, arg ) {
|
|
var value, key, ret = [],
|
|
i = 0,
|
|
length = elems.length,
|
|
// jquery objects are treated as arrays
|
|
isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
|
|
|
|
// Go through the array, translating each of the items to their
|
|
if ( isArray ) {
|
|
for ( ; i < length; i++ ) {
|
|
value = callback( elems[ i ], i, arg );
|
|
|
|
if ( value != null ) {
|
|
ret[ ret.length ] = value;
|
|
}
|
|
}
|
|
|
|
// Go through every key on the object,
|
|
} else {
|
|
for ( key in elems ) {
|
|
value = callback( elems[ key ], key, arg );
|
|
|
|
if ( value != null ) {
|
|
ret[ ret.length ] = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Flatten any nested arrays
|
|
return ret.concat.apply( [], ret );
|
|
},
|
|
|
|
// A global GUID counter for objects
|
|
guid: 1,
|
|
|
|
// Bind a function to a context, optionally partially applying any
|
|
// arguments.
|
|
proxy: function( fn, context ) {
|
|
if ( typeof context === "string" ) {
|
|
var tmp = fn[ context ];
|
|
context = fn;
|
|
fn = tmp;
|
|
}
|
|
|
|
// Quick check to determine if target is callable, in the spec
|
|
// this throws a TypeError, but we will just return undefined.
|
|
if ( !jQuery.isFunction( fn ) ) {
|
|
return undefined;
|
|
}
|
|
|
|
// Simulated bind
|
|
var args = slice.call( arguments, 2 ),
|
|
proxy = function() {
|
|
return fn.apply( context, args.concat( slice.call( arguments ) ) );
|
|
};
|
|
|
|
// Set the guid of unique handler to the same of original handler, so it can be removed
|
|
proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
|
|
|
|
return proxy;
|
|
},
|
|
|
|
// Mutifunctional method to get and set values to a collection
|
|
// The value/s can optionally be executed if it's a function
|
|
access: function( elems, key, value, exec, fn, pass ) {
|
|
var length = elems.length;
|
|
|
|
// Setting many attributes
|
|
if ( typeof key === "object" ) {
|
|
for ( var k in key ) {
|
|
jQuery.access( elems, k, key[k], exec, fn, value );
|
|
}
|
|
return elems;
|
|
}
|
|
|
|
// Setting one attribute
|
|
if ( value !== undefined ) {
|
|
// Optionally, function values get executed if exec is true
|
|
exec = !pass && exec && jQuery.isFunction(value);
|
|
|
|
for ( var i = 0; i < length; i++ ) {
|
|
fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
|
|
}
|
|
|
|
return elems;
|
|
}
|
|
|
|
// Getting an attribute
|
|
return length ? fn( elems[0], key ) : undefined;
|
|
},
|
|
|
|
now: function() {
|
|
return (new Date()).getTime();
|
|
},
|
|
|
|
// Use of jQuery.browser is frowned upon.
|
|
// More details: http://docs.jquery.com/Utilities/jQuery.browser
|
|
uaMatch: function( ua ) {
|
|
ua = ua.toLowerCase();
|
|
|
|
var match = rwebkit.exec( ua ) ||
|
|
ropera.exec( ua ) ||
|
|
rmsie.exec( ua ) ||
|
|
ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
|
|
[];
|
|
|
|
return { browser: match[1] || "", version: match[2] || "0" };
|
|
},
|
|
|
|
sub: function() {
|
|
function jQuerySub( selector, context ) {
|
|
return new jQuerySub.fn.init( selector, context );
|
|
}
|
|
jQuery.extend( true, jQuerySub, this );
|
|
jQuerySub.superclass = this;
|
|
jQuerySub.fn = jQuerySub.prototype = this();
|
|
jQuerySub.fn.constructor = jQuerySub;
|
|
jQuerySub.sub = this.sub;
|
|
jQuerySub.fn.init = function init( selector, context ) {
|
|
if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
|
|
context = jQuerySub( context );
|
|
}
|
|
|
|
return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
|
|
};
|
|
jQuerySub.fn.init.prototype = jQuerySub.fn;
|
|
var rootjQuerySub = jQuerySub(document);
|
|
return jQuerySub;
|
|
},
|
|
|
|
browser: {}
|
|
});
|
|
|
|
// Populate the class2type map
|
|
jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
|
|
class2type[ "[object " + name + "]" ] = name.toLowerCase();
|
|
});
|
|
|
|
browserMatch = jQuery.uaMatch( userAgent );
|
|
if ( browserMatch.browser ) {
|
|
jQuery.browser[ browserMatch.browser ] = true;
|
|
jQuery.browser.version = browserMatch.version;
|
|
}
|
|
|
|
// Deprecated, use jQuery.browser.webkit instead
|
|
if ( jQuery.browser.webkit ) {
|
|
jQuery.browser.safari = true;
|
|
}
|
|
|
|
// IE doesn't match non-breaking spaces with \s
|
|
if ( rnotwhite.test( "\xA0" ) ) {
|
|
trimLeft = /^[\s\xA0]+/;
|
|
trimRight = /[\s\xA0]+$/;
|
|
}
|
|
|
|
// All jQuery objects should point back to these
|
|
rootjQuery = jQuery(document);
|
|
|
|
// Cleanup functions for the document ready method
|
|
if ( document.addEventListener ) {
|
|
DOMContentLoaded = function() {
|
|
document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
|
|
jQuery.ready();
|
|
};
|
|
|
|
} else if ( document.attachEvent ) {
|
|
DOMContentLoaded = function() {
|
|
// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
|
|
if ( document.readyState === "complete" ) {
|
|
document.detachEvent( "onreadystatechange", DOMContentLoaded );
|
|
jQuery.ready();
|
|
}
|
|
};
|
|
}
|
|
|
|
// The DOM ready check for Internet Explorer
|
|
function doScrollCheck() {
|
|
if ( jQuery.isReady ) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
// If IE is used, use the trick by Diego Perini
|
|
// http://javascript.nwbox.com/IEContentLoaded/
|
|
document.documentElement.doScroll("left");
|
|
} catch(e) {
|
|
setTimeout( doScrollCheck, 1 );
|
|
return;
|
|
}
|
|
|
|
// and execute any waiting functions
|
|
jQuery.ready();
|
|
}
|
|
|
|
return jQuery;
|
|
|
|
})();
|
|
|
|
|
|
var // Promise methods
|
|
promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ),
|
|
// Static reference to slice
|
|
sliceDeferred = [].slice;
|
|
|
|
jQuery.extend({
|
|
// Create a simple deferred (one callbacks list)
|
|
_Deferred: function() {
|
|
var // callbacks list
|
|
callbacks = [],
|
|
// stored [ context , args ]
|
|
fired,
|
|
// to avoid firing when already doing so
|
|
firing,
|
|
// flag to know if the deferred has been cancelled
|
|
cancelled,
|
|
// the deferred itself
|
|
deferred = {
|
|
|
|
// done( f1, f2, ...)
|
|
done: function() {
|
|
if ( !cancelled ) {
|
|
var args = arguments,
|
|
i,
|
|
length,
|
|
elem,
|
|
type,
|
|
_fired;
|
|
if ( fired ) {
|
|
_fired = fired;
|
|
fired = 0;
|
|
}
|
|
for ( i = 0, length = args.length; i < length; i++ ) {
|
|
elem = args[ i ];
|
|
type = jQuery.type( elem );
|
|
if ( type === "array" ) {
|
|
deferred.done.apply( deferred, elem );
|
|
} else if ( type === "function" ) {
|
|
callbacks.push( elem );
|
|
}
|
|
}
|
|
if ( _fired ) {
|
|
deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
|
|
}
|
|
}
|
|
return this;
|
|
},
|
|
|
|
// resolve with given context and args
|
|
resolveWith: function( context, args ) {
|
|
if ( !cancelled && !fired && !firing ) {
|
|
// make sure args are available (#8421)
|
|
args = args || [];
|
|
firing = 1;
|
|
try {
|
|
while( callbacks[ 0 ] ) {
|
|
callbacks.shift().apply( context, args );
|
|
}
|
|
}
|
|
finally {
|
|
fired = [ context, args ];
|
|
firing = 0;
|
|
}
|
|
}
|
|
return this;
|
|
},
|
|
|
|
// resolve with this as context and given arguments
|
|
resolve: function() {
|
|
deferred.resolveWith( this, arguments );
|
|
return this;
|
|
},
|
|
|
|
// Has this deferred been resolved?
|
|
isResolved: function() {
|
|
return !!( firing || fired );
|
|
},
|
|
|
|
// Cancel
|
|
cancel: function() {
|
|
cancelled = 1;
|
|
callbacks = [];
|
|
return this;
|
|
}
|
|
};
|
|
|
|
return deferred;
|
|
},
|
|
|
|
// Full fledged deferred (two callbacks list)
|
|
Deferred: function( func ) {
|
|
var deferred = jQuery._Deferred(),
|
|
failDeferred = jQuery._Deferred(),
|
|
promise;
|
|
// Add errorDeferred methods, then and promise
|
|
jQuery.extend( deferred, {
|
|
then: function( doneCallbacks, failCallbacks ) {
|
|
deferred.done( doneCallbacks ).fail( failCallbacks );
|
|
return this;
|
|
},
|
|
always: function() {
|
|
return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments );
|
|
},
|
|
fail: failDeferred.done,
|
|
rejectWith: failDeferred.resolveWith,
|
|
reject: failDeferred.resolve,
|
|
isRejected: failDeferred.isResolved,
|
|
pipe: function( fnDone, fnFail ) {
|
|
return jQuery.Deferred(function( newDefer ) {
|
|
jQuery.each( {
|
|
done: [ fnDone, "resolve" ],
|
|
fail: [ fnFail, "reject" ]
|
|
}, function( handler, data ) {
|
|
var fn = data[ 0 ],
|
|
action = data[ 1 ],
|
|
returned;
|
|
if ( jQuery.isFunction( fn ) ) {
|
|
deferred[ handler ](function() {
|
|
returned = fn.apply( this, arguments );
|
|
if ( returned && jQuery.isFunction( returned.promise ) ) {
|
|
returned.promise().then( newDefer.resolve, newDefer.reject );
|
|
} else {
|
|
newDefer[ action ]( returned );
|
|
}
|
|
});
|
|
} else {
|
|
deferred[ handler ]( newDefer[ action ] );
|
|
}
|
|
});
|
|
}).promise();
|
|
},
|
|
// Get a promise for this deferred
|
|
// If obj is provided, the promise aspect is added to the object
|
|
promise: function( obj ) {
|
|
if ( obj == null ) {
|
|
if ( promise ) {
|
|
return promise;
|
|
}
|
|
promise = obj = {};
|
|
}
|
|
var i = promiseMethods.length;
|
|
while( i-- ) {
|
|
obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
|
|
}
|
|
return obj;
|
|
}
|
|
});
|
|
// Make sure only one callback list will be used
|
|
deferred.done( failDeferred.cancel ).fail( deferred.cancel );
|
|
// Unexpose cancel
|
|
delete deferred.cancel;
|
|
// Call given func if any
|
|
if ( func ) {
|
|
func.call( deferred, deferred );
|
|
}
|
|
return deferred;
|
|
},
|
|
|
|
// Deferred helper
|
|
when: function( firstParam ) {
|
|
var args = arguments,
|
|
i = 0,
|
|
length = args.length,
|
|
count = length,
|
|
deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
|
|
firstParam :
|
|
jQuery.Deferred();
|
|
function resolveFunc( i ) {
|
|
return function( value ) {
|
|
args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
|
|
if ( !( --count ) ) {
|
|
// Strange bug in FF4:
|
|
// Values changed onto the arguments object sometimes end up as undefined values
|
|
// outside the $.when method. Cloning the object into a fresh array solves the issue
|
|
deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) );
|
|
}
|
|
};
|
|
}
|
|
if ( length > 1 ) {
|
|
for( ; i < length; i++ ) {
|
|
if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) {
|
|
args[ i ].promise().then( resolveFunc(i), deferred.reject );
|
|
} else {
|
|
--count;
|
|
}
|
|
}
|
|
if ( !count ) {
|
|
deferred.resolveWith( deferred, args );
|
|
}
|
|
} else if ( deferred !== firstParam ) {
|
|
deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
|
|
}
|
|
return deferred.promise();
|
|
}
|
|
});
|
|
|
|
|
|
|
|
jQuery.support = (function() {
|
|
|
|
var div = document.createElement( "div" ),
|
|
documentElement = document.documentElement,
|
|
all,
|
|
a,
|
|
select,
|
|
opt,
|
|
input,
|
|
marginDiv,
|
|
support,
|
|
fragment,
|
|
body,
|
|
testElementParent,
|
|
testElement,
|
|
testElementStyle,
|
|
tds,
|
|
events,
|
|
eventName,
|
|
i,
|
|
isSupported;
|
|
|
|
// Preliminary tests
|
|
div.setAttribute("className", "t");
|
|
div.innerHTML = " <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
|
|
|
|
all = div.getElementsByTagName( "*" );
|
|
a = div.getElementsByTagName( "a" )[ 0 ];
|
|
|
|
// Can't get basic test support
|
|
if ( !all || !all.length || !a ) {
|
|
return {};
|
|
}
|
|
|
|
// First batch of supports tests
|
|
select = document.createElement( "select" );
|
|
opt = select.appendChild( document.createElement("option") );
|
|
input = div.getElementsByTagName( "input" )[ 0 ];
|
|
|
|
support = {
|
|
// IE strips leading whitespace when .innerHTML is used
|
|
leadingWhitespace: ( div.firstChild.nodeType === 3 ),
|
|
|
|
// Make sure that tbody elements aren't automatically inserted
|
|
// IE will insert them into empty tables
|
|
tbody: !div.getElementsByTagName( "tbody" ).length,
|
|
|
|
// Make sure that link elements get serialized correctly by innerHTML
|
|
// This requires a wrapper element in IE
|
|
htmlSerialize: !!div.getElementsByTagName( "link" ).length,
|
|
|
|
// Get the style information from getAttribute
|
|
// (IE uses .cssText instead)
|
|
style: /top/.test( a.getAttribute("style") ),
|
|
|
|
// Make sure that URLs aren't manipulated
|
|
// (IE normalizes it by default)
|
|
hrefNormalized: ( a.getAttribute( "href" ) === "/a" ),
|
|
|
|
// Make sure that element opacity exists
|
|
// (IE uses filter instead)
|
|
// Use a regex to work around a WebKit issue. See #5145
|
|
opacity: /^0.55$/.test( a.style.opacity ),
|
|
|
|
// Verify style float existence
|
|
// (IE uses styleFloat instead of cssFloat)
|
|
cssFloat: !!a.style.cssFloat,
|
|
|
|
// Make sure that if no value is specified for a checkbox
|
|
// that it defaults to "on".
|
|
// (WebKit defaults to "" instead)
|
|
checkOn: ( input.value === "on" ),
|
|
|
|
// Make sure that a selected-by-default option has a working selected property.
|
|
// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
|
|
optSelected: opt.selected,
|
|
|
|
// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
|
|
getSetAttribute: div.className !== "t",
|
|
|
|
// Will be defined later
|
|
submitBubbles: true,
|
|
changeBubbles: true,
|
|
focusinBubbles: false,
|
|
deleteExpando: true,
|
|
noCloneEvent: true,
|
|
inlineBlockNeedsLayout: false,
|
|
shrinkWrapBlocks: false,
|
|
reliableMarginRight: true
|
|
};
|
|
|
|
// Make sure checked status is properly cloned
|
|
input.checked = true;
|
|
support.noCloneChecked = input.cloneNode( true ).checked;
|
|
|
|
// Make sure that the options inside disabled selects aren't marked as disabled
|
|
// (WebKit marks them as disabled)
|
|
select.disabled = true;
|
|
support.optDisabled = !opt.disabled;
|
|
|
|
// Test to see if it's possible to delete an expando from an element
|
|
// Fails in Internet Explorer
|
|
try {
|
|
delete div.test;
|
|
} catch( e ) {
|
|
support.deleteExpando = false;
|
|
}
|
|
|
|
if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
|
|
div.attachEvent( "onclick", function() {
|
|
// Cloning a node shouldn't copy over any
|
|
// bound event handlers (IE does this)
|
|
support.noCloneEvent = false;
|
|
});
|
|
div.cloneNode( true ).fireEvent( "onclick" );
|
|
}
|
|
|
|
// Check if a radio maintains it's value
|
|
// after being appended to the DOM
|
|
input = document.createElement("input");
|
|
input.value = "t";
|
|
input.setAttribute("type", "radio");
|
|
support.radioValue = input.value === "t";
|
|
|
|
input.setAttribute("checked", "checked");
|
|
div.appendChild( input );
|
|
fragment = document.createDocumentFragment();
|
|
fragment.appendChild( div.firstChild );
|
|
|
|
// WebKit doesn't clone checked state correctly in fragments
|
|
support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
|
|
|
|
div.innerHTML = "";
|
|
|
|
// Figure out if the W3C box model works as expected
|
|
div.style.width = div.style.paddingLeft = "1px";
|
|
|
|
body = document.getElementsByTagName( "body" )[ 0 ];
|
|
// We use our own, invisible, body unless the body is already present
|
|
// in which case we use a div (#9239)
|
|
testElement = document.createElement( body ? "div" : "body" );
|
|
testElementStyle = {
|
|
visibility: "hidden",
|
|
width: 0,
|
|
height: 0,
|
|
border: 0,
|
|
margin: 0
|
|
};
|
|
if ( body ) {
|
|
jQuery.extend( testElementStyle, {
|
|
position: "absolute",
|
|
left: -1000,
|
|
top: -1000
|
|
});
|
|
}
|
|
for ( i in testElementStyle ) {
|
|
testElement.style[ i ] = testElementStyle[ i ];
|
|
}
|
|
testElement.appendChild( div );
|
|
testElementParent = body || documentElement;
|
|
testElementParent.insertBefore( testElement, testElementParent.firstChild );
|
|
|
|
// Check if a disconnected checkbox will retain its checked
|
|
// value of true after appended to the DOM (IE6/7)
|
|
support.appendChecked = input.checked;
|
|
|
|
support.boxModel = div.offsetWidth === 2;
|
|
|
|
if ( "zoom" in div.style ) {
|
|
// Check if natively block-level elements act like inline-block
|
|
// elements when setting their display to 'inline' and giving
|
|
// them layout
|
|
// (IE < 8 does this)
|
|
div.style.display = "inline";
|
|
div.style.zoom = 1;
|
|
support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
|
|
|
|
// Check if elements with layout shrink-wrap their children
|
|
// (IE 6 does this)
|
|
div.style.display = "";
|
|
div.innerHTML = "<div style='width:4px;'></div>";
|
|
support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
|
|
}
|
|
|
|
div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
|
|
tds = div.getElementsByTagName( "td" );
|
|
|
|
// Check if table cells still have offsetWidth/Height when they are set
|
|
// to display:none and there are still other visible table cells in a
|
|
// table row; if so, offsetWidth/Height are not reliable for use when
|
|
// determining if an element has been hidden directly using
|
|
// display:none (it is still safe to use offsets if a parent element is
|
|
// hidden; don safety goggles and see bug #4512 for more information).
|
|
// (only IE 8 fails this test)
|
|
isSupported = ( tds[ 0 ].offsetHeight === 0 );
|
|
|
|
tds[ 0 ].style.display = "";
|
|
tds[ 1 ].style.display = "none";
|
|
|
|
// Check if empty table cells still have offsetWidth/Height
|
|
// (IE < 8 fail this test)
|
|
support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
|
|
div.innerHTML = "";
|
|
|
|
// Check if div with explicit width and no margin-right incorrectly
|
|
// gets computed margin-right based on width of container. For more
|
|
// info see bug #3333
|
|
// Fails in WebKit before Feb 2011 nightlies
|
|
// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
|
|
if ( document.defaultView && document.defaultView.getComputedStyle ) {
|
|
marginDiv = document.createElement( "div" );
|
|
marginDiv.style.width = "0";
|
|
marginDiv.style.marginRight = "0";
|
|
div.appendChild( marginDiv );
|
|
support.reliableMarginRight =
|
|
( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
|
|
}
|
|
|
|
// Remove the body element we added
|
|
testElement.innerHTML = "";
|
|
testElementParent.removeChild( testElement );
|
|
|
|
// Technique from Juriy Zaytsev
|
|
// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
|
|
// We only care about the case where non-standard event systems
|
|
// are used, namely in IE. Short-circuiting here helps us to
|
|
// avoid an eval call (in setAttribute) which can cause CSP
|
|
// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
|
|
if ( div.attachEvent ) {
|
|
for( i in {
|
|
submit: 1,
|
|
change: 1,
|
|
focusin: 1
|
|
} ) {
|
|
eventName = "on" + i;
|
|
isSupported = ( eventName in div );
|
|
if ( !isSupported ) {
|
|
div.setAttribute( eventName, "return;" );
|
|
isSupported = ( typeof div[ eventName ] === "function" );
|
|
}
|
|
support[ i + "Bubbles" ] = isSupported;
|
|
}
|
|
}
|
|
|
|
// Null connected elements to avoid leaks in IE
|
|
testElement = fragment = select = opt = body = marginDiv = div = input = null;
|
|
|
|
return support;
|
|
})();
|
|
|
|
// Keep track of boxModel
|
|
jQuery.boxModel = jQuery.support.boxModel;
|
|
|
|
|
|
|
|
|
|
var rbrace = /^(?:\{.*\}|\[.*\])$/,
|
|
rmultiDash = /([a-z])([A-Z])/g;
|
|
|
|
jQuery.extend({
|
|
cache: {},
|
|
|
|
// Please use with caution
|
|
uuid: 0,
|
|
|
|
// Unique for each copy of jQuery on the page
|
|
// Non-digits removed to match rinlinejQuery
|
|
expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
|
|
|
|
// The following elements throw uncatchable exceptions if you
|
|
// attempt to add expando properties to them.
|
|
noData: {
|
|
"embed": true,
|
|
// Ban all objects except for Flash (which handle expandos)
|
|
"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
|
|
"applet": true
|
|
},
|
|
|
|
hasData: function( elem ) {
|
|
elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
|
|
|
|
return !!elem && !isEmptyDataObject( elem );
|
|
},
|
|
|
|
data: function( elem, name, data, pvt /* Internal Use Only */ ) {
|
|
if ( !jQuery.acceptData( elem ) ) {
|
|
return;
|
|
}
|
|
|
|
var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,
|
|
|
|
// We have to handle DOM nodes and JS objects differently because IE6-7
|
|
// can't GC object references properly across the DOM-JS boundary
|
|
isNode = elem.nodeType,
|
|
|
|
// Only DOM nodes need the global jQuery cache; JS object data is
|
|
// attached directly to the object so GC can occur automatically
|
|
cache = isNode ? jQuery.cache : elem,
|
|
|
|
// Only defining an ID for JS objects if its cache already exists allows
|
|
// the code to shortcut on the same path as a DOM node with no cache
|
|
id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
|
|
|
|
// Avoid doing any more work than we need to when trying to get data on an
|
|
// object that has no data at all
|
|
if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
|
|
return;
|
|
}
|
|
|
|
if ( !id ) {
|
|
// Only DOM nodes need a new unique ID for each element since their data
|
|
// ends up in the global cache
|
|
if ( isNode ) {
|
|
elem[ jQuery.expando ] = id = ++jQuery.uuid;
|
|
} else {
|
|
id = jQuery.expando;
|
|
}
|
|
}
|
|
|
|
if ( !cache[ id ] ) {
|
|
cache[ id ] = {};
|
|
|
|
// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
|
|
// metadata on plain JS objects when the object is serialized using
|
|
// JSON.stringify
|
|
if ( !isNode ) {
|
|
cache[ id ].toJSON = jQuery.noop;
|
|
}
|
|
}
|
|
|
|
// An object can be passed to jQuery.data instead of a key/value pair; this gets
|
|
// shallow copied over onto the existing cache
|
|
if ( typeof name === "object" || typeof name === "function" ) {
|
|
if ( pvt ) {
|
|
cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
|
|
} else {
|
|
cache[ id ] = jQuery.extend(cache[ id ], name);
|
|
}
|
|
}
|
|
|
|
thisCache = cache[ id ];
|
|
|
|
// Internal jQuery data is stored in a separate object inside the object's data
|
|
// cache in order to avoid key collisions between internal data and user-defined
|
|
// data
|
|
if ( pvt ) {
|
|
if ( !thisCache[ internalKey ] ) {
|
|
thisCache[ internalKey ] = {};
|
|
}
|
|
|
|
thisCache = thisCache[ internalKey ];
|
|
}
|
|
|
|
if ( data !== undefined ) {
|
|
thisCache[ jQuery.camelCase( name ) ] = data;
|
|
}
|
|
|
|
// TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
|
|
// not attempt to inspect the internal events object using jQuery.data, as this
|
|
// internal data object is undocumented and subject to change.
|
|
if ( name === "events" && !thisCache[name] ) {
|
|
return thisCache[ internalKey ] && thisCache[ internalKey ].events;
|
|
}
|
|
|
|
return getByName ?
|
|
// Check for both converted-to-camel and non-converted data property names
|
|
thisCache[ jQuery.camelCase( name ) ] || thisCache[ name ] :
|
|
thisCache;
|
|
},
|
|
|
|
removeData: function( elem, name, pvt /* Internal Use Only */ ) {
|
|
if ( !jQuery.acceptData( elem ) ) {
|
|
return;
|
|
}
|
|
|
|
var internalKey = jQuery.expando, isNode = elem.nodeType,
|
|
|
|
// See jQuery.data for more information
|
|
cache = isNode ? jQuery.cache : elem,
|
|
|
|
// See jQuery.data for more information
|
|
id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
|
|
|
|
// If there is already no cache entry for this object, there is no
|
|
// purpose in continuing
|
|
if ( !cache[ id ] ) {
|
|
return;
|
|
}
|
|
|
|
if ( name ) {
|
|
var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
|
|
|
|
if ( thisCache ) {
|
|
delete thisCache[ name ];
|
|
|
|
// If there is no data left in the cache, we want to continue
|
|
// and let the cache object itself get destroyed
|
|
if ( !isEmptyDataObject(thisCache) ) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// See jQuery.data for more information
|
|
if ( pvt ) {
|
|
delete cache[ id ][ internalKey ];
|
|
|
|
// Don't destroy the parent cache unless the internal data object
|
|
// had been the only thing left in it
|
|
if ( !isEmptyDataObject(cache[ id ]) ) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
var internalCache = cache[ id ][ internalKey ];
|
|
|
|
// Browsers that fail expando deletion also refuse to delete expandos on
|
|
// the window, but it will allow it on all other JS objects; other browsers
|
|
// don't care
|
|
if ( jQuery.support.deleteExpando || cache != window ) {
|
|
delete cache[ id ];
|
|
} else {
|
|
cache[ id ] = null;
|
|
}
|
|
|
|
// We destroyed the entire user cache at once because it's faster than
|
|
// iterating through each key, but we need to continue to persist internal
|
|
// data if it existed
|
|
if ( internalCache ) {
|
|
cache[ id ] = {};
|
|
// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
|
|
// metadata on plain JS objects when the object is serialized using
|
|
// JSON.stringify
|
|
if ( !isNode ) {
|
|
cache[ id ].toJSON = jQuery.noop;
|
|
}
|
|
|
|
cache[ id ][ internalKey ] = internalCache;
|
|
|
|
// Otherwise, we need to eliminate the expando on the node to avoid
|
|
// false lookups in the cache for entries that no longer exist
|
|
} else if ( isNode ) {
|
|
// IE does not allow us to delete expando properties from nodes,
|
|
// nor does it have a removeAttribute function on Document nodes;
|
|
// we must handle all of these cases
|
|
if ( jQuery.support.deleteExpando ) {
|
|
delete elem[ jQuery.expando ];
|
|
} else if ( elem.removeAttribute ) {
|
|
elem.removeAttribute( jQuery.expando );
|
|
} else {
|
|
elem[ jQuery.expando ] = null;
|
|
}
|
|
}
|
|
},
|
|
|
|
// For internal use only.
|
|
_data: function( elem, name, data ) {
|
|
return jQuery.data( elem, name, data, true );
|
|
},
|
|
|
|
// A method for determining if a DOM node can handle the data expando
|
|
acceptData: function( elem ) {
|
|
if ( elem.nodeName ) {
|
|
var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
|
|
|
|
if ( match ) {
|
|
return !(match === true || elem.getAttribute("classid") !== match);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
});
|
|
|
|
jQuery.fn.extend({
|
|
data: function( key, value ) {
|
|
var data = null;
|
|
|
|
if ( typeof key === "undefined" ) {
|
|
if ( this.length ) {
|
|
data = jQuery.data( this[0] );
|
|
|
|
if ( this[0].nodeType === 1 ) {
|
|
var attr = this[0].attributes, name;
|
|
for ( var i = 0, l = attr.length; i < l; i++ ) {
|
|
name = attr[i].name;
|
|
|
|
if ( name.indexOf( "data-" ) === 0 ) {
|
|
name = jQuery.camelCase( name.substring(5) );
|
|
|
|
dataAttr( this[0], name, data[ name ] );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return data;
|
|
|
|
} else if ( typeof key === "object" ) {
|
|
return this.each(function() {
|
|
jQuery.data( this, key );
|
|
});
|
|
}
|
|
|
|
var parts = key.split(".");
|
|
parts[1] = parts[1] ? "." + parts[1] : "";
|
|
|
|
if ( value === undefined ) {
|
|
data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
|
|
|
|
// Try to fetch any internally stored data first
|
|
if ( data === undefined && this.length ) {
|
|
data = jQuery.data( this[0], key );
|
|
data = dataAttr( this[0], key, data );
|
|
}
|
|
|
|
return data === undefined && parts[1] ?
|
|
this.data( parts[0] ) :
|
|
data;
|
|
|
|
} else {
|
|
return this.each(function() {
|
|
var $this = jQuery( this ),
|
|
args = [ parts[0], value ];
|
|
|
|
$this.triggerHandler( "setData" + parts[1] + "!", args );
|
|
jQuery.data( this, key, value );
|
|
$this.triggerHandler( "changeData" + parts[1] + "!", args );
|
|
});
|
|
}
|
|
},
|
|
|
|
removeData: function( key ) {
|
|
return this.each(function() {
|
|
jQuery.removeData( this, key );
|
|
});
|
|
}
|
|
});
|
|
|
|
function dataAttr( elem, key, data ) {
|
|
// If nothing was found internally, try to fetch any
|
|
// data from the HTML5 data-* attribute
|
|
if ( data === undefined && elem.nodeType === 1 ) {
|
|
var name = "data-" + key.replace( rmultiDash, "$1-$2" ).toLowerCase();
|
|
|
|
data = elem.getAttribute( name );
|
|
|
|
if ( typeof data === "string" ) {
|
|
try {
|
|
data = data === "true" ? true :
|
|
data === "false" ? false :
|
|
data === "null" ? null :
|
|
!jQuery.isNaN( data ) ? parseFloat( data ) :
|
|
rbrace.test( data ) ? jQuery.parseJSON( data ) :
|
|
data;
|
|
} catch( e ) {}
|
|
|
|
// Make sure we set the data so it isn't changed later
|
|
jQuery.data( elem, key, data );
|
|
|
|
} else {
|
|
data = undefined;
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
// TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
|
|
// property to be considered empty objects; this property always exists in
|
|
// order to make sure JSON.stringify does not expose internal metadata
|
|
function isEmptyDataObject( obj ) {
|
|
for ( var name in obj ) {
|
|
if ( name !== "toJSON" ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
function handleQueueMarkDefer( elem, type, src ) {
|
|
var deferDataKey = type + "defer",
|
|
queueDataKey = type + "queue",
|
|
markDataKey = type + "mark",
|
|
defer = jQuery.data( elem, deferDataKey, undefined, true );
|
|
if ( defer &&
|
|
( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
|
|
( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
|
|
// Give room for hard-coded callbacks to fire first
|
|
// and eventually mark/queue something else on the element
|
|
setTimeout( function() {
|
|
if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
|
|
!jQuery.data( elem, markDataKey, undefined, true ) ) {
|
|
jQuery.removeData( elem, deferDataKey, true );
|
|
defer.resolve();
|
|
}
|
|
}, 0 );
|
|
}
|
|
}
|
|
|
|
jQuery.extend({
|
|
|
|
_mark: function( elem, type ) {
|
|
if ( elem ) {
|
|
type = (type || "fx") + "mark";
|
|
jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true );
|
|
}
|
|
},
|
|
|
|
_unmark: function( force, elem, type ) {
|
|
if ( force !== true ) {
|
|
type = elem;
|
|
elem = force;
|
|
force = false;
|
|
}
|
|
if ( elem ) {
|
|
type = type || "fx";
|
|
var key = type + "mark",
|
|
count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) || 1 ) - 1 );
|
|
if ( count ) {
|
|
jQuery.data( elem, key, count, true );
|
|
} else {
|
|
jQuery.removeData( elem, key, true );
|
|
handleQueueMarkDefer( elem, type, "mark" );
|
|
}
|
|
}
|
|
},
|
|
|
|
queue: function( elem, type, data ) {
|
|
if ( elem ) {
|
|
type = (type || "fx") + "queue";
|
|
var q = jQuery.data( elem, type, undefined, true );
|
|
// Speed up dequeue by getting out quickly if this is just a lookup
|
|
if ( data ) {
|
|
if ( !q || jQuery.isArray(data) ) {
|
|
q = jQuery.data( elem, type, jQuery.makeArray(data), true );
|
|
} else {
|
|
q.push( data );
|
|
}
|
|
}
|
|
return q || [];
|
|
}
|
|
},
|
|
|
|
dequeue: function( elem, type ) {
|
|
type = type || "fx";
|
|
|
|
var queue = jQuery.queue( elem, type ),
|
|
fn = queue.shift(),
|
|
defer;
|
|
|
|
// If the fx queue is dequeued, always remove the progress sentinel
|
|
if ( fn === "inprogress" ) {
|
|
fn = queue.shift();
|
|
}
|
|
|
|
if ( fn ) {
|
|
// Add a progress sentinel to prevent the fx queue from being
|
|
// automatically dequeued
|
|
if ( type === "fx" ) {
|
|
queue.unshift("inprogress");
|
|
}
|
|
|
|
fn.call(elem, function() {
|
|
jQuery.dequeue(elem, type);
|
|
});
|
|
}
|
|
|
|
if ( !queue.length ) {
|
|
jQuery.removeData( elem, type + "queue", true );
|
|
handleQueueMarkDefer( elem, type, "queue" );
|
|
}
|
|
}
|
|
});
|
|
|
|
jQuery.fn.extend({
|
|
queue: function( type, data ) {
|
|
if ( typeof type !== "string" ) {
|
|
data = type;
|
|
type = "fx";
|
|
}
|
|
|
|
if ( data === undefined ) {
|
|
return jQuery.queue( this[0], type );
|
|
}
|
|
return this.each(function() {
|
|
var queue = jQuery.queue( this, type, data );
|
|
|
|
if ( type === "fx" && queue[0] !== "inprogress" ) {
|
|
jQuery.dequeue( this, type );
|
|
}
|
|
});
|
|
},
|
|
dequeue: function( type ) {
|
|
return this.each(function() {
|
|
jQuery.dequeue( this, type );
|
|
});
|
|
},
|
|
// Based off of the plugin by Clint Helfers, with permission.
|
|
// http://blindsignals.com/index.php/2009/07/jquery-delay/
|
|
delay: function( time, type ) {
|
|
time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
|
|
type = type || "fx";
|
|
|
|
return this.queue( type, function() {
|
|
var elem = this;
|
|
setTimeout(function() {
|
|
jQuery.dequeue( elem, type );
|
|
}, time );
|
|
});
|
|
},
|
|
clearQueue: function( type ) {
|
|
return this.queue( type || "fx", [] );
|
|
},
|
|
// Get a promise resolved when queues of a certain type
|
|
// are emptied (fx is the type by default)
|
|
promise: function( type, object ) {
|
|
if ( typeof type !== "string" ) {
|
|
object = type;
|
|
type = undefined;
|
|
}
|
|
type = type || "fx";
|
|
var defer = jQuery.Deferred(),
|
|
elements = this,
|
|
i = elements.length,
|
|
count = 1,
|
|
deferDataKey = type + "defer",
|
|
queueDataKey = type + "queue",
|
|
markDataKey = type + "mark",
|
|
tmp;
|
|
function resolve() {
|
|
if ( !( --count ) ) {
|
|
defer.resolveWith( elements, [ elements ] );
|
|
}
|
|
}
|
|
while( i-- ) {
|
|
if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
|
|
( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
|
|
jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
|
|
jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) {
|
|
count++;
|
|
tmp.done( resolve );
|
|
}
|
|
}
|
|
resolve();
|
|
return defer.promise();
|
|
}
|
|
});
|
|
|
|
|
|
|
|
|
|
var rclass = /[\n\t\r]/g,
|
|
rspace = /\s+/,
|
|
rreturn = /\r/g,
|
|
rtype = /^(?:button|input)$/i,
|
|
rfocusable = /^(?:button|input|object|select|textarea)$/i,
|
|
rclickable = /^a(?:rea)?$/i,
|
|
rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
|
|
rinvalidChar = /\:|^on/,
|
|
formHook, boolHook;
|
|
|
|
jQuery.fn.extend({
|
|
attr: function( name, value ) {
|
|
return jQuery.access( this, name, value, true, jQuery.attr );
|
|
},
|
|
|
|
removeAttr: function( name ) {
|
|
return this.each(function() {
|
|
jQuery.removeAttr( this, name );
|
|
});
|
|
},
|
|
|
|
prop: function( name, value ) {
|
|
return jQuery.access( this, name, value, true, jQuery.prop );
|
|
},
|
|
|
|
removeProp: function( name ) {
|
|
name = jQuery.propFix[ name ] || name;
|
|
return this.each(function() {
|
|
// try/catch handles cases where IE balks (such as removing a property on window)
|
|
try {
|
|
this[ name ] = undefined;
|
|
delete this[ name ];
|
|
} catch( e ) {}
|
|
});
|
|
},
|
|
|
|
addClass: function( value ) {
|
|
var classNames, i, l, elem,
|
|
setClass, c, cl;
|
|
|
|
if ( jQuery.isFunction( value ) ) {
|
|
return this.each(function( j ) {
|
|
jQuery( this ).addClass( value.call(this, j, this.className) );
|
|
});
|
|
}
|
|
|
|
if ( value && typeof value === "string" ) {
|
|
classNames = value.split( rspace );
|
|
|
|
for ( i = 0, l = this.length; i < l; i++ ) {
|
|
elem = this[ i ];
|
|
|
|
if ( elem.nodeType === 1 ) {
|
|
if ( !elem.className && classNames.length === 1 ) {
|
|
elem.className = value;
|
|
|
|
} else {
|
|
setClass = " " + elem.className + " ";
|
|
|
|
for ( c = 0, cl = classNames.length; c < cl; c++ ) {
|
|
if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
|
|
setClass += classNames[ c ] + " ";
|
|
}
|
|
}
|
|
elem.className = jQuery.trim( setClass );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
removeClass: function( value ) {
|
|
var classNames, i, l, elem, className, c, cl;
|
|
|
|
if ( jQuery.isFunction( value ) ) {
|
|
return this.each(function( j ) {
|
|
jQuery( this ).removeClass( value.call(this, j, this.className) );
|
|
});
|
|
}
|
|
|
|
if ( (value && typeof value === "string") || value === undefined ) {
|
|
classNames = (value || "").split( rspace );
|
|
|
|
for ( i = 0, l = this.length; i < l; i++ ) {
|
|
elem = this[ i ];
|
|
|
|
if ( elem.nodeType === 1 && elem.className ) {
|
|
if ( value ) {
|
|
className = (" " + elem.className + " ").replace( rclass, " " );
|
|
for ( c = 0, cl = classNames.length; c < cl; c++ ) {
|
|
className = className.replace(" " + classNames[ c ] + " ", " ");
|
|
}
|
|
elem.className = jQuery.trim( className );
|
|
|
|
} else {
|
|
elem.className = "";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
toggleClass: function( value, stateVal ) {
|
|
var type = typeof value,
|
|
isBool = typeof stateVal === "boolean";
|
|
|
|
if ( jQuery.isFunction( value ) ) {
|
|
return this.each(function( i ) {
|
|
jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
|
|
});
|
|
}
|
|
|
|
return this.each(function() {
|
|
if ( type === "string" ) {
|
|
// toggle individual class names
|
|
var className,
|
|
i = 0,
|
|
self = jQuery( this ),
|
|
state = stateVal,
|
|
classNames = value.split( rspace );
|
|
|
|
while ( (className = classNames[ i++ ]) ) {
|
|
// check each className given, space seperated list
|
|
state = isBool ? state : !self.hasClass( className );
|
|
self[ state ? "addClass" : "removeClass" ]( className );
|
|
}
|
|
|
|
} else if ( type === "undefined" || type === "boolean" ) {
|
|
if ( this.className ) {
|
|
// store className if set
|
|
jQuery._data( this, "__className__", this.className );
|
|
}
|
|
|
|
// toggle whole className
|
|
this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
|
|
}
|
|
});
|
|
},
|
|
|
|
hasClass: function( selector ) {
|
|
var className = " " + selector + " ";
|
|
for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
},
|
|
|
|
val: function( value ) {
|
|
var hooks, ret,
|
|
elem = this[0];
|
|
|
|
if ( !arguments.length ) {
|
|
if ( elem ) {
|
|
hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ];
|
|
|
|
if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
|
|
return ret;
|
|
}
|
|
|
|
ret = elem.value;
|
|
|
|
return typeof ret === "string" ?
|
|
// handle most common string cases
|
|
ret.replace(rreturn, "") :
|
|
// handle cases where value is null/undef or number
|
|
ret == null ? "" : ret;
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
var isFunction = jQuery.isFunction( value );
|
|
|
|
return this.each(function( i ) {
|
|
var self = jQuery(this), val;
|
|
|
|
if ( this.nodeType !== 1 ) {
|
|
return;
|
|
}
|
|
|
|
if ( isFunction ) {
|
|
val = value.call( this, i, self.val() );
|
|
} else {
|
|
val = value;
|
|
}
|
|
|
|
// Treat null/undefined as ""; convert numbers to string
|
|
if ( val == null ) {
|
|
val = "";
|
|
} else if ( typeof val === "number" ) {
|
|
val += "";
|
|
} else if ( jQuery.isArray( val ) ) {
|
|
val = jQuery.map(val, function ( value ) {
|
|
return value == null ? "" : value + "";
|
|
});
|
|
}
|
|
|
|
hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ];
|
|
|
|
// If set returns undefined, fall back to normal setting
|
|
if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
|
|
this.value = val;
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
jQuery.extend({
|
|
valHooks: {
|
|
option: {
|
|
get: function( elem ) {
|
|
// attributes.value is undefined in Blackberry 4.7 but
|
|
// uses .value. See #6932
|
|
var val = elem.attributes.value;
|
|
return !val || val.specified ? elem.value : elem.text;
|
|
}
|
|
},
|
|
select: {
|
|
get: function( elem ) {
|
|
var value,
|
|
index = elem.selectedIndex,
|
|
values = [],
|
|
options = elem.options,
|
|
one = elem.type === "select-one";
|
|
|
|
// Nothing was selected
|
|
if ( index < 0 ) {
|
|
return null;
|
|
}
|
|
|
|
// Loop through all the selected options
|
|
for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
|
|
var option = options[ i ];
|
|
|
|
// Don't return options that are disabled or in a disabled optgroup
|
|
if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
|
|
(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
|
|
|
|
// Get the specific value for the option
|
|
value = jQuery( option ).val();
|
|
|
|
// We don't need an array for one selects
|
|
if ( one ) {
|
|
return value;
|
|
}
|
|
|
|
// Multi-Selects return an array
|
|
values.push( value );
|
|
}
|
|
}
|
|
|
|
// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
|
|
if ( one && !values.length && options.length ) {
|
|
return jQuery( options[ index ] ).val();
|
|
}
|
|
|
|
return values;
|
|
},
|
|
|
|
set: function( elem, value ) {
|
|
var values = jQuery.makeArray( value );
|
|
|
|
jQuery(elem).find("option").each(function() {
|
|
this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
|
|
});
|
|
|
|
if ( !values.length ) {
|
|
elem.selectedIndex = -1;
|
|
}
|
|
return values;
|
|
}
|
|
}
|
|
},
|
|
|
|
attrFn: {
|
|
val: true,
|
|
css: true,
|
|
html: true,
|
|
text: true,
|
|
data: true,
|
|
width: true,
|
|
height: true,
|
|
offset: true
|
|
},
|
|
|
|
attrFix: {
|
|
// Always normalize to ensure hook usage
|
|
tabindex: "tabIndex"
|
|
},
|
|
|
|
attr: function( elem, name, value, pass ) {
|
|
var nType = elem.nodeType;
|
|
|
|
// don't get/set attributes on text, comment and attribute nodes
|
|
if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
|
|
return undefined;
|
|
}
|
|
|
|
if ( pass && name in jQuery.attrFn ) {
|
|
return jQuery( elem )[ name ]( value );
|
|
}
|
|
|
|
// Fallback to prop when attributes are not supported
|
|
if ( !("getAttribute" in elem) ) {
|
|
return jQuery.prop( elem, name, value );
|
|
}
|
|
|
|
var ret, hooks,
|
|
notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
|
|
|
|
// Normalize the name if needed
|
|
if ( notxml ) {
|
|
name = jQuery.attrFix[ name ] || name;
|
|
|
|
hooks = jQuery.attrHooks[ name ];
|
|
|
|
if ( !hooks ) {
|
|
// Use boolHook for boolean attributes
|
|
if ( rboolean.test( name ) ) {
|
|
|
|
hooks = boolHook;
|
|
|
|
// Use formHook for forms and if the name contains certain characters
|
|
} else if ( formHook && name !== "className" &&
|
|
(jQuery.nodeName( elem, "form" ) || rinvalidChar.test( name )) ) {
|
|
|
|
hooks = formHook;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( value !== undefined ) {
|
|
|
|
if ( value === null ) {
|
|
jQuery.removeAttr( elem, name );
|
|
return undefined;
|
|
|
|
} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
|
|
return ret;
|
|
|
|
} else {
|
|
elem.setAttribute( name, "" + value );
|
|
return value;
|
|
}
|
|
|
|
} else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
ret = elem.getAttribute( name );
|
|
|
|
// Non-existent attributes return null, we normalize to undefined
|
|
return ret === null ?
|
|
undefined :
|
|
ret;
|
|
}
|
|
},
|
|
|
|
removeAttr: function( elem, name ) {
|
|
var propName;
|
|
if ( elem.nodeType === 1 ) {
|
|
name = jQuery.attrFix[ name ] || name;
|
|
|
|
if ( jQuery.support.getSetAttribute ) {
|
|
// Use removeAttribute in browsers that support it
|
|
elem.removeAttribute( name );
|
|
} else {
|
|
jQuery.attr( elem, name, "" );
|
|
elem.removeAttributeNode( elem.getAttributeNode( name ) );
|
|
}
|
|
|
|
// Set corresponding property to false for boolean attributes
|
|
if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] || name) in elem ) {
|
|
elem[ propName ] = false;
|
|
}
|
|
}
|
|
},
|
|
|
|
attrHooks: {
|
|
type: {
|
|
set: function( elem, value ) {
|
|
// We can't allow the type property to be changed (since it causes problems in IE)
|
|
if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
|
|
jQuery.error( "type property can't be changed" );
|
|
} else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
|
|
// Setting the type on a radio button after the value resets the value in IE6-9
|
|
// Reset value to it's default in case type is set after value
|
|
// This is for element creation
|
|
var val = elem.value;
|
|
elem.setAttribute( "type", value );
|
|
if ( val ) {
|
|
elem.value = val;
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
},
|
|
tabIndex: {
|
|
get: function( elem ) {
|
|
// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
|
|
// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
|
|
var attributeNode = elem.getAttributeNode("tabIndex");
|
|
|
|
return attributeNode && attributeNode.specified ?
|
|
parseInt( attributeNode.value, 10 ) :
|
|
rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
|
|
0 :
|
|
undefined;
|
|
}
|
|
},
|
|
// Use the value property for back compat
|
|
// Use the formHook for button elements in IE6/7 (#1954)
|
|
value: {
|
|
get: function( elem, name ) {
|
|
if ( formHook && jQuery.nodeName( elem, "button" ) ) {
|
|
return formHook.get( elem, name );
|
|
}
|
|
return name in elem ?
|
|
elem.value :
|
|
null;
|
|
},
|
|
set: function( elem, value, name ) {
|
|
if ( formHook && jQuery.nodeName( elem, "button" ) ) {
|
|
return formHook.set( elem, value, name );
|
|
}
|
|
// Does not return so that setAttribute is also used
|
|
elem.value = value;
|
|
}
|
|
}
|
|
},
|
|
|
|
propFix: {
|
|
tabindex: "tabIndex",
|
|
readonly: "readOnly",
|
|
"for": "htmlFor",
|
|
"class": "className",
|
|
maxlength: "maxLength",
|
|
cellspacing: "cellSpacing",
|
|
cellpadding: "cellPadding",
|
|
rowspan: "rowSpan",
|
|
colspan: "colSpan",
|
|
usemap: "useMap",
|
|
frameborder: "frameBorder",
|
|
contenteditable: "contentEditable"
|
|
},
|
|
|
|
prop: function( elem, name, value ) {
|
|
var nType = elem.nodeType;
|
|
|
|
// don't get/set properties on text, comment and attribute nodes
|
|
if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
|
|
return undefined;
|
|
}
|
|
|
|
var ret, hooks,
|
|
notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
|
|
|
|
if ( notxml ) {
|
|
// Fix name and attach hooks
|
|
name = jQuery.propFix[ name ] || name;
|
|
hooks = jQuery.propHooks[ name ];
|
|
}
|
|
|
|
if ( value !== undefined ) {
|
|
if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
|
|
return ret;
|
|
|
|
} else {
|
|
return (elem[ name ] = value);
|
|
}
|
|
|
|
} else {
|
|
if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== undefined ) {
|
|
return ret;
|
|
|
|
} else {
|
|
return elem[ name ];
|
|
}
|
|
}
|
|
},
|
|
|
|
propHooks: {}
|
|
});
|
|
|
|
// Hook for boolean attributes
|
|
boolHook = {
|
|
get: function( elem, name ) {
|
|
// Align boolean attributes with corresponding properties
|
|
return jQuery.prop( elem, name ) ?
|
|
name.toLowerCase() :
|
|
undefined;
|
|
},
|
|
set: function( elem, value, name ) {
|
|
var propName;
|
|
if ( value === false ) {
|
|
// Remove boolean attributes when set to false
|
|
jQuery.removeAttr( elem, name );
|
|
} else {
|
|
// value is true since we know at this point it's type boolean and not false
|
|
// Set boolean attributes to the same name and set the DOM property
|
|
propName = jQuery.propFix[ name ] || name;
|
|
if ( propName in elem ) {
|
|
// Only set the IDL specifically if it already exists on the element
|
|
elem[ propName ] = true;
|
|
}
|
|
|
|
elem.setAttribute( name, name.toLowerCase() );
|
|
}
|
|
return name;
|
|
}
|
|
};
|
|
|
|
// IE6/7 do not support getting/setting some attributes with get/setAttribute
|
|
if ( !jQuery.support.getSetAttribute ) {
|
|
|
|
// propFix is more comprehensive and contains all fixes
|
|
jQuery.attrFix = jQuery.propFix;
|
|
|
|
// Use this for any attribute on a form in IE6/7
|
|
formHook = jQuery.attrHooks.name = jQuery.attrHooks.title = jQuery.valHooks.button = {
|
|
get: function( elem, name ) {
|
|
var ret;
|
|
ret = elem.getAttributeNode( name );
|
|
// Return undefined if nodeValue is empty string
|
|
return ret && ret.nodeValue !== "" ?
|
|
ret.nodeValue :
|
|
undefined;
|
|
},
|
|
set: function( elem, value, name ) {
|
|
// Check form objects in IE (multiple bugs related)
|
|
// Only use nodeValue if the attribute node exists on the form
|
|
var ret = elem.getAttributeNode( name );
|
|
if ( ret ) {
|
|
ret.nodeValue = value;
|
|
return value;
|
|
}
|
|
}
|
|
};
|
|
|
|
// Set width and height to auto instead of 0 on empty string( Bug #8150 )
|
|
// This is for removals
|
|
jQuery.each([ "width", "height" ], function( i, name ) {
|
|
jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
|
|
set: function( elem, value ) {
|
|
if ( value === "" ) {
|
|
elem.setAttribute( name, "auto" );
|
|
return value;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
|
|
// Some attributes require a special call on IE
|
|
if ( !jQuery.support.hrefNormalized ) {
|
|
jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
|
|
jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
|
|
get: function( elem ) {
|
|
var ret = elem.getAttribute( name, 2 );
|
|
return ret === null ? undefined : ret;
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
if ( !jQuery.support.style ) {
|
|
jQuery.attrHooks.style = {
|
|
get: function( elem ) {
|
|
// Return undefined in the case of empty string
|
|
// Normalize to lowercase since IE uppercases css property names
|
|
return elem.style.cssText.toLowerCase() || undefined;
|
|
},
|
|
set: function( elem, value ) {
|
|
return (elem.style.cssText = "" + value);
|
|
}
|
|
};
|
|
}
|
|
|
|
// Safari mis-reports the default selected property of an option
|
|
// Accessing the parent's selectedIndex property fixes it
|
|
if ( !jQuery.support.optSelected ) {
|
|
jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
|
|
get: function( elem ) {
|
|
var parent = elem.parentNode;
|
|
|
|
if ( parent ) {
|
|
parent.selectedIndex;
|
|
|
|
// Make sure that it also works with optgroups, see #5701
|
|
if ( parent.parentNode ) {
|
|
parent.parentNode.selectedIndex;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// Radios and checkboxes getter/setter
|
|
if ( !jQuery.support.checkOn ) {
|
|
jQuery.each([ "radio", "checkbox" ], function() {
|
|
jQuery.valHooks[ this ] = {
|
|
get: function( elem ) {
|
|
// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
|
|
return elem.getAttribute("value") === null ? "on" : elem.value;
|
|
}
|
|
};
|
|
});
|
|
}
|
|
jQuery.each([ "radio", "checkbox" ], function() {
|
|
jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
|
|
set: function( elem, value ) {
|
|
if ( jQuery.isArray( value ) ) {
|
|
return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
|
|
|
|
|
|
var rnamespaces = /\.(.*)$/,
|
|
rformElems = /^(?:textarea|input|select)$/i,
|
|
rperiod = /\./g,
|
|
rspaces = / /g,
|
|
rescape = /[^\w\s.|`]/g,
|
|
fcleanup = function( nm ) {
|
|
return nm.replace(rescape, "\\$&");
|
|
};
|
|
|
|
/*
|
|
* A number of helper functions used for managing events.
|
|
* Many of the ideas behind this code originated from
|
|
* Dean Edwards' addEvent library.
|
|
*/
|
|
jQuery.event = {
|
|
|
|
// Bind an event to an element
|
|
// Original by Dean Edwards
|
|
add: function( elem, types, handler, data ) {
|
|
if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
|
|
return;
|
|
}
|
|
|
|
if ( handler === false ) {
|
|
handler = returnFalse;
|
|
} else if ( !handler ) {
|
|
// Fixes bug #7229. Fix recommended by jdalton
|
|
return;
|
|
}
|
|
|
|
var handleObjIn, handleObj;
|
|
|
|
if ( handler.handler ) {
|
|
handleObjIn = handler;
|
|
handler = handleObjIn.handler;
|
|
}
|
|
|
|
// Make sure that the function being executed has a unique ID
|
|
if ( !handler.guid ) {
|
|
handler.guid = jQuery.guid++;
|
|
}
|
|
|
|
// Init the element's event structure
|
|
var elemData = jQuery._data( elem );
|
|
|
|
// If no elemData is found then we must be trying to bind to one of the
|
|
// banned noData elements
|
|
if ( !elemData ) {
|
|
return;
|
|
}
|
|
|
|
var events = elemData.events,
|
|
eventHandle = elemData.handle;
|
|
|
|
if ( !events ) {
|
|
elemData.events = events = {};
|
|
}
|
|
|
|
if ( !eventHandle ) {
|
|
elemData.handle = eventHandle = function( e ) {
|
|
// Discard the second event of a jQuery.event.trigger() and
|
|
// when an event is called after a page has unloaded
|
|
return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
|
|
jQuery.event.handle.apply( eventHandle.elem, arguments ) :
|
|
undefined;
|
|
};
|
|
}
|
|
|
|
// Add elem as a property of the handle function
|
|
// This is to prevent a memory leak with non-native events in IE.
|
|
eventHandle.elem = elem;
|
|
|
|
// Handle multiple events separated by a space
|
|
// jQuery(...).bind("mouseover mouseout", fn);
|
|
types = types.split(" ");
|
|
|
|
var type, i = 0, namespaces;
|
|
|
|
while ( (type = types[ i++ ]) ) {
|
|
handleObj = handleObjIn ?
|
|
jQuery.extend({}, handleObjIn) :
|
|
{ handler: handler, data: data };
|
|
|
|
// Namespaced event handlers
|
|
if ( type.indexOf(".") > -1 ) {
|
|
namespaces = type.split(".");
|
|
type = namespaces.shift();
|
|
handleObj.namespace = namespaces.slice(0).sort().join(".");
|
|
|
|
} else {
|
|
namespaces = [];
|
|
handleObj.namespace = "";
|
|
}
|
|
|
|
handleObj.type = type;
|
|
if ( !handleObj.guid ) {
|
|
handleObj.guid = handler.guid;
|
|
}
|
|
|
|
// Get the current list of functions bound to this event
|
|
var handlers = events[ type ],
|
|
special = jQuery.event.special[ type ] || {};
|
|
|
|
// Init the event handler queue
|
|
if ( !handlers ) {
|
|
handlers = events[ type ] = [];
|
|
|
|
// Check for a special event handler
|
|
// Only use addEventListener/attachEvent if the special
|
|
// events handler returns false
|
|
if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
|
|
// Bind the global event handler to the element
|
|
if ( elem.addEventListener ) {
|
|
elem.addEventListener( type, eventHandle, false );
|
|
|
|
} else if ( elem.attachEvent ) {
|
|
elem.attachEvent( "on" + type, eventHandle );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( special.add ) {
|
|
special.add.call( elem, handleObj );
|
|
|
|
if ( !handleObj.handler.guid ) {
|
|
handleObj.handler.guid = handler.guid;
|
|
}
|
|
}
|
|
|
|
// Add the function to the element's handler list
|
|
handlers.push( handleObj );
|
|
|
|
// Keep track of which events have been used, for event optimization
|
|
jQuery.event.global[ type ] = true;
|
|
}
|
|
|
|
// Nullify elem to prevent memory leaks in IE
|
|
elem = null;
|
|
},
|
|
|
|
global: {},
|
|
|
|
// Detach an event or set of events from an element
|
|
remove: function( elem, types, handler, pos ) {
|
|
// don't do events on text and comment nodes
|
|
if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
|
|
return;
|
|
}
|
|
|
|
if ( handler === false ) {
|
|
handler = returnFalse;
|
|
}
|
|
|
|
var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
|
|
elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
|
|
events = elemData && elemData.events;
|
|
|
|
if ( !elemData || !events ) {
|
|
return;
|
|
}
|
|
|
|
// types is actually an event object here
|
|
if ( types && types.type ) {
|
|
handler = types.handler;
|
|
types = types.type;
|
|
}
|
|
|
|
// Unbind all events for the element
|
|
if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
|
|
types = types || "";
|
|
|
|
for ( type in events ) {
|
|
jQuery.event.remove( elem, type + types );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Handle multiple events separated by a space
|
|
// jQuery(...).unbind("mouseover mouseout", fn);
|
|
types = types.split(" ");
|
|
|
|
while ( (type = types[ i++ ]) ) {
|
|
origType = type;
|
|
handleObj = null;
|
|
all = type.indexOf(".") < 0;
|
|
namespaces = [];
|
|
|
|
if ( !all ) {
|
|
// Namespaced event handlers
|
|
namespaces = type.split(".");
|
|
type = namespaces.shift();
|
|
|
|
namespace = new RegExp("(^|\\.)" +
|
|
jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
|
|
}
|
|
|
|
eventType = events[ type ];
|
|
|
|
if ( !eventType ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !handler ) {
|
|
for ( j = 0; j < eventType.length; j++ ) {
|
|
handleObj = eventType[ j ];
|
|
|
|
if ( all || namespace.test( handleObj.namespace ) ) {
|
|
jQuery.event.remove( elem, origType, handleObj.handler, j );
|
|
eventType.splice( j--, 1 );
|
|
}
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
special = jQuery.event.special[ type ] || {};
|
|
|
|
for ( j = pos || 0; j < eventType.length; j++ ) {
|
|
handleObj = eventType[ j ];
|
|
|
|
if ( handler.guid === handleObj.guid ) {
|
|
// remove the given handler for the given type
|
|
if ( all || namespace.test( handleObj.namespace ) ) {
|
|
if ( pos == null ) {
|
|
eventType.splice( j--, 1 );
|
|
}
|
|
|
|
if ( special.remove ) {
|
|
special.remove.call( elem, handleObj );
|
|
}
|
|
}
|
|
|
|
if ( pos != null ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// remove generic event handler if no more handlers exist
|
|
if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
|
|
if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
|
|
jQuery.removeEvent( elem, type, elemData.handle );
|
|
}
|
|
|
|
ret = null;
|
|
delete events[ type ];
|
|
}
|
|
}
|
|
|
|
// Remove the expando if it's no longer used
|
|
if ( jQuery.isEmptyObject( events ) ) {
|
|
var handle = elemData.handle;
|
|
if ( handle ) {
|
|
handle.elem = null;
|
|
}
|
|
|
|
delete elemData.events;
|
|
delete elemData.handle;
|
|
|
|
if ( jQuery.isEmptyObject( elemData ) ) {
|
|
jQuery.removeData( elem, undefined, true );
|
|
}
|
|
}
|
|
},
|
|
|
|
// Events that are safe to short-circuit if no handlers are attached.
|
|
// Native DOM events should not be added, they may have inline handlers.
|
|
customEvent: {
|
|
"getData": true,
|
|
"setData": true,
|
|
"changeData": true
|
|
},
|
|
|
|
trigger: function( event, data, elem, onlyHandlers ) {
|
|
// Event object or event type
|
|
var type = event.type || event,
|
|
namespaces = [],
|
|
exclusive;
|
|
|
|
if ( type.indexOf("!") >= 0 ) {
|
|
// Exclusive events trigger only for the exact event (no namespaces)
|
|
type = type.slice(0, -1);
|
|
exclusive = true;
|
|
}
|
|
|
|
if ( type.indexOf(".") >= 0 ) {
|
|
// Namespaced trigger; create a regexp to match event type in handle()
|
|
namespaces = type.split(".");
|
|
type = namespaces.shift();
|
|
namespaces.sort();
|
|
}
|
|
|
|
if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
|
|
// No jQuery handlers for this event type, and it can't have inline handlers
|
|
return;
|
|
}
|
|
|
|
// Caller can pass in an Event, Object, or just an event type string
|
|
event = typeof event === "object" ?
|
|
// jQuery.Event object
|
|
event[ jQuery.expando ] ? event :
|
|
// Object literal
|
|
new jQuery.Event( type, event ) :
|
|
// Just the event type (string)
|
|
new jQuery.Event( type );
|
|
|
|
event.type = type;
|
|
event.exclusive = exclusive;
|
|
event.namespace = namespaces.join(".");
|
|
event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)");
|
|
|
|
// triggerHandler() and global events don't bubble or run the default action
|
|
if ( onlyHandlers || !elem ) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
}
|
|
|
|
// Handle a global trigger
|
|
if ( !elem ) {
|
|
// TODO: Stop taunting the data cache; remove global events and always attach to document
|
|
jQuery.each( jQuery.cache, function() {
|
|
// internalKey variable is just used to make it easier to find
|
|
// and potentially change this stuff later; currently it just
|
|
// points to jQuery.expando
|
|
var internalKey = jQuery.expando,
|
|
internalCache = this[ internalKey ];
|
|
if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
|
|
jQuery.event.trigger( event, data, internalCache.handle.elem );
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
|
|
// Don't do events on text and comment nodes
|
|
if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
|
|
return;
|
|
}
|
|
|
|
// Clean up the event in case it is being reused
|
|
event.result = undefined;
|
|
event.target = elem;
|
|
|
|
// Clone any incoming data and prepend the event, creating the handler arg list
|
|
data = data != null ? jQuery.makeArray( data ) : [];
|
|
data.unshift( event );
|
|
|
|
var cur = elem,
|
|
// IE doesn't like method names with a colon (#3533, #8272)
|
|
ontype = type.indexOf(":") < 0 ? "on" + type : "";
|
|
|
|
// Fire event on the current element, then bubble up the DOM tree
|
|
do {
|
|
var handle = jQuery._data( cur, "handle" );
|
|
|
|
event.currentTarget = cur;
|
|
if ( handle ) {
|
|
handle.apply( cur, data );
|
|
}
|
|
|
|
// Trigger an inline bound script
|
|
if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) {
|
|
event.result = false;
|
|
event.preventDefault();
|
|
}
|
|
|
|
// Bubble up to document, then to window
|
|
cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window;
|
|
} while ( cur && !event.isPropagationStopped() );
|
|
|
|
// If nobody prevented the default action, do it now
|
|
if ( !event.isDefaultPrevented() ) {
|
|
var old,
|
|
special = jQuery.event.special[ type ] || {};
|
|
|
|
if ( (!special._default || special._default.call( elem.ownerDocument, event ) === false) &&
|
|
!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
|
|
|
|
// Call a native DOM method on the target with the same name name as the event.
|
|
// Can't use an .isFunction)() check here because IE6/7 fails that test.
|
|
// IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch.
|
|
try {
|
|
if ( ontype && elem[ type ] ) {
|
|
// Don't re-trigger an onFOO event when we call its FOO() method
|
|
old = elem[ ontype ];
|
|
|
|
if ( old ) {
|
|
elem[ ontype ] = null;
|
|
}
|
|
|
|
jQuery.event.triggered = type;
|
|
elem[ type ]();
|
|
}
|
|
} catch ( ieError ) {}
|
|
|
|
if ( old ) {
|
|
elem[ ontype ] = old;
|
|
}
|
|
|
|
jQuery.event.triggered = undefined;
|
|
}
|
|
}
|
|
|
|
return event.result;
|
|
},
|
|
|
|
handle: function( event ) {
|
|
event = jQuery.event.fix( event || window.event );
|
|
// Snapshot the handlers list since a called handler may add/remove events.
|
|
var handlers = ((jQuery._data( this, "events" ) || {})[ event.type ] || []).slice(0),
|
|
run_all = !event.exclusive && !event.namespace,
|
|
args = Array.prototype.slice.call( arguments, 0 );
|
|
|
|
// Use the fix-ed Event rather than the (read-only) native event
|
|
args[0] = event;
|
|
event.currentTarget = this;
|
|
|
|
for ( var j = 0, l = handlers.length; j < l; j++ ) {
|
|
var handleObj = handlers[ j ];
|
|
|
|
// Triggered event must 1) be non-exclusive and have no namespace, or
|
|
// 2) have namespace(s) a subset or equal to those in the bound event.
|
|
if ( run_all || event.namespace_re.test( handleObj.namespace ) ) {
|
|
// Pass in a reference to the handler function itself
|
|
// So that we can later remove it
|
|
event.handler = handleObj.handler;
|
|
event.data = handleObj.data;
|
|
event.handleObj = handleObj;
|
|
|
|
var ret = handleObj.handler.apply( this, args );
|
|
|
|
if ( ret !== undefined ) {
|
|
event.result = ret;
|
|
if ( ret === false ) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
}
|
|
}
|
|
|
|
if ( event.isImmediatePropagationStopped() ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return event.result;
|
|
},
|
|
|
|
props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
|
|
|
|
fix: function( event ) {
|
|
if ( event[ jQuery.expando ] ) {
|
|
return event;
|
|
}
|
|
|
|
// store a copy of the original event object
|
|
// and "clone" to set read-only properties
|
|
var originalEvent = event;
|
|
event = jQuery.Event( originalEvent );
|
|
|
|
for ( var i = this.props.length, prop; i; ) {
|
|
prop = this.props[ --i ];
|
|
event[ prop ] = originalEvent[ prop ];
|
|
}
|
|
|
|
// Fix target property, if necessary
|
|
if ( !event.target ) {
|
|
// Fixes #1925 where srcElement might not be defined either
|
|
event.target = event.srcElement || document;
|
|
}
|
|
|
|
// check if target is a textnode (safari)
|
|
if ( event.target.nodeType === 3 ) {
|
|
event.target = event.target.parentNode;
|
|
}
|
|
|
|
// Add relatedTarget, if necessary
|
|
if ( !event.relatedTarget && event.fromElement ) {
|
|
event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
|
|
}
|
|
|
|
// Calculate pageX/Y if missing and clientX/Y available
|
|
if ( event.pageX == null && event.clientX != null ) {
|
|
var eventDocument = event.target.ownerDocument || document,
|
|
doc = eventDocument.documentElement,
|
|
body = eventDocument.body;
|
|
|
|
event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
|
|
event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
|
|
}
|
|
|
|
// Add which for key events
|
|
if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
|
|
event.which = event.charCode != null ? event.charCode : event.keyCode;
|
|
}
|
|
|
|
// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
|
|
if ( !event.metaKey && event.ctrlKey ) {
|
|
event.metaKey = event.ctrlKey;
|
|
}
|
|
|
|
// Add which for click: 1 === left; 2 === middle; 3 === right
|
|
// Note: button is not normalized, so don't use it
|
|
if ( !event.which && event.button !== undefined ) {
|
|
event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
|
|
}
|
|
|
|
return event;
|
|
},
|
|
|
|
// Deprecated, use jQuery.guid instead
|
|
guid: 1E8,
|
|
|
|
// Deprecated, use jQuery.proxy instead
|
|
proxy: jQuery.proxy,
|
|
|
|
special: {
|
|
ready: {
|
|
// Make sure the ready event is setup
|
|
setup: jQuery.bindReady,
|
|
teardown: jQuery.noop
|
|
},
|
|
|
|
live: {
|
|
add: function( handleObj ) {
|
|
jQuery.event.add( this,
|
|
liveConvert( handleObj.origType, handleObj.selector ),
|
|
jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
|
|
},
|
|
|
|
remove: function( handleObj ) {
|
|
jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
|
|
}
|
|
},
|
|
|
|
beforeunload: {
|
|
setup: function( data, namespaces, eventHandle ) {
|
|
// We only want to do this special case on windows
|
|
if ( jQuery.isWindow( this ) ) {
|
|
this.onbeforeunload = eventHandle;
|
|
}
|
|
},
|
|
|
|
teardown: function( namespaces, eventHandle ) {
|
|
if ( this.onbeforeunload === eventHandle ) {
|
|
this.onbeforeunload = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
jQuery.removeEvent = document.removeEventListener ?
|
|
function( elem, type, handle ) {
|
|
if ( elem.removeEventListener ) {
|
|
elem.removeEventListener( type, handle, false );
|
|
}
|
|
} :
|
|
function( elem, type, handle ) {
|
|
if ( elem.detachEvent ) {
|
|
elem.detachEvent( "on" + type, handle );
|
|
}
|
|
};
|
|
|
|
jQuery.Event = function( src, props ) {
|
|
// Allow instantiation without the 'new' keyword
|
|
if ( !this.preventDefault ) {
|
|
return new jQuery.Event( src, props );
|
|
}
|
|
|
|
// Event object
|
|
if ( src && src.type ) {
|
|
this.originalEvent = src;
|
|
this.type = src.type;
|
|
|
|
// Events bubbling up the document may have been marked as prevented
|
|
// by a handler lower down the tree; reflect the correct value.
|
|
this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
|
|
src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
|
|
|
|
// Event type
|
|
} else {
|
|
this.type = src;
|
|
}
|
|
|
|
// Put explicitly provided properties onto the event object
|
|
if ( props ) {
|
|
jQuery.extend( this, props );
|
|
}
|
|
|
|
// timeStamp is buggy for some events on Firefox(#3843)
|
|
// So we won't rely on the native value
|
|
this.timeStamp = jQuery.now();
|
|
|
|
// Mark it as fixed
|
|
this[ jQuery.expando ] = true;
|
|
};
|
|
|
|
function returnFalse() {
|
|
return false;
|
|
}
|
|
function returnTrue() {
|
|
return true;
|
|
}
|
|
|
|
// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
|
|
// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
|
|
jQuery.Event.prototype = {
|
|
preventDefault: function() {
|
|
this.isDefaultPrevented = returnTrue;
|
|
|
|
var e = this.originalEvent;
|
|
if ( !e ) {
|
|
return;
|
|
}
|
|
|
|
// if preventDefault exists run it on the original event
|
|
if ( e.preventDefault ) {
|
|
e.preventDefault();
|
|
|
|
// otherwise set the returnValue property of the original event to false (IE)
|
|
} else {
|
|
e.returnValue = false;
|
|
}
|
|
},
|
|
stopPropagation: function() {
|
|
this.isPropagationStopped = returnTrue;
|
|
|
|
var e = this.originalEvent;
|
|
if ( !e ) {
|
|
return;
|
|
}
|
|
// if stopPropagation exists run it on the original event
|
|
if ( e.stopPropagation ) {
|
|
e.stopPropagation();
|
|
}
|
|
// otherwise set the cancelBubble property of the original event to true (IE)
|
|
e.cancelBubble = true;
|
|
},
|
|
stopImmediatePropagation: function() {
|
|
this.isImmediatePropagationStopped = returnTrue;
|
|
this.stopPropagation();
|
|
},
|
|
isDefaultPrevented: returnFalse,
|
|
isPropagationStopped: returnFalse,
|
|
isImmediatePropagationStopped: returnFalse
|
|
};
|
|
|
|
// Checks if an event happened on an element within another element
|
|
// Used in jQuery.event.special.mouseenter and mouseleave handlers
|
|
var withinElement = function( event ) {
|
|
|
|
// Check if mouse(over|out) are still within the same parent element
|
|
var related = event.relatedTarget,
|
|
inside = false,
|
|
eventType = event.type;
|
|
|
|
event.type = event.data;
|
|
|
|
if ( related !== this ) {
|
|
|
|
if ( related ) {
|
|
inside = jQuery.contains( this, related );
|
|
}
|
|
|
|
if ( !inside ) {
|
|
|
|
jQuery.event.handle.apply( this, arguments );
|
|
|
|
event.type = eventType;
|
|
}
|
|
}
|
|
},
|
|
|
|
// In case of event delegation, we only need to rename the event.type,
|
|
// liveHandler will take care of the rest.
|
|
delegate = function( event ) {
|
|
event.type = event.data;
|
|
jQuery.event.handle.apply( this, arguments );
|
|
};
|
|
|
|
// Create mouseenter and mouseleave events
|
|
jQuery.each({
|
|
mouseenter: "mouseover",
|
|
mouseleave: "mouseout"
|
|
}, function( orig, fix ) {
|
|
jQuery.event.special[ orig ] = {
|
|
setup: function( data ) {
|
|
jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
|
|
},
|
|
teardown: function( data ) {
|
|
jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
|
|
}
|
|
};
|
|
});
|
|
|
|
// submit delegation
|
|
if ( !jQuery.support.submitBubbles ) {
|
|
|
|
jQuery.event.special.submit = {
|
|
setup: function( data, namespaces ) {
|
|
if ( !jQuery.nodeName( this, "form" ) ) {
|
|
jQuery.event.add(this, "click.specialSubmit", function( e ) {
|
|
var elem = e.target,
|
|
type = elem.type;
|
|
|
|
if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
|
|
trigger( "submit", this, arguments );
|
|
}
|
|
});
|
|
|
|
jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
|
|
var elem = e.target,
|
|
type = elem.type;
|
|
|
|
if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
|
|
trigger( "submit", this, arguments );
|
|
}
|
|
});
|
|
|
|
} else {
|
|
return false;
|
|
}
|
|
},
|
|
|
|
teardown: function( namespaces ) {
|
|
jQuery.event.remove( this, ".specialSubmit" );
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
// change delegation, happens here so we have bind.
|
|
if ( !jQuery.support.changeBubbles ) {
|
|
|
|
var changeFilters,
|
|
|
|
getVal = function( elem ) {
|
|
var type = elem.type, val = elem.value;
|
|
|
|
if ( type === "radio" || type === "checkbox" ) {
|
|
val = elem.checked;
|
|
|
|
} else if ( type === "select-multiple" ) {
|
|
val = elem.selectedIndex > -1 ?
|
|
jQuery.map( elem.options, function( elem ) {
|
|
return elem.selected;
|
|
}).join("-") :
|
|
"";
|
|
|
|
} else if ( jQuery.nodeName( elem, "select" ) ) {
|
|
val = elem.selectedIndex;
|
|
}
|
|
|
|
return val;
|
|
},
|
|
|
|
testChange = function testChange( e ) {
|
|
var elem = e.target, data, val;
|
|
|
|
if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
|
|
return;
|
|
}
|
|
|
|
data = jQuery._data( elem, "_change_data" );
|
|
val = getVal(elem);
|
|
|
|
// the current data will be also retrieved by beforeactivate
|
|
if ( e.type !== "focusout" || elem.type !== "radio" ) {
|
|
jQuery._data( elem, "_change_data", val );
|
|
}
|
|
|
|
if ( data === undefined || val === data ) {
|
|
return;
|
|
}
|
|
|
|
if ( data != null || val ) {
|
|
e.type = "change";
|
|
e.liveFired = undefined;
|
|
jQuery.event.trigger( e, arguments[1], elem );
|
|
}
|
|
};
|
|
|
|
jQuery.event.special.change = {
|
|
filters: {
|
|
focusout: testChange,
|
|
|
|
beforedeactivate: testChange,
|
|
|
|
click: function( e ) {
|
|
var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
|
|
|
|
if ( type === "radio" || type === "checkbox" || jQuery.nodeName( elem, "select" ) ) {
|
|
testChange.call( this, e );
|
|
}
|
|
},
|
|
|
|
// Change has to be called before submit
|
|
// Keydown will be called before keypress, which is used in submit-event delegation
|
|
keydown: function( e ) {
|
|
var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
|
|
|
|
if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) ||
|
|
(e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
|
|
type === "select-multiple" ) {
|
|
testChange.call( this, e );
|
|
}
|
|
},
|
|
|
|
// Beforeactivate happens also before the previous element is blurred
|
|
// with this event you can't trigger a change event, but you can store
|
|
// information
|
|
beforeactivate: function( e ) {
|
|
var elem = e.target;
|
|
jQuery._data( elem, "_change_data", getVal(elem) );
|
|
}
|
|
},
|
|
|
|
setup: function( data, namespaces ) {
|
|
if ( this.type === "file" ) {
|
|
return false;
|
|
}
|
|
|
|
for ( var type in changeFilters ) {
|
|
jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
|
|
}
|
|
|
|
return rformElems.test( this.nodeName );
|
|
},
|
|
|
|
teardown: function( namespaces ) {
|
|
jQuery.event.remove( this, ".specialChange" );
|
|
|
|
return rformElems.test( this.nodeName );
|
|
}
|
|
};
|
|
|
|
changeFilters = jQuery.event.special.change.filters;
|
|
|
|
// Handle when the input is .focus()'d
|
|
changeFilters.focus = changeFilters.beforeactivate;
|
|
}
|
|
|
|
function trigger( type, elem, args ) {
|
|
// Piggyback on a donor event to simulate a different one.
|
|
// Fake originalEvent to avoid donor's stopPropagation, but if the
|
|
// simulated event prevents default then we do the same on the donor.
|
|
// Don't pass args or remember liveFired; they apply to the donor event.
|
|
var event = jQuery.extend( {}, args[ 0 ] );
|
|
event.type = type;
|
|
event.originalEvent = {};
|
|
event.liveFired = undefined;
|
|
jQuery.event.handle.call( elem, event );
|
|
if ( event.isDefaultPrevented() ) {
|
|
args[ 0 ].preventDefault();
|
|
}
|
|
}
|
|
|
|
// Create "bubbling" focus and blur events
|
|
if ( !jQuery.support.focusinBubbles ) {
|
|
jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
|
|
|
|
// Attach a single capturing handler while someone wants focusin/focusout
|
|
var attaches = 0;
|
|
|
|
jQuery.event.special[ fix ] = {
|
|
setup: function() {
|
|
if ( attaches++ === 0 ) {
|
|
document.addEventListener( orig, handler, true );
|
|
}
|
|
},
|
|
teardown: function() {
|
|
if ( --attaches === 0 ) {
|
|
document.removeEventListener( orig, handler, true );
|
|
}
|
|
}
|
|
};
|
|
|
|
function handler( donor ) {
|
|
// Donor event is always a native one; fix it and switch its type.
|
|
// Let focusin/out handler cancel the donor focus/blur event.
|
|
var e = jQuery.event.fix( donor );
|
|
e.type = fix;
|
|
e.originalEvent = {};
|
|
jQuery.event.trigger( e, null, e.target );
|
|
if ( e.isDefaultPrevented() ) {
|
|
donor.preventDefault();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
jQuery.each(["bind", "one"], function( i, name ) {
|
|
jQuery.fn[ name ] = function( type, data, fn ) {
|
|
var handler;
|
|
|
|
// Handle object literals
|
|
if ( typeof type === "object" ) {
|
|
for ( var key in type ) {
|
|
this[ name ](key, data, type[key], fn);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
if ( arguments.length === 2 || data === false ) {
|
|
fn = data;
|
|
data = undefined;
|
|
}
|
|
|
|
if ( name === "one" ) {
|
|
handler = function( event ) {
|
|
jQuery( this ).unbind( event, handler );
|
|
return fn.apply( this, arguments );
|
|
};
|
|
handler.guid = fn.guid || jQuery.guid++;
|
|
} else {
|
|
handler = fn;
|
|
}
|
|
|
|
if ( type === "unload" && name !== "one" ) {
|
|
this.one( type, data, fn );
|
|
|
|
} else {
|
|
for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
jQuery.event.add( this[i], type, handler, data );
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
});
|
|
|
|
jQuery.fn.extend({
|
|
unbind: function( type, fn ) {
|
|
// Handle object literals
|
|
if ( typeof type === "object" && !type.preventDefault ) {
|
|
for ( var key in type ) {
|
|
this.unbind(key, type[key]);
|
|
}
|
|
|
|
} else {
|
|
for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
jQuery.event.remove( this[i], type, fn );
|
|
}
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
delegate: function( selector, types, data, fn ) {
|
|
return this.live( types, data, fn, selector );
|
|
},
|
|
|
|
undelegate: function( selector, types, fn ) {
|
|
if ( arguments.length === 0 ) {
|
|
return this.unbind( "live" );
|
|
|
|
} else {
|
|
return this.die( types, null, fn, selector );
|
|
}
|
|
},
|
|
|
|
trigger: function( type, data ) {
|
|
return this.each(function() {
|
|
jQuery.event.trigger( type, data, this );
|
|
});
|
|
},
|
|
|
|
triggerHandler: function( type, data ) {
|
|
if ( this[0] ) {
|
|
return jQuery.event.trigger( type, data, this[0], true );
|
|
}
|
|
},
|
|
|
|
toggle: function( fn ) {
|
|
// Save reference to arguments for access in closure
|
|
var args = arguments,
|
|
guid = fn.guid || jQuery.guid++,
|
|
i = 0,
|
|
toggler = function( event ) {
|
|
// Figure out which function to execute
|
|
var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
|
|
jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
|
|
|
|
// Make sure that clicks stop
|
|
event.preventDefault();
|
|
|
|
// and execute the function
|
|
return args[ lastToggle ].apply( this, arguments ) || false;
|
|
};
|
|
|
|
// link all the functions, so any of them can unbind this click handler
|
|
toggler.guid = guid;
|
|
while ( i < args.length ) {
|
|
args[ i++ ].guid = guid;
|
|
}
|
|
|
|
return this.click( toggler );
|
|
},
|
|
|
|
hover: function( fnOver, fnOut ) {
|
|
return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
|
|
}
|
|
});
|
|
|
|
var liveMap = {
|
|
focus: "focusin",
|
|
blur: "focusout",
|
|
mouseenter: "mouseover",
|
|
mouseleave: "mouseout"
|
|
};
|
|
|
|
jQuery.each(["live", "die"], function( i, name ) {
|
|
jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
|
|
var type, i = 0, match, namespaces, preType,
|
|
selector = origSelector || this.selector,
|
|
context = origSelector ? this : jQuery( this.context );
|
|
|
|
if ( typeof types === "object" && !types.preventDefault ) {
|
|
for ( var key in types ) {
|
|
context[ name ]( key, data, types[key], selector );
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
if ( name === "die" && !types &&
|
|
origSelector && origSelector.charAt(0) === "." ) {
|
|
|
|
context.unbind( origSelector );
|
|
|
|
return this;
|
|
}
|
|
|
|
if ( data === false || jQuery.isFunction( data ) ) {
|
|
fn = data || returnFalse;
|
|
data = undefined;
|
|
}
|
|
|
|
types = (types || "").split(" ");
|
|
|
|
while ( (type = types[ i++ ]) != null ) {
|
|
match = rnamespaces.exec( type );
|
|
namespaces = "";
|
|
|
|
if ( match ) {
|
|
namespaces = match[0];
|
|
type = type.replace( rnamespaces, "" );
|
|
}
|
|
|
|
if ( type === "hover" ) {
|
|
types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
|
|
continue;
|
|
}
|
|
|
|
preType = type;
|
|
|
|
if ( liveMap[ type ] ) {
|
|
types.push( liveMap[ type ] + namespaces );
|
|
type = type + namespaces;
|
|
|
|
} else {
|
|
type = (liveMap[ type ] || type) + namespaces;
|
|
}
|
|
|
|
if ( name === "live" ) {
|
|
// bind live handler
|
|
for ( var j = 0, l = context.length; j < l; j++ ) {
|
|
jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
|
|
{ data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
|
|
}
|
|
|
|
} else {
|
|
// unbind live handler
|
|
context.unbind( "live." + liveConvert( type, selector ), fn );
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
});
|
|
|
|
function liveHandler( event ) {
|
|
var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
|
|
elems = [],
|
|
selectors = [],
|
|
events = jQuery._data( this, "events" );
|
|
|
|
// Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
|
|
if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
|
|
return;
|
|
}
|
|
|
|
if ( event.namespace ) {
|
|
namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
|
|
}
|
|
|
|
event.liveFired = this;
|
|
|
|
var live = events.live.slice(0);
|
|
|
|
for ( j = 0; j < live.length; j++ ) {
|
|
handleObj = live[j];
|
|
|
|
if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
|
|
selectors.push( handleObj.selector );
|
|
|
|
} else {
|
|
live.splice( j--, 1 );
|
|
}
|
|
}
|
|
|
|
match = jQuery( event.target ).closest( selectors, event.currentTarget );
|
|
|
|
for ( i = 0, l = match.length; i < l; i++ ) {
|
|
close = match[i];
|
|
|
|
for ( j = 0; j < live.length; j++ ) {
|
|
handleObj = live[j];
|
|
|
|
if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) && !close.elem.disabled ) {
|
|
elem = close.elem;
|
|
related = null;
|
|
|
|
// Those two events require additional checking
|
|
if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
|
|
event.type = handleObj.preType;
|
|
related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
|
|
|
|
// Make sure not to accidentally match a child element with the same selector
|
|
if ( related && jQuery.contains( elem, related ) ) {
|
|
related = elem;
|
|
}
|
|
}
|
|
|
|
if ( !related || related !== elem ) {
|
|
elems.push({ elem: elem, handleObj: handleObj, level: close.level });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( i = 0, l = elems.length; i < l; i++ ) {
|
|
match = elems[i];
|
|
|
|
if ( maxLevel && match.level > maxLevel ) {
|
|
break;
|
|
}
|
|
|
|
event.currentTarget = match.elem;
|
|
event.data = match.handleObj.data;
|
|
event.handleObj = match.handleObj;
|
|
|
|
ret = match.handleObj.origHandler.apply( match.elem, arguments );
|
|
|
|
if ( ret === false || event.isPropagationStopped() ) {
|
|
maxLevel = match.level;
|
|
|
|
if ( ret === false ) {
|
|
stop = false;
|
|
}
|
|
if ( event.isImmediatePropagationStopped() ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return stop;
|
|
}
|
|
|
|
function liveConvert( type, selector ) {
|
|
return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&");
|
|
}
|
|
|
|
jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
|
|
"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
|
|
"change select submit keydown keypress keyup error").split(" "), function( i, name ) {
|
|
|
|
// Handle event binding
|
|
jQuery.fn[ name ] = function( data, fn ) {
|
|
if ( fn == null ) {
|
|
fn = data;
|
|
data = null;
|
|
}
|
|
|
|
return arguments.length > 0 ?
|
|
this.bind( name, data, fn ) :
|
|
this.trigger( name );
|
|
};
|
|
|
|
if ( jQuery.attrFn ) {
|
|
jQuery.attrFn[ name ] = true;
|
|
}
|
|
});
|
|
|
|
|
|
|
|
/*!
|
|
* Sizzle CSS Selector Engine
|
|
* Copyright 2011, The Dojo Foundation
|
|
* Released under the MIT, BSD, and GPL Licenses.
|
|
* More information: http://sizzlejs.com/
|
|
*/
|
|
(function(){
|
|
|
|
var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
|
|
done = 0,
|
|
toString = Object.prototype.toString,
|
|
hasDuplicate = false,
|
|
baseHasDuplicate = true,
|
|
rBackslash = /\\/g,
|
|
rNonWord = /\W/;
|
|
|
|
// Here we check if the JavaScript engine is using some sort of
|
|
// optimization where it does not always call our comparision
|
|
// function. If that is the case, discard the hasDuplicate value.
|
|
// Thus far that includes Google Chrome.
|
|
[0, 0].sort(function() {
|
|
baseHasDuplicate = false;
|
|
return 0;
|
|
});
|
|
|
|
var Sizzle = function( selector, context, results, seed ) {
|
|
results = results || [];
|
|
context = context || document;
|
|
|
|
var origContext = context;
|
|
|
|
if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
|
|
return [];
|
|
}
|
|
|
|
if ( !selector || typeof selector !== "string" ) {
|
|
return results;
|
|
}
|
|
|
|
var m, set, checkSet, extra, ret, cur, pop, i,
|
|
prune = true,
|
|
contextXML = Sizzle.isXML( context ),
|
|
parts = [],
|
|
soFar = selector;
|
|
|
|
// Reset the position of the chunker regexp (start from head)
|
|
do {
|
|
chunker.exec( "" );
|
|
m = chunker.exec( soFar );
|
|
|
|
if ( m ) {
|
|
soFar = m[3];
|
|
|
|
parts.push( m[1] );
|
|
|
|
if ( m[2] ) {
|
|
extra = m[3];
|
|
break;
|
|
}
|
|
}
|
|
} while ( m );
|
|
|
|
if ( parts.length > 1 && origPOS.exec( selector ) ) {
|
|
|
|
if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
|
|
set = posProcess( parts[0] + parts[1], context );
|
|
|
|
} else {
|
|
set = Expr.relative[ parts[0] ] ?
|
|
[ context ] :
|
|
Sizzle( parts.shift(), context );
|
|
|
|
while ( parts.length ) {
|
|
selector = parts.shift();
|
|
|
|
if ( Expr.relative[ selector ] ) {
|
|
selector += parts.shift();
|
|
}
|
|
|
|
set = posProcess( selector, set );
|
|
}
|
|
}
|
|
|
|
} else {
|
|
// Take a shortcut and set the context if the root selector is an ID
|
|
// (but not if it'll be faster if the inner selector is an ID)
|
|
if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
|
|
Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
|
|
|
|
ret = Sizzle.find( parts.shift(), context, contextXML );
|
|
context = ret.expr ?
|
|
Sizzle.filter( ret.expr, ret.set )[0] :
|
|
ret.set[0];
|
|
}
|
|
|
|
if ( context ) {
|
|
ret = seed ?
|
|
{ expr: parts.pop(), set: makeArray(seed) } :
|
|
Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
|
|
|
|
set = ret.expr ?
|
|
Sizzle.filter( ret.expr, ret.set ) :
|
|
ret.set;
|
|
|
|
if ( parts.length > 0 ) {
|
|
checkSet = makeArray( set );
|
|
|
|
} else {
|
|
prune = false;
|
|
}
|
|
|
|
while ( parts.length ) {
|
|
cur = parts.pop();
|
|
pop = cur;
|
|
|
|
if ( !Expr.relative[ cur ] ) {
|
|
cur = "";
|
|
} else {
|
|
pop = parts.pop();
|
|
}
|
|
|
|
if ( pop == null ) {
|
|
pop = context;
|
|
}
|
|
|
|
Expr.relative[ cur ]( checkSet, pop, contextXML );
|
|
}
|
|
|
|
} else {
|
|
checkSet = parts = [];
|
|
}
|
|
}
|
|
|
|
if ( !checkSet ) {
|
|
checkSet = set;
|
|
}
|
|
|
|
if ( !checkSet ) {
|
|
Sizzle.error( cur || selector );
|
|
}
|
|
|
|
if ( toString.call(checkSet) === "[object Array]" ) {
|
|
if ( !prune ) {
|
|
results.push.apply( results, checkSet );
|
|
|
|
} else if ( context && context.nodeType === 1 ) {
|
|
for ( i = 0; checkSet[i] != null; i++ ) {
|
|
if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
|
|
results.push( set[i] );
|
|
}
|
|
}
|
|
|
|
} else {
|
|
for ( i = 0; checkSet[i] != null; i++ ) {
|
|
if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
|
|
results.push( set[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
makeArray( checkSet, results );
|
|
}
|
|
|
|
if ( extra ) {
|
|
Sizzle( extra, origContext, results, seed );
|
|
Sizzle.uniqueSort( results );
|
|
}
|
|
|
|
return results;
|
|
};
|
|
|
|
Sizzle.uniqueSort = function( results ) {
|
|
if ( sortOrder ) {
|
|
hasDuplicate = baseHasDuplicate;
|
|
results.sort( sortOrder );
|
|
|
|
if ( hasDuplicate ) {
|
|
for ( var i = 1; i < results.length; i++ ) {
|
|
if ( results[i] === results[ i - 1 ] ) {
|
|
results.splice( i--, 1 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return results;
|
|
};
|
|
|
|
Sizzle.matches = function( expr, set ) {
|
|
return Sizzle( expr, null, null, set );
|
|
};
|
|
|
|
Sizzle.matchesSelector = function( node, expr ) {
|
|
return Sizzle( expr, null, null, [node] ).length > 0;
|
|
};
|
|
|
|
Sizzle.find = function( expr, context, isXML ) {
|
|
var set;
|
|
|
|
if ( !expr ) {
|
|
return [];
|
|
}
|
|
|
|
for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
|
|
var match,
|
|
type = Expr.order[i];
|
|
|
|
if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
|
|
var left = match[1];
|
|
match.splice( 1, 1 );
|
|
|
|
if ( left.substr( left.length - 1 ) !== "\\" ) {
|
|
match[1] = (match[1] || "").replace( rBackslash, "" );
|
|
set = Expr.find[ type ]( match, context, isXML );
|
|
|
|
if ( set != null ) {
|
|
expr = expr.replace( Expr.match[ type ], "" );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !set ) {
|
|
set = typeof context.getElementsByTagName !== "undefined" ?
|
|
context.getElementsByTagName( "*" ) :
|
|
[];
|
|
}
|
|
|
|
return { set: set, expr: expr };
|
|
};
|
|
|
|
Sizzle.filter = function( expr, set, inplace, not ) {
|
|
var match, anyFound,
|
|
old = expr,
|
|
result = [],
|
|
curLoop = set,
|
|
isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
|
|
|
|
while ( expr && set.length ) {
|
|
for ( var type in Expr.filter ) {
|
|
if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
|
|
var found, item,
|
|
filter = Expr.filter[ type ],
|
|
left = match[1];
|
|
|
|
anyFound = false;
|
|
|
|
match.splice(1,1);
|
|
|
|
if ( left.substr( left.length - 1 ) === "\\" ) {
|
|
continue;
|
|
}
|
|
|
|
if ( curLoop === result ) {
|
|
result = [];
|
|
}
|
|
|
|
if ( Expr.preFilter[ type ] ) {
|
|
match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
|
|
|
|
if ( !match ) {
|
|
anyFound = found = true;
|
|
|
|
} else if ( match === true ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( match ) {
|
|
for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
|
|
if ( item ) {
|
|
found = filter( item, match, i, curLoop );
|
|
var pass = not ^ !!found;
|
|
|
|
if ( inplace && found != null ) {
|
|
if ( pass ) {
|
|
anyFound = true;
|
|
|
|
} else {
|
|
curLoop[i] = false;
|
|
}
|
|
|
|
} else if ( pass ) {
|
|
result.push( item );
|
|
anyFound = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( found !== undefined ) {
|
|
if ( !inplace ) {
|
|
curLoop = result;
|
|
}
|
|
|
|
expr = expr.replace( Expr.match[ type ], "" );
|
|
|
|
if ( !anyFound ) {
|
|
return [];
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Improper expression
|
|
if ( expr === old ) {
|
|
if ( anyFound == null ) {
|
|
Sizzle.error( expr );
|
|
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
old = expr;
|
|
}
|
|
|
|
return curLoop;
|
|
};
|
|
|
|
Sizzle.error = function( msg ) {
|
|
throw "Syntax error, unrecognized expression: " + msg;
|
|
};
|
|
|
|
var Expr = Sizzle.selectors = {
|
|
order: [ "ID", "NAME", "TAG" ],
|
|
|
|
match: {
|
|
ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
|
|
CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
|
|
NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
|
|
ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
|
|
TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
|
|
CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
|
|
POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
|
|
PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
|
|
},
|
|
|
|
leftMatch: {},
|
|
|
|
attrMap: {
|
|
"class": "className",
|
|
"for": "htmlFor"
|
|
},
|
|
|
|
attrHandle: {
|
|
href: function( elem ) {
|
|
return elem.getAttribute( "href" );
|
|
},
|
|
type: function( elem ) {
|
|
return elem.getAttribute( "type" );
|
|
}
|
|
},
|
|
|
|
relative: {
|
|
"+": function(checkSet, part){
|
|
var isPartStr = typeof part === "string",
|
|
isTag = isPartStr && !rNonWord.test( part ),
|
|
isPartStrNotTag = isPartStr && !isTag;
|
|
|
|
if ( isTag ) {
|
|
part = part.toLowerCase();
|
|
}
|
|
|
|
for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
|
|
if ( (elem = checkSet[i]) ) {
|
|
while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
|
|
|
|
checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
|
|
elem || false :
|
|
elem === part;
|
|
}
|
|
}
|
|
|
|
if ( isPartStrNotTag ) {
|
|
Sizzle.filter( part, checkSet, true );
|
|
}
|
|
},
|
|
|
|
">": function( checkSet, part ) {
|
|
var elem,
|
|
isPartStr = typeof part === "string",
|
|
i = 0,
|
|
l = checkSet.length;
|
|
|
|
if ( isPartStr && !rNonWord.test( part ) ) {
|
|
part = part.toLowerCase();
|
|
|
|
for ( ; i < l; i++ ) {
|
|
elem = checkSet[i];
|
|
|
|
if ( elem ) {
|
|
var parent = elem.parentNode;
|
|
checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
for ( ; i < l; i++ ) {
|
|
elem = checkSet[i];
|
|
|
|
if ( elem ) {
|
|
checkSet[i] = isPartStr ?
|
|
elem.parentNode :
|
|
elem.parentNode === part;
|
|
}
|
|
}
|
|
|
|
if ( isPartStr ) {
|
|
Sizzle.filter( part, checkSet, true );
|
|
}
|
|
}
|
|
},
|
|
|
|
"": function(checkSet, part, isXML){
|
|
var nodeCheck,
|
|
doneName = done++,
|
|
checkFn = dirCheck;
|
|
|
|
if ( typeof part === "string" && !rNonWord.test( part ) ) {
|
|
part = part.toLowerCase();
|
|
nodeCheck = part;
|
|
checkFn = dirNodeCheck;
|
|
}
|
|
|
|
checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
|
|
},
|
|
|
|
"~": function( checkSet, part, isXML ) {
|
|
var nodeCheck,
|
|
doneName = done++,
|
|
checkFn = dirCheck;
|
|
|
|
if ( typeof part === "string" && !rNonWord.test( part ) ) {
|
|
part = part.toLowerCase();
|
|
nodeCheck = part;
|
|
checkFn = dirNodeCheck;
|
|
}
|
|
|
|
checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
|
|
}
|
|
},
|
|
|
|
find: {
|
|
ID: function( match, context, isXML ) {
|
|
if ( typeof context.getElementById !== "undefined" && !isXML ) {
|
|
var m = context.getElementById(match[1]);
|
|
// Check parentNode to catch when Blackberry 4.6 returns
|
|
// nodes that are no longer in the document #6963
|
|
return m && m.parentNode ? [m] : [];
|
|
}
|
|
},
|
|
|
|
NAME: function( match, context ) {
|
|
if ( typeof context.getElementsByName !== "undefined" ) {
|
|
var ret = [],
|
|
results = context.getElementsByName( match[1] );
|
|
|
|
for ( var i = 0, l = results.length; i < l; i++ ) {
|
|
if ( results[i].getAttribute("name") === match[1] ) {
|
|
ret.push( results[i] );
|
|
}
|
|
}
|
|
|
|
return ret.length === 0 ? null : ret;
|
|
}
|
|
},
|
|
|
|
TAG: function( match, context ) {
|
|
if ( typeof context.getElementsByTagName !== "undefined" ) {
|
|
return context.getElementsByTagName( match[1] );
|
|
}
|
|
}
|
|
},
|
|
preFilter: {
|
|
CLASS: function( match, curLoop, inplace, result, not, isXML ) {
|
|
match = " " + match[1].replace( rBackslash, "" ) + " ";
|
|
|
|
if ( isXML ) {
|
|
return match;
|
|
}
|
|
|
|
for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
|
|
if ( elem ) {
|
|
if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
|
|
if ( !inplace ) {
|
|
result.push( elem );
|
|
}
|
|
|
|
} else if ( inplace ) {
|
|
curLoop[i] = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
},
|
|
|
|
ID: function( match ) {
|
|
return match[1].replace( rBackslash, "" );
|
|
},
|
|
|
|
TAG: function( match, curLoop ) {
|
|
return match[1].replace( rBackslash, "" ).toLowerCase();
|
|
},
|
|
|
|
CHILD: function( match ) {
|
|
if ( match[1] === "nth" ) {
|
|
if ( !match[2] ) {
|
|
Sizzle.error( match[0] );
|
|
}
|
|
|
|
match[2] = match[2].replace(/^\+|\s*/g, '');
|
|
|
|
// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
|
|
var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
|
|
match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
|
|
!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
|
|
|
|
// calculate the numbers (first)n+(last) including if they are negative
|
|
match[2] = (test[1] + (test[2] || 1)) - 0;
|
|
match[3] = test[3] - 0;
|
|
}
|
|
else if ( match[2] ) {
|
|
Sizzle.error( match[0] );
|
|
}
|
|
|
|
// TODO: Move to normal caching system
|
|
match[0] = done++;
|
|
|
|
return match;
|
|
},
|
|
|
|
ATTR: function( match, curLoop, inplace, result, not, isXML ) {
|
|
var name = match[1] = match[1].replace( rBackslash, "" );
|
|
|
|
if ( !isXML && Expr.attrMap[name] ) {
|
|
match[1] = Expr.attrMap[name];
|
|
}
|
|
|
|
// Handle if an un-quoted value was used
|
|
match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );
|
|
|
|
if ( match[2] === "~=" ) {
|
|
match[4] = " " + match[4] + " ";
|
|
}
|
|
|
|
return match;
|
|
},
|
|
|
|
PSEUDO: function( match, curLoop, inplace, result, not ) {
|
|
if ( match[1] === "not" ) {
|
|
// If we're dealing with a complex expression, or a simple one
|
|
if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
|
|
match[3] = Sizzle(match[3], null, null, curLoop);
|
|
|
|
} else {
|
|
var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
|
|
|
|
if ( !inplace ) {
|
|
result.push.apply( result, ret );
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
|
|
return true;
|
|
}
|
|
|
|
return match;
|
|
},
|
|
|
|
POS: function( match ) {
|
|
match.unshift( true );
|
|
|
|
return match;
|
|
}
|
|
},
|
|
|
|
filters: {
|
|
enabled: function( elem ) {
|
|
return elem.disabled === false && elem.type !== "hidden";
|
|
},
|
|
|
|
disabled: function( elem ) {
|
|
return elem.disabled === true;
|
|
},
|
|
|
|
checked: function( elem ) {
|
|
return elem.checked === true;
|
|
},
|
|
|
|
selected: function( elem ) {
|
|
// Accessing this property makes selected-by-default
|
|
// options in Safari work properly
|
|
if ( elem.parentNode ) {
|
|
elem.parentNode.selectedIndex;
|
|
}
|
|
|
|
return elem.selected === true;
|
|
},
|
|
|
|
parent: function( elem ) {
|
|
return !!elem.firstChild;
|
|
},
|
|
|
|
empty: function( elem ) {
|
|
return !elem.firstChild;
|
|
},
|
|
|
|
has: function( elem, i, match ) {
|
|
return !!Sizzle( match[3], elem ).length;
|
|
},
|
|
|
|
header: function( elem ) {
|
|
return (/h\d/i).test( elem.nodeName );
|
|
},
|
|
|
|
text: function( elem ) {
|
|
var attr = elem.getAttribute( "type" ), type = elem.type;
|
|
// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
|
|
// use getAttribute instead to test this case
|
|
return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );
|
|
},
|
|
|
|
radio: function( elem ) {
|
|
return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
|
|
},
|
|
|
|
checkbox: function( elem ) {
|
|
return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
|
|
},
|
|
|
|
file: function( elem ) {
|
|
return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
|
|
},
|
|
|
|
password: function( elem ) {
|
|
return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
|
|
},
|
|
|
|
submit: function( elem ) {
|
|
var name = elem.nodeName.toLowerCase();
|
|
return (name === "input" || name === "button") && "submit" === elem.type;
|
|
},
|
|
|
|
image: function( elem ) {
|
|
return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
|
|
},
|
|
|
|
reset: function( elem ) {
|
|
var name = elem.nodeName.toLowerCase();
|
|
return (name === "input" || name === "button") && "reset" === elem.type;
|
|
},
|
|
|
|
button: function( elem ) {
|
|
var name = elem.nodeName.toLowerCase();
|
|
return name === "input" && "button" === elem.type || name === "button";
|
|
},
|
|
|
|
input: function( elem ) {
|
|
return (/input|select|textarea|button/i).test( elem.nodeName );
|
|
},
|
|
|
|
focus: function( elem ) {
|
|
return elem === elem.ownerDocument.activeElement;
|
|
}
|
|
},
|
|
setFilters: {
|
|
first: function( elem, i ) {
|
|
return i === 0;
|
|
},
|
|
|
|
last: function( elem, i, match, array ) {
|
|
return i === array.length - 1;
|
|
},
|
|
|
|
even: function( elem, i ) {
|
|
return i % 2 === 0;
|
|
},
|
|
|
|
odd: function( elem, i ) {
|
|
return i % 2 === 1;
|
|
},
|
|
|
|
lt: function( elem, i, match ) {
|
|
return i < match[3] - 0;
|
|
},
|
|
|
|
gt: function( elem, i, match ) {
|
|
return i > match[3] - 0;
|
|
},
|
|
|
|
nth: function( elem, i, match ) {
|
|
return match[3] - 0 === i;
|
|
},
|
|
|
|
eq: function( elem, i, match ) {
|
|
return match[3] - 0 === i;
|
|
}
|
|
},
|
|
filter: {
|
|
PSEUDO: function( elem, match, i, array ) {
|
|
var name = match[1],
|
|
filter = Expr.filters[ name ];
|
|
|
|
if ( filter ) {
|
|
return filter( elem, i, match, array );
|
|
|
|
} else if ( name === "contains" ) {
|
|
return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
|
|
|
|
} else if ( name === "not" ) {
|
|
var not = match[3];
|
|
|
|
for ( var j = 0, l = not.length; j < l; j++ ) {
|
|
if ( not[j] === elem ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
|
|
} else {
|
|
Sizzle.error( name );
|
|
}
|
|
},
|
|
|
|
CHILD: function( elem, match ) {
|
|
var type = match[1],
|
|
node = elem;
|
|
|
|
switch ( type ) {
|
|
case "only":
|
|
case "first":
|
|
while ( (node = node.previousSibling) ) {
|
|
if ( node.nodeType === 1 ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( type === "first" ) {
|
|
return true;
|
|
}
|
|
|
|
node = elem;
|
|
|
|
case "last":
|
|
while ( (node = node.nextSibling) ) {
|
|
if ( node.nodeType === 1 ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
|
|
case "nth":
|
|
var first = match[2],
|
|
last = match[3];
|
|
|
|
if ( first === 1 && last === 0 ) {
|
|
return true;
|
|
}
|
|
|
|
var doneName = match[0],
|
|
parent = elem.parentNode;
|
|
|
|
if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
|
|
var count = 0;
|
|
|
|
for ( node = parent.firstChild; node; node = node.nextSibling ) {
|
|
if ( node.nodeType === 1 ) {
|
|
node.nodeIndex = ++count;
|
|
}
|
|
}
|
|
|
|
parent.sizcache = doneName;
|
|
}
|
|
|
|
var diff = elem.nodeIndex - last;
|
|
|
|
if ( first === 0 ) {
|
|
return diff === 0;
|
|
|
|
} else {
|
|
return ( diff % first === 0 && diff / first >= 0 );
|
|
}
|
|
}
|
|
},
|
|
|
|
ID: function( elem, match ) {
|
|
return elem.nodeType === 1 && elem.getAttribute("id") === match;
|
|
},
|
|
|
|
TAG: function( elem, match ) {
|
|
return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
|
|
},
|
|
|
|
CLASS: function( elem, match ) {
|
|
return (" " + (elem.className || elem.getAttribute("class")) + " ")
|
|
.indexOf( match ) > -1;
|
|
},
|
|
|
|
ATTR: function( elem, match ) {
|
|
var name = match[1],
|
|
result = Expr.attrHandle[ name ] ?
|
|
Expr.attrHandle[ name ]( elem ) :
|
|
elem[ name ] != null ?
|
|
elem[ name ] :
|
|
elem.getAttribute( name ),
|
|
value = result + "",
|
|
type = match[2],
|
|
check = match[4];
|
|
|
|
return result == null ?
|
|
type === "!=" :
|
|
type === "=" ?
|
|
value === check :
|
|
type === "*=" ?
|
|
value.indexOf(check) >= 0 :
|
|
type === "~=" ?
|
|
(" " + value + " ").indexOf(check) >= 0 :
|
|
!check ?
|
|
value && result !== false :
|
|
type === "!=" ?
|
|
value !== check :
|
|
type === "^=" ?
|
|
value.indexOf(check) === 0 :
|
|
type === "$=" ?
|
|
value.substr(value.length - check.length) === check :
|
|
type === "|=" ?
|
|
value === check || value.substr(0, check.length + 1) === check + "-" :
|
|
false;
|
|
},
|
|
|
|
POS: function( elem, match, i, array ) {
|
|
var name = match[2],
|
|
filter = Expr.setFilters[ name ];
|
|
|
|
if ( filter ) {
|
|
return filter( elem, i, match, array );
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
var origPOS = Expr.match.POS,
|
|
fescape = function(all, num){
|
|
return "\\" + (num - 0 + 1);
|
|
};
|
|
|
|
for ( var type in Expr.match ) {
|
|
Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
|
|
Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
|
|
}
|
|
|
|
var makeArray = function( array, results ) {
|
|
array = Array.prototype.slice.call( array, 0 );
|
|
|
|
if ( results ) {
|
|
results.push.apply( results, array );
|
|
return results;
|
|
}
|
|
|
|
return array;
|
|
};
|
|
|
|
// Perform a simple check to determine if the browser is capable of
|
|
// converting a NodeList to an array using builtin methods.
|
|
// Also verifies that the returned array holds DOM nodes
|
|
// (which is not the case in the Blackberry browser)
|
|
try {
|
|
Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
|
|
|
|
// Provide a fallback method if it does not work
|
|
} catch( e ) {
|
|
makeArray = function( array, results ) {
|
|
var i = 0,
|
|
ret = results || [];
|
|
|
|
if ( toString.call(array) === "[object Array]" ) {
|
|
Array.prototype.push.apply( ret, array );
|
|
|
|
} else {
|
|
if ( typeof array.length === "number" ) {
|
|
for ( var l = array.length; i < l; i++ ) {
|
|
ret.push( array[i] );
|
|
}
|
|
|
|
} else {
|
|
for ( ; array[i]; i++ ) {
|
|
ret.push( array[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
};
|
|
}
|
|
|
|
var sortOrder, siblingCheck;
|
|
|
|
if ( document.documentElement.compareDocumentPosition ) {
|
|
sortOrder = function( a, b ) {
|
|
if ( a === b ) {
|
|
hasDuplicate = true;
|
|
return 0;
|
|
}
|
|
|
|
if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
|
|
return a.compareDocumentPosition ? -1 : 1;
|
|
}
|
|
|
|
return a.compareDocumentPosition(b) & 4 ? -1 : 1;
|
|
};
|
|
|
|
} else {
|
|
sortOrder = function( a, b ) {
|
|
// The nodes are identical, we can exit early
|
|
if ( a === b ) {
|
|
hasDuplicate = true;
|
|
return 0;
|
|
|
|
// Fallback to using sourceIndex (in IE) if it's available on both nodes
|
|
} else if ( a.sourceIndex && b.sourceIndex ) {
|
|
return a.sourceIndex - b.sourceIndex;
|
|
}
|
|
|
|
var al, bl,
|
|
ap = [],
|
|
bp = [],
|
|
aup = a.parentNode,
|
|
bup = b.parentNode,
|
|
cur = aup;
|
|
|
|
// If the nodes are siblings (or identical) we can do a quick check
|
|
if ( aup === bup ) {
|
|
return siblingCheck( a, b );
|
|
|
|
// If no parents were found then the nodes are disconnected
|
|
} else if ( !aup ) {
|
|
return -1;
|
|
|
|
} else if ( !bup ) {
|
|
return 1;
|
|
}
|
|
|
|
// Otherwise they're somewhere else in the tree so we need
|
|
// to build up a full list of the parentNodes for comparison
|
|
while ( cur ) {
|
|
ap.unshift( cur );
|
|
cur = cur.parentNode;
|
|
}
|
|
|
|
cur = bup;
|
|
|
|
while ( cur ) {
|
|
bp.unshift( cur );
|
|
cur = cur.parentNode;
|
|
}
|
|
|
|
al = ap.length;
|
|
bl = bp.length;
|
|
|
|
// Start walking down the tree looking for a discrepancy
|
|
for ( var i = 0; i < al && i < bl; i++ ) {
|
|
if ( ap[i] !== bp[i] ) {
|
|
return siblingCheck( ap[i], bp[i] );
|
|
}
|
|
}
|
|
|
|
// We ended someplace up the tree so do a sibling check
|
|
return i === al ?
|
|
siblingCheck( a, bp[i], -1 ) :
|
|
siblingCheck( ap[i], b, 1 );
|
|
};
|
|
|
|
siblingCheck = function( a, b, ret ) {
|
|
if ( a === b ) {
|
|
return ret;
|
|
}
|
|
|
|
var cur = a.nextSibling;
|
|
|
|
while ( cur ) {
|
|
if ( cur === b ) {
|
|
return -1;
|
|
}
|
|
|
|
cur = cur.nextSibling;
|
|
}
|
|
|
|
return 1;
|
|
};
|
|
}
|
|
|
|
// Utility function for retreiving the text value of an array of DOM nodes
|
|
Sizzle.getText = function( elems ) {
|
|
var ret = "", elem;
|
|
|
|
for ( var i = 0; elems[i]; i++ ) {
|
|
elem = elems[i];
|
|
|
|
// Get the text from text nodes and CDATA nodes
|
|
if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
|
|
ret += elem.nodeValue;
|
|
|
|
// Traverse everything else, except comment nodes
|
|
} else if ( elem.nodeType !== 8 ) {
|
|
ret += Sizzle.getText( elem.childNodes );
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
};
|
|
|
|
// Check to see if the browser returns elements by name when
|
|
// querying by getElementById (and provide a workaround)
|
|
(function(){
|
|
// We're going to inject a fake input element with a specified name
|
|
var form = document.createElement("div"),
|
|
id = "script" + (new Date()).getTime(),
|
|
root = document.documentElement;
|
|
|
|
form.innerHTML = "<a name='" + id + "'/>";
|
|
|
|
// Inject it into the root element, check its status, and remove it quickly
|
|
root.insertBefore( form, root.firstChild );
|
|
|
|
// The workaround has to do additional checks after a getElementById
|
|
// Which slows things down for other browsers (hence the branching)
|
|
if ( document.getElementById( id ) ) {
|
|
Expr.find.ID = function( match, context, isXML ) {
|
|
if ( typeof context.getElementById !== "undefined" && !isXML ) {
|
|
var m = context.getElementById(match[1]);
|
|
|
|
return m ?
|
|
m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
|
|
[m] :
|
|
undefined :
|
|
[];
|
|
}
|
|
};
|
|
|
|
Expr.filter.ID = function( elem, match ) {
|
|
var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
|
|
|
|
return elem.nodeType === 1 && node && node.nodeValue === match;
|
|
};
|
|
}
|
|
|
|
root.removeChild( form );
|
|
|
|
// release memory in IE
|
|
root = form = null;
|
|
})();
|
|
|
|
(function(){
|
|
// Check to see if the browser returns only elements
|
|
// when doing getElementsByTagName("*")
|
|
|
|
// Create a fake element
|
|
var div = document.createElement("div");
|
|
div.appendChild( document.createComment("") );
|
|
|
|
// Make sure no comments are found
|
|
if ( div.getElementsByTagName("*").length > 0 ) {
|
|
Expr.find.TAG = function( match, context ) {
|
|
var results = context.getElementsByTagName( match[1] );
|
|
|
|
// Filter out possible comments
|
|
if ( match[1] === "*" ) {
|
|
var tmp = [];
|
|
|
|
for ( var i = 0; results[i]; i++ ) {
|
|
if ( results[i].nodeType === 1 ) {
|
|
tmp.push( results[i] );
|
|
}
|
|
}
|
|
|
|
results = tmp;
|
|
}
|
|
|
|
return results;
|
|
};
|
|
}
|
|
|
|
// Check to see if an attribute returns normalized href attributes
|
|
div.innerHTML = "<a href='#'></a>";
|
|
|
|
if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
|
|
div.firstChild.getAttribute("href") !== "#" ) {
|
|
|
|
Expr.attrHandle.href = function( elem ) {
|
|
return elem.getAttribute( "href", 2 );
|
|
};
|
|
}
|
|
|
|
// release memory in IE
|
|
div = null;
|
|
})();
|
|
|
|
if ( document.querySelectorAll ) {
|
|
(function(){
|
|
var oldSizzle = Sizzle,
|
|
div = document.createElement("div"),
|
|
id = "__sizzle__";
|
|
|
|
div.innerHTML = "<p class='TEST'></p>";
|
|
|
|
// Safari can't handle uppercase or unicode characters when
|
|
// in quirks mode.
|
|
if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
|
|
return;
|
|
}
|
|
|
|
Sizzle = function( query, context, extra, seed ) {
|
|
context = context || document;
|
|
|
|
// Only use querySelectorAll on non-XML documents
|
|
// (ID selectors don't work in non-HTML documents)
|
|
if ( !seed && !Sizzle.isXML(context) ) {
|
|
// See if we find a selector to speed up
|
|
var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
|
|
|
|
if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
|
|
// Speed-up: Sizzle("TAG")
|
|
if ( match[1] ) {
|
|
return makeArray( context.getElementsByTagName( query ), extra );
|
|
|
|
// Speed-up: Sizzle(".CLASS")
|
|
} else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
|
|
return makeArray( context.getElementsByClassName( match[2] ), extra );
|
|
}
|
|
}
|
|
|
|
if ( context.nodeType === 9 ) {
|
|
// Speed-up: Sizzle("body")
|
|
// The body element only exists once, optimize finding it
|
|
if ( query === "body" && context.body ) {
|
|
return makeArray( [ context.body ], extra );
|
|
|
|
// Speed-up: Sizzle("#ID")
|
|
} else if ( match && match[3] ) {
|
|
var elem = context.getElementById( match[3] );
|
|
|
|
// Check parentNode to catch when Blackberry 4.6 returns
|
|
// nodes that are no longer in the document #6963
|
|
if ( elem && elem.parentNode ) {
|
|
// Handle the case where IE and Opera return items
|
|
// by name instead of ID
|
|
if ( elem.id === match[3] ) {
|
|
return makeArray( [ elem ], extra );
|
|
}
|
|
|
|
} else {
|
|
return makeArray( [], extra );
|
|
}
|
|
}
|
|
|
|
try {
|
|
return makeArray( context.querySelectorAll(query), extra );
|
|
} catch(qsaError) {}
|
|
|
|
// qSA works strangely on Element-rooted queries
|
|
// We can work around this by specifying an extra ID on the root
|
|
// and working up from there (Thanks to Andrew Dupont for the technique)
|
|
// IE 8 doesn't work on object elements
|
|
} else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
|
|
var oldContext = context,
|
|
old = context.getAttribute( "id" ),
|
|
nid = old || id,
|
|
hasParent = context.parentNode,
|
|
relativeHierarchySelector = /^\s*[+~]/.test( query );
|
|
|
|
if ( !old ) {
|
|
context.setAttribute( "id", nid );
|
|
} else {
|
|
nid = nid.replace( /'/g, "\\$&" );
|
|
}
|
|
if ( relativeHierarchySelector && hasParent ) {
|
|
context = context.parentNode;
|
|
}
|
|
|
|
try {
|
|
if ( !relativeHierarchySelector || hasParent ) {
|
|
return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
|
|
}
|
|
|
|
} catch(pseudoError) {
|
|
} finally {
|
|
if ( !old ) {
|
|
oldContext.removeAttribute( "id" );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return oldSizzle(query, context, extra, seed);
|
|
};
|
|
|
|
for ( var prop in oldSizzle ) {
|
|
Sizzle[ prop ] = oldSizzle[ prop ];
|
|
}
|
|
|
|
// release memory in IE
|
|
div = null;
|
|
})();
|
|
}
|
|
|
|
(function(){
|
|
var html = document.documentElement,
|
|
matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;
|
|
|
|
if ( matches ) {
|
|
// Check to see if it's possible to do matchesSelector
|
|
// on a disconnected node (IE 9 fails this)
|
|
var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
|
|
pseudoWorks = false;
|
|
|
|
try {
|
|
// This should fail with an exception
|
|
// Gecko does not error, returns false instead
|
|
matches.call( document.documentElement, "[test!='']:sizzle" );
|
|
|
|
} catch( pseudoError ) {
|
|
pseudoWorks = true;
|
|
}
|
|
|
|
Sizzle.matchesSelector = function( node, expr ) {
|
|
// Make sure that attribute selectors are quoted
|
|
expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
|
|
|
|
if ( !Sizzle.isXML( node ) ) {
|
|
try {
|
|
if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
|
|
var ret = matches.call( node, expr );
|
|
|
|
// IE 9's matchesSelector returns false on disconnected nodes
|
|
if ( ret || !disconnectedMatch ||
|
|
// As well, disconnected nodes are said to be in a document
|
|
// fragment in IE 9, so check for that
|
|
node.document && node.document.nodeType !== 11 ) {
|
|
return ret;
|
|
}
|
|
}
|
|
} catch(e) {}
|
|
}
|
|
|
|
return Sizzle(expr, null, null, [node]).length > 0;
|
|
};
|
|
}
|
|
})();
|
|
|
|
(function(){
|
|
var div = document.createElement("div");
|
|
|
|
div.innerHTML = "<div class='test e'></div><div class='test'></div>";
|
|
|
|
// Opera can't find a second classname (in 9.6)
|
|
// Also, make sure that getElementsByClassName actually exists
|
|
if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
|
|
return;
|
|
}
|
|
|
|
// Safari caches class attributes, doesn't catch changes (in 3.2)
|
|
div.lastChild.className = "e";
|
|
|
|
if ( div.getElementsByClassName("e").length === 1 ) {
|
|
return;
|
|
}
|
|
|
|
Expr.order.splice(1, 0, "CLASS");
|
|
Expr.find.CLASS = function( match, context, isXML ) {
|
|
if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
|
|
return context.getElementsByClassName(match[1]);
|
|
}
|
|
};
|
|
|
|
// release memory in IE
|
|
div = null;
|
|
})();
|
|
|
|
function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
|
|
for ( var i = 0, l = checkSet.length; i < l; i++ ) {
|
|
var elem = checkSet[i];
|
|
|
|
if ( elem ) {
|
|
var match = false;
|
|
|
|
elem = elem[dir];
|
|
|
|
while ( elem ) {
|
|
if ( elem.sizcache === doneName ) {
|
|
match = checkSet[elem.sizset];
|
|
break;
|
|
}
|
|
|
|
if ( elem.nodeType === 1 && !isXML ){
|
|
elem.sizcache = doneName;
|
|
elem.sizset = i;
|
|
}
|
|
|
|
if ( elem.nodeName.toLowerCase() === cur ) {
|
|
match = elem;
|
|
break;
|
|
}
|
|
|
|
elem = elem[dir];
|
|
}
|
|
|
|
checkSet[i] = match;
|
|
}
|
|
}
|
|
}
|
|
|
|
function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
|
|
for ( var i = 0, l = checkSet.length; i < l; i++ ) {
|
|
var elem = checkSet[i];
|
|
|
|
if ( elem ) {
|
|
var match = false;
|
|
|
|
elem = elem[dir];
|
|
|
|
while ( elem ) {
|
|
if ( elem.sizcache === doneName ) {
|
|
match = checkSet[elem.sizset];
|
|
break;
|
|
}
|
|
|
|
if ( elem.nodeType === 1 ) {
|
|
if ( !isXML ) {
|
|
elem.sizcache = doneName;
|
|
elem.sizset = i;
|
|
}
|
|
|
|
if ( typeof cur !== "string" ) {
|
|
if ( elem === cur ) {
|
|
match = true;
|
|
break;
|
|
}
|
|
|
|
} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
|
|
match = elem;
|
|
break;
|
|
}
|
|
}
|
|
|
|
elem = elem[dir];
|
|
}
|
|
|
|
checkSet[i] = match;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( document.documentElement.contains ) {
|
|
Sizzle.contains = function( a, b ) {
|
|
return a !== b && (a.contains ? a.contains(b) : true);
|
|
};
|
|
|
|
} else if ( document.documentElement.compareDocumentPosition ) {
|
|
Sizzle.contains = function( a, b ) {
|
|
return !!(a.compareDocumentPosition(b) & 16);
|
|
};
|
|
|
|
} else {
|
|
Sizzle.contains = function() {
|
|
return false;
|
|
};
|
|
}
|
|
|
|
Sizzle.isXML = function( elem ) {
|
|
// documentElement is verified for cases where it doesn't yet exist
|
|
// (such as loading iframes in IE - #4833)
|
|
var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
|
|
|
|
return documentElement ? documentElement.nodeName !== "HTML" : false;
|
|
};
|
|
|
|
var posProcess = function( selector, context ) {
|
|
var match,
|
|
tmpSet = [],
|
|
later = "",
|
|
root = context.nodeType ? [context] : context;
|
|
|
|
// Position selectors must be done after the filter
|
|
// And so must :not(positional) so we move all PSEUDOs to the end
|
|
while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
|
|
later += match[0];
|
|
selector = selector.replace( Expr.match.PSEUDO, "" );
|
|
}
|
|
|
|
selector = Expr.relative[selector] ? selector + "*" : selector;
|
|
|
|
for ( var i = 0, l = root.length; i < l; i++ ) {
|
|
Sizzle( selector, root[i], tmpSet );
|
|
}
|
|
|
|
return Sizzle.filter( later, tmpSet );
|
|
};
|
|
|
|
// EXPOSE
|
|
jQuery.find = Sizzle;
|
|
jQuery.expr = Sizzle.selectors;
|
|
jQuery.expr[":"] = jQuery.expr.filters;
|
|
jQuery.unique = Sizzle.uniqueSort;
|
|
jQuery.text = Sizzle.getText;
|
|
jQuery.isXMLDoc = Sizzle.isXML;
|
|
jQuery.contains = Sizzle.contains;
|
|
|
|
|
|
})();
|
|
|
|
|
|
var runtil = /Until$/,
|
|
rparentsprev = /^(?:parents|prevUntil|prevAll)/,
|
|
// Note: This RegExp should be improved, or likely pulled from Sizzle
|
|
rmultiselector = /,/,
|
|
isSimple = /^.[^:#\[\.,]*$/,
|
|
slice = Array.prototype.slice,
|
|
POS = jQuery.expr.match.POS,
|
|
// methods guaranteed to produce a unique set when starting from a unique set
|
|
guaranteedUnique = {
|
|
children: true,
|
|
contents: true,
|
|
next: true,
|
|
prev: true
|
|
};
|
|
|
|
jQuery.fn.extend({
|
|
find: function( selector ) {
|
|
var self = this,
|
|
i, l;
|
|
|
|
if ( typeof selector !== "string" ) {
|
|
return jQuery( selector ).filter(function() {
|
|
for ( i = 0, l = self.length; i < l; i++ ) {
|
|
if ( jQuery.contains( self[ i ], this ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
var ret = this.pushStack( "", "find", selector ),
|
|
length, n, r;
|
|
|
|
for ( i = 0, l = this.length; i < l; i++ ) {
|
|
length = ret.length;
|
|
jQuery.find( selector, this[i], ret );
|
|
|
|
if ( i > 0 ) {
|
|
// Make sure that the results are unique
|
|
for ( n = length; n < ret.length; n++ ) {
|
|
for ( r = 0; r < length; r++ ) {
|
|
if ( ret[r] === ret[n] ) {
|
|
ret.splice(n--, 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
},
|
|
|
|
has: function( target ) {
|
|
var targets = jQuery( target );
|
|
return this.filter(function() {
|
|
for ( var i = 0, l = targets.length; i < l; i++ ) {
|
|
if ( jQuery.contains( this, targets[i] ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
});
|
|
},
|
|
|
|
not: function( selector ) {
|
|
return this.pushStack( winnow(this, selector, false), "not", selector);
|
|
},
|
|
|
|
filter: function( selector ) {
|
|
return this.pushStack( winnow(this, selector, true), "filter", selector );
|
|
},
|
|
|
|
is: function( selector ) {
|
|
return !!selector && ( typeof selector === "string" ?
|
|
jQuery.filter( selector, this ).length > 0 :
|
|
this.filter( selector ).length > 0 );
|
|
},
|
|
|
|
closest: function( selectors, context ) {
|
|
var ret = [], i, l, cur = this[0];
|
|
|
|
// Array
|
|
if ( jQuery.isArray( selectors ) ) {
|
|
var match, selector,
|
|
matches = {},
|
|
level = 1;
|
|
|
|
if ( cur && selectors.length ) {
|
|
for ( i = 0, l = selectors.length; i < l; i++ ) {
|
|
selector = selectors[i];
|
|
|
|
if ( !matches[ selector ] ) {
|
|
matches[ selector ] = POS.test( selector ) ?
|
|
jQuery( selector, context || this.context ) :
|
|
selector;
|
|
}
|
|
}
|
|
|
|
while ( cur && cur.ownerDocument && cur !== context ) {
|
|
for ( selector in matches ) {
|
|
match = matches[ selector ];
|
|
|
|
if ( match.jquery ? match.index( cur ) > -1 : jQuery( cur ).is( match ) ) {
|
|
ret.push({ selector: selector, elem: cur, level: level });
|
|
}
|
|
}
|
|
|
|
cur = cur.parentNode;
|
|
level++;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
// String
|
|
var pos = POS.test( selectors ) || typeof selectors !== "string" ?
|
|
jQuery( selectors, context || this.context ) :
|
|
0;
|
|
|
|
for ( i = 0, l = this.length; i < l; i++ ) {
|
|
cur = this[i];
|
|
|
|
while ( cur ) {
|
|
if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
|
|
ret.push( cur );
|
|
break;
|
|
|
|
} else {
|
|
cur = cur.parentNode;
|
|
if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
|
|
|
|
return this.pushStack( ret, "closest", selectors );
|
|
},
|
|
|
|
// Determine the position of an element within
|
|
// the matched set of elements
|
|
index: function( elem ) {
|
|
if ( !elem || typeof elem === "string" ) {
|
|
return jQuery.inArray( this[0],
|
|
// If it receives a string, the selector is used
|
|
// If it receives nothing, the siblings are used
|
|
elem ? jQuery( elem ) : this.parent().children() );
|
|
}
|
|
// Locate the position of the desired element
|
|
return jQuery.inArray(
|
|
// If it receives a jQuery object, the first element is used
|
|
elem.jquery ? elem[0] : elem, this );
|
|
},
|
|
|
|
add: function( selector, context ) {
|
|
var set = typeof selector === "string" ?
|
|
jQuery( selector, context ) :
|
|
jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
|
|
all = jQuery.merge( this.get(), set );
|
|
|
|
return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
|
|
all :
|
|
jQuery.unique( all ) );
|
|
},
|
|
|
|
andSelf: function() {
|
|
return this.add( this.prevObject );
|
|
}
|
|
});
|
|
|
|
// A painfully simple check to see if an element is disconnected
|
|
// from a document (should be improved, where feasible).
|
|
function isDisconnected( node ) {
|
|
return !node || !node.parentNode || node.parentNode.nodeType === 11;
|
|
}
|
|
|
|
jQuery.each({
|
|
parent: function( elem ) {
|
|
var parent = elem.parentNode;
|
|
return parent && parent.nodeType !== 11 ? parent : null;
|
|
},
|
|
parents: function( elem ) {
|
|
return jQuery.dir( elem, "parentNode" );
|
|
},
|
|
parentsUntil: function( elem, i, until ) {
|
|
return jQuery.dir( elem, "parentNode", until );
|
|
},
|
|
next: function( elem ) {
|
|
return jQuery.nth( elem, 2, "nextSibling" );
|
|
},
|
|
prev: function( elem ) {
|
|
return jQuery.nth( elem, 2, "previousSibling" );
|
|
},
|
|
nextAll: function( elem ) {
|
|
return jQuery.dir( elem, "nextSibling" );
|
|
},
|
|
prevAll: function( elem ) {
|
|
return jQuery.dir( elem, "previousSibling" );
|
|
},
|
|
nextUntil: function( elem, i, until ) {
|
|
return jQuery.dir( elem, "nextSibling", until );
|
|
},
|
|
prevUntil: function( elem, i, until ) {
|
|
return jQuery.dir( elem, "previousSibling", until );
|
|
},
|
|
siblings: function( elem ) {
|
|
return jQuery.sibling( elem.parentNode.firstChild, elem );
|
|
},
|
|
children: function( elem ) {
|
|
return jQuery.sibling( elem.firstChild );
|
|
},
|
|
contents: function( elem ) {
|
|
return jQuery.nodeName( elem, "iframe" ) ?
|
|
elem.contentDocument || elem.contentWindow.document :
|
|
jQuery.makeArray( elem.childNodes );
|
|
}
|
|
}, function( name, fn ) {
|
|
jQuery.fn[ name ] = function( until, selector ) {
|
|
var ret = jQuery.map( this, fn, until ),
|
|
// The variable 'args' was introduced in
|
|
// https://github.com/jquery/jquery/commit/52a0238
|
|
// to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
|
|
// http://code.google.com/p/v8/issues/detail?id=1050
|
|
args = slice.call(arguments);
|
|
|
|
if ( !runtil.test( name ) ) {
|
|
selector = until;
|
|
}
|
|
|
|
if ( selector && typeof selector === "string" ) {
|
|
ret = jQuery.filter( selector, ret );
|
|
}
|
|
|
|
ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
|
|
|
|
if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
|
|
ret = ret.reverse();
|
|
}
|
|
|
|
return this.pushStack( ret, name, args.join(",") );
|
|
};
|
|
});
|
|
|
|
jQuery.extend({
|
|
filter: function( expr, elems, not ) {
|
|
if ( not ) {
|
|
expr = ":not(" + expr + ")";
|
|
}
|
|
|
|
return elems.length === 1 ?
|
|
jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
|
|
jQuery.find.matches(expr, elems);
|
|
},
|
|
|
|
dir: function( elem, dir, until ) {
|
|
var matched = [],
|
|
cur = elem[ dir ];
|
|
|
|
while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
|
|
if ( cur.nodeType === 1 ) {
|
|
matched.push( cur );
|
|
}
|
|
cur = cur[dir];
|
|
}
|
|
return matched;
|
|
},
|
|
|
|
nth: function( cur, result, dir, elem ) {
|
|
result = result || 1;
|
|
var num = 0;
|
|
|
|
for ( ; cur; cur = cur[dir] ) {
|
|
if ( cur.nodeType === 1 && ++num === result ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return cur;
|
|
},
|
|
|
|
sibling: function( n, elem ) {
|
|
var r = [];
|
|
|
|
for ( ; n; n = n.nextSibling ) {
|
|
if ( n.nodeType === 1 && n !== elem ) {
|
|
r.push( n );
|
|
}
|
|
}
|
|
|
|
return r;
|
|
}
|
|
});
|
|
|
|
// Implement the identical functionality for filter and not
|
|
function winnow( elements, qualifier, keep ) {
|
|
|
|
// Can't pass null or undefined to indexOf in Firefox 4
|
|
// Set to 0 to skip string check
|
|
qualifier = qualifier || 0;
|
|
|
|
if ( jQuery.isFunction( qualifier ) ) {
|
|
return jQuery.grep(elements, function( elem, i ) {
|
|
var retVal = !!qualifier.call( elem, i, elem );
|
|
return retVal === keep;
|
|
});
|
|
|
|
} else if ( qualifier.nodeType ) {
|
|
return jQuery.grep(elements, function( elem, i ) {
|
|
return (elem === qualifier) === keep;
|
|
});
|
|
|
|
} else if ( typeof qualifier === "string" ) {
|
|
var filtered = jQuery.grep(elements, function( elem ) {
|
|
return elem.nodeType === 1;
|
|
});
|
|
|
|
if ( isSimple.test( qualifier ) ) {
|
|
return jQuery.filter(qualifier, filtered, !keep);
|
|
} else {
|
|
qualifier = jQuery.filter( qualifier, filtered );
|
|
}
|
|
}
|
|
|
|
return jQuery.grep(elements, function( elem, i ) {
|
|
return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
|
|
});
|
|
}
|
|
|
|
|
|
|
|
|
|
var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
|
|
rleadingWhitespace = /^\s+/,
|
|
rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
|
|
rtagName = /<([\w:]+)/,
|
|
rtbody = /<tbody/i,
|
|
rhtml = /<|&#?\w+;/,
|
|
rnocache = /<(?:script|object|embed|option|style)/i,
|
|
// checked="checked" or checked
|
|
rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
|
|
rscriptType = /\/(java|ecma)script/i,
|
|
rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/,
|
|
wrapMap = {
|
|
option: [ 1, "<select multiple='multiple'>", "</select>" ],
|
|
legend: [ 1, "<fieldset>", "</fieldset>" ],
|
|
thead: [ 1, "<table>", "</table>" ],
|
|
tr: [ 2, "<table><tbody>", "</tbody></table>" ],
|
|
td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
|
|
col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
|
|
area: [ 1, "<map>", "</map>" ],
|
|
_default: [ 0, "", "" ]
|
|
};
|
|
|
|
wrapMap.optgroup = wrapMap.option;
|
|
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
|
|
wrapMap.th = wrapMap.td;
|
|
|
|
// IE can't serialize <link> and <script> tags normally
|
|
if ( !jQuery.support.htmlSerialize ) {
|
|
wrapMap._default = [ 1, "div<div>", "</div>" ];
|
|
}
|
|
|
|
jQuery.fn.extend({
|
|
text: function( text ) {
|
|
if ( jQuery.isFunction(text) ) {
|
|
return this.each(function(i) {
|
|
var self = jQuery( this );
|
|
|
|
self.text( text.call(this, i, self.text()) );
|
|
});
|
|
}
|
|
|
|
if ( typeof text !== "object" && text !== undefined ) {
|
|
return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
|
|
}
|
|
|
|
return jQuery.text( this );
|
|
},
|
|
|
|
wrapAll: function( html ) {
|
|
if ( jQuery.isFunction( html ) ) {
|
|
return this.each(function(i) {
|
|
jQuery(this).wrapAll( html.call(this, i) );
|
|
});
|
|
}
|
|
|
|
if ( this[0] ) {
|
|
// The elements to wrap the target around
|
|
var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
|
|
|
|
if ( this[0].parentNode ) {
|
|
wrap.insertBefore( this[0] );
|
|
}
|
|
|
|
wrap.map(function() {
|
|
var elem = this;
|
|
|
|
while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
|
|
elem = elem.firstChild;
|
|
}
|
|
|
|
return elem;
|
|
}).append( this );
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
wrapInner: function( html ) {
|
|
if ( jQuery.isFunction( html ) ) {
|
|
return this.each(function(i) {
|
|
jQuery(this).wrapInner( html.call(this, i) );
|
|
});
|
|
}
|
|
|
|
return this.each(function() {
|
|
var self = jQuery( this ),
|
|
contents = self.contents();
|
|
|
|
if ( contents.length ) {
|
|
contents.wrapAll( html );
|
|
|
|
} else {
|
|
self.append( html );
|
|
}
|
|
});
|
|
},
|
|
|
|
wrap: function( html ) {
|
|
return this.each(function() {
|
|
jQuery( this ).wrapAll( html );
|
|
});
|
|
},
|
|
|
|
unwrap: function() {
|
|
return this.parent().each(function() {
|
|
if ( !jQuery.nodeName( this, "body" ) ) {
|
|
jQuery( this ).replaceWith( this.childNodes );
|
|
}
|
|
}).end();
|
|
},
|
|
|
|
append: function() {
|
|
return this.domManip(arguments, true, function( elem ) {
|
|
if ( this.nodeType === 1 ) {
|
|
this.appendChild( elem );
|
|
}
|
|
});
|
|
},
|
|
|
|
prepend: function() {
|
|
return this.domManip(arguments, true, function( elem ) {
|
|
if ( this.nodeType === 1 ) {
|
|
this.insertBefore( elem, this.firstChild );
|
|
}
|
|
});
|
|
},
|
|
|
|
before: function() {
|
|
if ( this[0] && this[0].parentNode ) {
|
|
return this.domManip(arguments, false, function( elem ) {
|
|
this.parentNode.insertBefore( elem, this );
|
|
});
|
|
} else if ( arguments.length ) {
|
|
var set = jQuery(arguments[0]);
|
|
set.push.apply( set, this.toArray() );
|
|
return this.pushStack( set, "before", arguments );
|
|
}
|
|
},
|
|
|
|
after: function() {
|
|
if ( this[0] && this[0].parentNode ) {
|
|
return this.domManip(arguments, false, function( elem ) {
|
|
this.parentNode.insertBefore( elem, this.nextSibling );
|
|
});
|
|
} else if ( arguments.length ) {
|
|
var set = this.pushStack( this, "after", arguments );
|
|
set.push.apply( set, jQuery(arguments[0]).toArray() );
|
|
return set;
|
|
}
|
|
},
|
|
|
|
// keepData is for internal use only--do not document
|
|
remove: function( selector, keepData ) {
|
|
for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
|
|
if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
|
|
if ( !keepData && elem.nodeType === 1 ) {
|
|
jQuery.cleanData( elem.getElementsByTagName("*") );
|
|
jQuery.cleanData( [ elem ] );
|
|
}
|
|
|
|
if ( elem.parentNode ) {
|
|
elem.parentNode.removeChild( elem );
|
|
}
|
|
}
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
empty: function() {
|
|
for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
|
|
// Remove element nodes and prevent memory leaks
|
|
if ( elem.nodeType === 1 ) {
|
|
jQuery.cleanData( elem.getElementsByTagName("*") );
|
|
}
|
|
|
|
// Remove any remaining nodes
|
|
while ( elem.firstChild ) {
|
|
elem.removeChild( elem.firstChild );
|
|
}
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
clone: function( dataAndEvents, deepDataAndEvents ) {
|
|
dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
|
|
deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
|
|
|
|
return this.map( function () {
|
|
return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
|
|
});
|
|
},
|
|
|
|
html: function( value ) {
|
|
if ( value === undefined ) {
|
|
return this[0] && this[0].nodeType === 1 ?
|
|
this[0].innerHTML.replace(rinlinejQuery, "") :
|
|
null;
|
|
|
|
// See if we can take a shortcut and just use innerHTML
|
|
} else if ( typeof value === "string" && !rnocache.test( value ) &&
|
|
(jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
|
|
!wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
|
|
|
|
value = value.replace(rxhtmlTag, "<$1></$2>");
|
|
|
|
try {
|
|
for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
// Remove element nodes and prevent memory leaks
|
|
if ( this[i].nodeType === 1 ) {
|
|
jQuery.cleanData( this[i].getElementsByTagName("*") );
|
|
this[i].innerHTML = value;
|
|
}
|
|
}
|
|
|
|
// If using innerHTML throws an exception, use the fallback method
|
|
} catch(e) {
|
|
this.empty().append( value );
|
|
}
|
|
|
|
} else if ( jQuery.isFunction( value ) ) {
|
|
this.each(function(i){
|
|
var self = jQuery( this );
|
|
|
|
self.html( value.call(this, i, self.html()) );
|
|
});
|
|
|
|
} else {
|
|
this.empty().append( value );
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
replaceWith: function( value ) {
|
|
if ( this[0] && this[0].parentNode ) {
|
|
// Make sure that the elements are removed from the DOM before they are inserted
|
|
// this can help fix replacing a parent with child elements
|
|
if ( jQuery.isFunction( value ) ) {
|
|
return this.each(function(i) {
|
|
var self = jQuery(this), old = self.html();
|
|
self.replaceWith( value.call( this, i, old ) );
|
|
});
|
|
}
|
|
|
|
if ( typeof value !== "string" ) {
|
|
value = jQuery( value ).detach();
|
|
}
|
|
|
|
return this.each(function() {
|
|
var next = this.nextSibling,
|
|
parent = this.parentNode;
|
|
|
|
jQuery( this ).remove();
|
|
|
|
if ( next ) {
|
|
jQuery(next).before( value );
|
|
} else {
|
|
jQuery(parent).append( value );
|
|
}
|
|
});
|
|
} else {
|
|
return this.length ?
|
|
this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
|
|
this;
|
|
}
|
|
},
|
|
|
|
detach: function( selector ) {
|
|
return this.remove( selector, true );
|
|
},
|
|
|
|
domManip: function( args, table, callback ) {
|
|
var results, first, fragment, parent,
|
|
value = args[0],
|
|
scripts = [];
|
|
|
|
// We can't cloneNode fragments that contain checked, in WebKit
|
|
if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
|
|
return this.each(function() {
|
|
jQuery(this).domManip( args, table, callback, true );
|
|
});
|
|
}
|
|
|
|
if ( jQuery.isFunction(value) ) {
|
|
return this.each(function(i) {
|
|
var self = jQuery(this);
|
|
args[0] = value.call(this, i, table ? self.html() : undefined);
|
|
self.domManip( args, table, callback );
|
|
});
|
|
}
|
|
|
|
if ( this[0] ) {
|
|
parent = value && value.parentNode;
|
|
|
|
// If we're in a fragment, just use that instead of building a new one
|
|
if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
|
|
results = { fragment: parent };
|
|
|
|
} else {
|
|
results = jQuery.buildFragment( args, this, scripts );
|
|
}
|
|
|
|
fragment = results.fragment;
|
|
|
|
if ( fragment.childNodes.length === 1 ) {
|
|
first = fragment = fragment.firstChild;
|
|
} else {
|
|
first = fragment.firstChild;
|
|
}
|
|
|
|
if ( first ) {
|
|
table = table && jQuery.nodeName( first, "tr" );
|
|
|
|
for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
|
|
callback.call(
|
|
table ?
|
|
root(this[i], first) :
|
|
this[i],
|
|
// Make sure that we do not leak memory by inadvertently discarding
|
|
// the original fragment (which might have attached data) instead of
|
|
// using it; in addition, use the original fragment object for the last
|
|
// item instead of first because it can end up being emptied incorrectly
|
|
// in certain situations (Bug #8070).
|
|
// Fragments from the fragment cache must always be cloned and never used
|
|
// in place.
|
|
results.cacheable || (l > 1 && i < lastIndex) ?
|
|
jQuery.clone( fragment, true, true ) :
|
|
fragment
|
|
);
|
|
}
|
|
}
|
|
|
|
if ( scripts.length ) {
|
|
jQuery.each( scripts, evalScript );
|
|
}
|
|
}
|
|
|
|
return this;
|
|
}
|
|
});
|
|
|
|
function root( elem, cur ) {
|
|
return jQuery.nodeName(elem, "table") ?
|
|
(elem.getElementsByTagName("tbody")[0] ||
|
|
elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
|
|
elem;
|
|
}
|
|
|
|
function cloneCopyEvent( src, dest ) {
|
|
|
|
if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
|
|
return;
|
|
}
|
|
|
|
var internalKey = jQuery.expando,
|
|
oldData = jQuery.data( src ),
|
|
curData = jQuery.data( dest, oldData );
|
|
|
|
// Switch to use the internal data object, if it exists, for the next
|
|
// stage of data copying
|
|
if ( (oldData = oldData[ internalKey ]) ) {
|
|
var events = oldData.events;
|
|
curData = curData[ internalKey ] = jQuery.extend({}, oldData);
|
|
|
|
if ( events ) {
|
|
delete curData.handle;
|
|
curData.events = {};
|
|
|
|
for ( var type in events ) {
|
|
for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
|
|
jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function cloneFixAttributes( src, dest ) {
|
|
var nodeName;
|
|
|
|
// We do not need to do anything for non-Elements
|
|
if ( dest.nodeType !== 1 ) {
|
|
return;
|
|
}
|
|
|
|
// clearAttributes removes the attributes, which we don't want,
|
|
// but also removes the attachEvent events, which we *do* want
|
|
if ( dest.clearAttributes ) {
|
|
dest.clearAttributes();
|
|
}
|
|
|
|
// mergeAttributes, in contrast, only merges back on the
|
|
// original attributes, not the events
|
|
if ( dest.mergeAttributes ) {
|
|
dest.mergeAttributes( src );
|
|
}
|
|
|
|
nodeName = dest.nodeName.toLowerCase();
|
|
|
|
// IE6-8 fail to clone children inside object elements that use
|
|
// the proprietary classid attribute value (rather than the type
|
|
// attribute) to identify the type of content to display
|
|
if ( nodeName === "object" ) {
|
|
dest.outerHTML = src.outerHTML;
|
|
|
|
} else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
|
|
// IE6-8 fails to persist the checked state of a cloned checkbox
|
|
// or radio button. Worse, IE6-7 fail to give the cloned element
|
|
// a checked appearance if the defaultChecked value isn't also set
|
|
if ( src.checked ) {
|
|
dest.defaultChecked = dest.checked = src.checked;
|
|
}
|
|
|
|
// IE6-7 get confused and end up setting the value of a cloned
|
|
// checkbox/radio button to an empty string instead of "on"
|
|
if ( dest.value !== src.value ) {
|
|
dest.value = src.value;
|
|
}
|
|
|
|
// IE6-8 fails to return the selected option to the default selected
|
|
// state when cloning options
|
|
} else if ( nodeName === "option" ) {
|
|
dest.selected = src.defaultSelected;
|
|
|
|
// IE6-8 fails to set the defaultValue to the correct value when
|
|
// cloning other types of input fields
|
|
} else if ( nodeName === "input" || nodeName === "textarea" ) {
|
|
dest.defaultValue = src.defaultValue;
|
|
}
|
|
|
|
// Event data gets referenced instead of copied if the expando
|
|
// gets copied too
|
|
dest.removeAttribute( jQuery.expando );
|
|
}
|
|
|
|
jQuery.buildFragment = function( args, nodes, scripts ) {
|
|
var fragment, cacheable, cacheresults, doc;
|
|
|
|
// nodes may contain either an explicit document object,
|
|
// a jQuery collection or context object.
|
|
// If nodes[0] contains a valid object to assign to doc
|
|
if ( nodes && nodes[0] ) {
|
|
doc = nodes[0].ownerDocument || nodes[0];
|
|
}
|
|
|
|
// Ensure that an attr object doesn't incorrectly stand in as a document object
|
|
// Chrome and Firefox seem to allow this to occur and will throw exception
|
|
// Fixes #8950
|
|
if ( !doc.createDocumentFragment ) {
|
|
doc = document;
|
|
}
|
|
|
|
// Only cache "small" (1/2 KB) HTML strings that are associated with the main document
|
|
// Cloning options loses the selected state, so don't cache them
|
|
// IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
|
|
// Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
|
|
if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
|
|
args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
|
|
|
|
cacheable = true;
|
|
|
|
cacheresults = jQuery.fragments[ args[0] ];
|
|
if ( cacheresults && cacheresults !== 1 ) {
|
|
fragment = cacheresults;
|
|
}
|
|
}
|
|
|
|
if ( !fragment ) {
|
|
fragment = doc.createDocumentFragment();
|
|
jQuery.clean( args, doc, fragment, scripts );
|
|
}
|
|
|
|
if ( cacheable ) {
|
|
jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
|
|
}
|
|
|
|
return { fragment: fragment, cacheable: cacheable };
|
|
};
|
|
|
|
jQuery.fragments = {};
|
|
|
|
jQuery.each({
|
|
appendTo: "append",
|
|
prependTo: "prepend",
|
|
insertBefore: "before",
|
|
insertAfter: "after",
|
|
replaceAll: "replaceWith"
|
|
}, function( name, original ) {
|
|
jQuery.fn[ name ] = function( selector ) {
|
|
var ret = [],
|
|
insert = jQuery( selector ),
|
|
parent = this.length === 1 && this[0].parentNode;
|
|
|
|
if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
|
|
insert[ original ]( this[0] );
|
|
return this;
|
|
|
|
} else {
|
|
for ( var i = 0, l = insert.length; i < l; i++ ) {
|
|
var elems = (i > 0 ? this.clone(true) : this).get();
|
|
jQuery( insert[i] )[ original ]( elems );
|
|
ret = ret.concat( elems );
|
|
}
|
|
|
|
return this.pushStack( ret, name, insert.selector );
|
|
}
|
|
};
|
|
});
|
|
|
|
function getAll( elem ) {
|
|
if ( "getElementsByTagName" in elem ) {
|
|
return elem.getElementsByTagName( "*" );
|
|
|
|
} else if ( "querySelectorAll" in elem ) {
|
|
return elem.querySelectorAll( "*" );
|
|
|
|
} else {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
// Used in clean, fixes the defaultChecked property
|
|
function fixDefaultChecked( elem ) {
|
|
if ( elem.type === "checkbox" || elem.type === "radio" ) {
|
|
elem.defaultChecked = elem.checked;
|
|
}
|
|
}
|
|
// Finds all inputs and passes them to fixDefaultChecked
|
|
function findInputs( elem ) {
|
|
if ( jQuery.nodeName( elem, "input" ) ) {
|
|
fixDefaultChecked( elem );
|
|
} else if ( "getElementsByTagName" in elem ) {
|
|
jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
|
|
}
|
|
}
|
|
|
|
jQuery.extend({
|
|
clone: function( elem, dataAndEvents, deepDataAndEvents ) {
|
|
var clone = elem.cloneNode(true),
|
|
srcElements,
|
|
destElements,
|
|
i;
|
|
|
|
if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
|
|
(elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
|
|
// IE copies events bound via attachEvent when using cloneNode.
|
|
// Calling detachEvent on the clone will also remove the events
|
|
// from the original. In order to get around this, we use some
|
|
// proprietary methods to clear the events. Thanks to MooTools
|
|
// guys for this hotness.
|
|
|
|
cloneFixAttributes( elem, clone );
|
|
|
|
// Using Sizzle here is crazy slow, so we use getElementsByTagName
|
|
// instead
|
|
srcElements = getAll( elem );
|
|
destElements = getAll( clone );
|
|
|
|
// Weird iteration because IE will replace the length property
|
|
// with an element if you are cloning the body and one of the
|
|
// elements on the page has a name or id of "length"
|
|
for ( i = 0; srcElements[i]; ++i ) {
|
|
cloneFixAttributes( srcElements[i], destElements[i] );
|
|
}
|
|
}
|
|
|
|
// Copy the events from the original to the clone
|
|
if ( dataAndEvents ) {
|
|
cloneCopyEvent( elem, clone );
|
|
|
|
if ( deepDataAndEvents ) {
|
|
srcElements = getAll( elem );
|
|
destElements = getAll( clone );
|
|
|
|
for ( i = 0; srcElements[i]; ++i ) {
|
|
cloneCopyEvent( srcElements[i], destElements[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
srcElements = destElements = null;
|
|
|
|
// Return the cloned set
|
|
return clone;
|
|
},
|
|
|
|
clean: function( elems, context, fragment, scripts ) {
|
|
var checkScriptType;
|
|
|
|
context = context || document;
|
|
|
|
// !context.createElement fails in IE with an error but returns typeof 'object'
|
|
if ( typeof context.createElement === "undefined" ) {
|
|
context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
|
|
}
|
|
|
|
var ret = [], j;
|
|
|
|
for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
|
|
if ( typeof elem === "number" ) {
|
|
elem += "";
|
|
}
|
|
|
|
if ( !elem ) {
|
|
continue;
|
|
}
|
|
|
|
// Convert html string into DOM nodes
|
|
if ( typeof elem === "string" ) {
|
|
if ( !rhtml.test( elem ) ) {
|
|
elem = context.createTextNode( elem );
|
|
} else {
|
|
// Fix "XHTML"-style tags in all browsers
|
|
elem = elem.replace(rxhtmlTag, "<$1></$2>");
|
|
|
|
// Trim whitespace, otherwise indexOf won't work as expected
|
|
var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
|
|
wrap = wrapMap[ tag ] || wrapMap._default,
|
|
depth = wrap[0],
|
|
div = context.createElement("div");
|
|
|
|
// Go to html and back, then peel off extra wrappers
|
|
div.innerHTML = wrap[1] + elem + wrap[2];
|
|
|
|
// Move to the right depth
|
|
while ( depth-- ) {
|
|
div = div.lastChild;
|
|
}
|
|
|
|
// Remove IE's autoinserted <tbody> from table fragments
|
|
if ( !jQuery.support.tbody ) {
|
|
|
|
// String was a <table>, *may* have spurious <tbody>
|
|
var hasBody = rtbody.test(elem),
|
|
tbody = tag === "table" && !hasBody ?
|
|
div.firstChild && div.firstChild.childNodes :
|
|
|
|
// String was a bare <thead> or <tfoot>
|
|
wrap[1] === "<table>" && !hasBody ?
|
|
div.childNodes :
|
|
[];
|
|
|
|
for ( j = tbody.length - 1; j >= 0 ; --j ) {
|
|
if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
|
|
tbody[ j ].parentNode.removeChild( tbody[ j ] );
|
|
}
|
|
}
|
|
}
|
|
|
|
// IE completely kills leading whitespace when innerHTML is used
|
|
if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
|
|
div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
|
|
}
|
|
|
|
elem = div.childNodes;
|
|
}
|
|
}
|
|
|
|
// Resets defaultChecked for any radios and checkboxes
|
|
// about to be appended to the DOM in IE 6/7 (#8060)
|
|
var len;
|
|
if ( !jQuery.support.appendChecked ) {
|
|
if ( elem[0] && typeof (len = elem.length) === "number" ) {
|
|
for ( j = 0; j < len; j++ ) {
|
|
findInputs( elem[j] );
|
|
}
|
|
} else {
|
|
findInputs( elem );
|
|
}
|
|
}
|
|
|
|
if ( elem.nodeType ) {
|
|
ret.push( elem );
|
|
} else {
|
|
ret = jQuery.merge( ret, elem );
|
|
}
|
|
}
|
|
|
|
if ( fragment ) {
|
|
checkScriptType = function( elem ) {
|
|
return !elem.type || rscriptType.test( elem.type );
|
|
};
|
|
for ( i = 0; ret[i]; i++ ) {
|
|
if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
|
|
scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
|
|
|
|
} else {
|
|
if ( ret[i].nodeType === 1 ) {
|
|
var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType );
|
|
|
|
ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
|
|
}
|
|
fragment.appendChild( ret[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
},
|
|
|
|
cleanData: function( elems ) {
|
|
var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
|
|
deleteExpando = jQuery.support.deleteExpando;
|
|
|
|
for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
|
|
if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
|
|
continue;
|
|
}
|
|
|
|
id = elem[ jQuery.expando ];
|
|
|
|
if ( id ) {
|
|
data = cache[ id ] && cache[ id ][ internalKey ];
|
|
|
|
if ( data && data.events ) {
|
|
for ( var type in data.events ) {
|
|
if ( special[ type ] ) {
|
|
jQuery.event.remove( elem, type );
|
|
|
|
// This is a shortcut to avoid jQuery.event.remove's overhead
|
|
} else {
|
|
jQuery.removeEvent( elem, type, data.handle );
|
|
}
|
|
}
|
|
|
|
// Null the DOM reference to avoid IE6/7/8 leak (#7054)
|
|
if ( data.handle ) {
|
|
data.handle.elem = null;
|
|
}
|
|
}
|
|
|
|
if ( deleteExpando ) {
|
|
delete elem[ jQuery.expando ];
|
|
|
|
} else if ( elem.removeAttribute ) {
|
|
elem.removeAttribute( jQuery.expando );
|
|
}
|
|
|
|
delete cache[ id ];
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
function evalScript( i, elem ) {
|
|
if ( elem.src ) {
|
|
jQuery.ajax({
|
|
url: elem.src,
|
|
async: false,
|
|
dataType: "script"
|
|
});
|
|
} else {
|
|
jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "/*$0*/" ) );
|
|
}
|
|
|
|
if ( elem.parentNode ) {
|
|
elem.parentNode.removeChild( elem );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
var ralpha = /alpha\([^)]*\)/i,
|
|
ropacity = /opacity=([^)]*)/,
|
|
// fixed for IE9, see #8346
|
|
rupper = /([A-Z]|^ms)/g,
|
|
rnumpx = /^-?\d+(?:px)?$/i,
|
|
rnum = /^-?\d/,
|
|
rrelNum = /^[+\-]=/,
|
|
rrelNumFilter = /[^+\-\.\de]+/g,
|
|
|
|
cssShow = { position: "absolute", visibility: "hidden", display: "block" },
|
|
cssWidth = [ "Left", "Right" ],
|
|
cssHeight = [ "Top", "Bottom" ],
|
|
curCSS,
|
|
|
|
getComputedStyle,
|
|
currentStyle;
|
|
|
|
jQuery.fn.css = function( name, value ) {
|
|
// Setting 'undefined' is a no-op
|
|
if ( arguments.length === 2 && value === undefined ) {
|
|
return this;
|
|
}
|
|
|
|
return jQuery.access( this, name, value, true, function( elem, name, value ) {
|
|
return value !== undefined ?
|
|
jQuery.style( elem, name, value ) :
|
|
jQuery.css( elem, name );
|
|
});
|
|
};
|
|
|
|
jQuery.extend({
|
|
// Add in style property hooks for overriding the default
|
|
// behavior of getting and setting a style property
|
|
cssHooks: {
|
|
opacity: {
|
|
get: function( elem, computed ) {
|
|
if ( computed ) {
|
|
// We should always get a number back from opacity
|
|
var ret = curCSS( elem, "opacity", "opacity" );
|
|
return ret === "" ? "1" : ret;
|
|
|
|
} else {
|
|
return elem.style.opacity;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
// Exclude the following css properties to add px
|
|
cssNumber: {
|
|
"fillOpacity": true,
|
|
"fontWeight": true,
|
|
"lineHeight": true,
|
|
"opacity": true,
|
|
"orphans": true,
|
|
"widows": true,
|
|
"zIndex": true,
|
|
"zoom": true
|
|
},
|
|
|
|
// Add in properties whose names you wish to fix before
|
|
// setting or getting the value
|
|
cssProps: {
|
|
// normalize float css property
|
|
"float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
|
|
},
|
|
|
|
// Get and set the style property on a DOM Node
|
|
style: function( elem, name, value, extra ) {
|
|
// Don't set styles on text and comment nodes
|
|
if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
|
|
return;
|
|
}
|
|
|
|
// Make sure that we're working with the right name
|
|
var ret, type, origName = jQuery.camelCase( name ),
|
|
style = elem.style, hooks = jQuery.cssHooks[ origName ];
|
|
|
|
name = jQuery.cssProps[ origName ] || origName;
|
|
|
|
// Check if we're setting a value
|
|
if ( value !== undefined ) {
|
|
type = typeof value;
|
|
|
|
// Make sure that NaN and null values aren't set. See: #7116
|
|
if ( type === "number" && isNaN( value ) || value == null ) {
|
|
return;
|
|
}
|
|
|
|
// convert relative number strings (+= or -=) to relative numbers. #7345
|
|
if ( type === "string" && rrelNum.test( value ) ) {
|
|
value = +value.replace( rrelNumFilter, "" ) + parseFloat( jQuery.css( elem, name ) );
|
|
// Fixes bug #9237
|
|
type = "number";
|
|
}
|
|
|
|
// If a number was passed in, add 'px' to the (except for certain CSS properties)
|
|
if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
|
|
value += "px";
|
|
}
|
|
|
|
// If a hook was provided, use that value, otherwise just set the specified value
|
|
if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
|
|
// Wrapped to prevent IE from throwing errors when 'invalid' values are provided
|
|
// Fixes bug #5509
|
|
try {
|
|
style[ name ] = value;
|
|
} catch(e) {}
|
|
}
|
|
|
|
} else {
|
|
// If a hook was provided get the non-computed value from there
|
|
if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
|
|
return ret;
|
|
}
|
|
|
|
// Otherwise just get the value from the style object
|
|
return style[ name ];
|
|
}
|
|
},
|
|
|
|
css: function( elem, name, extra ) {
|
|
var ret, hooks;
|
|
|
|
// Make sure that we're working with the right name
|
|
name = jQuery.camelCase( name );
|
|
hooks = jQuery.cssHooks[ name ];
|
|
name = jQuery.cssProps[ name ] || name;
|
|
|
|
// cssFloat needs a special treatment
|
|
if ( name === "cssFloat" ) {
|
|
name = "float";
|
|
}
|
|
|
|
// If a hook was provided get the computed value from there
|
|
if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
|
|
return ret;
|
|
|
|
// Otherwise, if a way to get the computed value exists, use that
|
|
} else if ( curCSS ) {
|
|
return curCSS( elem, name );
|
|
}
|
|
},
|
|
|
|
// A method for quickly swapping in/out CSS properties to get correct calculations
|
|
swap: function( elem, options, callback ) {
|
|
var old = {};
|
|
|
|
// Remember the old values, and insert the new ones
|
|
for ( var name in options ) {
|
|
old[ name ] = elem.style[ name ];
|
|
elem.style[ name ] = options[ name ];
|
|
}
|
|
|
|
callback.call( elem );
|
|
|
|
// Revert the old values
|
|
for ( name in options ) {
|
|
elem.style[ name ] = old[ name ];
|
|
}
|
|
}
|
|
});
|
|
|
|
// DEPRECATED, Use jQuery.css() instead
|
|
jQuery.curCSS = jQuery.css;
|
|
|
|
jQuery.each(["height", "width"], function( i, name ) {
|
|
jQuery.cssHooks[ name ] = {
|
|
get: function( elem, computed, extra ) {
|
|
var val;
|
|
|
|
if ( computed ) {
|
|
if ( elem.offsetWidth !== 0 ) {
|
|
return getWH( elem, name, extra );
|
|
} else {
|
|
jQuery.swap( elem, cssShow, function() {
|
|
val = getWH( elem, name, extra );
|
|
});
|
|
}
|
|
|
|
return val;
|
|
}
|
|
},
|
|
|
|
set: function( elem, value ) {
|
|
if ( rnumpx.test( value ) ) {
|
|
// ignore negative width and height values #1599
|
|
value = parseFloat( value );
|
|
|
|
if ( value >= 0 ) {
|
|
return value + "px";
|
|
}
|
|
|
|
} else {
|
|
return value;
|
|
}
|
|
}
|
|
};
|
|
});
|
|
|
|
if ( !jQuery.support.opacity ) {
|
|
jQuery.cssHooks.opacity = {
|
|
get: function( elem, computed ) {
|
|
// IE uses filters for opacity
|
|
return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
|
|
( parseFloat( RegExp.$1 ) / 100 ) + "" :
|
|
computed ? "1" : "";
|
|
},
|
|
|
|
set: function( elem, value ) {
|
|
var style = elem.style,
|
|
currentStyle = elem.currentStyle;
|
|
|
|
// IE has trouble with opacity if it does not have layout
|
|
// Force it by setting the zoom level
|
|
style.zoom = 1;
|
|
|
|
// Set the alpha filter to set the opacity
|
|
var opacity = jQuery.isNaN( value ) ?
|
|
"" :
|
|
"alpha(opacity=" + value * 100 + ")",
|
|
filter = currentStyle && currentStyle.filter || style.filter || "";
|
|
|
|
style.filter = ralpha.test( filter ) ?
|
|
filter.replace( ralpha, opacity ) :
|
|
filter + " " + opacity;
|
|
}
|
|
};
|
|
}
|
|
|
|
jQuery(function() {
|
|
// This hook cannot be added until DOM ready because the support test
|
|
// for it is not run until after DOM ready
|
|
if ( !jQuery.support.reliableMarginRight ) {
|
|
jQuery.cssHooks.marginRight = {
|
|
get: function( elem, computed ) {
|
|
// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
|
|
// Work around by temporarily setting element display to inline-block
|
|
var ret;
|
|
jQuery.swap( elem, { "display": "inline-block" }, function() {
|
|
if ( computed ) {
|
|
ret = curCSS( elem, "margin-right", "marginRight" );
|
|
} else {
|
|
ret = elem.style.marginRight;
|
|
}
|
|
});
|
|
return ret;
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
if ( document.defaultView && document.defaultView.getComputedStyle ) {
|
|
getComputedStyle = function( elem, name ) {
|
|
var ret, defaultView, computedStyle;
|
|
|
|
name = name.replace( rupper, "-$1" ).toLowerCase();
|
|
|
|
if ( !(defaultView = elem.ownerDocument.defaultView) ) {
|
|
return undefined;
|
|
}
|
|
|
|
if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
|
|
ret = computedStyle.getPropertyValue( name );
|
|
if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
|
|
ret = jQuery.style( elem, name );
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
};
|
|
}
|
|
|
|
if ( document.documentElement.currentStyle ) {
|
|
currentStyle = function( elem, name ) {
|
|
var left,
|
|
ret = elem.currentStyle && elem.currentStyle[ name ],
|
|
rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ],
|
|
style = elem.style;
|
|
|
|
// From the awesome hack by Dean Edwards
|
|
// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
|
|
|
|
// If we're not dealing with a regular pixel number
|
|
// but a number that has a weird ending, we need to convert it to pixels
|
|
if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
|
|
// Remember the original values
|
|
left = style.left;
|
|
|
|
// Put in the new values to get a computed value out
|
|
if ( rsLeft ) {
|
|
elem.runtimeStyle.left = elem.currentStyle.left;
|
|
}
|
|
style.left = name === "fontSize" ? "1em" : (ret || 0);
|
|
ret = style.pixelLeft + "px";
|
|
|
|
// Revert the changed values
|
|
style.left = left;
|
|
if ( rsLeft ) {
|
|
elem.runtimeStyle.left = rsLeft;
|
|
}
|
|
}
|
|
|
|
return ret === "" ? "auto" : ret;
|
|
};
|
|
}
|
|
|
|
curCSS = getComputedStyle || currentStyle;
|
|
|
|
function getWH( elem, name, extra ) {
|
|
|
|
// Start with offset property
|
|
var val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
|
|
which = name === "width" ? cssWidth : cssHeight;
|
|
|
|
if ( val > 0 ) {
|
|
if ( extra !== "border" ) {
|
|
jQuery.each( which, function() {
|
|
if ( !extra ) {
|
|
val -= parseFloat( jQuery.css( elem, "padding" + this ) ) || 0;
|
|
}
|
|
if ( extra === "margin" ) {
|
|
val += parseFloat( jQuery.css( elem, extra + this ) ) || 0;
|
|
} else {
|
|
val -= parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) || 0;
|
|
}
|
|
});
|
|
}
|
|
|
|
return val + "px";
|
|
}
|
|
|
|
// Fall back to computed then uncomputed css if necessary
|
|
val = curCSS( elem, name, name );
|
|
if ( val < 0 || val == null ) {
|
|
val = elem.style[ name ] || 0;
|
|
}
|
|
// Normalize "", auto, and prepare for extra
|
|
val = parseFloat( val ) || 0;
|
|
|
|
// Add padding, border, margin
|
|
if ( extra ) {
|
|
jQuery.each( which, function() {
|
|
val += parseFloat( jQuery.css( elem, "padding" + this ) ) || 0;
|
|
if ( extra !== "padding" ) {
|
|
val += parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) || 0;
|
|
}
|
|
if ( extra === "margin" ) {
|
|
val += parseFloat( jQuery.css( elem, extra + this ) ) || 0;
|
|
}
|
|
});
|
|
}
|
|
|
|
return val + "px";
|
|
}
|
|
|
|
if ( jQuery.expr && jQuery.expr.filters ) {
|
|
jQuery.expr.filters.hidden = function( elem ) {
|
|
var width = elem.offsetWidth,
|
|
height = elem.offsetHeight;
|
|
|
|
return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
|
|
};
|
|
|
|
jQuery.expr.filters.visible = function( elem ) {
|
|
return !jQuery.expr.filters.hidden( elem );
|
|
};
|
|
}
|
|
|
|
|
|
|
|
|
|
var r20 = /%20/g,
|
|
rbracket = /\[\]$/,
|
|
rCRLF = /\r?\n/g,
|
|
rhash = /#.*$/,
|
|
rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
|
|
rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
|
|
// #7653, #8125, #8152: local protocol detection
|
|
rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|widget):$/,
|
|
rnoContent = /^(?:GET|HEAD)$/,
|
|
rprotocol = /^\/\//,
|
|
rquery = /\?/,
|
|
rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
|
|
rselectTextarea = /^(?:select|textarea)/i,
|
|
rspacesAjax = /\s+/,
|
|
rts = /([?&])_=[^&]*/,
|
|
rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
|
|
|
|
// Keep a copy of the old load method
|
|
_load = jQuery.fn.load,
|
|
|
|
/* Prefilters
|
|
* 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
|
|
* 2) These are called:
|
|
* - BEFORE asking for a transport
|
|
* - AFTER param serialization (s.data is a string if s.processData is true)
|
|
* 3) key is the dataType
|
|
* 4) the catchall symbol "*" can be used
|
|
* 5) execution will start with transport dataType and THEN continue down to "*" if needed
|
|
*/
|
|
prefilters = {},
|
|
|
|
/* Transports bindings
|
|
* 1) key is the dataType
|
|
* 2) the catchall symbol "*" can be used
|
|
* 3) selection will start with transport dataType and THEN go to "*" if needed
|
|
*/
|
|
transports = {},
|
|
|
|
// Document location
|
|
ajaxLocation,
|
|
|
|
// Document location segments
|
|
ajaxLocParts;
|
|
|
|
// #8138, IE may throw an exception when accessing
|
|
// a field from window.location if document.domain has been set
|
|
try {
|
|
ajaxLocation = location.href;
|
|
} catch( e ) {
|
|
// Use the href attribute of an A element
|
|
// since IE will modify it given document.location
|
|
ajaxLocation = document.createElement( "a" );
|
|
ajaxLocation.href = "";
|
|
ajaxLocation = ajaxLocation.href;
|
|
}
|
|
|
|
// Segment location into parts
|
|
ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
|
|
|
|
// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
|
|
function addToPrefiltersOrTransports( structure ) {
|
|
|
|
// dataTypeExpression is optional and defaults to "*"
|
|
return function( dataTypeExpression, func ) {
|
|
|
|
if ( typeof dataTypeExpression !== "string" ) {
|
|
func = dataTypeExpression;
|
|
dataTypeExpression = "*";
|
|
}
|
|
|
|
if ( jQuery.isFunction( func ) ) {
|
|
var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
|
|
i = 0,
|
|
length = dataTypes.length,
|
|
dataType,
|
|
list,
|
|
placeBefore;
|
|
|
|
// For each dataType in the dataTypeExpression
|
|
for(; i < length; i++ ) {
|
|
dataType = dataTypes[ i ];
|
|
// We control if we're asked to add before
|
|
// any existing element
|
|
placeBefore = /^\+/.test( dataType );
|
|
if ( placeBefore ) {
|
|
dataType = dataType.substr( 1 ) || "*";
|
|
}
|
|
list = structure[ dataType ] = structure[ dataType ] || [];
|
|
// then we add to the structure accordingly
|
|
list[ placeBefore ? "unshift" : "push" ]( func );
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// Base inspection function for prefilters and transports
|
|
function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
|
|
dataType /* internal */, inspected /* internal */ ) {
|
|
|
|
dataType = dataType || options.dataTypes[ 0 ];
|
|
inspected = inspected || {};
|
|
|
|
inspected[ dataType ] = true;
|
|
|
|
var list = structure[ dataType ],
|
|
i = 0,
|
|
length = list ? list.length : 0,
|
|
executeOnly = ( structure === prefilters ),
|
|
selection;
|
|
|
|
for(; i < length && ( executeOnly || !selection ); i++ ) {
|
|
selection = list[ i ]( options, originalOptions, jqXHR );
|
|
// If we got redirected to another dataType
|
|
// we try there if executing only and not done already
|
|
if ( typeof selection === "string" ) {
|
|
if ( !executeOnly || inspected[ selection ] ) {
|
|
selection = undefined;
|
|
} else {
|
|
options.dataTypes.unshift( selection );
|
|
selection = inspectPrefiltersOrTransports(
|
|
structure, options, originalOptions, jqXHR, selection, inspected );
|
|
}
|
|
}
|
|
}
|
|
// If we're only executing or nothing was selected
|
|
// we try the catchall dataType if not done already
|
|
if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
|
|
selection = inspectPrefiltersOrTransports(
|
|
structure, options, originalOptions, jqXHR, "*", inspected );
|
|
}
|
|
// unnecessary when only executing (prefilters)
|
|
// but it'll be ignored by the caller in that case
|
|
return selection;
|
|
}
|
|
|
|
jQuery.fn.extend({
|
|
load: function( url, params, callback ) {
|
|
if ( typeof url !== "string" && _load ) {
|
|
return _load.apply( this, arguments );
|
|
|
|
// Don't do a request if no elements are being requested
|
|
} else if ( !this.length ) {
|
|
return this;
|
|
}
|
|
|
|
var off = url.indexOf( " " );
|
|
if ( off >= 0 ) {
|
|
var selector = url.slice( off, url.length );
|
|
url = url.slice( 0, off );
|
|
}
|
|
|
|
// Default to a GET request
|
|
var type = "GET";
|
|
|
|
// If the second parameter was provided
|
|
if ( params ) {
|
|
// If it's a function
|
|
if ( jQuery.isFunction( params ) ) {
|
|
// We assume that it's the callback
|
|
callback = params;
|
|
params = undefined;
|
|
|
|
// Otherwise, build a param string
|
|
} else if ( typeof params === "object" ) {
|
|
params = jQuery.param( params, jQuery.ajaxSettings.traditional );
|
|
type = "POST";
|
|
}
|
|
}
|
|
|
|
var self = this;
|
|
|
|
// Request the remote document
|
|
jQuery.ajax({
|
|
url: url,
|
|
type: type,
|
|
dataType: "html",
|
|
data: params,
|
|
// Complete callback (responseText is used internally)
|
|
complete: function( jqXHR, status, responseText ) {
|
|
// Store the response as specified by the jqXHR object
|
|
responseText = jqXHR.responseText;
|
|
// If successful, inject the HTML into all the matched elements
|
|
if ( jqXHR.isResolved() ) {
|
|
// #4825: Get the actual response in case
|
|
// a dataFilter is present in ajaxSettings
|
|
jqXHR.done(function( r ) {
|
|
responseText = r;
|
|
});
|
|
// See if a selector was specified
|
|
self.html( selector ?
|
|
// Create a dummy div to hold the results
|
|
jQuery("<div>")
|
|
// inject the contents of the document in, removing the scripts
|
|
// to avoid any 'Permission Denied' errors in IE
|
|
.append(responseText.replace(rscript, ""))
|
|
|
|
// Locate the specified elements
|
|
.find(selector) :
|
|
|
|
// If not, just inject the full result
|
|
responseText );
|
|
}
|
|
|
|
if ( callback ) {
|
|
self.each( callback, [ responseText, status, jqXHR ] );
|
|
}
|
|
}
|
|
});
|
|
|
|
return this;
|
|
},
|
|
|
|
serialize: function() {
|
|
return jQuery.param( this.serializeArray() );
|
|
},
|
|
|
|
serializeArray: function() {
|
|
return this.map(function(){
|
|
return this.elements ? jQuery.makeArray( this.elements ) : this;
|
|
})
|
|
.filter(function(){
|
|
return this.name && !this.disabled &&
|
|
( this.checked || rselectTextarea.test( this.nodeName ) ||
|
|
rinput.test( this.type ) );
|
|
})
|
|
.map(function( i, elem ){
|
|
var val = jQuery( this ).val();
|
|
|
|
return val == null ?
|
|
null :
|
|
jQuery.isArray( val ) ?
|
|
jQuery.map( val, function( val, i ){
|
|
return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
|
|
}) :
|
|
{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
|
|
}).get();
|
|
}
|
|
});
|
|
|
|
// Attach a bunch of functions for handling common AJAX events
|
|
jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
|
|
jQuery.fn[ o ] = function( f ){
|
|
return this.bind( o, f );
|
|
};
|
|
});
|
|
|
|
jQuery.each( [ "get", "post" ], function( i, method ) {
|
|
jQuery[ method ] = function( url, data, callback, type ) {
|
|
// shift arguments if data argument was omitted
|
|
if ( jQuery.isFunction( data ) ) {
|
|
type = type || callback;
|
|
callback = data;
|
|
data = undefined;
|
|
}
|
|
|
|
return jQuery.ajax({
|
|
type: method,
|
|
url: url,
|
|
data: data,
|
|
success: callback,
|
|
dataType: type
|
|
});
|
|
};
|
|
});
|
|
|
|
jQuery.extend({
|
|
|
|
getScript: function( url, callback ) {
|
|
return jQuery.get( url, undefined, callback, "script" );
|
|
},
|
|
|
|
getJSON: function( url, data, callback ) {
|
|
return jQuery.get( url, data, callback, "json" );
|
|
},
|
|
|
|
// Creates a full fledged settings object into target
|
|
// with both ajaxSettings and settings fields.
|
|
// If target is omitted, writes into ajaxSettings.
|
|
ajaxSetup: function ( target, settings ) {
|
|
if ( !settings ) {
|
|
// Only one parameter, we extend ajaxSettings
|
|
settings = target;
|
|
target = jQuery.extend( true, jQuery.ajaxSettings, settings );
|
|
} else {
|
|
// target was provided, we extend into it
|
|
jQuery.extend( true, target, jQuery.ajaxSettings, settings );
|
|
}
|
|
// Flatten fields we don't want deep extended
|
|
for( var field in { context: 1, url: 1 } ) {
|
|
if ( field in settings ) {
|
|
target[ field ] = settings[ field ];
|
|
} else if( field in jQuery.ajaxSettings ) {
|
|
target[ field ] = jQuery.ajaxSettings[ field ];
|
|
}
|
|
}
|
|
return target;
|
|
},
|
|
|
|
ajaxSettings: {
|
|
url: ajaxLocation,
|
|
isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
|
|
global: true,
|
|
type: "GET",
|
|
contentType: "application/x-www-form-urlencoded",
|
|
processData: true,
|
|
async: true,
|
|
/*
|
|
timeout: 0,
|
|
data: null,
|
|
dataType: null,
|
|
username: null,
|
|
password: null,
|
|
cache: null,
|
|
traditional: false,
|
|
headers: {},
|
|
*/
|
|
|
|
accepts: {
|
|
xml: "application/xml, text/xml",
|
|
html: "text/html",
|
|
text: "text/plain",
|
|
json: "application/json, text/javascript",
|
|
"*": "*/*"
|
|
},
|
|
|
|
contents: {
|
|
xml: /xml/,
|
|
html: /html/,
|
|
json: /json/
|
|
},
|
|
|
|
responseFields: {
|
|
xml: "responseXML",
|
|
text: "responseText"
|
|
},
|
|
|
|
// List of data converters
|
|
// 1) key format is "source_type destination_type" (a single space in-between)
|
|
// 2) the catchall symbol "*" can be used for source_type
|
|
converters: {
|
|
|
|
// Convert anything to text
|
|
"* text": window.String,
|
|
|
|
// Text to html (true = no transformation)
|
|
"text html": true,
|
|
|
|
// Evaluate text as a json expression
|
|
"text json": jQuery.parseJSON,
|
|
|
|
// Parse text as xml
|
|
"text xml": jQuery.parseXML
|
|
}
|
|
},
|
|
|
|
ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
|
|
ajaxTransport: addToPrefiltersOrTransports( transports ),
|
|
|
|
// Main method
|
|
ajax: function( url, options ) {
|
|
|
|
// If url is an object, simulate pre-1.5 signature
|
|
if ( typeof url === "object" ) {
|
|
options = url;
|
|
url = undefined;
|
|
}
|
|
|
|
// Force options to be an object
|
|
options = options || {};
|
|
|
|
var // Create the final options object
|
|
s = jQuery.ajaxSetup( {}, options ),
|
|
// Callbacks context
|
|
callbackContext = s.context || s,
|
|
// Context for global events
|
|
// It's the callbackContext if one was provided in the options
|
|
// and if it's a DOM node or a jQuery collection
|
|
globalEventContext = callbackContext !== s &&
|
|
( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
|
|
jQuery( callbackContext ) : jQuery.event,
|
|
// Deferreds
|
|
deferred = jQuery.Deferred(),
|
|
completeDeferred = jQuery._Deferred(),
|
|
// Status-dependent callbacks
|
|
statusCode = s.statusCode || {},
|
|
// ifModified key
|
|
ifModifiedKey,
|
|
// Headers (they are sent all at once)
|
|
requestHeaders = {},
|
|
requestHeadersNames = {},
|
|
// Response headers
|
|
responseHeadersString,
|
|
responseHeaders,
|
|
// transport
|
|
transport,
|
|
// timeout handle
|
|
timeoutTimer,
|
|
// Cross-domain detection vars
|
|
parts,
|
|
// The jqXHR state
|
|
state = 0,
|
|
// To know if global events are to be dispatched
|
|
fireGlobals,
|
|
// Loop variable
|
|
i,
|
|
// Fake xhr
|
|
jqXHR = {
|
|
|
|
readyState: 0,
|
|
|
|
// Caches the header
|
|
setRequestHeader: function( name, value ) {
|
|
if ( !state ) {
|
|
var lname = name.toLowerCase();
|
|
name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
|
|
requestHeaders[ name ] = value;
|
|
}
|
|
return this;
|
|
},
|
|
|
|
// Raw string
|
|
getAllResponseHeaders: function() {
|
|
return state === 2 ? responseHeadersString : null;
|
|
},
|
|
|
|
// Builds headers hashtable if needed
|
|
getResponseHeader: function( key ) {
|
|
var match;
|
|
if ( state === 2 ) {
|
|
if ( !responseHeaders ) {
|
|
responseHeaders = {};
|
|
while( ( match = rheaders.exec( responseHeadersString ) ) ) {
|
|
responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
|
|
}
|
|
}
|
|
match = responseHeaders[ key.toLowerCase() ];
|
|
}
|
|
return match === undefined ? null : match;
|
|
},
|
|
|
|
// Overrides response content-type header
|
|
overrideMimeType: function( type ) {
|
|
if ( !state ) {
|
|
s.mimeType = type;
|
|
}
|
|
return this;
|
|
},
|
|
|
|
// Cancel the request
|
|
abort: function( statusText ) {
|
|
statusText = statusText || "abort";
|
|
if ( transport ) {
|
|
transport.abort( statusText );
|
|
}
|
|
done( 0, statusText );
|
|
return this;
|
|
}
|
|
};
|
|
|
|
// Callback for when everything is done
|
|
// It is defined here because jslint complains if it is declared
|
|
// at the end of the function (which would be more logical and readable)
|
|
function done( status, statusText, responses, headers ) {
|
|
|
|
// Called once
|
|
if ( state === 2 ) {
|
|
return;
|
|
}
|
|
|
|
// State is "done" now
|
|
state = 2;
|
|
|
|
// Clear timeout if it exists
|
|
if ( timeoutTimer ) {
|
|
clearTimeout( timeoutTimer );
|
|
}
|
|
|
|
// Dereference transport for early garbage collection
|
|
// (no matter how long the jqXHR object will be used)
|
|
transport = undefined;
|
|
|
|
// Cache response headers
|
|
responseHeadersString = headers || "";
|
|
|
|
// Set readyState
|
|
jqXHR.readyState = status ? 4 : 0;
|
|
|
|
var isSuccess,
|
|
success,
|
|
error,
|
|
response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
|
|
lastModified,
|
|
etag;
|
|
|
|
// If successful, handle type chaining
|
|
if ( status >= 200 && status < 300 || status === 304 ) {
|
|
|
|
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
|
|
if ( s.ifModified ) {
|
|
|
|
if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
|
|
jQuery.lastModified[ ifModifiedKey ] = lastModified;
|
|
}
|
|
if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
|
|
jQuery.etag[ ifModifiedKey ] = etag;
|
|
}
|
|
}
|
|
|
|
// If not modified
|
|
if ( status === 304 ) {
|
|
|
|
statusText = "notmodified";
|
|
isSuccess = true;
|
|
|
|
// If we have data
|
|
} else {
|
|
|
|
try {
|
|
success = ajaxConvert( s, response );
|
|
statusText = "success";
|
|
isSuccess = true;
|
|
} catch(e) {
|
|
// We have a parsererror
|
|
statusText = "parsererror";
|
|
error = e;
|
|
}
|
|
}
|
|
} else {
|
|
// We extract error from statusText
|
|
// then normalize statusText and status for non-aborts
|
|
error = statusText;
|
|
if( !statusText || status ) {
|
|
statusText = "error";
|
|
if ( status < 0 ) {
|
|
status = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set data for the fake xhr object
|
|
jqXHR.status = status;
|
|
jqXHR.statusText = statusText;
|
|
|
|
// Success/Error
|
|
if ( isSuccess ) {
|
|
deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
|
|
} else {
|
|
deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
|
|
}
|
|
|
|
// Status-dependent callbacks
|
|
jqXHR.statusCode( statusCode );
|
|
statusCode = undefined;
|
|
|
|
if ( fireGlobals ) {
|
|
globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
|
|
[ jqXHR, s, isSuccess ? success : error ] );
|
|
}
|
|
|
|
// Complete
|
|
completeDeferred.resolveWith( callbackContext, [ jqXHR, statusText ] );
|
|
|
|
if ( fireGlobals ) {
|
|
globalEventContext.trigger( "ajaxComplete", [ jqXHR, s] );
|
|
// Handle the global AJAX counter
|
|
if ( !( --jQuery.active ) ) {
|
|
jQuery.event.trigger( "ajaxStop" );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Attach deferreds
|
|
deferred.promise( jqXHR );
|
|
jqXHR.success = jqXHR.done;
|
|
jqXHR.error = jqXHR.fail;
|
|
jqXHR.complete = completeDeferred.done;
|
|
|
|
// Status-dependent callbacks
|
|
jqXHR.statusCode = function( map ) {
|
|
if ( map ) {
|
|
var tmp;
|
|
if ( state < 2 ) {
|
|
for( tmp in map ) {
|
|
statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
|
|
}
|
|
} else {
|
|
tmp = map[ jqXHR.status ];
|
|
jqXHR.then( tmp, tmp );
|
|
}
|
|
}
|
|
return this;
|
|
};
|
|
|
|
// Remove hash character (#7531: and string promotion)
|
|
// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
|
|
// We also use the url parameter if available
|
|
s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
|
|
|
|
// Extract dataTypes list
|
|
s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );
|
|
|
|
// Determine if a cross-domain request is in order
|
|
if ( s.crossDomain == null ) {
|
|
parts = rurl.exec( s.url.toLowerCase() );
|
|
s.crossDomain = !!( parts &&
|
|
( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
|
|
( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
|
|
( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
|
|
);
|
|
}
|
|
|
|
// Convert data if not already a string
|
|
if ( s.data && s.processData && typeof s.data !== "string" ) {
|
|
s.data = jQuery.param( s.data, s.traditional );
|
|
}
|
|
|
|
// Apply prefilters
|
|
inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
|
|
|
|
// If request was aborted inside a prefiler, stop there
|
|
if ( state === 2 ) {
|
|
return false;
|
|
}
|
|
|
|
// We can fire global events as of now if asked to
|
|
fireGlobals = s.global;
|
|
|
|
// Uppercase the type
|
|
s.type = s.type.toUpperCase();
|
|
|
|
// Determine if request has content
|
|
s.hasContent = !rnoContent.test( s.type );
|
|
|
|
// Watch for a new set of requests
|
|
if ( fireGlobals && jQuery.active++ === 0 ) {
|
|
jQuery.event.trigger( "ajaxStart" );
|
|
}
|
|
|
|
// More options handling for requests with no content
|
|
if ( !s.hasContent ) {
|
|
|
|
// If data is available, append data to url
|
|
if ( s.data ) {
|
|
s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
|
|
}
|
|
|
|
// Get ifModifiedKey before adding the anti-cache parameter
|
|
ifModifiedKey = s.url;
|
|
|
|
// Add anti-cache in url if needed
|
|
if ( s.cache === false ) {
|
|
|
|
var ts = jQuery.now(),
|
|
// try replacing _= if it is there
|
|
ret = s.url.replace( rts, "$1_=" + ts );
|
|
|
|
// if nothing was replaced, add timestamp to the end
|
|
s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
|
|
}
|
|
}
|
|
|
|
// Set the correct header, if data is being sent
|
|
if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
|
|
jqXHR.setRequestHeader( "Content-Type", s.contentType );
|
|
}
|
|
|
|
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
|
|
if ( s.ifModified ) {
|
|
ifModifiedKey = ifModifiedKey || s.url;
|
|
if ( jQuery.lastModified[ ifModifiedKey ] ) {
|
|
jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
|
|
}
|
|
if ( jQuery.etag[ ifModifiedKey ] ) {
|
|
jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
|
|
}
|
|
}
|
|
|
|
// Set the Accepts header for the server, depending on the dataType
|
|
jqXHR.setRequestHeader(
|
|
"Accept",
|
|
s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
|
|
s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", */*; q=0.01" : "" ) :
|
|
s.accepts[ "*" ]
|
|
);
|
|
|
|
// Check for headers option
|
|
for ( i in s.headers ) {
|
|
jqXHR.setRequestHeader( i, s.headers[ i ] );
|
|
}
|
|
|
|
// Allow custom headers/mimetypes and early abort
|
|
if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
|
|
// Abort if not done already
|
|
jqXHR.abort();
|
|
return false;
|
|
|
|
}
|
|
|
|
// Install callbacks on deferreds
|
|
for ( i in { success: 1, error: 1, complete: 1 } ) {
|
|
jqXHR[ i ]( s[ i ] );
|
|
}
|
|
|
|
// Get transport
|
|
transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
|
|
|
|
// If no transport, we auto-abort
|
|
if ( !transport ) {
|
|
done( -1, "No Transport" );
|
|
} else {
|
|
jqXHR.readyState = 1;
|
|
// Send global event
|
|
if ( fireGlobals ) {
|
|
globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
|
|
}
|
|
// Timeout
|
|
if ( s.async && s.timeout > 0 ) {
|
|
timeoutTimer = setTimeout( function(){
|
|
jqXHR.abort( "timeout" );
|
|
}, s.timeout );
|
|
}
|
|
|
|
try {
|
|
state = 1;
|
|
transport.send( requestHeaders, done );
|
|
} catch (e) {
|
|
// Propagate exception as error if not done
|
|
if ( status < 2 ) {
|
|
done( -1, e );
|
|
// Simply rethrow otherwise
|
|
} else {
|
|
jQuery.error( e );
|
|
}
|
|
}
|
|
}
|
|
|
|
return jqXHR;
|
|
},
|
|
|
|
// Serialize an array of form elements or a set of
|
|
// key/values into a query string
|
|
param: function( a, traditional ) {
|
|
var s = [],
|
|
add = function( key, value ) {
|
|
// If value is a function, invoke it and return its value
|
|
value = jQuery.isFunction( value ) ? value() : value;
|
|
s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
|
|
};
|
|
|
|
// Set traditional to true for jQuery <= 1.3.2 behavior.
|
|
if ( traditional === undefined ) {
|
|
traditional = jQuery.ajaxSettings.traditional;
|
|
}
|
|
|
|
// If an array was passed in, assume that it is an array of form elements.
|
|
if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
|
|
// Serialize the form elements
|
|
jQuery.each( a, function() {
|
|
add( this.name, this.value );
|
|
});
|
|
|
|
} else {
|
|
// If traditional, encode the "old" way (the way 1.3.2 or older
|
|
// did it), otherwise encode params recursively.
|
|
for ( var prefix in a ) {
|
|
buildParams( prefix, a[ prefix ], traditional, add );
|
|
}
|
|
}
|
|
|
|
// Return the resulting serialization
|
|
return s.join( "&" ).replace( r20, "+" );
|
|
}
|
|
});
|
|
|
|
function buildParams( prefix, obj, traditional, add ) {
|
|
if ( jQuery.isArray( obj ) ) {
|
|
// Serialize array item.
|
|
jQuery.each( obj, function( i, v ) {
|
|
if ( traditional || rbracket.test( prefix ) ) {
|
|
// Treat each array item as a scalar.
|
|
add( prefix, v );
|
|
|
|
} else {
|
|
// If array item is non-scalar (array or object), encode its
|
|
// numeric index to resolve deserialization ambiguity issues.
|
|
// Note that rack (as of 1.0.0) can't currently deserialize
|
|
// nested arrays properly, and attempting to do so may cause
|
|
// a server error. Possible fixes are to modify rack's
|
|
// deserialization algorithm or to provide an option or flag
|
|
// to force array serialization to be shallow.
|
|
buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
|
|
}
|
|
});
|
|
|
|
} else if ( !traditional && obj != null && typeof obj === "object" ) {
|
|
// Serialize object item.
|
|
for ( var name in obj ) {
|
|
buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
|
|
}
|
|
|
|
} else {
|
|
// Serialize scalar item.
|
|
add( prefix, obj );
|
|
}
|
|
}
|
|
|
|
// This is still on the jQuery object... for now
|
|
// Want to move this to jQuery.ajax some day
|
|
jQuery.extend({
|
|
|
|
// Counter for holding the number of active queries
|
|
active: 0,
|
|
|
|
// Last-Modified header cache for next request
|
|
lastModified: {},
|
|
etag: {}
|
|
|
|
});
|
|
|
|
/* Handles responses to an ajax request:
|
|
* - sets all responseXXX fields accordingly
|
|
* - finds the right dataType (mediates between content-type and expected dataType)
|
|
* - returns the corresponding response
|
|
*/
|
|
function ajaxHandleResponses( s, jqXHR, responses ) {
|
|
|
|
var contents = s.contents,
|
|
dataTypes = s.dataTypes,
|
|
responseFields = s.responseFields,
|
|
ct,
|
|
type,
|
|
finalDataType,
|
|
firstDataType;
|
|
|
|
// Fill responseXXX fields
|
|
for( type in responseFields ) {
|
|
if ( type in responses ) {
|
|
jqXHR[ responseFields[type] ] = responses[ type ];
|
|
}
|
|
}
|
|
|
|
// Remove auto dataType and get content-type in the process
|
|
while( dataTypes[ 0 ] === "*" ) {
|
|
dataTypes.shift();
|
|
if ( ct === undefined ) {
|
|
ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
|
|
}
|
|
}
|
|
|
|
// Check if we're dealing with a known content-type
|
|
if ( ct ) {
|
|
for ( type in contents ) {
|
|
if ( contents[ type ] && contents[ type ].test( ct ) ) {
|
|
dataTypes.unshift( type );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check to see if we have a response for the expected dataType
|
|
if ( dataTypes[ 0 ] in responses ) {
|
|
finalDataType = dataTypes[ 0 ];
|
|
} else {
|
|
// Try convertible dataTypes
|
|
for ( type in responses ) {
|
|
if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
|
|
finalDataType = type;
|
|
break;
|
|
}
|
|
if ( !firstDataType ) {
|
|
firstDataType = type;
|
|
}
|
|
}
|
|
// Or just use first one
|
|
finalDataType = finalDataType || firstDataType;
|
|
}
|
|
|
|
// If we found a dataType
|
|
// We add the dataType to the list if needed
|
|
// and return the corresponding response
|
|
if ( finalDataType ) {
|
|
if ( finalDataType !== dataTypes[ 0 ] ) {
|
|
dataTypes.unshift( finalDataType );
|
|
}
|
|
return responses[ finalDataType ];
|
|
}
|
|
}
|
|
|
|
// Chain conversions given the request and the original response
|
|
function ajaxConvert( s, response ) {
|
|
|
|
// Apply the dataFilter if provided
|
|
if ( s.dataFilter ) {
|
|
response = s.dataFilter( response, s.dataType );
|
|
}
|
|
|
|
var dataTypes = s.dataTypes,
|
|
converters = {},
|
|
i,
|
|
key,
|
|
length = dataTypes.length,
|
|
tmp,
|
|
// Current and previous dataTypes
|
|
current = dataTypes[ 0 ],
|
|
prev,
|
|
// Conversion expression
|
|
conversion,
|
|
// Conversion function
|
|
conv,
|
|
// Conversion functions (transitive conversion)
|
|
conv1,
|
|
conv2;
|
|
|
|
// For each dataType in the chain
|
|
for( i = 1; i < length; i++ ) {
|
|
|
|
// Create converters map
|
|
// with lowercased keys
|
|
if ( i === 1 ) {
|
|
for( key in s.converters ) {
|
|
if( typeof key === "string" ) {
|
|
converters[ key.toLowerCase() ] = s.converters[ key ];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get the dataTypes
|
|
prev = current;
|
|
current = dataTypes[ i ];
|
|
|
|
// If current is auto dataType, update it to prev
|
|
if( current === "*" ) {
|
|
current = prev;
|
|
// If no auto and dataTypes are actually different
|
|
} else if ( prev !== "*" && prev !== current ) {
|
|
|
|
// Get the converter
|
|
conversion = prev + " " + current;
|
|
conv = converters[ conversion ] || converters[ "* " + current ];
|
|
|
|
// If there is no direct converter, search transitively
|
|
if ( !conv ) {
|
|
conv2 = undefined;
|
|
for( conv1 in converters ) {
|
|
tmp = conv1.split( " " );
|
|
if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
|
|
conv2 = converters[ tmp[1] + " " + current ];
|
|
if ( conv2 ) {
|
|
conv1 = converters[ conv1 ];
|
|
if ( conv1 === true ) {
|
|
conv = conv2;
|
|
} else if ( conv2 === true ) {
|
|
conv = conv1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// If we found no converter, dispatch an error
|
|
if ( !( conv || conv2 ) ) {
|
|
jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
|
|
}
|
|
// If found converter is not an equivalence
|
|
if ( conv !== true ) {
|
|
// Convert with 1 or 2 converters accordingly
|
|
response = conv ? conv( response ) : conv2( conv1(response) );
|
|
}
|
|
}
|
|
}
|
|
return response;
|
|
}
|
|
|
|
|
|
|
|
|
|
var jsc = jQuery.now(),
|
|
jsre = /(\=)\?(&|$)|\?\?/i;
|
|
|
|
// Default jsonp settings
|
|
jQuery.ajaxSetup({
|
|
jsonp: "callback",
|
|
jsonpCallback: function() {
|
|
return jQuery.expando + "_" + ( jsc++ );
|
|
}
|
|
});
|
|
|
|
// Detect, normalize options and install callbacks for jsonp requests
|
|
jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
|
|
|
|
var inspectData = s.contentType === "application/x-www-form-urlencoded" &&
|
|
( typeof s.data === "string" );
|
|
|
|
if ( s.dataTypes[ 0 ] === "jsonp" ||
|
|
s.jsonp !== false && ( jsre.test( s.url ) ||
|
|
inspectData && jsre.test( s.data ) ) ) {
|
|
|
|
var responseContainer,
|
|
jsonpCallback = s.jsonpCallback =
|
|
jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
|
|
previous = window[ jsonpCallback ],
|
|
url = s.url,
|
|
data = s.data,
|
|
replace = "$1" + jsonpCallback + "$2";
|
|
|
|
if ( s.jsonp !== false ) {
|
|
url = url.replace( jsre, replace );
|
|
if ( s.url === url ) {
|
|
if ( inspectData ) {
|
|
data = data.replace( jsre, replace );
|
|
}
|
|
if ( s.data === data ) {
|
|
// Add callback manually
|
|
url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.url = url;
|
|
s.data = data;
|
|
|
|
// Install callback
|
|
window[ jsonpCallback ] = function( response ) {
|
|
responseContainer = [ response ];
|
|
};
|
|
|
|
// Clean-up function
|
|
jqXHR.always(function() {
|
|
// Set callback back to previous value
|
|
window[ jsonpCallback ] = previous;
|
|
// Call if it was a function and we have a response
|
|
if ( responseContainer && jQuery.isFunction( previous ) ) {
|
|
window[ jsonpCallback ]( responseContainer[ 0 ] );
|
|
}
|
|
});
|
|
|
|
// Use data converter to retrieve json after script execution
|
|
s.converters["script json"] = function() {
|
|
if ( !responseContainer ) {
|
|
jQuery.error( jsonpCallback + " was not called" );
|
|
}
|
|
return responseContainer[ 0 ];
|
|
};
|
|
|
|
// force json dataType
|
|
s.dataTypes[ 0 ] = "json";
|
|
|
|
// Delegate to script
|
|
return "script";
|
|
}
|
|
});
|
|
|
|
|
|
|
|
|
|
// Install script dataType
|
|
jQuery.ajaxSetup({
|
|
accepts: {
|
|
script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
|
|
},
|
|
contents: {
|
|
script: /javascript|ecmascript/
|
|
},
|
|
converters: {
|
|
"text script": function( text ) {
|
|
jQuery.globalEval( text );
|
|
return text;
|
|
}
|
|
}
|
|
});
|
|
|
|
// Handle cache's special case and global
|
|
jQuery.ajaxPrefilter( "script", function( s ) {
|
|
if ( s.cache === undefined ) {
|
|
s.cache = false;
|
|
}
|
|
if ( s.crossDomain ) {
|
|
s.type = "GET";
|
|
s.global = false;
|
|
}
|
|
});
|
|
|
|
// Bind script tag hack transport
|
|
jQuery.ajaxTransport( "script", function(s) {
|
|
|
|
// This transport only deals with cross domain requests
|
|
if ( s.crossDomain ) {
|
|
|
|
var script,
|
|
head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
|
|
|
|
return {
|
|
|
|
send: function( _, callback ) {
|
|
|
|
script = document.createElement( "script" );
|
|
|
|
script.async = "async";
|
|
|
|
if ( s.scriptCharset ) {
|
|
script.charset = s.scriptCharset;
|
|
}
|
|
|
|
script.src = s.url;
|
|
|
|
// Attach handlers for all browsers
|
|
script.onload = script.onreadystatechange = function( _, isAbort ) {
|
|
|
|
if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
|
|
|
|
// Handle memory leak in IE
|
|
script.onload = script.onreadystatechange = null;
|
|
|
|
// Remove the script
|
|
if ( head && script.parentNode ) {
|
|
head.removeChild( script );
|
|
}
|
|
|
|
// Dereference the script
|
|
script = undefined;
|
|
|
|
// Callback if not abort
|
|
if ( !isAbort ) {
|
|
callback( 200, "success" );
|
|
}
|
|
}
|
|
};
|
|
// Use insertBefore instead of appendChild to circumvent an IE6 bug.
|
|
// This arises when a base node is used (#2709 and #4378).
|
|
head.insertBefore( script, head.firstChild );
|
|
},
|
|
|
|
abort: function() {
|
|
if ( script ) {
|
|
script.onload( 0, 1 );
|
|
}
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
|
|
|
|
|
|
var // #5280: Internet Explorer will keep connections alive if we don't abort on unload
|
|
xhrOnUnloadAbort = window.ActiveXObject ? function() {
|
|
// Abort all pending requests
|
|
for ( var key in xhrCallbacks ) {
|
|
xhrCallbacks[ key ]( 0, 1 );
|
|
}
|
|
} : false,
|
|
xhrId = 0,
|
|
xhrCallbacks;
|
|
|
|
// Functions to create xhrs
|
|
function createStandardXHR() {
|
|
try {
|
|
return new window.XMLHttpRequest();
|
|
} catch( e ) {}
|
|
}
|
|
|
|
function createActiveXHR() {
|
|
try {
|
|
return new window.ActiveXObject( "Microsoft.XMLHTTP" );
|
|
} catch( e ) {}
|
|
}
|
|
|
|
// Create the request object
|
|
// (This is still attached to ajaxSettings for backward compatibility)
|
|
jQuery.ajaxSettings.xhr = window.ActiveXObject ?
|
|
/* Microsoft failed to properly
|
|
* implement the XMLHttpRequest in IE7 (can't request local files),
|
|
* so we use the ActiveXObject when it is available
|
|
* Additionally XMLHttpRequest can be disabled in IE7/IE8 so
|
|
* we need a fallback.
|
|
*/
|
|
function() {
|
|
return !this.isLocal && createStandardXHR() || createActiveXHR();
|
|
} :
|
|
// For all other browsers, use the standard XMLHttpRequest object
|
|
createStandardXHR;
|
|
|
|
// Determine support properties
|
|
(function( xhr ) {
|
|
jQuery.extend( jQuery.support, {
|
|
ajax: !!xhr,
|
|
cors: !!xhr && ( "withCredentials" in xhr )
|
|
});
|
|
})( jQuery.ajaxSettings.xhr() );
|
|
|
|
// Create transport if the browser can provide an xhr
|
|
if ( jQuery.support.ajax ) {
|
|
|
|
jQuery.ajaxTransport(function( s ) {
|
|
// Cross domain only allowed if supported through XMLHttpRequest
|
|
if ( !s.crossDomain || jQuery.support.cors ) {
|
|
|
|
var callback;
|
|
|
|
return {
|
|
send: function( headers, complete ) {
|
|
|
|
// Get a new xhr
|
|
var xhr = s.xhr(),
|
|
handle,
|
|
i;
|
|
|
|
// Open the socket
|
|
// Passing null username, generates a login popup on Opera (#2865)
|
|
if ( s.username ) {
|
|
xhr.open( s.type, s.url, s.async, s.username, s.password );
|
|
} else {
|
|
xhr.open( s.type, s.url, s.async );
|
|
}
|
|
|
|
// Apply custom fields if provided
|
|
if ( s.xhrFields ) {
|
|
for ( i in s.xhrFields ) {
|
|
xhr[ i ] = s.xhrFields[ i ];
|
|
}
|
|
}
|
|
|
|
// Override mime type if needed
|
|
if ( s.mimeType && xhr.overrideMimeType ) {
|
|
xhr.overrideMimeType( s.mimeType );
|
|
}
|
|
|
|
// X-Requested-With header
|
|
// For cross-domain requests, seeing as conditions for a preflight are
|
|
// akin to a jigsaw puzzle, we simply never set it to be sure.
|
|
// (it can always be set on a per-request basis or even using ajaxSetup)
|
|
// For same-domain requests, won't change header if already provided.
|
|
if ( !s.crossDomain && !headers["X-Requested-With"] ) {
|
|
headers[ "X-Requested-With" ] = "XMLHttpRequest";
|
|
}
|
|
|
|
// Need an extra try/catch for cross domain requests in Firefox 3
|
|
try {
|
|
for ( i in headers ) {
|
|
xhr.setRequestHeader( i, headers[ i ] );
|
|
}
|
|
} catch( _ ) {}
|
|
|
|
// Do send the request
|
|
// This may raise an exception which is actually
|
|
// handled in jQuery.ajax (so no try/catch here)
|
|
xhr.send( ( s.hasContent && s.data ) || null );
|
|
|
|
// Listener
|
|
callback = function( _, isAbort ) {
|
|
|
|
var status,
|
|
statusText,
|
|
responseHeaders,
|
|
responses,
|
|
xml;
|
|
|
|
// Firefox throws exceptions when accessing properties
|
|
// of an xhr when a network error occured
|
|
// http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
|
|
try {
|
|
|
|
// Was never called and is aborted or complete
|
|
if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
|
|
|
|
// Only called once
|
|
callback = undefined;
|
|
|
|
// Do not keep as active anymore
|
|
if ( handle ) {
|
|
xhr.onreadystatechange = jQuery.noop;
|
|
if ( xhrOnUnloadAbort ) {
|
|
delete xhrCallbacks[ handle ];
|
|
}
|
|
}
|
|
|
|
// If it's an abort
|
|
if ( isAbort ) {
|
|
// Abort it manually if needed
|
|
if ( xhr.readyState !== 4 ) {
|
|
xhr.abort();
|
|
}
|
|
} else {
|
|
status = xhr.status;
|
|
responseHeaders = xhr.getAllResponseHeaders();
|
|
responses = {};
|
|
xml = xhr.responseXML;
|
|
|
|
// Construct response list
|
|
if ( xml && xml.documentElement /* #4958 */ ) {
|
|
responses.xml = xml;
|
|
}
|
|
responses.text = xhr.responseText;
|
|
|
|
// Firefox throws an exception when accessing
|
|
// statusText for faulty cross-domain requests
|
|
try {
|
|
statusText = xhr.statusText;
|
|
} catch( e ) {
|
|
// We normalize with Webkit giving an empty statusText
|
|
statusText = "";
|
|
}
|
|
|
|
// Filter status for non standard behaviors
|
|
|
|
// If the request is local and we have data: assume a success
|
|
// (success with no data won't get notified, that's the best we
|
|
// can do given current implementations)
|
|
if ( !status && s.isLocal && !s.crossDomain ) {
|
|
status = responses.text ? 200 : 404;
|
|
// IE - #1450: sometimes returns 1223 when it should be 204
|
|
} else if ( status === 1223 ) {
|
|
status = 204;
|
|
}
|
|
}
|
|
}
|
|
} catch( firefoxAccessException ) {
|
|
if ( !isAbort ) {
|
|
complete( -1, firefoxAccessException );
|
|
}
|
|
}
|
|
|
|
// Call complete if needed
|
|
if ( responses ) {
|
|
complete( status, statusText, responses, responseHeaders );
|
|
}
|
|
};
|
|
|
|
// if we're in sync mode or it's in cache
|
|
// and has been retrieved directly (IE6 & IE7)
|
|
// we need to manually fire the callback
|
|
if ( !s.async || xhr.readyState === 4 ) {
|
|
callback();
|
|
} else {
|
|
handle = ++xhrId;
|
|
if ( xhrOnUnloadAbort ) {
|
|
// Create the active xhrs callbacks list if needed
|
|
// and attach the unload handler
|
|
if ( !xhrCallbacks ) {
|
|
xhrCallbacks = {};
|
|
jQuery( window ).unload( xhrOnUnloadAbort );
|
|
}
|
|
// Add to list of active xhrs callbacks
|
|
xhrCallbacks[ handle ] = callback;
|
|
}
|
|
xhr.onreadystatechange = callback;
|
|
}
|
|
},
|
|
|
|
abort: function() {
|
|
if ( callback ) {
|
|
callback(0,1);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
|
|
|
|
var elemdisplay = {},
|
|
iframe, iframeDoc,
|
|
rfxtypes = /^(?:toggle|show|hide)$/,
|
|
rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
|
|
timerId,
|
|
fxAttrs = [
|
|
// height animations
|
|
[ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
|
|
// width animations
|
|
[ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
|
|
// opacity animations
|
|
[ "opacity" ]
|
|
],
|
|
fxNow,
|
|
requestAnimationFrame = window.webkitRequestAnimationFrame ||
|
|
window.mozRequestAnimationFrame ||
|
|
window.oRequestAnimationFrame;
|
|
|
|
jQuery.fn.extend({
|
|
show: function( speed, easing, callback ) {
|
|
var elem, display;
|
|
|
|
if ( speed || speed === 0 ) {
|
|
return this.animate( genFx("show", 3), speed, easing, callback);
|
|
|
|
} else {
|
|
for ( var i = 0, j = this.length; i < j; i++ ) {
|
|
elem = this[i];
|
|
|
|
if ( elem.style ) {
|
|
display = elem.style.display;
|
|
|
|
// Reset the inline display of this element to learn if it is
|
|
// being hidden by cascaded rules or not
|
|
if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
|
|
display = elem.style.display = "";
|
|
}
|
|
|
|
// Set elements which have been overridden with display: none
|
|
// in a stylesheet to whatever the default browser style is
|
|
// for such an element
|
|
if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
|
|
jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set the display of most of the elements in a second loop
|
|
// to avoid the constant reflow
|
|
for ( i = 0; i < j; i++ ) {
|
|
elem = this[i];
|
|
|
|
if ( elem.style ) {
|
|
display = elem.style.display;
|
|
|
|
if ( display === "" || display === "none" ) {
|
|
elem.style.display = jQuery._data(elem, "olddisplay") || "";
|
|
}
|
|
}
|
|
}
|
|
|
|
return this;
|
|
}
|
|
},
|
|
|
|
hide: function( speed, easing, callback ) {
|
|
if ( speed || speed === 0 ) {
|
|
return this.animate( genFx("hide", 3), speed, easing, callback);
|
|
|
|
} else {
|
|
for ( var i = 0, j = this.length; i < j; i++ ) {
|
|
if ( this[i].style ) {
|
|
var display = jQuery.css( this[i], "display" );
|
|
|
|
if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) {
|
|
jQuery._data( this[i], "olddisplay", display );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set the display of the elements in a second loop
|
|
// to avoid the constant reflow
|
|
for ( i = 0; i < j; i++ ) {
|
|
if ( this[i].style ) {
|
|
this[i].style.display = "none";
|
|
}
|
|
}
|
|
|
|
return this;
|
|
}
|
|
},
|
|
|
|
// Save the old toggle function
|
|
_toggle: jQuery.fn.toggle,
|
|
|
|
toggle: function( fn, fn2, callback ) {
|
|
var bool = typeof fn === "boolean";
|
|
|
|
if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
|
|
this._toggle.apply( this, arguments );
|
|
|
|
} else if ( fn == null || bool ) {
|
|
this.each(function() {
|
|
var state = bool ? fn : jQuery(this).is(":hidden");
|
|
jQuery(this)[ state ? "show" : "hide" ]();
|
|
});
|
|
|
|
} else {
|
|
this.animate(genFx("toggle", 3), fn, fn2, callback);
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
fadeTo: function( speed, to, easing, callback ) {
|
|
return this.filter(":hidden").css("opacity", 0).show().end()
|
|
.animate({opacity: to}, speed, easing, callback);
|
|
},
|
|
|
|
animate: function( prop, speed, easing, callback ) {
|
|
var optall = jQuery.speed(speed, easing, callback);
|
|
|
|
if ( jQuery.isEmptyObject( prop ) ) {
|
|
return this.each( optall.complete, [ false ] );
|
|
}
|
|
|
|
// Do not change referenced properties as per-property easing will be lost
|
|
prop = jQuery.extend( {}, prop );
|
|
|
|
return this[ optall.queue === false ? "each" : "queue" ](function() {
|
|
// XXX 'this' does not always have a nodeName when running the
|
|
// test suite
|
|
|
|
if ( optall.queue === false ) {
|
|
jQuery._mark( this );
|
|
}
|
|
|
|
var opt = jQuery.extend( {}, optall ),
|
|
isElement = this.nodeType === 1,
|
|
hidden = isElement && jQuery(this).is(":hidden"),
|
|
name, val, p,
|
|
display, e,
|
|
parts, start, end, unit;
|
|
|
|
// will store per property easing and be used to determine when an animation is complete
|
|
opt.animatedProperties = {};
|
|
|
|
for ( p in prop ) {
|
|
|
|
// property name normalization
|
|
name = jQuery.camelCase( p );
|
|
if ( p !== name ) {
|
|
prop[ name ] = prop[ p ];
|
|
delete prop[ p ];
|
|
}
|
|
|
|
val = prop[ name ];
|
|
|
|
// easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
|
|
if ( jQuery.isArray( val ) ) {
|
|
opt.animatedProperties[ name ] = val[ 1 ];
|
|
val = prop[ name ] = val[ 0 ];
|
|
} else {
|
|
opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] || opt.easing || 'swing';
|
|
}
|
|
|
|
if ( val === "hide" && hidden || val === "show" && !hidden ) {
|
|
return opt.complete.call( this );
|
|
}
|
|
|
|
if ( isElement && ( name === "height" || name === "width" ) ) {
|
|
// Make sure that nothing sneaks out
|
|
// Record all 3 overflow attributes because IE does not
|
|
// change the overflow attribute when overflowX and
|
|
// overflowY are set to the same value
|
|
opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
|
|
|
|
// Set display property to inline-block for height/width
|
|
// animations on inline elements that are having width/height
|
|
// animated
|
|
if ( jQuery.css( this, "display" ) === "inline" &&
|
|
jQuery.css( this, "float" ) === "none" ) {
|
|
if ( !jQuery.support.inlineBlockNeedsLayout ) {
|
|
this.style.display = "inline-block";
|
|
|
|
} else {
|
|
display = defaultDisplay( this.nodeName );
|
|
|
|
// inline-level elements accept inline-block;
|
|
// block-level elements need to be inline with layout
|
|
if ( display === "inline" ) {
|
|
this.style.display = "inline-block";
|
|
|
|
} else {
|
|
this.style.display = "inline";
|
|
this.style.zoom = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( opt.overflow != null ) {
|
|
this.style.overflow = "hidden";
|
|
}
|
|
|
|
for ( p in prop ) {
|
|
e = new jQuery.fx( this, opt, p );
|
|
val = prop[ p ];
|
|
|
|
if ( rfxtypes.test(val) ) {
|
|
e[ val === "toggle" ? hidden ? "show" : "hide" : val ]();
|
|
|
|
} else {
|
|
parts = rfxnum.exec( val );
|
|
start = e.cur();
|
|
|
|
if ( parts ) {
|
|
end = parseFloat( parts[2] );
|
|
unit = parts[3] || ( jQuery.cssNumber[ p ] ? "" : "px" );
|
|
|
|
// We need to compute starting value
|
|
if ( unit !== "px" ) {
|
|
jQuery.style( this, p, (end || 1) + unit);
|
|
start = ((end || 1) / e.cur()) * start;
|
|
jQuery.style( this, p, start + unit);
|
|
}
|
|
|
|
// If a +=/-= token was provided, we're doing a relative animation
|
|
if ( parts[1] ) {
|
|
end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
|
|
}
|
|
|
|
e.custom( start, end, unit );
|
|
|
|
} else {
|
|
e.custom( start, val, "" );
|
|
}
|
|
}
|
|
}
|
|
|
|
// For JS strict compliance
|
|
return true;
|
|
});
|
|
},
|
|
|
|
stop: function( clearQueue, gotoEnd ) {
|
|
if ( clearQueue ) {
|
|
this.queue([]);
|
|
}
|
|
|
|
this.each(function() {
|
|
var timers = jQuery.timers,
|
|
i = timers.length;
|
|
// clear marker counters if we know they won't be
|
|
if ( !gotoEnd ) {
|
|
jQuery._unmark( true, this );
|
|
}
|
|
while ( i-- ) {
|
|
if ( timers[i].elem === this ) {
|
|
if (gotoEnd) {
|
|
// force the next step to be the last
|
|
timers[i](true);
|
|
}
|
|
|
|
timers.splice(i, 1);
|
|
}
|
|
}
|
|
});
|
|
|
|
// start the next in the queue if the last step wasn't forced
|
|
if ( !gotoEnd ) {
|
|
this.dequeue();
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
});
|
|
|
|
// Animations created synchronously will run synchronously
|
|
function createFxNow() {
|
|
setTimeout( clearFxNow, 0 );
|
|
return ( fxNow = jQuery.now() );
|
|
}
|
|
|
|
function clearFxNow() {
|
|
fxNow = undefined;
|
|
}
|
|
|
|
// Generate parameters to create a standard animation
|
|
function genFx( type, num ) {
|
|
var obj = {};
|
|
|
|
jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
|
|
obj[ this ] = type;
|
|
});
|
|
|
|
return obj;
|
|
}
|
|
|
|
// Generate shortcuts for custom animations
|
|
jQuery.each({
|
|
slideDown: genFx("show", 1),
|
|
slideUp: genFx("hide", 1),
|
|
slideToggle: genFx("toggle", 1),
|
|
fadeIn: { opacity: "show" },
|
|
fadeOut: { opacity: "hide" },
|
|
fadeToggle: { opacity: "toggle" }
|
|
}, function( name, props ) {
|
|
jQuery.fn[ name ] = function( speed, easing, callback ) {
|
|
return this.animate( props, speed, easing, callback );
|
|
};
|
|
});
|
|
|
|
jQuery.extend({
|
|
speed: function( speed, easing, fn ) {
|
|
var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
|
|
complete: fn || !fn && easing ||
|
|
jQuery.isFunction( speed ) && speed,
|
|
duration: speed,
|
|
easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
|
|
};
|
|
|
|
opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
|
|
opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
|
|
|
|
// Queueing
|
|
opt.old = opt.complete;
|
|
opt.complete = function( noUnmark ) {
|
|
if ( jQuery.isFunction( opt.old ) ) {
|
|
opt.old.call( this );
|
|
}
|
|
|
|
if ( opt.queue !== false ) {
|
|
jQuery.dequeue( this );
|
|
} else if ( noUnmark !== false ) {
|
|
jQuery._unmark( this );
|
|
}
|
|
};
|
|
|
|
return opt;
|
|
},
|
|
|
|
easing: {
|
|
linear: function( p, n, firstNum, diff ) {
|
|
return firstNum + diff * p;
|
|
},
|
|
swing: function( p, n, firstNum, diff ) {
|
|
return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
|
|
}
|
|
},
|
|
|
|
timers: [],
|
|
|
|
fx: function( elem, options, prop ) {
|
|
this.options = options;
|
|
this.elem = elem;
|
|
this.prop = prop;
|
|
|
|
options.orig = options.orig || {};
|
|
}
|
|
|
|
});
|
|
|
|
jQuery.fx.prototype = {
|
|
// Simple function for setting a style value
|
|
update: function() {
|
|
if ( this.options.step ) {
|
|
this.options.step.call( this.elem, this.now, this );
|
|
}
|
|
|
|
(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
|
|
},
|
|
|
|
// Get the current size
|
|
cur: function() {
|
|
if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
|
|
return this.elem[ this.prop ];
|
|
}
|
|
|
|
var parsed,
|
|
r = jQuery.css( this.elem, this.prop );
|
|
// Empty strings, null, undefined and "auto" are converted to 0,
|
|
// complex values such as "rotate(1rad)" are returned as is,
|
|
// simple values such as "10px" are parsed to Float.
|
|
return isNaN( parsed = parseFloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
|
|
},
|
|
|
|
// Start an animation from one number to another
|
|
custom: function( from, to, unit ) {
|
|
var self = this,
|
|
fx = jQuery.fx,
|
|
raf;
|
|
|
|
this.startTime = fxNow || createFxNow();
|
|
this.start = from;
|
|
this.end = to;
|
|
this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
|
|
this.now = this.start;
|
|
this.pos = this.state = 0;
|
|
|
|
function t( gotoEnd ) {
|
|
return self.step(gotoEnd);
|
|
}
|
|
|
|
t.elem = this.elem;
|
|
|
|
if ( t() && jQuery.timers.push(t) && !timerId ) {
|
|
// Use requestAnimationFrame instead of setInterval if available
|
|
if ( requestAnimationFrame ) {
|
|
timerId = true;
|
|
raf = function() {
|
|
// When timerId gets set to null at any point, this stops
|
|
if ( timerId ) {
|
|
requestAnimationFrame( raf );
|
|
fx.tick();
|
|
}
|
|
};
|
|
requestAnimationFrame( raf );
|
|
} else {
|
|
timerId = setInterval( fx.tick, fx.interval );
|
|
}
|
|
}
|
|
},
|
|
|
|
// Simple 'show' function
|
|
show: function() {
|
|
// Remember where we started, so that we can go back to it later
|
|
this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
|
|
this.options.show = true;
|
|
|
|
// Begin the animation
|
|
// Make sure that we start at a small width/height to avoid any
|
|
// flash of content
|
|
this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
|
|
|
|
// Start by showing the element
|
|
jQuery( this.elem ).show();
|
|
},
|
|
|
|
// Simple 'hide' function
|
|
hide: function() {
|
|
// Remember where we started, so that we can go back to it later
|
|
this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
|
|
this.options.hide = true;
|
|
|
|
// Begin the animation
|
|
this.custom(this.cur(), 0);
|
|
},
|
|
|
|
// Each step of an animation
|
|
step: function( gotoEnd ) {
|
|
var t = fxNow || createFxNow(),
|
|
done = true,
|
|
elem = this.elem,
|
|
options = this.options,
|
|
i, n;
|
|
|
|
if ( gotoEnd || t >= options.duration + this.startTime ) {
|
|
this.now = this.end;
|
|
this.pos = this.state = 1;
|
|
this.update();
|
|
|
|
options.animatedProperties[ this.prop ] = true;
|
|
|
|
for ( i in options.animatedProperties ) {
|
|
if ( options.animatedProperties[i] !== true ) {
|
|
done = false;
|
|
}
|
|
}
|
|
|
|
if ( done ) {
|
|
// Reset the overflow
|
|
if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
|
|
|
|
jQuery.each( [ "", "X", "Y" ], function (index, value) {
|
|
elem.style[ "overflow" + value ] = options.overflow[index];
|
|
});
|
|
}
|
|
|
|
// Hide the element if the "hide" operation was done
|
|
if ( options.hide ) {
|
|
jQuery(elem).hide();
|
|
}
|
|
|
|
// Reset the properties, if the item has been hidden or shown
|
|
if ( options.hide || options.show ) {
|
|
for ( var p in options.animatedProperties ) {
|
|
jQuery.style( elem, p, options.orig[p] );
|
|
}
|
|
}
|
|
|
|
// Execute the complete function
|
|
options.complete.call( elem );
|
|
}
|
|
|
|
return false;
|
|
|
|
} else {
|
|
// classical easing cannot be used with an Infinity duration
|
|
if ( options.duration == Infinity ) {
|
|
this.now = t;
|
|
} else {
|
|
n = t - this.startTime;
|
|
this.state = n / options.duration;
|
|
|
|
// Perform the easing function, defaults to swing
|
|
this.pos = jQuery.easing[ options.animatedProperties[ this.prop ] ]( this.state, n, 0, 1, options.duration );
|
|
this.now = this.start + ((this.end - this.start) * this.pos);
|
|
}
|
|
// Perform the next step of the animation
|
|
this.update();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
jQuery.extend( jQuery.fx, {
|
|
tick: function() {
|
|
for ( var timers = jQuery.timers, i = 0 ; i < timers.length ; ++i ) {
|
|
if ( !timers[i]() ) {
|
|
timers.splice(i--, 1);
|
|
}
|
|
}
|
|
|
|
if ( !timers.length ) {
|
|
jQuery.fx.stop();
|
|
}
|
|
},
|
|
|
|
interval: 13,
|
|
|
|
stop: function() {
|
|
clearInterval( timerId );
|
|
timerId = null;
|
|
},
|
|
|
|
speeds: {
|
|
slow: 600,
|
|
fast: 200,
|
|
// Default speed
|
|
_default: 400
|
|
},
|
|
|
|
step: {
|
|
opacity: function( fx ) {
|
|
jQuery.style( fx.elem, "opacity", fx.now );
|
|
},
|
|
|
|
_default: function( fx ) {
|
|
if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
|
|
fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
|
|
} else {
|
|
fx.elem[ fx.prop ] = fx.now;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
if ( jQuery.expr && jQuery.expr.filters ) {
|
|
jQuery.expr.filters.animated = function( elem ) {
|
|
return jQuery.grep(jQuery.timers, function( fn ) {
|
|
return elem === fn.elem;
|
|
}).length;
|
|
};
|
|
}
|
|
|
|
// Try to restore the default display value of an element
|
|
function defaultDisplay( nodeName ) {
|
|
|
|
if ( !elemdisplay[ nodeName ] ) {
|
|
|
|
var body = document.body,
|
|
elem = jQuery( "<" + nodeName + ">" ).appendTo( body ),
|
|
display = elem.css( "display" );
|
|
|
|
elem.remove();
|
|
|
|
// If the simple way fails,
|
|
// get element's real default display by attaching it to a temp iframe
|
|
if ( display === "none" || display === "" ) {
|
|
// No iframe to use yet, so create it
|
|
if ( !iframe ) {
|
|
iframe = document.createElement( "iframe" );
|
|
iframe.frameBorder = iframe.width = iframe.height = 0;
|
|
}
|
|
|
|
body.appendChild( iframe );
|
|
|
|
// Create a cacheable copy of the iframe document on first call.
|
|
// IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML
|
|
// document to it; WebKit & Firefox won't allow reusing the iframe document.
|
|
if ( !iframeDoc || !iframe.createElement ) {
|
|
iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
|
|
iframeDoc.write( ( document.compatMode === "CSS1Compat" ? "<!doctype html>" : "" ) + "<html><body>" );
|
|
iframeDoc.close();
|
|
}
|
|
|
|
elem = iframeDoc.createElement( nodeName );
|
|
|
|
iframeDoc.body.appendChild( elem );
|
|
|
|
display = jQuery.css( elem, "display" );
|
|
|
|
body.removeChild( iframe );
|
|
}
|
|
|
|
// Store the correct default display
|
|
elemdisplay[ nodeName ] = display;
|
|
}
|
|
|
|
return elemdisplay[ nodeName ];
|
|
}
|
|
|
|
|
|
|
|
|
|
var rtable = /^t(?:able|d|h)$/i,
|
|
rroot = /^(?:body|html)$/i;
|
|
|
|
if ( "getBoundingClientRect" in document.documentElement ) {
|
|
jQuery.fn.offset = function( options ) {
|
|
var elem = this[0], box;
|
|
|
|
if ( options ) {
|
|
return this.each(function( i ) {
|
|
jQuery.offset.setOffset( this, options, i );
|
|
});
|
|
}
|
|
|
|
if ( !elem || !elem.ownerDocument ) {
|
|
return null;
|
|
}
|
|
|
|
if ( elem === elem.ownerDocument.body ) {
|
|
return jQuery.offset.bodyOffset( elem );
|
|
}
|
|
|
|
try {
|
|
box = elem.getBoundingClientRect();
|
|
} catch(e) {}
|
|
|
|
var doc = elem.ownerDocument,
|
|
docElem = doc.documentElement;
|
|
|
|
// Make sure we're not dealing with a disconnected DOM node
|
|
if ( !box || !jQuery.contains( docElem, elem ) ) {
|
|
return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
|
|
}
|
|
|
|
var body = doc.body,
|
|
win = getWindow(doc),
|
|
clientTop = docElem.clientTop || body.clientTop || 0,
|
|
clientLeft = docElem.clientLeft || body.clientLeft || 0,
|
|
scrollTop = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop || body.scrollTop,
|
|
scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft,
|
|
top = box.top + scrollTop - clientTop,
|
|
left = box.left + scrollLeft - clientLeft;
|
|
|
|
return { top: top, left: left };
|
|
};
|
|
|
|
} else {
|
|
jQuery.fn.offset = function( options ) {
|
|
var elem = this[0];
|
|
|
|
if ( options ) {
|
|
return this.each(function( i ) {
|
|
jQuery.offset.setOffset( this, options, i );
|
|
});
|
|
}
|
|
|
|
if ( !elem || !elem.ownerDocument ) {
|
|
return null;
|
|
}
|
|
|
|
if ( elem === elem.ownerDocument.body ) {
|
|
return jQuery.offset.bodyOffset( elem );
|
|
}
|
|
|
|
jQuery.offset.initialize();
|
|
|
|
var computedStyle,
|
|
offsetParent = elem.offsetParent,
|
|
prevOffsetParent = elem,
|
|
doc = elem.ownerDocument,
|
|
docElem = doc.documentElement,
|
|
body = doc.body,
|
|
defaultView = doc.defaultView,
|
|
prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
|
|
top = elem.offsetTop,
|
|
left = elem.offsetLeft;
|
|
|
|
while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
|
|
if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
|
|
break;
|
|
}
|
|
|
|
computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
|
|
top -= elem.scrollTop;
|
|
left -= elem.scrollLeft;
|
|
|
|
if ( elem === offsetParent ) {
|
|
top += elem.offsetTop;
|
|
left += elem.offsetLeft;
|
|
|
|
if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
|
|
top += parseFloat( computedStyle.borderTopWidth ) || 0;
|
|
left += parseFloat( computedStyle.borderLeftWidth ) || 0;
|
|
}
|
|
|
|
prevOffsetParent = offsetParent;
|
|
offsetParent = elem.offsetParent;
|
|
}
|
|
|
|
if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
|
|
top += parseFloat( computedStyle.borderTopWidth ) || 0;
|
|
left += parseFloat( computedStyle.borderLeftWidth ) || 0;
|
|
}
|
|
|
|
prevComputedStyle = computedStyle;
|
|
}
|
|
|
|
if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
|
|
top += body.offsetTop;
|
|
left += body.offsetLeft;
|
|
}
|
|
|
|
if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
|
|
top += Math.max( docElem.scrollTop, body.scrollTop );
|
|
left += Math.max( docElem.scrollLeft, body.scrollLeft );
|
|
}
|
|
|
|
return { top: top, left: left };
|
|
};
|
|
}
|
|
|
|
jQuery.offset = {
|
|
initialize: function() {
|
|
var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
|
|
html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
|
|
|
|
jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
|
|
|
|
container.innerHTML = html;
|
|
body.insertBefore( container, body.firstChild );
|
|
innerDiv = container.firstChild;
|
|
checkDiv = innerDiv.firstChild;
|
|
td = innerDiv.nextSibling.firstChild.firstChild;
|
|
|
|
this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
|
|
this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
|
|
|
|
checkDiv.style.position = "fixed";
|
|
checkDiv.style.top = "20px";
|
|
|
|
// safari subtracts parent border width here which is 5px
|
|
this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
|
|
checkDiv.style.position = checkDiv.style.top = "";
|
|
|
|
innerDiv.style.overflow = "hidden";
|
|
innerDiv.style.position = "relative";
|
|
|
|
this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
|
|
|
|
this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
|
|
|
|
body.removeChild( container );
|
|
jQuery.offset.initialize = jQuery.noop;
|
|
},
|
|
|
|
bodyOffset: function( body ) {
|
|
var top = body.offsetTop,
|
|
left = body.offsetLeft;
|
|
|
|
jQuery.offset.initialize();
|
|
|
|
if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
|
|
top += parseFloat( jQuery.css(body, "marginTop") ) || 0;
|
|
left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
|
|
}
|
|
|
|
return { top: top, left: left };
|
|
},
|
|
|
|
setOffset: function( elem, options, i ) {
|
|
var position = jQuery.css( elem, "position" );
|
|
|
|
// set position first, in-case top/left are set even on static elem
|
|
if ( position === "static" ) {
|
|
elem.style.position = "relative";
|
|
}
|
|
|
|
var curElem = jQuery( elem ),
|
|
curOffset = curElem.offset(),
|
|
curCSSTop = jQuery.css( elem, "top" ),
|
|
curCSSLeft = jQuery.css( elem, "left" ),
|
|
calculatePosition = (position === "absolute" || position === "fixed") && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
|
|
props = {}, curPosition = {}, curTop, curLeft;
|
|
|
|
// need to be able to calculate position if either top or left is auto and position is either absolute or fixed
|
|
if ( calculatePosition ) {
|
|
curPosition = curElem.position();
|
|
curTop = curPosition.top;
|
|
curLeft = curPosition.left;
|
|
} else {
|
|
curTop = parseFloat( curCSSTop ) || 0;
|
|
curLeft = parseFloat( curCSSLeft ) || 0;
|
|
}
|
|
|
|
if ( jQuery.isFunction( options ) ) {
|
|
options = options.call( elem, i, curOffset );
|
|
}
|
|
|
|
if (options.top != null) {
|
|
props.top = (options.top - curOffset.top) + curTop;
|
|
}
|
|
if (options.left != null) {
|
|
props.left = (options.left - curOffset.left) + curLeft;
|
|
}
|
|
|
|
if ( "using" in options ) {
|
|
options.using.call( elem, props );
|
|
} else {
|
|
curElem.css( props );
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
jQuery.fn.extend({
|
|
position: function() {
|
|
if ( !this[0] ) {
|
|
return null;
|
|
}
|
|
|
|
var elem = this[0],
|
|
|
|
// Get *real* offsetParent
|
|
offsetParent = this.offsetParent(),
|
|
|
|
// Get correct offsets
|
|
offset = this.offset(),
|
|
parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
|
|
|
|
// Subtract element margins
|
|
// note: when an element has margin: auto the offsetLeft and marginLeft
|
|
// are the same in Safari causing offset.left to incorrectly be 0
|
|
offset.top -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
|
|
offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
|
|
|
|
// Add offsetParent borders
|
|
parentOffset.top += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
|
|
parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
|
|
|
|
// Subtract the two offsets
|
|
return {
|
|
top: offset.top - parentOffset.top,
|
|
left: offset.left - parentOffset.left
|
|
};
|
|
},
|
|
|
|
offsetParent: function() {
|
|
return this.map(function() {
|
|
var offsetParent = this.offsetParent || document.body;
|
|
while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
|
|
offsetParent = offsetParent.offsetParent;
|
|
}
|
|
return offsetParent;
|
|
});
|
|
}
|
|
});
|
|
|
|
|
|
// Create scrollLeft and scrollTop methods
|
|
jQuery.each( ["Left", "Top"], function( i, name ) {
|
|
var method = "scroll" + name;
|
|
|
|
jQuery.fn[ method ] = function( val ) {
|
|
var elem, win;
|
|
|
|
if ( val === undefined ) {
|
|
elem = this[ 0 ];
|
|
|
|
if ( !elem ) {
|
|
return null;
|
|
}
|
|
|
|
win = getWindow( elem );
|
|
|
|
// Return the scroll offset
|
|
return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
|
|
jQuery.support.boxModel && win.document.documentElement[ method ] ||
|
|
win.document.body[ method ] :
|
|
elem[ method ];
|
|
}
|
|
|
|
// Set the scroll offset
|
|
return this.each(function() {
|
|
win = getWindow( this );
|
|
|
|
if ( win ) {
|
|
win.scrollTo(
|
|
!i ? val : jQuery( win ).scrollLeft(),
|
|
i ? val : jQuery( win ).scrollTop()
|
|
);
|
|
|
|
} else {
|
|
this[ method ] = val;
|
|
}
|
|
});
|
|
};
|
|
});
|
|
|
|
function getWindow( elem ) {
|
|
return jQuery.isWindow( elem ) ?
|
|
elem :
|
|
elem.nodeType === 9 ?
|
|
elem.defaultView || elem.parentWindow :
|
|
false;
|
|
}
|
|
|
|
|
|
|
|
|
|
// Create width, height, innerHeight, innerWidth, outerHeight and outerWidth methods
|
|
jQuery.each([ "Height", "Width" ], function( i, name ) {
|
|
|
|
var type = name.toLowerCase();
|
|
|
|
// innerHeight and innerWidth
|
|
jQuery.fn[ "inner" + name ] = function() {
|
|
var elem = this[0];
|
|
return elem && elem.style ?
|
|
parseFloat( jQuery.css( elem, type, "padding" ) ) :
|
|
null;
|
|
};
|
|
|
|
// outerHeight and outerWidth
|
|
jQuery.fn[ "outer" + name ] = function( margin ) {
|
|
var elem = this[0];
|
|
return elem && elem.style ?
|
|
parseFloat( jQuery.css( elem, type, margin ? "margin" : "border" ) ) :
|
|
null;
|
|
};
|
|
|
|
jQuery.fn[ type ] = function( size ) {
|
|
// Get window width or height
|
|
var elem = this[0];
|
|
if ( !elem ) {
|
|
return size == null ? null : this;
|
|
}
|
|
|
|
if ( jQuery.isFunction( size ) ) {
|
|
return this.each(function( i ) {
|
|
var self = jQuery( this );
|
|
self[ type ]( size.call( this, i, self[ type ]() ) );
|
|
});
|
|
}
|
|
|
|
if ( jQuery.isWindow( elem ) ) {
|
|
// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
|
|
// 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
|
|
var docElemProp = elem.document.documentElement[ "client" + name ];
|
|
return elem.document.compatMode === "CSS1Compat" && docElemProp ||
|
|
elem.document.body[ "client" + name ] || docElemProp;
|
|
|
|
// Get document width or height
|
|
} else if ( elem.nodeType === 9 ) {
|
|
// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
|
|
return Math.max(
|
|
elem.documentElement["client" + name],
|
|
elem.body["scroll" + name], elem.documentElement["scroll" + name],
|
|
elem.body["offset" + name], elem.documentElement["offset" + name]
|
|
);
|
|
|
|
// Get or set width or height on the element
|
|
} else if ( size === undefined ) {
|
|
var orig = jQuery.css( elem, type ),
|
|
ret = parseFloat( orig );
|
|
|
|
return jQuery.isNaN( ret ) ? orig : ret;
|
|
|
|
// Set the width or height on the element (default to pixels if value is unitless)
|
|
} else {
|
|
return this.css( type, typeof size === "string" ? size : size + "px" );
|
|
}
|
|
};
|
|
|
|
});
|
|
|
|
|
|
// Expose jQuery to the global object
|
|
window.jQuery = window.$ = jQuery;
|
|
})(window);
|
|
}
|
|
})(window);/**
|
|
* Copyright 2010 Tim Down.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/**
|
|
* jshashtable
|
|
*
|
|
* jshashtable is a JavaScript implementation of a hash table. It creates a single constructor function called Hashtable
|
|
* in the global scope.
|
|
*
|
|
* Author: Tim Down <tim@timdown.co.uk>
|
|
* Version: 2.1
|
|
* Build date: 21 March 2010
|
|
* Website: http://www.timdown.co.uk/jshashtable
|
|
*/
|
|
|
|
var Hashtable = (function() {
|
|
var FUNCTION = "function";
|
|
|
|
var arrayRemoveAt = (typeof Array.prototype.splice == FUNCTION) ?
|
|
function(arr, idx) {
|
|
arr.splice(idx, 1);
|
|
} :
|
|
|
|
function(arr, idx) {
|
|
var itemsAfterDeleted, i, len;
|
|
if (idx === arr.length - 1) {
|
|
arr.length = idx;
|
|
} else {
|
|
itemsAfterDeleted = arr.slice(idx + 1);
|
|
arr.length = idx;
|
|
for (i = 0, len = itemsAfterDeleted.length; i < len; ++i) {
|
|
arr[idx + i] = itemsAfterDeleted[i];
|
|
}
|
|
}
|
|
};
|
|
|
|
function hashObject(obj) {
|
|
var hashCode;
|
|
if (typeof obj == "string") {
|
|
return obj;
|
|
} else if (typeof obj.hashCode == FUNCTION) {
|
|
// Check the hashCode method really has returned a string
|
|
hashCode = obj.hashCode();
|
|
return (typeof hashCode == "string") ? hashCode : hashObject(hashCode);
|
|
} else if (typeof obj.toString == FUNCTION) {
|
|
return obj.toString();
|
|
} else {
|
|
try {
|
|
return String(obj);
|
|
} catch (ex) {
|
|
// For host objects (such as ActiveObjects in IE) that have no toString() method and throw an error when
|
|
// passed to String()
|
|
return Object.prototype.toString.call(obj);
|
|
}
|
|
}
|
|
}
|
|
|
|
function equals_fixedValueHasEquals(fixedValue, variableValue) {
|
|
return fixedValue.equals(variableValue);
|
|
}
|
|
|
|
function equals_fixedValueNoEquals(fixedValue, variableValue) {
|
|
return (typeof variableValue.equals == FUNCTION) ?
|
|
variableValue.equals(fixedValue) : (fixedValue === variableValue);
|
|
}
|
|
|
|
function createKeyValCheck(kvStr) {
|
|
return function(kv) {
|
|
if (kv === null) {
|
|
throw new Error("null is not a valid " + kvStr);
|
|
} else if (typeof kv == "undefined") {
|
|
throw new Error(kvStr + " must not be undefined");
|
|
}
|
|
};
|
|
}
|
|
|
|
var checkKey = createKeyValCheck("key"), checkValue = createKeyValCheck("value");
|
|
|
|
/*----------------------------------------------------------------------------------------------------------------*/
|
|
|
|
function Bucket(hash, firstKey, firstValue, equalityFunction) {
|
|
this[0] = hash;
|
|
this.entries = [];
|
|
this.addEntry(firstKey, firstValue);
|
|
|
|
if (equalityFunction !== null) {
|
|
this.getEqualityFunction = function() {
|
|
return equalityFunction;
|
|
};
|
|
}
|
|
}
|
|
|
|
var EXISTENCE = 0, ENTRY = 1, ENTRY_INDEX_AND_VALUE = 2;
|
|
|
|
function createBucketSearcher(mode) {
|
|
return function(key) {
|
|
var i = this.entries.length, entry, equals = this.getEqualityFunction(key);
|
|
while (i--) {
|
|
entry = this.entries[i];
|
|
if ( equals(key, entry[0]) ) {
|
|
switch (mode) {
|
|
case EXISTENCE:
|
|
return true;
|
|
case ENTRY:
|
|
return entry;
|
|
case ENTRY_INDEX_AND_VALUE:
|
|
return [ i, entry[1] ];
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
}
|
|
|
|
function createBucketLister(entryProperty) {
|
|
return function(aggregatedArr) {
|
|
var startIndex = aggregatedArr.length;
|
|
for (var i = 0, len = this.entries.length; i < len; ++i) {
|
|
aggregatedArr[startIndex + i] = this.entries[i][entryProperty];
|
|
}
|
|
};
|
|
}
|
|
|
|
Bucket.prototype = {
|
|
getEqualityFunction: function(searchValue) {
|
|
return (typeof searchValue.equals == FUNCTION) ? equals_fixedValueHasEquals : equals_fixedValueNoEquals;
|
|
},
|
|
|
|
getEntryForKey: createBucketSearcher(ENTRY),
|
|
|
|
getEntryAndIndexForKey: createBucketSearcher(ENTRY_INDEX_AND_VALUE),
|
|
|
|
removeEntryForKey: function(key) {
|
|
var result = this.getEntryAndIndexForKey(key);
|
|
if (result) {
|
|
arrayRemoveAt(this.entries, result[0]);
|
|
return result[1];
|
|
}
|
|
return null;
|
|
},
|
|
|
|
addEntry: function(key, value) {
|
|
this.entries[this.entries.length] = [key, value];
|
|
},
|
|
|
|
keys: createBucketLister(0),
|
|
|
|
values: createBucketLister(1),
|
|
|
|
getEntries: function(entries) {
|
|
var startIndex = entries.length;
|
|
for (var i = 0, len = this.entries.length; i < len; ++i) {
|
|
// Clone the entry stored in the bucket before adding to array
|
|
entries[startIndex + i] = this.entries[i].slice(0);
|
|
}
|
|
},
|
|
|
|
containsKey: createBucketSearcher(EXISTENCE),
|
|
|
|
containsValue: function(value) {
|
|
var i = this.entries.length;
|
|
while (i--) {
|
|
if ( value === this.entries[i][1] ) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
/*----------------------------------------------------------------------------------------------------------------*/
|
|
|
|
// Supporting functions for searching hashtable buckets
|
|
|
|
function searchBuckets(buckets, hash) {
|
|
var i = buckets.length, bucket;
|
|
while (i--) {
|
|
bucket = buckets[i];
|
|
if (hash === bucket[0]) {
|
|
return i;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function getBucketForHash(bucketsByHash, hash) {
|
|
var bucket = bucketsByHash[hash];
|
|
|
|
// Check that this is a genuine bucket and not something inherited from the bucketsByHash's prototype
|
|
return ( bucket && (bucket instanceof Bucket) ) ? bucket : null;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------------------------------------------*/
|
|
|
|
function Hashtable(hashingFunctionParam, equalityFunctionParam) {
|
|
var that = this;
|
|
var buckets = [];
|
|
var bucketsByHash = {};
|
|
|
|
var hashingFunction = (typeof hashingFunctionParam == FUNCTION) ? hashingFunctionParam : hashObject;
|
|
var equalityFunction = (typeof equalityFunctionParam == FUNCTION) ? equalityFunctionParam : null;
|
|
|
|
this.put = function(key, value) {
|
|
checkKey(key);
|
|
checkValue(value);
|
|
var hash = hashingFunction(key), bucket, bucketEntry, oldValue = null;
|
|
|
|
// Check if a bucket exists for the bucket key
|
|
bucket = getBucketForHash(bucketsByHash, hash);
|
|
if (bucket) {
|
|
// Check this bucket to see if it already contains this key
|
|
bucketEntry = bucket.getEntryForKey(key);
|
|
if (bucketEntry) {
|
|
// This bucket entry is the current mapping of key to value, so replace old value and we're done.
|
|
oldValue = bucketEntry[1];
|
|
bucketEntry[1] = value;
|
|
} else {
|
|
// The bucket does not contain an entry for this key, so add one
|
|
bucket.addEntry(key, value);
|
|
}
|
|
} else {
|
|
// No bucket exists for the key, so create one and put our key/value mapping in
|
|
bucket = new Bucket(hash, key, value, equalityFunction);
|
|
buckets[buckets.length] = bucket;
|
|
bucketsByHash[hash] = bucket;
|
|
}
|
|
return oldValue;
|
|
};
|
|
|
|
this.get = function(key) {
|
|
checkKey(key);
|
|
|
|
var hash = hashingFunction(key);
|
|
|
|
// Check if a bucket exists for the bucket key
|
|
var bucket = getBucketForHash(bucketsByHash, hash);
|
|
if (bucket) {
|
|
// Check this bucket to see if it contains this key
|
|
var bucketEntry = bucket.getEntryForKey(key);
|
|
if (bucketEntry) {
|
|
// This bucket entry is the current mapping of key to value, so return the value.
|
|
return bucketEntry[1];
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
this.containsKey = function(key) {
|
|
checkKey(key);
|
|
var bucketKey = hashingFunction(key);
|
|
|
|
// Check if a bucket exists for the bucket key
|
|
var bucket = getBucketForHash(bucketsByHash, bucketKey);
|
|
|
|
return bucket ? bucket.containsKey(key) : false;
|
|
};
|
|
|
|
this.containsValue = function(value) {
|
|
checkValue(value);
|
|
var i = buckets.length;
|
|
while (i--) {
|
|
if (buckets[i].containsValue(value)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
this.clear = function() {
|
|
buckets.length = 0;
|
|
bucketsByHash = {};
|
|
};
|
|
|
|
this.isEmpty = function() {
|
|
return !buckets.length;
|
|
};
|
|
|
|
var createBucketAggregator = function(bucketFuncName) {
|
|
return function() {
|
|
var aggregated = [], i = buckets.length;
|
|
while (i--) {
|
|
buckets[i][bucketFuncName](aggregated);
|
|
}
|
|
return aggregated;
|
|
};
|
|
};
|
|
|
|
this.keys = createBucketAggregator("keys");
|
|
this.values = createBucketAggregator("values");
|
|
this.entries = createBucketAggregator("getEntries");
|
|
|
|
this.remove = function(key) {
|
|
checkKey(key);
|
|
|
|
var hash = hashingFunction(key), bucketIndex, oldValue = null;
|
|
|
|
// Check if a bucket exists for the bucket key
|
|
var bucket = getBucketForHash(bucketsByHash, hash);
|
|
|
|
if (bucket) {
|
|
// Remove entry from this bucket for this key
|
|
oldValue = bucket.removeEntryForKey(key);
|
|
if (oldValue !== null) {
|
|
// Entry was removed, so check if bucket is empty
|
|
if (!bucket.entries.length) {
|
|
// Bucket is empty, so remove it from the bucket collections
|
|
bucketIndex = searchBuckets(buckets, hash);
|
|
arrayRemoveAt(buckets, bucketIndex);
|
|
delete bucketsByHash[hash];
|
|
}
|
|
}
|
|
}
|
|
return oldValue;
|
|
};
|
|
|
|
this.size = function() {
|
|
var total = 0, i = buckets.length;
|
|
while (i--) {
|
|
total += buckets[i].entries.length;
|
|
}
|
|
return total;
|
|
};
|
|
|
|
this.each = function(callback) {
|
|
var entries = that.entries(), i = entries.length, entry;
|
|
while (i--) {
|
|
entry = entries[i];
|
|
callback(entry[0], entry[1]);
|
|
}
|
|
};
|
|
|
|
this.putAll = function(hashtable, conflictCallback) {
|
|
var entries = hashtable.entries();
|
|
var entry, key, value, thisValue, i = entries.length;
|
|
var hasConflictCallback = (typeof conflictCallback == FUNCTION);
|
|
while (i--) {
|
|
entry = entries[i];
|
|
key = entry[0];
|
|
value = entry[1];
|
|
|
|
// Check for a conflict. The default behaviour is to overwrite the value for an existing key
|
|
if ( hasConflictCallback && (thisValue = that.get(key)) ) {
|
|
value = conflictCallback(key, thisValue, value);
|
|
}
|
|
that.put(key, value);
|
|
}
|
|
};
|
|
|
|
this.clone = function() {
|
|
var clone = new Hashtable(hashingFunctionParam, equalityFunctionParam);
|
|
clone.putAll(that);
|
|
return clone;
|
|
};
|
|
}
|
|
|
|
return Hashtable;
|
|
})();// Scheme numbers.
|
|
|
|
|
|
var __PLTNUMBERS_TOP__;
|
|
if (typeof(exports) !== 'undefined') {
|
|
__PLTNUMBERS_TOP__ = exports;
|
|
} else {
|
|
if (! this['jsnums']) {
|
|
this['jsnums'] = {};
|
|
}
|
|
__PLTNUMBERS_TOP__ = this['jsnums'];
|
|
}
|
|
|
|
//var jsnums = {};
|
|
|
|
|
|
// The numeric tower has the following levels:
|
|
// integers
|
|
// rationals
|
|
// floats
|
|
// complex numbers
|
|
//
|
|
// with the representations:
|
|
// integers: fixnum or BigInteger [level=0]
|
|
// rationals: Rational [level=1]
|
|
// floats: FloatPoint [level=2]
|
|
// complex numbers: Complex [level=3]
|
|
|
|
// We try to stick with the unboxed fixnum representation for
|
|
// integers, since that's what scheme programs commonly deal with, and
|
|
// we want that common type to be lightweight.
|
|
|
|
|
|
// A boxed-scheme-number is either BigInteger, Rational, FloatPoint, or Complex.
|
|
// An integer-scheme-number is either fixnum or BigInteger.
|
|
|
|
|
|
(function() {
|
|
// Abbreviation
|
|
var Numbers = __PLTNUMBERS_TOP__;
|
|
//var Numbers = jsnums;
|
|
|
|
|
|
// makeNumericBinop: (fixnum fixnum -> any) (scheme-number scheme-number -> any) -> (scheme-number scheme-number) X
|
|
// Creates a binary function that works either on fixnums or boxnums.
|
|
// Applies the appropriate binary function, ensuring that both scheme numbers are
|
|
// lifted to the same level.
|
|
var makeNumericBinop = function(onFixnums, onBoxednums, options) {
|
|
options = options || {};
|
|
return function(x, y) {
|
|
if (options.isXSpecialCase && options.isXSpecialCase(x))
|
|
return options.onXSpecialCase(x, y);
|
|
if (options.isYSpecialCase && options.isYSpecialCase(y))
|
|
return options.onYSpecialCase(x, y);
|
|
|
|
if (typeof(x) === 'number' &&
|
|
typeof(y) === 'number') {
|
|
return onFixnums(x, y);
|
|
}
|
|
if (typeof(x) === 'number') {
|
|
x = liftFixnumInteger(x, y);
|
|
}
|
|
if (typeof(y) === 'number') {
|
|
y = liftFixnumInteger(y, x);
|
|
}
|
|
|
|
if (x.level < y.level) x = x.liftTo(y);
|
|
if (y.level < x.level) y = y.liftTo(x);
|
|
return onBoxednums(x, y);
|
|
};
|
|
}
|
|
|
|
|
|
// fromFixnum: fixnum -> scheme-number
|
|
var fromFixnum = function(x) {
|
|
if (isNaN(x) || (! isFinite(x))) {
|
|
return FloatPoint.makeInstance(x);
|
|
}
|
|
var nf = Math.floor(x);
|
|
if (nf === x) {
|
|
if (isOverflow(nf)) {
|
|
return makeBignum(expandExponent(x+''));
|
|
} else {
|
|
return nf;
|
|
}
|
|
} else {
|
|
return FloatPoint.makeInstance(x);
|
|
}
|
|
};
|
|
|
|
var expandExponent = function(s) {
|
|
var match = s.match(scientificPattern), mantissaChunks, exponent;
|
|
if (match) {
|
|
mantissaChunks = match[1].match(/^([^.]*)(.*)$/);
|
|
exponent = Number(match[2]);
|
|
|
|
if (mantissaChunks[2].length === 0) {
|
|
return mantissaChunks[1] + zfill(exponent);
|
|
}
|
|
|
|
if (exponent >= mantissaChunks[2].length - 1) {
|
|
return (mantissaChunks[1] +
|
|
mantissaChunks[2].substring(1) +
|
|
zfill(exponent - (mantissaChunks[2].length - 1)));
|
|
} else {
|
|
return (mantissaChunks[1] +
|
|
mantissaChunks[2].substring(1, 1+exponent));
|
|
}
|
|
} else {
|
|
return s;
|
|
}
|
|
};
|
|
|
|
// zfill: integer -> string
|
|
// builds a string of "0"'s of length n.
|
|
var zfill = function(n) {
|
|
var buffer = [];
|
|
buffer.length = n;
|
|
for (var i = 0; i < n; i++) {
|
|
buffer[i] = '0';
|
|
}
|
|
return buffer.join('');
|
|
};
|
|
|
|
|
|
|
|
// liftFixnumInteger: fixnum-integer boxed-scheme-number -> boxed-scheme-number
|
|
// Lifts up fixnum integers to a boxed type.
|
|
var liftFixnumInteger = function(x, other) {
|
|
switch(other.level) {
|
|
case 0: // BigInteger
|
|
return makeBignum(x);
|
|
case 1: // Rational
|
|
return new Rational(x, 1);
|
|
case 2: // FloatPoint
|
|
return new FloatPoint(x);
|
|
case 3: // Complex
|
|
return new Complex(x, 0);
|
|
default:
|
|
throwRuntimeError("IMPOSSIBLE: cannot lift fixnum integer to " + other.toString(), x, other);
|
|
}
|
|
};
|
|
|
|
|
|
// throwRuntimeError: string (scheme-number | undefined) (scheme-number | undefined) -> void
|
|
// Throws a runtime error with the given message string.
|
|
var throwRuntimeError = function(msg, x, y) {
|
|
Numbers['onThrowRuntimeError'](msg, x, y);
|
|
};
|
|
|
|
|
|
|
|
// onThrowRuntimeError: string (scheme-number | undefined) (scheme-number | undefined) -> void
|
|
// By default, will throw a new Error with the given message.
|
|
// Override Numbers['onThrowRuntimeError'] if you need to do something special.
|
|
var onThrowRuntimeError = function(msg, x, y) {
|
|
throw new Error(msg);
|
|
};
|
|
|
|
|
|
// isSchemeNumber: any -> boolean
|
|
// Returns true if the thing is a scheme number.
|
|
var isSchemeNumber = function(thing) {
|
|
return (typeof(thing) === 'number'
|
|
|| (thing instanceof Rational ||
|
|
thing instanceof FloatPoint ||
|
|
thing instanceof Complex ||
|
|
thing instanceof BigInteger));
|
|
};
|
|
|
|
|
|
// isRational: scheme-number -> boolean
|
|
var isRational = function(n) {
|
|
return (typeof(n) === 'number' ||
|
|
(isSchemeNumber(n) && n.isRational()));
|
|
};
|
|
|
|
// isReal: scheme-number -> boolean
|
|
var isReal = function(n) {
|
|
return (typeof(n) === 'number' ||
|
|
(isSchemeNumber(n) && n.isReal()));
|
|
};
|
|
|
|
// isExact: scheme-number -> boolean
|
|
var isExact = function(n) {
|
|
return (typeof(n) === 'number' ||
|
|
(isSchemeNumber(n) && n.isExact()));
|
|
};
|
|
|
|
// isExact: scheme-number -> boolean
|
|
var isInexact = function(n) {
|
|
if (typeof(n) === 'number') {
|
|
return false;
|
|
} else {
|
|
return (isSchemeNumber(n) && n.isInexact());
|
|
}
|
|
};
|
|
|
|
// isInteger: scheme-number -> boolean
|
|
var isInteger = function(n) {
|
|
return (typeof(n) === 'number' ||
|
|
(isSchemeNumber(n) && n.isInteger()));
|
|
};
|
|
|
|
// isExactInteger: scheme-number -> boolean
|
|
var isExactInteger = function(n) {
|
|
return (typeof(n) === 'number' ||
|
|
(isSchemeNumber(n) &&
|
|
n.isInteger() &&
|
|
n.isExact()));
|
|
}
|
|
|
|
|
|
|
|
// toFixnum: scheme-number -> javascript-number
|
|
var toFixnum = function(n) {
|
|
if (typeof(n) === 'number')
|
|
return n;
|
|
return n.toFixnum();
|
|
};
|
|
|
|
// toExact: scheme-number -> scheme-number
|
|
var toExact = function(n) {
|
|
if (typeof(n) === 'number')
|
|
return n;
|
|
return n.toExact();
|
|
};
|
|
|
|
|
|
// toExact: scheme-number -> scheme-number
|
|
var toInexact = function(n) {
|
|
if (typeof(n) === 'number')
|
|
return FloatPoint.makeInstance(n);
|
|
return n.toInexact();
|
|
};
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
// add: scheme-number scheme-number -> scheme-number
|
|
var add = makeNumericBinop(
|
|
function(x, y) {
|
|
var sum = x + y;
|
|
if (isOverflow(sum)) {
|
|
return (makeBignum(x)).add(makeBignum(y));
|
|
} else {
|
|
return sum;
|
|
}
|
|
},
|
|
function(x, y) {
|
|
return x.add(y);
|
|
},
|
|
{isXSpecialCase: function(x) {
|
|
return isExactInteger(x) && _integerIsZero(x) },
|
|
onXSpecialCase: function(x, y) { return y; },
|
|
isYSpecialCase: function(y) {
|
|
return isExactInteger(y) && _integerIsZero(y) },
|
|
onYSpecialCase: function(x, y) { return x; }
|
|
});
|
|
|
|
|
|
// subtract: scheme-number scheme-number -> scheme-number
|
|
var subtract = makeNumericBinop(
|
|
function(x, y) {
|
|
var diff = x - y;
|
|
if (isOverflow(diff)) {
|
|
return (makeBignum(x)).subtract(makeBignum(y));
|
|
} else {
|
|
return diff;
|
|
}
|
|
},
|
|
function(x, y) {
|
|
return x.subtract(y);
|
|
},
|
|
{isXSpecialCase: function(x) {
|
|
return isExactInteger(x) && _integerIsZero(x) },
|
|
onXSpecialCase: function(x, y) { return negate(y); },
|
|
isYSpecialCase: function(y) {
|
|
return isExactInteger(y) && _integerIsZero(y) },
|
|
onYSpecialCase: function(x, y) { return x; }
|
|
});
|
|
|
|
|
|
// mulitply: scheme-number scheme-number -> scheme-number
|
|
var multiply = makeNumericBinop(
|
|
function(x, y) {
|
|
var prod = x * y;
|
|
if (isOverflow(prod)) {
|
|
return (makeBignum(x)).multiply(makeBignum(y));
|
|
} else {
|
|
return prod;
|
|
}
|
|
},
|
|
function(x, y) {
|
|
return x.multiply(y);
|
|
},
|
|
{isXSpecialCase: function(x) {
|
|
return (isExactInteger(x) &&
|
|
(_integerIsZero(x) || _integerIsOne(x) || _integerIsNegativeOne(x))) },
|
|
onXSpecialCase: function(x, y) {
|
|
if (_integerIsZero(x))
|
|
return 0;
|
|
if (_integerIsOne(x))
|
|
return y;
|
|
if (_integerIsNegativeOne(x))
|
|
return negate(y);
|
|
},
|
|
isYSpecialCase: function(y) {
|
|
return (isExactInteger(y) &&
|
|
(_integerIsZero(y) || _integerIsOne(y) || _integerIsNegativeOne(y)))},
|
|
onYSpecialCase: function(x, y) {
|
|
if (_integerIsZero(y))
|
|
return 0;
|
|
if (_integerIsOne(y))
|
|
return x;
|
|
if (_integerIsNegativeOne(y))
|
|
return negate(x);
|
|
}
|
|
});
|
|
|
|
|
|
// divide: scheme-number scheme-number -> scheme-number
|
|
var divide = makeNumericBinop(
|
|
function(x, y) {
|
|
if (_integerIsZero(y))
|
|
throwRuntimeError("/: division by zero", x, y);
|
|
var div = x / y;
|
|
if (isOverflow(div)) {
|
|
return (makeBignum(x)).divide(makeBignum(y));
|
|
} else if (Math.floor(div) !== div) {
|
|
return Rational.makeInstance(x, y);
|
|
} else {
|
|
return div;
|
|
}
|
|
},
|
|
function(x, y) {
|
|
return x.divide(y);
|
|
},
|
|
{ isXSpecialCase: function(x) {
|
|
return (eqv(x, 0));
|
|
},
|
|
onXSpecialCase: function(x, y) {
|
|
if (eqv(y, 0)) {
|
|
throwRuntimeError("/: division by zero", x, y);
|
|
}
|
|
return 0;
|
|
},
|
|
isYSpecialCase: function(y) {
|
|
return (eqv(y, 0)); },
|
|
onYSpecialCase: function(x, y) {
|
|
throwRuntimeError("/: division by zero", x, y);
|
|
}
|
|
});
|
|
|
|
|
|
// equals: scheme-number scheme-number -> boolean
|
|
var equals = makeNumericBinop(
|
|
function(x, y) {
|
|
return x === y;
|
|
},
|
|
function(x, y) {
|
|
return x.equals(y);
|
|
});
|
|
|
|
|
|
// eqv: scheme-number scheme-number -> boolean
|
|
var eqv = function(x, y) {
|
|
if (x === y)
|
|
return true;
|
|
if (typeof(x) === 'number' && typeof(y) === 'number')
|
|
return x === y;
|
|
if (x === NEGATIVE_ZERO || y === NEGATIVE_ZERO)
|
|
return x === y;
|
|
if (x instanceof Complex || y instanceof Complex) {
|
|
return (eqv(realPart(x), realPart(y)) &&
|
|
eqv(imaginaryPart(x), imaginaryPart(y)));
|
|
}
|
|
var ex = isExact(x), ey = isExact(y);
|
|
return (((ex && ey) || (!ex && !ey)) && equals(x, y));
|
|
};
|
|
|
|
// approxEqual: scheme-number scheme-number scheme-number -> boolean
|
|
var approxEquals = function(x, y, delta) {
|
|
return lessThan(abs(subtract(x, y)),
|
|
delta);
|
|
};
|
|
|
|
// greaterThanOrEqual: scheme-number scheme-number -> boolean
|
|
var greaterThanOrEqual = makeNumericBinop(
|
|
function(x, y) {
|
|
return x >= y;
|
|
},
|
|
function(x, y) {
|
|
if (!(isReal(x) && isReal(y)))
|
|
throwRuntimeError(
|
|
">=: couldn't be applied to complex number", x, y);
|
|
return x.greaterThanOrEqual(y);
|
|
});
|
|
|
|
|
|
// lessThanOrEqual: scheme-number scheme-number -> boolean
|
|
var lessThanOrEqual = makeNumericBinop(
|
|
function(x, y){
|
|
|
|
return x <= y;
|
|
},
|
|
function(x, y) {
|
|
if (!(isReal(x) && isReal(y)))
|
|
throwRuntimeError("<=: couldn't be applied to complex number", x, y);
|
|
return x.lessThanOrEqual(y);
|
|
});
|
|
|
|
|
|
// greaterThan: scheme-number scheme-number -> boolean
|
|
var greaterThan = makeNumericBinop(
|
|
function(x, y){
|
|
return x > y;
|
|
},
|
|
function(x, y) {
|
|
if (!(isReal(x) && isReal(y)))
|
|
throwRuntimeError(">: couldn't be applied to complex number", x, y);
|
|
return x.greaterThan(y);
|
|
});
|
|
|
|
|
|
// lessThan: scheme-number scheme-number -> boolean
|
|
var lessThan = makeNumericBinop(
|
|
function(x, y){
|
|
|
|
return x < y;
|
|
},
|
|
function(x, y) {
|
|
if (!(isReal(x) && isReal(y)))
|
|
throwRuntimeError("<: couldn't be applied to complex number", x, y);
|
|
return x.lessThan(y);
|
|
});
|
|
|
|
|
|
|
|
// expt: scheme-number scheme-number -> scheme-number
|
|
var expt = (function() {
|
|
var _expt = makeNumericBinop(
|
|
function(x, y){
|
|
var pow = Math.pow(x, y);
|
|
if (isOverflow(pow)) {
|
|
return (makeBignum(x)).expt(makeBignum(y));
|
|
} else {
|
|
return pow;
|
|
}
|
|
},
|
|
function(x, y) {
|
|
if (equals(y, 0)) {
|
|
return add(y, 1);
|
|
} else {
|
|
return x.expt(y);
|
|
}
|
|
});
|
|
return function(x, y) {
|
|
if (equals(y, 0))
|
|
return add(y, 1);
|
|
if (isReal(y) && lessThan(y, 0)) {
|
|
return _expt(divide(1, x), negate(y));
|
|
}
|
|
return _expt(x, y);
|
|
};
|
|
})();
|
|
|
|
|
|
// exp: scheme-number -> scheme-number
|
|
var exp = function(n) {
|
|
if ( eqv(n, 0) ) {
|
|
return 1;
|
|
}
|
|
if (typeof(n) === 'number') {
|
|
return FloatPoint.makeInstance(Math.exp(n));
|
|
}
|
|
return n.exp();
|
|
};
|
|
|
|
|
|
// modulo: scheme-number scheme-number -> scheme-number
|
|
var modulo = function(m, n) {
|
|
if (! isInteger(m)) {
|
|
throwRuntimeError('modulo: the first argument '
|
|
+ m + " is not an integer.", m, n);
|
|
}
|
|
if (! isInteger(n)) {
|
|
throwRuntimeError('modulo: the second argument '
|
|
+ n + " is not an integer.", m, n);
|
|
}
|
|
var result;
|
|
if (typeof(m) === 'number') {
|
|
result = m % n;
|
|
if (n < 0) {
|
|
if (result <= 0)
|
|
return result;
|
|
else
|
|
return result + n;
|
|
} else {
|
|
if (result < 0)
|
|
return result + n;
|
|
else
|
|
return result;
|
|
}
|
|
}
|
|
result = _integerModulo(floor(m), floor(n));
|
|
// The sign of the result should match the sign of n.
|
|
if (lessThan(n, 0)) {
|
|
if (lessThanOrEqual(result, 0)) {
|
|
return result;
|
|
}
|
|
return add(result, n);
|
|
|
|
} else {
|
|
if (lessThan(result, 0)) {
|
|
return add(result, n);
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
|
|
|
|
|
|
// numerator: scheme-number -> scheme-number
|
|
var numerator = function(n) {
|
|
if (typeof(n) === 'number')
|
|
return n;
|
|
return n.numerator();
|
|
};
|
|
|
|
|
|
// denominator: scheme-number -> scheme-number
|
|
var denominator = function(n) {
|
|
if (typeof(n) === 'number')
|
|
return 1;
|
|
return n.denominator();
|
|
};
|
|
|
|
// sqrt: scheme-number -> scheme-number
|
|
var sqrt = function(n) {
|
|
if (typeof(n) === 'number') {
|
|
if (n >= 0) {
|
|
var result = Math.sqrt(n);
|
|
if (Math.floor(result) === result) {
|
|
return result;
|
|
} else {
|
|
return FloatPoint.makeInstance(result);
|
|
}
|
|
} else {
|
|
return (Complex.makeInstance(0, sqrt(-n)));
|
|
}
|
|
}
|
|
return n.sqrt();
|
|
};
|
|
|
|
// abs: scheme-number -> scheme-number
|
|
var abs = function(n) {
|
|
if (typeof(n) === 'number') {
|
|
return Math.abs(n);
|
|
}
|
|
return n.abs();
|
|
};
|
|
|
|
// floor: scheme-number -> scheme-number
|
|
var floor = function(n) {
|
|
if (typeof(n) === 'number')
|
|
return n;
|
|
return n.floor();
|
|
};
|
|
|
|
// ceiling: scheme-number -> scheme-number
|
|
var ceiling = function(n) {
|
|
if (typeof(n) === 'number')
|
|
return n;
|
|
return n.ceiling();
|
|
};
|
|
|
|
// conjugate: scheme-number -> scheme-number
|
|
var conjugate = function(n) {
|
|
if (typeof(n) === 'number')
|
|
return n;
|
|
return n.conjugate();
|
|
};
|
|
|
|
// magnitude: scheme-number -> scheme-number
|
|
var magnitude = function(n) {
|
|
if (typeof(n) === 'number')
|
|
return Math.abs(n);
|
|
return n.magnitude();
|
|
};
|
|
|
|
|
|
// log: scheme-number -> scheme-number
|
|
var log = function(n) {
|
|
if ( eqv(n, 1) ) {
|
|
return 0;
|
|
}
|
|
if (typeof(n) === 'number') {
|
|
return FloatPoint.makeInstance(Math.log(n));
|
|
}
|
|
return n.log();
|
|
};
|
|
|
|
// angle: scheme-number -> scheme-number
|
|
var angle = function(n) {
|
|
if (typeof(n) === 'number') {
|
|
if (n > 0)
|
|
return 0;
|
|
else
|
|
return FloatPoint.pi;
|
|
}
|
|
return n.angle();
|
|
};
|
|
|
|
// tan: scheme-number -> scheme-number
|
|
var tan = function(n) {
|
|
if (eqv(n, 0)) { return 0; }
|
|
if (typeof(n) === 'number') {
|
|
return FloatPoint.makeInstance(Math.tan(n));
|
|
}
|
|
return n.tan();
|
|
};
|
|
|
|
// atan: scheme-number -> scheme-number
|
|
var atan = function(n) {
|
|
if (eqv(n, 0)) { return 0; }
|
|
if (typeof(n) === 'number') {
|
|
return FloatPoint.makeInstance(Math.atan(n));
|
|
}
|
|
return n.atan();
|
|
};
|
|
|
|
// cos: scheme-number -> scheme-number
|
|
var cos = function(n) {
|
|
if (eqv(n, 0)) { return 1; }
|
|
if (typeof(n) === 'number') {
|
|
return FloatPoint.makeInstance(Math.cos(n));
|
|
}
|
|
return n.cos();
|
|
};
|
|
|
|
// sin: scheme-number -> scheme-number
|
|
var sin = function(n) {
|
|
if (eqv(n, 0)) { return 0; }
|
|
if (typeof(n) === 'number') {
|
|
return FloatPoint.makeInstance(Math.sin(n));
|
|
}
|
|
return n.sin();
|
|
};
|
|
|
|
// acos: scheme-number -> scheme-number
|
|
var acos = function(n) {
|
|
if (eqv(n, 1)) { return 0; }
|
|
if (typeof(n) === 'number') {
|
|
return FloatPoint.makeInstance(Math.acos(n));
|
|
}
|
|
return n.acos();
|
|
};
|
|
|
|
// asin: scheme-number -> scheme-number
|
|
var asin = function(n) {
|
|
if (eqv(n, 0)) { return 0; }
|
|
if (typeof(n) === 'number') {
|
|
return FloatPoint.makeInstance(Math.asin(n));
|
|
}
|
|
return n.asin();
|
|
};
|
|
|
|
// imaginaryPart: scheme-number -> scheme-number
|
|
var imaginaryPart = function(n) {
|
|
if (typeof(n) === 'number') {
|
|
return 0;
|
|
}
|
|
return n.imaginaryPart();
|
|
};
|
|
|
|
// realPart: scheme-number -> scheme-number
|
|
var realPart = function(n) {
|
|
if (typeof(n) === 'number') {
|
|
return n;
|
|
}
|
|
return n.realPart();
|
|
};
|
|
|
|
// round: scheme-number -> scheme-number
|
|
var round = function(n) {
|
|
if (typeof(n) === 'number') {
|
|
return n;
|
|
}
|
|
return n.round();
|
|
};
|
|
|
|
|
|
|
|
// sqr: scheme-number -> scheme-number
|
|
var sqr = function(x) {
|
|
return multiply(x, x);
|
|
};
|
|
|
|
|
|
// integerSqrt: scheme-number -> scheme-number
|
|
var integerSqrt = function(x) {
|
|
if (! isInteger(x)) {
|
|
throwRuntimeError('integer-sqrt: the argument ' + x.toString() +
|
|
" is not an integer.", x);
|
|
}
|
|
if (typeof (x) === 'number') {
|
|
if(x < 0) {
|
|
return Complex.makeInstance(0,
|
|
Math.floor(Math.sqrt(-x)))
|
|
} else {
|
|
return Math.floor(Math.sqrt(x));
|
|
}
|
|
}
|
|
return x.integerSqrt();
|
|
};
|
|
|
|
|
|
// gcd: scheme-number [scheme-number ...] -> scheme-number
|
|
var gcd = function(first, rest) {
|
|
if (! isInteger(first)) {
|
|
throwRuntimeError('gcd: the argument ' + first.toString() +
|
|
" is not an integer.", first);
|
|
}
|
|
var a = abs(first), t, b;
|
|
for(var i = 0; i < rest.length; i++) {
|
|
b = abs(rest[i]);
|
|
if (! isInteger(b)) {
|
|
throwRuntimeError('gcd: the argument ' + b.toString() +
|
|
" is not an integer.", b);
|
|
}
|
|
while (! _integerIsZero(b)) {
|
|
t = a;
|
|
a = b;
|
|
b = _integerModulo(t, b);
|
|
}
|
|
}
|
|
return a;
|
|
};
|
|
|
|
// lcm: scheme-number [scheme-number ...] -> scheme-number
|
|
var lcm = function(first, rest) {
|
|
if (! isInteger(first)) {
|
|
throwRuntimeError('lcm: the argument ' + first.toString() +
|
|
" is not an integer.", first);
|
|
}
|
|
var result = abs(first);
|
|
if (_integerIsZero(result)) { return 0; }
|
|
for (var i = 0; i < rest.length; i++) {
|
|
if (! isInteger(rest[i])) {
|
|
throwRuntimeError('lcm: the argument ' + rest[i].toString() +
|
|
" is not an integer.", rest[i]);
|
|
}
|
|
var divisor = _integerGcd(result, rest[i]);
|
|
if (_integerIsZero(divisor)) {
|
|
return 0;
|
|
}
|
|
result = divide(multiply(result, rest[i]), divisor);
|
|
}
|
|
return result;
|
|
};
|
|
|
|
|
|
var quotient = function(x, y) {
|
|
if (! isInteger(x)) {
|
|
throwRuntimeError('quotient: the first argument ' + x.toString() +
|
|
" is not an integer.", x);
|
|
}
|
|
if (! isInteger(y)) {
|
|
throwRuntimeError('quotient: the second argument ' + y.toString() +
|
|
" is not an integer.", y);
|
|
}
|
|
return _integerQuotient(x, y);
|
|
};
|
|
|
|
|
|
var remainder = function(x, y) {
|
|
if (! isInteger(x)) {
|
|
throwRuntimeError('remainder: the first argument ' + x.toString() +
|
|
" is not an integer.", x);
|
|
}
|
|
if (! isInteger(y)) {
|
|
throwRuntimeError('remainder: the second argument ' + y.toString() +
|
|
" is not an integer.", y);
|
|
}
|
|
return _integerRemainder(x, y);
|
|
};
|
|
|
|
|
|
// Implementation of the hyperbolic functions
|
|
// http://en.wikipedia.org/wiki/Hyperbolic_cosine
|
|
var cosh = function(x) {
|
|
if (eqv(x, 0)) {
|
|
return FloatPoint.makeInstance(1.0);
|
|
}
|
|
return divide(add(exp(x), exp(negate(x))),
|
|
2);
|
|
};
|
|
|
|
var sinh = function(x) {
|
|
return divide(subtract(exp(x), exp(negate(x))),
|
|
2);
|
|
};
|
|
|
|
|
|
|
|
var makeComplexPolar = function(r, theta) {
|
|
// special case: if theta is zero, just return
|
|
// the scalar.
|
|
if (eqv(theta, 0)) {
|
|
return r;
|
|
}
|
|
return Complex.makeInstance(multiply(r, cos(theta)),
|
|
multiply(r, sin(theta)));
|
|
};
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// Helpers
|
|
|
|
|
|
// IsFinite: scheme-number -> boolean
|
|
// Returns true if the scheme number is finite or not.
|
|
var isSchemeNumberFinite = function(n) {
|
|
if (typeof(n) === 'number') {
|
|
return isFinite(n);
|
|
} else {
|
|
return n.isFinite();
|
|
}
|
|
};
|
|
|
|
// isOverflow: javascript-number -> boolean
|
|
// Returns true if we consider the number an overflow.
|
|
var MIN_FIXNUM = -(9e15);
|
|
var MAX_FIXNUM = (9e15);
|
|
var isOverflow = function(n) {
|
|
return (n < MIN_FIXNUM || MAX_FIXNUM < n);
|
|
};
|
|
|
|
|
|
// negate: scheme-number -> scheme-number
|
|
// multiplies a number times -1.
|
|
var negate = function(n) {
|
|
if (typeof(n) === 'number') {
|
|
return -n;
|
|
}
|
|
return n.negate();
|
|
};
|
|
|
|
|
|
// halve: scheme-number -> scheme-number
|
|
// Divide a number by 2.
|
|
var halve = function(n) {
|
|
return divide(n, 2);
|
|
};
|
|
|
|
|
|
// timesI: scheme-number scheme-number
|
|
// multiplies a number times i.
|
|
var timesI = function(x) {
|
|
return multiply(x, plusI);
|
|
};
|
|
|
|
|
|
// fastExpt: computes n^k by squaring.
|
|
// n^k = (n^2)^(k/2)
|
|
// Assumes k is non-negative integer.
|
|
var fastExpt = function(n, k) {
|
|
var acc = 1;
|
|
while (true) {
|
|
if (_integerIsZero(k)) {
|
|
return acc;
|
|
}
|
|
if (equals(modulo(k, 2), 0)) {
|
|
n = multiply(n, n);
|
|
k = divide(k, 2);
|
|
} else {
|
|
acc = multiply(acc, n);
|
|
k = subtract(k, 1);
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
// Integer operations
|
|
// Integers are either represented as fixnums or as BigIntegers.
|
|
|
|
// makeIntegerBinop: (fixnum fixnum -> X) (BigInteger BigInteger -> X) -> X
|
|
// Helper to collect the common logic for coersing integer fixnums or bignums to a
|
|
// common type before doing an operation.
|
|
var makeIntegerBinop = function(onFixnums, onBignums, options) {
|
|
options = options || {};
|
|
return (function(m, n) {
|
|
if (m instanceof Rational) {
|
|
m = numerator(m);
|
|
} else if (m instanceof Complex) {
|
|
m = realPart(m);
|
|
}
|
|
|
|
if (n instanceof Rational) {
|
|
n = numerator(n);
|
|
}else if (n instanceof Complex) {
|
|
n = realPart(n);
|
|
}
|
|
|
|
if (typeof(m) === 'number' && typeof(n) === 'number') {
|
|
var result = onFixnums(m, n);
|
|
if (! isOverflow(result) ||
|
|
(options.ignoreOverflow)) {
|
|
return result;
|
|
}
|
|
}
|
|
if (m instanceof FloatPoint || n instanceof FloatPoint) {
|
|
if (options.doNotCoerseToFloating) {
|
|
return onFixnums(toFixnum(m), toFixnum(n));
|
|
}
|
|
else {
|
|
return FloatPoint.makeInstance(
|
|
onFixnums(toFixnum(m), toFixnum(n)));
|
|
}
|
|
}
|
|
if (typeof(m) === 'number') {
|
|
m = makeBignum(m);
|
|
}
|
|
if (typeof(n) === 'number') {
|
|
n = makeBignum(n);
|
|
}
|
|
return onBignums(m, n);
|
|
});
|
|
};
|
|
|
|
|
|
var makeIntegerUnOp = function(onFixnums, onBignums, options) {
|
|
options = options || {};
|
|
return (function(m) {
|
|
if (m instanceof Rational) {
|
|
m = numerator(m);
|
|
} else if (m instanceof Complex) {
|
|
m = realPart(m);
|
|
}
|
|
|
|
if (typeof(m) === 'number') {
|
|
var result = onFixnums(m);
|
|
if (! isOverflow(result) ||
|
|
(options.ignoreOverflow)) {
|
|
return result;
|
|
}
|
|
}
|
|
if (m instanceof FloatPoint) {
|
|
return onFixnums(toFixnum(m));
|
|
}
|
|
if (typeof(m) === 'number') {
|
|
m = makeBignum(m);
|
|
}
|
|
return onBignums(m);
|
|
});
|
|
};
|
|
|
|
|
|
|
|
// _integerModulo: integer-scheme-number integer-scheme-number -> integer-scheme-number
|
|
var _integerModulo = makeIntegerBinop(
|
|
function(m, n) {
|
|
return m % n;
|
|
},
|
|
function(m, n) {
|
|
return bnMod.call(m, n);
|
|
});
|
|
|
|
|
|
// _integerGcd: integer-scheme-number integer-scheme-number -> integer-scheme-number
|
|
var _integerGcd = makeIntegerBinop(
|
|
function(a, b) {
|
|
var t;
|
|
while (b !== 0) {
|
|
t = a;
|
|
a = b;
|
|
b = t % b;
|
|
}
|
|
return a;
|
|
},
|
|
function(m, n) {
|
|
return bnGCD.call(m, n);
|
|
});
|
|
|
|
|
|
// _integerIsZero: integer-scheme-number -> boolean
|
|
// Returns true if the number is zero.
|
|
var _integerIsZero = makeIntegerUnOp(
|
|
function(n){
|
|
return n === 0;
|
|
},
|
|
function(n) {
|
|
return bnEquals.call(n, BigInteger.ZERO);
|
|
}
|
|
);
|
|
|
|
|
|
// _integerIsOne: integer-scheme-number -> boolean
|
|
var _integerIsOne = makeIntegerUnOp(
|
|
function(n) {
|
|
return n === 1;
|
|
},
|
|
function(n) {
|
|
return bnEquals.call(n, BigInteger.ONE);
|
|
});
|
|
|
|
|
|
|
|
// _integerIsNegativeOne: integer-scheme-number -> boolean
|
|
var _integerIsNegativeOne = makeIntegerUnOp(
|
|
function(n) {
|
|
return n === -1;
|
|
},
|
|
function(n) {
|
|
return bnEquals.call(n, BigInteger.NEGATIVE_ONE);
|
|
});
|
|
|
|
|
|
|
|
// _integerAdd: integer-scheme-number integer-scheme-number -> integer-scheme-number
|
|
var _integerAdd = makeIntegerBinop(
|
|
function(m, n) {
|
|
return m + n;
|
|
},
|
|
function(m, n) {
|
|
return bnAdd.call(m, n);
|
|
});
|
|
|
|
// _integerSubtract: integer-scheme-number integer-scheme-number -> integer-scheme-number
|
|
var _integerSubtract = makeIntegerBinop(
|
|
function(m, n) {
|
|
return m - n;
|
|
},
|
|
function(m, n) {
|
|
return bnSubtract.call(m, n);
|
|
});
|
|
|
|
// _integerMultiply: integer-scheme-number integer-scheme-number -> integer-scheme-number
|
|
var _integerMultiply = makeIntegerBinop(
|
|
function(m, n) {
|
|
return m * n;
|
|
},
|
|
function(m, n) {
|
|
return bnMultiply.call(m, n);
|
|
});
|
|
|
|
//_integerQuotient: integer-scheme-number integer-scheme-number -> integer-scheme-number
|
|
var _integerQuotient = makeIntegerBinop(
|
|
function(m, n) {
|
|
return ((m - (m % n))/ n);
|
|
},
|
|
function(m, n) {
|
|
return bnDivide.call(m, n);
|
|
});
|
|
|
|
var _integerRemainder = makeIntegerBinop(
|
|
function(m, n) {
|
|
return m % n;
|
|
},
|
|
function(m, n) {
|
|
return bnRemainder.call(m, n);
|
|
});
|
|
|
|
|
|
// _integerDivideToFixnum: integer-scheme-number integer-scheme-number -> fixnum
|
|
var _integerDivideToFixnum = makeIntegerBinop(
|
|
function(m, n) {
|
|
return m / n;
|
|
},
|
|
function(m, n) {
|
|
return toFixnum(m) / toFixnum(n);
|
|
},
|
|
{ignoreOverflow: true,
|
|
doNotCoerseToFloating: true});
|
|
|
|
|
|
// _integerEquals: integer-scheme-number integer-scheme-number -> boolean
|
|
var _integerEquals = makeIntegerBinop(
|
|
function(m, n) {
|
|
return m === n;
|
|
},
|
|
function(m, n) {
|
|
return bnEquals.call(m, n);
|
|
},
|
|
{doNotCoerseToFloating: true});
|
|
|
|
// _integerGreaterThan: integer-scheme-number integer-scheme-number -> boolean
|
|
var _integerGreaterThan = makeIntegerBinop(
|
|
function(m, n) {
|
|
return m > n;
|
|
},
|
|
function(m, n) {
|
|
return bnCompareTo.call(m, n) > 0;
|
|
},
|
|
{doNotCoerseToFloating: true});
|
|
|
|
// _integerLessThan: integer-scheme-number integer-scheme-number -> boolean
|
|
var _integerLessThan = makeIntegerBinop(
|
|
function(m, n) {
|
|
return m < n;
|
|
},
|
|
function(m, n) {
|
|
return bnCompareTo.call(m, n) < 0;
|
|
},
|
|
{doNotCoerseToFloating: true});
|
|
|
|
// _integerGreaterThanOrEqual: integer-scheme-number integer-scheme-number -> boolean
|
|
var _integerGreaterThanOrEqual = makeIntegerBinop(
|
|
function(m, n) {
|
|
return m >= n;
|
|
},
|
|
function(m, n) {
|
|
return bnCompareTo.call(m, n) >= 0;
|
|
},
|
|
{doNotCoerseToFloating: true});
|
|
|
|
// _integerLessThanOrEqual: integer-scheme-number integer-scheme-number -> boolean
|
|
var _integerLessThanOrEqual = makeIntegerBinop(
|
|
function(m, n) {
|
|
return m <= n;
|
|
},
|
|
function(m, n) {
|
|
return bnCompareTo.call(m, n) <= 0;
|
|
},
|
|
{doNotCoerseToFloating: true});
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// The boxed number types are expected to implement the following
|
|
// interface.
|
|
//
|
|
// toString: -> string
|
|
|
|
// level: number
|
|
|
|
// liftTo: scheme-number -> scheme-number
|
|
|
|
// isFinite: -> boolean
|
|
|
|
// isInteger: -> boolean
|
|
// Produce true if this number can be coersed into an integer.
|
|
|
|
// isRational: -> boolean
|
|
// Produce true if the number is rational.
|
|
|
|
// isReal: -> boolean
|
|
// Produce true if the number is real.
|
|
|
|
// isExact: -> boolean
|
|
// Produce true if the number is exact
|
|
|
|
// toExact: -> scheme-number
|
|
// Produce an exact number.
|
|
|
|
// toFixnum: -> javascript-number
|
|
// Produce a javascript number.
|
|
|
|
// greaterThan: scheme-number -> boolean
|
|
// Compare against instance of the same type.
|
|
|
|
// greaterThanOrEqual: scheme-number -> boolean
|
|
// Compare against instance of the same type.
|
|
|
|
// lessThan: scheme-number -> boolean
|
|
// Compare against instance of the same type.
|
|
|
|
// lessThanOrEqual: scheme-number -> boolean
|
|
// Compare against instance of the same type.
|
|
|
|
// add: scheme-number -> scheme-number
|
|
// Add with an instance of the same type.
|
|
|
|
// subtract: scheme-number -> scheme-number
|
|
// Subtract with an instance of the same type.
|
|
|
|
// multiply: scheme-number -> scheme-number
|
|
// Multiply with an instance of the same type.
|
|
|
|
// divide: scheme-number -> scheme-number
|
|
// Divide with an instance of the same type.
|
|
|
|
// numerator: -> scheme-number
|
|
// Return the numerator.
|
|
|
|
// denominator: -> scheme-number
|
|
// Return the denominator.
|
|
|
|
// integerSqrt: -> scheme-number
|
|
// Produce the integer square root.
|
|
|
|
// sqrt: -> scheme-number
|
|
// Produce the square root.
|
|
|
|
// abs: -> scheme-number
|
|
// Produce the absolute value.
|
|
|
|
// floor: -> scheme-number
|
|
// Produce the floor.
|
|
|
|
// ceiling: -> scheme-number
|
|
// Produce the ceiling.
|
|
|
|
// conjugate: -> scheme-number
|
|
// Produce the conjugate.
|
|
|
|
// magnitude: -> scheme-number
|
|
// Produce the magnitude.
|
|
|
|
// log: -> scheme-number
|
|
// Produce the log.
|
|
|
|
// angle: -> scheme-number
|
|
// Produce the angle.
|
|
|
|
// atan: -> scheme-number
|
|
// Produce the arc tangent.
|
|
|
|
// cos: -> scheme-number
|
|
// Produce the cosine.
|
|
|
|
// sin: -> scheme-number
|
|
// Produce the sine.
|
|
|
|
// expt: scheme-number -> scheme-number
|
|
// Produce the power to the input.
|
|
|
|
// exp: -> scheme-number
|
|
// Produce e raised to the given power.
|
|
|
|
// acos: -> scheme-number
|
|
// Produce the arc cosine.
|
|
|
|
// asin: -> scheme-number
|
|
// Produce the arc sine.
|
|
|
|
// imaginaryPart: -> scheme-number
|
|
// Produce the imaginary part
|
|
|
|
// realPart: -> scheme-number
|
|
// Produce the real part.
|
|
|
|
// round: -> scheme-number
|
|
// Round to the nearest integer.
|
|
|
|
// equals: scheme-number -> boolean
|
|
// Produce true if the given number of the same type is equal.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// Rationals
|
|
|
|
|
|
var Rational = function(n, d) {
|
|
this.n = n;
|
|
this.d = d;
|
|
};
|
|
|
|
|
|
Rational.prototype.toString = function() {
|
|
if (_integerIsOne(this.d)) {
|
|
return this.n.toString() + "";
|
|
} else {
|
|
return this.n.toString() + "/" + this.d.toString();
|
|
}
|
|
};
|
|
|
|
|
|
Rational.prototype.level = 1;
|
|
|
|
|
|
Rational.prototype.liftTo = function(target) {
|
|
if (target.level === 2)
|
|
return new FloatPoint(
|
|
_integerDivideToFixnum(this.n, this.d));
|
|
if (target.level === 3)
|
|
return new Complex(this, 0);
|
|
return throwRuntimeError("invalid level of Number", this, target);
|
|
};
|
|
|
|
Rational.prototype.isFinite = function() {
|
|
return true;
|
|
};
|
|
|
|
Rational.prototype.equals = function(other) {
|
|
return (other instanceof Rational &&
|
|
_integerEquals(this.n, other.n) &&
|
|
_integerEquals(this.d, other.d));
|
|
};
|
|
|
|
|
|
|
|
Rational.prototype.isInteger = function() {
|
|
return _integerIsOne(this.d);
|
|
};
|
|
|
|
Rational.prototype.isRational = function() {
|
|
return true;
|
|
};
|
|
|
|
Rational.prototype.isReal = function() {
|
|
return true;
|
|
};
|
|
|
|
|
|
Rational.prototype.add = function(other) {
|
|
return Rational.makeInstance(_integerAdd(_integerMultiply(this.n, other.d),
|
|
_integerMultiply(this.d, other.n)),
|
|
_integerMultiply(this.d, other.d));
|
|
};
|
|
|
|
Rational.prototype.subtract = function(other) {
|
|
return Rational.makeInstance(_integerSubtract(_integerMultiply(this.n, other.d),
|
|
_integerMultiply(this.d, other.n)),
|
|
_integerMultiply(this.d, other.d));
|
|
};
|
|
|
|
Rational.prototype.negate = function() {
|
|
return Rational.makeInstance(-this.n, this.d)
|
|
};
|
|
|
|
Rational.prototype.multiply = function(other) {
|
|
return Rational.makeInstance(_integerMultiply(this.n, other.n),
|
|
_integerMultiply(this.d, other.d));
|
|
};
|
|
|
|
Rational.prototype.divide = function(other) {
|
|
if (_integerIsZero(this.d) || _integerIsZero(other.n)) {
|
|
throwRuntimeError("/: division by zero", this, other);
|
|
}
|
|
return Rational.makeInstance(_integerMultiply(this.n, other.d),
|
|
_integerMultiply(this.d, other.n));
|
|
};
|
|
|
|
|
|
Rational.prototype.toExact = function() {
|
|
return this;
|
|
};
|
|
|
|
Rational.prototype.toInexact = function() {
|
|
return FloatPoint.makeInstance(this.toFixnum());
|
|
};
|
|
|
|
|
|
Rational.prototype.isExact = function() {
|
|
return true;
|
|
};
|
|
|
|
Rational.prototype.isInexact = function() {
|
|
return false;
|
|
};
|
|
|
|
|
|
Rational.prototype.toFixnum = function() {
|
|
return _integerDivideToFixnum(this.n, this.d);
|
|
};
|
|
|
|
Rational.prototype.numerator = function() {
|
|
return this.n;
|
|
};
|
|
|
|
Rational.prototype.denominator = function() {
|
|
return this.d;
|
|
};
|
|
|
|
Rational.prototype.greaterThan = function(other) {
|
|
return _integerGreaterThan(_integerMultiply(this.n, other.d),
|
|
_integerMultiply(this.d, other.n));
|
|
};
|
|
|
|
Rational.prototype.greaterThanOrEqual = function(other) {
|
|
return _integerGreaterThanOrEqual(_integerMultiply(this.n, other.d),
|
|
_integerMultiply(this.d, other.n));
|
|
};
|
|
|
|
Rational.prototype.lessThan = function(other) {
|
|
return _integerLessThan(_integerMultiply(this.n, other.d),
|
|
_integerMultiply(this.d, other.n));
|
|
};
|
|
|
|
Rational.prototype.lessThanOrEqual = function(other) {
|
|
return _integerLessThanOrEqual(_integerMultiply(this.n, other.d),
|
|
_integerMultiply(this.d, other.n));
|
|
};
|
|
|
|
Rational.prototype.integerSqrt = function() {
|
|
var result = sqrt(this);
|
|
if (isRational(result)) {
|
|
return toExact(floor(result));
|
|
} else if (isReal(result)) {
|
|
return toExact(floor(result));
|
|
} else {
|
|
return Complex.makeInstance(toExact(floor(realPart(result))),
|
|
toExact(floor(imaginaryPart(result))));
|
|
}
|
|
};
|
|
|
|
|
|
Rational.prototype.sqrt = function() {
|
|
if (_integerGreaterThanOrEqual(this.n, 0)) {
|
|
var newN = sqrt(this.n);
|
|
var newD = sqrt(this.d);
|
|
if (equals(floor(newN), newN) &&
|
|
equals(floor(newD), newD)) {
|
|
return Rational.makeInstance(newN, newD);
|
|
} else {
|
|
return FloatPoint.makeInstance(_integerDivideToFixnum(newN, newD));
|
|
}
|
|
} else {
|
|
var newN = sqrt(negate(this.n));
|
|
var newD = sqrt(this.d);
|
|
if (equals(floor(newN), newN) &&
|
|
equals(floor(newD), newD)) {
|
|
return Complex.makeInstance(
|
|
0,
|
|
Rational.makeInstance(newN, newD));
|
|
} else {
|
|
return Complex.makeInstance(
|
|
0,
|
|
FloatPoint.makeInstance(_integerDivideToFixnum(newN, newD)));
|
|
}
|
|
}
|
|
};
|
|
|
|
Rational.prototype.abs = function() {
|
|
return Rational.makeInstance(abs(this.n),
|
|
this.d);
|
|
};
|
|
|
|
|
|
Rational.prototype.floor = function() {
|
|
var quotient = _integerQuotient(this.n, this.d);
|
|
if (_integerLessThan(this.n, 0)) {
|
|
return subtract(quotient, 1);
|
|
} else {
|
|
return quotient;
|
|
}
|
|
};
|
|
|
|
|
|
Rational.prototype.ceiling = function() {
|
|
var quotient = _integerQuotient(this.n, this.d);
|
|
if (_integerLessThan(this.n, 0)) {
|
|
return quotient;
|
|
} else {
|
|
return add(quotient, 1);
|
|
}
|
|
};
|
|
|
|
Rational.prototype.conjugate = function() {
|
|
return this;
|
|
};
|
|
|
|
Rational.prototype.magnitude = Rational.prototype.abs;
|
|
|
|
Rational.prototype.log = function(){
|
|
return FloatPoint.makeInstance(Math.log(this.n / this.d));
|
|
};
|
|
|
|
Rational.prototype.angle = function(){
|
|
if (_integerIsZero(this.n))
|
|
return 0;
|
|
if (_integerGreaterThan(this.n, 0))
|
|
return 0;
|
|
else
|
|
return FloatPoint.pi;
|
|
};
|
|
|
|
Rational.prototype.tan = function(){
|
|
return FloatPoint.makeInstance(Math.tan(_integerDivideToFixnum(this.n, this.d)));
|
|
};
|
|
|
|
Rational.prototype.atan = function(){
|
|
return FloatPoint.makeInstance(Math.atan(_integerDivideToFixnum(this.n, this.d)));
|
|
};
|
|
|
|
Rational.prototype.cos = function(){
|
|
return FloatPoint.makeInstance(Math.cos(_integerDivideToFixnum(this.n, this.d)));
|
|
};
|
|
|
|
Rational.prototype.sin = function(){
|
|
return FloatPoint.makeInstance(Math.sin(_integerDivideToFixnum(this.n, this.d)));
|
|
};
|
|
|
|
Rational.prototype.expt = function(a){
|
|
if (isExactInteger(a) && greaterThanOrEqual(a, 0)) {
|
|
return fastExpt(this, a);
|
|
}
|
|
return FloatPoint.makeInstance(Math.pow(_integerDivideToFixnum(this.n, this.d),
|
|
_integerDivideToFixnum(a.n, a.d)));
|
|
};
|
|
|
|
Rational.prototype.exp = function(){
|
|
return FloatPoint.makeInstance(Math.exp(_integerDivideToFixnum(this.n, this.d)));
|
|
};
|
|
|
|
Rational.prototype.acos = function(){
|
|
return FloatPoint.makeInstance(Math.acos(_integerDivideToFixnum(this.n, this.d)));
|
|
};
|
|
|
|
Rational.prototype.asin = function(){
|
|
return FloatPoint.makeInstance(Math.asin(_integerDivideToFixnum(this.n, this.d)));
|
|
};
|
|
|
|
Rational.prototype.imaginaryPart = function(){
|
|
return 0;
|
|
};
|
|
|
|
Rational.prototype.realPart = function(){
|
|
return this;
|
|
};
|
|
|
|
|
|
Rational.prototype.round = function() {
|
|
// FIXME: not correct when values are bignums
|
|
if (equals(this.d, 2)) {
|
|
// Round to even if it's a n/2
|
|
var v = _integerDivideToFixnum(this.n, this.d);
|
|
var fl = Math.floor(v);
|
|
var ce = Math.ceil(v);
|
|
if (_integerIsZero(fl % 2)) {
|
|
return fl;
|
|
}
|
|
else {
|
|
return ce;
|
|
}
|
|
} else {
|
|
return Math.round(this.n / this.d);
|
|
}
|
|
};
|
|
|
|
|
|
Rational.makeInstance = function(n, d) {
|
|
if (n === undefined)
|
|
throwRuntimeError("n undefined", n, d);
|
|
|
|
if (d === undefined) { d = 1; }
|
|
|
|
if (_integerLessThan(d, 0)) {
|
|
n = negate(n);
|
|
d = negate(d);
|
|
}
|
|
|
|
var divisor = _integerGcd(abs(n), abs(d));
|
|
n = _integerQuotient(n, divisor);
|
|
d = _integerQuotient(d, divisor);
|
|
|
|
// Optimization: if we can get around construction the rational
|
|
// in favor of just returning n, do it:
|
|
if (_integerIsOne(d) || _integerIsZero(n)) {
|
|
return n;
|
|
}
|
|
|
|
return new Rational(n, d);
|
|
};
|
|
|
|
|
|
|
|
// Floating Point numbers
|
|
var FloatPoint = function(n) {
|
|
this.n = n;
|
|
};
|
|
FloatPoint = FloatPoint;
|
|
|
|
|
|
var NaN = new FloatPoint(Number.NaN);
|
|
var inf = new FloatPoint(Number.POSITIVE_INFINITY);
|
|
var neginf = new FloatPoint(Number.NEGATIVE_INFINITY);
|
|
|
|
// We use these two constants to represent the floating-point coersion
|
|
// of bignums that can't be represented with fidelity.
|
|
var TOO_POSITIVE_TO_REPRESENT = new FloatPoint(Number.POSITIVE_INFINITY);
|
|
var TOO_NEGATIVE_TO_REPRESENT = new FloatPoint(Number.NEGATIVE_INFINITY);
|
|
|
|
// Negative zero is a distinguished value representing -0.0.
|
|
// There should only be one instance for -0.0.
|
|
var NEGATIVE_ZERO = new FloatPoint(-0.0);
|
|
var INEXACT_ZERO = new FloatPoint(0.0);
|
|
|
|
FloatPoint.pi = new FloatPoint(Math.PI);
|
|
FloatPoint.e = new FloatPoint(Math.E);
|
|
FloatPoint.nan = NaN;
|
|
FloatPoint.inf = inf;
|
|
FloatPoint.neginf = neginf;
|
|
|
|
FloatPoint.makeInstance = function(n) {
|
|
if (isNaN(n)) {
|
|
return FloatPoint.nan;
|
|
} else if (n === Number.POSITIVE_INFINITY) {
|
|
return FloatPoint.inf;
|
|
} else if (n === Number.NEGATIVE_INFINITY) {
|
|
return FloatPoint.neginf;
|
|
} else if (n === 0) {
|
|
if ((1/n) === -Infinity) {
|
|
return NEGATIVE_ZERO;
|
|
} else {
|
|
return INEXACT_ZERO;
|
|
}
|
|
}
|
|
return new FloatPoint(n);
|
|
};
|
|
|
|
|
|
FloatPoint.prototype.isExact = function() {
|
|
return false;
|
|
};
|
|
|
|
FloatPoint.prototype.isInexact = function() {
|
|
return true;
|
|
};
|
|
|
|
|
|
FloatPoint.prototype.isFinite = function() {
|
|
return (isFinite(this.n) ||
|
|
this === TOO_POSITIVE_TO_REPRESENT ||
|
|
this === TOO_NEGATIVE_TO_REPRESENT);
|
|
};
|
|
|
|
|
|
FloatPoint.prototype.toExact = function() {
|
|
// The precision of ieee is about 16 decimal digits, which we use here.
|
|
if (! isFinite(this.n) || isNaN(this.n)) {
|
|
throwRuntimeError("toExact: no exact representation for " + this, this);
|
|
}
|
|
|
|
var stringRep = this.n.toString();
|
|
var match = stringRep.match(/^(.*)\.(.*)$/);
|
|
if (match) {
|
|
var intPart = parseInt(match[1]);
|
|
var fracPart = parseInt(match[2]);
|
|
var tenToDecimalPlaces = Math.pow(10, match[2].length);
|
|
return Rational.makeInstance(Math.round(this.n * tenToDecimalPlaces),
|
|
tenToDecimalPlaces);
|
|
}
|
|
else {
|
|
return this.n;
|
|
}
|
|
};
|
|
|
|
FloatPoint.prototype.toInexact = function() {
|
|
return this;
|
|
};
|
|
|
|
FloatPoint.prototype.isInexact = function() {
|
|
return true;
|
|
};
|
|
|
|
|
|
FloatPoint.prototype.level = 2;
|
|
|
|
|
|
FloatPoint.prototype.liftTo = function(target) {
|
|
if (target.level === 3)
|
|
return new Complex(this, 0);
|
|
return throwRuntimeError("invalid level of Number", this, target);
|
|
};
|
|
|
|
FloatPoint.prototype.toString = function() {
|
|
if (isNaN(this.n))
|
|
return "+nan.0";
|
|
if (this.n === Number.POSITIVE_INFINITY)
|
|
return "+inf.0";
|
|
if (this.n === Number.NEGATIVE_INFINITY)
|
|
return "-inf.0";
|
|
if (this === NEGATIVE_ZERO)
|
|
return "-0.0";
|
|
var partialResult = this.n.toString();
|
|
if (! partialResult.match('\\.')) {
|
|
return partialResult + ".0";
|
|
} else {
|
|
return partialResult;
|
|
}
|
|
};
|
|
|
|
|
|
FloatPoint.prototype.equals = function(other, aUnionFind) {
|
|
return ((other instanceof FloatPoint) &&
|
|
((this.n === other.n)));
|
|
};
|
|
|
|
|
|
|
|
FloatPoint.prototype.isRational = function() {
|
|
return this.isFinite();
|
|
};
|
|
|
|
FloatPoint.prototype.isInteger = function() {
|
|
return this.isFinite() && this.n === Math.floor(this.n);
|
|
};
|
|
|
|
FloatPoint.prototype.isReal = function() {
|
|
return true;
|
|
};
|
|
|
|
|
|
// sign: Number -> {-1, 0, 1}
|
|
var sign = function(n) {
|
|
if (lessThan(n, 0)) {
|
|
return -1;
|
|
} else if (greaterThan(n, 0)) {
|
|
return 1;
|
|
} else if (n === NEGATIVE_ZERO) {
|
|
return -1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
|
|
FloatPoint.prototype.add = function(other) {
|
|
if (this.isFinite() && other.isFinite()) {
|
|
return FloatPoint.makeInstance(this.n + other.n);
|
|
} else {
|
|
if (isNaN(this.n) || isNaN(other.n)) {
|
|
return NaN;
|
|
} else if (this.isFinite() && ! other.isFinite()) {
|
|
return other;
|
|
} else if (!this.isFinite() && other.isFinite()) {
|
|
return this;
|
|
} else {
|
|
return ((sign(this) * sign(other) === 1) ?
|
|
this : NaN);
|
|
};
|
|
}
|
|
};
|
|
|
|
FloatPoint.prototype.subtract = function(other) {
|
|
if (this.isFinite() && other.isFinite()) {
|
|
return FloatPoint.makeInstance(this.n - other.n);
|
|
} else if (isNaN(this.n) || isNaN(other.n)) {
|
|
return NaN;
|
|
} else if (! this.isFinite() && ! other.isFinite()) {
|
|
if (sign(this) === sign(other)) {
|
|
return NaN;
|
|
} else {
|
|
return this;
|
|
}
|
|
} else if (this.isFinite()) {
|
|
return multiply(other, -1);
|
|
} else { // other.isFinite()
|
|
return this;
|
|
}
|
|
};
|
|
|
|
|
|
FloatPoint.prototype.negate = function() {
|
|
return FloatPoint.makeInstance(-this.n);
|
|
};
|
|
|
|
FloatPoint.prototype.multiply = function(other) {
|
|
return FloatPoint.makeInstance(this.n * other.n);
|
|
};
|
|
|
|
FloatPoint.prototype.divide = function(other) {
|
|
return FloatPoint.makeInstance(this.n / other.n);
|
|
};
|
|
|
|
|
|
FloatPoint.prototype.toFixnum = function() {
|
|
return this.n;
|
|
};
|
|
|
|
FloatPoint.prototype.numerator = function() {
|
|
var stringRep = this.n.toString();
|
|
var match = stringRep.match(/^(.*)\.(.*)$/);
|
|
if (match) {
|
|
var afterDecimal = parseInt(match[2]);
|
|
var factorToInt = Math.pow(10, match[2].length);
|
|
var extraFactor = _integerGcd(factorToInt, afterDecimal);
|
|
var multFactor = factorToInt / extraFactor;
|
|
return FloatPoint.makeInstance( Math.round(this.n * multFactor) );
|
|
} else {
|
|
return this;
|
|
}
|
|
};
|
|
|
|
FloatPoint.prototype.denominator = function() {
|
|
var stringRep = this.n.toString();
|
|
var match = stringRep.match(/^(.*)\.(.*)$/);
|
|
if (match) {
|
|
var afterDecimal = parseInt(match[2]);
|
|
var factorToInt = Math.pow(10, match[2].length);
|
|
var extraFactor = _integerGcd(factorToInt, afterDecimal);
|
|
return FloatPoint.makeInstance( Math.round(factorToInt/extraFactor) );
|
|
} else {
|
|
return FloatPoint.makeInstance(1);
|
|
}
|
|
};
|
|
|
|
|
|
FloatPoint.prototype.floor = function() {
|
|
return FloatPoint.makeInstance(Math.floor(this.n));
|
|
};
|
|
|
|
FloatPoint.prototype.ceiling = function() {
|
|
return FloatPoint.makeInstance(Math.ceil(this.n));
|
|
};
|
|
|
|
|
|
FloatPoint.prototype.greaterThan = function(other) {
|
|
return this.n > other.n;
|
|
};
|
|
|
|
FloatPoint.prototype.greaterThanOrEqual = function(other) {
|
|
return this.n >= other.n;
|
|
};
|
|
|
|
FloatPoint.prototype.lessThan = function(other) {
|
|
return this.n < other.n;
|
|
};
|
|
|
|
FloatPoint.prototype.lessThanOrEqual = function(other) {
|
|
return this.n <= other.n;
|
|
};
|
|
|
|
|
|
FloatPoint.prototype.integerSqrt = function() {
|
|
if (this === NEGATIVE_ZERO) { return this; }
|
|
if (isInteger(this)) {
|
|
if(this.n >= 0) {
|
|
return FloatPoint.makeInstance(Math.floor(Math.sqrt(this.n)));
|
|
} else {
|
|
return Complex.makeInstance(
|
|
INEXACT_ZERO,
|
|
FloatPoint.makeInstance(Math.floor(Math.sqrt(-this.n))));
|
|
}
|
|
} else {
|
|
throwRuntimeError("integerSqrt: can only be applied to an integer", this);
|
|
}
|
|
};
|
|
|
|
FloatPoint.prototype.sqrt = function() {
|
|
if (this.n < 0) {
|
|
var result = Complex.makeInstance(
|
|
0,
|
|
FloatPoint.makeInstance(Math.sqrt(-this.n)));
|
|
return result;
|
|
} else {
|
|
return FloatPoint.makeInstance(Math.sqrt(this.n));
|
|
}
|
|
};
|
|
|
|
FloatPoint.prototype.abs = function() {
|
|
return FloatPoint.makeInstance(Math.abs(this.n));
|
|
};
|
|
|
|
|
|
|
|
FloatPoint.prototype.log = function(){
|
|
if (this.n < 0)
|
|
return (new Complex(this, 0)).log();
|
|
else
|
|
return FloatPoint.makeInstance(Math.log(this.n));
|
|
};
|
|
|
|
FloatPoint.prototype.angle = function(){
|
|
if (0 === this.n)
|
|
return 0;
|
|
if (this.n > 0)
|
|
return 0;
|
|
else
|
|
return FloatPoint.pi;
|
|
};
|
|
|
|
FloatPoint.prototype.tan = function(){
|
|
return FloatPoint.makeInstance(Math.tan(this.n));
|
|
};
|
|
|
|
FloatPoint.prototype.atan = function(){
|
|
return FloatPoint.makeInstance(Math.atan(this.n));
|
|
};
|
|
|
|
FloatPoint.prototype.cos = function(){
|
|
return FloatPoint.makeInstance(Math.cos(this.n));
|
|
};
|
|
|
|
FloatPoint.prototype.sin = function(){
|
|
return FloatPoint.makeInstance(Math.sin(this.n));
|
|
};
|
|
|
|
FloatPoint.prototype.expt = function(a){
|
|
if (this.n === 1) {
|
|
if (a.isFinite()) {
|
|
return this;
|
|
} else if (isNaN(a.n)){
|
|
return this;
|
|
} else {
|
|
return this;
|
|
}
|
|
} else {
|
|
return FloatPoint.makeInstance(Math.pow(this.n, a.n));
|
|
}
|
|
};
|
|
|
|
FloatPoint.prototype.exp = function(){
|
|
return FloatPoint.makeInstance(Math.exp(this.n));
|
|
};
|
|
|
|
FloatPoint.prototype.acos = function(){
|
|
return FloatPoint.makeInstance(Math.acos(this.n));
|
|
};
|
|
|
|
FloatPoint.prototype.asin = function(){
|
|
return FloatPoint.makeInstance(Math.asin(this.n));
|
|
};
|
|
|
|
FloatPoint.prototype.imaginaryPart = function(){
|
|
return 0;
|
|
};
|
|
|
|
FloatPoint.prototype.realPart = function(){
|
|
return this;
|
|
};
|
|
|
|
|
|
FloatPoint.prototype.round = function(){
|
|
if (isFinite(this.n)) {
|
|
if (this === NEGATIVE_ZERO) {
|
|
return this;
|
|
}
|
|
if (Math.abs(Math.floor(this.n) - this.n) === 0.5) {
|
|
if (Math.floor(this.n) % 2 === 0)
|
|
return FloatPoint.makeInstance(Math.floor(this.n));
|
|
return FloatPoint.makeInstance(Math.ceil(this.n));
|
|
} else {
|
|
return FloatPoint.makeInstance(Math.round(this.n));
|
|
}
|
|
} else {
|
|
return this;
|
|
}
|
|
};
|
|
|
|
|
|
FloatPoint.prototype.conjugate = function() {
|
|
return this;
|
|
};
|
|
|
|
FloatPoint.prototype.magnitude = FloatPoint.prototype.abs;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Complex numbers
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
var Complex = function(r, i){
|
|
this.r = r;
|
|
this.i = i;
|
|
};
|
|
|
|
// Constructs a complex number from two basic number r and i. r and i can
|
|
// either be plt.type.Rational or plt.type.FloatPoint.
|
|
Complex.makeInstance = function(r, i){
|
|
if (i === undefined) { i = 0; }
|
|
if (isExact(i) && isInteger(i) && _integerIsZero(i)) {
|
|
return r;
|
|
}
|
|
if (isInexact(r) || isInexact(i)) {
|
|
r = toInexact(r);
|
|
i = toInexact(i);
|
|
}
|
|
return new Complex(r, i);
|
|
};
|
|
|
|
Complex.prototype.toString = function() {
|
|
var realPart = this.r.toString(), imagPart = this.i.toString();
|
|
if (imagPart[0] === '-' || imagPart[0] === '+') {
|
|
return realPart + imagPart + 'i';
|
|
} else {
|
|
return realPart + "+" + imagPart + 'i';
|
|
}
|
|
};
|
|
|
|
|
|
Complex.prototype.isFinite = function() {
|
|
return isSchemeNumberFinite(this.r) && isSchemeNumberFinite(this.i);
|
|
};
|
|
|
|
|
|
Complex.prototype.isRational = function() {
|
|
return isRational(this.r) && eqv(this.i, 0);
|
|
};
|
|
|
|
Complex.prototype.isInteger = function() {
|
|
return (isInteger(this.r) &&
|
|
eqv(this.i, 0));
|
|
};
|
|
|
|
Complex.prototype.toExact = function() {
|
|
return Complex.makeInstance( toExact(this.r), toExact(this.i) );
|
|
};
|
|
|
|
Complex.prototype.toInexact = function() {
|
|
return Complex.makeInstance(toInexact(this.r),
|
|
toInexact(this.i));
|
|
};
|
|
|
|
|
|
Complex.prototype.isExact = function() {
|
|
return isExact(this.r) && isExact(this.i);
|
|
};
|
|
|
|
|
|
Complex.prototype.isInexact = function() {
|
|
return isInexact(this.r) || isInexact(this.i);
|
|
};
|
|
|
|
|
|
Complex.prototype.level = 3;
|
|
|
|
|
|
Complex.prototype.liftTo = function(target){
|
|
throwRuntimeError("Don't know how to lift Complex number", this, target);
|
|
};
|
|
|
|
Complex.prototype.equals = function(other) {
|
|
var result = ((other instanceof Complex) &&
|
|
(equals(this.r, other.r)) &&
|
|
(equals(this.i, other.i)));
|
|
return result;
|
|
};
|
|
|
|
|
|
|
|
Complex.prototype.greaterThan = function(other) {
|
|
if (! this.isReal() || ! other.isReal()) {
|
|
throwRuntimeError(">: expects argument of type real number", this, other);
|
|
}
|
|
return greaterThan(this.r, other.r);
|
|
};
|
|
|
|
Complex.prototype.greaterThanOrEqual = function(other) {
|
|
if (! this.isReal() || ! other.isReal()) {
|
|
throwRuntimeError(">=: expects argument of type real number", this, other);
|
|
}
|
|
return greaterThanOrEqual(this.r, other.r);
|
|
};
|
|
|
|
Complex.prototype.lessThan = function(other) {
|
|
if (! this.isReal() || ! other.isReal()) {
|
|
throwRuntimeError("<: expects argument of type real number", this, other);
|
|
}
|
|
return lessThan(this.r, other.r);
|
|
};
|
|
|
|
Complex.prototype.lessThanOrEqual = function(other) {
|
|
if (! this.isReal() || ! other.isReal()) {
|
|
throwRuntimeError("<=: expects argument of type real number", this, other);
|
|
}
|
|
return lessThanOrEqual(this.r, other.r);
|
|
};
|
|
|
|
|
|
Complex.prototype.abs = function(){
|
|
if (!equals(this.i, 0).valueOf())
|
|
throwRuntimeError("abs: expects argument of type real number", this);
|
|
return abs(this.r);
|
|
};
|
|
|
|
Complex.prototype.toFixnum = function(){
|
|
if (!equals(this.i, 0).valueOf())
|
|
throwRuntimeError("toFixnum: expects argument of type real number", this);
|
|
return toFixnum(this.r);
|
|
};
|
|
|
|
Complex.prototype.numerator = function() {
|
|
if (!this.isReal())
|
|
throwRuntimeError("numerator: can only be applied to real number", this);
|
|
return numerator(this.n);
|
|
};
|
|
|
|
|
|
Complex.prototype.denominator = function() {
|
|
if (!this.isReal())
|
|
throwRuntimeError("floor: can only be applied to real number", this);
|
|
return denominator(this.n);
|
|
};
|
|
|
|
Complex.prototype.add = function(other){
|
|
return Complex.makeInstance(
|
|
add(this.r, other.r),
|
|
add(this.i, other.i));
|
|
};
|
|
|
|
Complex.prototype.subtract = function(other){
|
|
return Complex.makeInstance(
|
|
subtract(this.r, other.r),
|
|
subtract(this.i, other.i));
|
|
};
|
|
|
|
Complex.prototype.negate = function() {
|
|
return Complex.makeInstance(negate(this.r),
|
|
negate(this.i));
|
|
};
|
|
|
|
|
|
Complex.prototype.multiply = function(other){
|
|
// If the other value is real, just do primitive division
|
|
if (other.isReal()) {
|
|
return Complex.makeInstance(
|
|
multiply(this.r, other.r),
|
|
multiply(this.i, other.r));
|
|
}
|
|
var r = subtract(
|
|
multiply(this.r, other.r),
|
|
multiply(this.i, other.i));
|
|
var i = add(
|
|
multiply(this.r, other.i),
|
|
multiply(this.i, other.r));
|
|
return Complex.makeInstance(r, i);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
Complex.prototype.divide = function(other){
|
|
var a, b, c, d, r, x, y;
|
|
// If the other value is real, just do primitive division
|
|
if (other.isReal()) {
|
|
return Complex.makeInstance(
|
|
divide(this.r, other.r),
|
|
divide(this.i, other.r));
|
|
}
|
|
|
|
if (this.isInexact() || other.isInexact()) {
|
|
// http://portal.acm.org/citation.cfm?id=1039814
|
|
// We currently use Smith's method, though we should
|
|
// probably switch over to Priest's method.
|
|
a = this.r;
|
|
b = this.i;
|
|
c = other.r;
|
|
d = other.i;
|
|
if (lessThanOrEqual(abs(d), abs(c))) {
|
|
r = divide(d, c);
|
|
x = divide(add(a, multiply(b, r)),
|
|
add(c, multiply(d, r)));
|
|
y = divide(subtract(b, multiply(a, r)),
|
|
add(c, multiply(d, r)));
|
|
} else {
|
|
r = divide(c, d);
|
|
x = divide(add(multiply(a, r), b),
|
|
add(multiply(c, r), d));
|
|
y = divide(subtract(multiply(b, r), a),
|
|
add(multiply(c, r), d));
|
|
}
|
|
return Complex.makeInstance(x, y);
|
|
} else {
|
|
var con = conjugate(other);
|
|
var up = multiply(this, con);
|
|
|
|
// Down is guaranteed to be real by this point.
|
|
var down = realPart(multiply(other, con));
|
|
|
|
var result = Complex.makeInstance(
|
|
divide(realPart(up), down),
|
|
divide(imaginaryPart(up), down));
|
|
return result;
|
|
}
|
|
};
|
|
|
|
Complex.prototype.conjugate = function(){
|
|
var result = Complex.makeInstance(
|
|
this.r,
|
|
subtract(0, this.i));
|
|
|
|
return result;
|
|
};
|
|
|
|
Complex.prototype.magnitude = function(){
|
|
var sum = add(
|
|
multiply(this.r, this.r),
|
|
multiply(this.i, this.i));
|
|
return sqrt(sum);
|
|
};
|
|
|
|
Complex.prototype.isReal = function(){
|
|
return eqv(this.i, 0);
|
|
};
|
|
|
|
Complex.prototype.integerSqrt = function() {
|
|
if (isInteger(this)) {
|
|
return integerSqrt(this.r);
|
|
} else {
|
|
throwRuntimeError("integerSqrt: can only be applied to an integer", this);
|
|
}
|
|
};
|
|
|
|
Complex.prototype.sqrt = function(){
|
|
if (this.isReal())
|
|
return sqrt(this.r);
|
|
// http://en.wikipedia.org/wiki/Square_root#Square_roots_of_negative_and_complex_numbers
|
|
var r_plus_x = add(this.magnitude(), this.r);
|
|
|
|
var r = sqrt(halve(r_plus_x));
|
|
|
|
var i = divide(this.i, sqrt(multiply(r_plus_x, 2)));
|
|
|
|
|
|
return Complex.makeInstance(r, i);
|
|
};
|
|
|
|
Complex.prototype.log = function(){
|
|
var m = this.magnitude();
|
|
var theta = this.angle();
|
|
var result = add(
|
|
log(m),
|
|
timesI(theta));
|
|
return result;
|
|
};
|
|
|
|
Complex.prototype.angle = function(){
|
|
if (this.isReal()) {
|
|
return angle(this.r);
|
|
}
|
|
if (equals(0, this.r)) {
|
|
var tmp = halve(FloatPoint.pi);
|
|
return greaterThan(this.i, 0) ?
|
|
tmp : negate(tmp);
|
|
} else {
|
|
var tmp = atan(divide(abs(this.i), abs(this.r)));
|
|
if (greaterThan(this.r, 0)) {
|
|
return greaterThan(this.i, 0) ?
|
|
tmp : negate(tmp);
|
|
} else {
|
|
return greaterThan(this.i, 0) ?
|
|
subtract(FloatPoint.pi, tmp) : subtract(tmp, FloatPoint.pi);
|
|
}
|
|
}
|
|
};
|
|
|
|
var plusI = Complex.makeInstance(0, 1);
|
|
var minusI = Complex.makeInstance(0, -1);
|
|
|
|
|
|
Complex.prototype.tan = function() {
|
|
return divide(this.sin(), this.cos());
|
|
};
|
|
|
|
Complex.prototype.atan = function(){
|
|
if (equals(this, plusI) ||
|
|
equals(this, minusI)) {
|
|
return neginf;
|
|
}
|
|
return multiply(
|
|
plusI,
|
|
multiply(
|
|
FloatPoint.makeInstance(0.5),
|
|
log(divide(
|
|
add(plusI, this),
|
|
add(
|
|
plusI,
|
|
subtract(0, this))))));
|
|
};
|
|
|
|
Complex.prototype.cos = function(){
|
|
if (this.isReal())
|
|
return cos(this.r);
|
|
var iz = timesI(this);
|
|
var iz_negate = negate(iz);
|
|
|
|
return halve(add(exp(iz), exp(iz_negate)));
|
|
};
|
|
|
|
Complex.prototype.sin = function(){
|
|
if (this.isReal())
|
|
return sin(this.r);
|
|
var iz = timesI(this);
|
|
var iz_negate = negate(iz);
|
|
var z2 = Complex.makeInstance(0, 2);
|
|
var exp_negate = subtract(exp(iz), exp(iz_negate));
|
|
var result = divide(exp_negate, z2);
|
|
return result;
|
|
};
|
|
|
|
|
|
Complex.prototype.expt = function(y){
|
|
if (isExactInteger(y) && greaterThanOrEqual(y, 0)) {
|
|
return fastExpt(this, y);
|
|
}
|
|
var expo = multiply(y, this.log());
|
|
return exp(expo);
|
|
};
|
|
|
|
Complex.prototype.exp = function(){
|
|
var r = exp(this.r);
|
|
var cos_a = cos(this.i);
|
|
var sin_a = sin(this.i);
|
|
|
|
return multiply(
|
|
r,
|
|
add(cos_a, timesI(sin_a)));
|
|
};
|
|
|
|
Complex.prototype.acos = function(){
|
|
if (this.isReal())
|
|
return acos(this.r);
|
|
var pi_half = halve(FloatPoint.pi);
|
|
var iz = timesI(this);
|
|
var root = sqrt(subtract(1, sqr(this)));
|
|
var l = timesI(log(add(iz, root)));
|
|
return add(pi_half, l);
|
|
};
|
|
|
|
Complex.prototype.asin = function(){
|
|
if (this.isReal())
|
|
return asin(this.r);
|
|
|
|
var oneNegateThisSq =
|
|
subtract(1, sqr(this));
|
|
var sqrtOneNegateThisSq = sqrt(oneNegateThisSq);
|
|
return multiply(2, atan(divide(this,
|
|
add(1, sqrtOneNegateThisSq))));
|
|
};
|
|
|
|
Complex.prototype.ceiling = function(){
|
|
if (!this.isReal())
|
|
throwRuntimeError("ceiling: can only be applied to real number", this);
|
|
return ceiling(this.r);
|
|
};
|
|
|
|
Complex.prototype.floor = function(){
|
|
if (!this.isReal())
|
|
throwRuntimeError("floor: can only be applied to real number", this);
|
|
return floor(this.r);
|
|
};
|
|
|
|
Complex.prototype.imaginaryPart = function(){
|
|
return this.i;
|
|
};
|
|
|
|
Complex.prototype.realPart = function(){
|
|
return this.r;
|
|
};
|
|
|
|
Complex.prototype.round = function(){
|
|
if (!this.isReal())
|
|
throwRuntimeError("round: can only be applied to real number", this);
|
|
return round(this.r);
|
|
};
|
|
|
|
|
|
|
|
var rationalRegexp = new RegExp("^([+-]?\\d+)/(\\d+)$");
|
|
var complexRegexp = new RegExp("^([+-]?[\\d\\w/\\.]*)([+-])([\\d\\w/\\.]*)i$");
|
|
var digitRegexp = new RegExp("^[+-]?\\d+$");
|
|
var flonumRegexp = new RegExp("^([+-]?\\d*)\\.(\\d*)$");
|
|
var scientificPattern = new RegExp("^([+-]?\\d*\\.?\\d*)[Ee](\\+?\\d+)$");
|
|
|
|
// fromString: string -> (scheme-number | false)
|
|
var fromString = function(x) {
|
|
var aMatch = x.match(rationalRegexp);
|
|
if (aMatch) {
|
|
return Rational.makeInstance(fromString(aMatch[1]),
|
|
fromString(aMatch[2]));
|
|
}
|
|
|
|
var cMatch = x.match(complexRegexp);
|
|
if (cMatch) {
|
|
return Complex.makeInstance(fromString(cMatch[1] || "0"),
|
|
fromString(cMatch[2] + (cMatch[3] || "1")));
|
|
}
|
|
|
|
// Floating point tests
|
|
if (x === '+nan.0' || x === '-nan.0')
|
|
return FloatPoint.nan;
|
|
if (x === '+inf.0')
|
|
return FloatPoint.inf;
|
|
if (x === '-inf.0')
|
|
return FloatPoint.neginf;
|
|
if (x === "-0.0") {
|
|
return NEGATIVE_ZERO;
|
|
}
|
|
if (x.match(flonumRegexp) || x.match(scientificPattern)) {
|
|
return FloatPoint.makeInstance(Number(x));
|
|
}
|
|
|
|
// Finally, integer tests.
|
|
if (x.match(digitRegexp)) {
|
|
var n = Number(x);
|
|
if (isOverflow(n)) {
|
|
return makeBignum(x);
|
|
} else {
|
|
return n;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// The code below comes from Tom Wu's BigInteger implementation:
|
|
|
|
// Copyright (c) 2005 Tom Wu
|
|
// All Rights Reserved.
|
|
// See "LICENSE" for details.
|
|
|
|
// Basic JavaScript BN library - subset useful for RSA encryption.
|
|
|
|
// Bits per digit
|
|
var dbits;
|
|
|
|
// JavaScript engine analysis
|
|
var canary = 0xdeadbeefcafe;
|
|
var j_lm = ((canary&0xffffff)==0xefcafe);
|
|
|
|
// (public) Constructor
|
|
function BigInteger(a,b,c) {
|
|
if(a != null)
|
|
if("number" == typeof a) this.fromNumber(a,b,c);
|
|
else if(b == null && "string" != typeof a) this.fromString(a,256);
|
|
else this.fromString(a,b);
|
|
}
|
|
|
|
// return new, unset BigInteger
|
|
function nbi() { return new BigInteger(null); }
|
|
|
|
// am: Compute w_j += (x*this_i), propagate carries,
|
|
// c is initial carry, returns final carry.
|
|
// c < 3*dvalue, x < 2*dvalue, this_i < dvalue
|
|
// We need to select the fastest one that works in this environment.
|
|
|
|
// am1: use a single mult and divide to get the high bits,
|
|
// max digit bits should be 26 because
|
|
// max internal value = 2*dvalue^2-2*dvalue (< 2^53)
|
|
function am1(i,x,w,j,c,n) {
|
|
while(--n >= 0) {
|
|
var v = x*this[i++]+w[j]+c;
|
|
c = Math.floor(v/0x4000000);
|
|
w[j++] = v&0x3ffffff;
|
|
}
|
|
return c;
|
|
}
|
|
// am2 avoids a big mult-and-extract completely.
|
|
// Max digit bits should be <= 30 because we do bitwise ops
|
|
// on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)
|
|
function am2(i,x,w,j,c,n) {
|
|
var xl = x&0x7fff, xh = x>>15;
|
|
while(--n >= 0) {
|
|
var l = this[i]&0x7fff;
|
|
var h = this[i++]>>15;
|
|
var m = xh*l+h*xl;
|
|
l = xl*l+((m&0x7fff)<<15)+w[j]+(c&0x3fffffff);
|
|
c = (l>>>30)+(m>>>15)+xh*h+(c>>>30);
|
|
w[j++] = l&0x3fffffff;
|
|
}
|
|
return c;
|
|
}
|
|
// Alternately, set max digit bits to 28 since some
|
|
// browsers slow down when dealing with 32-bit numbers.
|
|
function am3(i,x,w,j,c,n) {
|
|
var xl = x&0x3fff, xh = x>>14;
|
|
while(--n >= 0) {
|
|
var l = this[i]&0x3fff;
|
|
var h = this[i++]>>14;
|
|
var m = xh*l+h*xl;
|
|
l = xl*l+((m&0x3fff)<<14)+w[j]+c;
|
|
c = (l>>28)+(m>>14)+xh*h;
|
|
w[j++] = l&0xfffffff;
|
|
}
|
|
return c;
|
|
}
|
|
if(j_lm && (typeof(navigator) !== 'undefined' && navigator.appName == "Microsoft Internet Explorer")) {
|
|
BigInteger.prototype.am = am2;
|
|
dbits = 30;
|
|
}
|
|
else if(j_lm && (typeof(navigator) !== 'undefined' && navigator.appName != "Netscape")) {
|
|
BigInteger.prototype.am = am1;
|
|
dbits = 26;
|
|
}
|
|
else { // Mozilla/Netscape seems to prefer am3
|
|
BigInteger.prototype.am = am3;
|
|
dbits = 28;
|
|
}
|
|
|
|
BigInteger.prototype.DB = dbits;
|
|
BigInteger.prototype.DM = ((1<<dbits)-1);
|
|
BigInteger.prototype.DV = (1<<dbits);
|
|
|
|
var BI_FP = 52;
|
|
BigInteger.prototype.FV = Math.pow(2,BI_FP);
|
|
BigInteger.prototype.F1 = BI_FP-dbits;
|
|
BigInteger.prototype.F2 = 2*dbits-BI_FP;
|
|
|
|
// Digit conversions
|
|
var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
|
|
var BI_RC = [];
|
|
var rr,vv;
|
|
rr = "0".charCodeAt(0);
|
|
for(vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv;
|
|
rr = "a".charCodeAt(0);
|
|
for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
|
|
rr = "A".charCodeAt(0);
|
|
for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
|
|
|
|
function int2char(n) { return BI_RM.charAt(n); }
|
|
function intAt(s,i) {
|
|
var c = BI_RC[s.charCodeAt(i)];
|
|
return (c==null)?-1:c;
|
|
}
|
|
|
|
// (protected) copy this to r
|
|
function bnpCopyTo(r) {
|
|
for(var i = this.t-1; i >= 0; --i) r[i] = this[i];
|
|
r.t = this.t;
|
|
r.s = this.s;
|
|
}
|
|
|
|
// (protected) set from integer value x, -DV <= x < DV
|
|
function bnpFromInt(x) {
|
|
this.t = 1;
|
|
this.s = (x<0)?-1:0;
|
|
if(x > 0) this[0] = x;
|
|
else if(x < -1) this[0] = x+DV;
|
|
else this.t = 0;
|
|
}
|
|
|
|
// return bigint initialized to value
|
|
function nbv(i) { var r = nbi(); r.fromInt(i); return r; }
|
|
|
|
// (protected) set from string and radix
|
|
function bnpFromString(s,b) {
|
|
var k;
|
|
if(b == 16) k = 4;
|
|
else if(b == 8) k = 3;
|
|
else if(b == 256) k = 8; // byte array
|
|
else if(b == 2) k = 1;
|
|
else if(b == 32) k = 5;
|
|
else if(b == 4) k = 2;
|
|
else { this.fromRadix(s,b); return; }
|
|
this.t = 0;
|
|
this.s = 0;
|
|
var i = s.length, mi = false, sh = 0;
|
|
while(--i >= 0) {
|
|
var x = (k==8)?s[i]&0xff:intAt(s,i);
|
|
if(x < 0) {
|
|
if(s.charAt(i) == "-") mi = true;
|
|
continue;
|
|
}
|
|
mi = false;
|
|
if(sh == 0)
|
|
this[this.t++] = x;
|
|
else if(sh+k > this.DB) {
|
|
this[this.t-1] |= (x&((1<<(this.DB-sh))-1))<<sh;
|
|
this[this.t++] = (x>>(this.DB-sh));
|
|
}
|
|
else
|
|
this[this.t-1] |= x<<sh;
|
|
sh += k;
|
|
if(sh >= this.DB) sh -= this.DB;
|
|
}
|
|
if(k == 8 && (s[0]&0x80) != 0) {
|
|
this.s = -1;
|
|
if(sh > 0) this[this.t-1] |= ((1<<(this.DB-sh))-1)<<sh;
|
|
}
|
|
this.clamp();
|
|
if(mi) BigInteger.ZERO.subTo(this,this);
|
|
}
|
|
|
|
// (protected) clamp off excess high words
|
|
function bnpClamp() {
|
|
var c = this.s&this.DM;
|
|
while(this.t > 0 && this[this.t-1] == c) --this.t;
|
|
}
|
|
|
|
// (public) return string representation in given radix
|
|
function bnToString(b) {
|
|
if(this.s < 0) return "-"+this.negate().toString(b);
|
|
var k;
|
|
if(b == 16) k = 4;
|
|
else if(b == 8) k = 3;
|
|
else if(b == 2) k = 1;
|
|
else if(b == 32) k = 5;
|
|
else if(b == 4) k = 2;
|
|
else return this.toRadix(b);
|
|
var km = (1<<k)-1, d, m = false, r = [], i = this.t;
|
|
var p = this.DB-(i*this.DB)%k;
|
|
if(i-- > 0) {
|
|
if(p < this.DB && (d = this[i]>>p) > 0) { m = true; r.push(int2char(d)); }
|
|
while(i >= 0) {
|
|
if(p < k) {
|
|
d = (this[i]&((1<<p)-1))<<(k-p);
|
|
d |= this[--i]>>(p+=this.DB-k);
|
|
}
|
|
else {
|
|
d = (this[i]>>(p-=k))&km;
|
|
if(p <= 0) { p += this.DB; --i; }
|
|
}
|
|
if(d > 0) m = true;
|
|
if(m) r.push(int2char(d));
|
|
}
|
|
}
|
|
return m?r.join(""):"0";
|
|
}
|
|
|
|
// (public) -this
|
|
function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this,r); return r; }
|
|
|
|
// (public) |this|
|
|
function bnAbs() { return (this.s<0)?this.negate():this; }
|
|
|
|
// (public) return + if this > a, - if this < a, 0 if equal
|
|
function bnCompareTo(a) {
|
|
var r = this.s-a.s;
|
|
if(r != 0) return r;
|
|
var i = this.t;
|
|
if ( this.s < 0 ) {
|
|
r = a.t - i;
|
|
}
|
|
else {
|
|
r = i - a.t;
|
|
}
|
|
if(r != 0) return r;
|
|
while(--i >= 0) if((r=this[i]-a[i]) != 0) return r;
|
|
return 0;
|
|
}
|
|
|
|
// returns bit length of the integer x
|
|
function nbits(x) {
|
|
var r = 1, t;
|
|
if((t=x>>>16) != 0) { x = t; r += 16; }
|
|
if((t=x>>8) != 0) { x = t; r += 8; }
|
|
if((t=x>>4) != 0) { x = t; r += 4; }
|
|
if((t=x>>2) != 0) { x = t; r += 2; }
|
|
if((t=x>>1) != 0) { x = t; r += 1; }
|
|
return r;
|
|
}
|
|
|
|
// (public) return the number of bits in "this"
|
|
function bnBitLength() {
|
|
if(this.t <= 0) return 0;
|
|
return this.DB*(this.t-1)+nbits(this[this.t-1]^(this.s&this.DM));
|
|
}
|
|
|
|
// (protected) r = this << n*DB
|
|
function bnpDLShiftTo(n,r) {
|
|
var i;
|
|
for(i = this.t-1; i >= 0; --i) r[i+n] = this[i];
|
|
for(i = n-1; i >= 0; --i) r[i] = 0;
|
|
r.t = this.t+n;
|
|
r.s = this.s;
|
|
}
|
|
|
|
// (protected) r = this >> n*DB
|
|
function bnpDRShiftTo(n,r) {
|
|
for(var i = n; i < this.t; ++i) r[i-n] = this[i];
|
|
r.t = Math.max(this.t-n,0);
|
|
r.s = this.s;
|
|
}
|
|
|
|
// (protected) r = this << n
|
|
function bnpLShiftTo(n,r) {
|
|
var bs = n%this.DB;
|
|
var cbs = this.DB-bs;
|
|
var bm = (1<<cbs)-1;
|
|
var ds = Math.floor(n/this.DB), c = (this.s<<bs)&this.DM, i;
|
|
for(i = this.t-1; i >= 0; --i) {
|
|
r[i+ds+1] = (this[i]>>cbs)|c;
|
|
c = (this[i]&bm)<<bs;
|
|
}
|
|
for(i = ds-1; i >= 0; --i) r[i] = 0;
|
|
r[ds] = c;
|
|
r.t = this.t+ds+1;
|
|
r.s = this.s;
|
|
r.clamp();
|
|
}
|
|
|
|
// (protected) r = this >> n
|
|
function bnpRShiftTo(n,r) {
|
|
r.s = this.s;
|
|
var ds = Math.floor(n/this.DB);
|
|
if(ds >= this.t) { r.t = 0; return; }
|
|
var bs = n%this.DB;
|
|
var cbs = this.DB-bs;
|
|
var bm = (1<<bs)-1;
|
|
r[0] = this[ds]>>bs;
|
|
for(var i = ds+1; i < this.t; ++i) {
|
|
r[i-ds-1] |= (this[i]&bm)<<cbs;
|
|
r[i-ds] = this[i]>>bs;
|
|
}
|
|
if(bs > 0) r[this.t-ds-1] |= (this.s&bm)<<cbs;
|
|
r.t = this.t-ds;
|
|
r.clamp();
|
|
}
|
|
|
|
// (protected) r = this - a
|
|
function bnpSubTo(a,r) {
|
|
var i = 0, c = 0, m = Math.min(a.t,this.t);
|
|
while(i < m) {
|
|
c += this[i]-a[i];
|
|
r[i++] = c&this.DM;
|
|
c >>= this.DB;
|
|
}
|
|
if(a.t < this.t) {
|
|
c -= a.s;
|
|
while(i < this.t) {
|
|
c += this[i];
|
|
r[i++] = c&this.DM;
|
|
c >>= this.DB;
|
|
}
|
|
c += this.s;
|
|
}
|
|
else {
|
|
c += this.s;
|
|
while(i < a.t) {
|
|
c -= a[i];
|
|
r[i++] = c&this.DM;
|
|
c >>= this.DB;
|
|
}
|
|
c -= a.s;
|
|
}
|
|
r.s = (c<0)?-1:0;
|
|
if(c < -1) r[i++] = this.DV+c;
|
|
else if(c > 0) r[i++] = c;
|
|
r.t = i;
|
|
r.clamp();
|
|
}
|
|
|
|
// (protected) r = this * a, r != this,a (HAC 14.12)
|
|
// "this" should be the larger one if appropriate.
|
|
function bnpMultiplyTo(a,r) {
|
|
var x = this.abs(), y = a.abs();
|
|
var i = x.t;
|
|
r.t = i+y.t;
|
|
while(--i >= 0) r[i] = 0;
|
|
for(i = 0; i < y.t; ++i) r[i+x.t] = x.am(0,y[i],r,i,0,x.t);
|
|
r.s = 0;
|
|
r.clamp();
|
|
if(this.s != a.s) BigInteger.ZERO.subTo(r,r);
|
|
}
|
|
|
|
// (protected) r = this^2, r != this (HAC 14.16)
|
|
function bnpSquareTo(r) {
|
|
var x = this.abs();
|
|
var i = r.t = 2*x.t;
|
|
while(--i >= 0) r[i] = 0;
|
|
for(i = 0; i < x.t-1; ++i) {
|
|
var c = x.am(i,x[i],r,2*i,0,1);
|
|
if((r[i+x.t]+=x.am(i+1,2*x[i],r,2*i+1,c,x.t-i-1)) >= x.DV) {
|
|
r[i+x.t] -= x.DV;
|
|
r[i+x.t+1] = 1;
|
|
}
|
|
}
|
|
if(r.t > 0) r[r.t-1] += x.am(i,x[i],r,2*i,0,1);
|
|
r.s = 0;
|
|
r.clamp();
|
|
}
|
|
|
|
|
|
// (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)
|
|
// r != q, this != m. q or r may be null.
|
|
function bnpDivRemTo(m,q,r) {
|
|
var pm = m.abs();
|
|
if(pm.t <= 0) return;
|
|
var pt = this.abs();
|
|
if(pt.t < pm.t) {
|
|
if(q != null) q.fromInt(0);
|
|
if(r != null) this.copyTo(r);
|
|
return;
|
|
}
|
|
if(r == null) r = nbi();
|
|
var y = nbi(), ts = this.s, ms = m.s;
|
|
var nsh = this.DB-nbits(pm[pm.t-1]); // normalize modulus
|
|
if(nsh > 0) { pm.lShiftTo(nsh,y); pt.lShiftTo(nsh,r); }
|
|
else { pm.copyTo(y); pt.copyTo(r); }
|
|
var ys = y.t;
|
|
var y0 = y[ys-1];
|
|
if(y0 == 0) return;
|
|
var yt = y0*(1<<this.F1)+((ys>1)?y[ys-2]>>this.F2:0);
|
|
var d1 = this.FV/yt, d2 = (1<<this.F1)/yt, e = 1<<this.F2;
|
|
var i = r.t, j = i-ys, t = (q==null)?nbi():q;
|
|
y.dlShiftTo(j,t);
|
|
if(r.compareTo(t) >= 0) {
|
|
r[r.t++] = 1;
|
|
r.subTo(t,r);
|
|
}
|
|
BigInteger.ONE.dlShiftTo(ys,t);
|
|
t.subTo(y,y); // "negative" y so we can replace sub with am later
|
|
while(y.t < ys) y[y.t++] = 0;
|
|
while(--j >= 0) {
|
|
// Estimate quotient digit
|
|
var qd = (r[--i]==y0)?this.DM:Math.floor(r[i]*d1+(r[i-1]+e)*d2);
|
|
if((r[i]+=y.am(0,qd,r,j,0,ys)) < qd) { // Try it out
|
|
y.dlShiftTo(j,t);
|
|
r.subTo(t,r);
|
|
while(r[i] < --qd) r.subTo(t,r);
|
|
}
|
|
}
|
|
if(q != null) {
|
|
r.drShiftTo(ys,q);
|
|
if(ts != ms) BigInteger.ZERO.subTo(q,q);
|
|
}
|
|
r.t = ys;
|
|
r.clamp();
|
|
if(nsh > 0) r.rShiftTo(nsh,r); // Denormalize remainder
|
|
if(ts < 0) BigInteger.ZERO.subTo(r,r);
|
|
}
|
|
|
|
// (public) this mod a
|
|
function bnMod(a) {
|
|
var r = nbi();
|
|
this.abs().divRemTo(a,null,r);
|
|
if(this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r,r);
|
|
return r;
|
|
}
|
|
|
|
// Modular reduction using "classic" algorithm
|
|
function Classic(m) { this.m = m; }
|
|
function cConvert(x) {
|
|
if(x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m);
|
|
else return x;
|
|
}
|
|
function cRevert(x) { return x; }
|
|
function cReduce(x) { x.divRemTo(this.m,null,x); }
|
|
function cMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
|
|
function cSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
|
|
|
|
Classic.prototype.convert = cConvert;
|
|
Classic.prototype.revert = cRevert;
|
|
Classic.prototype.reduce = cReduce;
|
|
Classic.prototype.mulTo = cMulTo;
|
|
Classic.prototype.sqrTo = cSqrTo;
|
|
|
|
// (protected) return "-1/this % 2^DB"; useful for Mont. reduction
|
|
// justification:
|
|
// xy == 1 (mod m)
|
|
// xy = 1+km
|
|
// xy(2-xy) = (1+km)(1-km)
|
|
// x[y(2-xy)] = 1-k^2m^2
|
|
// x[y(2-xy)] == 1 (mod m^2)
|
|
// if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
|
|
// should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
|
|
// JS multiply "overflows" differently from C/C++, so care is needed here.
|
|
function bnpInvDigit() {
|
|
if(this.t < 1) return 0;
|
|
var x = this[0];
|
|
if((x&1) == 0) return 0;
|
|
var y = x&3; // y == 1/x mod 2^2
|
|
y = (y*(2-(x&0xf)*y))&0xf; // y == 1/x mod 2^4
|
|
y = (y*(2-(x&0xff)*y))&0xff; // y == 1/x mod 2^8
|
|
y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff; // y == 1/x mod 2^16
|
|
// last step - calculate inverse mod DV directly;
|
|
// assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
|
|
y = (y*(2-x*y%this.DV))%this.DV; // y == 1/x mod 2^dbits
|
|
// we really want the negative inverse, and -DV < y < DV
|
|
return (y>0)?this.DV-y:-y;
|
|
}
|
|
|
|
// Montgomery reduction
|
|
function Montgomery(m) {
|
|
this.m = m;
|
|
this.mp = m.invDigit();
|
|
this.mpl = this.mp&0x7fff;
|
|
this.mph = this.mp>>15;
|
|
this.um = (1<<(m.DB-15))-1;
|
|
this.mt2 = 2*m.t;
|
|
}
|
|
|
|
// xR mod m
|
|
function montConvert(x) {
|
|
var r = nbi();
|
|
x.abs().dlShiftTo(this.m.t,r);
|
|
r.divRemTo(this.m,null,r);
|
|
if(x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r,r);
|
|
return r;
|
|
}
|
|
|
|
// x/R mod m
|
|
function montRevert(x) {
|
|
var r = nbi();
|
|
x.copyTo(r);
|
|
this.reduce(r);
|
|
return r;
|
|
}
|
|
|
|
// x = x/R mod m (HAC 14.32)
|
|
function montReduce(x) {
|
|
while(x.t <= this.mt2) // pad x so am has enough room later
|
|
x[x.t++] = 0;
|
|
for(var i = 0; i < this.m.t; ++i) {
|
|
// faster way of calculating u0 = x[i]*mp mod DV
|
|
var j = x[i]&0x7fff;
|
|
var u0 = (j*this.mpl+(((j*this.mph+(x[i]>>15)*this.mpl)&this.um)<<15))&x.DM;
|
|
// use am to combine the multiply-shift-add into one call
|
|
j = i+this.m.t;
|
|
x[j] += this.m.am(0,u0,x,i,0,this.m.t);
|
|
// propagate carry
|
|
while(x[j] >= x.DV) { x[j] -= x.DV; x[++j]++; }
|
|
}
|
|
x.clamp();
|
|
x.drShiftTo(this.m.t,x);
|
|
if(x.compareTo(this.m) >= 0) x.subTo(this.m,x);
|
|
}
|
|
|
|
// r = "x^2/R mod m"; x != r
|
|
function montSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
|
|
|
|
// r = "xy/R mod m"; x,y != r
|
|
function montMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
|
|
|
|
Montgomery.prototype.convert = montConvert;
|
|
Montgomery.prototype.revert = montRevert;
|
|
Montgomery.prototype.reduce = montReduce;
|
|
Montgomery.prototype.mulTo = montMulTo;
|
|
Montgomery.prototype.sqrTo = montSqrTo;
|
|
|
|
// (protected) true iff this is even
|
|
function bnpIsEven() { return ((this.t>0)?(this[0]&1):this.s) == 0; }
|
|
|
|
// (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
|
|
function bnpExp(e,z) {
|
|
if(e > 0xffffffff || e < 1) return BigInteger.ONE;
|
|
var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1;
|
|
g.copyTo(r);
|
|
while(--i >= 0) {
|
|
z.sqrTo(r,r2);
|
|
if((e&(1<<i)) > 0) z.mulTo(r2,g,r);
|
|
else { var t = r; r = r2; r2 = t; }
|
|
}
|
|
return z.revert(r);
|
|
}
|
|
|
|
// (public) this^e % m, 0 <= e < 2^32
|
|
function bnModPowInt(e,m) {
|
|
var z;
|
|
if(e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m);
|
|
return this.exp(e,z);
|
|
}
|
|
|
|
// protected
|
|
BigInteger.prototype.copyTo = bnpCopyTo;
|
|
BigInteger.prototype.fromInt = bnpFromInt;
|
|
BigInteger.prototype.fromString = bnpFromString;
|
|
BigInteger.prototype.clamp = bnpClamp;
|
|
BigInteger.prototype.dlShiftTo = bnpDLShiftTo;
|
|
BigInteger.prototype.drShiftTo = bnpDRShiftTo;
|
|
BigInteger.prototype.lShiftTo = bnpLShiftTo;
|
|
BigInteger.prototype.rShiftTo = bnpRShiftTo;
|
|
BigInteger.prototype.subTo = bnpSubTo;
|
|
BigInteger.prototype.multiplyTo = bnpMultiplyTo;
|
|
BigInteger.prototype.squareTo = bnpSquareTo;
|
|
BigInteger.prototype.divRemTo = bnpDivRemTo;
|
|
BigInteger.prototype.invDigit = bnpInvDigit;
|
|
BigInteger.prototype.isEven = bnpIsEven;
|
|
BigInteger.prototype.exp = bnpExp;
|
|
|
|
// public
|
|
BigInteger.prototype.toString = bnToString;
|
|
BigInteger.prototype.negate = bnNegate;
|
|
BigInteger.prototype.abs = bnAbs;
|
|
BigInteger.prototype.compareTo = bnCompareTo;
|
|
BigInteger.prototype.bitLength = bnBitLength;
|
|
BigInteger.prototype.mod = bnMod;
|
|
BigInteger.prototype.modPowInt = bnModPowInt;
|
|
|
|
// "constants"
|
|
BigInteger.ZERO = nbv(0);
|
|
BigInteger.ONE = nbv(1);
|
|
|
|
// Copyright (c) 2005-2009 Tom Wu
|
|
// All Rights Reserved.
|
|
// See "LICENSE" for details.
|
|
|
|
// Extended JavaScript BN functions, required for RSA private ops.
|
|
|
|
// Version 1.1: new BigInteger("0", 10) returns "proper" zero
|
|
|
|
// (public)
|
|
function bnClone() { var r = nbi(); this.copyTo(r); return r; }
|
|
|
|
// (public) return value as integer
|
|
function bnIntValue() {
|
|
if(this.s < 0) {
|
|
if(this.t == 1) return this[0]-this.DV;
|
|
else if(this.t == 0) return -1;
|
|
}
|
|
else if(this.t == 1) return this[0];
|
|
else if(this.t == 0) return 0;
|
|
// assumes 16 < DB < 32
|
|
return ((this[1]&((1<<(32-this.DB))-1))<<this.DB)|this[0];
|
|
}
|
|
|
|
// (public) return value as byte
|
|
function bnByteValue() { return (this.t==0)?this.s:(this[0]<<24)>>24; }
|
|
|
|
// (public) return value as short (assumes DB>=16)
|
|
function bnShortValue() { return (this.t==0)?this.s:(this[0]<<16)>>16; }
|
|
|
|
// (protected) return x s.t. r^x < DV
|
|
function bnpChunkSize(r) { return Math.floor(Math.LN2*this.DB/Math.log(r)); }
|
|
|
|
// (public) 0 if this == 0, 1 if this > 0
|
|
function bnSigNum() {
|
|
if(this.s < 0) return -1;
|
|
else if(this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0;
|
|
else return 1;
|
|
}
|
|
|
|
// (protected) convert to radix string
|
|
function bnpToRadix(b) {
|
|
if(b == null) b = 10;
|
|
if(this.signum() == 0 || b < 2 || b > 36) return "0";
|
|
var cs = this.chunkSize(b);
|
|
var a = Math.pow(b,cs);
|
|
var d = nbv(a), y = nbi(), z = nbi(), r = "";
|
|
this.divRemTo(d,y,z);
|
|
while(y.signum() > 0) {
|
|
r = (a+z.intValue()).toString(b).substr(1) + r;
|
|
y.divRemTo(d,y,z);
|
|
}
|
|
return z.intValue().toString(b) + r;
|
|
}
|
|
|
|
// (protected) convert from radix string
|
|
function bnpFromRadix(s,b) {
|
|
this.fromInt(0);
|
|
if(b == null) b = 10;
|
|
var cs = this.chunkSize(b);
|
|
var d = Math.pow(b,cs), mi = false, j = 0, w = 0;
|
|
for(var i = 0; i < s.length; ++i) {
|
|
var x = intAt(s,i);
|
|
if(x < 0) {
|
|
if(s.charAt(i) == "-" && this.signum() == 0) mi = true;
|
|
continue;
|
|
}
|
|
w = b*w+x;
|
|
if(++j >= cs) {
|
|
this.dMultiply(d);
|
|
this.dAddOffset(w,0);
|
|
j = 0;
|
|
w = 0;
|
|
}
|
|
}
|
|
if(j > 0) {
|
|
this.dMultiply(Math.pow(b,j));
|
|
this.dAddOffset(w,0);
|
|
}
|
|
if(mi) BigInteger.ZERO.subTo(this,this);
|
|
}
|
|
|
|
// (protected) alternate constructor
|
|
function bnpFromNumber(a,b,c) {
|
|
if("number" == typeof b) {
|
|
// new BigInteger(int,int,RNG)
|
|
if(a < 2) this.fromInt(1);
|
|
else {
|
|
this.fromNumber(a,c);
|
|
if(!this.testBit(a-1)) // force MSB set
|
|
this.bitwiseTo(BigInteger.ONE.shiftLeft(a-1),op_or,this);
|
|
if(this.isEven()) this.dAddOffset(1,0); // force odd
|
|
while(!this.isProbablePrime(b)) {
|
|
this.dAddOffset(2,0);
|
|
if(this.bitLength() > a) this.subTo(BigInteger.ONE.shiftLeft(a-1),this);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// new BigInteger(int,RNG)
|
|
var x = [], t = a&7;
|
|
x.length = (a>>3)+1;
|
|
b.nextBytes(x);
|
|
if(t > 0) x[0] &= ((1<<t)-1); else x[0] = 0;
|
|
this.fromString(x,256);
|
|
}
|
|
}
|
|
|
|
// (public) convert to bigendian byte array
|
|
function bnToByteArray() {
|
|
var i = this.t, r = [];
|
|
r[0] = this.s;
|
|
var p = this.DB-(i*this.DB)%8, d, k = 0;
|
|
if(i-- > 0) {
|
|
if(p < this.DB && (d = this[i]>>p) != (this.s&this.DM)>>p)
|
|
r[k++] = d|(this.s<<(this.DB-p));
|
|
while(i >= 0) {
|
|
if(p < 8) {
|
|
d = (this[i]&((1<<p)-1))<<(8-p);
|
|
d |= this[--i]>>(p+=this.DB-8);
|
|
}
|
|
else {
|
|
d = (this[i]>>(p-=8))&0xff;
|
|
if(p <= 0) { p += this.DB; --i; }
|
|
}
|
|
if((d&0x80) != 0) d |= -256;
|
|
if(k == 0 && (this.s&0x80) != (d&0x80)) ++k;
|
|
if(k > 0 || d != this.s) r[k++] = d;
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
function bnEquals(a) { return(this.compareTo(a)==0); }
|
|
function bnMin(a) { return(this.compareTo(a)<0)?this:a; }
|
|
function bnMax(a) { return(this.compareTo(a)>0)?this:a; }
|
|
|
|
// (protected) r = this op a (bitwise)
|
|
function bnpBitwiseTo(a,op,r) {
|
|
var i, f, m = Math.min(a.t,this.t);
|
|
for(i = 0; i < m; ++i) r[i] = op(this[i],a[i]);
|
|
if(a.t < this.t) {
|
|
f = a.s&this.DM;
|
|
for(i = m; i < this.t; ++i) r[i] = op(this[i],f);
|
|
r.t = this.t;
|
|
}
|
|
else {
|
|
f = this.s&this.DM;
|
|
for(i = m; i < a.t; ++i) r[i] = op(f,a[i]);
|
|
r.t = a.t;
|
|
}
|
|
r.s = op(this.s,a.s);
|
|
r.clamp();
|
|
}
|
|
|
|
// (public) this & a
|
|
function op_and(x,y) { return x&y; }
|
|
function bnAnd(a) { var r = nbi(); this.bitwiseTo(a,op_and,r); return r; }
|
|
|
|
// (public) this | a
|
|
function op_or(x,y) { return x|y; }
|
|
function bnOr(a) { var r = nbi(); this.bitwiseTo(a,op_or,r); return r; }
|
|
|
|
// (public) this ^ a
|
|
function op_xor(x,y) { return x^y; }
|
|
function bnXor(a) { var r = nbi(); this.bitwiseTo(a,op_xor,r); return r; }
|
|
|
|
// (public) this & ~a
|
|
function op_andnot(x,y) { return x&~y; }
|
|
function bnAndNot(a) { var r = nbi(); this.bitwiseTo(a,op_andnot,r); return r; }
|
|
|
|
// (public) ~this
|
|
function bnNot() {
|
|
var r = nbi();
|
|
for(var i = 0; i < this.t; ++i) r[i] = this.DM&~this[i];
|
|
r.t = this.t;
|
|
r.s = ~this.s;
|
|
return r;
|
|
}
|
|
|
|
// (public) this << n
|
|
function bnShiftLeft(n) {
|
|
var r = nbi();
|
|
if(n < 0) this.rShiftTo(-n,r); else this.lShiftTo(n,r);
|
|
return r;
|
|
}
|
|
|
|
// (public) this >> n
|
|
function bnShiftRight(n) {
|
|
var r = nbi();
|
|
if(n < 0) this.lShiftTo(-n,r); else this.rShiftTo(n,r);
|
|
return r;
|
|
}
|
|
|
|
// return index of lowest 1-bit in x, x < 2^31
|
|
function lbit(x) {
|
|
if(x == 0) return -1;
|
|
var r = 0;
|
|
if((x&0xffff) == 0) { x >>= 16; r += 16; }
|
|
if((x&0xff) == 0) { x >>= 8; r += 8; }
|
|
if((x&0xf) == 0) { x >>= 4; r += 4; }
|
|
if((x&3) == 0) { x >>= 2; r += 2; }
|
|
if((x&1) == 0) ++r;
|
|
return r;
|
|
}
|
|
|
|
// (public) returns index of lowest 1-bit (or -1 if none)
|
|
function bnGetLowestSetBit() {
|
|
for(var i = 0; i < this.t; ++i)
|
|
if(this[i] != 0) return i*this.DB+lbit(this[i]);
|
|
if(this.s < 0) return this.t*this.DB;
|
|
return -1;
|
|
}
|
|
|
|
// return number of 1 bits in x
|
|
function cbit(x) {
|
|
var r = 0;
|
|
while(x != 0) { x &= x-1; ++r; }
|
|
return r;
|
|
}
|
|
|
|
// (public) return number of set bits
|
|
function bnBitCount() {
|
|
var r = 0, x = this.s&this.DM;
|
|
for(var i = 0; i < this.t; ++i) r += cbit(this[i]^x);
|
|
return r;
|
|
}
|
|
|
|
// (public) true iff nth bit is set
|
|
function bnTestBit(n) {
|
|
var j = Math.floor(n/this.DB);
|
|
if(j >= this.t) return(this.s!=0);
|
|
return((this[j]&(1<<(n%this.DB)))!=0);
|
|
}
|
|
|
|
// (protected) this op (1<<n)
|
|
function bnpChangeBit(n,op) {
|
|
var r = BigInteger.ONE.shiftLeft(n);
|
|
this.bitwiseTo(r,op,r);
|
|
return r;
|
|
}
|
|
|
|
// (public) this | (1<<n)
|
|
function bnSetBit(n) { return this.changeBit(n,op_or); }
|
|
|
|
// (public) this & ~(1<<n)
|
|
function bnClearBit(n) { return this.changeBit(n,op_andnot); }
|
|
|
|
// (public) this ^ (1<<n)
|
|
function bnFlipBit(n) { return this.changeBit(n,op_xor); }
|
|
|
|
// (protected) r = this + a
|
|
function bnpAddTo(a,r) {
|
|
var i = 0, c = 0, m = Math.min(a.t,this.t);
|
|
while(i < m) {
|
|
c += this[i]+a[i];
|
|
r[i++] = c&this.DM;
|
|
c >>= this.DB;
|
|
}
|
|
if(a.t < this.t) {
|
|
c += a.s;
|
|
while(i < this.t) {
|
|
c += this[i];
|
|
r[i++] = c&this.DM;
|
|
c >>= this.DB;
|
|
}
|
|
c += this.s;
|
|
}
|
|
else {
|
|
c += this.s;
|
|
while(i < a.t) {
|
|
c += a[i];
|
|
r[i++] = c&this.DM;
|
|
c >>= this.DB;
|
|
}
|
|
c += a.s;
|
|
}
|
|
r.s = (c<0)?-1:0;
|
|
if(c > 0) r[i++] = c;
|
|
else if(c < -1) r[i++] = this.DV+c;
|
|
r.t = i;
|
|
r.clamp();
|
|
}
|
|
|
|
// (public) this + a
|
|
function bnAdd(a) { var r = nbi(); this.addTo(a,r); return r; }
|
|
|
|
// (public) this - a
|
|
function bnSubtract(a) { var r = nbi(); this.subTo(a,r); return r; }
|
|
|
|
// (public) this * a
|
|
function bnMultiply(a) { var r = nbi(); this.multiplyTo(a,r); return r; }
|
|
|
|
// (public) this / a
|
|
function bnDivide(a) { var r = nbi(); this.divRemTo(a,r,null); return r; }
|
|
|
|
// (public) this % a
|
|
function bnRemainder(a) { var r = nbi(); this.divRemTo(a,null,r); return r; }
|
|
|
|
// (public) [this/a,this%a]
|
|
function bnDivideAndRemainder(a) {
|
|
var q = nbi(), r = nbi();
|
|
this.divRemTo(a,q,r);
|
|
return [q,r];
|
|
}
|
|
|
|
// (protected) this *= n, this >= 0, 1 < n < DV
|
|
function bnpDMultiply(n) {
|
|
this[this.t] = this.am(0,n-1,this,0,0,this.t);
|
|
++this.t;
|
|
this.clamp();
|
|
}
|
|
|
|
// (protected) this += n << w words, this >= 0
|
|
function bnpDAddOffset(n,w) {
|
|
if(n == 0) return;
|
|
while(this.t <= w) this[this.t++] = 0;
|
|
this[w] += n;
|
|
while(this[w] >= this.DV) {
|
|
this[w] -= this.DV;
|
|
if(++w >= this.t) this[this.t++] = 0;
|
|
++this[w];
|
|
}
|
|
}
|
|
|
|
// A "null" reducer
|
|
function NullExp() {}
|
|
function nNop(x) { return x; }
|
|
function nMulTo(x,y,r) { x.multiplyTo(y,r); }
|
|
function nSqrTo(x,r) { x.squareTo(r); }
|
|
|
|
NullExp.prototype.convert = nNop;
|
|
NullExp.prototype.revert = nNop;
|
|
NullExp.prototype.mulTo = nMulTo;
|
|
NullExp.prototype.sqrTo = nSqrTo;
|
|
|
|
// (public) this^e
|
|
function bnPow(e) { return this.exp(e,new NullExp()); }
|
|
|
|
// (protected) r = lower n words of "this * a", a.t <= n
|
|
// "this" should be the larger one if appropriate.
|
|
function bnpMultiplyLowerTo(a,n,r) {
|
|
var i = Math.min(this.t+a.t,n);
|
|
r.s = 0; // assumes a,this >= 0
|
|
r.t = i;
|
|
while(i > 0) r[--i] = 0;
|
|
var j;
|
|
for(j = r.t-this.t; i < j; ++i) r[i+this.t] = this.am(0,a[i],r,i,0,this.t);
|
|
for(j = Math.min(a.t,n); i < j; ++i) this.am(0,a[i],r,i,0,n-i);
|
|
r.clamp();
|
|
}
|
|
|
|
// (protected) r = "this * a" without lower n words, n > 0
|
|
// "this" should be the larger one if appropriate.
|
|
function bnpMultiplyUpperTo(a,n,r) {
|
|
--n;
|
|
var i = r.t = this.t+a.t-n;
|
|
r.s = 0; // assumes a,this >= 0
|
|
while(--i >= 0) r[i] = 0;
|
|
for(i = Math.max(n-this.t,0); i < a.t; ++i)
|
|
r[this.t+i-n] = this.am(n-i,a[i],r,0,0,this.t+i-n);
|
|
r.clamp();
|
|
r.drShiftTo(1,r);
|
|
}
|
|
|
|
// Barrett modular reduction
|
|
function Barrett(m) {
|
|
// setup Barrett
|
|
this.r2 = nbi();
|
|
this.q3 = nbi();
|
|
BigInteger.ONE.dlShiftTo(2*m.t,this.r2);
|
|
this.mu = this.r2.divide(m);
|
|
this.m = m;
|
|
}
|
|
|
|
function barrettConvert(x) {
|
|
if(x.s < 0 || x.t > 2*this.m.t) return x.mod(this.m);
|
|
else if(x.compareTo(this.m) < 0) return x;
|
|
else { var r = nbi(); x.copyTo(r); this.reduce(r); return r; }
|
|
}
|
|
|
|
function barrettRevert(x) { return x; }
|
|
|
|
// x = x mod m (HAC 14.42)
|
|
function barrettReduce(x) {
|
|
x.drShiftTo(this.m.t-1,this.r2);
|
|
if(x.t > this.m.t+1) { x.t = this.m.t+1; x.clamp(); }
|
|
this.mu.multiplyUpperTo(this.r2,this.m.t+1,this.q3);
|
|
this.m.multiplyLowerTo(this.q3,this.m.t+1,this.r2);
|
|
while(x.compareTo(this.r2) < 0) x.dAddOffset(1,this.m.t+1);
|
|
x.subTo(this.r2,x);
|
|
while(x.compareTo(this.m) >= 0) x.subTo(this.m,x);
|
|
}
|
|
|
|
// r = x^2 mod m; x != r
|
|
function barrettSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
|
|
|
|
// r = x*y mod m; x,y != r
|
|
function barrettMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
|
|
|
|
Barrett.prototype.convert = barrettConvert;
|
|
Barrett.prototype.revert = barrettRevert;
|
|
Barrett.prototype.reduce = barrettReduce;
|
|
Barrett.prototype.mulTo = barrettMulTo;
|
|
Barrett.prototype.sqrTo = barrettSqrTo;
|
|
|
|
// (public) this^e % m (HAC 14.85)
|
|
function bnModPow(e,m) {
|
|
var i = e.bitLength(), k, r = nbv(1), z;
|
|
if(i <= 0) return r;
|
|
else if(i < 18) k = 1;
|
|
else if(i < 48) k = 3;
|
|
else if(i < 144) k = 4;
|
|
else if(i < 768) k = 5;
|
|
else k = 6;
|
|
if(i < 8)
|
|
z = new Classic(m);
|
|
else if(m.isEven())
|
|
z = new Barrett(m);
|
|
else
|
|
z = new Montgomery(m);
|
|
|
|
// precomputation
|
|
var g = [], n = 3, k1 = k-1, km = (1<<k)-1;
|
|
g[1] = z.convert(this);
|
|
if(k > 1) {
|
|
var g2 = nbi();
|
|
z.sqrTo(g[1],g2);
|
|
while(n <= km) {
|
|
g[n] = nbi();
|
|
z.mulTo(g2,g[n-2],g[n]);
|
|
n += 2;
|
|
}
|
|
}
|
|
|
|
var j = e.t-1, w, is1 = true, r2 = nbi(), t;
|
|
i = nbits(e[j])-1;
|
|
while(j >= 0) {
|
|
if(i >= k1) w = (e[j]>>(i-k1))&km;
|
|
else {
|
|
w = (e[j]&((1<<(i+1))-1))<<(k1-i);
|
|
if(j > 0) w |= e[j-1]>>(this.DB+i-k1);
|
|
}
|
|
|
|
n = k;
|
|
while((w&1) == 0) { w >>= 1; --n; }
|
|
if((i -= n) < 0) { i += this.DB; --j; }
|
|
if(is1) { // ret == 1, don't bother squaring or multiplying it
|
|
g[w].copyTo(r);
|
|
is1 = false;
|
|
}
|
|
else {
|
|
while(n > 1) { z.sqrTo(r,r2); z.sqrTo(r2,r); n -= 2; }
|
|
if(n > 0) z.sqrTo(r,r2); else { t = r; r = r2; r2 = t; }
|
|
z.mulTo(r2,g[w],r);
|
|
}
|
|
|
|
while(j >= 0 && (e[j]&(1<<i)) == 0) {
|
|
z.sqrTo(r,r2); t = r; r = r2; r2 = t;
|
|
if(--i < 0) { i = this.DB-1; --j; }
|
|
}
|
|
}
|
|
return z.revert(r);
|
|
}
|
|
|
|
// (public) gcd(this,a) (HAC 14.54)
|
|
function bnGCD(a) {
|
|
var x = (this.s<0)?this.negate():this.clone();
|
|
var y = (a.s<0)?a.negate():a.clone();
|
|
if(x.compareTo(y) < 0) { var t = x; x = y; y = t; }
|
|
var i = x.getLowestSetBit(), g = y.getLowestSetBit();
|
|
if(g < 0) return x;
|
|
if(i < g) g = i;
|
|
if(g > 0) {
|
|
x.rShiftTo(g,x);
|
|
y.rShiftTo(g,y);
|
|
}
|
|
while(x.signum() > 0) {
|
|
if((i = x.getLowestSetBit()) > 0) x.rShiftTo(i,x);
|
|
if((i = y.getLowestSetBit()) > 0) y.rShiftTo(i,y);
|
|
if(x.compareTo(y) >= 0) {
|
|
x.subTo(y,x);
|
|
x.rShiftTo(1,x);
|
|
}
|
|
else {
|
|
y.subTo(x,y);
|
|
y.rShiftTo(1,y);
|
|
}
|
|
}
|
|
if(g > 0) y.lShiftTo(g,y);
|
|
return y;
|
|
}
|
|
|
|
// (protected) this % n, n < 2^26
|
|
function bnpModInt(n) {
|
|
if(n <= 0) return 0;
|
|
var d = this.DV%n, r = (this.s<0)?n-1:0;
|
|
if(this.t > 0)
|
|
if(d == 0) r = this[0]%n;
|
|
else for(var i = this.t-1; i >= 0; --i) r = (d*r+this[i])%n;
|
|
return r;
|
|
}
|
|
|
|
// (public) 1/this % m (HAC 14.61)
|
|
function bnModInverse(m) {
|
|
var ac = m.isEven();
|
|
if((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO;
|
|
var u = m.clone(), v = this.clone();
|
|
var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1);
|
|
while(u.signum() != 0) {
|
|
while(u.isEven()) {
|
|
u.rShiftTo(1,u);
|
|
if(ac) {
|
|
if(!a.isEven() || !b.isEven()) { a.addTo(this,a); b.subTo(m,b); }
|
|
a.rShiftTo(1,a);
|
|
}
|
|
else if(!b.isEven()) b.subTo(m,b);
|
|
b.rShiftTo(1,b);
|
|
}
|
|
while(v.isEven()) {
|
|
v.rShiftTo(1,v);
|
|
if(ac) {
|
|
if(!c.isEven() || !d.isEven()) { c.addTo(this,c); d.subTo(m,d); }
|
|
c.rShiftTo(1,c);
|
|
}
|
|
else if(!d.isEven()) d.subTo(m,d);
|
|
d.rShiftTo(1,d);
|
|
}
|
|
if(u.compareTo(v) >= 0) {
|
|
u.subTo(v,u);
|
|
if(ac) a.subTo(c,a);
|
|
b.subTo(d,b);
|
|
}
|
|
else {
|
|
v.subTo(u,v);
|
|
if(ac) c.subTo(a,c);
|
|
d.subTo(b,d);
|
|
}
|
|
}
|
|
if(v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO;
|
|
if(d.compareTo(m) >= 0) return d.subtract(m);
|
|
if(d.signum() < 0) d.addTo(m,d); else return d;
|
|
if(d.signum() < 0) return d.add(m); else return d;
|
|
}
|
|
|
|
var lowprimes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509];
|
|
var lplim = (1<<26)/lowprimes[lowprimes.length-1];
|
|
|
|
// (public) test primality with certainty >= 1-.5^t
|
|
function bnIsProbablePrime(t) {
|
|
var i, x = this.abs();
|
|
if(x.t == 1 && x[0] <= lowprimes[lowprimes.length-1]) {
|
|
for(i = 0; i < lowprimes.length; ++i)
|
|
if(x[0] == lowprimes[i]) return true;
|
|
return false;
|
|
}
|
|
if(x.isEven()) return false;
|
|
i = 1;
|
|
while(i < lowprimes.length) {
|
|
var m = lowprimes[i], j = i+1;
|
|
while(j < lowprimes.length && m < lplim) m *= lowprimes[j++];
|
|
m = x.modInt(m);
|
|
while(i < j) if(m%lowprimes[i++] == 0) return false;
|
|
}
|
|
return x.millerRabin(t);
|
|
}
|
|
|
|
// (protected) true if probably prime (HAC 4.24, Miller-Rabin)
|
|
function bnpMillerRabin(t) {
|
|
var n1 = this.subtract(BigInteger.ONE);
|
|
var k = n1.getLowestSetBit();
|
|
if(k <= 0) return false;
|
|
var r = n1.shiftRight(k);
|
|
t = (t+1)>>1;
|
|
if(t > lowprimes.length) t = lowprimes.length;
|
|
var a = nbi();
|
|
for(var i = 0; i < t; ++i) {
|
|
a.fromInt(lowprimes[i]);
|
|
var y = a.modPow(r,this);
|
|
if(y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {
|
|
var j = 1;
|
|
while(j++ < k && y.compareTo(n1) != 0) {
|
|
y = y.modPowInt(2,this);
|
|
if(y.compareTo(BigInteger.ONE) == 0) return false;
|
|
}
|
|
if(y.compareTo(n1) != 0) return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
// protected
|
|
BigInteger.prototype.chunkSize = bnpChunkSize;
|
|
BigInteger.prototype.toRadix = bnpToRadix;
|
|
BigInteger.prototype.fromRadix = bnpFromRadix;
|
|
BigInteger.prototype.fromNumber = bnpFromNumber;
|
|
BigInteger.prototype.bitwiseTo = bnpBitwiseTo;
|
|
BigInteger.prototype.changeBit = bnpChangeBit;
|
|
BigInteger.prototype.addTo = bnpAddTo;
|
|
BigInteger.prototype.dMultiply = bnpDMultiply;
|
|
BigInteger.prototype.dAddOffset = bnpDAddOffset;
|
|
BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;
|
|
BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;
|
|
BigInteger.prototype.modInt = bnpModInt;
|
|
BigInteger.prototype.millerRabin = bnpMillerRabin;
|
|
|
|
// public
|
|
BigInteger.prototype.clone = bnClone;
|
|
BigInteger.prototype.intValue = bnIntValue;
|
|
BigInteger.prototype.byteValue = bnByteValue;
|
|
BigInteger.prototype.shortValue = bnShortValue;
|
|
BigInteger.prototype.signum = bnSigNum;
|
|
BigInteger.prototype.toByteArray = bnToByteArray;
|
|
BigInteger.prototype.equals = bnEquals;
|
|
BigInteger.prototype.min = bnMin;
|
|
BigInteger.prototype.max = bnMax;
|
|
BigInteger.prototype.and = bnAnd;
|
|
BigInteger.prototype.or = bnOr;
|
|
BigInteger.prototype.xor = bnXor;
|
|
BigInteger.prototype.andNot = bnAndNot;
|
|
BigInteger.prototype.not = bnNot;
|
|
BigInteger.prototype.shiftLeft = bnShiftLeft;
|
|
BigInteger.prototype.shiftRight = bnShiftRight;
|
|
BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;
|
|
BigInteger.prototype.bitCount = bnBitCount;
|
|
BigInteger.prototype.testBit = bnTestBit;
|
|
BigInteger.prototype.setBit = bnSetBit;
|
|
BigInteger.prototype.clearBit = bnClearBit;
|
|
BigInteger.prototype.flipBit = bnFlipBit;
|
|
BigInteger.prototype.add = bnAdd;
|
|
BigInteger.prototype.subtract = bnSubtract;
|
|
BigInteger.prototype.multiply = bnMultiply;
|
|
BigInteger.prototype.divide = bnDivide;
|
|
BigInteger.prototype.remainder = bnRemainder;
|
|
BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;
|
|
BigInteger.prototype.modPow = bnModPow;
|
|
BigInteger.prototype.modInverse = bnModInverse;
|
|
BigInteger.prototype.pow = bnPow;
|
|
BigInteger.prototype.gcd = bnGCD;
|
|
BigInteger.prototype.isProbablePrime = bnIsProbablePrime;
|
|
|
|
// BigInteger interfaces not implemented in jsbn:
|
|
|
|
// BigInteger(int signum, byte[] magnitude)
|
|
// double doubleValue()
|
|
// float floatValue()
|
|
// int hashCode()
|
|
// long longValue()
|
|
// static BigInteger valueOf(long val)
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
// END OF copy-and-paste of jsbn.
|
|
|
|
|
|
|
|
BigInteger.NEGATIVE_ONE = BigInteger.ONE.negate();
|
|
|
|
|
|
// Other methods we need to add for compatibilty with js-numbers numeric tower.
|
|
|
|
// add is implemented above.
|
|
// subtract is implemented above.
|
|
// multiply is implemented above.
|
|
// equals is implemented above.
|
|
// abs is implemented above.
|
|
// negate is defined above.
|
|
|
|
// makeBignum: string -> BigInteger
|
|
var makeBignum = function(s) {
|
|
if (typeof(s) === 'number') { s = s + ''; }
|
|
s = expandExponent(s);
|
|
return new BigInteger(s, 10);
|
|
};
|
|
|
|
var zerostring = function(n) {
|
|
var buf = [];
|
|
for (var i = 0; i < n; i++) {
|
|
buf.push('0');
|
|
}
|
|
return buf.join('');
|
|
};
|
|
|
|
|
|
BigInteger.prototype.level = 0;
|
|
BigInteger.prototype.liftTo = function(target) {
|
|
if (target.level === 1) {
|
|
return new Rational(this, 1);
|
|
}
|
|
if (target.level === 2) {
|
|
var fixrep = this.toFixnum();
|
|
if (fixrep === Number.POSITIVE_INFINITY)
|
|
return TOO_POSITIVE_TO_REPRESENT;
|
|
if (fixrep === Number.NEGATIVE_INFINITY)
|
|
return TOO_NEGATIVE_TO_REPRESENT;
|
|
return new FloatPoint(fixrep);
|
|
}
|
|
if (target.level === 3) {
|
|
return new Complex(this, 0);
|
|
}
|
|
return throwRuntimeError("invalid level for BigInteger lift", this, target);
|
|
};
|
|
|
|
BigInteger.prototype.isFinite = function() {
|
|
return true;
|
|
};
|
|
|
|
BigInteger.prototype.isInteger = function() {
|
|
return true;
|
|
};
|
|
|
|
BigInteger.prototype.isRational = function() {
|
|
return true;
|
|
};
|
|
|
|
BigInteger.prototype.isReal = function() {
|
|
return true;
|
|
};
|
|
|
|
BigInteger.prototype.isExact = function() {
|
|
return true;
|
|
};
|
|
|
|
BigInteger.prototype.isInexact = function() {
|
|
return false;
|
|
};
|
|
|
|
BigInteger.prototype.toExact = function() {
|
|
return this;
|
|
};
|
|
|
|
BigInteger.prototype.toInexact = function() {
|
|
return FloatPoint.makeInstance(this.toFixnum());
|
|
};
|
|
|
|
BigInteger.prototype.toFixnum = function() {
|
|
var result = 0, str = this.toString(), i;
|
|
if (str[0] === '-') {
|
|
for (i=1; i < str.length; i++) {
|
|
result = result * 10 + Number(str[i]);
|
|
}
|
|
return -result;
|
|
} else {
|
|
for (i=0; i < str.length; i++) {
|
|
result = result * 10 + Number(str[i]);
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
|
|
|
|
BigInteger.prototype.greaterThan = function(other) {
|
|
return this.compareTo(other) > 0;
|
|
};
|
|
|
|
BigInteger.prototype.greaterThanOrEqual = function(other) {
|
|
return this.compareTo(other) >= 0;
|
|
};
|
|
|
|
BigInteger.prototype.lessThan = function(other) {
|
|
return this.compareTo(other) < 0;
|
|
};
|
|
|
|
BigInteger.prototype.lessThanOrEqual = function(other) {
|
|
return this.compareTo(other) <= 0;
|
|
};
|
|
|
|
// divide: scheme-number -> scheme-number
|
|
// WARNING NOTE: we override the old version of divide.
|
|
BigInteger.prototype.divide = function(other) {
|
|
var quotientAndRemainder = bnDivideAndRemainder.call(this, other);
|
|
if (quotientAndRemainder[1].compareTo(BigInteger.ZERO) === 0) {
|
|
return quotientAndRemainder[0];
|
|
} else {
|
|
var result = add(quotientAndRemainder[0],
|
|
Rational.makeInstance(quotientAndRemainder[1], other));
|
|
return result;
|
|
}
|
|
};
|
|
|
|
BigInteger.prototype.numerator = function() {
|
|
return this;
|
|
};
|
|
|
|
BigInteger.prototype.denominator = function() {
|
|
return 1;
|
|
};
|
|
|
|
|
|
(function() {
|
|
// Classic implementation of Newton-Ralphson square-root search,
|
|
// adapted for integer-sqrt.
|
|
// http://en.wikipedia.org/wiki/Newton's_method#Square_root_of_a_number
|
|
var searchIter = function(n, guess) {
|
|
while(!(lessThanOrEqual(sqr(guess),n) &&
|
|
lessThan(n,sqr(add(guess, 1))))) {
|
|
guess = floor(divide(add(guess,
|
|
floor(divide(n, guess))),
|
|
2));
|
|
}
|
|
return guess;
|
|
};
|
|
|
|
// integerSqrt: -> scheme-number
|
|
BigInteger.prototype.integerSqrt = function() {
|
|
var n;
|
|
if(sign(this) >= 0) {
|
|
return searchIter(this, this);
|
|
} else {
|
|
n = this.negate();
|
|
return Complex.makeInstance(0, searchIter(n, n));
|
|
}
|
|
};
|
|
})();
|
|
|
|
|
|
(function() {
|
|
// Get an approximation using integerSqrt, and then start another
|
|
// Newton-Ralphson search if necessary.
|
|
BigInteger.prototype.sqrt = function() {
|
|
var approx = this.integerSqrt(), fix;
|
|
if (eqv(sqr(approx), this)) {
|
|
return approx;
|
|
}
|
|
fix = toFixnum(this);
|
|
if (isFinite(fix)) {
|
|
if (fix >= 0) {
|
|
return FloatPoint.makeInstance(Math.sqrt(fix));
|
|
} else {
|
|
return Complex.makeInstance(
|
|
0,
|
|
FloatPoint.makeInstance(Math.sqrt(-fix)));
|
|
}
|
|
} else {
|
|
return approx;
|
|
}
|
|
};
|
|
})();
|
|
|
|
|
|
|
|
|
|
|
|
// sqrt: -> scheme-number
|
|
// http://en.wikipedia.org/wiki/Newton's_method#Square_root_of_a_number
|
|
// Produce the square root.
|
|
|
|
// floor: -> scheme-number
|
|
// Produce the floor.
|
|
BigInteger.prototype.floor = function() {
|
|
return this;
|
|
}
|
|
|
|
// ceiling: -> scheme-number
|
|
// Produce the ceiling.
|
|
BigInteger.prototype.ceiling = function() {
|
|
return this;
|
|
}
|
|
|
|
// conjugate: -> scheme-number
|
|
// Produce the conjugate.
|
|
|
|
// magnitude: -> scheme-number
|
|
// Produce the magnitude.
|
|
|
|
// log: -> scheme-number
|
|
// Produce the log.
|
|
|
|
// angle: -> scheme-number
|
|
// Produce the angle.
|
|
|
|
// atan: -> scheme-number
|
|
// Produce the arc tangent.
|
|
|
|
// cos: -> scheme-number
|
|
// Produce the cosine.
|
|
|
|
// sin: -> scheme-number
|
|
// Produce the sine.
|
|
|
|
|
|
// expt: scheme-number -> scheme-number
|
|
// Produce the power to the input.
|
|
BigInteger.prototype.expt = function(n) {
|
|
return bnPow.call(this, n);
|
|
};
|
|
|
|
|
|
|
|
// exp: -> scheme-number
|
|
// Produce e raised to the given power.
|
|
|
|
// acos: -> scheme-number
|
|
// Produce the arc cosine.
|
|
|
|
// asin: -> scheme-number
|
|
// Produce the arc sine.
|
|
|
|
BigInteger.prototype.imaginaryPart = function() {
|
|
return 0;
|
|
}
|
|
BigInteger.prototype.realPart = function() {
|
|
return this;
|
|
}
|
|
|
|
// round: -> scheme-number
|
|
// Round to the nearest integer.
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// toRepeatingDecimal: jsnum jsnum {limit: number}? -> [string, string, string]
|
|
//
|
|
// Given the numerator and denominator parts of a rational,
|
|
// produces the repeating-decimal representation, where the first
|
|
// part are the digits before the decimal, the second are the
|
|
// non-repeating digits after the decimal, and the third are the
|
|
// remaining repeating decimals.
|
|
//
|
|
// An optional limit on the decimal expansion can be provided, in which
|
|
// case the search cuts off if we go past the limit.
|
|
// If this happens, the third argument returned becomes '...' to indicate
|
|
// that the search was prematurely cut off.
|
|
var toRepeatingDecimal = (function() {
|
|
var getResidue = function(r, d, limit) {
|
|
var digits = [];
|
|
var seenRemainders = {};
|
|
seenRemainders[r] = true;
|
|
while(true) {
|
|
if (limit-- <= 0) {
|
|
return [digits.join(''), '...']
|
|
}
|
|
|
|
var nextDigit = quotient(
|
|
multiply(r, 10), d);
|
|
var nextRemainder = remainder(
|
|
multiply(r, 10),
|
|
d);
|
|
digits.push(nextDigit.toString());
|
|
if (seenRemainders[nextRemainder]) {
|
|
r = nextRemainder;
|
|
break;
|
|
} else {
|
|
seenRemainders[nextRemainder] = true;
|
|
r = nextRemainder;
|
|
}
|
|
}
|
|
|
|
var firstRepeatingRemainder = r;
|
|
var repeatingDigits = [];
|
|
while (true) {
|
|
var nextDigit = quotient(multiply(r, 10), d);
|
|
var nextRemainder = remainder(
|
|
multiply(r, 10),
|
|
d);
|
|
repeatingDigits.push(nextDigit.toString());
|
|
if (equals(nextRemainder, firstRepeatingRemainder)) {
|
|
break;
|
|
} else {
|
|
r = nextRemainder;
|
|
}
|
|
};
|
|
|
|
var digitString = digits.join('');
|
|
var repeatingDigitString = repeatingDigits.join('');
|
|
|
|
while (digitString.length >= repeatingDigitString.length &&
|
|
(digitString.substring(
|
|
digitString.length - repeatingDigitString.length)
|
|
=== repeatingDigitString)) {
|
|
digitString = digitString.substring(
|
|
0, digitString.length - repeatingDigitString.length);
|
|
}
|
|
|
|
return [digitString, repeatingDigitString];
|
|
|
|
};
|
|
|
|
return function(n, d, options) {
|
|
// default limit on decimal expansion; can be overridden
|
|
var limit = 512;
|
|
if (options && typeof(options.limit) !== 'undefined') {
|
|
limit = options.limit;
|
|
}
|
|
if (! isInteger(n)) {
|
|
throwRuntimeError('toRepeatingDecimal: n ' + n.toString() +
|
|
" is not an integer.");
|
|
}
|
|
if (! isInteger(d)) {
|
|
throwRuntimeError('toRepeatingDecimal: d ' + d.toString() +
|
|
" is not an integer.");
|
|
}
|
|
if (equals(d, 0)) {
|
|
throwRuntimeError('toRepeatingDecimal: d equals 0');
|
|
}
|
|
if (lessThan(d, 0)) {
|
|
throwRuntimeError('toRepeatingDecimal: d < 0');
|
|
}
|
|
var sign = (lessThan(n, 0) ? "-" : "");
|
|
n = abs(n);
|
|
var beforeDecimalPoint = sign + quotient(n, d);
|
|
var afterDecimals = getResidue(remainder(n, d), d, limit);
|
|
return [beforeDecimalPoint].concat(afterDecimals);
|
|
};
|
|
})();
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
// External interface of js-numbers:
|
|
|
|
Numbers['fromFixnum'] = fromFixnum;
|
|
Numbers['fromString'] = fromString;
|
|
Numbers['makeBignum'] = makeBignum;
|
|
Numbers['makeRational'] = Rational.makeInstance;
|
|
Numbers['makeFloat'] = FloatPoint.makeInstance;
|
|
Numbers['makeComplex'] = Complex.makeInstance;
|
|
Numbers['makeComplexPolar'] = makeComplexPolar;
|
|
|
|
Numbers['pi'] = FloatPoint.pi;
|
|
Numbers['e'] = FloatPoint.e;
|
|
Numbers['nan'] = FloatPoint.nan;
|
|
Numbers['negative_inf'] = FloatPoint.neginf;
|
|
Numbers['inf'] = FloatPoint.inf;
|
|
Numbers['negative_one'] = -1; // Rational.NEGATIVE_ONE;
|
|
Numbers['zero'] = 0; // Rational.ZERO;
|
|
Numbers['one'] = 1; // Rational.ONE;
|
|
Numbers['i'] = plusI;
|
|
Numbers['negative_i'] = minusI;
|
|
Numbers['negative_zero'] = NEGATIVE_ZERO;
|
|
|
|
Numbers['onThrowRuntimeError'] = onThrowRuntimeError;
|
|
Numbers['isSchemeNumber'] = isSchemeNumber;
|
|
Numbers['isRational'] = isRational;
|
|
Numbers['isReal'] = isReal;
|
|
Numbers['isExact'] = isExact;
|
|
Numbers['isInexact'] = isInexact;
|
|
Numbers['isInteger'] = isInteger;
|
|
|
|
Numbers['toFixnum'] = toFixnum;
|
|
Numbers['toExact'] = toExact;
|
|
Numbers['toInexact'] = toInexact;
|
|
Numbers['add'] = add;
|
|
Numbers['subtract'] = subtract;
|
|
Numbers['multiply'] = multiply;
|
|
Numbers['divide'] = divide;
|
|
Numbers['equals'] = equals;
|
|
Numbers['eqv'] = eqv;
|
|
Numbers['approxEquals'] = approxEquals;
|
|
Numbers['greaterThanOrEqual'] = greaterThanOrEqual;
|
|
Numbers['lessThanOrEqual'] = lessThanOrEqual;
|
|
Numbers['greaterThan'] = greaterThan;
|
|
Numbers['lessThan'] = lessThan;
|
|
Numbers['expt'] = expt;
|
|
Numbers['exp'] = exp;
|
|
Numbers['modulo'] = modulo;
|
|
Numbers['numerator'] = numerator;
|
|
Numbers['denominator'] = denominator;
|
|
Numbers['integerSqrt'] = integerSqrt;
|
|
Numbers['sqrt'] = sqrt;
|
|
Numbers['abs'] = abs;
|
|
Numbers['quotient'] = quotient;
|
|
Numbers['remainder'] = remainder;
|
|
Numbers['floor'] = floor;
|
|
Numbers['ceiling'] = ceiling;
|
|
Numbers['conjugate'] = conjugate;
|
|
Numbers['magnitude'] = magnitude;
|
|
Numbers['log'] = log;
|
|
Numbers['angle'] = angle;
|
|
Numbers['tan'] = tan;
|
|
Numbers['atan'] = atan;
|
|
Numbers['cos'] = cos;
|
|
Numbers['sin'] = sin;
|
|
Numbers['tan'] = tan;
|
|
Numbers['acos'] = acos;
|
|
Numbers['asin'] = asin;
|
|
Numbers['cosh'] = cosh;
|
|
Numbers['sinh'] = sinh;
|
|
Numbers['imaginaryPart'] = imaginaryPart;
|
|
Numbers['realPart'] = realPart;
|
|
Numbers['round'] = round;
|
|
Numbers['sqr'] = sqr;
|
|
Numbers['gcd'] = gcd;
|
|
Numbers['lcm'] = lcm;
|
|
|
|
Numbers['toRepeatingDecimal'] = toRepeatingDecimal;
|
|
|
|
|
|
|
|
// The following exposes the class representations for easier
|
|
// integration with other projects.
|
|
Numbers['BigInteger'] = BigInteger;
|
|
Numbers['Rational'] = Rational;
|
|
Numbers['FloatPoint'] = FloatPoint;
|
|
Numbers['Complex'] = Complex;
|
|
|
|
Numbers['MIN_FIXNUM'] = MIN_FIXNUM;
|
|
Numbers['MAX_FIXNUM'] = MAX_FIXNUM;
|
|
|
|
})();
|
|
// Basic library functions. This will include a few simple functions,
|
|
// but be augmented with several namespaces for the other libraries in
|
|
// the base library.
|
|
if (! this['plt']) { this['plt'] = {}; }
|
|
(function (plt) {
|
|
var baselib = {};
|
|
plt['baselib'] = baselib;
|
|
|
|
|
|
|
|
// Simple object inheritance.
|
|
var heir = function(parentPrototype) {
|
|
var f = function() {}
|
|
f.prototype = parentPrototype;
|
|
return new f();
|
|
};
|
|
|
|
|
|
|
|
// clone: object -> object
|
|
// Copies an object. The new object should respond like the old
|
|
// object, including to things like instanceof.
|
|
var clone = function(obj) {
|
|
var C = function() {}
|
|
C.prototype = obj;
|
|
var c = new C();
|
|
for (property in obj) {
|
|
if (obj.hasOwnProperty(property)) {
|
|
c[property] = obj[property];
|
|
}
|
|
}
|
|
return c;
|
|
};
|
|
|
|
|
|
// Consumes a class and creates a predicate that recognizes subclasses.
|
|
var makeClassPredicate = function(aClass) {
|
|
return function(x) { return x instanceof aClass; };
|
|
};
|
|
|
|
|
|
|
|
// Helper to deal with the argument-passing of primitives. Call f
|
|
// with arguments bound from MACHINE.env, assuming
|
|
// MACHINE.argcount has been initialized with the number of
|
|
// arguments on the stack. vs provides optional values for the
|
|
// arguments that go beyond those of the mandatoryArgCount.
|
|
var withArguments = function(MACHINE,
|
|
mandatoryArgCount,
|
|
vs,
|
|
f) {
|
|
var args = [];
|
|
for (var i = 0; i < MACHINE.argcount; i++) {
|
|
if (i < mandatoryArgCount) {
|
|
args.push(MACHINE.env[MACHINE.env.length - 1 - i]);
|
|
} else {
|
|
if (i < MACHINE.argcount) {
|
|
args.push(MACHINE.env[MACHINE.env.length - 1 - i]);
|
|
} else {
|
|
args.push(vs[mandatoryArgCount - i]);
|
|
}
|
|
}
|
|
}
|
|
return f.apply(null, args);
|
|
};
|
|
|
|
|
|
|
|
baselib.heir = heir;
|
|
baselib.clone = clone;
|
|
baselib.makeClassPredicate = makeClassPredicate;
|
|
baselib.withArguments = withArguments;
|
|
|
|
|
|
})(this['plt']);
|
|
// Frame structures.
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.frames = exports;
|
|
|
|
|
|
|
|
// A generic frame just holds marks.
|
|
var Frame = function() {
|
|
// The set of continuation marks.
|
|
this.marks = [];
|
|
|
|
// When we're in the middle of computing with-cont-mark, we
|
|
// stash the key in here temporarily.
|
|
this.pendingContinuationMarkKey = undefined;
|
|
this.pendingApplyValuesProc = undefined;
|
|
this.pendingBegin0Count = undefined;
|
|
this.pendingBegin0Values = undefined;
|
|
};
|
|
|
|
|
|
// Frames must support marks and the temporary variables necessary to
|
|
// support with-continuation-mark and with-values.
|
|
|
|
// Specialized frames support more features:
|
|
|
|
// A CallFrame represents a call stack frame, and includes the return address
|
|
// as well as the function being called.
|
|
var CallFrame = function(label, proc) {
|
|
this.label = label;
|
|
this.proc = proc;
|
|
|
|
// The set of continuation marks.
|
|
this.marks = [];
|
|
|
|
// When we're in the middle of computing with-cont-mark, we
|
|
// stash the key in here temporarily.
|
|
this.pendingContinuationMarkKey = undefined;
|
|
};
|
|
CallFrame.prototype = baselib.heir(Frame.prototype);
|
|
|
|
|
|
|
|
// A prompt frame includes a return address, as well as a prompt tag
|
|
// for supporting delimited continuations.
|
|
var PromptFrame = function(label, tag) {
|
|
this.label = label;
|
|
this.tag = tag; // ContinuationPromptTag
|
|
|
|
// The set of continuation marks.
|
|
this.marks = [];
|
|
|
|
// When we're in the middle of computing with-cont-mark, we
|
|
// stash the key in here temporarily.
|
|
this.pendingContinuationMarkKey = undefined;
|
|
};
|
|
PromptFrame.prototype = baselib.heir(Frame.prototype);
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
exports.Frame = Frame;
|
|
exports.CallFrame = CallFrame;
|
|
exports.PromptFrame = PromptFrame;
|
|
|
|
|
|
|
|
})(this['plt'].baselib);(function(baselib) {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Union/find for circular equality testing.
|
|
|
|
var UnionFind = function() {
|
|
// this.parenMap holds the arrows from an arbitrary pointer
|
|
// to its parent.
|
|
this.parentMap = baselib.hashes.makeLowLevelEqHash();
|
|
}
|
|
|
|
// find: ptr -> UnionFindNode
|
|
// Returns the representative for this ptr.
|
|
UnionFind.prototype.find = function(ptr) {
|
|
var parent = (this.parentMap.containsKey(ptr) ?
|
|
this.parentMap.get(ptr) : ptr);
|
|
if (parent === ptr) {
|
|
return parent;
|
|
} else {
|
|
var rep = this.find(parent);
|
|
// Path compression:
|
|
this.parentMap.put(ptr, rep);
|
|
return rep;
|
|
}
|
|
};
|
|
|
|
// merge: ptr ptr -> void
|
|
// Merge the representative nodes for ptr1 and ptr2.
|
|
UnionFind.prototype.merge = function(ptr1, ptr2) {
|
|
this.parentMap.put(this.find(ptr1), this.find(ptr2));
|
|
};
|
|
|
|
|
|
|
|
baselib.UnionFind = UnionFind;
|
|
|
|
})(this['plt'].baselib);// Equality function
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.equality = exports;
|
|
|
|
|
|
// equals: X Y -> boolean
|
|
// Returns true if the objects are equivalent; otherwise, returns false.
|
|
var equals = function(x, y, aUnionFind) {
|
|
if (x === y) { return true; }
|
|
|
|
if (plt.baselib.numbers.isNumber(x) && plt.baselib.numbers.isNumber(y)) {
|
|
return plt.baselib.numbers.eqv(x, y);
|
|
}
|
|
|
|
if (baselib.strings.isString(x) && baselib.strings.isString(y)) {
|
|
return x.toString() === y.toString();
|
|
}
|
|
|
|
if (x == undefined || x == null) {
|
|
return (y == undefined || y == null);
|
|
}
|
|
|
|
if ( typeof(x) == 'object' &&
|
|
typeof(y) == 'object' &&
|
|
x.equals &&
|
|
y.equals) {
|
|
|
|
if (typeof (aUnionFind) === 'undefined') {
|
|
aUnionFind = new plt.baselib.UnionFind();
|
|
}
|
|
|
|
if (aUnionFind.find(x) === aUnionFind.find(y)) {
|
|
return true;
|
|
}
|
|
else {
|
|
aUnionFind.merge(x, y);
|
|
return x.equals(y, aUnionFind);
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
|
|
exports.equals = equals;
|
|
|
|
})(this['plt'].baselib);// Formatting library.
|
|
// Produces string and DOM representations of values.
|
|
//
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.format = exports;
|
|
|
|
|
|
|
|
// format: string [X ...] string -> string
|
|
// String formatting. If an exception occurs, throws
|
|
// a plain Error whose message describes the formatting error.
|
|
var format = function(formatStr, args, functionName) {
|
|
var throwFormatError = function() {
|
|
functionName = functionName || 'format';
|
|
var matches = formatStr.match(new RegExp('~[sSaA]', 'g'));
|
|
var expectedNumberOfArgs = (matches === null ? 0 : matches.length);
|
|
var errorStrBuffer = [functionName + ': format string requires ' + expectedNumberOfArgs
|
|
+ ' arguments, given ' + args.length + '; arguments were:',
|
|
toWrittenString(formatStr)];
|
|
for (var i = 0; i < args.length; i++) {
|
|
errorStrBuffer.push( toWrittenString(args[i]) );
|
|
}
|
|
|
|
throw new Error(errorStrBuffer.join(' '));
|
|
}
|
|
|
|
var pattern = new RegExp("~[sSaAnevE%~]", "g");
|
|
var buffer = args.slice(0);
|
|
var onTemplate = function(s) {
|
|
if (s === "~~") {
|
|
return "~";
|
|
} else if (s === '~n' || s === '~%') {
|
|
return "\n";
|
|
} else if (s === '~s' || s === "~S") {
|
|
if (buffer.length === 0) {
|
|
throwFormatError();
|
|
}
|
|
return toWrittenString(buffer.shift());
|
|
} else if (s === '~e' || s === "~E") {
|
|
// FIXME: we don't yet have support for the error-print
|
|
// handler, and currently treat ~e just like ~s.
|
|
if (buffer.length === 0) {
|
|
throwFormatError();
|
|
}
|
|
return toWrittenString(buffer.shift());
|
|
}
|
|
else if (s === '~v') {
|
|
if (buffer.length === 0) {
|
|
throwFormatError();
|
|
}
|
|
// fprintf must do something more interesting here by
|
|
// printing the dom representation directly...
|
|
return toWrittenString(buffer.shift());
|
|
} else if (s === '~a' || s === "~A") {
|
|
if (buffer.length === 0) {
|
|
throwFormatError();
|
|
}
|
|
return toDisplayedString(buffer.shift());
|
|
} else {
|
|
throw new Error(functionName +
|
|
': string.replace matched invalid regexp');
|
|
}
|
|
}
|
|
var result = formatStr.replace(pattern, onTemplate);
|
|
if (buffer.length > 0) {
|
|
throwFormatError();
|
|
}
|
|
return result;
|
|
};
|
|
|
|
|
|
// toWrittenString: Any Hashtable -> String
|
|
var toWrittenString = function(x, cache) {
|
|
if (! cache) {
|
|
cache = plt.baselib.hashes.makeLowLevelEqHash();
|
|
}
|
|
if (x === null) {
|
|
return "null";
|
|
}
|
|
if (x === true) { return "true"; }
|
|
if (x === false) { return "false"; }
|
|
if (typeof(x) === 'object') {
|
|
if (cache.containsKey(x)) {
|
|
return "...";
|
|
}
|
|
}
|
|
if (x == undefined) {
|
|
return "#<undefined>";
|
|
}
|
|
if (typeof(x) == 'string') {
|
|
return escapeString(x.toString());
|
|
}
|
|
if (typeof(x) != 'object' && typeof(x) != 'function') {
|
|
return x.toString();
|
|
}
|
|
|
|
var returnVal;
|
|
if (typeof(x.toWrittenString) !== 'undefined') {
|
|
returnVal = x.toWrittenString(cache);
|
|
} else if (typeof(x.toDisplayedString) !== 'undefined') {
|
|
returnVal = x.toDisplayedString(cache);
|
|
} else {
|
|
returnVal = x.toString();
|
|
}
|
|
cache.remove(x);
|
|
return returnVal;
|
|
};
|
|
|
|
|
|
|
|
// toDisplayedString: Any Hashtable -> String
|
|
var toDisplayedString = function(x, cache) {
|
|
if (! cache) {
|
|
cache = plt.baselib.hashes.makeLowLevelEqHash();
|
|
}
|
|
if (x === null) {
|
|
return "null";
|
|
}
|
|
if (x === true) { return "true"; }
|
|
if (x === false) { return "false"; }
|
|
if (typeof(x) === 'object') {
|
|
if (cache.containsKey(x)) {
|
|
return "...";
|
|
}
|
|
}
|
|
if (x == undefined || x == null) {
|
|
return "#<undefined>";
|
|
}
|
|
if (typeof(x) == 'string') {
|
|
return x;
|
|
}
|
|
if (typeof(x) != 'object' && typeof(x) != 'function') {
|
|
return x.toString();
|
|
}
|
|
|
|
var returnVal;
|
|
if (typeof(x.toDisplayedString) !== 'undefined') {
|
|
returnVal = x.toDisplayedString(cache);
|
|
} else if (typeof(x.toWrittenString) !== 'undefined') {
|
|
returnVal = x.toWrittenString(cache);
|
|
} else {
|
|
returnVal = x.toString();
|
|
}
|
|
cache.remove(x);
|
|
return returnVal;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var ToDomNodeParameters = function(params) {
|
|
if (! params) { params = {}; }
|
|
this.cache = plt.baselib.hashes.makeLowLevelEqHash();
|
|
for (var k in params) {
|
|
if (params.hasOwnProperty(k)) {
|
|
this[k] = params[k];
|
|
}
|
|
}
|
|
this.objectCounter = 0;
|
|
};
|
|
|
|
// getMode: -> (U "print" "display" "write")
|
|
ToDomNodeParameters.prototype.getMode = function() {
|
|
if (this.mode) {
|
|
return this.mode;
|
|
}
|
|
return 'print';
|
|
};
|
|
|
|
ToDomNodeParameters.prototype.containsKey = function(x) {
|
|
return this.cache.containsKey(x);
|
|
};
|
|
|
|
ToDomNodeParameters.prototype.get = function(x) {
|
|
return this.cache.get(x);
|
|
};
|
|
|
|
ToDomNodeParameters.prototype.remove = function(x) {
|
|
return this.cache.remove(x);
|
|
};
|
|
|
|
ToDomNodeParameters.prototype.put = function(x) {
|
|
this.objectCounter++;
|
|
return this.cache.put(x, this.objectCounter);
|
|
};
|
|
|
|
|
|
// toDomNode: scheme-value -> dom-node
|
|
var toDomNode = function(x, params) {
|
|
if (params === 'write') {
|
|
params = new ToDomNodeParameters({'mode' : 'write'});
|
|
} else if (params === 'print') {
|
|
params = new ToDomNodeParameters({'mode' : 'print'});
|
|
} else if (params === 'display') {
|
|
params = new ToDomNodeParameters({'mode' : 'display'});
|
|
} else {
|
|
params = params || new ToDomNodeParameters({'mode' : 'display'});
|
|
}
|
|
|
|
if (plt.baselib.numbers.isSchemeNumber(x)) {
|
|
var node = numberToDomNode(x, params);
|
|
$(node).addClass("number");
|
|
return node;
|
|
}
|
|
|
|
if (x === null) {
|
|
var node = document.createElement("span");
|
|
node.appendChild(document.createTextNode("null"));
|
|
$(node).addClass("null");
|
|
return node;
|
|
}
|
|
|
|
if (x === true) {
|
|
var node = document.createElement("span");
|
|
node.appendChild(document.createTextNode("true"));
|
|
$(node).addClass("boolean");
|
|
return node;
|
|
}
|
|
|
|
if (x === false) {
|
|
var node = document.createElement("span");
|
|
node.appendChild(document.createTextNode("false"));
|
|
$(node).addClass("boolean");
|
|
return node;
|
|
}
|
|
|
|
if (typeof(x) == 'object') {
|
|
if (params.containsKey(x)) {
|
|
var node = document.createElement("span");
|
|
node.appendChild(document.createTextNode("#" + params.get(x)));
|
|
return node;
|
|
}
|
|
}
|
|
if (x === undefined || x == null) {
|
|
var node = document.createElement("span");
|
|
node.appendChild(document.createTextNode("#<undefined>"));
|
|
return node;
|
|
}
|
|
|
|
if (typeof(x) == 'string') {
|
|
var wrapper = document.createElement("span");
|
|
wrapper.style["white-space"] = "pre";
|
|
var node;
|
|
if (params.getMode() === 'write' || params.getMode() === 'print') {
|
|
node = document.createTextNode(toWrittenString(x));
|
|
} else {
|
|
node = document.createTextNode(toDisplayedString(x));
|
|
}
|
|
wrapper.appendChild(node);
|
|
$(wrapper).addClass("string");
|
|
return wrapper;
|
|
}
|
|
|
|
if (typeof(x) != 'object' && typeof(x) != 'function') {
|
|
var node = document.createElement("span");
|
|
node.appendChild(document.createTextNode(x.toString()));
|
|
$(node).addClass("procedure");
|
|
return node;
|
|
}
|
|
|
|
var returnVal;
|
|
if (x.nodeType) {
|
|
returnVal = x;
|
|
} else if (typeof(x.toDomNode) !== 'undefined') {
|
|
returnVal = x.toDomNode(params);
|
|
} else if (params.getMode() === 'write' &&
|
|
typeof(x.toWrittenString) !== 'undefined') {
|
|
var node = document.createElement("span");
|
|
node.appendChild(document.createTextNode(x.toWrittenString(params)));
|
|
returnVal = node;
|
|
} else if (params.getMode() === 'display' &&
|
|
typeof(x.toDisplayedString) !== 'undefined') {
|
|
var node = document.createElement("span");
|
|
node.appendChild(document.createTextNode(x.toDisplayedString(params)));
|
|
returnVal = node;
|
|
} else {
|
|
var node = document.createElement("span");
|
|
node.appendChild(document.createTextNode(x.toString()));
|
|
returnVal = node;
|
|
}
|
|
params.remove(x);
|
|
return returnVal;
|
|
};
|
|
|
|
|
|
|
|
// numberToDomNode: jsnum -> dom
|
|
// Given a jsnum, produces a dom-node representation.
|
|
var numberToDomNode = function(n, params) {
|
|
var node;
|
|
if (plt.baselib.numbers.isExact(n)) {
|
|
if (plt.baselib.numbers.isInteger(n)) {
|
|
node = document.createElement("span");
|
|
node.appendChild(document.createTextNode(n.toString()));
|
|
return node;
|
|
} else if (plt.baselib.numbers.isRational(n)) {
|
|
return rationalToDomNode(n);
|
|
} else if (plt.baselib.numbers.isComplex(n)) {
|
|
node = document.createElement("span");
|
|
node.appendChild(document.createTextNode(n.toString()));
|
|
return node;
|
|
} else {
|
|
node = document.createElement("span");
|
|
node.appendChild(document.createTextNode(n.toString()));
|
|
return node;
|
|
}
|
|
} else {
|
|
node = document.createElement("span");
|
|
node.appendChild(document.createTextNode(n.toString()));
|
|
return node;
|
|
}
|
|
};
|
|
|
|
// rationalToDomNode: rational -> dom-node
|
|
var rationalToDomNode = function(n) {
|
|
var repeatingDecimalNode = document.createElement("span");
|
|
var chunks = plt.baselib.numbers.toRepeatingDecimal(plt.baselib.numbers.numerator(n),
|
|
plt.baselib.numbers.denominator(n),
|
|
{limit: 25});
|
|
repeatingDecimalNode.appendChild(document.createTextNode(chunks[0] + '.'))
|
|
repeatingDecimalNode.appendChild(document.createTextNode(chunks[1]));
|
|
if (chunks[2] === '...') {
|
|
repeatingDecimalNode.appendChild(
|
|
document.createTextNode(chunks[2]));
|
|
} else if (chunks[2] !== '0') {
|
|
var overlineSpan = document.createElement("span");
|
|
overlineSpan.style.textDecoration = 'overline';
|
|
overlineSpan.appendChild(document.createTextNode(chunks[2]));
|
|
repeatingDecimalNode.appendChild(overlineSpan);
|
|
}
|
|
|
|
|
|
var fractionalNode = document.createElement("span");
|
|
var numeratorNode = document.createElement("sup");
|
|
numeratorNode.appendChild(document.createTextNode(String(plt.baselib.numbers.numerator(n))));
|
|
var denominatorNode = document.createElement("sub");
|
|
denominatorNode.appendChild(document.createTextNode(String(plt.baselib.numbers.denominator(n))));
|
|
fractionalNode.appendChild(numeratorNode);
|
|
fractionalNode.appendChild(document.createTextNode("/"));
|
|
fractionalNode.appendChild(denominatorNode);
|
|
|
|
|
|
var numberNode = document.createElement("span");
|
|
numberNode.appendChild(repeatingDecimalNode);
|
|
numberNode.appendChild(fractionalNode);
|
|
fractionalNode.style['display'] = 'none';
|
|
|
|
var showingRepeating = true;
|
|
|
|
numberNode.onclick = function(e) {
|
|
showingRepeating = !showingRepeating;
|
|
repeatingDecimalNode.style['display'] =
|
|
(showingRepeating ? 'inline' : 'none')
|
|
fractionalNode.style['display'] =
|
|
(!showingRepeating ? 'inline' : 'none')
|
|
};
|
|
numberNode.style['cursor'] = 'pointer';
|
|
return numberNode;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var escapeString = function(s) {
|
|
return '"' + replaceUnprintableStringChars(s) + '"';
|
|
};
|
|
|
|
var replaceUnprintableStringChars = function(s) {
|
|
var ret = [];
|
|
for (var i = 0; i < s.length; i++) {
|
|
var val = s.charCodeAt(i);
|
|
switch(val) {
|
|
case 7: ret.push('\\a'); break;
|
|
case 8: ret.push('\\b'); break;
|
|
case 9: ret.push('\\t'); break;
|
|
case 10: ret.push('\\n'); break;
|
|
case 11: ret.push('\\v'); break;
|
|
case 12: ret.push('\\f'); break;
|
|
case 13: ret.push('\\r'); break;
|
|
case 34: ret.push('\\"'); break;
|
|
case 92: ret.push('\\\\'); break;
|
|
default: if (val >= 32 && val <= 126) {
|
|
ret.push( s.charAt(i) );
|
|
}
|
|
else {
|
|
var numStr = val.toString(16).toUpperCase();
|
|
while (numStr.length < 4) {
|
|
numStr = '0' + numStr;
|
|
}
|
|
ret.push('\\u' + numStr);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return ret.join('');
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
exports.ToDomNodeParameters = ToDomNodeParameters;
|
|
|
|
exports.format = format;
|
|
exports.toWrittenString = toWrittenString;
|
|
exports.toDisplayedString = toDisplayedString;
|
|
exports.toDomNode = toDomNode;
|
|
|
|
exports.escapeString = escapeString;
|
|
})(this['plt'].baselib);// Other miscellaneous constants
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.constants = exports;
|
|
|
|
|
|
var VoidValue = function() {};
|
|
VoidValue.prototype.toString = function() {
|
|
return "#<void>";
|
|
};
|
|
|
|
var VOID_VALUE = new VoidValue();
|
|
|
|
|
|
var EofValue = function() {};
|
|
EofValue.prototype.toString = function() {
|
|
return "#<eof>";
|
|
}
|
|
|
|
var EOF_VALUE = new EofValue();
|
|
|
|
|
|
exports.VOID_VALUE = VOID_VALUE;
|
|
exports.EOF_VALUE = EOF_VALUE;
|
|
})(this['plt'].baselib);// Numbers.
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.numbers = exports;
|
|
|
|
|
|
|
|
var isNumber = jsnums.isSchemeNumber;
|
|
var isReal = jsnums.isReal;
|
|
var isRational = jsnums.isRational;
|
|
var isComplex = isNumber;
|
|
var isInteger = jsnums.isInteger;
|
|
|
|
|
|
var isNatural = function(x) {
|
|
return (jsnums.isExact(x) && isInteger(x)
|
|
&& jsnums.greaterThanOrEqual(x, 0));
|
|
};
|
|
|
|
var isNonNegativeReal = function(x) {
|
|
return isReal(x) && jsnums.greaterThanOrEqual(x, 0);
|
|
};
|
|
|
|
var isByte = function(x) {
|
|
return (isNatural(x) &&
|
|
jsnums.lessThan(x, 256));
|
|
};
|
|
|
|
|
|
// sign: number -> number
|
|
var sign = function(x) {
|
|
if (jsnums.isInexact(x)) {
|
|
if (jsnums.greaterThan(x, 0) ) {
|
|
return jsnums.makeFloat(1);
|
|
} else if (jsnums.lessThan(x, 0) ) {
|
|
return jsnums.makeFloat(-1);
|
|
} else {
|
|
return jsnums.makeFloat(0);
|
|
}
|
|
} else {
|
|
if (jsnums.greaterThan(x, 0)) {
|
|
return 1;
|
|
} else if (jsnums.lessThan(x, 0)) {
|
|
return -1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Exports
|
|
|
|
|
|
// We first re-export everything in jsnums.
|
|
for (var prop in jsnums) {
|
|
if (jsnums.hasOwnProperty(prop)) {
|
|
exports[prop] = jsnums[prop];
|
|
}
|
|
}
|
|
|
|
exports.isNumber = jsnums.isSchemeNumber;
|
|
exports.isReal = isReal;
|
|
exports.isRational = isRational;
|
|
exports.isComplex = isComplex;
|
|
exports.isInteger = isInteger;
|
|
exports.isNatural = isNatural;
|
|
exports.isByte = isByte;
|
|
exports.isNonNegativeReal = isNonNegativeReal;
|
|
|
|
exports.sign = sign;
|
|
|
|
|
|
})(this['plt'].baselib);// list structures (pairs, empty)
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.lists = exports;
|
|
|
|
|
|
|
|
|
|
|
|
Empty = function() {
|
|
};
|
|
Empty.EMPTY = new Empty();
|
|
var EMPTY = Empty.EMPTY;
|
|
|
|
|
|
|
|
Empty.prototype.equals = function(other, aUnionFind) {
|
|
return other instanceof Empty;
|
|
};
|
|
|
|
Empty.prototype.reverse = function() {
|
|
return this;
|
|
};
|
|
|
|
Empty.prototype.toWrittenString = function(cache) { return "empty"; };
|
|
Empty.prototype.toDisplayedString = function(cache) { return "empty"; };
|
|
Empty.prototype.toString = function(cache) { return "()"; };
|
|
|
|
|
|
// Empty.append: (listof X) -> (listof X)
|
|
Empty.prototype.append = function(b){
|
|
return b;
|
|
};
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// Cons Pairs
|
|
|
|
var Cons = function(first, rest) {
|
|
this.first = first;
|
|
this.rest = rest;
|
|
};
|
|
|
|
Cons.prototype.reverse = function() {
|
|
var lst = this;
|
|
var ret = EMPTY;
|
|
while (lst !== EMPTY) {
|
|
ret = Cons.makeInstance(lst.first, ret);
|
|
lst = lst.rest;
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
Cons.makeInstance = function(first, rest) {
|
|
return new Cons(first, rest);
|
|
};
|
|
|
|
// FIXME: can we reduce the recursion on this?
|
|
Cons.prototype.equals = function(other, aUnionFind) {
|
|
if (! (other instanceof Cons)) {
|
|
return false;
|
|
}
|
|
return (plt.baselib.equality.equals(this.first, other.first, aUnionFind) &&
|
|
plt.baselib.equality.equals(this.rest, other.rest, aUnionFind));
|
|
};
|
|
|
|
|
|
|
|
|
|
// Cons.append: (listof X) -> (listof X)
|
|
Cons.prototype.append = function(b){
|
|
if (b === EMPTY)
|
|
return this;
|
|
var ret = b;
|
|
var lst = this.reverse();
|
|
while (lst !== EMPTY) {
|
|
ret = Cons.makeInstance(lst.first, ret);
|
|
lst = lst.rest;
|
|
}
|
|
|
|
return ret;
|
|
};
|
|
|
|
|
|
Cons.prototype.toWrittenString = function(cache) {
|
|
cache.put(this, true);
|
|
var texts = [];
|
|
var p = this;
|
|
while ( p instanceof Cons ) {
|
|
texts.push(plt.baselib.format.toWrittenString(p.first, cache));
|
|
p = p.rest;
|
|
if (typeof(p) === 'object' && cache.containsKey(p)) {
|
|
break;
|
|
}
|
|
}
|
|
if ( p !== EMPTY ) {
|
|
texts.push('.');
|
|
texts.push(plt.baselib.format.toWrittenString(p, cache));
|
|
}
|
|
return "(" + texts.join(" ") + ")";
|
|
};
|
|
|
|
Cons.prototype.toString = Cons.prototype.toWrittenString;
|
|
|
|
Cons.prototype.toDisplayedString = function(cache) {
|
|
cache.put(this, true);
|
|
var texts = [];
|
|
var p = this;
|
|
while ( p instanceof Cons ) {
|
|
texts.push(plt.baselib.format.toDisplayedString(p.first, cache));
|
|
p = p.rest;
|
|
if (typeof(p) === 'object' && cache.containsKey(p)) {
|
|
break;
|
|
}
|
|
}
|
|
if ( p !== Empty.EMPTY ) {
|
|
texts.push('.');
|
|
texts.push(plt.baselib.format.toDisplayedString(p, cache));
|
|
}
|
|
return "(" + texts.join(" ") + ")";
|
|
};
|
|
|
|
|
|
|
|
Cons.prototype.toDomNode = function(cache) {
|
|
cache.put(this, true);
|
|
var node = document.createElement("span");
|
|
node.appendChild(document.createTextNode("("));
|
|
var p = this;
|
|
while ( p instanceof Cons ) {
|
|
node.appendChild(plt.baselib.format.toDomNode(p.first, cache));
|
|
p = p.rest;
|
|
if ( p !== Empty.EMPTY ) {
|
|
node.appendChild(document.createTextNode(" "));
|
|
}
|
|
if (typeof(p) === 'object' && cache.containsKey(p)) {
|
|
break;
|
|
}
|
|
}
|
|
if ( p !== Empty.EMPTY ) {
|
|
node.appendChild(document.createTextNode("."));
|
|
node.appendChild(document.createTextNode(" "));
|
|
node.appendChild(plt.baselib.format.toDomNode(p, cache));
|
|
}
|
|
|
|
node.appendChild(document.createTextNode(")"));
|
|
return node;
|
|
};
|
|
|
|
|
|
var isPair = function(x) { return x instanceof Cons; };
|
|
var isEmpty = function(x) { return x === Empty.EMPTY; };
|
|
|
|
|
|
var makePair = Cons.makeInstance;
|
|
|
|
var makeList = function() {
|
|
var result = Empty.EMPTY;
|
|
for(var i = arguments.length-1; i >= 0; i--) {
|
|
result = Cons.makeInstance(arguments[i], result);
|
|
}
|
|
return result;
|
|
};
|
|
|
|
|
|
// isList: Any -> Boolean
|
|
// Returns true if x is a list (a chain of pairs terminated by EMPTY).
|
|
var isList = function(x) {
|
|
while (x !== Empty.EMPTY) {
|
|
if (x instanceof Cons) {
|
|
x = x.rest;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
|
|
|
|
|
|
var reverse = function(lst) {
|
|
var rev = EMPTY;
|
|
while(lst !== EMPTY) {
|
|
rev = makePair(lst.first, rev);
|
|
lst = lst.rest;
|
|
}
|
|
return rev;
|
|
};
|
|
|
|
|
|
var length = function(lst) {
|
|
var len = 0;
|
|
while (lst !== EMPTY) {
|
|
len++;
|
|
lst = lst.rest;
|
|
}
|
|
return len;
|
|
};
|
|
|
|
|
|
var listRef = function(lst, n) {
|
|
for (var i = 0; i < n; i++) {
|
|
lst = lst.rest;
|
|
}
|
|
return lst.first;
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
exports.EMPTY = EMPTY;
|
|
exports.Empty = Empty;
|
|
exports.Cons = Cons;
|
|
exports.isPair = isPair;
|
|
exports.isList = isList;
|
|
exports.isEmpty = isEmpty;
|
|
exports.makePair = makePair;
|
|
exports.makeList = makeList;
|
|
exports.reverse = reverse;
|
|
exports.length = length;
|
|
exports.listRef = listRef;
|
|
|
|
|
|
})(this['plt'].baselib);// vectors
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.vectors = exports;
|
|
|
|
|
|
|
|
Vector = function(n, initialElements) {
|
|
this.elts = new Array(n);
|
|
if (initialElements) {
|
|
for (var i = 0; i < n; i++) {
|
|
this.elts[i] = initialElements[i];
|
|
}
|
|
} else {
|
|
for (var i = 0; i < n; i++) {
|
|
this.elts[i] = undefined;
|
|
}
|
|
}
|
|
this.mutable = true;
|
|
};
|
|
|
|
Vector.makeInstance = function(n, elts) {
|
|
return new Vector(n, elts);
|
|
}
|
|
|
|
Vector.prototype.length = function() {
|
|
return this.elts.length;
|
|
};
|
|
|
|
Vector.prototype.ref = function(k) {
|
|
return this.elts[k];
|
|
};
|
|
|
|
Vector.prototype.set = function(k, v) {
|
|
this.elts[k] = v;
|
|
};
|
|
|
|
Vector.prototype.equals = function(other, aUnionFind) {
|
|
if (other != null && other != undefined && other instanceof Vector) {
|
|
if (other.length() != this.length()) {
|
|
return false
|
|
}
|
|
for (var i = 0; i < this.length(); i++) {
|
|
if (! plt.baselib.equality.equals(this.elts[i], other.elts[i], aUnionFind)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
Vector.prototype.toList = function() {
|
|
var ret = plt.baselib.lists.EMPTY;
|
|
for (var i = this.length() - 1; i >= 0; i--) {
|
|
ret = plt.baselib.lists.Cons.makeInstance(this.elts[i], ret);
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
Vector.prototype.toWrittenString = function(cache) {
|
|
cache.put(this, true);
|
|
var texts = [];
|
|
for (var i = 0; i < this.length(); i++) {
|
|
texts.push(plt.baselib.format.toWrittenString(this.ref(i), cache));
|
|
}
|
|
return "#(" + texts.join(" ") + ")";
|
|
};
|
|
|
|
Vector.prototype.toDisplayedString = function(cache) {
|
|
cache.put(this, true);
|
|
var texts = [];
|
|
for (var i = 0; i < this.length(); i++) {
|
|
texts.push(plt.baselib.format.toDisplayedString(this.ref(i), cache));
|
|
}
|
|
return "#(" + texts.join(" ") + ")";
|
|
};
|
|
|
|
Vector.prototype.toDomNode = function(cache) {
|
|
cache.put(this, true);
|
|
var node = document.createElement("span");
|
|
node.appendChild(document.createTextNode("#("));
|
|
for (var i = 0; i < this.length(); i++) {
|
|
node.appendChild(plt.baselib.format.toDomNode(this.ref(i), cache));
|
|
if (i !== this.length()-1) {
|
|
node.appendChild(document.createTextNode(" "));
|
|
}
|
|
}
|
|
node.appendChild(document.createTextNode(")"));
|
|
return node;
|
|
};
|
|
|
|
|
|
var isVector = function(x) { return x instanceof Vector; };
|
|
|
|
var makeVector = function() {
|
|
return Vector.makeInstance(arguments.length, arguments);
|
|
};
|
|
|
|
var makeVectorImmutable = function() {
|
|
var v = Vector.makeInstance(arguments.length, arguments);
|
|
v.mutable = false;
|
|
return v;
|
|
};
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
exports.Vector = Vector;
|
|
exports.isVector = isVector;
|
|
exports.makeVector = makeVector;
|
|
exports.makeVectorImmutable = makeVectorImmutable;
|
|
|
|
|
|
})(this['plt'].baselib);// Single characters
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.chars = exports;
|
|
|
|
|
|
// Chars
|
|
// Char: string -> Char
|
|
Char = function(val){
|
|
this.val = val;
|
|
};
|
|
// The characters less than 256 must be eq?, according to the
|
|
// documentation:
|
|
// http://docs.racket-lang.org/reference/characters.html
|
|
var _CharCache = {};
|
|
for (var i = 0; i < 256; i++) {
|
|
_CharCache[String.fromCharCode(i)] = new Char(String.fromCharCode(i));
|
|
}
|
|
|
|
// makeInstance: 1-character string -> Char
|
|
Char.makeInstance = function(val){
|
|
if (_CharCache[val]) {
|
|
return _CharCache[val];
|
|
}
|
|
return new Char(val);
|
|
};
|
|
|
|
Char.prototype.toString = function(cache) {
|
|
var code = this.val.charCodeAt(0);
|
|
var returnVal;
|
|
switch (code) {
|
|
case 0: returnVal = '#\\nul'; break;
|
|
case 8: returnVal = '#\\backspace'; break;
|
|
case 9: returnVal = '#\\tab'; break;
|
|
case 10: returnVal = '#\\newline'; break;
|
|
case 11: returnVal = '#\\vtab'; break;
|
|
case 12: returnVal = '#\\page'; break;
|
|
case 13: returnVal = '#\\return'; break;
|
|
case 20: returnVal = '#\\space'; break;
|
|
case 127: returnVal = '#\\rubout'; break;
|
|
default: if (code >= 32 && code <= 126) {
|
|
returnVal = ("#\\" + this.val);
|
|
}
|
|
else {
|
|
var numStr = code.toString(16).toUpperCase();
|
|
while (numStr.length < 4) {
|
|
numStr = '0' + numStr;
|
|
}
|
|
returnVal = ('#\\u' + numStr);
|
|
}
|
|
break;
|
|
}
|
|
return returnVal;
|
|
};
|
|
|
|
Char.prototype.toWrittenString = Char.prototype.toString;
|
|
|
|
Char.prototype.toDisplayedString = function (cache) {
|
|
return this.val;
|
|
};
|
|
|
|
Char.prototype.getValue = function() {
|
|
return this.val;
|
|
};
|
|
|
|
Char.prototype.equals = function(other, aUnionFind){
|
|
return other instanceof Char && this.val == other.val;
|
|
};
|
|
|
|
|
|
|
|
|
|
exports.Char = Char;
|
|
|
|
})(this['plt'].baselib);// Structure types
|
|
|
|
(function(baselib) {
|
|
|
|
var exports = {};
|
|
baselib.symbols = exports;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// Symbols
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
var Symbol = function(val) {
|
|
this.val = val;
|
|
};
|
|
|
|
var symbolCache = {};
|
|
|
|
// makeInstance: string -> Symbol.
|
|
Symbol.makeInstance = function(val) {
|
|
// To ensure that we can eq? symbols with equal values.
|
|
if (!(val in symbolCache)) {
|
|
symbolCache[val] = new Symbol(val);
|
|
} else {
|
|
}
|
|
return symbolCache[val];
|
|
};
|
|
|
|
Symbol.prototype.equals = function(other, aUnionFind) {
|
|
return other instanceof Symbol &&
|
|
this.val === other.val;
|
|
};
|
|
|
|
|
|
Symbol.prototype.toString = function(cache) {
|
|
return this.val;
|
|
};
|
|
|
|
Symbol.prototype.toWrittenString = function(cache) {
|
|
return this.val;
|
|
};
|
|
|
|
Symbol.prototype.toDisplayedString = function(cache) {
|
|
return this.val;
|
|
};
|
|
|
|
|
|
var isSymbol = function(x) { return x instanceof Symbol; };
|
|
|
|
var makeSymbol = function(s) { return Symbol.makeInstance(s); };
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
exports.Symbol = Symbol;
|
|
exports.makeSymbol = makeSymbol;
|
|
exports.isSymbol = isSymbol;
|
|
|
|
})(this['plt'].baselib);// Strings
|
|
|
|
// Strings are either mutable or immutable. immutable strings are represented
|
|
// as regular JavaScript strings. Mutable ones are represented as instances
|
|
// of the Str class.
|
|
|
|
(function(baselib) {
|
|
var exports = {};
|
|
|
|
baselib.strings = exports;
|
|
|
|
|
|
|
|
var isString = function(s) {
|
|
return (typeof s === 'string' ||
|
|
s instanceof Str);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// Now using mutable strings
|
|
var Str = function(chars) {
|
|
this.chars = chars;
|
|
this.length = chars.length;
|
|
this.mutable = true;
|
|
}
|
|
|
|
Str.makeInstance = function(chars) {
|
|
return new Str(chars);
|
|
}
|
|
|
|
Str.fromString = function(s) {
|
|
return Str.makeInstance(s.split(""));
|
|
}
|
|
|
|
Str.prototype.toString = function() {
|
|
return this.chars.join("");
|
|
}
|
|
|
|
Str.prototype.toWrittenString = function(cache) {
|
|
return escapeString(this.toString());
|
|
}
|
|
|
|
Str.prototype.toDisplayedString = Str.prototype.toString;
|
|
|
|
Str.prototype.copy = function() {
|
|
return Str.makeInstance(this.chars.slice(0));
|
|
}
|
|
|
|
Str.prototype.substring = function(start, end) {
|
|
if (end == null || end == undefined) {
|
|
end = this.length;
|
|
}
|
|
|
|
return Str.makeInstance( this.chars.slice(start, end) );
|
|
}
|
|
|
|
Str.prototype.charAt = function(index) {
|
|
return this.chars[index];
|
|
}
|
|
|
|
Str.prototype.charCodeAt = function(index) {
|
|
return this.chars[index].charCodeAt(0);
|
|
}
|
|
|
|
Str.prototype.replace = function(expr, newStr) {
|
|
return Str.fromString( this.toString().replace(expr, newStr) );
|
|
}
|
|
|
|
|
|
Str.prototype.equals = function(other, aUnionFind) {
|
|
if ( !(other instanceof Str || typeof(other) == 'string') ) {
|
|
return false;
|
|
}
|
|
return this.toString() === other.toString();
|
|
}
|
|
|
|
|
|
Str.prototype.set = function(i, c) {
|
|
this.chars[i] = c;
|
|
}
|
|
|
|
Str.prototype.toUpperCase = function() {
|
|
return Str.fromString( this.chars.join("").toUpperCase() );
|
|
}
|
|
|
|
Str.prototype.toLowerCase = function() {
|
|
return Str.fromString( this.chars.join("").toLowerCase() );
|
|
}
|
|
|
|
Str.prototype.match = function(regexpr) {
|
|
return this.toString().match(regexpr);
|
|
}
|
|
|
|
|
|
var escapeString = function(s) {
|
|
return '"' + replaceUnprintableStringChars(s) + '"';
|
|
};
|
|
|
|
var replaceUnprintableStringChars = function(s) {
|
|
var ret = [];
|
|
for (var i = 0; i < s.length; i++) {
|
|
var val = s.charCodeAt(i);
|
|
switch(val) {
|
|
case 7: ret.push('\\a'); break;
|
|
case 8: ret.push('\\b'); break;
|
|
case 9: ret.push('\\t'); break;
|
|
case 10: ret.push('\\n'); break;
|
|
case 11: ret.push('\\v'); break;
|
|
case 12: ret.push('\\f'); break;
|
|
case 13: ret.push('\\r'); break;
|
|
case 34: ret.push('\\"'); break;
|
|
case 92: ret.push('\\\\'); break;
|
|
default: if (val >= 32 && val <= 126) {
|
|
ret.push( s.charAt(i) );
|
|
}
|
|
else {
|
|
var numStr = val.toString(16).toUpperCase();
|
|
while (numStr.length < 4) {
|
|
numStr = '0' + numStr;
|
|
}
|
|
ret.push('\\u' + numStr);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return ret.join('');
|
|
};
|
|
|
|
|
|
/*
|
|
// Strings
|
|
// For the moment, we just reuse Javascript strings.
|
|
String = String;
|
|
String.makeInstance = function(s) {
|
|
return s.valueOf();
|
|
};
|
|
|
|
|
|
// WARNING
|
|
// WARNING: we are extending the built-in Javascript string class here!
|
|
// WARNING
|
|
String.prototype.equals = function(other, aUnionFind){
|
|
return this == other;
|
|
};
|
|
|
|
var _quoteReplacingRegexp = new RegExp("[\"\\\\]", "g");
|
|
String.prototype.toWrittenString = function(cache) {
|
|
return '"' + this.replace(_quoteReplacingRegexp,
|
|
function(match, submatch, index) {
|
|
return "\\" + match;
|
|
}) + '"';
|
|
};
|
|
|
|
String.prototype.toDisplayedString = function(cache) {
|
|
return this;
|
|
};
|
|
*/
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
exports.Str = Str;
|
|
exports.escapeString = escapeString;
|
|
exports.isString = isString;
|
|
|
|
|
|
})(this['plt'].baselib);// Arity structure
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.bytes = exports;
|
|
|
|
// Bytes
|
|
|
|
var Bytes = function(bts, mutable) {
|
|
// bytes: arrayof [0-255]
|
|
this.bytes = bts;
|
|
this.mutable = (mutable === undefined) ? false : mutable;
|
|
};
|
|
|
|
Bytes.prototype.get = function(i) {
|
|
return this.bytes[i];
|
|
};
|
|
|
|
Bytes.prototype.set = function(i, b) {
|
|
if (this.mutable) {
|
|
this.bytes[i] = b;
|
|
}
|
|
};
|
|
|
|
Bytes.prototype.length = function() {
|
|
return this.bytes.length;
|
|
};
|
|
|
|
Bytes.prototype.copy = function(mutable) {
|
|
return new Bytes(this.bytes.slice(0), mutable);
|
|
};
|
|
|
|
Bytes.prototype.subbytes = function(start, end) {
|
|
if (end == null || end == undefined) {
|
|
end = this.bytes.length;
|
|
}
|
|
|
|
return new Bytes( this.bytes.slice(start, end), true );
|
|
};
|
|
|
|
|
|
Bytes.prototype.equals = function(other) {
|
|
if (! (other instanceof Bytes)) {
|
|
return false;
|
|
}
|
|
if (this.bytes.length != other.bytes.length) {
|
|
return false;
|
|
}
|
|
var A = this.bytes;
|
|
var B = other.bytes;
|
|
var n = this.bytes.length;
|
|
for (var i = 0; i < n; i++) {
|
|
if (A[i] !== B[i])
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
|
|
|
|
Bytes.prototype.toString = function(cache) {
|
|
var ret = '';
|
|
for (var i = 0; i < this.bytes.length; i++) {
|
|
ret += String.fromCharCode(this.bytes[i]);
|
|
}
|
|
|
|
return ret;
|
|
};
|
|
|
|
Bytes.prototype.toDisplayedString = Bytes.prototype.toString;
|
|
|
|
Bytes.prototype.toWrittenString = function() {
|
|
var ret = ['#"'];
|
|
for (var i = 0; i < this.bytes.length; i++) {
|
|
ret.push( escapeByte(this.bytes[i]) );
|
|
}
|
|
ret.push('"');
|
|
return ret.join('');
|
|
};
|
|
|
|
var escapeByte = function(aByte) {
|
|
var ret = [];
|
|
var returnVal;
|
|
switch(aByte) {
|
|
case 7: returnVal = '\\a'; break;
|
|
case 8: returnVal = '\\b'; break;
|
|
case 9: returnVal = '\\t'; break;
|
|
case 10: returnVal = '\\n'; break;
|
|
case 11: returnVal = '\\v'; break;
|
|
case 12: returnVal = '\\f'; break;
|
|
case 13: returnVal = '\\r'; break;
|
|
case 34: returnVal = '\\"'; break;
|
|
case 92: returnVal = '\\\\'; break;
|
|
default: if (aByte >= 32 && aByte <= 126) {
|
|
returnVal = String.fromCharCode(aByte);
|
|
}
|
|
else {
|
|
ret.push( '\\' + aByte.toString(8) );
|
|
}
|
|
break;
|
|
}
|
|
return returnVal;
|
|
};
|
|
|
|
|
|
|
|
exports.Bytes = Bytes;
|
|
|
|
})(this['plt'].baselib);
|
|
(function(baselib) {
|
|
var exports = {};
|
|
|
|
baselib.hashes = exports;
|
|
|
|
|
|
|
|
var _eqHashCodeCounter = 0;
|
|
var makeEqHashCode = function() {
|
|
_eqHashCodeCounter++;
|
|
return _eqHashCodeCounter;
|
|
};
|
|
|
|
|
|
// getHashCode: any -> (or fixnum string)
|
|
// Given a value, produces a hashcode appropriate for eq.
|
|
var getEqHashCode = function(x) {
|
|
if (typeof(x) === 'string') {
|
|
return x;
|
|
}
|
|
if (typeof(x) === 'number') {
|
|
return String(x);
|
|
}
|
|
if (x && !x._eqHashCode) {
|
|
x._eqHashCode = makeEqHashCode();
|
|
}
|
|
if (x && x._eqHashCode) {
|
|
return x._eqHashCode;
|
|
}
|
|
return 0;
|
|
};
|
|
|
|
|
|
// Creates a low-level hashtable, following the interface of
|
|
// http://www.timdown.co.uk/jshashtable/
|
|
//
|
|
// Defined to use the getEqHashCode defined in baselib_hash.js.
|
|
var makeLowLevelEqHash = function() {
|
|
return new Hashtable(function(x) { return getEqHashCode(x); },
|
|
function(x, y) { return x === y; });
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Eq Hashtables
|
|
var EqHashTable = function(inputHash) {
|
|
this.hash = makeLowLevelEqHash();
|
|
this.mutable = true;
|
|
|
|
};
|
|
|
|
EqHashTable.prototype.toWrittenString = function(cache) {
|
|
var keys = this.hash.keys();
|
|
var ret = [];
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var keyStr = toWrittenString(keys[i], cache);
|
|
var valStr = toWrittenString(this.hash.get(keys[i]), cache);
|
|
ret.push('(' + keyStr + ' . ' + valStr + ')');
|
|
}
|
|
return ('#hasheq(' + ret.join(' ') + ')');
|
|
};
|
|
|
|
EqHashTable.prototype.toDisplayedString = function(cache) {
|
|
var keys = this.hash.keys();
|
|
var ret = [];
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var keyStr = toDisplayedString(keys[i], cache);
|
|
var valStr = toDisplayedString(this.hash.get(keys[i]), cache);
|
|
ret.push('(' + keyStr + ' . ' + valStr + ')');
|
|
}
|
|
return ('#hasheq(' + ret.join(' ') + ')');
|
|
};
|
|
|
|
EqHashTable.prototype.equals = function(other, aUnionFind) {
|
|
if ( !(other instanceof EqHashTable) ) {
|
|
return false;
|
|
}
|
|
|
|
if (this.hash.keys().length != other.hash.keys().length) {
|
|
return false;
|
|
}
|
|
|
|
var keys = this.hash.keys();
|
|
for (var i = 0; i < keys.length; i++){
|
|
if ( !(other.hash.containsKey(keys[i]) &&
|
|
plt.baselib.equality.equals(this.hash.get(keys[i]),
|
|
other.hash.get(keys[i]),
|
|
aUnionFind)) ) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Equal hash tables
|
|
var EqualHashTable = function(inputHash) {
|
|
this.hash = new _Hashtable(
|
|
function(x) {
|
|
return plt.baselib.format.toWrittenString(x);
|
|
},
|
|
function(x, y) {
|
|
return plt.baselib.equality.equals(x, y, new plt.baselib.UnionFind());
|
|
});
|
|
this.mutable = true;
|
|
};
|
|
|
|
EqualHashTable.prototype.toWrittenString = function(cache) {
|
|
var keys = this.hash.keys();
|
|
var ret = [];
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var keyStr = plt.baselib.format.toWrittenString(keys[i], cache);
|
|
var valStr = plt.baselib.format.toWrittenString(this.hash.get(keys[i]), cache);
|
|
ret.push('(' + keyStr + ' . ' + valStr + ')');
|
|
}
|
|
return ('#hash(' + ret.join(' ') + ')');
|
|
};
|
|
EqualHashTable.prototype.toDisplayedString = function(cache) {
|
|
var keys = this.hash.keys();
|
|
var ret = [];
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var keyStr = plt.baselib.format.toDisplayedString(keys[i], cache);
|
|
var valStr = plt.baselib.format.toDisplayedString(this.hash.get(keys[i]), cache);
|
|
ret.push('(' + keyStr + ' . ' + valStr + ')');
|
|
}
|
|
return ('#hash(' + ret.join(' ') + ')');
|
|
};
|
|
|
|
EqualHashTable.prototype.equals = function(other, aUnionFind) {
|
|
if ( !(other instanceof EqualHashTable) ) {
|
|
return false;
|
|
}
|
|
|
|
if (this.hash.keys().length != other.hash.keys().length) {
|
|
return false;
|
|
}
|
|
|
|
var keys = this.hash.keys();
|
|
for (var i = 0; i < keys.length; i++){
|
|
if (! (other.hash.containsKey(keys[i]) &&
|
|
plt.baselib.equality.equals(this.hash.get(keys[i]),
|
|
other.hash.get(keys[i]),
|
|
aUnionFind))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
|
|
|
|
|
|
|
|
var isHash = function(x) {
|
|
return (x instanceof EqHashTable ||
|
|
x instanceof EqualHashTable);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
exports.getEqHashCode = getEqHashCode;
|
|
exports.makeEqHashCode = makeEqHashCode;
|
|
exports.makeLowLevelEqHash = makeLowLevelEqHash;
|
|
|
|
|
|
exports.EqualHashTable = EqualHashTable;
|
|
exports.EqHashTable = EqHashTable;
|
|
exports.isHash = isHash;
|
|
|
|
|
|
})(this['plt'].baselib);(function(baselib) {
|
|
var exports = {};
|
|
baselib.regexps = exports;
|
|
|
|
|
|
// Regular expressions.
|
|
|
|
var RegularExpression = function(pattern) {
|
|
this.pattern = pattern;
|
|
};
|
|
|
|
|
|
var ByteRegularExpression = function(pattern) {
|
|
this.pattern = pattern;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
exports.RegularExpression = RegularExpression;
|
|
exports.ByteRegularExpression = ByteRegularExpression;
|
|
|
|
})(this['plt'].baselib);(function(baselib) {
|
|
var exports = {};
|
|
baselib.paths = exports;
|
|
|
|
// Paths
|
|
|
|
var Path = function(p) {
|
|
this.path = p;
|
|
};
|
|
|
|
Path.prototype.toString = function() {
|
|
return String(this.path);
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
exports.Path = Path;
|
|
|
|
})(this['plt'].baselib);// Exceptions
|
|
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.boxes = exports;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Boxes
|
|
|
|
var Box = function(x, mutable) {
|
|
this.val = x;
|
|
this.mutable = mutable;
|
|
};
|
|
|
|
Box.prototype.ref = function() {
|
|
return this.val;
|
|
};
|
|
|
|
Box.prototype.set = function(newVal) {
|
|
if (this.mutable) {
|
|
this.val = newVal;
|
|
}
|
|
};
|
|
|
|
Box.prototype.toString = function(cache) {
|
|
cache.put(this, true);
|
|
return "#&" + plt.baselib.format.toWrittenString(this.val, cache);
|
|
};
|
|
|
|
Box.prototype.toWrittenString = function(cache) {
|
|
cache.put(this, true);
|
|
return "#&" + plt.baselib.format.toWrittenString(this.val, cache);
|
|
};
|
|
|
|
Box.prototype.toDisplayedString = function(cache) {
|
|
cache.put(this, true);
|
|
return "#&" + plt.baselib.format.toDisplayedString(this.val, cache);
|
|
};
|
|
|
|
Box.prototype.toDomNode = function(cache) {
|
|
cache.put(this, true);
|
|
var parent = document.createElement("span");
|
|
parent.appendChild(document.createTextNode('#&'));
|
|
parent.appendChild(plt.baselib.format.toDomNode(this.val, cache));
|
|
return parent;
|
|
};
|
|
|
|
Box.prototype.equals = function(other, aUnionFind) {
|
|
return ((other instanceof Box) &&
|
|
plt.baselib.equality.equals(this.val, other.val, aUnionFind));
|
|
};
|
|
|
|
var makeBox = function(x) {
|
|
return new Box(x, true);
|
|
};
|
|
|
|
var makeImmutableBox = function(x) {
|
|
return new Box(x, false);
|
|
};
|
|
|
|
var isBox = function(x) {
|
|
return x instanceof Box;
|
|
};
|
|
|
|
var isMutableBox = function(x) {
|
|
return (x instanceof Box && x.mutable);
|
|
};
|
|
|
|
var isImmutableBox = function(x) {
|
|
return (x instanceof Box && (!x.mutable));
|
|
};
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
exports.Box = Box;
|
|
exports.isBox = isBox;
|
|
exports.isMutableBox = isMutableBox;
|
|
exports.isImmutableBox = isImmutableBox;
|
|
exports.makeBox = makeBox;
|
|
exports.makeImmutableBox = makeImmutableBox;
|
|
|
|
|
|
})(this['plt'].baselib);// Placeholders
|
|
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.placeholders = exports;
|
|
|
|
|
|
// Placeholders: same thing as boxes. Distinct type just to support make-reader-graph.
|
|
|
|
var Placeholder = function(x, mutable) {
|
|
this.val = x;
|
|
};
|
|
|
|
Placeholder.prototype.ref = function() {
|
|
return this.val;
|
|
};
|
|
|
|
Placeholder.prototype.set = function(newVal) {
|
|
this.val = newVal;
|
|
};
|
|
|
|
Placeholder.prototype.toString = function(cache) {
|
|
return "#<placeholder>";
|
|
};
|
|
|
|
Placeholder.prototype.toWrittenString = function(cache) {
|
|
return "#<placeholder>";
|
|
};
|
|
|
|
Placeholder.prototype.toDisplayedString = function(cache) {
|
|
return "#<placeholder>";
|
|
};
|
|
|
|
Placeholder.prototype.toDomNode = function(cache) {
|
|
var parent = document.createElement("span");
|
|
parent.appendChild(document.createTextNode('#<placeholder>'));
|
|
return parent;
|
|
};
|
|
|
|
Placeholder.prototype.equals = function(other, aUnionFind) {
|
|
return ((other instanceof Placeholder) &&
|
|
plt.baselib.equality.equals(this.val, other.val, aUnionFind));
|
|
};
|
|
|
|
|
|
var isPlaceholder = function(x) {
|
|
return x instanceof Placeholder;
|
|
};
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
exports.Placeholder = Placeholder;
|
|
exports.isPlaceholder = isPlaceholder;
|
|
|
|
|
|
|
|
})(this['plt'].baselib);// Keywords
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.keywords = exports;
|
|
|
|
|
|
var Keyword = function(val) {
|
|
this.val = val;
|
|
};
|
|
|
|
var keywordCache = {};
|
|
|
|
// makeInstance: string -> Keyword.
|
|
Keyword.makeInstance = function(val) {
|
|
// To ensure that we can eq? symbols with equal values.
|
|
if (!(val in keywordCache)) {
|
|
keywordCache[val] = new Keyword(val);
|
|
} else {
|
|
}
|
|
return keywordCache[val];
|
|
};
|
|
|
|
Keyword.prototype.equals = function(other, aUnionFind) {
|
|
return other instanceof Keyword &&
|
|
this.val == other.val;
|
|
};
|
|
|
|
|
|
Keyword.prototype.toString = function(cache) {
|
|
return this.val;
|
|
};
|
|
|
|
Keyword.prototype.toWrittenString = function(cache) {
|
|
return this.val;
|
|
};
|
|
|
|
Keyword.prototype.toDisplayedString = function(cache) {
|
|
return this.val;
|
|
};
|
|
|
|
|
|
exports.Keyword = Keyword;
|
|
|
|
})(this['plt'].baselib);// Structure types
|
|
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.structs = exports;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var StructType = function(name, // string
|
|
type, // StructType
|
|
numberOfArgs, // number
|
|
numberOfFields, // number
|
|
firstField,
|
|
applyGuard,
|
|
constructor,
|
|
predicate,
|
|
accessor,
|
|
mutator) {
|
|
this.name = name;
|
|
this.type = type;
|
|
this.numberOfArgs = numberOfArgs;
|
|
this.numberOfFields = numberOfFields;
|
|
this.firstField = firstField;
|
|
|
|
this.applyGuard = applyGuard;
|
|
this.constructor = constructor;
|
|
this.predicate = predicate;
|
|
this.accessor = accessor;
|
|
this.mutator = mutator;
|
|
};
|
|
|
|
|
|
StructType.prototype.toString = function(cache) {
|
|
return '#<struct-type:' + this.name + '>';
|
|
};
|
|
|
|
|
|
StructType.prototype.equals = function(other, aUnionFind) {
|
|
return this === other;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// guard-function: array string (array -> value)
|
|
|
|
|
|
|
|
|
|
|
|
// makeStructureType: string StructType number number boolean
|
|
// guard-function -> StructType
|
|
//
|
|
// Creates a new structure type.
|
|
|
|
var makeStructureType = function(theName,
|
|
parentType,
|
|
initFieldCnt,
|
|
autoFieldCnt,
|
|
autoV,
|
|
guard) {
|
|
// Defaults
|
|
autoFieldCnt = autoFieldCnt || 0;
|
|
parentType = parentType || DEFAULT_PARENT_TYPE;
|
|
guard = guard || DEFAULT_GUARD;
|
|
|
|
|
|
|
|
// rawConstructor creates a new struct type inheriting from
|
|
// the parent, with no guard checks.
|
|
var rawConstructor = function(name, args) {
|
|
parentType.type.call(this, name, args);
|
|
for (var i = 0; i < initFieldCnt; i++) {
|
|
this._fields.push(args[i+parentType.numberOfArgs]);
|
|
}
|
|
for (var i = 0; i < autoFieldCnt; i++) {
|
|
this._fields.push(autoV);
|
|
}
|
|
};
|
|
rawConstructor.prototype = baselib.heir(parentType.type.prototype);
|
|
|
|
|
|
|
|
// Set type, necessary for equality checking
|
|
rawConstructor.prototype.type = rawConstructor;
|
|
|
|
// The structure type consists of the name, its constructor, a
|
|
// record of how many argument it and its parent type contains,
|
|
// the list of autofields, the guard, and functions corresponding
|
|
// to the constructor, the predicate, the accessor, and mutators.
|
|
var newType = new StructType(
|
|
theName,
|
|
rawConstructor,
|
|
initFieldCnt + parentType.numberOfArgs,
|
|
initFieldCnt + autoFieldCnt,
|
|
parentType.firstField + parentType.numberOfFields,
|
|
function(args, name, k) {
|
|
return guard(args, name,
|
|
function(result) {
|
|
var parentArgs = result.slice(0, parentType.numberOfArgs);
|
|
var restArgs = result.slice(parentType.numberOfArgs);
|
|
return parentType.applyGuard(
|
|
parentArgs, name,
|
|
function(parentRes) {
|
|
return k( parentRes.concat(restArgs) ); });
|
|
});
|
|
},
|
|
// constructor
|
|
function() {
|
|
var args = [].slice.call(arguments);
|
|
return newType.applyGuard(
|
|
args,
|
|
baselib.symbols.Symbol.makeInstance(theName),
|
|
function(res) {
|
|
return new rawConstructor(theName, res); });
|
|
},
|
|
|
|
// predicate
|
|
function(x) {
|
|
return x instanceof rawConstructor;
|
|
},
|
|
|
|
// accessor
|
|
function(x, i) { return x._fields[i + this.firstField]; },
|
|
|
|
// mutator
|
|
function(x, i, v) { x._fields[i + this.firstField] = v; });
|
|
return newType;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
var Struct = function(constructorName, fields) {
|
|
this._constructorName = constructorName;
|
|
this._fields = [];
|
|
};
|
|
|
|
Struct.prototype.toWrittenString = function(cache) {
|
|
cache.put(this, true);
|
|
var buffer = [];
|
|
buffer.push("(");
|
|
buffer.push(this._constructorName);
|
|
for(var i = 0; i < this._fields.length; i++) {
|
|
buffer.push(" ");
|
|
buffer.push(plt.baselib.format.toWrittenString(this._fields[i], cache));
|
|
}
|
|
buffer.push(")");
|
|
return buffer.join("");
|
|
};
|
|
|
|
Struct.prototype.toDisplayedString = function(cache) {
|
|
return plt.baselib.format.toWrittenString(this, cache);
|
|
};
|
|
|
|
Struct.prototype.toDomNode = function(params) {
|
|
params.put(this, true);
|
|
var node = document.createElement("span");
|
|
$(node).append(document.createTextNode("("));
|
|
$(node).append(document.createTextNode(this._constructorName));
|
|
for(var i = 0; i < this._fields.length; i++) {
|
|
$(node).append(document.createTextNode(" "));
|
|
$(node).append(plt.baselib.format.toDomNode(this._fields[i], params));
|
|
}
|
|
$(node).append(document.createTextNode(")"));
|
|
return node;
|
|
};
|
|
|
|
|
|
Struct.prototype.equals = function(other, aUnionFind) {
|
|
if ( other.type == undefined ||
|
|
this.type !== other.type ||
|
|
!(other instanceof this.type) ) {
|
|
return false;
|
|
}
|
|
|
|
for (var i = 0; i < this._fields.length; i++) {
|
|
if (! equals(this._fields[i],
|
|
other._fields[i],
|
|
aUnionFind)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
Struct.prototype.type = Struct;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// // Struct Procedure types
|
|
// var StructProc = function(type, name, numParams, isRest, usesState, impl) {
|
|
// PrimProc.call(this, name, numParams, isRest, usesState, impl);
|
|
// this.type = type;
|
|
// };
|
|
// StructProc.prototype = baselib.heir(PrimProc.prototype);
|
|
|
|
// var StructConstructorProc = function() {
|
|
// StructProc.apply(this, arguments);
|
|
// };
|
|
// StructConstructorProc.prototype = baselib.heir(StructProc.prototype);
|
|
|
|
// var StructPredicateProc = function() {
|
|
// StructProc.apply(this, arguments);
|
|
// };
|
|
// StructPredicateProc.prototype = baselib.heir(StructProc.prototype);
|
|
|
|
// var StructAccessorProc = function() {
|
|
// StructProc.apply(this, arguments);
|
|
// };
|
|
// StructAccessorProc.prototype = baselib.heir(StructProc.prototype);
|
|
|
|
// var StructMutatorProc = function() {
|
|
// StructProc.apply(this, arguments);
|
|
// };
|
|
// StructMutatorProc.prototype = baselib.heir(StructProc.prototype);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Default structure guard just calls the continuation argument.
|
|
var DEFAULT_GUARD = function(args, name, k) {
|
|
return k(args);
|
|
};
|
|
|
|
|
|
// The default parent type refers to the toplevel Struct.
|
|
var DEFAULT_PARENT_TYPE = { type: Struct,
|
|
numberOfArgs: 0,
|
|
numberOfFields: 0,
|
|
firstField: 0,
|
|
applyGuard: DEFAULT_GUARD };
|
|
|
|
|
|
|
|
var isStruct = function(x) { return x instanceof Struct; };
|
|
var isStructType = function(x) { return x instanceof StructType; };
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
exports.StructType = StructType;
|
|
exports.Struct = Struct;
|
|
exports.makeStructureType = makeStructureType;
|
|
exports.isStruct = isStruct;
|
|
exports.isStructType = isStructType;
|
|
|
|
// exports.StructProc = StructProc;
|
|
// exports.StructConstructorProc = StructConstructorProc;
|
|
// exports.StructPredicateProc = StructPredicateProc;
|
|
// exports.StructAccessorProc = StructAccessorProc;
|
|
// exports.StructMutatorProc = StructMutatorProc;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
})(this['plt'].baselib);// Arity structure
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.ports = exports;
|
|
|
|
|
|
// Output Ports
|
|
|
|
var OutputPort = function() {};
|
|
var isOutputPort = baselib.makeClassPredicate(OutputPort);
|
|
|
|
|
|
var StandardOutputPort = function() {
|
|
OutputPort.call(this);
|
|
};
|
|
StandardOutputPort.prototype = baselib.heir(OutputPort.prototype);
|
|
StandardOutputPort.prototype.writeDomNode = function(MACHINE, domNode) {
|
|
MACHINE.params['currentDisplayer'](MACHINE, domNode);
|
|
jQuery('*', domNode).trigger({type : 'afterAttach'});
|
|
};
|
|
|
|
var StandardErrorPort = function() {
|
|
OutputPort.call(this);
|
|
};
|
|
StandardErrorPort.prototype = baselib.heir(OutputPort.prototype);
|
|
StandardErrorPort.prototype.writeDomNode = function(MACHINE, domNode) {
|
|
MACHINE.params['currentErrorDisplayer'](MACHINE, domNode);
|
|
jQuery('*', domNode).trigger({type : 'afterAttach'});
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var OutputStringPort = function() {
|
|
this.buf = [];
|
|
};
|
|
OutputStringPort.prototype = baselib.heir(OutputPort.prototype);
|
|
OutputStringPort.prototype.writeDomNode = function(MACHINE, v) {
|
|
this.buf.push($(v).text());
|
|
};
|
|
OutputStringPort.prototype.getOutputString = function() {
|
|
return this.buf.join('');
|
|
};
|
|
var isOutputStringPort = baselib.makeClassPredicate(OutputStringPort);
|
|
|
|
|
|
|
|
|
|
exports.OutputPort = OutputPort;
|
|
exports.isOutputPort = isOutputPort;
|
|
exports.StandardOutputPort = StandardOutputPort;
|
|
exports.StandardErrorPort = StandardErrorPort;
|
|
exports.OutputStringPort = OutputStringPort;
|
|
exports.isOutputStringPort = isOutputStringPort;
|
|
|
|
|
|
})(this['plt'].baselib);// Procedures
|
|
|
|
// For historical reasons, this module is called 'functions' instead of 'procedures'.
|
|
// This may change soon.
|
|
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.functions = exports;
|
|
|
|
// Procedure types: a procedure is either a Primitive or a Closure.
|
|
|
|
// A Primitive is a function that's expected to return. It is not
|
|
// allowed to call into Closures. Its caller is expected to pop off
|
|
// its argument stack space.
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
// coerseToJavaScript: racket function -> JavaScript function
|
|
// Given a closure or primitive, produces an
|
|
// asynchronous JavaScript function.
|
|
// The function will run on the provided MACHINE.
|
|
//
|
|
// It assumes that it must begin its own trampoline.
|
|
var asJavaScriptFunction = function(v, MACHINE) {
|
|
MACHINE = MACHINE || plt.runtime.currentMachine;
|
|
if (isPrimitiveProcedure(v)) {
|
|
return coersePrimitiveToJavaScript(v, MACHINE);
|
|
} else if (isClosure(v)) {
|
|
return coerseClosureToJavaScript(v, MACHINE);
|
|
} else {
|
|
plt.baselib.exceptions.raise(MACHINE,
|
|
plt.baselib.exceptions.makeExnFail(
|
|
plt.baselib.format.format(
|
|
"Not a procedure: ~e",
|
|
v)));
|
|
}
|
|
};
|
|
|
|
var coersePrimitiveToJavaScript = function(v, MACHINE) {
|
|
return function(succ, fail) {
|
|
try {
|
|
succ = succ || function(){};
|
|
fail = fail || function(){};
|
|
|
|
var oldArgcount = MACHINE.argcount;
|
|
MACHINE.argcount = arguments.length - 2;
|
|
for (var i = 0; i < arguments.length - 2; i++) {
|
|
MACHINE.env.push(arguments[arguments.length - 1 - i]);
|
|
}
|
|
|
|
// Check arity usage.
|
|
if (! plt.baselib.arity.isArityMatching(v.arity, args.length)) {
|
|
throw new Error("arity mismatch");
|
|
}
|
|
|
|
var result = v.apply(null, args);
|
|
MACHINE.argcount = oldArgcount;
|
|
for (var i = 0; i < arguments.length - 2; i++) {
|
|
MACHINE.env.pop();
|
|
}
|
|
succ(result);
|
|
} catch (e) {
|
|
fail(e);
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
var coerseClosureToJavaScript = function(v, MACHINE) {
|
|
var f = function(succ, fail) {
|
|
succ = succ || function(){};
|
|
fail = fail || function(){};
|
|
|
|
// Check arity usage.
|
|
if (! plt.baselib.arity.isArityMatching(v.arity, arguments.length - 2)) {
|
|
throw new Error("arity mismatch");
|
|
}
|
|
|
|
|
|
var oldVal = MACHINE.val;
|
|
var oldArgcount = MACHINE.argcount;
|
|
var oldProc = MACHINE.proc;
|
|
|
|
var oldErrorHandler = MACHINE.params['currentErrorHandler'];
|
|
var afterGoodInvoke = function(MACHINE) {
|
|
plt.runtime.PAUSE(
|
|
function(restart) {
|
|
MACHINE.params['currentErrorHandler'] = oldErrorHandler;
|
|
var returnValue = MACHINE.val;
|
|
MACHINE.val = oldVal;
|
|
MACHINE.argcount = oldArgcount;
|
|
MACHINE.proc = oldProc;
|
|
succ(returnValue);
|
|
});
|
|
};
|
|
afterGoodInvoke.multipleValueReturn = function(MACHINE) {
|
|
plt.runtime.PAUSE(
|
|
function(restart) {
|
|
MACHINE.params['currentErrorHandler'] = oldErrorHandler;
|
|
var returnValues = [MACHINE.val];
|
|
for (var i = 0; i < MACHINE.argcount - 1; i++) {
|
|
returnValues.push(MACHINE.env.pop());
|
|
}
|
|
MACHINE.val = oldVal;
|
|
MACHINE.argcount = oldArgcount;
|
|
MACHINE.proc = oldProc;
|
|
succ.apply(null, returnValues);
|
|
});
|
|
};
|
|
|
|
MACHINE.control.push(
|
|
new plt.baselib.frames.CallFrame(afterGoodInvoke, null));
|
|
MACHINE.argcount = arguments.length - 2;
|
|
for (var i = 0; i < arguments.length - 2; i++) {
|
|
MACHINE.env.push(arguments[arguments.length - 1 - i]);
|
|
}
|
|
MACHINE.proc = v;
|
|
MACHINE.params['currentErrorHandler'] = function(MACHINE, e) {
|
|
MACHINE.params['currentErrorHandler'] = oldErrorHandler;
|
|
MACHINE.val = oldVal;
|
|
MACHINE.argcount = oldArgcount;
|
|
MACHINE.proc = oldProc;
|
|
fail(e);
|
|
};
|
|
plt.runtime.trampoline(MACHINE, v.label);
|
|
};
|
|
return f;
|
|
};
|
|
|
|
|
|
|
|
// internallCallDuringPause: call a Racket procedure and get its results.
|
|
// The use assumes the machine is in a running-but-paused state.
|
|
var internalCallDuringPause = function(MACHINE, proc, success, fail) {
|
|
if (! plt.baselib.arity.isArityMatching(proc.arity, arguments.length - 4)) {
|
|
return fail(plt.baselib.exceptions.makeExnFailContractArity("arity mismatch"));
|
|
}
|
|
|
|
if (isPrimitiveProcedure(proc)) {
|
|
var oldArgcount = MACHINE.argcount;
|
|
MACHINE.argcount = arguments.length - 4;
|
|
for (var i = 0; i < arguments.length - 4; i++) {
|
|
MACHINE.env.push(arguments[arguments.length - 1 - i]);
|
|
}
|
|
var result = proc.call(null, MACHINE);
|
|
for (var i = 0; i < arguments.length - 4; i++) {
|
|
MACHINE.env.pop();
|
|
}
|
|
success(result);
|
|
} else if (isClosure(proc)) {
|
|
var oldVal = MACHINE.val;
|
|
var oldArgcount = MACHINE.argcount;
|
|
var oldProc = MACHINE.proc;
|
|
|
|
var oldErrorHandler = MACHINE.params['currentErrorHandler'];
|
|
var afterGoodInvoke = function(MACHINE) {
|
|
plt.runtime.PAUSE(function(restart) {
|
|
MACHINE.params['currentErrorHandler'] = oldErrorHandler;
|
|
var returnValue = MACHINE.val;
|
|
MACHINE.val = oldVal;
|
|
MACHINE.argcount = oldArgcount;
|
|
MACHINE.proc = oldProc;
|
|
success(returnValue);
|
|
});
|
|
};
|
|
afterGoodInvoke.multipleValueReturn = function(MACHINE) {
|
|
plt.runtime.PAUSE(function(restart) {
|
|
MACHINE.params['currentErrorHandler'] = oldErrorHandler;
|
|
var returnValues = [MACHINE.val];
|
|
for (var i = 0; i < MACHINE.argcount - 1; i++) {
|
|
returnValues.push(MACHINE.env.pop());
|
|
}
|
|
MACHINE.val = oldVal;
|
|
MACHINE.argcount = oldArgcount;
|
|
MACHINE.proc = oldProc;
|
|
success.apply(null, returnValues);
|
|
});
|
|
};
|
|
|
|
MACHINE.control.push(
|
|
new plt.baselib.frames.CallFrame(afterGoodInvoke, null));
|
|
MACHINE.argcount = arguments.length - 4;
|
|
for (var i = 0; i < arguments.length - 4; i++) {
|
|
MACHINE.env.push(arguments[arguments.length - 1 - i]);
|
|
}
|
|
MACHINE.proc = proc;
|
|
MACHINE.params['currentErrorHandler'] = function(MACHINE, e) {
|
|
MACHINE.params['currentErrorHandler'] = oldErrorHandler;
|
|
MACHINE.val = oldVal;
|
|
MACHINE.argcount = oldArgcount;
|
|
MACHINE.proc = oldProc;
|
|
fail(e);
|
|
};
|
|
plt.runtime.trampoline(MACHINE, proc.label);
|
|
} else {
|
|
fail(plt.baselib.exceptions.makeExnFail(
|
|
plt.baselib.format.format(
|
|
"Not a procedure: ~e",
|
|
proc)));
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// A Closure is a function that takes on more responsibilities: it is
|
|
// responsible for popping off stack space before it finishes, and it
|
|
// is also explicitly responsible for continuing the computation by
|
|
// popping off the control stack and doing the jump. Because of this,
|
|
// closures can do pretty much anything to the machine.
|
|
|
|
// A closure consists of its free variables as well as a label
|
|
// into its text segment.
|
|
var Closure = function(label, arity, closedVals, displayName) {
|
|
this.label = label; // (MACHINE -> void)
|
|
this.arity = arity; // number
|
|
this.closedVals = closedVals; // arrayof number
|
|
this.displayName = displayName; // string
|
|
};
|
|
|
|
|
|
|
|
// Finalize the return from a closure. This is a helper function
|
|
// for those who implement Closures by hand.
|
|
//
|
|
// If used in the body of a Closure, it must be in tail
|
|
// position. This finishes the closure call, and does the following:
|
|
//
|
|
// * Clears out the existing arguments off the stack frame
|
|
// * Sets up the return value
|
|
// * Jumps either to the single-value return point, or the multiple-value
|
|
// return point.
|
|
//
|
|
// I'd personally love for this to be a macro and avoid the
|
|
// extra function call here.
|
|
var finalizeClosureCall = function(MACHINE) {
|
|
MACHINE.callsBeforeTrampoline--;
|
|
var frame, i, returnArgs = [].slice.call(arguments, 1);
|
|
|
|
// clear out stack space
|
|
// TODO: replace with a splice.
|
|
for(i = 0; i < MACHINE.argcount; i++) {
|
|
MACHINE.env.pop();
|
|
}
|
|
|
|
if (returnArgs.length === 1) {
|
|
MACHINE.val = returnArgs[0];
|
|
frame = MACHINE.control.pop();
|
|
return frame.label(MACHINE);
|
|
} else if (returnArgs.length === 0) {
|
|
MACHINE.argcount = 0;
|
|
frame = MACHINE.control.pop();
|
|
return frame.label.multipleValueReturn(MACHINE);
|
|
} else {
|
|
MACHINE.argcount = returnArgs.length;
|
|
MACHINE.val = returnArgs.shift();
|
|
// TODO: replace with a splice.
|
|
for(i = 0; i < MACHINE.argcount - 1; i++) {
|
|
MACHINE.env.push(returnArgs.pop());
|
|
}
|
|
frame = MACHINE.control.pop();
|
|
return frame.label.multipleValueReturn(MACHINE);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var makePrimitiveProcedure = function(name, arity, f) {
|
|
f.arity = arity;
|
|
f.displayName = name;
|
|
return f;
|
|
};
|
|
|
|
var makeClosure = function(name, arity, f, closureArgs) {
|
|
if (! closureArgs) { closureArgs = []; }
|
|
return new Closure(f,
|
|
arity,
|
|
closureArgs,
|
|
name);
|
|
};
|
|
|
|
|
|
|
|
|
|
var isPrimitiveProcedure = function(x) {
|
|
return typeof(x) === 'function';
|
|
};
|
|
|
|
var isClosure = function(x) {
|
|
return x instanceof Closure;
|
|
};
|
|
|
|
|
|
var isProcedure = function(x) {
|
|
return (typeof(x) === 'function' ||
|
|
x instanceof Closure);
|
|
};
|
|
|
|
|
|
|
|
var renameProcedure = function(f, name) {
|
|
if (isPrimitiveProcedure(f)) {
|
|
return makePrimitiveProcedure(
|
|
name,
|
|
f.arity,
|
|
function() {
|
|
return f.apply(null, arguments);
|
|
});
|
|
} else {
|
|
return new Closure(
|
|
f.label,
|
|
f.arity,
|
|
f.closedVals,
|
|
name);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
exports.Closure = Closure;
|
|
exports.internalCallDuringPause = internalCallDuringPause;
|
|
exports.finalizeClosureCall = finalizeClosureCall;
|
|
|
|
exports.makePrimitiveProcedure = makePrimitiveProcedure;
|
|
exports.makeClosure = makeClosure;
|
|
|
|
exports.isPrimitiveProcedure = isPrimitiveProcedure;
|
|
exports.isClosure = isClosure;
|
|
|
|
exports.isProcedure = isProcedure;
|
|
|
|
|
|
exports.renameProcedure = renameProcedure;
|
|
|
|
|
|
exports.asJavaScriptFunction = asJavaScriptFunction;
|
|
|
|
})(this['plt'].baselib);(function(baselib) {
|
|
var exports = {};
|
|
baselib.modules = exports;
|
|
|
|
|
|
var ModuleRecord = function(name, label) {
|
|
this.name = name;
|
|
this.label = label;
|
|
this.isInvoked = false;
|
|
this.prefix = false;
|
|
this.namespace = {};
|
|
|
|
// JavaScript-implemented code will assign privateExports
|
|
// with all of the exported identifiers.
|
|
this.privateExports = {};
|
|
};
|
|
|
|
// Returns access to the names defined in the module.
|
|
ModuleRecord.prototype.getNamespace = function() {
|
|
return this.namespace;
|
|
};
|
|
|
|
ModuleRecord.prototype.finalizeModuleInvokation = function() {
|
|
var i, len = this.prefix.names.length;
|
|
for (i=0; i < len; i++) {
|
|
this.namespace[this.prefix.names[i]] = this.prefix[i];
|
|
}
|
|
};
|
|
|
|
|
|
// External invokation of a module.
|
|
ModuleRecord.prototype.invoke = function(MACHINE, succ, fail) {
|
|
this._invoke(false, MACHINE, succ, fail);
|
|
};
|
|
|
|
// Internal invokation of a module.
|
|
ModuleRecord.prototype.internalInvoke = function(MACHINE, succ, fail) {
|
|
this._invoke(true, MACHINE, succ, fail);
|
|
};
|
|
|
|
// Private: general invokation of a module
|
|
ModuleRecord.prototype._invoke = function(isInternal, MACHINE, succ, fail) {
|
|
var that = this;
|
|
MACHINE = MACHINE || plt.runtime.currentMachine;
|
|
succ = succ || function(){};
|
|
fail = fail || function(){};
|
|
|
|
var oldErrorHandler = MACHINE.params['currentErrorHandler'];
|
|
var afterGoodInvoke = function(MACHINE) {
|
|
MACHINE.params['currentErrorHandler'] = oldErrorHandler;
|
|
succ();
|
|
};
|
|
|
|
if (this.isInvoked) {
|
|
succ();
|
|
} else {
|
|
MACHINE.params['currentErrorHandler'] = function(MACHINE, anError) {
|
|
MACHINE.params['currentErrorHandler'] = oldErrorHandler;
|
|
fail(MACHINE, anError)
|
|
};
|
|
MACHINE.control.push(new plt.baselib.frames.CallFrame(afterGoodInvoke, null));
|
|
if (isInternal) {
|
|
throw that.label;
|
|
} else {
|
|
plt.runtime.trampoline(MACHINE, that.label);
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
exports.ModuleRecord = ModuleRecord;
|
|
|
|
|
|
})(this['plt'].baselib);// Arity structure
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.arity = exports;
|
|
|
|
|
|
|
|
var ArityAtLeast = plt.baselib.structs.makeStructureType(
|
|
'arity-at-least', false, 1, 0, false, false);
|
|
|
|
|
|
// An arity is either a primitive number, an ArityAtLeast instance,
|
|
// or a list of either primitive numbers or ArityAtLeast instances.
|
|
|
|
|
|
|
|
var isArityAtLeast = ArityAtLeast.predicate;
|
|
var arityAtLeastValue = function(x) {
|
|
var val = ArityAtLeast.accessor(x, 0);
|
|
return val;
|
|
}
|
|
|
|
|
|
ArityAtLeast.type.prototype.toString = function() {
|
|
return '#<arity-at-least ' + arityAtLeastValue(this) + '>';
|
|
};
|
|
|
|
|
|
|
|
// isArityMatching: arity natural -> boolean
|
|
// Produces true if n satisfies the arity.
|
|
var isArityMatching = function(arity, n) {
|
|
if (typeof(arity) === 'number') {
|
|
return arity === n;
|
|
} else if (isArityAtLeast(arity)) {
|
|
return n >= arityAtLeastValue(arity);
|
|
} else {
|
|
while (arity !== plt.baselib.lists.EMPTY) {
|
|
if (typeof(arity.first) === 'number') {
|
|
if (arity.first === n) { return true; }
|
|
} else if (isArityAtLeast(arity)) {
|
|
if (n >= arityAtLeastValue(arity.first)) { return true; }
|
|
}
|
|
arity = arity.rest;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
exports.ArityAtLeast = ArityAtLeast;
|
|
exports.makeArityAtLeast = ArityAtLeast.constructor;
|
|
exports.isArityAtLeast = isArityAtLeast;
|
|
exports.isArityMatching = isArityMatching;
|
|
exports.arityAtLeastValue = arityAtLeastValue;
|
|
|
|
})(this['plt'].baselib);// Structure types
|
|
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.inspectors = exports;
|
|
|
|
|
|
var Inspector = function() {
|
|
};
|
|
var DEFAULT_INSPECTOR = new Inspector();
|
|
|
|
Inspector.prototype.toString = function() {
|
|
return "#<inspector>";
|
|
};
|
|
|
|
var isInspector = baselib.makeClassPredicate(Inspector);
|
|
|
|
|
|
|
|
exports.Inspector = Inspector;
|
|
exports.DEFAULT_INSPECTOR = DEFAULT_INSPECTOR;
|
|
|
|
exports.isInspector = isInspector;
|
|
|
|
|
|
})(this['plt'].baselib);// Exceptions
|
|
|
|
(function(baselib) {
|
|
var exceptions = {};
|
|
baselib.exceptions = exceptions;
|
|
|
|
|
|
|
|
// Error type exports
|
|
var InternalError = function(val, contMarks) {
|
|
this.val = val;
|
|
this.contMarks = (contMarks ? contMarks : false);
|
|
}
|
|
|
|
|
|
var SchemeError = function(val) {
|
|
this.val = val;
|
|
}
|
|
|
|
|
|
var IncompleteExn = function(constructor, msg, otherArgs) {
|
|
this.constructor = constructor;
|
|
this.msg = msg;
|
|
this.otherArgs = otherArgs;
|
|
};
|
|
|
|
|
|
// (define-struct exn (message continuation-mark-set))
|
|
var Exn = plt.baselib.structs.makeStructureType(
|
|
'exn', false, 2, 0, false, false);
|
|
|
|
|
|
// (define-struct (exn:break exn) (continuation))
|
|
var ExnBreak = plt.baselib.structs.makeStructureType(
|
|
'exn:break', Exn, 1, 0, false, false);
|
|
|
|
|
|
var ExnFail = plt.baselib.structs.makeStructureType(
|
|
'exn:fail', Exn, 0, 0, false, false);
|
|
|
|
var ExnFailContract = plt.baselib.structs.makeStructureType(
|
|
'exn:fail:contract', ExnFail, 0, 0, false, false);
|
|
|
|
var ExnFailContractArity = plt.baselib.structs.makeStructureType(
|
|
'exn:fail:contract:arity', ExnFailContract, 0, 0, false, false);
|
|
|
|
var ExnFailContractVariable = plt.baselib.structs.makeStructureType(
|
|
'exn:fail:contract:variable', ExnFailContract, 1, 0, false, false);
|
|
|
|
var ExnFailContractDivisionByZero = plt.baselib.structs.makeStructureType(
|
|
'exn:fail:contract:divide-by-zero', ExnFailContract, 0, 0, false, false);
|
|
|
|
|
|
|
|
|
|
|
|
var exceptionHandlerKey = new plt.baselib.symbols.Symbol("exnh");
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// Raise error to the toplevel.
|
|
|
|
// If the error is of an exception type, make sure e.message holds the string
|
|
// value to allow integration with systems that don't recognize Racket error
|
|
// structures.
|
|
var raise = function(MACHINE, e) {
|
|
if (Exn.predicate(e)) {
|
|
e.message = Exn.accessor(e, 0);
|
|
}
|
|
|
|
if (typeof(window['console']) !== 'undefined' &&
|
|
typeof(console['log']) === 'function') {
|
|
console.log(MACHINE);
|
|
if (e['stack']) { console.log(e['stack']); }
|
|
else { console.log(e); }
|
|
}
|
|
throw e;
|
|
};
|
|
|
|
|
|
|
|
|
|
var raiseUnboundToplevelError = function(MACHINE, name) {
|
|
raise(MACHINE,
|
|
new Error(
|
|
plt.baselib.format.format(
|
|
"Not bound: ~a",
|
|
[name])));
|
|
};
|
|
|
|
|
|
var raiseArgumentTypeError = function(MACHINE,
|
|
callerName,
|
|
expectedTypeName,
|
|
argumentOffset,
|
|
actualValue) {
|
|
raise(MACHINE,
|
|
new Error(
|
|
plt.baselib.format.format(
|
|
"~a: expected ~a as argument ~e but received ~e",
|
|
[callerName,
|
|
expectedTypeName,
|
|
(argumentOffset + 1),
|
|
actualValue])));
|
|
};
|
|
|
|
var raiseContextExpectedValuesError = function(MACHINE, expected) {
|
|
raise(MACHINE,
|
|
new Error(plt.baselib.format.format(
|
|
"expected ~e values, received ~e values"
|
|
[expected,
|
|
MACHINE.argcount])));
|
|
};
|
|
|
|
var raiseArityMismatchError = function(MACHINE, proc, expected, received) {
|
|
raise(MACHINE,
|
|
new Error(plt.baselib.format.format(
|
|
"~a: expected ~e value(s), received ~e value(s)",
|
|
[proc.displayName,
|
|
expected ,
|
|
received])))
|
|
};
|
|
|
|
var raiseOperatorApplicationError = function(MACHINE, operator) {
|
|
raise(MACHINE,
|
|
new Error(
|
|
plt.baselib.format.format(
|
|
"not a procedure: ~e",
|
|
[operator])));
|
|
};
|
|
|
|
var raiseOperatorIsNotClosure = function(MACHINE, operator) {
|
|
raise(MACHINE,
|
|
new Error(
|
|
plt.baselib.format.format(
|
|
"not a closure: ~e",
|
|
[operator])));
|
|
};
|
|
|
|
var raiseOperatorIsNotPrimitiveProcedure = function(MACHINE, operator) {
|
|
raise(MACHINE,
|
|
new Error(
|
|
plt.baselib.format.format(
|
|
"not a primitive procedure: ~e",
|
|
[operator])));
|
|
};
|
|
|
|
|
|
var raiseUnimplementedPrimitiveError = function(MACHINE, name) {
|
|
raise(MACHINE,
|
|
new Error("unimplemented kernel procedure: " + name))
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Exports
|
|
|
|
exceptions.InternalError = InternalError;
|
|
exceptions.internalError = function(v, contMarks) { return new InternalError(v, contMarks); };
|
|
exceptions.isInternalError = function(x) { return x instanceof InternalError; };
|
|
|
|
|
|
exceptions.SchemeError = SchemeError;
|
|
exceptions.schemeError = function(v) { return new SchemeError(v); };
|
|
exceptions.isSchemeError = function(v) { return v instanceof SchemeError; };
|
|
|
|
|
|
exceptions.IncompleteExn = IncompleteExn;
|
|
exceptions.makeIncompleteExn = function(constructor, msg, args) { return new IncompleteExn(constructor, msg, args); };
|
|
exceptions.isIncompleteExn = function(x) { return x instanceof IncompleteExn; };
|
|
|
|
|
|
exceptions.Exn = Exn;
|
|
exceptions.makeExn = Exn.constructor;
|
|
exceptions.isExn = Exn.predicate;
|
|
exceptions.exnMessage = function(exn) { return Exn.accessor(exn, 0); };
|
|
exceptions.exnContMarks = function(exn) { return Exn.accessor(exn, 1); };
|
|
exceptions.exnSetContMarks = function(exn, v) { Exn.mutator(exn, 1, v); };
|
|
|
|
exceptions.ExnBreak = ExnBreak;
|
|
exceptions.makeExnBreak = ExnBreak.constructor;
|
|
exceptions.isExnBreak = ExnBreak.predicate;
|
|
exceptions.exnBreakContinuation =
|
|
function(exn) { return ExnBreak.accessor(exn, 0); };
|
|
|
|
exceptions.ExnFail = ExnFail;
|
|
exceptions.makeExnFail = ExnFail.constructor;
|
|
exceptions.isExnFail = ExnFail.predicate;
|
|
|
|
exceptions.ExnFailContract = ExnFailContract;
|
|
exceptions.makeExnFailContract = ExnFailContract.constructor;
|
|
exceptions.isExnFailContract = ExnFailContract.predicate;
|
|
|
|
exceptions.ExnFailContractArity = ExnFailContractArity;
|
|
exceptions.makeExnFailContractArity = ExnFailContractArity.constructor;
|
|
exceptions.isExnFailContractArity = ExnFailContractArity.predicate;
|
|
|
|
exceptions.ExnFailContractVariable = ExnFailContractVariable;
|
|
exceptions.makeExnFailContractVariable = ExnFailContractVariable.constructor;
|
|
exceptions.isExnFailContractVariable = ExnFailContractVariable.predicate;
|
|
exceptions.exnFailContractVariableId =
|
|
function(exn) { return ExnFailContractVariable.accessor(exn, 0); };
|
|
|
|
|
|
exceptions.ExnFailContractDivisionByZero = ExnFailContractDivisionByZero;
|
|
exceptions.makeExnFailContractDivisionByZero =
|
|
ExnFailContractDivisionByZero.constructor;
|
|
exceptions.isExnFailContractDivisionByZero = ExnFailContractDivisionByZero.predicate;
|
|
|
|
|
|
exceptions.exceptionHandlerKey = exceptionHandlerKey;
|
|
|
|
|
|
|
|
|
|
exceptions.raise = raise;
|
|
exceptions.raiseUnboundToplevelError = raiseUnboundToplevelError;
|
|
exceptions.raiseArgumentTypeError = raiseArgumentTypeError;
|
|
exceptions.raiseContextExpectedValuesError = raiseContextExpectedValuesError;
|
|
exceptions.raiseArityMismatchError = raiseArityMismatchError;
|
|
exceptions.raiseOperatorApplicationError = raiseOperatorApplicationError;
|
|
exceptions.raiseOperatorIsNotClosure = raiseOperatorIsNotClosure;
|
|
exceptions.raiseOperatorIsNotPrimitiveProcedure = raiseOperatorIsNotPrimitiveProcedure;
|
|
exceptions.raiseUnimplementedPrimitiveError = raiseUnimplementedPrimitiveError;
|
|
|
|
|
|
})(this['plt'].baselib);// Arity structure
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.readergraph = exports;
|
|
|
|
|
|
var readerGraph = function(x, objectHash, n) {
|
|
if (typeof(x) === 'object' && objectHash.containsKey(x)) {
|
|
return objectHash.get(x);
|
|
}
|
|
|
|
if (plt.baselib.lists.isPair(x)) {
|
|
var consPair = plt.baselib.lists.makePair(x.first, x.rest);
|
|
objectHash.put(x, consPair);
|
|
consPair.first = readerGraph(x.first, objectHash, n+1);
|
|
consPair.rest = readerGraph(x.rest, objectHash, n+1);
|
|
return consPair;
|
|
}
|
|
|
|
if (plt.baselib.vectors.isVector(x)) {
|
|
var len = x.length();
|
|
var aVector = plt.baselib.vectors.makeVector(len, x.elts);
|
|
objectHash.put(x, aVector);
|
|
for (var i = 0; i < len; i++) {
|
|
aVector.elts[i] = readerGraph(aVector.elts[i], objectHash, n+1);
|
|
}
|
|
return aVector;
|
|
}
|
|
|
|
if (plt.baselib.boxes.isBox(x)) {
|
|
var aBox = plt.baselib.boxes.makeBox(x.ref());
|
|
objectHash.put(x, aBox);
|
|
aBox.val = readerGraph(x.ref(), objectHash, n+1);
|
|
return aBox;
|
|
}
|
|
|
|
if (plt.baselib.hashes.isHash(x)) {
|
|
throw new Error("make-reader-graph of hash not implemented yet");
|
|
}
|
|
|
|
if (plt.baselib.structs.isStruct(x)) {
|
|
var aStruct = baselib.clone(x);
|
|
objectHash.put(x, aStruct);
|
|
for(var i = 0 ;i < x._fields.length; i++) {
|
|
x._fields[i] = readerGraph(x._fields[i], objectHash, n+1);
|
|
}
|
|
return aStruct;
|
|
}
|
|
|
|
if (plt.baselib.placeholders.isPlaceholder(x)) {
|
|
return readerGraph(x.ref(), objectHash, n+1);
|
|
}
|
|
|
|
return x;
|
|
};
|
|
|
|
exports.readerGraph = readerGraph;
|
|
|
|
})(this['plt'].baselib);// Helper functions for argument checking.
|
|
|
|
(function(baselib) {
|
|
var exports = {};
|
|
baselib.check = exports;
|
|
|
|
var EMPTY = plt.baselib.lists.EMPTY;
|
|
var isPair = plt.baselib.lists.isPair;
|
|
var makeLowLevelEqHash = plt.baselib.hashes.makeLowLevelEqHash;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
var makeCheckArgumentType = function(predicate, predicateName) {
|
|
return function(MACHINE, callerName, position) {
|
|
testArgument(
|
|
MACHINE,
|
|
predicateName,
|
|
predicate,
|
|
MACHINE.env[MACHINE.env.length - 1 - position],
|
|
position,
|
|
callerName);
|
|
return MACHINE.env[MACHINE.env.length - 1 - position];
|
|
}
|
|
};
|
|
|
|
var makeCheckParameterizedArgumentType = function(parameterizedPredicate,
|
|
parameterizedPredicateName) {
|
|
return function(MACHINE, callerName, position) {
|
|
var args = [];
|
|
for (var i = 3; i < arguments.length; i++) {
|
|
args.push(arguments[i]);
|
|
}
|
|
testArgument(
|
|
MACHINE,
|
|
parameterizedPredicateName.apply(null, args),
|
|
function(x) {
|
|
return parameterizedPredicate.apply(null, [x].concat(args));
|
|
},
|
|
MACHINE.env[MACHINE.env.length - 1 - position],
|
|
position,
|
|
callerName);
|
|
return MACHINE.env[MACHINE.env.length - 1 - position];
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
var makeCheckListofArgumentType = function(predicate, predicateName) {
|
|
var listPredicate = function(x) {
|
|
var seen = makeLowLevelEqHash();
|
|
while (true) {
|
|
if (x === EMPTY){
|
|
return true;
|
|
}
|
|
|
|
if (!isPair(x)) {
|
|
return false;
|
|
}
|
|
|
|
if(seen.containsKey(x)) {
|
|
// raise an error? we've got a cycle!
|
|
return false
|
|
}
|
|
|
|
if (! predicate(x.first)) {
|
|
return false;
|
|
}
|
|
|
|
seen.put(x, true);
|
|
x = x.rest;
|
|
}
|
|
};
|
|
return function(MACHINE, callerName, position) {
|
|
testArgument(
|
|
MACHINE,
|
|
'list of ' + predicateName,
|
|
listPredicate,
|
|
MACHINE.env[MACHINE.env.length - 1 - position],
|
|
position,
|
|
callerName);
|
|
return MACHINE.env[MACHINE.env.length - 1 - position];
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// testArgument: (X -> boolean) X number string string -> boolean
|
|
// Produces true if val is true, and otherwise raises an error.
|
|
var testArgument = function(MACHINE,
|
|
expectedTypeName,
|
|
predicate,
|
|
val,
|
|
index,
|
|
callerName) {
|
|
if (predicate(val)) {
|
|
return true;
|
|
} else {
|
|
plt.baselib.exceptions.raiseArgumentTypeError(MACHINE,
|
|
callerName,
|
|
expectedTypeName,
|
|
index,
|
|
val);
|
|
}
|
|
};
|
|
|
|
var testArity = function(callerName, observed, minimum, maximum) {
|
|
if (observed < minimum || observed > maximum) {
|
|
plt.baselib.exceptions.raise(
|
|
MACHINE, new Error(callerName + ": expected at least " + minimum
|
|
+ " arguments "
|
|
+ " but received " + observed));
|
|
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
var checkOutputPort = makeCheckArgumentType(
|
|
plt.baselib.ports.isOutputPort,
|
|
'output port');
|
|
|
|
var checkSymbol = makeCheckArgumentType(
|
|
plt.baselib.symbols.isSymbol,
|
|
'symbol');
|
|
|
|
var checkString = makeCheckArgumentType(
|
|
plt.baselib.strings.isString,
|
|
'string');
|
|
|
|
var checkProcedure = makeCheckArgumentType(
|
|
plt.baselib.functions.isProcedure,
|
|
'procedure');
|
|
|
|
var checkNumber = makeCheckArgumentType(
|
|
plt.baselib.numbers.isNumber,
|
|
'number');
|
|
|
|
var checkReal = makeCheckArgumentType(
|
|
plt.baselib.numbers.isReal,
|
|
'real');
|
|
|
|
var checkNatural = makeCheckArgumentType(
|
|
plt.baselib.numbers.isNatural,
|
|
'natural');
|
|
|
|
var checkByte = makeCheckArgumentType(
|
|
function(x) { return (typeof(x) === 'number' && 0 <= x && x < 256) },
|
|
'byte');
|
|
|
|
var checkNaturalInRange = makeCheckParameterizedArgumentType(
|
|
function(x, a, b) {
|
|
if (! plt.baselib.numbers.isNatural(x)) { return false; }
|
|
return (plt.baselib.numbers.lessThanOrEqual(a, x) &&
|
|
plt.baselib.numbers.lessThan(x, b));
|
|
},
|
|
function(a, b) {
|
|
return plt.baselib.format.format('natural between ~a and ~a', [a, b]);
|
|
});
|
|
|
|
var checkInteger = makeCheckArgumentType(
|
|
plt.baselib.numbers.isInteger,
|
|
'integer');
|
|
|
|
var checkRational = makeCheckArgumentType(
|
|
plt.baselib.numbers.isRational,
|
|
'rational');
|
|
|
|
var checkNonNegativeReal = makeCheckArgumentType(
|
|
plt.baselib.numbers.isNonNegativeReal,
|
|
'non-negative real');
|
|
|
|
var checkPair = makeCheckArgumentType(
|
|
plt.baselib.lists.isPair,
|
|
'pair');
|
|
|
|
var checkList = makeCheckArgumentType(
|
|
plt.baselib.lists.isList,
|
|
'list');
|
|
|
|
var checkVector = makeCheckArgumentType(
|
|
plt.baselib.vectors.isVector,
|
|
'vector');
|
|
|
|
var checkBoolean = makeCheckArgumentType(
|
|
function(x) { return x === true || x === false; },
|
|
'boolean');
|
|
|
|
var checkBox = makeCheckArgumentType(
|
|
plt.baselib.boxes.isBox,
|
|
'box');
|
|
|
|
var checkMutableBox = makeCheckArgumentType(
|
|
plt.baselib.boxes.isMutableBox,
|
|
'mutable box');
|
|
|
|
var checkInspector = makeCheckArgumentType(
|
|
plt.baselib.inspectors.isInspector,
|
|
'inspector');
|
|
|
|
|
|
var checkByte = makeCheckArgumentType(
|
|
plt.baselib.numbers.isByte,
|
|
'byte');
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
exports.testArgument = testArgument;
|
|
exports.testArity = testArity;
|
|
exports.makeCheckArgumentType = makeCheckArgumentType;
|
|
exports.makeCheckParameterizedArgumentType = makeCheckParameterizedArgumentType;
|
|
exports.makeCheckListofArgumentType = makeCheckListofArgumentType;
|
|
|
|
exports.checkOutputPort = checkOutputPort;
|
|
exports.checkString = checkString;
|
|
exports.checkSymbol = checkSymbol;
|
|
exports.checkProcedure = checkProcedure;
|
|
exports.checkNumber = checkNumber;
|
|
exports.checkReal = checkReal;
|
|
exports.checkNonNegativeReal = checkNonNegativeReal;
|
|
exports.checkNatural = checkNatural;
|
|
exports.checkNaturalInRange = checkNaturalInRange;
|
|
exports.checkByte = checkByte;
|
|
exports.checkInteger = checkInteger;
|
|
exports.checkRational = checkRational;
|
|
exports.checkPair = checkPair;
|
|
exports.checkList = checkList;
|
|
exports.checkVector = checkVector;
|
|
exports.checkBox = checkBox;
|
|
exports.checkMutableBox = checkMutableBox;
|
|
exports.checkInspector = checkInspector;
|
|
exports.checkByte = checkByte;
|
|
exports.checkBoolean = checkBoolean;
|
|
|
|
|
|
|
|
})(this['plt'].baselib);
|
|
// runtime.js: the main runtime library for whalesong.
|
|
//
|
|
|
|
if(this['plt'] === undefined) { this['plt'] = {}; }
|
|
|
|
|
|
// All of the values here are namespaced under "plt.runtime".
|
|
(function(scope) {
|
|
var runtime = {};
|
|
scope['runtime'] = runtime;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
// We try to isolate the effect of external modules: all the identifiers we
|
|
// pull from external modules should be listed here, and should otherwise not
|
|
// show up outside this section!
|
|
var isNumber = plt.baselib.numbers.isNumber;
|
|
var isNatural = plt.baselib.numbers.isNatural;
|
|
var isReal = plt.baselib.numbers.isReal;
|
|
var isPair = plt.baselib.lists.isPair;
|
|
var isList = plt.baselib.lists.isList;
|
|
var isVector = plt.baselib.vectors.isVector;
|
|
var isString = plt.baselib.strings.isString;
|
|
var isSymbol = plt.baselib.symbols.isSymbol;
|
|
var isNonNegativeReal = plt.baselib.numbers.isNonNegativeReal;
|
|
var equals = plt.baselib.equality.equals;
|
|
|
|
var NULL = plt.baselib.lists.EMPTY;
|
|
var VOID = plt.baselib.constants.VOID_VALUE;
|
|
var EOF = plt.baselib.constants.EOF_VALUE;
|
|
|
|
var NEGATIVE_ZERO = plt.baselib.numbers.negative_zero;
|
|
var INF = plt.baselib.numbers.inf;
|
|
var NEGATIVE_INF = plt.baselib.numbers.negative_inf;
|
|
var NAN = plt.baselib.numbers.nan;
|
|
|
|
var makeFloat = plt.baselib.numbers.makeFloat;
|
|
var makeRational = plt.baselib.numbers.makeRational;
|
|
var makeBignum = plt.baselib.numbers.makeBignum;
|
|
var makeComplex = plt.baselib.numbers.makeComplex;
|
|
|
|
var makeSymbol = plt.baselib.symbols.makeSymbol;
|
|
|
|
var makeBox = plt.baselib.boxes.makeBox;
|
|
var isBox = plt.baselib.boxes.isBox;
|
|
|
|
var makeVector = plt.baselib.vectors.makeVector;
|
|
var makeList = plt.baselib.lists.makeList;
|
|
var makePair = plt.baselib.lists.makePair;
|
|
|
|
|
|
var Closure = plt.baselib.functions.Closure;
|
|
var finalizeClosureCall = plt.baselib.functions.finalizeClosureCall;
|
|
var makePrimitiveProcedure = plt.baselib.functions.makePrimitiveProcedure;
|
|
|
|
|
|
// Other helpers
|
|
var withArguments = plt.baselib.withArguments;
|
|
var heir = plt.baselib.heir;
|
|
var makeClassPredicate = plt.baselib.makeClassPredicate;
|
|
var toDomNode = plt.baselib.format.toDomNode;
|
|
var toWrittenString = plt.baselib.format.toWrittenString;
|
|
var toDisplayedString = plt.baselib.format.toDisplayedString;
|
|
|
|
|
|
|
|
// Frame structures.
|
|
var Frame = plt.baselib.frames.Frame;
|
|
var CallFrame = plt.baselib.frames.CallFrame;
|
|
var PromptFrame = plt.baselib.frames.PromptFrame;
|
|
|
|
// Module structure
|
|
var ModuleRecord = plt.baselib.modules.ModuleRecord;
|
|
|
|
|
|
|
|
// Ports
|
|
var OutputPort = plt.baselib.ports.OutputPort;
|
|
var isOutputPort = plt.baselib.ports.isOutputPort;
|
|
var StandardOutputPort = plt.baselib.ports.StandardOutputPort;
|
|
var StandardErrorPort = plt.baselib.ports.StandardErrorPort;
|
|
var OutputStringPort = plt.baselib.ports.OutputStringPort;
|
|
var isOutputStringPort = plt.baselib.ports.isOutputStringPort;
|
|
|
|
|
|
|
|
|
|
// Exceptions and error handling.
|
|
var raise = plt.baselib.exceptions.raise;
|
|
var raiseUnboundToplevelError = plt.baselib.exceptions.raiseUnboundToplevelError;
|
|
var raiseArgumentTypeError = plt.baselib.exceptions.raiseArgumentTypeError;
|
|
var raiseContextExpectedValuesError = plt.baselib.exceptions.raiseContextExpectedValuesError;
|
|
var raiseArityMismatchError = plt.baselib.exceptions.raiseArityMismatchError;
|
|
var raiseOperatorApplicationError = plt.baselib.exceptions.raiseOperatorApplicationError;
|
|
var raiseOperatorIsNotPrimitiveProcedure = plt.baselib.exceptions.raiseOperatorIsNotPrimitiveProcedure;
|
|
var raiseOperatorIsNotClosure = plt.baselib.exceptions.raiseOperatorIsNotClosure;
|
|
var raiseUnimplementedPrimitiveError = plt.baselib.exceptions.raiseUnimplementedPrimitiveError;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var testArgument = plt.baselib.check.testArgument;
|
|
var testArity = plt.baselib.check.testArity;
|
|
var makeCheckArgumentType = plt.baselib.check.makeCheckArgumentType;
|
|
|
|
var checkOutputPort = plt.baselib.check.checkOutputPort;
|
|
var checkString = plt.baselib.check.checkString;
|
|
var checkSymbol = plt.baselib.check.checkSymbol;
|
|
var checkByte = plt.baselib.check.checkByte;
|
|
var checkProcedure = plt.baselib.check.checkProcedure;
|
|
var checkNumber = plt.baselib.check.checkNumber;
|
|
var checkReal = plt.baselib.check.checkReal;
|
|
var checkNonNegativeReal = plt.baselib.check.checkNonNegativeReal;
|
|
var checkNatural = plt.baselib.check.checkNatural;
|
|
var checkNaturalInRange = plt.baselib.check.checkNaturalInRange;
|
|
var checkInteger = plt.baselib.check.checkInteger;
|
|
var checkRational = plt.baselib.check.checkRational;
|
|
var checkPair = plt.baselib.check.checkPair;
|
|
var checkList = plt.baselib.check.checkList;
|
|
var checkVector = plt.baselib.check.checkVector;
|
|
var checkBox = plt.baselib.check.checkBox;
|
|
var checkMutableBox = plt.baselib.check.checkMutableBox;
|
|
var checkInspector = plt.baselib.check.checkInspector;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////]
|
|
// The MACHINE
|
|
|
|
|
|
// This value will be dynamically determined.
|
|
// See findStackLimit later in this file.
|
|
var STACK_LIMIT_ESTIMATE = 100;
|
|
|
|
|
|
var Machine = function() {
|
|
this.callsBeforeTrampoline = STACK_LIMIT_ESTIMATE;
|
|
this.val = undefined;
|
|
this.proc = undefined;
|
|
this.argcount = undefined;
|
|
this.env = [];
|
|
this.control = []; // Arrayof (U Frame CallFrame PromptFrame)
|
|
this.running = false;
|
|
this.modules = {}; // String -> ModuleRecord
|
|
this.mainModules = []; // Arrayof String
|
|
this.params = {
|
|
|
|
// currentDisplayer: DomNode -> Void
|
|
// currentDisplayer is responsible for displaying to the browser.
|
|
'currentDisplayer': function(MACHINE, domNode) {
|
|
$(domNode).appendTo(document.body);
|
|
},
|
|
|
|
// currentErrorDisplayer: DomNode -> Void
|
|
// currentErrorDisplayer is responsible for displaying errors to the browser.
|
|
'currentErrorDisplayer': function(MACHINE, domNode) {
|
|
$(domNode).appendTo(document.body);
|
|
},
|
|
|
|
'currentInspector': plt.baselib.inspectors.DEFAULT_INSPECTOR,
|
|
|
|
'currentOutputPort': new StandardOutputPort(),
|
|
'currentErrorPort': new StandardErrorPort(),
|
|
'currentSuccessHandler': function(MACHINE) {},
|
|
'currentErrorHandler': function(MACHINE, exn) {
|
|
MACHINE.params.currentErrorDisplayer(
|
|
MACHINE,
|
|
toDomNode(exn));
|
|
},
|
|
|
|
'currentNamespace': {},
|
|
|
|
// These parameters control how often
|
|
// control yields back to the browser
|
|
// for response. The implementation is a
|
|
// simple PID controller.
|
|
//
|
|
// To tune this, adjust desiredYieldsPerSecond.
|
|
// Do no touch numBouncesBeforeYield or
|
|
// maxNumBouncesBeforeYield, because those
|
|
// are adjusted automatically by the
|
|
// recomputeMaxNumBouncesBeforeYield
|
|
// procedure.
|
|
'desiredYieldsPerSecond': 5,
|
|
'numBouncesBeforeYield': 2000, // self-adjusting
|
|
'maxNumBouncesBeforeYield': 2000, // self-adjusting
|
|
|
|
'currentPrint': defaultCurrentPrint
|
|
|
|
|
|
};
|
|
this.primitives = Primitives;
|
|
};
|
|
|
|
|
|
|
|
|
|
// Approximately find the stack limit.
|
|
// This function assumes, on average, five variables or
|
|
// temporaries per stack frame.
|
|
// This will never report a number greater than MAXIMUM_CAP.
|
|
var findStackLimit = function(after) {
|
|
var MAXIMUM_CAP = 32768;
|
|
var n = 1;
|
|
var limitDiscovered = false;
|
|
setTimeout(
|
|
function() {
|
|
if(! limitDiscovered) {
|
|
limitDiscovered = true;
|
|
after(n);
|
|
}
|
|
},
|
|
0);
|
|
var loop1 = function(x, y, z, w, k) {
|
|
// Ensure termination, just in case JavaScript ever
|
|
// does eliminate stack limits.
|
|
if (n >= MAXIMUM_CAP) { return; }
|
|
n++;
|
|
return 1 + loop2(y, z, w, k, x);
|
|
};
|
|
var loop2 = function(x, y, z, w, k) {
|
|
n++;
|
|
return 1 + loop1(y, z, w, k, x);
|
|
};
|
|
try {
|
|
var dontCare = 1 + loop1(2, "seven", [1], {number: 8}, 2);
|
|
} catch (e) {
|
|
// ignore exceptions.
|
|
}
|
|
if (! limitDiscovered) {
|
|
limitDiscovered = true;
|
|
after(n);
|
|
}
|
|
};
|
|
|
|
|
|
// Schedule a stack limit estimation. If it fails, no harm, no
|
|
// foul (hopefully!)
|
|
setTimeout(function() {
|
|
findStackLimit(function(v) {
|
|
// Trying to be a little conservative.
|
|
STACK_LIMIT_ESTIMATE = Math.floor(v / 10);
|
|
});
|
|
},
|
|
0);
|
|
|
|
|
|
// captureControl implements the continuation-capturing part of
|
|
// call/cc. It grabs the control frames up to (but not including) the
|
|
// prompt tagged by the given tag.
|
|
var captureControl = function(MACHINE, skip, tag) {
|
|
var i;
|
|
for (i = MACHINE.control.length - 1 - skip; i >= 0; i--) {
|
|
if (MACHINE.control[i].tag === tag) {
|
|
return MACHINE.control.slice(i + 1,
|
|
MACHINE.control.length - skip);
|
|
}
|
|
}
|
|
raise(MACHINE, new Error("captureControl: unable to find tag " + tag));
|
|
};
|
|
|
|
|
|
|
|
// restoreControl clears the control stack (up to, but not including the
|
|
// prompt tagged by tag), and then appends the rest of the control frames.
|
|
// At the moment, the rest of the control frames is assumed to be in the
|
|
// top of the environment.
|
|
var restoreControl = function(MACHINE, tag) {
|
|
var i;
|
|
for (i = MACHINE.control.length - 1; i >= 0; i--) {
|
|
if (MACHINE.control[i].tag === tag) {
|
|
MACHINE.control =
|
|
MACHINE.control.slice(0, i+1).concat(
|
|
MACHINE.env[MACHINE.env.length - 1]);
|
|
return;
|
|
}
|
|
}
|
|
raise(MACHINE, new Error("restoreControl: unable to find tag " + tag));
|
|
|
|
};
|
|
|
|
|
|
// Splices the list argument in the environment. Adjusts MACHINE.argcount
|
|
// appropriately.
|
|
var spliceListIntoStack = function(MACHINE, depth) {
|
|
var lst = MACHINE.env[MACHINE.env.length - 1 - depth];
|
|
var vals = [];
|
|
while(lst !== NULL) {
|
|
vals.push(lst.first);
|
|
lst = lst.rest;
|
|
}
|
|
vals.reverse();
|
|
MACHINE.env.splice.apply(MACHINE.env,
|
|
[MACHINE.env.length - 1 - depth, 1].concat(vals));
|
|
MACHINE.argcount = MACHINE.argcount + vals.length - 1;
|
|
};
|
|
|
|
|
|
// Unsplices a list from the MACHINE stack.
|
|
var unspliceRestFromStack = function(MACHINE, depth, length) {
|
|
var lst = NULL;
|
|
var i;
|
|
for (i = 0; i < length; i++) {
|
|
lst = makePair(MACHINE.env[MACHINE.env.length - depth - length + i],
|
|
lst);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - depth - length,
|
|
length,
|
|
lst);
|
|
MACHINE.argcount = MACHINE.argcount - length + 1;
|
|
};
|
|
|
|
|
|
|
|
// recomputeGas: state number -> number
|
|
var recomputeMaxNumBouncesBeforeYield = function(MACHINE, observedDelay) {
|
|
// We'd like to see a delay of DESIRED_DELAY_BETWEEN_BOUNCES so
|
|
// that we get MACHINE.params.desiredYieldsPerSecond bounces per
|
|
// second.
|
|
var DESIRED_DELAY_BETWEEN_BOUNCES =
|
|
(1000 / MACHINE.params.desiredYieldsPerSecond);
|
|
var ALPHA = 50;
|
|
var delta = (ALPHA * ((DESIRED_DELAY_BETWEEN_BOUNCES -
|
|
observedDelay) /
|
|
DESIRED_DELAY_BETWEEN_BOUNCES));
|
|
MACHINE.params.maxNumBouncesBeforeYield =
|
|
Math.max(MACHINE.params.maxNumBouncesBeforeYield + delta,
|
|
1);
|
|
};
|
|
|
|
|
|
var HaltError = function(onHalt) {
|
|
// onHalt: MACHINE -> void
|
|
this.onHalt = onHalt || function(MACHINE) {};
|
|
};
|
|
|
|
|
|
var Pause = function(onPause) {
|
|
// onPause: MACHINE -> void
|
|
this.onPause = onPause || function(MACHINE) {};
|
|
};
|
|
|
|
var PAUSE = function(onPause) {
|
|
throw(new Pause(onPause));
|
|
};
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
// The toplevel trampoline.
|
|
//
|
|
//
|
|
// trampoline: MACHINE (MACHINE -> void) -> void
|
|
//
|
|
// All evaluation in Racketland happens in the context of this
|
|
// trampoline.
|
|
//
|
|
var trampoline = function(MACHINE, initialJump) {
|
|
var thunk = initialJump;
|
|
var startTime = (new Date()).valueOf();
|
|
MACHINE.callsBeforeTrampoline = STACK_LIMIT_ESTIMATE;
|
|
MACHINE.params.numBouncesBeforeYield =
|
|
MACHINE.params.maxNumBouncesBeforeYield;
|
|
MACHINE.running = true;
|
|
|
|
while(true) {
|
|
try {
|
|
thunk(MACHINE);
|
|
break;
|
|
} catch (e) {
|
|
// There are a few kinds of things that can get thrown
|
|
// during racket evaluation:
|
|
//
|
|
// functions: this gets thrown if the Racket code
|
|
// realizes that the number of bounces has grown too
|
|
// large. The thrown function represents a restarter
|
|
// function. The running flag remains true.
|
|
//
|
|
// Pause: causes the machine evaluation to pause, with
|
|
// the expectation that it will restart momentarily.
|
|
// The running flag on the machine will remain true.
|
|
//
|
|
// HaltError: causes evaluation to immediately halt.
|
|
// We schedule the onHalt function of the HaltError to
|
|
// call afterwards. The running flag on the machine
|
|
// is set to false.
|
|
//
|
|
// Everything else: otherwise, we send the exception value
|
|
// to the current error handler and exit.
|
|
// The running flag is set to false.
|
|
if (typeof(e) === 'function') {
|
|
thunk = e;
|
|
MACHINE.callsBeforeTrampoline = STACK_LIMIT_ESTIMATE;
|
|
|
|
if (MACHINE.params.numBouncesBeforeYield-- < 0) {
|
|
recomputeMaxNumBouncesBeforeYield(
|
|
MACHINE,
|
|
(new Date()).valueOf() - startTime);
|
|
setTimeout(
|
|
function() {
|
|
trampoline(MACHINE, thunk);
|
|
},
|
|
0);
|
|
return;
|
|
} else {
|
|
continue;
|
|
}
|
|
} else if (e instanceof Pause) {
|
|
var restart = function(thunk) {
|
|
setTimeout(
|
|
function() { trampoline(MACHINE, thunk); },
|
|
0);
|
|
};
|
|
e.onPause(restart);
|
|
return;
|
|
} else if (e instanceof HaltError) {
|
|
MACHINE.running = false;
|
|
e.onHalt(MACHINE);
|
|
return;
|
|
} else {
|
|
// General error condition: just exit out
|
|
// of the trampoline and call the current error handler.
|
|
MACHINE.running = false;
|
|
MACHINE.params.currentErrorHandler(MACHINE, e);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
MACHINE.running = false;
|
|
setTimeout(
|
|
function() { MACHINE.params.currentSuccessHandler(MACHINE); },
|
|
0);
|
|
return;
|
|
};
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var defaultCurrentPrint = new Closure(
|
|
function(MACHINE) {
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw arguments.callee;
|
|
}
|
|
var oldArgcount = MACHINE.argcount;
|
|
|
|
var elt = MACHINE.env[MACHINE.env.length - 1];
|
|
var outputPort =
|
|
MACHINE.params.currentOutputPort;
|
|
if (elt !== VOID) {
|
|
outputPort.writeDomNode(MACHINE, toDomNode(elt, 'print'));
|
|
outputPort.writeDomNode(MACHINE, toDomNode("\n", 'display'));
|
|
}
|
|
MACHINE.argcount = oldArgcount;
|
|
return finalizeClosureCall(MACHINE, VOID);
|
|
},
|
|
1,
|
|
[],
|
|
"printer");
|
|
|
|
|
|
|
|
|
|
|
|
var VariableReference = function(prefix, pos) {
|
|
this.prefix = prefix;
|
|
this.pos = pos;
|
|
};
|
|
|
|
|
|
|
|
// A continuation prompt tag labels a prompt frame.
|
|
var ContinuationPromptTag = function(name) {
|
|
this.name = name;
|
|
};
|
|
|
|
|
|
|
|
// There is a single, distinguished default continuation prompt tag
|
|
// that's used to wrap around toplevel prompts.
|
|
var DEFAULT_CONTINUATION_PROMPT_TAG =
|
|
new ContinuationPromptTag("default-continuation-prompt-tag");
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Primitives are the set of primitive values. Not all primitives
|
|
// are coded here; several of them (including call/cc) are injected by
|
|
// the bootstrapping code in compiler/boostrapped-primitives.rkt
|
|
var Primitives = {};
|
|
|
|
var installPrimitiveProcedure = function(name, arity, f) {
|
|
Primitives[name] = f;
|
|
Primitives[name].arity = arity;
|
|
Primitives[name].displayName = name;
|
|
};
|
|
|
|
var installPrimitiveClosure = function(name, arity, f) {
|
|
Primitives[name] =
|
|
new Closure(f, arity, [], name);
|
|
};
|
|
|
|
|
|
var installPrimitiveConstant = function(name, v) {
|
|
Primitives[name] = v;
|
|
};
|
|
|
|
|
|
|
|
installPrimitiveConstant('pi', plt.baselib.numbers.pi);
|
|
installPrimitiveConstant('e', plt.baselib.numbers.e);
|
|
installPrimitiveConstant('null', NULL);
|
|
installPrimitiveConstant('true', true);
|
|
installPrimitiveConstant('false', false);
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'display', makeList(1, 2),
|
|
function(MACHINE) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var outputPort = MACHINE.params.currentOutputPort;
|
|
if (MACHINE.argcount === 2) {
|
|
outputPort = checkOutputPort(MACHINE, 'display', 1);
|
|
}
|
|
outputPort.writeDomNode(MACHINE, toDomNode(firstArg, 'display'));
|
|
return VOID;
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'write-byte', makeList(1, 2),
|
|
function(MACHINE) {
|
|
var firstArg = checkByte(MACHINE, 'write-byte', 0);
|
|
var outputPort = MACHINE.params.currentOutputPort;
|
|
if (MACHINE.argcount === 2) {
|
|
outputPort = checkOutputPort(MACHINE, 'display', 1);
|
|
}
|
|
outputPort.writeDomNode(MACHINE, toDomNode(String.fromCharCode(firstArg), 'display'));
|
|
return VOID;
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'newline', makeList(0, 1),
|
|
function(MACHINE) {
|
|
var outputPort = MACHINE.params.currentOutputPort;
|
|
if (MACHINE.argcount === 1) {
|
|
outputPort = checkOutputPort(MACHINE, 'newline', 1);
|
|
}
|
|
outputPort.writeDomNode(MACHINE, toDomNode("\n", 'display'));
|
|
return VOID;
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'displayln',
|
|
makeList(1, 2),
|
|
function(MACHINE){
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var outputPort = MACHINE.params.currentOutputPort;
|
|
if (MACHINE.argcount === 2) {
|
|
outputPort = checkOutputPort(MACHINE, 'displayln', 1);
|
|
}
|
|
outputPort.writeDomNode(MACHINE, toDomNode(firstArg, 'display'));
|
|
outputPort.writeDomNode(MACHINE, toDomNode("\n", 'display'));
|
|
return VOID;
|
|
});
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'format',
|
|
plt.baselib.arity.makeArityAtLeast(1),
|
|
function(MACHINE) {
|
|
var args = [], i, formatString;
|
|
formatString = checkString(MACHINE, 'format', 0).toString();
|
|
for(i = 1; i < MACHINE.argcount; i++) {
|
|
args.push(MACHINE.env[MACHINE.env.length - 1 - i]);
|
|
}
|
|
return plt.baselib.format.format(formatString, args, 'format');
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'printf',
|
|
plt.baselib.arity.makeArityAtLeast(1),
|
|
function(MACHINE) {
|
|
var args = [], i, formatString, result, outputPort;
|
|
formatString = checkString(MACHINE, 'printf', 0).toString();
|
|
for(i = 1; i < MACHINE.argcount; i++) {
|
|
args.push(MACHINE.env[MACHINE.env.length - 1 - i]);
|
|
}
|
|
result = plt.baselib.format.format(formatString, args, 'format');
|
|
outputPort = MACHINE.params.currentOutputPort;
|
|
outputPort.writeDomNode(MACHINE, toDomNode(result, 'display'));
|
|
return VOID;
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'fprintf',
|
|
plt.baselib.arity.makeArityAtLeast(2),
|
|
function(MACHINE) {
|
|
var args = [], i, formatString, outputPort, result;
|
|
outputPort = checkOutputPort(MACHINE, 'fprintf', 0);
|
|
formatString = checkString(MACHINE, 'fprintf', 1).toString();
|
|
for(i = 2; i < MACHINE.argcount; i++) {
|
|
args.push(MACHINE.env[MACHINE.env.length - 1 - i]);
|
|
}
|
|
result = plt.baselib.format.format(formatString, args, 'format');
|
|
outputPort.writeDomNode(MACHINE, toDomNode(result, 'display'));
|
|
return VOID;
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'current-print',
|
|
makeList(0, 1),
|
|
function(MACHINE) {
|
|
if (MACHINE.argcount === 1) {
|
|
MACHINE.params['currentPrint'] =
|
|
checkProcedure(MACHINE, 'current-print', 0);
|
|
return VOID;
|
|
} else {
|
|
return MACHINE.params['currentPrint'];
|
|
}
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'current-output-port',
|
|
makeList(0, 1),
|
|
function(MACHINE) {
|
|
if (MACHINE.argcount === 1) {
|
|
MACHINE.params['currentOutputPort'] =
|
|
checkOutputPort(MACHINE, 'current-output-port', 0);
|
|
return VOID;
|
|
} else {
|
|
return MACHINE.params['currentOutputPort'];
|
|
}
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'=',
|
|
plt.baselib.arity.makeArityAtLeast(2),
|
|
function(MACHINE) {
|
|
var firstArg = checkNumber(MACHINE, '=', 0), secondArg;
|
|
for (var i = 1; i < MACHINE.argcount; i++) {
|
|
var secondArg = checkNumber(MACHINE, '=', i);
|
|
if (! (plt.baselib.numbers.equals(firstArg, secondArg))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'=~',
|
|
3,
|
|
function(MACHINE) {
|
|
var x = checkReal(MACHINE, '=~', 0);
|
|
var y = checkReal(MACHINE, '=~', 1);
|
|
var range = checkNonNegativeReal(MACHINE, '=~', 2);
|
|
return plt.baselib.numbers.lessThanOrEqual(
|
|
plt.baselib.numbers.abs(plt.baselib.numbers.subtract(x, y)),
|
|
range);
|
|
});
|
|
|
|
|
|
|
|
var makeChainingBinop = function(predicate, name) {
|
|
return function(MACHINE) {
|
|
var firstArg = checkNumber(MACHINE, name, 0), secondArg;
|
|
for (var i = 1; i < MACHINE.argcount; i++) {
|
|
secondArg = checkNumber(MACHINE, name, i);
|
|
if (! (predicate(firstArg, secondArg))) {
|
|
return false;
|
|
}
|
|
firstArg = secondArg;
|
|
}
|
|
return true;
|
|
};
|
|
};
|
|
|
|
installPrimitiveProcedure(
|
|
'<',
|
|
plt.baselib.arity.makeArityAtLeast(2),
|
|
makeChainingBinop(plt.baselib.numbers.lessThan, '<'));
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'>',
|
|
plt.baselib.arity.makeArityAtLeast(2),
|
|
makeChainingBinop(plt.baselib.numbers.greaterThan, '>'));
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'<=',
|
|
plt.baselib.arity.makeArityAtLeast(2),
|
|
makeChainingBinop(plt.baselib.numbers.lessThanOrEqual, '<='));
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'>=',
|
|
plt.baselib.arity.makeArityAtLeast(2),
|
|
makeChainingBinop(plt.baselib.numbers.greaterThanOrEqual, '>='));
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'+',
|
|
plt.baselib.arity.makeArityAtLeast(0),
|
|
function(MACHINE) {
|
|
var result = 0;
|
|
var i = 0;
|
|
for (i = 0; i < MACHINE.argcount; i++) {
|
|
result = plt.baselib.numbers.add(
|
|
result,
|
|
checkNumber(MACHINE, '+', i));
|
|
};
|
|
return result;
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'*',
|
|
plt.baselib.arity.makeArityAtLeast(0),
|
|
function(MACHINE) {
|
|
var result = 1;
|
|
var i = 0;
|
|
for (i=0; i < MACHINE.argcount; i++) {
|
|
result = plt.baselib.numbers.multiply(
|
|
result,
|
|
checkNumber(MACHINE, '*', i));
|
|
}
|
|
return result;
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'-',
|
|
plt.baselib.arity.makeArityAtLeast(1),
|
|
function(MACHINE) {
|
|
if (MACHINE.argcount === 1) {
|
|
return plt.baselib.numbers.subtract(
|
|
0,
|
|
checkNumber(MACHINE, '-', 0));
|
|
}
|
|
var result = checkNumber(MACHINE, '-', 0);
|
|
for (var i = 1; i < MACHINE.argcount; i++) {
|
|
result = plt.baselib.numbers.subtract(
|
|
result,
|
|
checkNumber(MACHINE, '-', i));
|
|
}
|
|
return result;
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'/',
|
|
plt.baselib.arity.makeArityAtLeast(1),
|
|
function(MACHINE) {
|
|
var result = checkNumber(MACHINE, '/', 0);
|
|
for (var i = 1; i < MACHINE.argcount; i++) {
|
|
result = plt.baselib.numbers.divide(
|
|
result,
|
|
checkNumber(MACHINE, '/', i));
|
|
}
|
|
return result;
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'add1',
|
|
1,
|
|
function(MACHINE) {
|
|
var firstArg = checkNumber(MACHINE, 'add1', 0);
|
|
return plt.baselib.numbers.add(firstArg, 1);
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'sub1',
|
|
1,
|
|
function(MACHINE) {
|
|
var firstArg = checkNumber(MACHINE, 'sub1', 0);
|
|
return plt.baselib.numbers.subtract(firstArg, 1);
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'zero?',
|
|
1,
|
|
function(MACHINE) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return plt.baselib.numbers.equals(firstArg, 0);
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'cons',
|
|
2,
|
|
function(MACHINE) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
return makePair(firstArg, secondArg);
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'list',
|
|
plt.baselib.arity.makeArityAtLeast(0),
|
|
function(MACHINE) {
|
|
var result = NULL;
|
|
for (var i = 0; i < MACHINE.argcount; i++) {
|
|
result = makePair(MACHINE.env[MACHINE.env.length - (MACHINE.argcount - i)],
|
|
result);
|
|
}
|
|
return result;
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'list-ref',
|
|
2,
|
|
function(MACHINE) {
|
|
var lst = checkList(MACHINE, 'list-ref', 0);
|
|
var index = checkNaturalInRange(MACHINE, 'list-ref', 1,
|
|
0, plt.baselib.lists.length(lst));
|
|
return plt.baselib.lists.listRef(lst, plt.baselib.numbers.toFixnum(index));
|
|
});
|
|
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'car',
|
|
1,
|
|
function(MACHINE) {
|
|
var firstArg = checkPair(MACHINE, 'car', 0);
|
|
return firstArg.first;
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'cdr',
|
|
1,
|
|
function(MACHINE) {
|
|
var firstArg = checkPair(MACHINE, 'cdr', 0);
|
|
return firstArg.rest;
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'pair?',
|
|
1,
|
|
function(MACHINE) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return isPair(firstArg);
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'set-car!',
|
|
2,
|
|
function(MACHINE) {
|
|
var firstArg = checkPair(MACHINE, 'set-car!', 0);
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
firstArg.first = secondArg;
|
|
return VOID;
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'set-cdr!',
|
|
2,
|
|
function(MACHINE) {
|
|
var firstArg = checkPair(MACHINE, 'set-car!', 0);
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
firstArg.rest = secondArg;
|
|
return VOID;
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'not',
|
|
1,
|
|
function(MACHINE) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return (firstArg === false);
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'null?',
|
|
1,
|
|
function(MACHINE) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return firstArg === NULL;
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'vector',
|
|
plt.baselib.arity.makeArityAtLeast(0),
|
|
function(MACHINE) {
|
|
var i;
|
|
var result = [];
|
|
for (i = 0; i < MACHINE.argcount; i++) {
|
|
result.push(MACHINE.env[MACHINE.env.length-1-i]);
|
|
}
|
|
var newVector = makeVector.apply(null, result);
|
|
return newVector;
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'vector->list',
|
|
1,
|
|
function(MACHINE) {
|
|
var elts = checkVector(MACHINE, 'vector->list', 0).elts;
|
|
var i;
|
|
var result = NULL;
|
|
for (i = 0; i < elts.length; i++) {
|
|
result = makePair(elts[elts.length - 1 - i], result);
|
|
}
|
|
return result;
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'list->vector',
|
|
1,
|
|
function(MACHINE) {
|
|
var firstArg = checkList(MACHINE, 'list->vector', 0);
|
|
var result = [];
|
|
while (firstArg !== NULL) {
|
|
result.push(firstArg.first);
|
|
firstArg = firstArg.rest;
|
|
}
|
|
return makeVector.apply(null, result);
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'vector-ref',
|
|
2,
|
|
function(MACHINE) {
|
|
var elts = checkVector(MACHINE, 'vector-ref', 0).elts;
|
|
var index = MACHINE.env[MACHINE.env.length-2];
|
|
return elts[index];
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'vector-set!',
|
|
3,
|
|
function(MACHINE) {
|
|
var elts = checkVector(MACHINE, 'vector-set!', 0).elts;
|
|
// FIXME: check out-of-bounds vector
|
|
var index = plt.baselib.numbers.toFixnum(
|
|
checkNaturalInRange(MACHINE, 'vector-set!', 1,
|
|
0, elts.length));
|
|
var val = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
elts[index] = val;
|
|
return VOID;
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'vector-length',
|
|
1,
|
|
function(MACHINE) {
|
|
return checkVector(MACHINE, 'vector-length', 0).elts.length;
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'make-vector',
|
|
makeList(1, 2),
|
|
function(MACHINE) {
|
|
var value = 0;
|
|
var length = plt.baselib.numbers.toFixnum(
|
|
checkNatural(MACHINE, 'make-vector', 0));
|
|
if (MACHINE.argcount == 2) {
|
|
value = MACHINE.env[MACHINE.env.length - 2];
|
|
}
|
|
var arr = [];
|
|
for(var i = 0; i < length; i++) {
|
|
arr[i] = value;
|
|
}
|
|
return makeVector.apply(null, arr);
|
|
});
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'symbol?',
|
|
1,
|
|
function(MACHINE) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return isSymbol(firstArg);
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'symbol->string',
|
|
1,
|
|
function(MACHINE) {
|
|
var firstArg = checkSymbol(MACHINE, 'symbol->string', 0);
|
|
return firstArg.toString();
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'string=?',
|
|
plt.baselib.arity.makeArityAtLeast(1),
|
|
function(MACHINE) {
|
|
var s = checkString(MACHINE, 'string=?', 0).toString();
|
|
for (var i = 1; i < MACHINE.argcount; i++) {
|
|
if (checkString(MACHINE, 'string=?', i).toString() !== s) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'string-append',
|
|
plt.baselib.arity.makeArityAtLeast(0),
|
|
function(MACHINE) {
|
|
var buffer = [];
|
|
var i;
|
|
for (i = 0; i < MACHINE.argcount; i++) {
|
|
buffer.push(checkString(MACHINE, 'string-append', i).toString());
|
|
}
|
|
return buffer.join('');
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'string-length',
|
|
1,
|
|
function(MACHINE) {
|
|
var firstArg = checkString(MACHINE, 'string-length', 0).toString();
|
|
return firstArg.length;
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'box',
|
|
1,
|
|
function(MACHINE) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return makeBox(firstArg);
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'unbox',
|
|
1,
|
|
function(MACHINE) {
|
|
var firstArg = checkBox(MACHINE, 'unbox', 0);
|
|
return firstArg.ref();
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'set-box!',
|
|
2,
|
|
function(MACHINE) {
|
|
var firstArg = checkMutableBox(MACHINE, 'set-box!', 0);
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
firstArg.set(secondArg);
|
|
return VOID;
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'void',
|
|
plt.baselib.arity.makeArityAtLeast(0),
|
|
function(MACHINE) {
|
|
return VOID;
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'random',
|
|
plt.baselib.lists.makeList(0, 1),
|
|
function(MACHINE) {
|
|
if (MACHINE.argcount === 0) {
|
|
return plt.baselib.numbers.makeFloat(Math.random());
|
|
} else {
|
|
var n = checkNatural(MACHINE, 'random', 0);
|
|
return Math.floor(Math.random() * plt.baselib.numbers.toFixnum(n));
|
|
}
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'eq?',
|
|
2,
|
|
function(MACHINE) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
return firstArg === secondArg;
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'equal?',
|
|
2,
|
|
function(MACHINE) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
return equals(firstArg, secondArg);
|
|
});
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'member',
|
|
2,
|
|
function(MACHINE) {
|
|
var x = MACHINE.env[MACHINE.env.length-1];
|
|
var lst = MACHINE.env[MACHINE.env.length-2];
|
|
var originalLst = lst;
|
|
while (true) {
|
|
if (lst === NULL) {
|
|
return false;
|
|
}
|
|
if (! isPair(lst)) {
|
|
raiseArgumentTypeError(MACHINE,
|
|
'member',
|
|
'list',
|
|
1,
|
|
MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
}
|
|
if (equals(x, (lst.first))) {
|
|
return lst;
|
|
}
|
|
lst = lst.rest;
|
|
}
|
|
});
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'reverse',
|
|
1,
|
|
function(MACHINE) {
|
|
var rev = NULL;
|
|
var lst = MACHINE.env[MACHINE.env.length-1];
|
|
while(lst !== NULL) {
|
|
testArgument(MACHINE,
|
|
'pair', isPair, lst, 0, 'reverse');
|
|
rev = makePair(lst.first, rev);
|
|
lst = lst.rest;
|
|
}
|
|
return rev;
|
|
});
|
|
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'abs',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.abs(
|
|
checkNumber(MACHINE, 'abs', 0));
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'acos',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.acos(
|
|
checkNumber(MACHINE, 'acos', 0));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'asin',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.asin(
|
|
checkNumber(MACHINE, 'asin', 0));
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'sin',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.sin(
|
|
checkNumber(MACHINE, 'sin', 0));
|
|
});
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'sinh',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.sinh(
|
|
checkNumber(MACHINE, 'sinh', 0));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'tan',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.tan(
|
|
checkNumber(MACHINE, 'tan', 0));
|
|
});
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'atan',
|
|
makeList(1, 2),
|
|
function(MACHINE) {
|
|
if (MACHINE.argcount === 1) {
|
|
return plt.baselib.numbers.atan(
|
|
checkNumber(MACHINE, 'atan', 0));
|
|
} else {
|
|
testArgument(MACHINE,
|
|
'number',
|
|
isNumber,
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
0,
|
|
'atan');
|
|
testArgument(MACHINE,
|
|
'number',
|
|
isNumber,
|
|
MACHINE.env[MACHINE.env.length - 2],
|
|
1,
|
|
'atan');
|
|
return plt.baselib.numbers.makeFloat(
|
|
Math.atan2(
|
|
plt.baselib.numbers.toFixnum(checkNumber(MACHINE, 'atan', 0)),
|
|
plt.baselib.numbers.toFixnum(checkNumber(MACHINE, 'atan', 1))));
|
|
}
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'angle',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.angle(
|
|
checkNumber(MACHINE, 'angle', 0));
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'magnitude',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.magnitude(
|
|
checkNumber(MACHINE, 'magnitude', 0));
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'conjugate',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.conjugate(
|
|
checkNumber(MACHINE, 'conjugate', 0));
|
|
});
|
|
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'cos',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.cos(
|
|
checkNumber(MACHINE, 'cos', 0));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'cosh',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.cosh(
|
|
checkNumber(MACHINE, 'cosh', 0));
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'gcd',
|
|
plt.baselib.arity.makeArityAtLeast(1),
|
|
function(MACHINE) {
|
|
var args = [], i, x;
|
|
for (i = 0; i < MACHINE.argcount; i++) {
|
|
args.push(checkNumber(MACHINE, 'gcd', i));
|
|
}
|
|
x = args.shift();
|
|
return plt.baselib.numbers.gcd(x, args);
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'lcm',
|
|
plt.baselib.arity.makeArityAtLeast(1),
|
|
function(MACHINE) {
|
|
var args = [], i, x;
|
|
for (i = 0; i < MACHINE.argcount; i++) {
|
|
args.push(checkNumber(MACHINE, 'lcm', i));
|
|
}
|
|
x = args.shift();
|
|
return plt.baselib.numbers.lcm(x, args);
|
|
});
|
|
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'exp',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.exp(
|
|
checkNumber(MACHINE, 'exp', 0));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'expt',
|
|
2,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.expt(
|
|
checkNumber(MACHINE, 'expt', 0),
|
|
checkNumber(MACHINE, 'expt', 1));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'exact?',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.isExact(
|
|
checkNumber(MACHINE, 'exact?', 0));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'integer?',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.isInteger(MACHINE.env[MACHINE.env.length - 1]);
|
|
});
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'imag-part',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.imaginaryPart(
|
|
checkNumber(MACHINE, 'imag-part', 0));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'real-part',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.realPart(
|
|
checkNumber(MACHINE, 'real-part', 0));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'make-polar',
|
|
2,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.makeComplexPolar(
|
|
checkReal(MACHINE, 'make-polar', 0),
|
|
checkReal(MACHINE, 'make-polar', 1));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'make-rectangular',
|
|
2,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.makeComplex(
|
|
checkReal(MACHINE, 'make-rectangular', 0),
|
|
checkReal(MACHINE, 'make-rectangular', 1));
|
|
});
|
|
|
|
installPrimitiveProcedure(
|
|
'modulo',
|
|
2,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.modulo(
|
|
checkInteger(MACHINE, 'modulo', 0),
|
|
checkInteger(MACHINE, 'modulo', 1));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'remainder',
|
|
2,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.remainder(
|
|
checkInteger(MACHINE, 'remainder', 0),
|
|
checkInteger(MACHINE, 'remainder', 1));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'quotient',
|
|
2,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.quotient(
|
|
checkInteger(MACHINE, 'quotient', 0),
|
|
checkInteger(MACHINE, 'quotient', 1));
|
|
});
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'floor',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.floor(
|
|
checkReal(MACHINE, 'floor', 0));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'ceiling',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.ceiling(
|
|
checkReal(MACHINE, 'ceiling', 0));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'round',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.round(
|
|
checkReal(MACHINE, 'round', 0));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'truncate',
|
|
1,
|
|
function(MACHINE) {
|
|
var n = checkReal(MACHINE, 'truncate', 0);
|
|
if (plt.baselib.numbers.lessThan(n, 0)) {
|
|
return plt.baselib.numbers.ceiling(n);
|
|
} else {
|
|
return plt.baselib.numbers.floor(n);
|
|
}
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'numerator',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.numerator(
|
|
checkRational(MACHINE, 'numerator', 0));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'denominator',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.denominator(
|
|
checkRational(MACHINE, 'denominator', 0));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'log',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.log(
|
|
checkNumber(MACHINE, 'log', 0));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'sqr',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.sqr(
|
|
checkNumber(MACHINE, 'sqr', 0));
|
|
});
|
|
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'sqrt',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.sqrt(
|
|
checkNumber(MACHINE, 'sqrt', 0));
|
|
});
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'integer-sqrt',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.integerSqrt(
|
|
checkInteger(MACHINE, 'integer-sqrt', 0));
|
|
});
|
|
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'sgn',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.sign(
|
|
checkInteger(MACHINE, 'sgn', 0));
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'number->string',
|
|
1,
|
|
function(MACHINE) {
|
|
return checkNumber(MACHINE, 'number->string', 0).toString();
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'string->symbol',
|
|
1,
|
|
function(MACHINE) {
|
|
return makeSymbol(checkString(MACHINE, 'string->symbol', 0).toString());
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'string->number',
|
|
1,
|
|
function(MACHINE) {
|
|
return plt.baselib.numbers.fromString(
|
|
checkString(MACHINE, 'string->number', 0).toString());
|
|
});
|
|
|
|
|
|
|
|
installPrimitiveClosure(
|
|
'make-struct-type',
|
|
makeList(4, 5, 6, 7, 8, 9, 10, 11),
|
|
function(MACHINE) {
|
|
withArguments(
|
|
MACHINE,
|
|
4,
|
|
[false,
|
|
NULL,
|
|
false,
|
|
false,
|
|
NULL,
|
|
false,
|
|
false],
|
|
function(name,
|
|
superType,
|
|
initFieldCount,
|
|
autoFieldCount,
|
|
autoV,
|
|
props, // FIXME: currently ignored
|
|
inspector, // FIXME: currently ignored
|
|
procSpec, // FIXME: currently ignored
|
|
immutables, // FIXME: currently ignored
|
|
guard, // FIXME: currently ignored
|
|
constructorName
|
|
) {
|
|
|
|
// FIXME: typechecks.
|
|
|
|
var structType = plt.baselib.structs.makeStructureType(
|
|
name,
|
|
superType,
|
|
initFieldCount,
|
|
autoFieldCount,
|
|
autoV,
|
|
//props,
|
|
//inspector,
|
|
//procSpec,
|
|
//immutables,
|
|
guard);
|
|
|
|
var constructorValue =
|
|
makePrimitiveProcedure(
|
|
constructorName,
|
|
plt.baselib.numbers.toFixnum(initFieldCount),
|
|
function(MACHINE) {
|
|
var args = [];
|
|
for(var i = 0; i < initFieldCount; i++) {
|
|
args.push(MACHINE.env[MACHINE.env.length - 1 - i]);
|
|
}
|
|
return structType.constructor.apply(null, args);
|
|
});
|
|
|
|
var predicateValue =
|
|
makePrimitiveProcedure(
|
|
String(name) + "?",
|
|
1,
|
|
function(MACHINE) {
|
|
return structType.predicate(MACHINE.env[MACHINE.env.length - 1]);
|
|
});
|
|
|
|
var accessorValue =
|
|
makePrimitiveProcedure(
|
|
String(name) + "-accessor",
|
|
2,
|
|
function(MACHINE) {
|
|
// FIXME: typechecks
|
|
return structType.accessor(
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
plt.baselib.numbers.toFixnum(MACHINE.env[MACHINE.env.length - 2]));
|
|
});
|
|
accessorValue.structType = structType;
|
|
|
|
var mutatorValue =
|
|
makePrimitiveProcedure(
|
|
String(name) + "-mutator",
|
|
3,
|
|
function(MACHINE) {
|
|
// FIXME: typechecks
|
|
return structType.mutator(
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
plt.baselib.numbers.toFixnum(MACHINE.env[MACHINE.env.length - 2]),
|
|
MACHINE.env[MACHINE.env.length - 3]);
|
|
});
|
|
mutatorValue.structType = structType;
|
|
|
|
|
|
finalizeClosureCall(MACHINE,
|
|
structType,
|
|
constructorValue,
|
|
predicateValue,
|
|
accessorValue,
|
|
mutatorValue);
|
|
});
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'current-inspector',
|
|
makeList(0, 1),
|
|
function(MACHINE) {
|
|
if (MACHINE.argcount === 1) {
|
|
MACHINE.params['currentInspector'] =
|
|
checkInspector(MACHINE, 'current-inspector', 0);
|
|
return VOID;
|
|
} else {
|
|
return MACHINE.params['currentInspector'];
|
|
}
|
|
}
|
|
);
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'make-struct-field-accessor',
|
|
makeList(2, 3),
|
|
function(MACHINE){
|
|
// FIXME: typechecks
|
|
// We must guarantee that the ref argument is good.
|
|
var structType = MACHINE.env[MACHINE.env.length - 1].structType;
|
|
var index = MACHINE.env[MACHINE.env.length - 2];
|
|
var name;
|
|
if (MACHINE.argcount === 3) {
|
|
name = String(MACHINE.env[MACHINE.env.length - 3]);
|
|
} else {
|
|
name = 'field' + index;
|
|
}
|
|
return makePrimitiveProcedure(
|
|
name,
|
|
1,
|
|
function(MACHINE) {
|
|
return structType.accessor(
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
plt.baselib.numbers.toFixnum(index));
|
|
});
|
|
|
|
});
|
|
|
|
|
|
installPrimitiveProcedure(
|
|
'make-struct-field-mutator',
|
|
makeList(2, 3),
|
|
function(MACHINE){
|
|
// FIXME: typechecks
|
|
// We must guarantee that the set! argument is good.
|
|
var structType = MACHINE.env[MACHINE.env.length - 1].structType;
|
|
var index = MACHINE.env[MACHINE.env.length - 2];
|
|
var name;
|
|
if (MACHINE.argcount === 3) {
|
|
name = String(MACHINE.env[MACHINE.env.length - 3]);
|
|
} else {
|
|
name = 'field' + index;
|
|
}
|
|
return makePrimitiveProcedure(
|
|
name,
|
|
2,
|
|
function(MACHINE) {
|
|
return structType.mutator(
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
plt.baselib.numbers.toFixnum(index),
|
|
MACHINE.env[MACHINE.env.length - 2]);
|
|
});
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// Implementation of the ready function. This will fire off when
|
|
// setReadyTrue is called.
|
|
|
|
(function(scope) {
|
|
scope.ready = function(f) {
|
|
if (runtimeIsReady) {
|
|
notifyWaiter(f);
|
|
} else {
|
|
readyWaiters.push(f);
|
|
}
|
|
};
|
|
|
|
scope.setReadyTrue = function() {
|
|
runtimeIsReady = true;
|
|
while(runtimeIsReady && readyWaiters.length > 0) {
|
|
notifyWaiter(readyWaiters.shift());
|
|
}
|
|
};
|
|
|
|
scope.setReadyFalse = function() {
|
|
runtimeIsReady = false;
|
|
};
|
|
|
|
|
|
var runtimeIsReady = false;
|
|
var readyWaiters = [];
|
|
var notifyWaiter = function(w) {
|
|
w();
|
|
};
|
|
})(this);
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// Executes all programs that have been labeled as a main module
|
|
var invokeMains = function(machine, succ, fail) {
|
|
runtime.ready(function() {
|
|
setReadyFalse();
|
|
machine = machine || runtime.currentMachine;
|
|
succ = succ || function() {};
|
|
fail = fail || function() {};
|
|
var mainModules = machine.mainModules.slice();
|
|
var loop = function() {
|
|
if (mainModules.length > 0) {
|
|
var nextModule = mainModules.shift();
|
|
nextModule.invoke(machine, loop, fail);
|
|
} else {
|
|
setReadyTrue();
|
|
succ();
|
|
}
|
|
};
|
|
setTimeout(loop, 0);
|
|
});
|
|
};
|
|
|
|
// Looks up a name in any of the machine's main modules.
|
|
var lookupInMains = function(name, machine) {
|
|
machine = machine || runtime.currentMachine;
|
|
for (var i = 0; i < machine.mainModules.length; i++) {
|
|
var ns = machine.mainModules[i].getNamespace();
|
|
if(ns.hasOwnProperty(name)) {
|
|
return ns[name];
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
// Exports
|
|
var exports = runtime;
|
|
exports['currentMachine'] = new Machine();
|
|
exports['invokeMains'] = invokeMains;
|
|
exports['lookupInMains'] = lookupInMains;
|
|
|
|
|
|
// installing new primitives
|
|
exports['installPrimitiveProcedure'] = installPrimitiveProcedure;
|
|
exports['installPrimitiveClosure'] = installPrimitiveClosure;
|
|
exports['makePrimitiveProcedure'] = makePrimitiveProcedure;
|
|
exports['Primitives'] = Primitives;
|
|
|
|
exports['ready'] = ready;
|
|
// Private: the runtime library will set this flag to true when
|
|
// the library has finished loading.
|
|
exports['setReadyTrue'] = setReadyTrue;
|
|
exports['setReadyFalse'] = setReadyFalse;
|
|
|
|
exports['Machine'] = Machine;
|
|
exports['Frame'] = Frame;
|
|
exports['CallFrame'] = CallFrame;
|
|
exports['PromptFrame'] = PromptFrame;
|
|
exports['Closure'] = Closure;
|
|
exports['ModuleRecord'] = ModuleRecord;
|
|
exports['VariableReference'] = VariableReference;
|
|
exports['ContinuationPromptTag'] = ContinuationPromptTag;
|
|
exports['DEFAULT_CONTINUATION_PROMPT_TAG'] =
|
|
DEFAULT_CONTINUATION_PROMPT_TAG;
|
|
exports['NULL'] = NULL;
|
|
exports['VOID'] = VOID;
|
|
|
|
exports['NEGATIVE_ZERO'] = NEGATIVE_ZERO;
|
|
exports['INF'] = INF;
|
|
exports['NEGATIVE_INF'] = NEGATIVE_INF;
|
|
exports['NAN'] = NAN;
|
|
|
|
|
|
|
|
|
|
|
|
exports['testArgument'] = testArgument;
|
|
exports['testArity'] = testArity;
|
|
exports['makeCheckArgumentType'] = makeCheckArgumentType;
|
|
|
|
|
|
exports['raise'] = raise;
|
|
exports['raiseUnboundToplevelError'] = raiseUnboundToplevelError;
|
|
exports['raiseArgumentTypeError'] = raiseArgumentTypeError;
|
|
exports['raiseContextExpectedValuesError'] = raiseContextExpectedValuesError;
|
|
exports['raiseArityMismatchError'] = raiseArityMismatchError;
|
|
exports['raiseOperatorApplicationError'] = raiseOperatorApplicationError;
|
|
exports['raiseOperatorIsNotPrimitiveProcedure'] = raiseOperatorIsNotPrimitiveProcedure;
|
|
exports['raiseOperatorIsNotClosure'] = raiseOperatorIsNotClosure;
|
|
exports['raiseUnimplementedPrimitiveError'] = raiseUnimplementedPrimitiveError;
|
|
|
|
|
|
exports['captureControl'] = captureControl;
|
|
exports['restoreControl'] = restoreControl;
|
|
|
|
exports['trampoline'] = trampoline;
|
|
exports['spliceListIntoStack'] = spliceListIntoStack;
|
|
exports['unspliceRestFromStack'] = unspliceRestFromStack;
|
|
|
|
|
|
exports['finalizeClosureCall'] = finalizeClosureCall;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
// Type constructors
|
|
|
|
// numbers
|
|
exports['makeList'] = makeList;
|
|
exports['makePair'] = makePair;
|
|
exports['makeVector'] = makeVector;
|
|
exports['makeBox'] = makeBox;
|
|
exports['makeFloat'] = makeFloat;
|
|
exports['makeRational'] = makeRational;
|
|
exports['makeBignum'] = makeBignum;
|
|
exports['makeComplex'] = makeComplex;
|
|
exports['makeSymbol'] = makeSymbol;
|
|
|
|
|
|
// Type predicates
|
|
exports['isPair'] = isPair;
|
|
exports['isList'] = isList;
|
|
exports['isVector'] = isVector;
|
|
exports['isOutputPort'] = isOutputPort;
|
|
exports['isOutputStringPort'] = isOutputStringPort;
|
|
exports['isBox'] = isBox;
|
|
exports['isString'] = isString;
|
|
exports['isSymbol'] = isSymbol;
|
|
exports['isNumber'] = isNumber;
|
|
exports['isNatural'] = isNatural;
|
|
exports['isReal'] = isReal;
|
|
exports['equals'] = equals;
|
|
|
|
exports['toDomNode'] = toDomNode;
|
|
exports['toWrittenString'] = toWrittenString;
|
|
exports['toDisplayedString'] = toDisplayedString;
|
|
|
|
exports['ArityAtLeast'] = plt.baselib.arity.ArityAtLeast;
|
|
exports['makeArityAtLeast'] = plt.baselib.arity.makeArityAtLeast;
|
|
exports['isArityMatching'] = plt.baselib.arity.isArityMatching;
|
|
|
|
exports['heir'] = heir;
|
|
exports['makeClassPredicate'] = makeClassPredicate;
|
|
|
|
exports['PAUSE'] = PAUSE;
|
|
exports['HaltError'] = HaltError;
|
|
|
|
|
|
|
|
exports['makeStructureType'] = plt.baselib.structs.makeStructureType;
|
|
exports['Struct'] = plt.baselib.structs.Struct;
|
|
exports['StructType'] = plt.baselib.structs.StructType;
|
|
|
|
|
|
})(this['plt']);
|
|
(function(MACHINE, SUCCESS, FAIL, PARAMS) {(function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start148 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start148;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt3, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([MACHINE.primitives["car"],MACHINE.primitives["cdr"],MACHINE.primitives["cons"],MACHINE.primitives["null"],MACHINE.primitives["null?"]]); MACHINE.env[MACHINE.env.length-1].names = ["car","cdr","cons","null","null?"];
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=new RUNTIME.Closure(_lamEntry1, 2, undefined, "map");
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 0].closedVals = [MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]]
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry1 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry1;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 3] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch5)(MACHINE); }
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 0][3] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 0].names[3]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0][3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch5 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch5;
|
|
}
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 4]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 6]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch7)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn11, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple10 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple10;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn11)(MACHINE);
|
|
};
|
|
|
|
var _procReturn11 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn11;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall9)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch7 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch7;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall9)(MACHINE);
|
|
};
|
|
|
|
var _afterCall9 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall9;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 7])) ? (MACHINE.env[MACHINE.env.length - 1 - 7]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 7]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn14, MACHINE.proc));
|
|
return (_lamEntry1)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple13 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple13;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn14)(MACHINE);
|
|
};
|
|
|
|
var _procReturn14 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn14;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall12)(MACHINE);
|
|
};
|
|
|
|
var _afterCall12 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall12;
|
|
}
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies1 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies1;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt3, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([MACHINE.primitives["car"],MACHINE.primitives["cdr"],MACHINE.primitives["cons"],MACHINE.primitives["null"],MACHINE.primitives["null?"]]); MACHINE.env[MACHINE.env.length-1].names = ["car","cdr","cons","null","null?"];
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=new RUNTIME.Closure(_lamEntry1, 2, undefined, "map");
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 0].closedVals = [MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]]
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple2 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple2;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt3)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt3 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt3;
|
|
}
|
|
RUNTIME.Primitives["map"] = MACHINE.val;
|
|
return (_afterLamBodies18)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry2 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry2;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 3] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch22)(MACHINE); }
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 0][2] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 0].names[2]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0][2];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch22 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch22;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 2]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch24)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn28, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple27 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple27;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn28)(MACHINE);
|
|
};
|
|
|
|
var _procReturn28 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn28;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 5])) ? (MACHINE.env[MACHINE.env.length - 1 - 5]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 5]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
MACHINE.env.splice(MACHINE.env.length - (2 + 4), 4);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return (_lamEntry2)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch24 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch24;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall26)(MACHINE);
|
|
};
|
|
|
|
var _afterCall26 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall26;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 5])) ? (MACHINE.env[MACHINE.env.length - 1 - 5]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 5]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
MACHINE.env.splice(MACHINE.env.length - (2 + 4), 4);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return (_lamEntry2)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies18 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies18;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt20, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([MACHINE.primitives["car"],MACHINE.primitives["cdr"],MACHINE.primitives["null"],MACHINE.primitives["null?"]]); MACHINE.env[MACHINE.env.length-1].names = ["car","cdr","null","null?"];
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=new RUNTIME.Closure(_lamEntry2, 2, undefined, "for-each");
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 0].closedVals = [MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]]
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple19 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple19;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt20)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt20 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt20;
|
|
}
|
|
RUNTIME.Primitives["for-each"] = MACHINE.val;
|
|
return (_afterLamBodies35)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry3 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry3;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 0])) ? (MACHINE.env[MACHINE.env.length - 1 - 0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 0]))).first;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies35 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies35;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt37, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([MACHINE.primitives["car"]]); MACHINE.env[MACHINE.env.length-1].names = ["car"];
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry3, 1, [MACHINE.env[MACHINE.env.length - 1 - 0]], "caar");
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple36 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple36;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt37)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt37 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt37;
|
|
}
|
|
RUNTIME.Primitives["caar"] = MACHINE.val;
|
|
return (_afterLamBodies38)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry4 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry4;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 3] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch42)(MACHINE); }
|
|
MACHINE.val = false;
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch42 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch42;
|
|
}
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 5])) ? (MACHINE.env[MACHINE.env.length - 1 - 5]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 5]))).first;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
if (MACHINE.val === false) { return (_falseBranch45)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch45 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch45;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 5])) ? (MACHINE.env[MACHINE.env.length - 1 - 5]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 5]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
MACHINE.env.splice(MACHINE.env.length - (2 + 4), 4);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return (_lamEntry4)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies38 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies38;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt40, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([MACHINE.primitives["car"],MACHINE.primitives["cdr"],MACHINE.primitives["eq?"],MACHINE.primitives["null?"]]); MACHINE.env[MACHINE.env.length-1].names = ["car","cdr","eq?","null?"];
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=new RUNTIME.Closure(_lamEntry4, 2, undefined, "memq");
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 0].closedVals = [MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]]
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple39 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple39;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt40)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt40 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt40;
|
|
}
|
|
RUNTIME.Primitives["memq"] = MACHINE.val;
|
|
return (_afterLamBodies53)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry5 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry5;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 3] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch57)(MACHINE); }
|
|
MACHINE.val = false;
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch57 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch57;
|
|
}
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][0] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[0]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch62)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn66, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple65 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple65;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn66)(MACHINE);
|
|
};
|
|
|
|
var _procReturn66 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn66;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall64)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch62 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch62;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall64)(MACHINE);
|
|
};
|
|
|
|
var _afterCall64 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall64;
|
|
}
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
if (MACHINE.val === false) { return (_falseBranch60)(MACHINE); }
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).first;
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch60 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch60;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 5])) ? (MACHINE.env[MACHINE.env.length - 1 - 5]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 5]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
MACHINE.env.splice(MACHINE.env.length - (2 + 4), 4);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return (_lamEntry5)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies53 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies53;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt55, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([MACHINE.params.currentNamespace["caar"] || MACHINE.primitives["caar"],MACHINE.primitives["car"],MACHINE.primitives["cdr"],MACHINE.primitives["eq?"],MACHINE.primitives["null?"]]); MACHINE.env[MACHINE.env.length-1].names = ["caar","car","cdr","eq?","null?"];
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=new RUNTIME.Closure(_lamEntry5, 2, undefined, "assq");
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 0].closedVals = [MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]]
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple54 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple54;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt55)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt55 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt55;
|
|
}
|
|
RUNTIME.Primitives["assq"] = MACHINE.val;
|
|
return (_afterLamBodies73)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry6 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry6;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 2] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch77)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch77 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch77;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.val=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5])) ? (MACHINE.env[MACHINE.env.length - 1 - 5]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 5])));
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
MACHINE.env.splice(MACHINE.env.length - (2 + 4), 4);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return (_lamEntry6)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry7 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry7;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = 0;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
MACHINE.env.splice(MACHINE.env.length - (2 + 2), 2);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return (_lamEntry6)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies73 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies73;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt75, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([MACHINE.primitives["add1"],MACHINE.primitives["cdr"],MACHINE.primitives["null?"]]); MACHINE.env[MACHINE.env.length-1].names = ["add1","cdr","null?"];
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=new RUNTIME.Closure(_lamEntry6, 2, undefined, "length-iter");
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 0].closedVals = [MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]]
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry7, 1, [MACHINE.env[MACHINE.env.length - 1 - 0]], "length");
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple74 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple74;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt75)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt75 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt75;
|
|
}
|
|
RUNTIME.Primitives["length"] = MACHINE.val;
|
|
return (_afterLamBodies88)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry8 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry8;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 3] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch92)(MACHINE); }
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 0][3] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 0].names[3]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0][3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch92 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch92;
|
|
}
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
if (MACHINE.val === false) { return (_falseBranch95)(MACHINE); }
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).first;
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch95 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch95;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 5])) ? (MACHINE.env[MACHINE.env.length - 1 - 5]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 5]))).first;
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 3]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 6]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn99, MACHINE.proc));
|
|
return (_lamEntry8)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple98 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple98;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn99)(MACHINE);
|
|
};
|
|
|
|
var _procReturn99 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn99;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
MACHINE.env.splice(MACHINE.env.length - (2 + 4), 4);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return (_lamEntry9)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterCall97 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall97;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
MACHINE.env.splice(MACHINE.env.length - (2 + 4), 4);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return (_lamEntry9)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry9 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry9;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 2] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch104)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch104 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch104;
|
|
}
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 6]))).rest;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn108, MACHINE.proc));
|
|
return (_lamEntry9)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple107 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple107;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn108)(MACHINE);
|
|
};
|
|
|
|
var _procReturn108 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn108;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall106)(MACHINE);
|
|
};
|
|
|
|
var _afterCall106 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall106;
|
|
}
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry10 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry10;
|
|
}
|
|
RUNTIME.unspliceRestFromStack(MACHINE, 0, (MACHINE.argcount - 0));
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
MACHINE.env.splice(MACHINE.env.length - (1 + 2), 2);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return (_lamEntry8)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies88 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies88;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt90, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([MACHINE.primitives["car"],MACHINE.primitives["cdr"],MACHINE.primitives["cons"],MACHINE.primitives["null"],MACHINE.primitives["null?"]]); MACHINE.env[MACHINE.env.length-1].names = ["car","cdr","cons","null","null?"];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=new RUNTIME.Closure(_lamEntry8, 1, undefined, "append-many");
|
|
MACHINE.env[MACHINE.env.length - 1 - 1]=new RUNTIME.Closure(_lamEntry9, 2, undefined, "append-2");
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 0].closedVals = [MACHINE.env[MACHINE.env.length - 1 - 1], MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 2]]
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 1].closedVals = [MACHINE.env[MACHINE.env.length - 1 - 1], MACHINE.env[MACHINE.env.length - 1 - 2]]
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry10, (RUNTIME.makeArityAtLeast(0)), [MACHINE.env[MACHINE.env.length - 1 - 0]], "append");
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple89 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple89;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt90)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt90 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt90;
|
|
}
|
|
RUNTIME.Primitives["append"] = MACHINE.val;
|
|
return (_afterLamBodies115)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry11 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry11;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.Frame());
|
|
MACHINE.control[MACHINE.control.length-1].pendingApplyValuesProc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.argcount = 0;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch120)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn124, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple123 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple123;
|
|
}
|
|
if (MACHINE.argcount === 0) { return (_afterArgsEvaluated119)(MACHINE); }
|
|
MACHINE.env.push(MACHINE.val);
|
|
return (_afterArgsEvaluated119)(MACHINE);
|
|
};
|
|
|
|
var _procReturn124 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn124;
|
|
}
|
|
MACHINE.argcount = 1;
|
|
return (_afterReturn125)(MACHINE);
|
|
};
|
|
|
|
var _afterReturn125 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterReturn125;
|
|
}
|
|
if (MACHINE.argcount === 0) { return (_afterArgsEvaluated119)(MACHINE); }
|
|
MACHINE.env.push(MACHINE.val);
|
|
return (_afterArgsEvaluated119)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch120 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch120;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.argcount = 1;
|
|
return (_afterCall122)(MACHINE);
|
|
};
|
|
|
|
var _afterCall122 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall122;
|
|
}
|
|
if (MACHINE.argcount === 0) { return (_afterArgsEvaluated119)(MACHINE); }
|
|
MACHINE.env.push(MACHINE.val);
|
|
return (_afterArgsEvaluated119)(MACHINE);
|
|
};
|
|
|
|
var _afterArgsEvaluated119 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterArgsEvaluated119;
|
|
}
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].pendingApplyValuesProc;
|
|
MACHINE.control.pop();
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch126)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (MACHINE.argcount + 2), 2);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch126 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch126;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies115 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies115;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt117, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry11, 2, [], "call-with-values");
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple116 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple116;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt117)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt117 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt117;
|
|
}
|
|
RUNTIME.Primitives["call-with-values"] = MACHINE.val;
|
|
RUNTIME.Primitives["call/cc"]=new RUNTIME.Closure(_callCCEntry, 1, [], "call/cc");
|
|
RUNTIME.Primitives["call-with-current-continuation"]=new RUNTIME.Closure(_callCCEntry, 1, [], "call/cc");
|
|
return (_afterCallCCImplementation131)(MACHINE);
|
|
};
|
|
|
|
var _callCCEntry = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _callCCEntry;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=RUNTIME.captureControl(MACHINE, 0, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1]=MACHINE.env.slice(0, MACHINE.env.length - 3);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=new RUNTIME.Closure(_callCCClosureEntry, 1, [MACHINE.env[MACHINE.env.length - 1 - 1], MACHINE.env[MACHINE.env.length - 1 - 0]], "call/cc");
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch132)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (1 + 0), 0);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch132 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch132;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 0;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _callCCClosureEntry = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _callCCClosureEntry;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
RUNTIME.restoreControl(MACHINE, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG);
|
|
MACHINE.env = MACHINE.env[MACHINE.env.length - 2].slice(0);
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterCallCCImplementation131 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCallCCImplementation131;
|
|
}
|
|
RUNTIME.Primitives["values"]=new RUNTIME.Closure(_valuesEntry138, (RUNTIME.makeArityAtLeast(0)), [], "values");
|
|
return (_afterApplyCode141)(MACHINE);
|
|
};
|
|
|
|
var _valuesEntry138 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _valuesEntry138;
|
|
}
|
|
if (MACHINE.argcount === 1) { return (_onSingleValue140)(MACHINE); }
|
|
if (MACHINE.argcount === 0) { return (_onZeroValues139)(MACHINE); }
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label.multipleValueReturn;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _onSingleValue140 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onSingleValue140;
|
|
}
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _onZeroValues139 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onZeroValues139;
|
|
}
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label.multipleValueReturn;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterValues137 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValues137;
|
|
}
|
|
RUNTIME.Primitives["values"]=new RUNTIME.Closure(_valuesEntry138, (RUNTIME.makeArityAtLeast(0)), [], "values");
|
|
return (_afterApplyCode141)(MACHINE);
|
|
};
|
|
|
|
var _applyEntry142 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _applyEntry142;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.argcount = (MACHINE.argcount - 1);
|
|
RUNTIME.spliceListIntoStack(MACHINE, (MACHINE.argcount - 1));
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch143)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (MACHINE.argcount + 0), 0);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch143 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch143;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 0;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterApplyCode141 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterApplyCode141;
|
|
}
|
|
RUNTIME.Primitives["apply"]=new RUNTIME.Closure(_applyEntry142, (RUNTIME.makeArityAtLeast(2)), [], "apply");
|
|
};
|
|
|
|
_procReturn11.multipleValueReturn = _procReturnMultiple10;
|
|
_procReturn14.multipleValueReturn = _procReturnMultiple13;
|
|
_beforePopPrompt3.multipleValueReturn = _beforePopPromptMultiple2;
|
|
_procReturn28.multipleValueReturn = _procReturnMultiple27;
|
|
_beforePopPrompt20.multipleValueReturn = _beforePopPromptMultiple19;
|
|
_beforePopPrompt37.multipleValueReturn = _beforePopPromptMultiple36;
|
|
_beforePopPrompt40.multipleValueReturn = _beforePopPromptMultiple39;
|
|
_procReturn66.multipleValueReturn = _procReturnMultiple65;
|
|
_beforePopPrompt55.multipleValueReturn = _beforePopPromptMultiple54;
|
|
_beforePopPrompt75.multipleValueReturn = _beforePopPromptMultiple74;
|
|
_procReturn99.multipleValueReturn = _procReturnMultiple98;
|
|
_procReturn108.multipleValueReturn = _procReturnMultiple107;
|
|
_beforePopPrompt90.multipleValueReturn = _beforePopPromptMultiple89;
|
|
_procReturn124.multipleValueReturn = _procReturnMultiple123;
|
|
_beforePopPrompt117.multipleValueReturn = _beforePopPromptMultiple116;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start148); })(MACHINE, function() { SUCCESS(); }, FAIL, PARAMS);})(plt.runtime.currentMachine,
|
|
function(){ plt.runtime.setReadyTrue(); },
|
|
function(){},
|
|
{});
|
|
]]><![CDATA[var invoke = (function(MACHINE, SUCCESS, FAIL, PARAMS) { plt.runtime.ready(function() {plt.runtime.setReadyFalse();(function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start1581 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start1581;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt151, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/racketcon/rain.rkt"]=new RUNTIME.ModuleRecord("rain", _moduleEntry1407);
|
|
return (_afterModuleBody1406)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry12 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry12;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][11] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[11]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 4][11];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 6][6] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 6].names[6]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][6];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6][18]);
|
|
MACHINE.val = 640;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch152)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn156, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple155 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple155;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn156)(MACHINE);
|
|
};
|
|
|
|
var _procReturn156 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn156;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall154)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch152 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch152;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall154)(MACHINE);
|
|
};
|
|
|
|
var _afterCall154 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall154;
|
|
}
|
|
MACHINE.val = 0;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch157)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn161, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple160 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple160;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn161)(MACHINE);
|
|
};
|
|
|
|
var _procReturn161 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn161;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall159)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch157 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch157;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall159)(MACHINE);
|
|
};
|
|
|
|
var _afterCall159 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall159;
|
|
}
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 5][18]);
|
|
MACHINE.val = 10;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch162)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn166, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple165 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple165;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn166)(MACHINE);
|
|
};
|
|
|
|
var _procReturn166 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn166;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall164)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch162 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch162;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall164)(MACHINE);
|
|
};
|
|
|
|
var _afterCall164 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall164;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.add(5, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0])) ? (MACHINE.env[MACHINE.env.length - 1 - 0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 0])));
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=RUNTIME.makePair("gray", RUNTIME.makePair("darkgray", RUNTIME.makePair("white", RUNTIME.makePair("blue", RUNTIME.makePair("lightblue", RUNTIME.makePair("darkblue", RUNTIME.NULL))))));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][20];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 7][18]);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 8][21]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch169)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn173, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple172 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple172;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn173)(MACHINE);
|
|
};
|
|
|
|
var _procReturn173 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn173;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch174)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn178, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch169 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch169;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall171)(MACHINE);
|
|
};
|
|
|
|
var _afterCall171 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall171;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch174)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn178, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple177 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple177;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn178)(MACHINE);
|
|
};
|
|
|
|
var _procReturn178 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn178;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch179)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn183, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch174 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch174;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall176)(MACHINE);
|
|
};
|
|
|
|
var _afterCall176 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall176;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch179)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn183, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple182 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple182;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn183)(MACHINE);
|
|
};
|
|
|
|
var _procReturn183 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn183;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall181)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch179 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch179;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall181)(MACHINE);
|
|
};
|
|
|
|
var _afterCall181 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall181;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 4][18]);
|
|
MACHINE.val = 10;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch184)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn188, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple187 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple187;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn188)(MACHINE);
|
|
};
|
|
|
|
var _procReturn188 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn188;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch189)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (4 + 1), 1);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch184 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch184;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall186)(MACHINE);
|
|
};
|
|
|
|
var _afterCall186 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall186;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch189)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (4 + 1), 1);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch189 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch189;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry13 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry13;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 2][20];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 2][18]);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 3][21]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch194)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn198, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple197 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple197;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn198)(MACHINE);
|
|
};
|
|
|
|
var _procReturn198 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn198;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch199)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn203, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch194 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch194;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall196)(MACHINE);
|
|
};
|
|
|
|
var _afterCall196 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall196;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch199)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn203, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple202 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple202;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn203)(MACHINE);
|
|
};
|
|
|
|
var _procReturn203 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn203;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch204)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (2 + 2), 2);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch199 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch199;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall201)(MACHINE);
|
|
};
|
|
|
|
var _afterCall201 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall201;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch204)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (2 + 2), 2);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch204 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch204;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry14 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry14;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 2] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch210)(MACHINE); }
|
|
MACHINE.val = RUNTIME.NULL;
|
|
MACHINE.env.length = MACHINE.env.length - 3;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch210 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch210;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch215)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn219, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple218 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple218;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn219)(MACHINE);
|
|
};
|
|
|
|
var _procReturn219 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn219;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch213)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 5])) ? (MACHINE.env[MACHINE.env.length - 1 - 5]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 5]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch223)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf224)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch215 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch215;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall217)(MACHINE);
|
|
};
|
|
|
|
var _afterCall217 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall217;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch213)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 5])) ? (MACHINE.env[MACHINE.env.length - 1 - 5]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 5]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch223)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf224)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch223 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch223;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 4]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch228)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn232, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple231 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple231;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn232)(MACHINE);
|
|
};
|
|
|
|
var _procReturn232 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn232;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch226)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch236)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf237)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch228 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch228;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall230)(MACHINE);
|
|
};
|
|
|
|
var _afterCall230 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall230;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch226)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch236)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf237)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch236 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch236;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 7]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch241)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn245, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple244 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple244;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn245)(MACHINE);
|
|
};
|
|
|
|
var _procReturn245 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn245;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch239)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch249)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf250)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch241 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch241;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall243)(MACHINE);
|
|
};
|
|
|
|
var _afterCall243 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall243;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch239)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch249)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf250)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch249 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch249;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 10]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch254)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn258, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple257 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple257;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn258)(MACHINE);
|
|
};
|
|
|
|
var _procReturn258 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn258;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch252)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 13][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 14];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch259)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn263, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch254 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch254;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall256)(MACHINE);
|
|
};
|
|
|
|
var _afterCall256 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall256;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch252)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 13][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 14];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch259)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn263, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple262 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple262;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn263)(MACHINE);
|
|
};
|
|
|
|
var _procReturn263 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn263;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall261)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch259 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch259;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall261)(MACHINE);
|
|
};
|
|
|
|
var _afterCall261 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall261;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf253)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch252 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch252;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch264)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn268, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple267 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple267;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn268)(MACHINE);
|
|
};
|
|
|
|
var _procReturn268 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn268;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall266)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch264 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch264;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall266)(MACHINE);
|
|
};
|
|
|
|
var _afterCall266 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall266;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf240)(MACHINE);
|
|
};
|
|
|
|
var _afterIf253 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf253;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf240)(MACHINE);
|
|
};
|
|
|
|
var _afterIf250 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf250;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf240)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch239 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch239;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch272)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = RUNTIME.NULL;
|
|
return (_afterIf273)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch272 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch272;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 8]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch277)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn281, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple280 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple280;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn281)(MACHINE);
|
|
};
|
|
|
|
var _procReturn281 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn281;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch275)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch282)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn286, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch277 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch277;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall279)(MACHINE);
|
|
};
|
|
|
|
var _afterCall279 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall279;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch275)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch282)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn286, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple285 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple285;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn286)(MACHINE);
|
|
};
|
|
|
|
var _procReturn286 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn286;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall284)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch282 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch282;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall284)(MACHINE);
|
|
};
|
|
|
|
var _afterCall284 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall284;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 5]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf276)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch275 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch275;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch287)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn291, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple290 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple290;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn291)(MACHINE);
|
|
};
|
|
|
|
var _procReturn291 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn291;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall289)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch287 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch287;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall289)(MACHINE);
|
|
};
|
|
|
|
var _afterCall289 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall289;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf240)(MACHINE);
|
|
};
|
|
|
|
var _afterIf276 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf276;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf240)(MACHINE);
|
|
};
|
|
|
|
var _afterIf273 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf273;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf240)(MACHINE);
|
|
};
|
|
|
|
var _afterIf240 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf240;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf227)(MACHINE);
|
|
};
|
|
|
|
var _afterIf237 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf237;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf227)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch226 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch226;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch295)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = RUNTIME.NULL;
|
|
return (_afterIf296)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch295 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch295;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 5]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch300)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn304, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple303 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple303;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn304)(MACHINE);
|
|
};
|
|
|
|
var _procReturn304 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn304;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch298)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch308)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf309)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch300 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch300;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall302)(MACHINE);
|
|
};
|
|
|
|
var _afterCall302 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall302;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch298)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch308)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf309)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch308 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch308;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 8]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch313)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn317, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple316 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple316;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn317)(MACHINE);
|
|
};
|
|
|
|
var _procReturn317 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn317;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch311)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch318)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn322, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch313 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch313;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall315)(MACHINE);
|
|
};
|
|
|
|
var _afterCall315 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall315;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch311)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch318)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn322, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple321 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple321;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn322)(MACHINE);
|
|
};
|
|
|
|
var _procReturn322 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn322;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall320)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch318 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch318;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall320)(MACHINE);
|
|
};
|
|
|
|
var _afterCall320 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall320;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf312)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch311 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch311;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch323)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn327, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple326 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple326;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn327)(MACHINE);
|
|
};
|
|
|
|
var _procReturn327 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn327;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall325)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch323 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch323;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall325)(MACHINE);
|
|
};
|
|
|
|
var _afterCall325 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall325;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 5]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf299)(MACHINE);
|
|
};
|
|
|
|
var _afterIf312 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf312;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 5]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf299)(MACHINE);
|
|
};
|
|
|
|
var _afterIf309 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf309;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 5]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf299)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch298 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch298;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch331)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = RUNTIME.NULL;
|
|
return (_afterIf332)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch331 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch331;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch336)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn340, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple339 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple339;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn340)(MACHINE);
|
|
};
|
|
|
|
var _procReturn340 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn340;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch334)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch341)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn345, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch336 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch336;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall338)(MACHINE);
|
|
};
|
|
|
|
var _afterCall338 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall338;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch334)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch341)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn345, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple344 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple344;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn345)(MACHINE);
|
|
};
|
|
|
|
var _procReturn345 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn345;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall343)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch341 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch341;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall343)(MACHINE);
|
|
};
|
|
|
|
var _afterCall343 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall343;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 6]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf335)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch334 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch334;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch346)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn350, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple349 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple349;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn350)(MACHINE);
|
|
};
|
|
|
|
var _procReturn350 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn350;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
return (_afterCall348)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch346 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch346;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
return (_afterCall348)(MACHINE);
|
|
};
|
|
|
|
var _afterCall348 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall348;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf299)(MACHINE);
|
|
};
|
|
|
|
var _afterIf335 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf335;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf299)(MACHINE);
|
|
};
|
|
|
|
var _afterIf332 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf332;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf299)(MACHINE);
|
|
};
|
|
|
|
var _afterIf299 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf299;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf227)(MACHINE);
|
|
};
|
|
|
|
var _afterIf296 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf296;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf227)(MACHINE);
|
|
};
|
|
|
|
var _afterIf227 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf227;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.length = MACHINE.env.length - 3;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterIf224 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf224;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.length = MACHINE.env.length - 3;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch213 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch213;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch354)(MACHINE); }
|
|
MACHINE.val = RUNTIME.NULL;
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch354 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch354;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 2]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch359)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn363, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple362 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple362;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn363)(MACHINE);
|
|
};
|
|
|
|
var _procReturn363 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn363;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch357)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch367)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf368)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch359 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch359;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall361)(MACHINE);
|
|
};
|
|
|
|
var _afterCall361 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall361;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch357)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch367)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf368)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch367 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch367;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 5]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch372)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn376, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple375 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple375;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn376)(MACHINE);
|
|
};
|
|
|
|
var _procReturn376 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn376;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch370)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch380)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf381)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch372 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch372;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall374)(MACHINE);
|
|
};
|
|
|
|
var _afterCall374 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall374;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch370)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch380)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf381)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch380 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch380;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 8]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch385)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn389, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple388 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple388;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn389)(MACHINE);
|
|
};
|
|
|
|
var _procReturn389 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn389;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch383)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch390)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn394, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch385 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch385;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall387)(MACHINE);
|
|
};
|
|
|
|
var _afterCall387 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall387;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch383)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch390)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn394, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple393 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple393;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn394)(MACHINE);
|
|
};
|
|
|
|
var _procReturn394 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn394;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall392)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch390 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch390;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall392)(MACHINE);
|
|
};
|
|
|
|
var _afterCall392 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall392;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf384)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch383 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch383;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch395)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn399, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple398 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple398;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn399)(MACHINE);
|
|
};
|
|
|
|
var _procReturn399 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn399;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall397)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch395 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch395;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall397)(MACHINE);
|
|
};
|
|
|
|
var _afterCall397 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall397;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf371)(MACHINE);
|
|
};
|
|
|
|
var _afterIf384 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf384;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf371)(MACHINE);
|
|
};
|
|
|
|
var _afterIf381 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf381;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf371)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch370 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch370;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch403)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = RUNTIME.NULL;
|
|
return (_afterIf404)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch403 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch403;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch408)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn412, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple411 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple411;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn412)(MACHINE);
|
|
};
|
|
|
|
var _procReturn412 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn412;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch406)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch413)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn417, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch408 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch408;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall410)(MACHINE);
|
|
};
|
|
|
|
var _afterCall410 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall410;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch406)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch413)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn417, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple416 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple416;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn417)(MACHINE);
|
|
};
|
|
|
|
var _procReturn417 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn417;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall415)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch413 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch413;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall415)(MACHINE);
|
|
};
|
|
|
|
var _afterCall415 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall415;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 5]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf407)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch406 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch406;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch418)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn422, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple421 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple421;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn422)(MACHINE);
|
|
};
|
|
|
|
var _procReturn422 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn422;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall420)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch418 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch418;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall420)(MACHINE);
|
|
};
|
|
|
|
var _afterCall420 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall420;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf371)(MACHINE);
|
|
};
|
|
|
|
var _afterIf407 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf407;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf371)(MACHINE);
|
|
};
|
|
|
|
var _afterIf404 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf404;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf371)(MACHINE);
|
|
};
|
|
|
|
var _afterIf371 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf371;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterIf368 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf368;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch357 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch357;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch426)(MACHINE); }
|
|
MACHINE.val = RUNTIME.NULL;
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch426 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch426;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 3]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch431)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn435, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple434 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple434;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn435)(MACHINE);
|
|
};
|
|
|
|
var _procReturn435 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn435;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch429)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch439)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf440)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch431 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch431;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall433)(MACHINE);
|
|
};
|
|
|
|
var _afterCall433 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall433;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch429)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch439)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf440)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch439 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch439;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch444)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn448, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple447 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple447;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn448)(MACHINE);
|
|
};
|
|
|
|
var _procReturn448 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn448;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch442)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch449)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn453, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch444 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch444;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall446)(MACHINE);
|
|
};
|
|
|
|
var _afterCall446 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall446;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch442)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch449)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn453, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple452 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple452;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn453)(MACHINE);
|
|
};
|
|
|
|
var _procReturn453 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn453;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall451)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch449 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch449;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall451)(MACHINE);
|
|
};
|
|
|
|
var _afterCall451 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall451;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf443)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch442 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch442;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch454)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn458, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple457 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple457;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn458)(MACHINE);
|
|
};
|
|
|
|
var _procReturn458 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn458;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall456)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch454 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch454;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall456)(MACHINE);
|
|
};
|
|
|
|
var _afterCall456 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall456;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterIf443 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf443;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterIf440 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf440;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch429 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch429;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch462)(MACHINE); }
|
|
MACHINE.val = RUNTIME.NULL;
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch462 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch462;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 4]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch467)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn471, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple470 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple470;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn471)(MACHINE);
|
|
};
|
|
|
|
var _procReturn471 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn471;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch465)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch472)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn476, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch467 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch467;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall469)(MACHINE);
|
|
};
|
|
|
|
var _afterCall469 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall469;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch465)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch472)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn476, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple475 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple475;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn476)(MACHINE);
|
|
};
|
|
|
|
var _procReturn476 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn476;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall474)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch472 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch472;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall474)(MACHINE);
|
|
};
|
|
|
|
var _afterCall474 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall474;
|
|
}
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch465 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch465;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 5][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch477)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (2 + 6), 6);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch477 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch477;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry15 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry15;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 1][23] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 1].names[23]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 1][23];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][29];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][30];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 6][17];
|
|
MACHINE.argcount = 0;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch482)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn486, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple485 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple485;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn486)(MACHINE);
|
|
};
|
|
|
|
var _procReturn486 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn486;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall484)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch482 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch482;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall484)(MACHINE);
|
|
};
|
|
|
|
var _afterCall484 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall484;
|
|
}
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 8][17];
|
|
MACHINE.argcount = 0;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch487)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn491, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple490 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple490;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn491)(MACHINE);
|
|
};
|
|
|
|
var _procReturn491 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn491;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall489)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch487 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch487;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall489)(MACHINE);
|
|
};
|
|
|
|
var _afterCall489 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall489;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 8][25]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch492)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn496, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple495 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple495;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn496)(MACHINE);
|
|
};
|
|
|
|
var _procReturn496 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn496;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall494)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch492 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch492;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall494)(MACHINE);
|
|
};
|
|
|
|
var _afterCall494 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall494;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch497)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn501, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple500 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple500;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn501)(MACHINE);
|
|
};
|
|
|
|
var _procReturn501 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn501;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall499)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch497 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch497;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall499)(MACHINE);
|
|
};
|
|
|
|
var _afterCall499 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall499;
|
|
}
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch505)(MACHINE); }
|
|
MACHINE.val = RUNTIME.NULL;
|
|
return (_afterIf506)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch505 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch505;
|
|
}
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 8][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 8].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch512)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn516, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple515 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple515;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn516)(MACHINE);
|
|
};
|
|
|
|
var _procReturn516 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn516;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch517)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn521, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch512 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch512;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall514)(MACHINE);
|
|
};
|
|
|
|
var _afterCall514 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall514;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch517)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn521, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple520 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple520;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn521)(MACHINE);
|
|
};
|
|
|
|
var _procReturn521 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn521;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall519)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch517 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch517;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall519)(MACHINE);
|
|
};
|
|
|
|
var _afterCall519 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall519;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 480;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=((plt.baselib.numbers.greaterThan(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0])) ? (MACHINE.env[MACHINE.env.length - 1 - 0]) : RUNTIME.raiseArgumentTypeError(MACHINE, ">", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0])),MACHINE.env[MACHINE.env.length - 1 - 1])));
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === false);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
if (MACHINE.val === false) { return (_falseBranch508)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch525)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf526)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch525 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch525;
|
|
}
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 9][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 11][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 11].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 11][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch532)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn536, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple535 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple535;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn536)(MACHINE);
|
|
};
|
|
|
|
var _procReturn536 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn536;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch537)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn541, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch532 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch532;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall534)(MACHINE);
|
|
};
|
|
|
|
var _afterCall534 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall534;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch537)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn541, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple540 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple540;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn541)(MACHINE);
|
|
};
|
|
|
|
var _procReturn541 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn541;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall539)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch537 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch537;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall539)(MACHINE);
|
|
};
|
|
|
|
var _afterCall539 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall539;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 480;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=((plt.baselib.numbers.greaterThan(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0])) ? (MACHINE.env[MACHINE.env.length - 1 - 0]) : RUNTIME.raiseArgumentTypeError(MACHINE, ">", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0])),MACHINE.env[MACHINE.env.length - 1 - 1])));
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === false);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
if (MACHINE.val === false) { return (_falseBranch528)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch545)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf546)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch545 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch545;
|
|
}
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 9][32]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch550)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn554, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple553 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple553;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn554)(MACHINE);
|
|
};
|
|
|
|
var _procReturn554 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn554;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall552)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch550 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch550;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall552)(MACHINE);
|
|
};
|
|
|
|
var _afterCall552 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall552;
|
|
}
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === false);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
if (MACHINE.val === false) { return (_falseBranch548)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12][28];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch555)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn559, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple558 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple558;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn559)(MACHINE);
|
|
};
|
|
|
|
var _procReturn559 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn559;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall557)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch555 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch555;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall557)(MACHINE);
|
|
};
|
|
|
|
var _afterCall557 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall557;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf549)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch548 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch548;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10][28];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch560)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn564, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple563 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple563;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn564)(MACHINE);
|
|
};
|
|
|
|
var _procReturn564 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn564;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall562)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch560 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch560;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall562)(MACHINE);
|
|
};
|
|
|
|
var _afterCall562 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall562;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf529)(MACHINE);
|
|
};
|
|
|
|
var _afterIf549 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf549;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf529)(MACHINE);
|
|
};
|
|
|
|
var _afterIf546 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf546;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf529)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch528 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch528;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch568)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = RUNTIME.NULL;
|
|
return (_afterIf569)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch568 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch568;
|
|
}
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 7][32]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch573)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn577, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple576 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple576;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn577)(MACHINE);
|
|
};
|
|
|
|
var _procReturn577 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn577;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall575)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch573 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch573;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall575)(MACHINE);
|
|
};
|
|
|
|
var _afterCall575 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall575;
|
|
}
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === false);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
if (MACHINE.val === false) { return (_falseBranch571)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10][28];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch578)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn582, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple581 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple581;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn582)(MACHINE);
|
|
};
|
|
|
|
var _procReturn582 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn582;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall580)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch578 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch578;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall580)(MACHINE);
|
|
};
|
|
|
|
var _afterCall580 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall580;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 5]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf572)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch571 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch571;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8][28];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch583)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn587, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple586 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple586;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn587)(MACHINE);
|
|
};
|
|
|
|
var _procReturn587 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn587;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall585)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch583 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch583;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall585)(MACHINE);
|
|
};
|
|
|
|
var _afterCall585 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall585;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf529)(MACHINE);
|
|
};
|
|
|
|
var _afterIf572 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf572;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf529)(MACHINE);
|
|
};
|
|
|
|
var _afterIf569 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf569;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf529)(MACHINE);
|
|
};
|
|
|
|
var _afterIf529 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf529;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf509)(MACHINE);
|
|
};
|
|
|
|
var _afterIf526 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf526;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf509)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch508 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch508;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch591)(MACHINE); }
|
|
MACHINE.val = RUNTIME.NULL;
|
|
return (_afterIf592)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch591 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch591;
|
|
}
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 7][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch598)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn602, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple601 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple601;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn602)(MACHINE);
|
|
};
|
|
|
|
var _procReturn602 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn602;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch603)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn607, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch598 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch598;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall600)(MACHINE);
|
|
};
|
|
|
|
var _afterCall600 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall600;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch603)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn607, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple606 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple606;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn607)(MACHINE);
|
|
};
|
|
|
|
var _procReturn607 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn607;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall605)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch603 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch603;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall605)(MACHINE);
|
|
};
|
|
|
|
var _afterCall605 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall605;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 480;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=((plt.baselib.numbers.greaterThan(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0])) ? (MACHINE.env[MACHINE.env.length - 1 - 0]) : RUNTIME.raiseArgumentTypeError(MACHINE, ">", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0])),MACHINE.env[MACHINE.env.length - 1 - 1])));
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === false);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
if (MACHINE.val === false) { return (_falseBranch594)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch611)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = RUNTIME.NULL;
|
|
return (_afterIf612)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch611 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch611;
|
|
}
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 7][32]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch616)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn620, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple619 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple619;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn620)(MACHINE);
|
|
};
|
|
|
|
var _procReturn620 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn620;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall618)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch616 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch616;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall618)(MACHINE);
|
|
};
|
|
|
|
var _afterCall618 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall618;
|
|
}
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === false);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
if (MACHINE.val === false) { return (_falseBranch614)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10][28];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch621)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn625, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple624 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple624;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn625)(MACHINE);
|
|
};
|
|
|
|
var _procReturn625 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn625;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall623)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch621 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch621;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall623)(MACHINE);
|
|
};
|
|
|
|
var _afterCall623 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall623;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf615)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch614 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch614;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8][28];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch626)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn630, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple629 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple629;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn630)(MACHINE);
|
|
};
|
|
|
|
var _procReturn630 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn630;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall628)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch626 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch626;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall628)(MACHINE);
|
|
};
|
|
|
|
var _afterCall628 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall628;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf595)(MACHINE);
|
|
};
|
|
|
|
var _afterIf615 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf615;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf595)(MACHINE);
|
|
};
|
|
|
|
var _afterIf612 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf612;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf595)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch594 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch594;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 1]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch634)(MACHINE); }
|
|
MACHINE.val = RUNTIME.NULL;
|
|
return (_afterIf635)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch634 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch634;
|
|
}
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 5][32]);
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch639)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn643, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple642 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple642;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn643)(MACHINE);
|
|
};
|
|
|
|
var _procReturn643 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn643;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall641)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch639 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch639;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall641)(MACHINE);
|
|
};
|
|
|
|
var _afterCall641 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall641;
|
|
}
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === false);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
if (MACHINE.val === false) { return (_falseBranch637)(MACHINE); }
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8][28];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch644)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn648, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple647 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple647;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn648)(MACHINE);
|
|
};
|
|
|
|
var _procReturn648 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn648;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall646)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch644 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch644;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall646)(MACHINE);
|
|
};
|
|
|
|
var _afterCall646 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall646;
|
|
}
|
|
MACHINE.val=RUNTIME.makePair(MACHINE.env[MACHINE.env.length - 1 - 0], MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
return (_afterIf638)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch637 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch637;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][26];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6][28];
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch649)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn653, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple652 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple652;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn653)(MACHINE);
|
|
};
|
|
|
|
var _procReturn653 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn653;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf595)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch649 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch649;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall651)(MACHINE);
|
|
};
|
|
|
|
var _afterCall651 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall651;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf595)(MACHINE);
|
|
};
|
|
|
|
var _afterIf638 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf638;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf595)(MACHINE);
|
|
};
|
|
|
|
var _afterIf635 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf635;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf595)(MACHINE);
|
|
};
|
|
|
|
var _afterIf595 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf595;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf509)(MACHINE);
|
|
};
|
|
|
|
var _afterIf592 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf592;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf509)(MACHINE);
|
|
};
|
|
|
|
var _afterIf509 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf509;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch654)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (1 + 2), 2);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _afterIf506 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf506;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch654)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (1 + 2), 2);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch654 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch654;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry16 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry16;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 2][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch662)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn666, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple665 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple665;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn666)(MACHINE);
|
|
};
|
|
|
|
var _procReturn666 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn666;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch667)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn671, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch662 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch662;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall664)(MACHINE);
|
|
};
|
|
|
|
var _afterCall664 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall664;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch667)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn671, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple670 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple670;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn671)(MACHINE);
|
|
};
|
|
|
|
var _procReturn671 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn671;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall669)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch667 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch667;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall669)(MACHINE);
|
|
};
|
|
|
|
var _afterCall669 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall669;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 480;
|
|
MACHINE.val=((plt.baselib.numbers.greaterThan(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0])) ? (MACHINE.env[MACHINE.env.length - 1 - 0]) : RUNTIME.raiseArgumentTypeError(MACHINE, ">", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0])),MACHINE.env[MACHINE.env.length - 1 - 1])));
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
if (MACHINE.val === false) { return (_falseBranch660)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch660 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch660;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][11] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[11]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 4][11];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 6][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 6].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch672)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn676, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple675 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple675;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn676)(MACHINE);
|
|
};
|
|
|
|
var _procReturn676 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn676;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall674)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch672 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch672;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall674)(MACHINE);
|
|
};
|
|
|
|
var _afterCall674 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall674;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 7][14] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 7].names[14]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 7][14];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch679)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn683, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple682 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple682;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn683)(MACHINE);
|
|
};
|
|
|
|
var _procReturn683 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn683;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall681)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch679 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch679;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall681)(MACHINE);
|
|
};
|
|
|
|
var _afterCall681 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall681;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 8][6] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 8].names[6]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][6];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][8] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[8]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][8];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch686)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn690, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple689 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple689;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn690)(MACHINE);
|
|
};
|
|
|
|
var _procReturn690 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn690;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall688)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch686 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch686;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall688)(MACHINE);
|
|
};
|
|
|
|
var _afterCall688 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall688;
|
|
}
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 10][9]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch691)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn695, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple694 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple694;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn695)(MACHINE);
|
|
};
|
|
|
|
var _procReturn695 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn695;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall693)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch691 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch691;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall693)(MACHINE);
|
|
};
|
|
|
|
var _afterCall693 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall693;
|
|
}
|
|
MACHINE.val=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0])) ? (MACHINE.env[MACHINE.env.length - 1 - 0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0])), ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 1])));
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch696)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn700, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple699 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple699;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn700)(MACHINE);
|
|
};
|
|
|
|
var _procReturn700 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn700;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall698)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch696 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch696;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall698)(MACHINE);
|
|
};
|
|
|
|
var _afterCall698 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall698;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 6][14] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 6].names[14]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6][14];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch701)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn705, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple704 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple704;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn705)(MACHINE);
|
|
};
|
|
|
|
var _procReturn705 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn705;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall703)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch701 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch701;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall703)(MACHINE);
|
|
};
|
|
|
|
var _afterCall703 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall703;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0])) ? (MACHINE.env[MACHINE.env.length - 1 - 0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 0])));
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][15] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[15]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch706)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn710, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple709 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple709;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn710)(MACHINE);
|
|
};
|
|
|
|
var _procReturn710 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn710;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall708)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch706 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch706;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall708)(MACHINE);
|
|
};
|
|
|
|
var _afterCall708 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall708;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 4][16]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch711)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn715, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple714 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple714;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn715)(MACHINE);
|
|
};
|
|
|
|
var _procReturn715 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn715;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch716)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (4 + 2), 2);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch711 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch711;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall713)(MACHINE);
|
|
};
|
|
|
|
var _afterCall713 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall713;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch716)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (4 + 2), 2);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch716 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch716;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry17 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry17;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 2][6] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 2].names[6]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 2][6];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][8] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[8]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][8];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch721)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn725, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple724 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple724;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn725)(MACHINE);
|
|
};
|
|
|
|
var _procReturn725 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn725;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall723)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch721 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch721;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall723)(MACHINE);
|
|
};
|
|
|
|
var _afterCall723 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall723;
|
|
}
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 4][9]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch726)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn730, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple729 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple729;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn730)(MACHINE);
|
|
};
|
|
|
|
var _procReturn730 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn730;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall728)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch726 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch726;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall728)(MACHINE);
|
|
};
|
|
|
|
var _afterCall728 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall728;
|
|
}
|
|
MACHINE.val=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0])) ? (MACHINE.env[MACHINE.env.length - 1 - 0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0])), ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 1])));
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch731)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (2 + 3), 3);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch731 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch731;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 3;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry18 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry18;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 2][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch736)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn740, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple739 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple739;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn740)(MACHINE);
|
|
};
|
|
|
|
var _procReturn740 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn740;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch741)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn745, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch736 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch736;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall738)(MACHINE);
|
|
};
|
|
|
|
var _afterCall738 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall738;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch741)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn745, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple744 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple744;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn745)(MACHINE);
|
|
};
|
|
|
|
var _procReturn745 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn745;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall743)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch741 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch741;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall743)(MACHINE);
|
|
};
|
|
|
|
var _afterCall743 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall743;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 480;
|
|
MACHINE.val=((plt.baselib.numbers.greaterThan(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0])) ? (MACHINE.env[MACHINE.env.length - 1 - 0]) : RUNTIME.raiseArgumentTypeError(MACHINE, ">", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0])),MACHINE.env[MACHINE.env.length - 1 - 1])));
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry19 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry19;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 3][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch746)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn750, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple749 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple749;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn750)(MACHINE);
|
|
};
|
|
|
|
var _procReturn750 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn750;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch751)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn755, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch746 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch746;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall748)(MACHINE);
|
|
};
|
|
|
|
var _afterCall748 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall748;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch751)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn755, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple754 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple754;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn755)(MACHINE);
|
|
};
|
|
|
|
var _procReturn755 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn755;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall753)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch751 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch751;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall753)(MACHINE);
|
|
};
|
|
|
|
var _afterCall753 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall753;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 480;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=((plt.baselib.numbers.greaterThan(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0])) ? (MACHINE.env[MACHINE.env.length - 1 - 0]) : RUNTIME.raiseArgumentTypeError(MACHINE, ">", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0])),MACHINE.env[MACHINE.env.length - 1 - 1])));
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === false);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry20 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry20;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][34];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "solid";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch756)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (3 + 3), 3);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch756 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch756;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 3;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry21 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry21;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 4][36];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 6][15] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 6].names[15]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6][15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch761)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn765, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple764 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple764;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn765)(MACHINE);
|
|
};
|
|
|
|
var _procReturn765 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn765;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall763)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch761 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch761;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall763)(MACHINE);
|
|
};
|
|
|
|
var _afterCall763 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall763;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6][16]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch768)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn772, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple771 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple771;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn772)(MACHINE);
|
|
};
|
|
|
|
var _procReturn772 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn772;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall770)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch768 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch768;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall770)(MACHINE);
|
|
};
|
|
|
|
var _afterCall770 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall770;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 9][34];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "solid";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch775)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn779, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple778 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple778;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn779)(MACHINE);
|
|
};
|
|
|
|
var _procReturn779 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn779;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall777)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch775 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch775;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall777)(MACHINE);
|
|
};
|
|
|
|
var _afterCall777 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall777;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][8] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[8]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][8];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 6][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 6].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch780)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn784, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple783 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple783;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn784)(MACHINE);
|
|
};
|
|
|
|
var _procReturn784 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn784;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch785)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn789, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch780 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch780;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall782)(MACHINE);
|
|
};
|
|
|
|
var _afterCall782 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall782;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch785)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn789, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple788 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple788;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn789)(MACHINE);
|
|
};
|
|
|
|
var _procReturn789 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn789;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall787)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch785 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch785;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall787)(MACHINE);
|
|
};
|
|
|
|
var _afterCall787 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall787;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 4][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 6][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 6].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch790)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn794, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple793 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple793;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn794)(MACHINE);
|
|
};
|
|
|
|
var _procReturn794 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn794;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch795)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn799, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch790 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch790;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall792)(MACHINE);
|
|
};
|
|
|
|
var _afterCall792 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall792;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch795)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn799, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple798 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple798;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn799)(MACHINE);
|
|
};
|
|
|
|
var _procReturn799 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn799;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall797)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch795 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch795;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall797)(MACHINE);
|
|
};
|
|
|
|
var _afterCall797 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall797;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch800)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (4 + 3), 3);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch800 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch800;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 3;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry22 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry22;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 3] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch806)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch806 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch806;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 6]))).first;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch808)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn812, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple811 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple811;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn812)(MACHINE);
|
|
};
|
|
|
|
var _procReturn812 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn812;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall810)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch808 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch808;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall810)(MACHINE);
|
|
};
|
|
|
|
var _afterCall810 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall810;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 5])) ? (MACHINE.env[MACHINE.env.length - 1 - 5]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 5]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch818)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch818 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch818;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).first;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch820)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn824, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple823 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple823;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn824)(MACHINE);
|
|
};
|
|
|
|
var _procReturn824 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn824;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall822)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch820 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch820;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall822)(MACHINE);
|
|
};
|
|
|
|
var _afterCall822 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall822;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch830)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch830 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch830;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).first;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch832)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn836, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple835 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple835;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn836)(MACHINE);
|
|
};
|
|
|
|
var _procReturn836 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn836;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall834)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch832 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch832;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall834)(MACHINE);
|
|
};
|
|
|
|
var _afterCall834 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall834;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch842)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 10;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch842 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch842;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).first;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch844)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn848, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple847 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple847;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn848)(MACHINE);
|
|
};
|
|
|
|
var _procReturn848 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn848;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall846)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch844 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch844;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall846)(MACHINE);
|
|
};
|
|
|
|
var _afterCall846 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall846;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch854)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 12;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch854 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch854;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 11][37];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 5])) ? (MACHINE.env[MACHINE.env.length - 1 - 5]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 5]))).first;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch856)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn860, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple859 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple859;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn860)(MACHINE);
|
|
};
|
|
|
|
var _procReturn860 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn860;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall858)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch856 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch856;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall858)(MACHINE);
|
|
};
|
|
|
|
var _afterCall858 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall858;
|
|
}
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch861)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (3 + 12), 12);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch861 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch861;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 12;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 12;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 11;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 10;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 9;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry23 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry23;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][3]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 2][25]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch868)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn872, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple871 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple871;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn872)(MACHINE);
|
|
};
|
|
|
|
var _procReturn872 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn872;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall870)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch868 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch868;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall870)(MACHINE);
|
|
};
|
|
|
|
var _afterCall870 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall870;
|
|
}
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch876)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch876 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch876;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 8][36];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 10][15] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 10].names[15]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10][15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch880)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn884, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple883 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple883;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn884)(MACHINE);
|
|
};
|
|
|
|
var _procReturn884 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn884;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall882)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch880 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch880;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall882)(MACHINE);
|
|
};
|
|
|
|
var _afterCall882 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall882;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 10][16]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch887)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn891, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple890 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple890;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn891)(MACHINE);
|
|
};
|
|
|
|
var _procReturn891 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn891;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall889)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch887 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch887;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall889)(MACHINE);
|
|
};
|
|
|
|
var _afterCall889 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall889;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 13][34];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "solid";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch894)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn898, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple897 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple897;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn898)(MACHINE);
|
|
};
|
|
|
|
var _procReturn898 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn898;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall896)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch894 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch894;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall896)(MACHINE);
|
|
};
|
|
|
|
var _afterCall896 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall896;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][8] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[8]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][8];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 10][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 10].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch899)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn903, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple902 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple902;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn903)(MACHINE);
|
|
};
|
|
|
|
var _procReturn903 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn903;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch904)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn908, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch899 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch899;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall901)(MACHINE);
|
|
};
|
|
|
|
var _afterCall901 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall901;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch904)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn908, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple907 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple907;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn908)(MACHINE);
|
|
};
|
|
|
|
var _procReturn908 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn908;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall906)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch904 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch904;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall906)(MACHINE);
|
|
};
|
|
|
|
var _afterCall906 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall906;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 8][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 10][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 10].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch909)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn913, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple912 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple912;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn913)(MACHINE);
|
|
};
|
|
|
|
var _procReturn913 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn913;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch914)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn918, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch909 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch909;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall911)(MACHINE);
|
|
};
|
|
|
|
var _afterCall911 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall911;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch914)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn918, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple917 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple917;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn918)(MACHINE);
|
|
};
|
|
|
|
var _procReturn918 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn918;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall916)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch914 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch914;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall916)(MACHINE);
|
|
};
|
|
|
|
var _afterCall916 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall916;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch919)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn923, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple922 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple922;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn923)(MACHINE);
|
|
};
|
|
|
|
var _procReturn923 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn923;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall921)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch919 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch919;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall921)(MACHINE);
|
|
};
|
|
|
|
var _afterCall921 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall921;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch929)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch929 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch929;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 10][36];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 12][15] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 12].names[15]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12][15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch933)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn937, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple936 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple936;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn937)(MACHINE);
|
|
};
|
|
|
|
var _procReturn937 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn937;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall935)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch933 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch933;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall935)(MACHINE);
|
|
};
|
|
|
|
var _afterCall935 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall935;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 12][16]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch940)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn944, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple943 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple943;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn944)(MACHINE);
|
|
};
|
|
|
|
var _procReturn944 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn944;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall942)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch940 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch940;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall942)(MACHINE);
|
|
};
|
|
|
|
var _afterCall942 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall942;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 15][34];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "solid";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch947)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn951, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple950 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple950;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn951)(MACHINE);
|
|
};
|
|
|
|
var _procReturn951 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn951;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall949)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch947 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch947;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall949)(MACHINE);
|
|
};
|
|
|
|
var _afterCall949 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall949;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 11][8] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 11].names[8]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 11][8];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 12][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 12].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch952)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn956, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple955 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple955;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn956)(MACHINE);
|
|
};
|
|
|
|
var _procReturn956 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn956;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch957)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn961, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch952 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch952;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall954)(MACHINE);
|
|
};
|
|
|
|
var _afterCall954 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall954;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch957)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn961, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple960 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple960;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn961)(MACHINE);
|
|
};
|
|
|
|
var _procReturn961 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn961;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall959)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch957 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch957;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall959)(MACHINE);
|
|
};
|
|
|
|
var _afterCall959 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall959;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 10][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 12][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 12].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch962)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn966, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple965 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple965;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn966)(MACHINE);
|
|
};
|
|
|
|
var _procReturn966 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn966;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch967)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn971, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch962 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch962;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall964)(MACHINE);
|
|
};
|
|
|
|
var _afterCall964 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall964;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch967)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn971, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple970 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple970;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn971)(MACHINE);
|
|
};
|
|
|
|
var _procReturn971 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn971;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall969)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch967 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch967;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall969)(MACHINE);
|
|
};
|
|
|
|
var _afterCall969 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall969;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch972)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn976, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple975 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple975;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn976)(MACHINE);
|
|
};
|
|
|
|
var _procReturn976 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn976;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall974)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch972 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch972;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall974)(MACHINE);
|
|
};
|
|
|
|
var _afterCall974 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall974;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch982)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch982 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch982;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 12][36];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 14][15] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 14].names[15]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 14][15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch986)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn990, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple989 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple989;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn990)(MACHINE);
|
|
};
|
|
|
|
var _procReturn990 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn990;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall988)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch986 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch986;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall988)(MACHINE);
|
|
};
|
|
|
|
var _afterCall988 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall988;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 14][16]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch993)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn997, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple996 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple996;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn997)(MACHINE);
|
|
};
|
|
|
|
var _procReturn997 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn997;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall995)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch993 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch993;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall995)(MACHINE);
|
|
};
|
|
|
|
var _afterCall995 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall995;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 17][34];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "solid";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1000)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1004, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1003 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1003;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1004)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1004 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1004;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1002)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1000 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1000;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1002)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1002 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1002;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 13][8] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 13].names[8]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13][8];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 14][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 14].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 14][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1005)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1009, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1008 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1008;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1009)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1009 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1009;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1010)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1014, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1005 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1005;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1007)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1007 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1007;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1010)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1014, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1013 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1013;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1014)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1014 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1014;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1012)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1010 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1010;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1012)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1012 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1012;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 12][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 14][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 14].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 14][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1015)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1019, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1018 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1018;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1019)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1019 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1019;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1020)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1024, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1015 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1015;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1017)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1017 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1017;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1020)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1024, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1023 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1023;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1024)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1024 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1024;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1022)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1020 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1020;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1022)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1022 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1022;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1025)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1029, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1028 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1028;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1029)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1029 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1029;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1027)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1025 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1025;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1027)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1027 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1027;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch1035)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 10;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1035 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1035;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 14][36];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 16][15] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 16].names[15]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 16][15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1039)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1043, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1042 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1042;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1043)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1043 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1043;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1041)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1039 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1039;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1041)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1041 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1041;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 16][16]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1046)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1050, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1049 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1049;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1050)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1050 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1050;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1048)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1046 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1046;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1048)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1048 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1048;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 19][34];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "solid";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1053)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1057, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1056 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1056;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1057)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1057 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1057;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1055)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1053 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1053;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1055)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1055 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1055;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 15][8] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 15].names[8]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 15][8];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 16][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 16].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 16][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1058)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1062, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1061 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1061;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1062)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1062 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1062;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1063)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1067, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1058 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1058;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1060)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1060 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1060;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1063)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1067, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1066 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1066;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1067)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1067 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1067;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1065)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1063 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1063;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1065)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1065 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1065;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 14][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 16][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 16].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 16][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1068)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1072, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1071 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1071;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1072)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1072 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1072;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1073)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1077, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1068 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1068;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1070)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1070 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1070;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1073)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1077, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1076 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1076;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1077)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1077 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1077;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1075)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1073 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1073;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1075)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1075 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1075;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1078)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1082, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1081 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1081;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1082)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1082 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1082;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1080)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1078 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1078;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1080)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1080 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1080;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch1088)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 12;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1088 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1088;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 16][36];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 18][15] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 18].names[15]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 18][15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1092)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1096, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1095 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1095;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1096)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1096 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1096;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1094)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1092 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1092;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1094)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1094 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1094;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 18][16]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1099)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1103, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1102 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1102;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1103)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1103 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1103;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1101)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1099 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1099;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1101)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1101 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1101;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 21][34];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "solid";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1106)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1110, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1109 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1109;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1110)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1110 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1110;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1108)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1106 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1106;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1108)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1108 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1108;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 17][8] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 17].names[8]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 17][8];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 18][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 18].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 18][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1111)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1115, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1114 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1114;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1115)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1115 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1115;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1116)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1120, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1111 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1111;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1113)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1113 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1113;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1116)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1120, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1119 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1119;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1120)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1120 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1120;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1118)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1116 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1116;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1118)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1118 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1118;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 16][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 18][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 18].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 18][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1121)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1125, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1124 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1124;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1125)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1125 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1125;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1126)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1130, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1121 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1121;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1123)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1123 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1123;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1126)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1130, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1129 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1129;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1130)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1130 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1130;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1128)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1126 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1126;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1128)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1128 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1128;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1131)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1135, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1134 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1134;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1135)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1135 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1135;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1133)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1131 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1131;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1133)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1133 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1133;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch1141)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 14;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1141 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1141;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 18][36];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 20][15] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 20].names[15]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 20][15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1145)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1149, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1148 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1148;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1149)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1149 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1149;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1147)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1145 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1145;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1147)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1147 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1147;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 20][16]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1152)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1156, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1155 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1155;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1156)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1156 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1156;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1154)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1152 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1152;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1154)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1154 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1154;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 23][34];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "solid";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1159)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1163, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1162 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1162;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1163)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1163 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1163;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1161)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1159 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1159;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1161)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1161 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1161;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 19][8] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 19].names[8]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 19][8];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 20][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 20].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 20][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1164)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1168, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1167 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1167;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1168)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1168 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1168;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1169)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1173, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1164 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1164;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1166)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1166 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1166;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1169)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1173, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1172 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1172;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1173)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1173 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1173;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1171)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1169 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1169;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1171)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1171 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1171;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 18][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 20][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 20].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 20][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1174)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1178, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1177 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1177;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1178)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1178 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1178;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1179)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1183, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1174 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1174;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1176)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1176 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1176;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1179)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1183, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1182 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1182;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1183)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1183 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1183;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1181)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1179 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1179;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1181)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1181 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1181;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1184)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1188, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1187 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1187;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1188)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1188 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1188;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1186)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1184 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1184;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1186)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1186 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1186;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch1194)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 16;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1194 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1194;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 20][36];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 22][15] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 22].names[15]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 22][15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1198)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1202, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1201 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1201;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1202)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1202 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1202;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1200)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1198 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1198;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1200)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1200 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1200;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 22][16]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1205)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1209, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1208 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1208;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1209)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1209 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1209;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1207)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1205 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1205;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1207)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1207 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1207;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 25][34];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "solid";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1212)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1216, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1215 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1215;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1216)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1216 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1216;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1214)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1212 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1212;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1214)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1214 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1214;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 21][8] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 21].names[8]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 21][8];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 22][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 22].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 22][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1217)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1221, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1220 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1220;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1221)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1221 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1221;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1222)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1226, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1217 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1217;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1219)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1219 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1219;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1222)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1226, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1225 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1225;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1226)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1226 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1226;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1224)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1222 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1222;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1224)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1224 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1224;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 20][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 22][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 22].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 22][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1227)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1231, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1230 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1230;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1231)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1231 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1231;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1232)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1236, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1227 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1227;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1229)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1229 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1229;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1232)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1236, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1235 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1235;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1236)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1236 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1236;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1234)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1232 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1232;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1234)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1234 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1234;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1237)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1241, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1240 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1240;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1241)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1241 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1241;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1239)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1237 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1237;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1239)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1239 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1239;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch1247)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 18;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1247 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1247;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 22][36];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 24][15] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 24].names[15]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 24][15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1251)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1255, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1254 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1254;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1255)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1255 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1255;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1253)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1251 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1251;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1253)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1253 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1253;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 24][16]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1258)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1262, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1261 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1261;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1262)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1262 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1262;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1260)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1258 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1258;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1260)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1260 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1260;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 27][34];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "solid";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1265)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1269, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1268 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1268;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1269)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1269 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1269;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1267)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1265 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1265;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1267)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1267 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1267;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 23][8] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 23].names[8]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 23][8];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 24][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 24].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 24][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1270)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1274, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1273 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1273;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1274)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1274 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1274;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1275)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1279, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1270 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1270;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1272)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1272 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1272;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1275)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1279, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1278 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1278;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1279)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1279 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1279;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1277)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1275 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1275;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1277)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1277 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1277;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 22][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 24][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 24].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 24][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1280)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1284, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1283 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1283;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1284)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1284 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1284;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1285)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1289, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1280 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1280;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1282)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1282 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1282;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1285)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1289, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1288 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1288;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1289)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1289 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1289;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1287)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1285 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1285;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1287)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1287 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1287;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1290)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1294, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1293 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1293;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1294)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1294 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1294;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1292)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1290 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1290;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1292)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1292 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1292;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch1300)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 20;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1300 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1300;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 24][36];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 26][15] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 26].names[15]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 26][15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1304)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1308, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1307 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1307;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1308)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1308 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1308;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1306)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1304 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1304;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1306)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1306 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1306;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 26][16]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1311)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1315, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1314 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1314;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1315)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1315 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1315;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1313)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1311 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1311;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1313)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1313 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1313;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 29][34];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "solid";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1318)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1322, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1321 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1321;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1322)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1322 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1322;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1320)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1318 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1318;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1320)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1320 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1320;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 25][8] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 25].names[8]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 25][8];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 26][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 26].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 26][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1323)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1327, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1326 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1326;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1327)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1327 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1327;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1328)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1332, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1323 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1323;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1325)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1325 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1325;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1328)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1332, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1331 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1331;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1332)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1332 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1332;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1330)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1328 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1328;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1330)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1330 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1330;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 24][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 26][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 26].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 26][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1333)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1337, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1336 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1336;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1337)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1337 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1337;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1338)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1342, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1333 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1333;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1335)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1335 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1335;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1338)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1342, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1341 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1341;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1342)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1342 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1342;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1340)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1338 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1338;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1340)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1340 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1340;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1343)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1347, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1346 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1346;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1347)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1347 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1347;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1345)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1343 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1343;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1345)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1345 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1345;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 2]))).rest;
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === RUNTIME.NULL);
|
|
if (MACHINE.val === false) { return (_falseBranch1353)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env.length = MACHINE.env.length - 22;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1353 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1353;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 23][37];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 23][35];
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "car", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 4]))).first;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 28][36];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 30][15] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 30].names[15]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 30][15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1357)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1361, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1360 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1360;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1361)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1361 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1361;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1359)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1357 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1357;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1359)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1359 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1359;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 30][16]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1364)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1368, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1367 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1367;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1368)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1368 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1368;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1366)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1364 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1364;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1366)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1366 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1366;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 33][34];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "solid";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1371)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1375, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1374 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1374;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1375)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1375 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1375;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1373)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1371 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1371;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1373)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1373 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1373;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 29][8] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 29].names[8]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 29][8];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 30][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 30].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 30][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1376)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1380, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1379 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1379;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1380)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1380 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1380;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1381)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1385, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1376 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1376;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1378)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1378 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1378;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1381)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1385, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1384 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1384;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1385)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1385 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1385;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1383)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1381 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1381;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1383)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1383 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1383;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 28][9]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 30][13] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 30].names[13]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 30][13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1386)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1390, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1389 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1389;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1390)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1390 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1390;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1391)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1395, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1386 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1386;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1388)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1388 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1388;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1391)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1395, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1394 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1394;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1395)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1395 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1395;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1393)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1391 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1391;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1393)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1393 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1393;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1396)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1400, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1399 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1399;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1400)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1400 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1400;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1398)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1396 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1396;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1398)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1398 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1398;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=(((RUNTIME.isPair(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "cdr", "pair", 0, MACHINE.env[MACHINE.env.length - 1 - 3]))).rest;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1401)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (3 + 22), 22);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1401 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1401;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 22;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 22;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 21;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 20;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 19;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 18;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 17;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 16;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 15;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 14;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 13;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 12;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 11;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 10;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 9;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 3;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies149 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies149;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt151, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/racketcon/rain.rkt"]=new RUNTIME.ModuleRecord("rain", _moduleEntry1407);
|
|
return (_afterModuleBody1406)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry1407 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry1407;
|
|
}
|
|
MACHINE.modules["whalesong/racketcon/rain.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/lang/base.rkt"] !== undefined) !== false) { return (_linked1408)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/lang/base.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1409)(MACHINE);
|
|
};
|
|
|
|
var _linked1408 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1408;
|
|
}
|
|
if (MACHINE.modules["whalesong/lang/base.rkt"].isInvoked !== false) { return (_alreadyLoaded1409)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1411, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/lang/base.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1410 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1410;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1411)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1411 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1411;
|
|
}
|
|
if ((MACHINE.modules["whalesong/world.rkt"] !== undefined) !== false) { return (_linked1412)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/world.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1413)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1409 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1409;
|
|
}
|
|
if ((MACHINE.modules["whalesong/world.rkt"] !== undefined) !== false) { return (_linked1412)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/world.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1413)(MACHINE);
|
|
};
|
|
|
|
var _linked1412 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1412;
|
|
}
|
|
if (MACHINE.modules["whalesong/world.rkt"].isInvoked !== false) { return (_alreadyLoaded1413)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1415, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/world.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1414 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1414;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1415)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1415 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1415;
|
|
}
|
|
MACHINE.env.push([MACHINE.params.currentNamespace["WIDTH"] || MACHINE.primitives["WIDTH"],MACHINE.params.currentNamespace["HEIGHT"] || MACHINE.primitives["HEIGHT"],MACHINE.params.currentNamespace["GRAVITY-FACTOR"] || MACHINE.primitives["GRAVITY-FACTOR"],MACHINE.params.currentNamespace["BACKGROUND"] || MACHINE.primitives["BACKGROUND"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["empty-scene15.15"],MACHINE.params.currentNamespace["struct:posn"] || MACHINE.primitives["struct:posn"],MACHINE.params.currentNamespace["make-posn"] || MACHINE.primitives["make-posn"],MACHINE.params.currentNamespace["posn?"] || MACHINE.primitives["posn?"],MACHINE.params.currentNamespace["posn-x"] || MACHINE.primitives["posn-x"],MACHINE.params.currentNamespace["posn-y"] || MACHINE.primitives["posn-y"],MACHINE.params.currentNamespace["struct:drop"] || MACHINE.primitives["struct:drop"],MACHINE.params.currentNamespace["make-drop"] || MACHINE.primitives["make-drop"],MACHINE.params.currentNamespace["drop?"] || MACHINE.primitives["drop?"],MACHINE.params.currentNamespace["drop-posn"] || MACHINE.primitives["drop-posn"],MACHINE.params.currentNamespace["drop-velocity"] || MACHINE.primitives["drop-velocity"],MACHINE.params.currentNamespace["drop-color"] || MACHINE.primitives["drop-color"],MACHINE.params.currentNamespace["drop-size"] || MACHINE.primitives["drop-size"],MACHINE.params.currentNamespace["random-drop"] || MACHINE.primitives["random-drop"],MACHINE.primitives["random"],MACHINE.params.currentNamespace["random-choice"] || MACHINE.primitives["random-choice"],MACHINE.primitives["list-ref"],MACHINE.primitives["length"],MACHINE.params.currentNamespace["struct:world"] || MACHINE.primitives["struct:world"],MACHINE.params.currentNamespace["make-world"] || MACHINE.primitives["make-world"],MACHINE.params.currentNamespace["world?"] || MACHINE.primitives["world?"],MACHINE.params.currentNamespace["world-sky"] || MACHINE.primitives["world-sky"],MACHINE.params.currentNamespace["my-filter"] || MACHINE.primitives["my-filter"],MACHINE.params.currentNamespace["tick"] || MACHINE.primitives["tick"],MACHINE.params.currentNamespace["not-on-floor?"] || MACHINE.primitives["not-on-floor?"],MACHINE.primitives["map"],MACHINE.params.currentNamespace["drop-descend"] || MACHINE.primitives["drop-descend"],MACHINE.params.currentNamespace["posn-descend"] || MACHINE.primitives["posn-descend"],MACHINE.params.currentNamespace["on-floor?"] || MACHINE.primitives["on-floor?"],MACHINE.params.currentNamespace["make-drop-image"] || MACHINE.primitives["make-drop-image"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["circle28.28"],MACHINE.params.currentNamespace["place-drop"] || MACHINE.primitives["place-drop"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["place-image16.16"],MACHINE.params.currentNamespace["my-foldl"] || MACHINE.primitives["my-foldl"],MACHINE.params.currentNamespace["draw"] || MACHINE.primitives["draw"],MACHINE.modules["whalesong/world/main.rkt"].namespace["big-bang1.1"],MACHINE.modules["whalesong/world/main.rkt"].namespace["to-draw5.5"],MACHINE.modules["whalesong/world/main.rkt"].namespace["on-tick2.2"],MACHINE.modules["collects/racket/private/modbeg.rkt"].namespace["print-values"]]); MACHINE.env[MACHINE.env.length-1].names = ["WIDTH","HEIGHT","GRAVITY-FACTOR","BACKGROUND","empty-scene15.15","struct:posn","make-posn","posn?","posn-x","posn-y","struct:drop","make-drop","drop?","drop-posn","drop-velocity","drop-color","drop-size","random-drop","random","random-choice","list-ref","length","struct:world","make-world","world?","world-sky","my-filter","tick","not-on-floor?","map","drop-descend","posn-descend","on-floor?","make-drop-image","circle28.28","place-drop","place-image16.16","my-foldl","draw","big-bang1.1","to-draw5.5","on-tick2.2","print-values"];
|
|
MACHINE.modules["whalesong/racketcon/rain.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1417, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val = 640;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1413 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1413;
|
|
}
|
|
MACHINE.env.push([MACHINE.params.currentNamespace["WIDTH"] || MACHINE.primitives["WIDTH"],MACHINE.params.currentNamespace["HEIGHT"] || MACHINE.primitives["HEIGHT"],MACHINE.params.currentNamespace["GRAVITY-FACTOR"] || MACHINE.primitives["GRAVITY-FACTOR"],MACHINE.params.currentNamespace["BACKGROUND"] || MACHINE.primitives["BACKGROUND"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["empty-scene15.15"],MACHINE.params.currentNamespace["struct:posn"] || MACHINE.primitives["struct:posn"],MACHINE.params.currentNamespace["make-posn"] || MACHINE.primitives["make-posn"],MACHINE.params.currentNamespace["posn?"] || MACHINE.primitives["posn?"],MACHINE.params.currentNamespace["posn-x"] || MACHINE.primitives["posn-x"],MACHINE.params.currentNamespace["posn-y"] || MACHINE.primitives["posn-y"],MACHINE.params.currentNamespace["struct:drop"] || MACHINE.primitives["struct:drop"],MACHINE.params.currentNamespace["make-drop"] || MACHINE.primitives["make-drop"],MACHINE.params.currentNamespace["drop?"] || MACHINE.primitives["drop?"],MACHINE.params.currentNamespace["drop-posn"] || MACHINE.primitives["drop-posn"],MACHINE.params.currentNamespace["drop-velocity"] || MACHINE.primitives["drop-velocity"],MACHINE.params.currentNamespace["drop-color"] || MACHINE.primitives["drop-color"],MACHINE.params.currentNamespace["drop-size"] || MACHINE.primitives["drop-size"],MACHINE.params.currentNamespace["random-drop"] || MACHINE.primitives["random-drop"],MACHINE.primitives["random"],MACHINE.params.currentNamespace["random-choice"] || MACHINE.primitives["random-choice"],MACHINE.primitives["list-ref"],MACHINE.primitives["length"],MACHINE.params.currentNamespace["struct:world"] || MACHINE.primitives["struct:world"],MACHINE.params.currentNamespace["make-world"] || MACHINE.primitives["make-world"],MACHINE.params.currentNamespace["world?"] || MACHINE.primitives["world?"],MACHINE.params.currentNamespace["world-sky"] || MACHINE.primitives["world-sky"],MACHINE.params.currentNamespace["my-filter"] || MACHINE.primitives["my-filter"],MACHINE.params.currentNamespace["tick"] || MACHINE.primitives["tick"],MACHINE.params.currentNamespace["not-on-floor?"] || MACHINE.primitives["not-on-floor?"],MACHINE.primitives["map"],MACHINE.params.currentNamespace["drop-descend"] || MACHINE.primitives["drop-descend"],MACHINE.params.currentNamespace["posn-descend"] || MACHINE.primitives["posn-descend"],MACHINE.params.currentNamespace["on-floor?"] || MACHINE.primitives["on-floor?"],MACHINE.params.currentNamespace["make-drop-image"] || MACHINE.primitives["make-drop-image"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["circle28.28"],MACHINE.params.currentNamespace["place-drop"] || MACHINE.primitives["place-drop"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["place-image16.16"],MACHINE.params.currentNamespace["my-foldl"] || MACHINE.primitives["my-foldl"],MACHINE.params.currentNamespace["draw"] || MACHINE.primitives["draw"],MACHINE.modules["whalesong/world/main.rkt"].namespace["big-bang1.1"],MACHINE.modules["whalesong/world/main.rkt"].namespace["to-draw5.5"],MACHINE.modules["whalesong/world/main.rkt"].namespace["on-tick2.2"],MACHINE.modules["collects/racket/private/modbeg.rkt"].namespace["print-values"]]); MACHINE.env[MACHINE.env.length-1].names = ["WIDTH","HEIGHT","GRAVITY-FACTOR","BACKGROUND","empty-scene15.15","struct:posn","make-posn","posn?","posn-x","posn-y","struct:drop","make-drop","drop?","drop-posn","drop-velocity","drop-color","drop-size","random-drop","random","random-choice","list-ref","length","struct:world","make-world","world?","world-sky","my-filter","tick","not-on-floor?","map","drop-descend","posn-descend","on-floor?","make-drop-image","circle28.28","place-drop","place-image16.16","my-foldl","draw","big-bang1.1","to-draw5.5","on-tick2.2","print-values"];
|
|
MACHINE.modules["whalesong/racketcon/rain.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1417, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val = 640;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1416 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1416;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1417)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1417 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1417;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1419, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val = 480;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1418 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1418;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1419)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1419 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1419;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1421, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][2] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1420 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1420;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1421)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1421 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1421;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1423, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 2][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = 640;
|
|
MACHINE.val = 480;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1424)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1428, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1427 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1427;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1428)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1428 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1428;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][3] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1424 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1424;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1426)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1426 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1426;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][3] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1422 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1422;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1423)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1423 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1423;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1430, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = MACHINE.primitives["make-struct-type"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = RUNTIME.makeSymbol("posn");
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 2;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = RUNTIME.NULL;
|
|
|
|
MACHINE.proc = MACHINE.primitives["current-inspector"];
|
|
MACHINE.argcount = 0;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1433)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1437, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1436 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1436;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1437)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1437 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1437;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
return (_afterCall1435)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1433 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1433;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
return (_afterCall1435)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1435 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1435;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = RUNTIME.makePair(0, RUNTIME.makePair(1, RUNTIME.NULL));
|
|
MACHINE.env[MACHINE.env.length - 1 - 9] = false;
|
|
MACHINE.val = RUNTIME.makeSymbol("posn");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = MACHINE.val;
|
|
MACHINE.argcount = 11;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1438)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1442, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1441 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1441;
|
|
}
|
|
if ((MACHINE.argcount - 5) === 0) { return (_afterValueCheck1443)(MACHINE); }
|
|
return (_procReturn1442)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1442 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1442;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 5);
|
|
return (_afterValueCheck1443)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck1443 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck1443;
|
|
}
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.primitives["values"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 0;
|
|
MACHINE.val = RUNTIME.makeSymbol("x");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1444)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1448, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1438 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1438;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.argcount = 1;
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 5);
|
|
return (_afterCall1440)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1440 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1440;
|
|
}
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.primitives["values"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 0;
|
|
MACHINE.val = RUNTIME.makeSymbol("x");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1444)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1448, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1447 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1447;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1448)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1448 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1448;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall1446)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1444 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1444;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall1446)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1446 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1446;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.val = RUNTIME.makeSymbol("y");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1449)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1453, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1452 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1452;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1453)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1453 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1453;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
MACHINE.argcount = 5;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1454)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1458, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1449 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1449;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1451)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1451 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1451;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
MACHINE.argcount = 5;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1454)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1458, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1457 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1457;
|
|
}
|
|
if ((MACHINE.argcount - 5) === 0) { return (_afterValueCheck1459)(MACHINE); }
|
|
return (_procReturn1458)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1458 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1458;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 5);
|
|
return (_afterValueCheck1459)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck1459 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck1459;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((5 - 1) + 5), 5);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4][5] = MACHINE.val;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4][6] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4][7] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4][8] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4][9] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1454 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1454;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.argcount = 1;
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 5);
|
|
return (_afterCall1456)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1456 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1456;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((5 - 1) + 5), 5);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4][5] = MACHINE.val;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4][6] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4][7] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4][8] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4][9] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1429 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1429;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1430)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1430 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1430;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1461, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = MACHINE.primitives["make-struct-type"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = RUNTIME.makeSymbol("drop");
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 4;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = RUNTIME.NULL;
|
|
|
|
MACHINE.proc = MACHINE.primitives["current-inspector"];
|
|
MACHINE.argcount = 0;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1464)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1468, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1467 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1467;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1468)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1468 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1468;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
return (_afterCall1466)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1464 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1464;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
return (_afterCall1466)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1466 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1466;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = RUNTIME.makePair(0, RUNTIME.makePair(1, RUNTIME.makePair(2, RUNTIME.makePair(3, RUNTIME.NULL))));
|
|
MACHINE.env[MACHINE.env.length - 1 - 9] = false;
|
|
MACHINE.val = RUNTIME.makeSymbol("drop");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = MACHINE.val;
|
|
MACHINE.argcount = 11;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1469)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1473, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1472 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1472;
|
|
}
|
|
if ((MACHINE.argcount - 5) === 0) { return (_afterValueCheck1474)(MACHINE); }
|
|
return (_procReturn1473)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1473 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1473;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 5);
|
|
return (_afterValueCheck1474)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck1474 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck1474;
|
|
}
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.primitives["values"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 0;
|
|
MACHINE.val = RUNTIME.makeSymbol("posn");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1475)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1479, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1469 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1469;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.argcount = 1;
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 5);
|
|
return (_afterCall1471)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1471 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1471;
|
|
}
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.primitives["values"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 0;
|
|
MACHINE.val = RUNTIME.makeSymbol("posn");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1475)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1479, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1478 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1478;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1479)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1479 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1479;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall1477)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1475 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1475;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall1477)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1477 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1477;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.val = RUNTIME.makeSymbol("velocity");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1480)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1484, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1483 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1483;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1484)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1484 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1484;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
return (_afterCall1482)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1480 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1480;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
return (_afterCall1482)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1482 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1482;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 2;
|
|
MACHINE.val = RUNTIME.makeSymbol("color");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1485)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1489, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1488 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1488;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1489)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1489 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1489;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
return (_afterCall1487)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1485 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1485;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
return (_afterCall1487)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1487 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1487;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 3;
|
|
MACHINE.val = RUNTIME.makeSymbol("size");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1490)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1494, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1493 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1493;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1494)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1494 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1494;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
MACHINE.argcount = 7;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1495)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1499, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1490 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1490;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1492)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1492 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1492;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
MACHINE.argcount = 7;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1495)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1499, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1498 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1498;
|
|
}
|
|
if ((MACHINE.argcount - 7) === 0) { return (_afterValueCheck1500)(MACHINE); }
|
|
return (_procReturn1499)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1499 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1499;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 7);
|
|
return (_afterValueCheck1500)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck1500 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck1500;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((7 - 1) + 5), 5);
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][10] = MACHINE.val;
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][11] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][12] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][13] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][14] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][15] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][16] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1495 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1495;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.argcount = 1;
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 7);
|
|
return (_afterCall1497)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1497 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1497;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((7 - 1) + 5), 5);
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][10] = MACHINE.val;
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][11] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][12] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][13] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][14] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][15] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][16] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1460 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1460;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1461)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1461 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1461;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1502, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry12, 0, [MACHINE.env[MACHINE.env.length - 1 - 0]], "random-drop");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][17] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1501 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1501;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1502)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1502 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1502;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1504, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry13, 1, [MACHINE.env[MACHINE.env.length - 1 - 0]], "random-choice");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][19] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1503 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1503;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1504)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1504 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1504;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1506, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = MACHINE.primitives["make-struct-type"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = RUNTIME.makeSymbol("world");
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = RUNTIME.NULL;
|
|
|
|
MACHINE.proc = MACHINE.primitives["current-inspector"];
|
|
MACHINE.argcount = 0;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1509)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1513, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1512 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1512;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1513)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1513 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1513;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
return (_afterCall1511)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1509 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1509;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
return (_afterCall1511)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1511 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1511;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = RUNTIME.makePair(0, RUNTIME.NULL);
|
|
MACHINE.env[MACHINE.env.length - 1 - 9] = false;
|
|
MACHINE.val = RUNTIME.makeSymbol("world");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = MACHINE.val;
|
|
MACHINE.argcount = 11;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1514)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1518, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1517 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1517;
|
|
}
|
|
if ((MACHINE.argcount - 5) === 0) { return (_afterValueCheck1519)(MACHINE); }
|
|
return (_procReturn1518)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1518 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1518;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 5);
|
|
return (_afterValueCheck1519)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck1519 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck1519;
|
|
}
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.primitives["values"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 0;
|
|
MACHINE.val = RUNTIME.makeSymbol("sky");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1520)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1524, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1514 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1514;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.argcount = 1;
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 5);
|
|
return (_afterCall1516)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1516 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1516;
|
|
}
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.primitives["values"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 0;
|
|
MACHINE.val = RUNTIME.makeSymbol("sky");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1520)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1524, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1523 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1523;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1524)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1524 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1524;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1525)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1529, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1520 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1520;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1522)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1522 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1522;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1525)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1529, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1528 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1528;
|
|
}
|
|
if ((MACHINE.argcount - 4) === 0) { return (_afterValueCheck1530)(MACHINE); }
|
|
return (_procReturn1529)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1529 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1529;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 4);
|
|
return (_afterValueCheck1530)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck1530 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck1530;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((4 - 1) + 5), 5);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3][22] = MACHINE.val;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3][23] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3][24] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3][25] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env.length = MACHINE.env.length - 3;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1525 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1525;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.argcount = 1;
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 4);
|
|
return (_afterCall1527)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1527 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1527;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((4 - 1) + 5), 5);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3][22] = MACHINE.val;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3][23] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3][24] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3][25] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env.length = MACHINE.env.length - 3;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1505 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1505;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1506)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1506 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1506;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1532, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry14, 2, [MACHINE.env[MACHINE.env.length - 1 - 0]], "my-filter");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][26] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1531 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1531;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1532)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1532 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1532;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1534, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry15, 1, [MACHINE.env[MACHINE.env.length - 1 - 0]], "tick");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][27] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1533 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1533;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1534)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1534 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1534;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1536, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry16, 1, [MACHINE.env[MACHINE.env.length - 1 - 0]], "drop-descend");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][30] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1535 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1535;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1536)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1536 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1536;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1538, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry17, 2, [MACHINE.env[MACHINE.env.length - 1 - 0]], "posn-descend");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][31] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1537 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1537;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1538)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1538 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1538;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1540, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry18, 1, [MACHINE.env[MACHINE.env.length - 1 - 0]], "on-floor?");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][32] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1539 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1539;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1540)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1540 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1540;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1542, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry19, 1, [MACHINE.env[MACHINE.env.length - 1 - 0]], "not-on-floor?");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][28] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1541 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1541;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1542)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1542 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1542;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1544, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry20, 2, [MACHINE.env[MACHINE.env.length - 1 - 0]], "make-drop-image");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][33] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1543 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1543;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1544)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1544 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1544;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1546, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry21, 2, [MACHINE.env[MACHINE.env.length - 1 - 0]], "place-drop");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][35] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1545 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1545;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1546)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1546 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1546;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1548, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry22, 3, [MACHINE.env[MACHINE.env.length - 1 - 0]], "my-foldl");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][37] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1547 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1547;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1548)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1548 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1548;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1550, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry23, 1, [MACHINE.env[MACHINE.env.length - 1 - 0]], "draw");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][38] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1549 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1549;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1550)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1550 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1550;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1552, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.control.push(new RUNTIME.Frame());
|
|
MACHINE.control[MACHINE.control.length-1].pendingApplyValuesProc = MACHINE.env[MACHINE.env.length - 1 - 0][42];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][39];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][23] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[23]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][23];
|
|
MACHINE.val = RUNTIME.NULL;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1555)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1559, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1558 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1558;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1559)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1559 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1559;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1557)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1555 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1555;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1557)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1557 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1557;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 3][40]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4][38];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1560)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1564, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1563 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1563;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1564)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1564 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1564;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1562)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1560 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1560;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1562)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1562 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1562;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 3][41]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4][27];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1565)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1569, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1568 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1568;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1569)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1569 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1569;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1570)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1574, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1565 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1565;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1567)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1567 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1567;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1570)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1574, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1573 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1573;
|
|
}
|
|
if (MACHINE.argcount === 0) { return (_afterArgsEvaluated1554)(MACHINE); }
|
|
MACHINE.env.push(MACHINE.val);
|
|
return (_afterArgsEvaluated1554)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1574 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1574;
|
|
}
|
|
MACHINE.argcount = 1;
|
|
return (_afterReturn1575)(MACHINE);
|
|
};
|
|
|
|
var _afterReturn1575 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterReturn1575;
|
|
}
|
|
if (MACHINE.argcount === 0) { return (_afterArgsEvaluated1554)(MACHINE); }
|
|
MACHINE.env.push(MACHINE.val);
|
|
return (_afterArgsEvaluated1554)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1570 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1570;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.argcount = 1;
|
|
return (_afterCall1572)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1572 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1572;
|
|
}
|
|
if (MACHINE.argcount === 0) { return (_afterArgsEvaluated1554)(MACHINE); }
|
|
MACHINE.env.push(MACHINE.val);
|
|
return (_afterArgsEvaluated1554)(MACHINE);
|
|
};
|
|
|
|
var _afterArgsEvaluated1554 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterArgsEvaluated1554;
|
|
}
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].pendingApplyValuesProc;
|
|
MACHINE.control.pop();
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1576)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1580, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1579 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1579;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1580)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1580 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1580;
|
|
}
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1576 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1576;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1578)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1578 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1578;
|
|
}
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1551 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1551;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1552)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1552 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1552;
|
|
}
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
MACHINE.modules["whalesong/racketcon/rain.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterModuleBody1406 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody1406;
|
|
}
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple150 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple150;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt151)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt151 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt151;
|
|
}
|
|
MACHINE.mainModules.push(MACHINE.modules["whalesong/racketcon/rain.rkt"]);
|
|
};
|
|
|
|
_procReturn156.multipleValueReturn = _procReturnMultiple155;
|
|
_procReturn161.multipleValueReturn = _procReturnMultiple160;
|
|
_procReturn166.multipleValueReturn = _procReturnMultiple165;
|
|
_procReturn173.multipleValueReturn = _procReturnMultiple172;
|
|
_procReturn178.multipleValueReturn = _procReturnMultiple177;
|
|
_procReturn183.multipleValueReturn = _procReturnMultiple182;
|
|
_procReturn188.multipleValueReturn = _procReturnMultiple187;
|
|
_procReturn198.multipleValueReturn = _procReturnMultiple197;
|
|
_procReturn203.multipleValueReturn = _procReturnMultiple202;
|
|
_procReturn219.multipleValueReturn = _procReturnMultiple218;
|
|
_procReturn232.multipleValueReturn = _procReturnMultiple231;
|
|
_procReturn245.multipleValueReturn = _procReturnMultiple244;
|
|
_procReturn258.multipleValueReturn = _procReturnMultiple257;
|
|
_procReturn263.multipleValueReturn = _procReturnMultiple262;
|
|
_procReturn268.multipleValueReturn = _procReturnMultiple267;
|
|
_procReturn281.multipleValueReturn = _procReturnMultiple280;
|
|
_procReturn286.multipleValueReturn = _procReturnMultiple285;
|
|
_procReturn291.multipleValueReturn = _procReturnMultiple290;
|
|
_procReturn304.multipleValueReturn = _procReturnMultiple303;
|
|
_procReturn317.multipleValueReturn = _procReturnMultiple316;
|
|
_procReturn322.multipleValueReturn = _procReturnMultiple321;
|
|
_procReturn327.multipleValueReturn = _procReturnMultiple326;
|
|
_procReturn340.multipleValueReturn = _procReturnMultiple339;
|
|
_procReturn345.multipleValueReturn = _procReturnMultiple344;
|
|
_procReturn350.multipleValueReturn = _procReturnMultiple349;
|
|
_procReturn363.multipleValueReturn = _procReturnMultiple362;
|
|
_procReturn376.multipleValueReturn = _procReturnMultiple375;
|
|
_procReturn389.multipleValueReturn = _procReturnMultiple388;
|
|
_procReturn394.multipleValueReturn = _procReturnMultiple393;
|
|
_procReturn399.multipleValueReturn = _procReturnMultiple398;
|
|
_procReturn412.multipleValueReturn = _procReturnMultiple411;
|
|
_procReturn417.multipleValueReturn = _procReturnMultiple416;
|
|
_procReturn422.multipleValueReturn = _procReturnMultiple421;
|
|
_procReturn435.multipleValueReturn = _procReturnMultiple434;
|
|
_procReturn448.multipleValueReturn = _procReturnMultiple447;
|
|
_procReturn453.multipleValueReturn = _procReturnMultiple452;
|
|
_procReturn458.multipleValueReturn = _procReturnMultiple457;
|
|
_procReturn471.multipleValueReturn = _procReturnMultiple470;
|
|
_procReturn476.multipleValueReturn = _procReturnMultiple475;
|
|
_procReturn486.multipleValueReturn = _procReturnMultiple485;
|
|
_procReturn491.multipleValueReturn = _procReturnMultiple490;
|
|
_procReturn496.multipleValueReturn = _procReturnMultiple495;
|
|
_procReturn501.multipleValueReturn = _procReturnMultiple500;
|
|
_procReturn516.multipleValueReturn = _procReturnMultiple515;
|
|
_procReturn521.multipleValueReturn = _procReturnMultiple520;
|
|
_procReturn536.multipleValueReturn = _procReturnMultiple535;
|
|
_procReturn541.multipleValueReturn = _procReturnMultiple540;
|
|
_procReturn554.multipleValueReturn = _procReturnMultiple553;
|
|
_procReturn559.multipleValueReturn = _procReturnMultiple558;
|
|
_procReturn564.multipleValueReturn = _procReturnMultiple563;
|
|
_procReturn577.multipleValueReturn = _procReturnMultiple576;
|
|
_procReturn582.multipleValueReturn = _procReturnMultiple581;
|
|
_procReturn587.multipleValueReturn = _procReturnMultiple586;
|
|
_procReturn602.multipleValueReturn = _procReturnMultiple601;
|
|
_procReturn607.multipleValueReturn = _procReturnMultiple606;
|
|
_procReturn620.multipleValueReturn = _procReturnMultiple619;
|
|
_procReturn625.multipleValueReturn = _procReturnMultiple624;
|
|
_procReturn630.multipleValueReturn = _procReturnMultiple629;
|
|
_procReturn643.multipleValueReturn = _procReturnMultiple642;
|
|
_procReturn648.multipleValueReturn = _procReturnMultiple647;
|
|
_procReturn653.multipleValueReturn = _procReturnMultiple652;
|
|
_procReturn666.multipleValueReturn = _procReturnMultiple665;
|
|
_procReturn671.multipleValueReturn = _procReturnMultiple670;
|
|
_procReturn676.multipleValueReturn = _procReturnMultiple675;
|
|
_procReturn683.multipleValueReturn = _procReturnMultiple682;
|
|
_procReturn690.multipleValueReturn = _procReturnMultiple689;
|
|
_procReturn695.multipleValueReturn = _procReturnMultiple694;
|
|
_procReturn700.multipleValueReturn = _procReturnMultiple699;
|
|
_procReturn705.multipleValueReturn = _procReturnMultiple704;
|
|
_procReturn710.multipleValueReturn = _procReturnMultiple709;
|
|
_procReturn715.multipleValueReturn = _procReturnMultiple714;
|
|
_procReturn725.multipleValueReturn = _procReturnMultiple724;
|
|
_procReturn730.multipleValueReturn = _procReturnMultiple729;
|
|
_procReturn740.multipleValueReturn = _procReturnMultiple739;
|
|
_procReturn745.multipleValueReturn = _procReturnMultiple744;
|
|
_procReturn750.multipleValueReturn = _procReturnMultiple749;
|
|
_procReturn755.multipleValueReturn = _procReturnMultiple754;
|
|
_procReturn765.multipleValueReturn = _procReturnMultiple764;
|
|
_procReturn772.multipleValueReturn = _procReturnMultiple771;
|
|
_procReturn779.multipleValueReturn = _procReturnMultiple778;
|
|
_procReturn784.multipleValueReturn = _procReturnMultiple783;
|
|
_procReturn789.multipleValueReturn = _procReturnMultiple788;
|
|
_procReturn794.multipleValueReturn = _procReturnMultiple793;
|
|
_procReturn799.multipleValueReturn = _procReturnMultiple798;
|
|
_procReturn812.multipleValueReturn = _procReturnMultiple811;
|
|
_procReturn824.multipleValueReturn = _procReturnMultiple823;
|
|
_procReturn836.multipleValueReturn = _procReturnMultiple835;
|
|
_procReturn848.multipleValueReturn = _procReturnMultiple847;
|
|
_procReturn860.multipleValueReturn = _procReturnMultiple859;
|
|
_procReturn872.multipleValueReturn = _procReturnMultiple871;
|
|
_procReturn884.multipleValueReturn = _procReturnMultiple883;
|
|
_procReturn891.multipleValueReturn = _procReturnMultiple890;
|
|
_procReturn898.multipleValueReturn = _procReturnMultiple897;
|
|
_procReturn903.multipleValueReturn = _procReturnMultiple902;
|
|
_procReturn908.multipleValueReturn = _procReturnMultiple907;
|
|
_procReturn913.multipleValueReturn = _procReturnMultiple912;
|
|
_procReturn918.multipleValueReturn = _procReturnMultiple917;
|
|
_procReturn923.multipleValueReturn = _procReturnMultiple922;
|
|
_procReturn937.multipleValueReturn = _procReturnMultiple936;
|
|
_procReturn944.multipleValueReturn = _procReturnMultiple943;
|
|
_procReturn951.multipleValueReturn = _procReturnMultiple950;
|
|
_procReturn956.multipleValueReturn = _procReturnMultiple955;
|
|
_procReturn961.multipleValueReturn = _procReturnMultiple960;
|
|
_procReturn966.multipleValueReturn = _procReturnMultiple965;
|
|
_procReturn971.multipleValueReturn = _procReturnMultiple970;
|
|
_procReturn976.multipleValueReturn = _procReturnMultiple975;
|
|
_procReturn990.multipleValueReturn = _procReturnMultiple989;
|
|
_procReturn997.multipleValueReturn = _procReturnMultiple996;
|
|
_procReturn1004.multipleValueReturn = _procReturnMultiple1003;
|
|
_procReturn1009.multipleValueReturn = _procReturnMultiple1008;
|
|
_procReturn1014.multipleValueReturn = _procReturnMultiple1013;
|
|
_procReturn1019.multipleValueReturn = _procReturnMultiple1018;
|
|
_procReturn1024.multipleValueReturn = _procReturnMultiple1023;
|
|
_procReturn1029.multipleValueReturn = _procReturnMultiple1028;
|
|
_procReturn1043.multipleValueReturn = _procReturnMultiple1042;
|
|
_procReturn1050.multipleValueReturn = _procReturnMultiple1049;
|
|
_procReturn1057.multipleValueReturn = _procReturnMultiple1056;
|
|
_procReturn1062.multipleValueReturn = _procReturnMultiple1061;
|
|
_procReturn1067.multipleValueReturn = _procReturnMultiple1066;
|
|
_procReturn1072.multipleValueReturn = _procReturnMultiple1071;
|
|
_procReturn1077.multipleValueReturn = _procReturnMultiple1076;
|
|
_procReturn1082.multipleValueReturn = _procReturnMultiple1081;
|
|
_procReturn1096.multipleValueReturn = _procReturnMultiple1095;
|
|
_procReturn1103.multipleValueReturn = _procReturnMultiple1102;
|
|
_procReturn1110.multipleValueReturn = _procReturnMultiple1109;
|
|
_procReturn1115.multipleValueReturn = _procReturnMultiple1114;
|
|
_procReturn1120.multipleValueReturn = _procReturnMultiple1119;
|
|
_procReturn1125.multipleValueReturn = _procReturnMultiple1124;
|
|
_procReturn1130.multipleValueReturn = _procReturnMultiple1129;
|
|
_procReturn1135.multipleValueReturn = _procReturnMultiple1134;
|
|
_procReturn1149.multipleValueReturn = _procReturnMultiple1148;
|
|
_procReturn1156.multipleValueReturn = _procReturnMultiple1155;
|
|
_procReturn1163.multipleValueReturn = _procReturnMultiple1162;
|
|
_procReturn1168.multipleValueReturn = _procReturnMultiple1167;
|
|
_procReturn1173.multipleValueReturn = _procReturnMultiple1172;
|
|
_procReturn1178.multipleValueReturn = _procReturnMultiple1177;
|
|
_procReturn1183.multipleValueReturn = _procReturnMultiple1182;
|
|
_procReturn1188.multipleValueReturn = _procReturnMultiple1187;
|
|
_procReturn1202.multipleValueReturn = _procReturnMultiple1201;
|
|
_procReturn1209.multipleValueReturn = _procReturnMultiple1208;
|
|
_procReturn1216.multipleValueReturn = _procReturnMultiple1215;
|
|
_procReturn1221.multipleValueReturn = _procReturnMultiple1220;
|
|
_procReturn1226.multipleValueReturn = _procReturnMultiple1225;
|
|
_procReturn1231.multipleValueReturn = _procReturnMultiple1230;
|
|
_procReturn1236.multipleValueReturn = _procReturnMultiple1235;
|
|
_procReturn1241.multipleValueReturn = _procReturnMultiple1240;
|
|
_procReturn1255.multipleValueReturn = _procReturnMultiple1254;
|
|
_procReturn1262.multipleValueReturn = _procReturnMultiple1261;
|
|
_procReturn1269.multipleValueReturn = _procReturnMultiple1268;
|
|
_procReturn1274.multipleValueReturn = _procReturnMultiple1273;
|
|
_procReturn1279.multipleValueReturn = _procReturnMultiple1278;
|
|
_procReturn1284.multipleValueReturn = _procReturnMultiple1283;
|
|
_procReturn1289.multipleValueReturn = _procReturnMultiple1288;
|
|
_procReturn1294.multipleValueReturn = _procReturnMultiple1293;
|
|
_procReturn1308.multipleValueReturn = _procReturnMultiple1307;
|
|
_procReturn1315.multipleValueReturn = _procReturnMultiple1314;
|
|
_procReturn1322.multipleValueReturn = _procReturnMultiple1321;
|
|
_procReturn1327.multipleValueReturn = _procReturnMultiple1326;
|
|
_procReturn1332.multipleValueReturn = _procReturnMultiple1331;
|
|
_procReturn1337.multipleValueReturn = _procReturnMultiple1336;
|
|
_procReturn1342.multipleValueReturn = _procReturnMultiple1341;
|
|
_procReturn1347.multipleValueReturn = _procReturnMultiple1346;
|
|
_procReturn1361.multipleValueReturn = _procReturnMultiple1360;
|
|
_procReturn1368.multipleValueReturn = _procReturnMultiple1367;
|
|
_procReturn1375.multipleValueReturn = _procReturnMultiple1374;
|
|
_procReturn1380.multipleValueReturn = _procReturnMultiple1379;
|
|
_procReturn1385.multipleValueReturn = _procReturnMultiple1384;
|
|
_procReturn1390.multipleValueReturn = _procReturnMultiple1389;
|
|
_procReturn1395.multipleValueReturn = _procReturnMultiple1394;
|
|
_procReturn1400.multipleValueReturn = _procReturnMultiple1399;
|
|
_onReturn1411.multipleValueReturn = _onReturnMultiple1410;
|
|
_onReturn1415.multipleValueReturn = _onReturnMultiple1414;
|
|
_beforePromptPop1417.multipleValueReturn = _beforePromptPopMultiple1416;
|
|
_beforePromptPop1419.multipleValueReturn = _beforePromptPopMultiple1418;
|
|
_beforePromptPop1421.multipleValueReturn = _beforePromptPopMultiple1420;
|
|
_procReturn1428.multipleValueReturn = _procReturnMultiple1427;
|
|
_beforePromptPop1423.multipleValueReturn = _beforePromptPopMultiple1422;
|
|
_procReturn1437.multipleValueReturn = _procReturnMultiple1436;
|
|
_procReturn1442.multipleValueReturn = _procReturnMultiple1441;
|
|
_procReturn1448.multipleValueReturn = _procReturnMultiple1447;
|
|
_procReturn1453.multipleValueReturn = _procReturnMultiple1452;
|
|
_procReturn1458.multipleValueReturn = _procReturnMultiple1457;
|
|
_beforePromptPop1430.multipleValueReturn = _beforePromptPopMultiple1429;
|
|
_procReturn1468.multipleValueReturn = _procReturnMultiple1467;
|
|
_procReturn1473.multipleValueReturn = _procReturnMultiple1472;
|
|
_procReturn1479.multipleValueReturn = _procReturnMultiple1478;
|
|
_procReturn1484.multipleValueReturn = _procReturnMultiple1483;
|
|
_procReturn1489.multipleValueReturn = _procReturnMultiple1488;
|
|
_procReturn1494.multipleValueReturn = _procReturnMultiple1493;
|
|
_procReturn1499.multipleValueReturn = _procReturnMultiple1498;
|
|
_beforePromptPop1461.multipleValueReturn = _beforePromptPopMultiple1460;
|
|
_beforePromptPop1502.multipleValueReturn = _beforePromptPopMultiple1501;
|
|
_beforePromptPop1504.multipleValueReturn = _beforePromptPopMultiple1503;
|
|
_procReturn1513.multipleValueReturn = _procReturnMultiple1512;
|
|
_procReturn1518.multipleValueReturn = _procReturnMultiple1517;
|
|
_procReturn1524.multipleValueReturn = _procReturnMultiple1523;
|
|
_procReturn1529.multipleValueReturn = _procReturnMultiple1528;
|
|
_beforePromptPop1506.multipleValueReturn = _beforePromptPopMultiple1505;
|
|
_beforePromptPop1532.multipleValueReturn = _beforePromptPopMultiple1531;
|
|
_beforePromptPop1534.multipleValueReturn = _beforePromptPopMultiple1533;
|
|
_beforePromptPop1536.multipleValueReturn = _beforePromptPopMultiple1535;
|
|
_beforePromptPop1538.multipleValueReturn = _beforePromptPopMultiple1537;
|
|
_beforePromptPop1540.multipleValueReturn = _beforePromptPopMultiple1539;
|
|
_beforePromptPop1542.multipleValueReturn = _beforePromptPopMultiple1541;
|
|
_beforePromptPop1544.multipleValueReturn = _beforePromptPopMultiple1543;
|
|
_beforePromptPop1546.multipleValueReturn = _beforePromptPopMultiple1545;
|
|
_beforePromptPop1548.multipleValueReturn = _beforePromptPopMultiple1547;
|
|
_beforePromptPop1550.multipleValueReturn = _beforePromptPopMultiple1549;
|
|
_procReturn1559.multipleValueReturn = _procReturnMultiple1558;
|
|
_procReturn1564.multipleValueReturn = _procReturnMultiple1563;
|
|
_procReturn1569.multipleValueReturn = _procReturnMultiple1568;
|
|
_procReturn1574.multipleValueReturn = _procReturnMultiple1573;
|
|
_procReturn1580.multipleValueReturn = _procReturnMultiple1579;
|
|
_beforePromptPop1552.multipleValueReturn = _beforePromptPopMultiple1551;
|
|
_beforePopPrompt151.multipleValueReturn = _beforePopPromptMultiple150;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start1581); })(MACHINE, function() { (function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start1599 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start1599;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1584, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/world.rkt"]=new RUNTIME.ModuleRecord("world", _moduleEntry1586);
|
|
return (_afterModuleBody1585)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies1582 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies1582;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1584, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/world.rkt"]=new RUNTIME.ModuleRecord("world", _moduleEntry1586);
|
|
return (_afterModuleBody1585)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry1586 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry1586;
|
|
}
|
|
MACHINE.modules["whalesong/world.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/lang/base.rkt"] !== undefined) !== false) { return (_linked1587)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/lang/base.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1588)(MACHINE);
|
|
};
|
|
|
|
var _linked1587 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1587;
|
|
}
|
|
if (MACHINE.modules["whalesong/lang/base.rkt"].isInvoked !== false) { return (_alreadyLoaded1588)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1590, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/lang/base.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1589 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1589;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1590)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1590 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1590;
|
|
}
|
|
if ((MACHINE.modules["whalesong/world/main.rkt"] !== undefined) !== false) { return (_linked1591)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/world/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1592)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1588 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1588;
|
|
}
|
|
if ((MACHINE.modules["whalesong/world/main.rkt"] !== undefined) !== false) { return (_linked1591)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/world/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1592)(MACHINE);
|
|
};
|
|
|
|
var _linked1591 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1591;
|
|
}
|
|
if (MACHINE.modules["whalesong/world/main.rkt"].isInvoked !== false) { return (_alreadyLoaded1592)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1594, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/world/main.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1593 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1593;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1594)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1594 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1594;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image.rkt"] !== undefined) !== false) { return (_linked1595)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1596)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1592 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1592;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image.rkt"] !== undefined) !== false) { return (_linked1595)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1596)(MACHINE);
|
|
};
|
|
|
|
var _linked1595 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1595;
|
|
}
|
|
if (MACHINE.modules["whalesong/image.rkt"].isInvoked !== false) { return (_alreadyLoaded1596)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1598, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/image.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1597 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1597;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1598)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1598 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1598;
|
|
}
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.modules["whalesong/world.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
MACHINE.modules["whalesong/world.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1596 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1596;
|
|
}
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.modules["whalesong/world.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
MACHINE.modules["whalesong/world.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterModuleBody1585 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody1585;
|
|
}
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple1583 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple1583;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt1584)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt1584 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt1584;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn1590.multipleValueReturn = _onReturnMultiple1589;
|
|
_onReturn1594.multipleValueReturn = _onReturnMultiple1593;
|
|
_onReturn1598.multipleValueReturn = _onReturnMultiple1597;
|
|
_beforePopPrompt1584.multipleValueReturn = _beforePopPromptMultiple1583;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start1599); })(MACHINE, function() {
|
|
MACHINE.modules["whalesong/world/main.rkt"] =
|
|
new plt.runtime.ModuleRecord("whalesong/world/main.rkt",
|
|
function(MACHINE) {
|
|
var afterName988 = function() {
|
|
if(--MACHINE.callsBeforeTrampoline<0) { throw arguments.callee; }
|
|
var modrec = MACHINE.modules["whalesong/world/main.rkt"];
|
|
var exports = {};
|
|
modrec.isInvoked = true;
|
|
(function(MACHINE, RUNTIME, EXPORTS){var rawJsworld = {};
|
|
|
|
// Stuff here is copy-and-pasted from Chris King's JSWorld.
|
|
//
|
|
// dyoo: as I remember, most of this code had been revised from
|
|
// Chris's original code by Ethan Cechetti, who rewrote it to
|
|
// continuation passing style during summer 2010.
|
|
|
|
(function() {
|
|
|
|
/* Type signature notation
|
|
* CPS(a b ... -> c) is used to denote
|
|
* a b ... (c -> void) -> void
|
|
*/
|
|
|
|
var Jsworld = rawJsworld;
|
|
|
|
var currentFocusedNode = false;
|
|
|
|
var doNothing = function() {};
|
|
|
|
|
|
|
|
|
|
|
|
// forEachK: CPS( array CPS(array -> void) (error -> void) -> void )
|
|
// Iterates through an array and applies f to each element using CPS
|
|
// If an error is thrown, it catches the error and calls f_error on it
|
|
var forEachK = function(a, f, f_error, k) {
|
|
var forEachHelp = function(i) {
|
|
if( i >= a.length ) {
|
|
if (k) {
|
|
return k();
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
try {
|
|
return f(a[i], function() { return forEachHelp(i+1); });
|
|
} catch (e) {
|
|
f_error(e);
|
|
}
|
|
};
|
|
return forEachHelp(0);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// WORLD STUFFS
|
|
//
|
|
|
|
function InitialWorld() {}
|
|
|
|
var world = new InitialWorld();
|
|
var worldListeners = [];
|
|
var eventDetachers = [];
|
|
var runningBigBangs = [];
|
|
|
|
var changingWorld = false;
|
|
|
|
|
|
|
|
// Close all world computations.
|
|
Jsworld.shutdown = function() {
|
|
while(runningBigBangs.length > 0) {
|
|
var currentRecord = runningBigBangs.pop();
|
|
if (currentRecord) { currentRecord.pause(); }
|
|
}
|
|
clear_running_state();
|
|
}
|
|
|
|
|
|
|
|
function add_world_listener(listener) {
|
|
worldListeners.push(listener);
|
|
}
|
|
|
|
|
|
function remove_world_listener(listener) {
|
|
var index = worldListeners.indexOf(listener);
|
|
if (index != -1) {
|
|
worldListeners.splice(index, 1);
|
|
}
|
|
}
|
|
|
|
function clear_running_state() {
|
|
world = new InitialWorld();
|
|
worldListeners = [];
|
|
|
|
for (var i = 0; i < eventDetachers.length; i++) {
|
|
eventDetachers[i]();
|
|
}
|
|
eventDetachers = [];
|
|
changingWorld = false;
|
|
}
|
|
|
|
|
|
// If we're in the middle of a change_world, delay.
|
|
var DELAY_BEFORE_RETRY = 10;
|
|
|
|
|
|
// change_world: CPS( CPS(world -> world) -> void )
|
|
// Adjust the world, and notify all listeners.
|
|
var change_world = function(updater, k) {
|
|
|
|
// Check to see if we're in the middle of changing
|
|
// the world already. If so, put on the queue
|
|
// and exit quickly.
|
|
if (changingWorld) {
|
|
setTimeout(
|
|
function() {
|
|
change_world(updater, k)},
|
|
DELAY_BEFORE_RETRY);
|
|
return;
|
|
}
|
|
|
|
|
|
changingWorld = true;
|
|
var originalWorld = world;
|
|
|
|
var changeWorldHelp = function() {
|
|
if (world instanceof WrappedWorldWithEffects) {
|
|
var effects = world.getEffects();
|
|
forEachK(effects,
|
|
function(anEffect, k2) {
|
|
anEffect.invokeEffect(change_world, k2);
|
|
},
|
|
function (e) {
|
|
changingWorld = false;
|
|
throw e;
|
|
},
|
|
function() {
|
|
world = world.getWorld();
|
|
changeWorldHelp2();
|
|
});
|
|
} else {
|
|
changeWorldHelp2();
|
|
}
|
|
};
|
|
|
|
var changeWorldHelp2 = function() {
|
|
forEachK(worldListeners,
|
|
function(listener, k2) {
|
|
listener(world, originalWorld, k2);
|
|
},
|
|
function(e) {
|
|
changingWorld = false;
|
|
world = originalWorld;
|
|
throw e; },
|
|
function() {
|
|
changingWorld = false;
|
|
k();
|
|
});
|
|
};
|
|
|
|
try {
|
|
updater(world, function(newWorld) {
|
|
world = newWorld;
|
|
changeWorldHelp();
|
|
});
|
|
} catch(e) {
|
|
changingWorld = false;
|
|
world = originalWorld;
|
|
|
|
if (typeof(console) !== 'undefined' && console.log && e.stack) {
|
|
console.log(e.stack);
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
Jsworld.change_world = change_world;
|
|
|
|
|
|
|
|
|
|
//
|
|
// STUFF THAT SHOULD REALLY BE IN ECMASCRIPT
|
|
//
|
|
Number.prototype.NaN0=function(){return isNaN(this)?0:this;}
|
|
function getPosition(e){
|
|
var left = 0;
|
|
var top = 0;
|
|
while (e.offsetParent){
|
|
left += e.offsetLeft + (e.currentStyle?(parseInt(e.currentStyle.borderLeftWidth)).NaN0():0);
|
|
top += e.offsetTop + (e.currentStyle?(parseInt(e.currentStyle.borderTopWidth)).NaN0():0);
|
|
e = e.offsetParent;
|
|
}
|
|
left += e.offsetLeft + (e.currentStyle?(parseInt(e.currentStyle.borderLeftWidth)).NaN0():0);
|
|
top += e.offsetTop + (e.currentStyle?(parseInt(e.currentStyle.borderTopWidth)).NaN0():0);
|
|
return {x:left, y:top};
|
|
}
|
|
Jsworld.getPosition = getPosition;
|
|
|
|
|
|
var gensym_counter = 0;
|
|
function gensym(){ return gensym_counter++;}
|
|
Jsworld.gensym = gensym;
|
|
|
|
|
|
var map = function(a1, f) {
|
|
var b = new Array(a1.length);
|
|
for (var i = 0; i < a1.length; i++) {
|
|
b[i] = f(a1[i]);
|
|
}
|
|
return b;
|
|
}
|
|
Jsworld.map = map;
|
|
|
|
|
|
|
|
var concat_map = function(a, f) {
|
|
var b = [];
|
|
for (var i = 0; i < a.length; i++) {
|
|
b = b.concat(f(a[i]));
|
|
}
|
|
return b;
|
|
}
|
|
|
|
|
|
var mapi = function(a, f) {
|
|
var b = new Array(a.length);
|
|
for (var i = 0; i < a.length; i++) {
|
|
b[i] = f(a[i], i);
|
|
}
|
|
return b;
|
|
}
|
|
Jsworld.mapi = mapi;
|
|
|
|
|
|
var fold = function(a, x, f) {
|
|
for (var i = 0; i < a.length; i++) {
|
|
x = f(a[i], x);
|
|
}
|
|
return x;
|
|
}
|
|
Jsworld.fold = fold;
|
|
|
|
|
|
function augment(o, a) {
|
|
var oo = {};
|
|
for (var e in o)
|
|
oo[e] = o[e];
|
|
for (var e in a)
|
|
oo[e] = a[e];
|
|
return oo;
|
|
}
|
|
Jsworld.augment = augment;
|
|
|
|
|
|
function assoc_cons(o, k, v) {
|
|
var oo = {};
|
|
for (var e in o)
|
|
oo[e] = o[e];
|
|
oo[k] = v;
|
|
return oo;
|
|
}
|
|
Jsworld.assoc_cons = assoc_cons;
|
|
|
|
|
|
function cons(value, array) {
|
|
return [value].concat(array);
|
|
}
|
|
Jsworld.cons = cons;
|
|
|
|
|
|
function append(array1, array2){
|
|
return array1.concat(array2);
|
|
}
|
|
Jsworld.append = append;
|
|
|
|
function array_join(array1, array2){
|
|
var joined = [];
|
|
for (var i = 0; i < array1.length; i++)
|
|
joined.push([array1[i], array2[i]]);
|
|
return joined;
|
|
}
|
|
Jsworld.array_join = array_join;
|
|
|
|
|
|
function removeq(a, value) {
|
|
for (var i = 0; i < a.length; i++)
|
|
if (a[i] === value){
|
|
return a.slice(0, i).concat(a.slice(i+1));
|
|
}
|
|
return a;
|
|
}
|
|
Jsworld.removeq = removeq;
|
|
|
|
function removef(a, value) {
|
|
for (var i = 0; i < a.length; i++)
|
|
if ( f(a[i]) ){
|
|
return a.slice(0, i).concat(a.slice(i+1));
|
|
}
|
|
return a;
|
|
}
|
|
Jsworld.removef = removef;
|
|
|
|
|
|
function filter(a, f) {
|
|
var b = [];
|
|
for (var i = 0; i < a.length; i++) {
|
|
if ( f(a[i]) ) {
|
|
b.push(a[i]);
|
|
}
|
|
}
|
|
return b;
|
|
}
|
|
Jsworld.filter = filter;
|
|
|
|
|
|
function without(obj, attrib) {
|
|
var o = {};
|
|
for (var a in obj)
|
|
if (a != attrib)
|
|
o[a] = obj[a];
|
|
return o;
|
|
}
|
|
Jsworld.without = without;
|
|
|
|
|
|
function memberq(a, x) {
|
|
for (var i = 0; i < a.length; i++)
|
|
if (a[i] === x) return true;
|
|
return false;
|
|
}
|
|
Jsworld.memberq = memberq;
|
|
|
|
|
|
function member(a, x) {
|
|
for (var i = 0; i < a.length; i++)
|
|
if (a[i] == x) return true;
|
|
return false;
|
|
}
|
|
Jsworld.member = member;
|
|
|
|
|
|
|
|
function head(a){
|
|
return a[0];
|
|
}
|
|
Jsworld.head = head;
|
|
|
|
|
|
function tail(a){
|
|
return a.slice(1, a.length);
|
|
}
|
|
Jsworld.tail = tail;
|
|
|
|
//
|
|
// DOM UPDATING STUFFS
|
|
//
|
|
|
|
// tree(N): { node: N, children: [tree(N)] }
|
|
// relation(N): { relation: 'parent', parent: N, child: N } | { relation: 'neighbor', left: N, right: N }
|
|
// relations(N): [relation(N)]
|
|
// nodes(N): [N]
|
|
// css(N): [css_node(N)]
|
|
// css_node(N): { node: N, attribs: attribs } | { className: string, attribs: attribs }
|
|
// attrib: { attrib: string, values: [string] }
|
|
// attribs: [attrib]
|
|
|
|
// treeable(nodes(N), relations(N)) = bool
|
|
/*function treeable(nodes, relations) {
|
|
// for all neighbor relations between x and y
|
|
for (var i = 0; i < relations.length; i++)
|
|
if (relations[i].relation == 'neighbor') {
|
|
var x = relations[i].left, y = relations[i].right;
|
|
|
|
// there does not exist a neighbor relation between x and z!=y or z!=x and y
|
|
for (var j = 0; j < relations.length; j++)
|
|
if (relations[j].relation === 'neighbor')
|
|
if (relations[j].left === x && relations[j].right !== y ||
|
|
relations[j].left !== x && relations[j].right === y)
|
|
return false;
|
|
}
|
|
|
|
// for all parent relations between x and y
|
|
for (var i = 0; i < relations.length; i++)
|
|
if (relations[i].relation == 'parent') {
|
|
var x = relations[i].parent, y = relations[i].child;
|
|
|
|
// there does not exist a parent relation between z!=x and y
|
|
for (var j = 0; j < relations.length; j++)
|
|
if (relations[j].relation == 'parent')
|
|
if (relations[j].parent !== x && relations[j].child === y)
|
|
return false;
|
|
}
|
|
|
|
// for all neighbor relations between x and y
|
|
for (var i = 0; i < relations.length; i++)
|
|
if (relations[i].relation == 'neighbor') {
|
|
var x = relations[i].left, y = relations[i].right;
|
|
|
|
// all parent relations between z and x or y share the same z
|
|
for (var j = 0; j < relations.length; j++)
|
|
if (relations[j].relation == 'parent')
|
|
for (var k = 0; k < relations.length; k++)
|
|
if (relations[k].relation == 'parent')
|
|
if (relations[j].child === x && relations[k].child === y &&
|
|
relations[j].parent !== relations[k].parent)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}*/
|
|
|
|
|
|
// node_to_tree: dom -> dom-tree
|
|
// Given a native dom node, produces the appropriate tree.
|
|
function node_to_tree(domNode) {
|
|
var result = [domNode];
|
|
for (var c = domNode.firstChild; c != null; c = c.nextSibling) {
|
|
result.push(node_to_tree(c));
|
|
}
|
|
return result;
|
|
}
|
|
Jsworld.node_to_tree = node_to_tree;
|
|
|
|
|
|
|
|
// nodes(tree(N)) = nodes(N)
|
|
function nodes(tree) {
|
|
var ret;
|
|
|
|
if (tree.node.jsworldOpaque == true) {
|
|
return [tree.node];
|
|
}
|
|
|
|
ret = [tree.node];
|
|
for (var i = 0; i < tree.children.length; i++)
|
|
ret = ret.concat(nodes(tree.children[i]));
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
// relations(tree(N)) = relations(N)
|
|
function relations(tree) {
|
|
var ret = [];
|
|
|
|
for (var i = 0; i < tree.children.length; i++)
|
|
ret.push({ relation: 'parent',
|
|
parent: tree.node,
|
|
child: tree.children[i].node });
|
|
|
|
for (var i = 0; i < tree.children.length - 1; i++)
|
|
ret.push({ relation: 'neighbor',
|
|
left: tree.children[i].node,
|
|
right: tree.children[i + 1].node });
|
|
|
|
if (! tree.node.jsworldOpaque) {
|
|
for (var i = 0; i < tree.children.length; i++) {
|
|
ret = ret.concat(relations(tree.children[i]));
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
var removeAllChildren = function(n) {
|
|
while (n.firstChild) {
|
|
n.removeChild(n.firstChild);
|
|
}
|
|
}
|
|
|
|
|
|
// Preorder traversal.
|
|
var preorder = function(node, f) {
|
|
f(node, function() {
|
|
var child = node.firstChild;
|
|
var nextSibling;
|
|
while (child) {
|
|
var nextSibling = child.nextSibling;
|
|
preorder(child, f);
|
|
child = nextSibling;
|
|
}
|
|
});
|
|
};
|
|
|
|
|
|
// update_dom(nodes(Node), relations(Node)) = void
|
|
function update_dom(toplevelNode, nodes, relations) {
|
|
|
|
// TODO: rewrite this to move stuff all in one go... possible? necessary?
|
|
|
|
// move all children to their proper parents
|
|
for (var i = 0; i < relations.length; i++) {
|
|
if (relations[i].relation == 'parent') {
|
|
var parent = relations[i].parent, child = relations[i].child;
|
|
if (child.parentNode !== parent) {
|
|
parent.appendChild(child);
|
|
}
|
|
}
|
|
}
|
|
|
|
// arrange siblings in proper order
|
|
// truly terrible... BUBBLE SORT
|
|
var unsorted = true;
|
|
while (unsorted) {
|
|
unsorted = false;
|
|
for (var i = 0; i < relations.length; i++) {
|
|
if (relations[i].relation == 'neighbor') {
|
|
var left = relations[i].left, right = relations[i].right;
|
|
|
|
if (! nodeEq(left.nextSibling, right)) {
|
|
left.parentNode.insertBefore(left, right)
|
|
unsorted = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Finally, remove nodes that shouldn't be attached anymore.
|
|
var nodesPlus = nodes.concat([toplevelNode]);
|
|
preorder(toplevelNode, function(aNode, continueTraversalDown) {
|
|
if (aNode.jsworldOpaque) {
|
|
if (! isMemq(aNode, nodesPlus)) {
|
|
aNode.parentNode.removeChild(aNode);
|
|
}
|
|
} else {
|
|
if (! isMemq(aNode, nodesPlus)) {
|
|
aNode.parentNode.removeChild(aNode);
|
|
} else {
|
|
continueTraversalDown();
|
|
}
|
|
}
|
|
});
|
|
|
|
refresh_node_values(nodes);
|
|
}
|
|
|
|
|
|
// isMemq: X (arrayof X) -> boolean
|
|
// Produces true if any of the elements of L are nodeEq to x.
|
|
var isMemq = function(x, L) {
|
|
var i;
|
|
for (i = 0 ; i < L.length; i++) {
|
|
if (nodeEq(x, L[i])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
|
|
// nodeEq: node node -> boolean
|
|
// Returns true if the two nodes should be the same.
|
|
var nodeEq = function(node1, node2) {
|
|
return (node1 && node2 && node1 === node2);
|
|
}
|
|
|
|
|
|
|
|
// camelCase: string -> string
|
|
function camelCase(name) {
|
|
return name.replace(/\-(.)/g, function(m, l){return l.toUpperCase()});
|
|
}
|
|
|
|
|
|
function set_css_attribs(node, attribs) {
|
|
for (var j = 0; j < attribs.length; j++){
|
|
node.style[camelCase(attribs[j].attrib)] = attribs[j].values.join(" ");
|
|
}
|
|
}
|
|
|
|
|
|
// isMatchingCssSelector: node css -> boolean
|
|
// Returns true if the CSS selector matches.
|
|
function isMatchingCssSelector(node, css) {
|
|
if (css.id.match(/^\./)) {
|
|
// Check to see if we match the class
|
|
return ('className' in node && member(node['className'].split(/\s+/),
|
|
css.id.substring(1)));
|
|
} else {
|
|
return ('id' in node && node.id == css.id);
|
|
}
|
|
}
|
|
|
|
|
|
function update_css(nodes, css) {
|
|
// clear CSS
|
|
for (var i = 0; i < nodes.length; i++) {
|
|
if ( !nodes[i].jsworldOpaque ) {
|
|
clearCss(nodes[i]);
|
|
}
|
|
}
|
|
|
|
// set CSS
|
|
for (var i = 0; i < css.length; i++)
|
|
if ('id' in css[i]) {
|
|
for (var j = 0; j < nodes.length; j++)
|
|
if (isMatchingCssSelector(nodes[j], css[i])) {
|
|
set_css_attribs(nodes[j], css[i].attribs);
|
|
}
|
|
}
|
|
else set_css_attribs(css[i].node, css[i].attribs);
|
|
}
|
|
|
|
|
|
var clearCss = function(node) {
|
|
// FIXME: we should not be clearing the css
|
|
// if ('style' in node)
|
|
// node.style.cssText = "";
|
|
}
|
|
|
|
|
|
|
|
// If any node cares about the world, send it in.
|
|
function refresh_node_values(nodes) {
|
|
for (var i = 0; i < nodes.length; i++) {
|
|
if (nodes[i].onWorldChange) {
|
|
nodes[i].onWorldChange(world);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
function do_redraw(world, oldWorld, toplevelNode, redraw_func, redraw_css_func, k) {
|
|
if (oldWorld instanceof InitialWorld) {
|
|
// Simple path
|
|
redraw_func(world,
|
|
function(drawn) {
|
|
var t = sexp2tree(drawn);
|
|
var ns = nodes(t);
|
|
// HACK: css before dom, due to excanvas hack.
|
|
redraw_css_func(world,
|
|
function(css) {
|
|
update_css(ns, sexp2css(css));
|
|
update_dom(toplevelNode, ns, relations(t));
|
|
k();
|
|
});
|
|
});
|
|
} else {
|
|
maintainingSelection(
|
|
function(k2) {
|
|
// For legibility, here is the non-CPS version of the same function:
|
|
/*
|
|
var oldRedraw = redraw_func(oldWorld);
|
|
var newRedraw = redraw_func(world);
|
|
var oldRedrawCss = redraw_css_func(oldWorld);
|
|
var newRedrawCss = redraw_css_func(world);
|
|
var t = sexp2tree(newRedraw);
|
|
var ns = nodes(t);
|
|
|
|
// Try to save the current selection and preserve it across
|
|
// dom updates.
|
|
|
|
if(oldRedraw !== newRedraw) {
|
|
// Kludge: update the CSS styles first.
|
|
// This is a workaround an issue with excanvas: any style change
|
|
// clears the content of the canvas, so we do this first before
|
|
// attaching the dom element.
|
|
update_css(ns, sexp2css(newRedrawCss));
|
|
update_dom(toplevelNode, ns, relations(t));
|
|
} else {
|
|
if(oldRedrawCss !== newRedrawCss) {
|
|
update_css(ns, sexp2css(newRedrawCss));
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
redraw_func(
|
|
world,
|
|
function(newRedraw) {
|
|
|
|
redraw_css_func(
|
|
world,
|
|
function(newRedrawCss) {
|
|
var t = sexp2tree(newRedraw);
|
|
var ns = nodes(t);
|
|
|
|
// Try to save the current selection and preserve it across
|
|
// dom updates.
|
|
|
|
// Kludge: update the CSS styles first.
|
|
// This is a workaround an issue with excanvas: any style change
|
|
// clears the content of the canvas, so we do this first before
|
|
// attaching the dom element.
|
|
update_css(ns, sexp2css(newRedrawCss));
|
|
update_dom(toplevelNode, ns, relations(t));
|
|
|
|
k2();
|
|
})
|
|
})
|
|
|
|
|
|
|
|
|
|
|
|
}, k);
|
|
}
|
|
}
|
|
|
|
|
|
// maintainingSelection: (-> void) -> void
|
|
// Calls the thunk f while trying to maintain the current focused selection.
|
|
function maintainingSelection(f, k) {
|
|
var currentFocusedSelection;
|
|
if (hasCurrentFocusedSelection()) {
|
|
currentFocusedSelection = getCurrentFocusedSelection();
|
|
f(function() {
|
|
currentFocusedSelection.restore();
|
|
k();
|
|
});
|
|
} else {
|
|
f(function() { k(); });
|
|
}
|
|
}
|
|
|
|
|
|
|
|
function FocusedSelection() {
|
|
this.focused = currentFocusedNode;
|
|
this.selectionStart = currentFocusedNode.selectionStart;
|
|
this.selectionEnd = currentFocusedNode.selectionEnd;
|
|
}
|
|
|
|
// Try to restore the focus.
|
|
FocusedSelection.prototype.restore = function() {
|
|
// FIXME: if we're scrolling through, what's visible
|
|
// isn't restored yet.
|
|
if (this.focused.parentNode) {
|
|
this.focused.selectionStart = this.selectionStart;
|
|
this.focused.selectionEnd = this.selectionEnd;
|
|
this.focused.focus();
|
|
} else if (this.focused.id) {
|
|
var matching = document.getElementById(this.focused.id);
|
|
if (matching) {
|
|
matching.selectionStart = this.selectionStart;
|
|
matching.selectionEnd = this.selectionEnd;
|
|
matching.focus();
|
|
}
|
|
}
|
|
};
|
|
|
|
function hasCurrentFocusedSelection() {
|
|
return currentFocusedNode != undefined;
|
|
}
|
|
|
|
function getCurrentFocusedSelection() {
|
|
return new FocusedSelection();
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
function BigBangRecord(top, world, handlerCreators, handlers, attribs) {
|
|
this.top = top;
|
|
this.world = world;
|
|
this.handlers = handlers;
|
|
this.handlerCreators = handlerCreators;
|
|
this.attribs = attribs;
|
|
}
|
|
|
|
BigBangRecord.prototype.restart = function() {
|
|
bigBang(this.top, this.world, this.handlerCreators, this.attribs);
|
|
}
|
|
|
|
BigBangRecord.prototype.pause = function() {
|
|
for(var i = 0 ; i < this.handlers.length; i++) {
|
|
if (this.handlers[i] instanceof StopWhenHandler) {
|
|
// Do nothing for now.
|
|
} else {
|
|
this.handlers[i].onUnregister(top);
|
|
}
|
|
}
|
|
};
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
// Notes: bigBang maintains a stack of activation records; it should be possible
|
|
// to call bigBang re-entrantly.
|
|
// top: dom
|
|
// init_world: any
|
|
// handlerCreators: (Arrayof (-> handler))
|
|
// k: any -> void
|
|
function bigBang(top, init_world, handlerCreators, attribs, succ) {
|
|
// clear_running_state();
|
|
|
|
// Construct a fresh set of the handlers.
|
|
var handlers = map(handlerCreators, function(x) { return x();} );
|
|
if (runningBigBangs.length > 0) {
|
|
runningBigBangs[runningBigBangs.length - 1].pause();
|
|
}
|
|
|
|
// Create an activation record for this big-bang.
|
|
var activationRecord =
|
|
new BigBangRecord(top, init_world, handlerCreators, handlers, attribs);
|
|
runningBigBangs.push(activationRecord);
|
|
function keepRecordUpToDate(w, oldW, k2) {
|
|
activationRecord.world = w;
|
|
k2();
|
|
}
|
|
add_world_listener(keepRecordUpToDate);
|
|
|
|
|
|
|
|
// Monitor for termination and register the other handlers.
|
|
var stopWhen = new StopWhenHandler(function(w, k2) { k2(false); },
|
|
function(w, k2) { k2(w); });
|
|
for(var i = 0 ; i < handlers.length; i++) {
|
|
if (handlers[i] instanceof StopWhenHandler) {
|
|
stopWhen = handlers[i];
|
|
} else {
|
|
handlers[i].onRegister(top);
|
|
}
|
|
}
|
|
var watchForTermination = function(w, oldW, k2) {
|
|
stopWhen.test(w,
|
|
function(stop) {
|
|
if (stop) {
|
|
Jsworld.shutdown();
|
|
succ(w);
|
|
/*
|
|
stopWhen.receiver(world,
|
|
function() {
|
|
var currentRecord = runningBigBangs.pop();
|
|
if (currentRecord) { currentRecord.pause(); }
|
|
if (runningBigBangs.length > 0) {
|
|
var restartingBigBang = runningBigBangs.pop();
|
|
restartingBigBang.restart();
|
|
}
|
|
k();
|
|
});
|
|
*/
|
|
}
|
|
else { k2(); }
|
|
});
|
|
};
|
|
add_world_listener(watchForTermination);
|
|
|
|
|
|
// Finally, begin the big-bang.
|
|
copy_attribs(top, attribs);
|
|
change_world(function(w, k2) { k2(init_world); }, doNothing);
|
|
|
|
|
|
}
|
|
Jsworld.bigBang = bigBang;
|
|
|
|
|
|
|
|
|
|
|
|
// on_tick: number CPS(world -> world) -> handler
|
|
var on_tick = function(delay, tick) {
|
|
return function() {
|
|
var scheduleTick, ticker;
|
|
|
|
|
|
(new Date()).valueOf()
|
|
|
|
scheduleTick = function(t) {
|
|
ticker.watchId = setTimeout(
|
|
function() {
|
|
ticker.watchId = undefined;
|
|
var startTime = (new Date()).valueOf();
|
|
change_world(tick,
|
|
function() {
|
|
var endTime = (new Date()).valueOf();
|
|
scheduleTick(Math.max(delay - (endTime - startTime),
|
|
0));
|
|
});
|
|
},
|
|
t);
|
|
};
|
|
|
|
ticker = {
|
|
watchId: -1,
|
|
onRegister: function (top) {
|
|
scheduleTick(delay);
|
|
},
|
|
|
|
onUnregister: function (top) {
|
|
if (ticker.watchId)
|
|
clearTimeout(ticker.watchId);
|
|
}
|
|
};
|
|
return ticker;
|
|
};
|
|
}
|
|
Jsworld.on_tick = on_tick;
|
|
|
|
|
|
function on_key(press) {
|
|
return function() {
|
|
var wrappedPress = function(e) {
|
|
preventDefault(e);
|
|
stopPropagation(e);
|
|
change_world(function(w, k) { press(w, e, k); }, doNothing);
|
|
};
|
|
return {
|
|
onRegister: function(top) {
|
|
//http://www.w3.org/TR/html5/editing.html#sequential-focus-navigation-and-the-tabindex-attribue
|
|
$(top).attr('tabindex', 1);
|
|
$(top).focus();
|
|
attachEvent(top, 'keydown', wrappedPress);
|
|
},
|
|
onUnregister: function(top) {
|
|
detachEvent(top, 'keydown', wrappedPress);
|
|
}
|
|
};
|
|
}
|
|
}
|
|
Jsworld.on_key = on_key;
|
|
|
|
|
|
|
|
// on_draw: CPS(world -> (sexpof node)) CPS(world -> (sexpof css-style)) -> handler
|
|
function on_draw(redraw, redraw_css) {
|
|
var wrappedRedraw = function(w, k) {
|
|
redraw(w, function(newDomTree) {
|
|
checkDomSexp(newDomTree, newDomTree);
|
|
k(newDomTree);
|
|
});
|
|
}
|
|
|
|
return function() {
|
|
var drawer = {
|
|
_top: null,
|
|
_listener: function(w, oldW, k2) {
|
|
do_redraw(w, oldW, drawer._top, wrappedRedraw, redraw_css, k2);
|
|
},
|
|
onRegister: function (top) {
|
|
drawer._top = top;
|
|
add_world_listener(drawer._listener);
|
|
},
|
|
|
|
onUnregister: function (top) {
|
|
remove_world_listener(drawer._listener);
|
|
}
|
|
};
|
|
return drawer;
|
|
};
|
|
}
|
|
Jsworld.on_draw = on_draw;
|
|
|
|
|
|
|
|
function StopWhenHandler(test, receiver) {
|
|
this.test = test;
|
|
this.receiver = receiver;
|
|
}
|
|
// stop_when: CPS(world -> boolean) CPS(world -> boolean) -> handler
|
|
function stop_when(test, receiver) {
|
|
return function() {
|
|
if (receiver == undefined) {
|
|
receiver = function(w, k) { k(w); };
|
|
}
|
|
return new StopWhenHandler(test, receiver);
|
|
};
|
|
}
|
|
Jsworld.stop_when = stop_when;
|
|
|
|
|
|
|
|
function on_world_change(f) {
|
|
var listener = function(world, oldW, k) { f(world, k); };
|
|
return function() {
|
|
return {
|
|
onRegister: function (top) {
|
|
add_world_listener(listener); },
|
|
onUnregister: function (top) {
|
|
remove_world_listener(listener)}
|
|
};
|
|
};
|
|
}
|
|
Jsworld.on_world_change = on_world_change;
|
|
|
|
|
|
|
|
|
|
|
|
// Compatibility for attaching events to nodes.
|
|
function attachEvent(node, eventName, fn) {
|
|
if (node.addEventListener) {
|
|
// Mozilla
|
|
node.addEventListener(eventName, fn, false);
|
|
} else {
|
|
// IE
|
|
node.attachEvent('on' + eventName, fn, false);
|
|
}
|
|
}
|
|
|
|
var detachEvent = function(node, eventName, fn) {
|
|
if (node.addEventListener) {
|
|
// Mozilla
|
|
node.removeEventListener(eventName, fn, false);
|
|
} else {
|
|
// IE
|
|
node.detachEvent('on' + eventName, fn, false);
|
|
}
|
|
}
|
|
|
|
//
|
|
// DOM CREATION STUFFS
|
|
//
|
|
|
|
// add_ev: node string CPS(world event -> world) -> void
|
|
// Attaches a world-updating handler when the world is changed.
|
|
function add_ev(node, event, f) {
|
|
var eventHandler = function(e) { change_world(function(w, k) { f(w, e, k); },
|
|
doNothing); };
|
|
attachEvent(node, event, eventHandler);
|
|
eventDetachers.push(function() { detachEvent(node, event, eventHandler); });
|
|
}
|
|
|
|
// add_ev_after: node string CPS(world event -> world) -> void
|
|
// Attaches a world-updating handler when the world is changed, but only
|
|
// after the fired event has finished.
|
|
function add_ev_after(node, event, f) {
|
|
var eventHandler = function(e) {
|
|
setTimeout(function() { change_world(function(w, k) { f(w, e, k); },
|
|
doNothing); },
|
|
0);
|
|
};
|
|
|
|
attachEvent(node, event, eventHandler);
|
|
eventDetachers.push(function() { detachEvent(node, event, eventHandler); });
|
|
}
|
|
|
|
|
|
function addFocusTracking(node) {
|
|
attachEvent(node, "focus", function(e) {
|
|
currentFocusedNode = node; });
|
|
attachEvent(node, "blur", function(e) {
|
|
currentFocusedNode = undefined;
|
|
});
|
|
return node;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// WORLD STUFFS
|
|
//
|
|
|
|
|
|
function sexp2tree(sexp) {
|
|
if(sexp.length == undefined) return { node: sexp, children: [] };
|
|
else return { node: sexp[0], children: map(sexp.slice(1), sexp2tree) };
|
|
}
|
|
|
|
function sexp2attrib(sexp) {
|
|
return { attrib: sexp[0], values: sexp.slice(1) };
|
|
}
|
|
|
|
function sexp2css_node(sexp) {
|
|
var attribs = map(sexp.slice(1), sexp2attrib);
|
|
if (typeof sexp[0] == 'string'){
|
|
return [{ id: sexp[0], attribs: attribs }];
|
|
} else if ('length' in sexp[0]){
|
|
return map(sexp[0], function (id) { return { id: id, attribs: attribs } });
|
|
} else {
|
|
return [{ node: sexp[0], attribs: attribs }];
|
|
}
|
|
}
|
|
|
|
function sexp2css(sexp) {
|
|
return concat_map(sexp, sexp2css_node);
|
|
}
|
|
|
|
|
|
|
|
function isTextNode(n) {
|
|
return (n.nodeType == Node.TEXT_NODE);
|
|
};
|
|
|
|
|
|
function isElementNode(n) {
|
|
return (n.nodeType == Node.ELEMENT_NODE);
|
|
};
|
|
|
|
|
|
var throwDomError = function(thing, topThing) {
|
|
throw new JsworldDomError(
|
|
plt.baselib.format.format(
|
|
"Expected a non-empty array, received ~s within ~s",
|
|
[thing, topThing]),
|
|
thing);
|
|
};
|
|
|
|
// checkDomSexp: X X -> boolean
|
|
// Checks to see if thing is a DOM-sexp. If not,
|
|
// throws an object that explains why not.
|
|
function checkDomSexp(thing, topThing) {
|
|
if (! thing instanceof Array) {
|
|
throwDomError(thing, topThing);
|
|
}
|
|
if (thing.length == 0) {
|
|
throwDomError(thing, topThing);
|
|
}
|
|
|
|
|
|
// Check that the first element is a Text or an element.
|
|
if (isTextNode(thing[0])) {
|
|
if (thing.length > 1) {
|
|
throw new JsworldDomError(plt.baselib.format.format("Text node ~s can not have children",
|
|
[thing]),
|
|
thing);
|
|
}
|
|
} else if (isElementNode(thing[0])) {
|
|
for (var i = 1; i < thing.length; i++) {
|
|
checkDomSexp(thing[i], thing);
|
|
}
|
|
} else {
|
|
console.log(thing[0]);
|
|
|
|
throw new JsworldDomError(
|
|
plt.baselib.format.format(
|
|
"expected a Text or an Element, received ~s within ~s",
|
|
[thing, topThing]),
|
|
thing[0]);
|
|
}
|
|
}
|
|
|
|
function JsworldDomError(msg, elt) {
|
|
this.msg = msg;
|
|
this.elt = elt;
|
|
}
|
|
JsworldDomError.prototype.toString = function() {
|
|
return "JsworldDomError: " + this.msg;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// DOM CREATION STUFFS
|
|
//
|
|
|
|
|
|
function copy_attribs(node, attribs) {
|
|
if (attribs)
|
|
for (a in attribs) {
|
|
if (attribs.hasOwnProperty(a)) {
|
|
if (typeof attribs[a] == 'function')
|
|
add_ev(node, a, attribs[a]);
|
|
else{
|
|
node[a] = attribs[a];//eval("node."+a+"='"+attribs[a]+"'");
|
|
}
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
|
|
|
|
//
|
|
// NODE TYPES
|
|
//
|
|
|
|
function p(attribs) {
|
|
return addFocusTracking(copy_attribs(document.createElement('p'), attribs));
|
|
}
|
|
Jsworld.p = p;
|
|
|
|
function div(attribs) {
|
|
return addFocusTracking(copy_attribs(document.createElement('div'), attribs));
|
|
}
|
|
Jsworld.div = div;
|
|
|
|
// Used To Be: (world event -> world) (hashof X Y) -> domElement
|
|
// Now: CPS(world event -> world) (hashof X Y) -> domElement
|
|
function button(f, attribs) {
|
|
var n = document.createElement('button');
|
|
n.onclick = function(e) {return false;};
|
|
add_ev(n, 'click', f);
|
|
return addFocusTracking(copy_attribs(n, attribs));
|
|
}
|
|
Jsworld.button = button;
|
|
|
|
|
|
|
|
|
|
var preventDefault = function(event) {
|
|
if (event.preventDefault) {
|
|
event.preventDefault();
|
|
} else {
|
|
event.returnValue = false;
|
|
}
|
|
}
|
|
|
|
var stopPropagation = function(event) {
|
|
if (event.stopPropagation) {
|
|
event.stopPropagation();
|
|
} else {
|
|
event.cancelBubble = true;
|
|
}
|
|
}
|
|
|
|
|
|
var stopClickPropagation = function(node) {
|
|
attachEvent(node, "click",
|
|
function(e) {
|
|
stopPropagation(e);
|
|
});
|
|
return node;
|
|
}
|
|
|
|
|
|
// input: string CPS(world -> world)
|
|
function input(aType, updateF, attribs) {
|
|
aType = aType.toLowerCase();
|
|
var dispatchTable = { text : text_input,
|
|
password: text_input,
|
|
checkbox: checkbox_input
|
|
//button: button_input,
|
|
//radio: radio_input
|
|
};
|
|
|
|
if (dispatchTable[aType]) {
|
|
return (dispatchTable[aType])(aType, updateF, attribs);
|
|
}
|
|
else {
|
|
throw new Error("js-input: does not currently support type " + aType);
|
|
}
|
|
}
|
|
Jsworld.input = input;
|
|
|
|
|
|
|
|
|
|
var text_input = function(type, updateF, attribs) {
|
|
var n = document.createElement('input');
|
|
n.type = type;
|
|
|
|
var lastVal = n.value;
|
|
var onEvent = function() {
|
|
if (! n.parentNode) { return; }
|
|
setTimeout(
|
|
function() {
|
|
if (lastVal != n.value) {
|
|
lastVal = n.value;
|
|
change_world(function (w, k) {
|
|
updateF(w, n.value, k);
|
|
}, doNothing);
|
|
}
|
|
},
|
|
0);
|
|
}
|
|
|
|
attachEvent(n, "keydown", onEvent);
|
|
eventDetachers.push(function() {
|
|
detachEvent(n, "keydown", onEvent); });
|
|
|
|
attachEvent(n, "change", onEvent);
|
|
eventDetachers.push(function() {
|
|
detachEvent(n, "change", onEvent); });
|
|
|
|
return stopClickPropagation(
|
|
addFocusTracking(copy_attribs(n, attribs)));
|
|
};
|
|
|
|
|
|
var checkbox_input = function(type, updateF, attribs) {
|
|
var n = document.createElement('input');
|
|
n.type = type;
|
|
var onCheck = function(w, e, k) {
|
|
updateF(w, n.checked, k);
|
|
};
|
|
// This established the widget->world direction
|
|
add_ev_after(n, 'change', onCheck);
|
|
|
|
attachEvent(n, 'click', function(e) {
|
|
stopPropagation(e);
|
|
});
|
|
|
|
return copy_attribs(n, attribs);
|
|
};
|
|
|
|
|
|
var button_input = function(type, updateF, attribs) {
|
|
var n = document.createElement('button');
|
|
add_ev(n, 'click', function(w, e, k) { updateF(w, n.value, k); });
|
|
return addFocusTracking(copy_attribs(n, attribs));
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
function text(s, attribs) {
|
|
var result = document.createElement("div");
|
|
result.appendChild(document.createTextNode(String(s)));
|
|
result.jsworldOpaque = true;
|
|
return result;
|
|
}
|
|
Jsworld.text = text;
|
|
|
|
function select(attribs, opts, f){
|
|
var n = document.createElement('select');
|
|
for(var i = 0; i < opts.length; i++) {
|
|
n.add(option({value: opts[i]}), null);
|
|
}
|
|
n.jsworldOpaque = true;
|
|
add_ev(n, 'change', f);
|
|
var result = addFocusTracking(copy_attribs(n, attribs));
|
|
return result;
|
|
}
|
|
Jsworld.select = select;
|
|
|
|
function option(attribs){
|
|
var node = document.createElement("option");
|
|
node.text = attribs.value;
|
|
node.value = attribs.value;
|
|
return node;
|
|
}
|
|
|
|
|
|
|
|
function textarea(attribs){
|
|
return addFocusTracking(copy_attribs(document.createElement('textarea'), attribs));
|
|
}
|
|
Jsworld.textarea = textarea;
|
|
|
|
function h1(attribs){
|
|
return addFocusTracking(copy_attribs(document.createElement('h1'), attribs));
|
|
}
|
|
Jsworld.h1 = h1;
|
|
|
|
function canvas(attribs){
|
|
return addFocusTracking(copy_attribs(document.createElement('canvas'), attribs));
|
|
}
|
|
Jsworld.canvas = canvas;
|
|
|
|
|
|
function img(src, attribs) {
|
|
var n = document.createElement('img');
|
|
n.src = src;
|
|
return addFocusTracking(copy_attribs(n, attribs));
|
|
}
|
|
Jsworld.img = img;
|
|
|
|
|
|
|
|
function raw_node(node, attribs) {
|
|
return addFocusTracking(copy_attribs(node, attribs));
|
|
}
|
|
Jsworld.raw_node = raw_node;
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Effects
|
|
|
|
// An effect is an object with an invokeEffect() method.
|
|
|
|
var WrappedWorldWithEffects = function(w, effects) {
|
|
if (w instanceof WrappedWorldWithEffects) {
|
|
this.w = w.w;
|
|
this.e = w.e.concat(effects);
|
|
} else {
|
|
this.w = w;
|
|
this.e = effects;
|
|
}
|
|
};
|
|
|
|
WrappedWorldWithEffects.prototype.getWorld = function() {
|
|
return this.w;
|
|
};
|
|
|
|
WrappedWorldWithEffects.prototype.getEffects = function() {
|
|
return this.e;
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
Jsworld.with_effect = function(w, e) {
|
|
return new WrappedWorldWithEffects(w, [e]);
|
|
};
|
|
|
|
Jsworld.with_multiple_effects = function(w, effects) {
|
|
return new WrappedWorldWithEffects(w, effects);
|
|
};
|
|
|
|
Jsworld.has_effects = function(w) {
|
|
return w instanceof WrappedWorldWithEffects;
|
|
};
|
|
|
|
|
|
})();
|
|
|
|
var imageLibrary = MACHINE.modules['whalesong/image/private/main.rkt'].privateExports;
|
|
var isImage = imageLibrary.isImage;
|
|
|
|
|
|
|
|
|
|
var PAUSE = plt.runtime.PAUSE;
|
|
var EMPTY = plt.baselib.lists.EMPTY;
|
|
var isString = plt.baselib.strings.isString;
|
|
var isBoolean = function(x) { return x === true || x === false; }
|
|
var isSymbol = plt.baselib.symbols.isSymbol;
|
|
var makePair = plt.baselib.lists.makePair;
|
|
var makeList = plt.baselib.lists.makeList;
|
|
var makeRational = plt.baselib.numbers.makeRational;
|
|
|
|
|
|
|
|
var finalizeClosureCall = plt.baselib.functions.finalizeClosureCall;
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
var bigBang = function(MACHINE, initW, handlers) {
|
|
|
|
var oldArgcount = MACHINE.argcount;
|
|
|
|
var outerToplevelNode = $('<span/>').get(0);
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, outerToplevelNode);
|
|
var toplevelNode = $('<span/>').appendTo(outerToplevelNode).get(0);
|
|
|
|
var configs = [];
|
|
var isOutputConfigSeen = false;
|
|
|
|
for (var i = 0 ; i < handlers.length; i++) {
|
|
if (isWorldConfigOption(handlers[i])) {
|
|
configs.push(handlers[i].toRawHandler(MACHINE, toplevelNode));
|
|
}
|
|
else {
|
|
configs.push(handlers[i]);
|
|
}
|
|
if (isOutputConfig(handlers[i])) { isOutputConfigSeen = true; }
|
|
}
|
|
|
|
// If we haven't seen an onDraw function, use the default one.
|
|
if (! isOutputConfigSeen) {
|
|
configs.push(new DefaultDrawingOutput().toRawHandler(MACHINE, toplevelNode));
|
|
}
|
|
|
|
|
|
PAUSE(function(restart) {
|
|
|
|
// var onBreak = function() {
|
|
// bigBangController.breaker();
|
|
// }
|
|
// state.addBreakRequestedListener(onBreak);
|
|
|
|
var bigBangController = rawJsworld.bigBang(
|
|
toplevelNode,
|
|
initW,
|
|
configs,
|
|
{},
|
|
function(finalWorldValue) {
|
|
// state.removeBreakRequestedListener(onBreak);
|
|
|
|
|
|
restart(function(MACHINE) {
|
|
MACHINE.argcount = oldArgcount;
|
|
finalizeClosureCall(
|
|
MACHINE,
|
|
finalWorldValue);
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// Every world configuration function (on-tick, stop-when, ...)
|
|
// produces a WorldConfigOption instance.
|
|
var WorldConfigOption = function(name) {
|
|
this.name = name;
|
|
};
|
|
|
|
WorldConfigOption.prototype.configure = function(config) {
|
|
throw new Error('unimplemented WorldConfigOption');
|
|
};
|
|
|
|
|
|
WorldConfigOption.prototype.toDomNode = function(cache) {
|
|
var span = document.createElement('span');
|
|
span.appendChild(document.createTextNode("(" + this.name + " ...)"));
|
|
return span;
|
|
};
|
|
|
|
WorldConfigOption.prototype.toWrittenString = function(cache) {
|
|
return "(" + this.name + " ...)";
|
|
};
|
|
|
|
WorldConfigOption.prototype.toDisplayedString = function(cache) {
|
|
return "(" + this.name + " ...)";
|
|
};
|
|
|
|
var isWorldConfigOption = plt.baselib.makeClassPredicate(WorldConfigOption);
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
// adaptWorldFunction: Racket-function -> World-CPS
|
|
// Takes a racket function and converts it to the CPS-style function
|
|
// that our world implementation expects.
|
|
var adaptWorldFunction = function(worldFunction) {
|
|
return function() {
|
|
// Consumes any number of arguments.
|
|
var success = arguments[arguments.length - 1];
|
|
plt.baselib.functions.internalCallDuringPause.apply(
|
|
null,
|
|
[MACHINE,
|
|
worldFunction,
|
|
function(v) {
|
|
success(v);
|
|
},
|
|
function(err) {
|
|
// FIXME: do error trapping
|
|
console.log(err);
|
|
}].concat([].slice.call(arguments, 0, arguments.length - 1)));
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
// OnTick: racket-function javascript-float -> handler
|
|
var OnTick = function(handler, aDelay) {
|
|
WorldConfigOption.call(this, 'on-tick');
|
|
this.handler = handler;
|
|
this.delay = aDelay;
|
|
};
|
|
|
|
OnTick.prototype = plt.baselib.heir(WorldConfigOption.prototype);
|
|
|
|
OnTick.prototype.toRawHandler = function(MACHINE, toplevelNode) {
|
|
var that = this;
|
|
var worldFunction = adaptWorldFunction(that.handler);
|
|
return rawJsworld.on_tick(this.delay, worldFunction);
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
var OnKey = function(handler) {
|
|
WorldConfigOption.call(this, 'on-key');
|
|
this.handler = handler;
|
|
}
|
|
|
|
OnKey.prototype = plt.baselib.heir(WorldConfigOption.prototype);
|
|
|
|
OnKey.prototype.toRawHandler = function(MACHINE, toplevelNode) {
|
|
var that = this;
|
|
var worldFunction = adaptWorldFunction(that.handler);
|
|
return rawJsworld.on_key(
|
|
function(w, e, success) {
|
|
worldFunction(w, getKeyCodeName(e), success);
|
|
});
|
|
};
|
|
|
|
|
|
var getKeyCodeName = function(e) {
|
|
var code = e.charCode || e.keyCode;
|
|
var keyname;
|
|
switch(code) {
|
|
case 16: keyname = "shift"; break;
|
|
case 17: keyname = "control"; break;
|
|
case 19: keyname = "pause"; break;
|
|
case 27: keyname = "escape"; break;
|
|
case 33: keyname = "prior"; break;
|
|
case 34: keyname = "next"; break;
|
|
case 35: keyname = "end"; break;
|
|
case 36: keyname = "home"; break;
|
|
case 37: keyname = "left"; break;
|
|
case 38: keyname = "up"; break;
|
|
case 39: keyname = "right"; break;
|
|
case 40: keyname = "down"; break;
|
|
case 42: keyname = "print"; break;
|
|
case 45: keyname = "insert"; break;
|
|
case 46: keyname = String.fromCharCode(127); break;
|
|
case 106: keyname = "*"; break;
|
|
case 107: keyname = "+"; break;
|
|
case 109: keyname = "-"; break;
|
|
case 110: keyname = "."; break;
|
|
case 111: keyname = "/"; break;
|
|
case 144: keyname = "numlock"; break;
|
|
case 145: keyname = "scroll"; break;
|
|
case 186: keyname = ";"; break;
|
|
case 187: keyname = "="; break;
|
|
case 188: keyname = ","; break;
|
|
case 189: keyname = "-"; break;
|
|
case 190: keyname = "."; break;
|
|
case 191: keyname = "/"; break;
|
|
case 192: keyname = "`"; break;
|
|
case 219: keyname = "["; break;
|
|
case 220: keyname = "\\"; break;
|
|
case 221: keyname = "]"; break;
|
|
case 222: keyname = "'"; break;
|
|
default:
|
|
if (code >= 96 && code <= 105) {
|
|
keyname = (code - 96).toString();
|
|
} else if (code >= 112 && code <= 123) {
|
|
keyname = "f" + (code - 111);
|
|
} else {
|
|
keyname = String.fromCharCode(code).toLowerCase();
|
|
}
|
|
break;
|
|
}
|
|
return keyname;
|
|
}
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var OutputConfig = function() {}
|
|
OutputConfig.prototype = plt.baselib.heir(WorldConfigOption.prototype);
|
|
var isOutputConfig = plt.baselib.makeClassPredicate(OutputConfig);
|
|
|
|
|
|
|
|
|
|
|
|
// // ToDraw
|
|
|
|
var ToDraw = function(handler) {
|
|
WorldConfigOption.call(this, 'to-draw');
|
|
this.handler = handler;
|
|
};
|
|
|
|
ToDraw.prototype = plt.baselib.heir(OutputConfig.prototype);
|
|
|
|
ToDraw.prototype.toRawHandler = function(MACHINE, toplevelNode) {
|
|
var that = this;
|
|
var reusableCanvas;
|
|
var reusableCanvasNode;
|
|
var adaptedWorldFunction = adaptWorldFunction(this.handler);
|
|
|
|
var worldFunction = function(world, success) {
|
|
|
|
adaptedWorldFunction(
|
|
world,
|
|
function(v) {
|
|
// fixme: once jsworld supports fail continuations, use them
|
|
// to check the status of the scene object and make sure it's an
|
|
// image.
|
|
|
|
|
|
if (isImage(v) ) {
|
|
var width = v.getWidth();
|
|
var height = v.getHeight();
|
|
|
|
if (! reusableCanvas) {
|
|
reusableCanvas = imageLibrary.makeCanvas(width, height);
|
|
// Note: the canvas object may itself manage objects,
|
|
// as in the case of an excanvas. In that case, we must make
|
|
// sure jsworld doesn't try to disrupt its contents!
|
|
reusableCanvas.jsworldOpaque = true;
|
|
reusableCanvasNode = rawJsworld.node_to_tree(reusableCanvas);
|
|
}
|
|
if (reusableCanvas.width !== width) {
|
|
reusableCanvas.width = width;
|
|
}
|
|
if (reusableCanvas.height !== height) {
|
|
reusableCanvas.height = height;
|
|
}
|
|
var ctx = reusableCanvas.getContext("2d");
|
|
v.render(ctx, 0, 0);
|
|
success([toplevelNode, reusableCanvasNode]);
|
|
} else {
|
|
success([toplevelNode, rawJsworld.node_to_tree(plt.baselib.format.toDomNode(v))]);
|
|
}
|
|
});
|
|
};
|
|
|
|
var cssFunction = function(w, k) {
|
|
if (reusableCanvas) {
|
|
k([[reusableCanvas,
|
|
["width", reusableCanvas.width + "px"],
|
|
["height", reusableCanvas.height + "px"]]]);
|
|
} else {
|
|
k([]);
|
|
}
|
|
}
|
|
|
|
return rawJsworld.on_draw(worldFunction, cssFunction);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var DefaultDrawingOutput = function() {
|
|
WorldConfigOption.call(this, 'to-draw');
|
|
};
|
|
|
|
DefaultDrawingOutput.prototype = plt.baselib.heir(WorldConfigOption.prototype);
|
|
|
|
DefaultDrawingOutput.prototype.toRawHandler = function(MACHINE, toplevelNode) {
|
|
var that = this;
|
|
var worldFunction = function(world, success) {
|
|
success([toplevelNode,
|
|
rawJsworld.node_to_tree(plt.baselib.format.toDomNode(world))]);
|
|
//k(rawJsworld.node_to_tree(plt.baselib.format.toDomNode(world)));
|
|
};
|
|
var cssFunction = function(w, success) { success([]); }
|
|
return rawJsworld.on_draw(worldFunction, cssFunction);
|
|
};
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
var StopWhen = function(handler) {
|
|
WorldConfigOption.call(this, 'stop-when');
|
|
this.handler = handler;
|
|
};
|
|
|
|
StopWhen.prototype = plt.baselib.heir(WorldConfigOption.prototype);
|
|
|
|
StopWhen.prototype.toRawHandler = function(MACHINE, toplevelNode) {
|
|
var that = this;
|
|
var worldFunction = adaptWorldFunction(that.handler);
|
|
return rawJsworld.stop_when(worldFunction);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// // This needs to be cleaned up!
|
|
|
|
|
|
// //////////////////////////////////////////////////////////////////////
|
|
// //////////////////////////////////////////////////////////////////////
|
|
// //////////////////////////////////////////////////////////////////////
|
|
// //////////////////////////////////////////////////////////////////////
|
|
// //////////////////////////////////////////////////////////////////////
|
|
|
|
// // The real low-level jsworld module:
|
|
// var _js = jsworld.Jsworld;
|
|
|
|
|
|
// var caller;
|
|
// var setCaller = function(c) {
|
|
// caller = function(op, args, k) {
|
|
// c(op, args, k, handleError);
|
|
// };
|
|
// };
|
|
// var unsetCaller = function() {
|
|
// caller = function(op, args, k) {
|
|
// throw new Error('caller not defined!');
|
|
// };
|
|
// };
|
|
// unsetCaller();
|
|
|
|
// // The restarted and things to set it
|
|
// // Note that we never want to restart the same computation
|
|
// // more than once, so we throw an error if someone tries to do that
|
|
// var restarter;
|
|
// var setRestarter = function(r) {
|
|
// var hasRestarted = false;
|
|
// restarter = function(v) {
|
|
// if (hasRestarted) {
|
|
// throw new Error('Cannot restart twice!');
|
|
// }
|
|
// hasRestarted = true;
|
|
// r(v);
|
|
// };
|
|
// };
|
|
// var unsetRestarter = function() {
|
|
// restarter = function() {
|
|
// throw new Error('restarter not defined!');
|
|
// };
|
|
// };
|
|
// unsetRestarter();
|
|
|
|
|
|
// var errorReporter = function(e) {
|
|
// // default: do nothing.
|
|
// };
|
|
|
|
|
|
|
|
// var terminator;
|
|
// var setTerminator = function(t) {
|
|
// terminator = t;
|
|
// };
|
|
// var unsetTerminator = function() {
|
|
// terminator = function() {
|
|
// throw new Error('terminator not defined!');
|
|
// };
|
|
// };
|
|
// unsetTerminator();
|
|
|
|
|
|
|
|
// // mutateStringsInDeepArray: array -> array
|
|
// // walks and in-place mutates Scheme strings to primitive strings.
|
|
// var mutateStringsInDeepArray = function(thing) {
|
|
// var i, length;
|
|
// if (typeof(thing) === 'object' &&
|
|
// thing.constructor === Array) {
|
|
// length = thing.length;
|
|
// for (i = 0; i < length; i++) {
|
|
// thing[i] = mutateStringsInDeepArray(thing[i]);
|
|
// }
|
|
// } else if (types.isString(thing)) {
|
|
// return thing.toString();
|
|
// }
|
|
// return thing;
|
|
// };
|
|
|
|
|
|
|
|
|
|
// var userConfigs = [];
|
|
|
|
// var startUserConfigs = function(k) {
|
|
// helpers.forEachK(userConfigs,
|
|
// function(aConfig, k2) {
|
|
// caller(aConfig.startup, aConfig.startupArgs,
|
|
// function(res) {
|
|
// aConfig.isRunning = true;
|
|
// aConfig.shutdownArg = res;
|
|
// k2()
|
|
// });
|
|
// },
|
|
// handleError,
|
|
// k);
|
|
// }
|
|
|
|
// var shutdownUserConfigs = function(k) {
|
|
// // console.log('shutting down user configs');
|
|
// var theConfigs = userConfigs;
|
|
// userConfigs = []
|
|
// helpers.forEachK(theConfigs,
|
|
// function(aConfig, k2) {
|
|
// // console.log(' shutting down a config');
|
|
// if (aConfig.isRunning) {
|
|
// aConfig.isRunning = false;
|
|
// caller(aConfig.shutdown, [aConfig.shutdownArg], k2);
|
|
// } else {
|
|
// k2();
|
|
// }
|
|
// },
|
|
// handleError,
|
|
// k);
|
|
// }
|
|
|
|
// var expandHandler = function(handler) {
|
|
// return types.jsValue('function', function() {
|
|
// var wrappedStimulusArgs = [];
|
|
// for (var i = 0; i < arguments.length; i++) {
|
|
// wrappedStimulusArgs.push( helpers.wrapJsValue(arguments[i]) );
|
|
// }
|
|
|
|
// Jsworld.updateWorld(
|
|
// function(w, k) {
|
|
// var args = [w].concat(wrappedStimulusArgs);
|
|
// caller(handler, args, k);
|
|
// },
|
|
// function() {});
|
|
// });
|
|
// };
|
|
|
|
|
|
// // var unwrapWorldEffects = function(w) {
|
|
// // if ( _js.has_effects(w) ) {
|
|
// // var unwrappedEffects =
|
|
// // helpers.map(function(e) {
|
|
// // if ( types.isEffect(e) ) {
|
|
// // return types.makeJsworldEffect(function(k) {
|
|
// // caller(types.effectThunk(e), [], k);
|
|
// // });
|
|
// // }
|
|
// // else {
|
|
// // return e;
|
|
// // }
|
|
// // },
|
|
// // w.getEffects());
|
|
// // var returnVal = _js.with_multiple_effects(w.getWorld(), unwrappedEffects);
|
|
// // return returnVal;
|
|
// // }
|
|
// // else {
|
|
// // return w;
|
|
// // }
|
|
// // };
|
|
|
|
|
|
// var deepUnwrapJsValues = function(x, k) {
|
|
// if ( types.isJsValue(x) ) {
|
|
// k(x.unbox());
|
|
// }
|
|
// else if ( types.isRenderEffect(x) ) {
|
|
// x.callImplementation(caller, function(y) { deepUnwrapJsValues(y, k); });
|
|
// }
|
|
// // var effects = helpers.schemeListToArray( types.renderEffectEffects(x) ).reverse();
|
|
// // types.setRenderEffectEffects(x, types.EMPTY);
|
|
// //
|
|
// // helpers.forEachK(effects,
|
|
// // function(ef, k2) { caller(ef, [], k2); },
|
|
// // handleError,
|
|
// // function() { deepUnwrapJsValues(types.renderEffectDomNode(x), k); });
|
|
// // }
|
|
// else if ( types.isPair(x) ) {
|
|
// deepUnwrapJsValues(x.first(), function(first) {
|
|
// deepUnwrapJsValues(x.rest(), function(rest) {
|
|
// k( types.cons(first, rest) );
|
|
// });
|
|
// });
|
|
// }
|
|
// else {
|
|
// k(x);
|
|
// }
|
|
// };
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// // isHandler: X -> boolean
|
|
// // Right now, a handler is a function that consumes and produces
|
|
// // configs. We should tighten up the type check eventually.
|
|
// var isHandler = function(x) {
|
|
// return typeof(x) == 'function';
|
|
// }
|
|
|
|
|
|
|
|
|
|
// //////////////////////////////////////////////////////////////////////
|
|
// //From this point forward, we define wrappers to integrate jsworld
|
|
// //with Moby.
|
|
|
|
|
|
// // getBigBangWindow: -> window
|
|
// var getBigBangWindow = function() {
|
|
// if (window.document.getElementById("jsworld-div") !== undefined) {
|
|
// return window;
|
|
// } else {
|
|
// var newDiv = window.document.createElement("div");
|
|
// newDiv.id = 'jsworld-div';
|
|
// window.document.appendChild(newDiv);
|
|
// return window;
|
|
// }
|
|
// }
|
|
|
|
|
|
// // types are
|
|
// // sexp: (cons node (listof sexp))
|
|
// // css-style: (node (listof (list string string)))
|
|
|
|
// // Exports:
|
|
|
|
|
|
|
|
|
|
// var isPair = types.isPair;
|
|
// var isEmpty = function(x) { return x === types.EMPTY; };
|
|
// var isList = function(x) { return (isPair(x) || isEmpty(x)); };
|
|
|
|
|
|
|
|
// // The default printWorldHook will write the written content of the node.
|
|
// // We probably want to invoke the pretty printer here instead!
|
|
// Jsworld.printWorldHook = function(world, node) {
|
|
// var newNode;
|
|
// if(node.lastChild == null) {
|
|
// newNode = types.toDomNode(world);
|
|
// node.appendChild(newNode);
|
|
// helpers.maybeCallAfterAttach(newNode);
|
|
// } else {
|
|
// newNode = types.toDomNode(world);
|
|
// node.replaceChild(newNode, node.lastChild);
|
|
// helpers.maybeCallAfterAttach(newNode);
|
|
// }
|
|
// };
|
|
|
|
|
|
|
|
// // Figure out the target of an event.
|
|
// // http://www.quirksmode.org/js/events_properties.html#target
|
|
// var findEventTarget = function(e) {
|
|
// var targ;
|
|
// if (e.target)
|
|
// targ = e.target;
|
|
// else if (e.srcElement)
|
|
// targ = e.srcElement;
|
|
// if (targ.nodeType == 3) // defeat Safari bug
|
|
// targ = targ.parentNode;
|
|
// return targ;
|
|
// }
|
|
|
|
// // isNode: any -> boolean
|
|
// // Returns true if the thing has a nodeType.
|
|
// var isNode = function(thing) {
|
|
// return thing && typeof(thing.nodeType) != 'undefined';
|
|
// }
|
|
|
|
|
|
|
|
// // checkWellFormedDomTree: X X (or number undefined) -> void
|
|
// // Check to see if the tree is well formed. If it isn't,
|
|
// // we need to raise a meaningful error so the user can repair
|
|
// // the structure.
|
|
// //
|
|
// // Invariants:
|
|
// // The dom tree must be a pair.
|
|
// // The first element must be a node.
|
|
// // Each of the rest of the elements must be dom trees.
|
|
// // If the first element is a text node, it must NOT have children.
|
|
// var checkWellFormedDomTree = function(x, top, index) {
|
|
// var fail = function(formatStr, formatArgs) {
|
|
// throw types.schemeError(
|
|
// types.incompleteExn(types.exnFailContract,
|
|
// helpers.format(formatStr, formatArgs),
|
|
// []));
|
|
// }
|
|
|
|
// if (_js.isPage(x)) {
|
|
// return;
|
|
// }
|
|
|
|
// if (types.isPair(x)) {
|
|
// var firstElt = x.first();
|
|
// var restElts = x.rest();
|
|
|
|
// if (! isNode(firstElt)) {
|
|
// fail("on-draw: expected a dom-element, but received ~s instead, the first element within ~s", [firstElt, top]);
|
|
// }
|
|
|
|
// if (firstElt.nodeType == Node.TEXT_NODE && !restElts.isEmpty() ) {
|
|
// fail("on-draw: the text node ~s must not have children. It has ~s", [firstElt, restElts]);
|
|
// }
|
|
|
|
// var i = 2;
|
|
// while( !restElts.isEmpty() ) {
|
|
// checkWellFormedDomTree(restElts.first(), x, i);
|
|
// restElts = restElts.rest();
|
|
// i++;
|
|
// }
|
|
// } else {
|
|
// var formatStr = "on-draw: expected a dom-s-expression, but received ~s instead";
|
|
// var formatArgs = [x];
|
|
// if (index != undefined) {
|
|
// formatStr += ", the ~a element within ~s";
|
|
// formatArgs.push( helpers.ordinalize(index) );
|
|
// formatArgs.push(top);
|
|
// }
|
|
// formatStr += ".";
|
|
|
|
// fail(formatStr, formatArgs);
|
|
// }
|
|
// };
|
|
|
|
|
|
// // Compatibility for attaching events to nodes.
|
|
// var attachEvent = function(node, eventName, fn) {
|
|
// if (node.addEventListener) {
|
|
// // Mozilla
|
|
// node.addEventListener(eventName, fn, false);
|
|
// } else {
|
|
// // IE
|
|
// node.attachEvent('on' + eventName, fn, false);
|
|
// }
|
|
// return function() {
|
|
// detachEvent(node, eventName, fn);
|
|
// }
|
|
// };
|
|
|
|
// var detachEvent = function(node, eventName, fn) {
|
|
// if (node.addEventListener) {
|
|
// // Mozilla
|
|
// node.removeEventListener(eventName, fn, false);
|
|
// } else {
|
|
// // IE
|
|
// node.detachEvent('on' + eventName, fn, false);
|
|
// }
|
|
// }
|
|
|
|
|
|
// var preventDefault = function(event) {
|
|
// if (event.preventDefault) {
|
|
// event.preventDefault();
|
|
// } else {
|
|
// event.returnValue = false;
|
|
// }
|
|
// }
|
|
|
|
// var stopPropagation = function(event) {
|
|
// if (event.stopPropagation) {
|
|
// event.stopPropagation();
|
|
// } else {
|
|
// event.cancelBubble = true;
|
|
// }
|
|
// }
|
|
|
|
|
|
// // bigBang: world dom (listof (list string string)) (arrayof handler) -> world
|
|
// Jsworld.bigBang = function(initWorld, toplevelNode, handlers, theCaller, theRestarter, onFail) {
|
|
// // shutdownListeners: arrayof (-> void)
|
|
// // We maintain a list of thunks that need to be called as soon as we come out of
|
|
// // bigBang, to do cleanup.
|
|
// var shutdownListeners = [];
|
|
|
|
// var onTermination = function(w) {
|
|
// for (var i = 0; i < shutdownListeners.length; i++) {
|
|
// try {
|
|
// shutdownListeners[i]();
|
|
// } catch (e) { }
|
|
// }
|
|
// shutdownUserConfigs(function() {
|
|
// unsetCaller();
|
|
// theRestarter(w);
|
|
// });
|
|
// }
|
|
|
|
|
|
// //console.log('in high level big-bang');
|
|
// errorReporter = onFail;
|
|
|
|
// setCaller(theCaller);
|
|
// setRestarter(theRestarter);
|
|
// setTerminator(function(w) {
|
|
// detachEvent(toplevelNode, 'click', absorber);
|
|
// shutdownUserConfigs(function() {
|
|
// unsetCaller();
|
|
// unsetTerminator();
|
|
// restarter(w);
|
|
// });
|
|
// });
|
|
|
|
// var attribs = types.EMPTY;
|
|
|
|
// // Ensure that the toplevelNode can be focused by mouse or keyboard
|
|
// toplevelNode.tabIndex = 0;
|
|
|
|
// // Absorb all click events so they don't bubble up.
|
|
// var absorber = function(e) {
|
|
// preventDefault(e);
|
|
// stopPropagation(e);
|
|
// return false;
|
|
// }
|
|
|
|
// attachEvent(toplevelNode, 'click', absorber);
|
|
// shutdownListeners.push(function() { detachEvent(toplevelNode, 'click', absorber)});
|
|
|
|
|
|
|
|
// var config = new world.Kernel.config.WorldConfig();
|
|
// for(var i = 0; i < handlers.length; i++) {
|
|
// if (isList(handlers[i])) {
|
|
// attribs = handlers[i];
|
|
// }
|
|
// else if (isHandler(handlers[i])) {
|
|
// config = handlers[i](config);
|
|
// }
|
|
// else if ( types.isWorldConfig(handlers[i]) ) {
|
|
// handlers[i].startupArgs = helpers.map(expandHandler, handlers[i].startupArgs);
|
|
// userConfigs.push(handlers[i]);
|
|
// }
|
|
// }
|
|
// config = config.updateAll({'changeWorld': Jsworld.updateWorld,
|
|
// 'shutdownWorld': Jsworld.shutdownWorld});
|
|
// var stimuli = new world.Kernel.stimuli.StimuliHandler(config, caller, restarter);
|
|
|
|
// var wrappedHandlers = [];
|
|
// var wrappedRedraw;
|
|
// var wrappedRedrawCss;
|
|
|
|
|
|
// if (config.lookup('onDraw')) {
|
|
// wrappedRedraw = function(w, k) {
|
|
// try {
|
|
// caller(config.lookup('onDraw'), [w],
|
|
// function(newDomTree) {
|
|
// deepUnwrapJsValues(newDomTree, function(unwrappedTree) {
|
|
// checkWellFormedDomTree(unwrappedTree, unwrappedTree, undefined);
|
|
// var result = [toplevelNode,
|
|
// helpers.deepListToArray(unwrappedTree)];
|
|
// k(result);
|
|
// });
|
|
// });
|
|
// } catch (e) {
|
|
// handleError(e);
|
|
// // throw e;
|
|
// }
|
|
// }
|
|
|
|
// if (config.lookup('onDrawCss')) {
|
|
// wrappedRedrawCss = function(w, k) {
|
|
// try {
|
|
// caller(config.lookup('onDrawCss'), [w],
|
|
// function(res) {
|
|
// var result = helpers.deepListToArray(res);
|
|
// result = mutateStringsInDeepArray(result);
|
|
// // plt.Kernel.setLastLoc(undefined);
|
|
// k(result);
|
|
// });
|
|
// } catch (e) {
|
|
// handleError(e);
|
|
// // throw e;
|
|
// }
|
|
// }
|
|
// }
|
|
// else {
|
|
// wrappedRedrawCss = function(w, k) { k([]); };
|
|
// }
|
|
// wrappedHandlers.push(_js.on_draw(wrappedRedraw, wrappedRedrawCss));
|
|
// } else if (config.lookup('onRedraw')) {
|
|
// var reusableCanvas = undefined;
|
|
// var reusableCanvasNode = undefined;
|
|
|
|
// wrappedRedraw = function(w, k) {
|
|
// try {
|
|
// //console.log('in onRedraw handler');
|
|
// caller(config.lookup('onRedraw'), [w],
|
|
// function(aScene) {
|
|
// // Performance hack: if we're using onRedraw, we know
|
|
// // we've got a scene, so we optimize away the repeated
|
|
// // construction of a canvas object.
|
|
// if ( world.Kernel.isImage(aScene) ) {
|
|
// var width = aScene.getWidth();
|
|
// var height = aScene.getHeight();
|
|
|
|
// if (! reusableCanvas) {
|
|
// reusableCanvas = world.Kernel.makeCanvas(width, height);
|
|
// // Note: the canvas object may itself manage objects,
|
|
// // as in the case of an excanvas. In that case, we must make
|
|
// // sure jsworld doesn't try to disrupt its contents!
|
|
// reusableCanvas.jsworldOpaque = true;
|
|
// reusableCanvasNode = _js.node_to_tree(reusableCanvas);
|
|
// }
|
|
|
|
// reusableCanvas.width = width;
|
|
// reusableCanvas.height = height;
|
|
// var ctx = reusableCanvas.getContext("2d");
|
|
// aScene.render(ctx, 0, 0);
|
|
|
|
// k([toplevelNode, reusableCanvasNode]);
|
|
// } else {
|
|
// k([toplevelNode, _js.node_to_tree(types.toDomNode(aScene))]);
|
|
// }
|
|
// });
|
|
// } catch (e) {
|
|
// handleError(e);
|
|
// // throw e;
|
|
// }
|
|
// }
|
|
|
|
// wrappedRedrawCss = function(w, k) {
|
|
// //console.log('in RedrawCss handler');
|
|
// k([[reusableCanvas,
|
|
// ["width", reusableCanvas.width + "px"],
|
|
// ["height", reusableCanvas.height + "px"]]]);
|
|
// }
|
|
// wrappedHandlers.push(_js.on_draw(wrappedRedraw, wrappedRedrawCss));
|
|
// } else {
|
|
// wrappedHandlers.push(_js.on_world_change
|
|
// (function(w, k) {
|
|
// Jsworld.printWorldHook(w, toplevelNode);
|
|
// k();
|
|
// }));
|
|
// }
|
|
|
|
// if (config.lookup('tickDelay')) {
|
|
// var wrappedTick = function(w, k) {
|
|
// caller(config.lookup('onTick'),
|
|
// [w],
|
|
// k);
|
|
// }
|
|
// var wrappedDelay = jsnums.toFixnum( config.lookup('tickDelay') );
|
|
// wrappedHandlers.push(_js.on_tick(wrappedDelay, wrappedTick));
|
|
// }
|
|
|
|
// if (config.lookup('stopWhen')) {
|
|
// wrappedHandlers.push(_js.stop_when(
|
|
// function(w, k) {
|
|
// caller(config.lookup('stopWhen'), [w],
|
|
// function(res) { k(res); });
|
|
// }));
|
|
// }
|
|
|
|
|
|
// if (config.lookup('onKey')) {
|
|
// var wrappedKey = function(w, e, k) {
|
|
// caller(config.lookup('onKey'), [w, helpers.getKeyCodeName(e)], k);
|
|
// }
|
|
// wrappedHandlers.push(_js.on_key(wrappedKey));
|
|
// toplevelNode.focus();
|
|
// }
|
|
|
|
|
|
// if (config.lookup('initialEffect')) {
|
|
// var updaters =
|
|
// world.Kernel.applyEffect(config.lookup('initialEffect'));
|
|
// for (var i = 0 ; i < updaters.length; i++) {
|
|
// if (config.lookup('stopWhen') &&
|
|
// config.lookup('stopWhen')([initWorld])) {
|
|
// break;
|
|
// } else {
|
|
// initWorld = updaters[i](initWorld);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
|
|
// _js.big_bang(toplevelNode,
|
|
// initWorld,
|
|
// wrappedHandlers,
|
|
// helpers.assocListToHash(attribs),
|
|
// terminator);
|
|
|
|
// startUserConfigs(function() {});
|
|
|
|
// return {
|
|
// breaker: function() {
|
|
// handleError(types.schemeError(
|
|
// types.incompleteExn(types.exnBreak, 'user break', [])));
|
|
// }
|
|
// };
|
|
|
|
// }
|
|
|
|
|
|
|
|
// var handleError = function(e) {
|
|
// // helpers.reportError(e);
|
|
// // When something bad happens, shut down
|
|
// // the world computation.
|
|
// // helpers.reportError("Shutting down jsworld computations");
|
|
// // world.Kernel.stimuli.onShutdown();
|
|
// world.Kernel.stimuli.massShutdown();
|
|
// shutdownUserConfigs(function() {
|
|
// errorReporter(e);
|
|
// // console.log('Got an error, the error was:');
|
|
// // console.log(e);
|
|
// if (typeof(console) !== 'undefined' && console.log) {
|
|
// if (e.stack) {
|
|
// console.log(e.stack);
|
|
// }
|
|
// else {
|
|
// console.log(e);
|
|
// }
|
|
// }
|
|
// if ( types.isSchemeError(e) ) {
|
|
// terminator(e);
|
|
// }
|
|
// else if ( types.isInternalError(e) ) {
|
|
// terminator(e);
|
|
// }
|
|
// else if (typeof(e) == 'string') {
|
|
// terminator( types.schemeError(types.incompleteExn(types.exnFail, e, [])) );
|
|
// }
|
|
// else if (e instanceof Error) {
|
|
// terminator( types.schemeError(types.incompleteExn(types.exnFail, e.message, [])) );
|
|
// }
|
|
// else {
|
|
// terminator( types.schemeError(e) );
|
|
// }
|
|
// });
|
|
// }
|
|
|
|
|
|
|
|
// // updateWorld: CPS( CPS(world -> world) -> void )
|
|
// Jsworld.updateWorld = function(updater, k) {
|
|
// var wrappedUpdater = function(w, k2) {
|
|
// try {
|
|
// updater(w, k2);
|
|
// } catch (e) {
|
|
// if (typeof(console) !== 'undefined' && console.log && e.stack) {
|
|
// console.log(e.stack);
|
|
// }
|
|
// handleError(e);
|
|
// // k2(w);
|
|
// }
|
|
// }
|
|
|
|
// _js.change_world(wrappedUpdater, k);
|
|
// }
|
|
|
|
|
|
|
|
// // shutdownWorld: -> void
|
|
// // Shut down all world computations.
|
|
// Jsworld.shutdownWorld = function() {
|
|
// _js.shutdown();
|
|
// };
|
|
|
|
|
|
// // var getAttribs = function(args) {
|
|
// // if (args.length == 0) {
|
|
// // return []
|
|
// // }
|
|
// // if (args.length == 1) {
|
|
// // return helpers.assocListToHash(args[0]);
|
|
// // } else {
|
|
// // throw new Error("getAttribs recevied unexpected value for args: "
|
|
// // + args);
|
|
// // }
|
|
// // }
|
|
|
|
|
|
// Jsworld.p = _js.p;
|
|
|
|
// Jsworld.div = _js.div;
|
|
|
|
// Jsworld.buttonBang = function(updateWorldF, effectF, attribs) {
|
|
// var wrappedF = function(w, evt, k) {
|
|
// try {
|
|
// // FIXME: Get effects back online!
|
|
// // caller(effectF, [world],
|
|
// // function(effect) {
|
|
// caller(updateWorldF, [w],
|
|
// function(newWorld) {
|
|
// // world.Kernel.applyEffect(effect);
|
|
// k(newWorld);
|
|
// });
|
|
// // });
|
|
// } catch (e) {
|
|
// if (typeof(console) !== 'undefined' && console.log && e.stack) {
|
|
// console.log(e.stack);
|
|
// }
|
|
// handleError(e);
|
|
// // k(w);
|
|
// }
|
|
// }
|
|
// return _js.button(wrappedF, attribs);
|
|
// };
|
|
|
|
|
|
// Jsworld.input = function(type, updateF, attribs) {
|
|
// var wrappedUpdater = function(w, evt, k) {
|
|
// caller(updateF, [w, evt], k);
|
|
// }
|
|
// return _js.input(type, wrappedUpdater, attribs);
|
|
// };
|
|
|
|
|
|
// Jsworld.get_dash_input_dash_value = function(node) {
|
|
// // plt.Kernel.check(node,
|
|
// // function(x) { return (plt.Kernel.isString(node) ||
|
|
// // node.nodeType ==
|
|
// // Node.ELEMENT_NODE) },
|
|
// // "get-input-value",
|
|
// // "dom-node",
|
|
// // 1);
|
|
// if (types.isString(node)) {
|
|
// return (document.getElementById(node).value || "");
|
|
// } else {
|
|
// return (node.value || "");
|
|
// }
|
|
|
|
// };
|
|
|
|
|
|
|
|
// // Images.
|
|
// Jsworld.img = _js.img;
|
|
|
|
// // text: string -> node
|
|
// Jsworld.text = _js.text;
|
|
|
|
// Jsworld.select = function(options, updateF, attribs) {
|
|
// var wrappedUpdater = function(w, e, k) {
|
|
// // console.log(e);
|
|
// caller(updateF, [w, e.target.value], k);
|
|
// }
|
|
// return _js.select(attribs, options, wrappedUpdater);
|
|
// };
|
|
|
|
|
|
|
|
|
|
// //////////////////////////////////////////////////////////////////////
|
|
// Jsworld.emptyPage = _js.emptyPage;
|
|
|
|
// Jsworld.placeOnPage = function(elt, left, top, page) {
|
|
// deepUnwrapJsValues(elt, function(newElt) {
|
|
// elt = types.toDomNode(newElt);});
|
|
// return _js.placeOnPage(elt, left, top, page);
|
|
// };
|
|
|
|
|
|
|
|
// var convertAttribList = function(attribList) {
|
|
// var nextElt;
|
|
// var key, val;
|
|
// var hash = {};
|
|
// while (attribList !== EMPTY) {
|
|
// nextElt = attribList.first;
|
|
|
|
// key = nextElt.first;
|
|
// val = nextElt.rest.first;
|
|
|
|
// key = String(key);
|
|
|
|
// if (isString(val)) {
|
|
// val = String(val);
|
|
// } else if (isBoolean(val)) {
|
|
// // do nothing: the representation is the same.
|
|
// } else if (isSymbol(val)) {
|
|
// if (String(val) === 'true') {
|
|
// val = true;
|
|
// } else if (String(val) === 'false') {
|
|
// val = false;
|
|
// } else {
|
|
// val = String(val);
|
|
// }
|
|
// } else {
|
|
// // raise error: neither string nor boolean
|
|
// throw new Error(
|
|
// plt.baselib.format.format(
|
|
// "attribute value ~s neither a string nor a boolean",
|
|
// [val]));
|
|
// }
|
|
// hash[key] = val;
|
|
// attribList = attribList.rest;
|
|
// }
|
|
// return hash;
|
|
// }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var PAUSE = plt.runtime.PAUSE;
|
|
var makeClosure = plt.baselib.functions.makeClosure;
|
|
var makeRational = plt.baselib.numbers.makeRational;
|
|
var makePrimitiveProcedure = plt.baselib.functions.makePrimitiveProcedure;
|
|
|
|
|
|
var checkNonNegativeReal = plt.baselib.check.checkNonNegativeReal;
|
|
var checkString = plt.baselib.check.checkString;
|
|
|
|
var checkProcedure = plt.baselib.check.checkProcedure;
|
|
|
|
// More specific function checkers, based on arity.
|
|
var checkProcedure1 = plt.baselib.check.makeCheckArgumentType(
|
|
function(x) { return (plt.baselib.functions.isProcedure(x) &&
|
|
plt.baselib.arity.isArityMatching(x.arity, 1)); },
|
|
'procedure that consumes a world argument');
|
|
|
|
|
|
var checkProcedureWithKey = plt.baselib.check.makeCheckArgumentType(
|
|
function(x) { return (plt.baselib.functions.isProcedure(x) &&
|
|
plt.baselib.arity.isArityMatching(x.arity, 2)); },
|
|
'procedure that consumes a world argument and a key');
|
|
|
|
|
|
var checkHandler = plt.baselib.check.makeCheckArgumentType(
|
|
isWorldConfigOption,
|
|
"world configuration handler");
|
|
|
|
|
|
|
|
|
|
// The default tick delay is 28 times a second.
|
|
var DEFAULT_TICK_DELAY = 1/28;
|
|
|
|
|
|
|
|
EXPORTS['big-bang'] =
|
|
makeClosure(
|
|
'big-bang',
|
|
plt.baselib.arity.makeArityAtLeast(1),
|
|
function(MACHINE) {
|
|
var initialWorldValue = MACHINE.env[MACHINE.env.length - 1];
|
|
var handlers = [];
|
|
for (var i = 1; i < MACHINE.argcount; i++) {
|
|
handlers.push(checkHandler(MACHINE, 'big-bang', i));
|
|
}
|
|
bigBang(MACHINE, initialWorldValue, handlers);
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['on-tick'] =
|
|
makePrimitiveProcedure(
|
|
'on-tick',
|
|
plt.baselib.lists.makeList(1, 2),
|
|
function(MACHINE) {
|
|
if (MACHINE.argcount === 1) {
|
|
var f = checkProcedure1(MACHINE, "on-tick", 0);
|
|
return new OnTick(f, Math.floor(DEFAULT_TICK_DELAY * 1000));
|
|
} else if (MACHINE.argcount === 2) {
|
|
var f = checkProcedure1(MACHINE, "on-tick", 0);
|
|
var delay = checkNonNegativeReal(MACHINE, "on-tick", 1);
|
|
return new OnTick(f, Math.floor(jsnums.toFixnum(delay) * 1000));
|
|
}
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['to-draw'] =
|
|
makePrimitiveProcedure(
|
|
'to-draw',
|
|
1,
|
|
function(MACHINE) {
|
|
var f = checkProcedure1(MACHINE, "on-tick", 0);
|
|
return new ToDraw(f);
|
|
});
|
|
|
|
|
|
|
|
|
|
EXPORTS['stop-when'] =
|
|
makePrimitiveProcedure(
|
|
'stop-when',
|
|
1,
|
|
function(MACHINE) {
|
|
var f = checkProcedure1(MACHINE, "on-tick", 0);
|
|
return new StopWhen(f);
|
|
});
|
|
|
|
|
|
EXPORTS['on-key'] =
|
|
makePrimitiveProcedure(
|
|
'on-key',
|
|
1,
|
|
function(MACHINE) {
|
|
var f = checkProcedureWithKey(MACHINE, "on-key", 0);
|
|
return new OnKey(f);
|
|
});
|
|
|
|
EXPORTS['key=?'] =
|
|
makePrimitiveProcedure(
|
|
'on-key',
|
|
2,
|
|
function(MACHINE) {
|
|
var k1 = checkString(MACHINE, "key=?", 0);
|
|
var k2 = checkString(MACHINE, "key=?", 1);
|
|
return k1.toString().toLowerCase() === k2.toString().toLowerCase();
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// EXPORTS['on-tick'] =
|
|
// new CasePrimitive(
|
|
// 'on-tick',
|
|
// [new PrimProc('on-tick',
|
|
// 1,
|
|
// false, false,
|
|
// function(f) {
|
|
// check(f, isFunction, "on-tick", "procedure", 1);
|
|
// return new OnTickBang(f,
|
|
// new PrimProc('', 1, false, false,
|
|
// function(w) { return types.effectDoNothing(); }),
|
|
// DEFAULT_TICK_DELAY);
|
|
// }),
|
|
// new PrimProc('on-tick',
|
|
// 2,
|
|
// false, false,
|
|
// function(f, aDelay) {
|
|
// check(f, isFunction, "on-tick", "procedure", 1, arguments);
|
|
// check(aDelay, isNumber, "on-tick", "number", 2, arguments);
|
|
// return new OnTickBang(f,
|
|
// new PrimProc('', 1, false, false,
|
|
// function(w) { return types.effectDoNothing(); }),
|
|
// aDelay);
|
|
// }) ]);
|
|
|
|
|
|
|
|
// EXPORTS['on-tick!'] =
|
|
// new CasePrimitive('on-tick!',
|
|
// [new PrimProc('on-tick!',
|
|
// 2,
|
|
// false, false,
|
|
// function(handler, effectHandler) {
|
|
// check(handler, isFunction, "on-tick!", "procedure", 1, arguments);
|
|
// check(effectHandler, isFunction, "on-tick!","procedure", 2, arguments);
|
|
// return new OnTickBang(handler, effectHandler, DEFAULT_TICK_DELAY);
|
|
// }),
|
|
// new PrimProc('on-tick!',
|
|
// 3,
|
|
// false, false,
|
|
// function(handler, effectHandler, aDelay) {
|
|
// check(handler, isFunction, "on-tick!", "procedure", 1, arguments);
|
|
// check(effectHandler, isFunction, "on-tick!","procedure", 2, arguments);
|
|
// check(aDelay, isNumber, "on-tick!", "number", 3, arguments);
|
|
// return new OnTickBang(handler, effectHandler, aDelay);
|
|
// }) ]);
|
|
})(MACHINE, plt.runtime, exports);
|
|
modrec.namespace["big-bang1.1"] = exports["big-bang"];
|
|
modrec.namespace["key=?4.4"] = exports["key=?"];
|
|
modrec.namespace["on-key3.3"] = exports["on-key"];
|
|
modrec.namespace["on-tick2.2"] = exports["on-tick"];
|
|
modrec.namespace["stop-when6.6"] = exports["stop-when"];
|
|
modrec.namespace["to-draw5.5"] = exports["to-draw"];
|
|
|
|
modrec.privateExports = exports;
|
|
return MACHINE.control.pop().label(MACHINE); };
|
|
if (! MACHINE.modules["whalesong/image.rkt"].isInvoked) {
|
|
MACHINE.modules["whalesong/image.rkt"].internalInvoke(MACHINE,
|
|
afterName988,
|
|
MACHINE.params.currentErrorHandler);
|
|
} else {
|
|
afterName988();
|
|
}
|
|
});
|
|
(function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start1613 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start1613;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1602, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/image.rkt"]=new RUNTIME.ModuleRecord("image", _moduleEntry1604);
|
|
return (_afterModuleBody1603)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies1600 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies1600;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1602, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/image.rkt"]=new RUNTIME.ModuleRecord("image", _moduleEntry1604);
|
|
return (_afterModuleBody1603)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry1604 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry1604;
|
|
}
|
|
MACHINE.modules["whalesong/image.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/lang/base.rkt"] !== undefined) !== false) { return (_linked1605)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/lang/base.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1606)(MACHINE);
|
|
};
|
|
|
|
var _linked1605 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1605;
|
|
}
|
|
if (MACHINE.modules["whalesong/lang/base.rkt"].isInvoked !== false) { return (_alreadyLoaded1606)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1608, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/lang/base.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1607 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1607;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1608)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1608 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1608;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/main.rkt"] !== undefined) !== false) { return (_linked1609)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1610)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1606 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1606;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/main.rkt"] !== undefined) !== false) { return (_linked1609)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1610)(MACHINE);
|
|
};
|
|
|
|
var _linked1609 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1609;
|
|
}
|
|
if (MACHINE.modules["whalesong/image/main.rkt"].isInvoked !== false) { return (_alreadyLoaded1610)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1612, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/image/main.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1611 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1611;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1612)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1612 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1612;
|
|
}
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.modules["whalesong/image.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
MACHINE.modules["whalesong/image.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1610 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1610;
|
|
}
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.modules["whalesong/image.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
MACHINE.modules["whalesong/image.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterModuleBody1603 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody1603;
|
|
}
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple1601 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple1601;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt1602)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt1602 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt1602;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn1608.multipleValueReturn = _onReturnMultiple1607;
|
|
_onReturn1612.multipleValueReturn = _onReturnMultiple1611;
|
|
_beforePopPrompt1602.multipleValueReturn = _beforePopPromptMultiple1601;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start1613); })(MACHINE, function() { (function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start1631 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start1631;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1616, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/image/main.rkt"]=new RUNTIME.ModuleRecord("main", _moduleEntry1618);
|
|
return (_afterModuleBody1617)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies1614 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies1614;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1616, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/image/main.rkt"]=new RUNTIME.ModuleRecord("main", _moduleEntry1618);
|
|
return (_afterModuleBody1617)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry1618 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry1618;
|
|
}
|
|
MACHINE.modules["whalesong/image/main.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/lang/base.rkt"] !== undefined) !== false) { return (_linked1619)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/lang/base.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1620)(MACHINE);
|
|
};
|
|
|
|
var _linked1619 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1619;
|
|
}
|
|
if (MACHINE.modules["whalesong/lang/base.rkt"].isInvoked !== false) { return (_alreadyLoaded1620)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1622, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/lang/base.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1621 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1621;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1622)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1622 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1622;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/private/main.rkt"] !== undefined) !== false) { return (_linked1623)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/private/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1624)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1620 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1620;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/private/main.rkt"] !== undefined) !== false) { return (_linked1623)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/private/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1624)(MACHINE);
|
|
};
|
|
|
|
var _linked1623 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1623;
|
|
}
|
|
if (MACHINE.modules["whalesong/image/private/main.rkt"].isInvoked !== false) { return (_alreadyLoaded1624)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1626, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/image/private/main.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1625 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1625;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1626)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1626 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1626;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/private/color.rkt"] !== undefined) !== false) { return (_linked1627)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/private/color.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1628)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1624 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1624;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/private/color.rkt"] !== undefined) !== false) { return (_linked1627)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/private/color.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1628)(MACHINE);
|
|
};
|
|
|
|
var _linked1627 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1627;
|
|
}
|
|
if (MACHINE.modules["whalesong/image/private/color.rkt"].isInvoked !== false) { return (_alreadyLoaded1628)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1630, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/image/private/color.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1629 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1629;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1630)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1630 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1630;
|
|
}
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.modules["whalesong/image/main.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
MACHINE.modules["whalesong/image/main.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1628 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1628;
|
|
}
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.modules["whalesong/image/main.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
MACHINE.modules["whalesong/image/main.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterModuleBody1617 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody1617;
|
|
}
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple1615 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple1615;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt1616)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt1616 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt1616;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn1622.multipleValueReturn = _onReturnMultiple1621;
|
|
_onReturn1626.multipleValueReturn = _onReturnMultiple1625;
|
|
_onReturn1630.multipleValueReturn = _onReturnMultiple1629;
|
|
_beforePopPrompt1616.multipleValueReturn = _beforePopPromptMultiple1615;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start1631); })(MACHINE, function() {
|
|
MACHINE.modules["whalesong/image/private/main.rkt"] =
|
|
new plt.runtime.ModuleRecord("whalesong/image/private/main.rkt",
|
|
function(MACHINE) {
|
|
var afterName1089 = function() {
|
|
if(--MACHINE.callsBeforeTrampoline<0) { throw arguments.callee; }
|
|
var modrec = MACHINE.modules["whalesong/image/private/main.rkt"];
|
|
var exports = {};
|
|
modrec.isInvoked = true;
|
|
(function(MACHINE, RUNTIME, EXPORTS){// This might want to live in the Racket world rather than in
|
|
// JavaScript land...
|
|
|
|
|
|
var colorNamespace = MACHINE.modules['whalesong/image/private/color.rkt'].namespace;
|
|
var colorStruct = colorNamespace['struct:color'];
|
|
var makeColor = colorStruct.constructor;
|
|
|
|
|
|
|
|
// Color database
|
|
var ColorDb = function() {
|
|
this.colors = {};
|
|
};
|
|
|
|
|
|
ColorDb.prototype.put = function(name, color) {
|
|
this.colors[name] = color;
|
|
};
|
|
|
|
ColorDb.prototype.get = function(name) {
|
|
return this.colors[name.toString().toUpperCase()];
|
|
};
|
|
|
|
|
|
// FIXME: update toString to handle the primitive field values.
|
|
|
|
var colorDb = new ColorDb();
|
|
colorDb.put("ORANGE", makeColor(255, 165, 0));
|
|
colorDb.put("RED", makeColor(255, 0, 0));
|
|
colorDb.put("ORANGERED", makeColor(255, 69, 0));
|
|
colorDb.put("TOMATO", makeColor(255, 99, 71));
|
|
colorDb.put("DARKRED", makeColor(139, 0, 0));
|
|
colorDb.put("RED", makeColor(255, 0, 0));
|
|
colorDb.put("FIREBRICK", makeColor(178, 34, 34));
|
|
colorDb.put("CRIMSON", makeColor(220, 20, 60));
|
|
colorDb.put("DEEPPINK", makeColor(255, 20, 147));
|
|
colorDb.put("MAROON", makeColor(176, 48, 96));
|
|
colorDb.put("INDIAN RED", makeColor(205, 92, 92));
|
|
colorDb.put("INDIANRED", makeColor(205, 92, 92));
|
|
colorDb.put("MEDIUM VIOLET RED", makeColor(199, 21, 133));
|
|
colorDb.put("MEDIUMVIOLETRED", makeColor(199, 21, 133));
|
|
colorDb.put("VIOLET RED", makeColor(208, 32, 144));
|
|
colorDb.put("VIOLETRED", makeColor(208, 32, 144));
|
|
colorDb.put("LIGHTCORAL", makeColor(240, 128, 128));
|
|
colorDb.put("HOTPINK", makeColor(255, 105, 180));
|
|
colorDb.put("PALEVIOLETRED", makeColor(219, 112, 147));
|
|
colorDb.put("LIGHTPINK", makeColor(255, 182, 193));
|
|
colorDb.put("ROSYBROWN", makeColor(188, 143, 143));
|
|
colorDb.put("PINK", makeColor(255, 192, 203));
|
|
colorDb.put("ORCHID", makeColor(218, 112, 214));
|
|
colorDb.put("LAVENDERBLUSH", makeColor(255, 240, 245));
|
|
colorDb.put("SNOW", makeColor(255, 250, 250));
|
|
colorDb.put("CHOCOLATE", makeColor(210, 105, 30));
|
|
colorDb.put("SADDLEBROWN", makeColor(139, 69, 19));
|
|
colorDb.put("BROWN", makeColor(132, 60, 36));
|
|
colorDb.put("DARKORANGE", makeColor(255, 140, 0));
|
|
colorDb.put("CORAL", makeColor(255, 127, 80));
|
|
colorDb.put("SIENNA", makeColor(160, 82, 45));
|
|
colorDb.put("ORANGE", makeColor(255, 165, 0));
|
|
colorDb.put("SALMON", makeColor(250, 128, 114));
|
|
colorDb.put("PERU", makeColor(205, 133, 63));
|
|
colorDb.put("DARKGOLDENROD", makeColor(184, 134, 11));
|
|
colorDb.put("GOLDENROD", makeColor(218, 165, 32));
|
|
colorDb.put("SANDYBROWN", makeColor(244, 164, 96));
|
|
colorDb.put("LIGHTSALMON", makeColor(255, 160, 122));
|
|
colorDb.put("DARKSALMON", makeColor(233, 150, 122));
|
|
colorDb.put("GOLD", makeColor(255, 215, 0));
|
|
colorDb.put("YELLOW", makeColor(255, 255, 0));
|
|
colorDb.put("OLIVE", makeColor(128, 128, 0));
|
|
colorDb.put("BURLYWOOD", makeColor(222, 184, 135));
|
|
colorDb.put("TAN", makeColor(210, 180, 140));
|
|
colorDb.put("NAVAJOWHITE", makeColor(255, 222, 173));
|
|
colorDb.put("PEACHPUFF", makeColor(255, 218, 185));
|
|
colorDb.put("KHAKI", makeColor(240, 230, 140));
|
|
colorDb.put("DARKKHAKI", makeColor(189, 183, 107));
|
|
colorDb.put("MOCCASIN", makeColor(255, 228, 181));
|
|
colorDb.put("WHEAT", makeColor(245, 222, 179));
|
|
colorDb.put("BISQUE", makeColor(255, 228, 196));
|
|
colorDb.put("PALEGOLDENROD", makeColor(238, 232, 170));
|
|
colorDb.put("BLANCHEDALMOND", makeColor(255, 235, 205));
|
|
colorDb.put("MEDIUM GOLDENROD", makeColor(234, 234, 173));
|
|
colorDb.put("MEDIUMGOLDENROD", makeColor(234, 234, 173));
|
|
colorDb.put("PAPAYAWHIP", makeColor(255, 239, 213));
|
|
colorDb.put("MISTYROSE", makeColor(255, 228, 225));
|
|
colorDb.put("LEMONCHIFFON", makeColor(255, 250, 205));
|
|
colorDb.put("ANTIQUEWHITE", makeColor(250, 235, 215));
|
|
colorDb.put("CORNSILK", makeColor(255, 248, 220));
|
|
colorDb.put("LIGHTGOLDENRODYELLOW", makeColor(250, 250, 210));
|
|
colorDb.put("OLDLACE", makeColor(253, 245, 230));
|
|
colorDb.put("LINEN", makeColor(250, 240, 230));
|
|
colorDb.put("LIGHTYELLOW", makeColor(255, 255, 224));
|
|
colorDb.put("SEASHELL", makeColor(255, 245, 238));
|
|
colorDb.put("BEIGE", makeColor(245, 245, 220));
|
|
colorDb.put("FLORALWHITE", makeColor(255, 250, 240));
|
|
colorDb.put("IVORY", makeColor(255, 255, 240));
|
|
colorDb.put("GREEN", makeColor(0, 255, 0));
|
|
colorDb.put("LAWNGREEN", makeColor(124, 252, 0));
|
|
colorDb.put("CHARTREUSE", makeColor(127, 255, 0));
|
|
colorDb.put("GREEN YELLOW", makeColor(173, 255, 47));
|
|
colorDb.put("GREENYELLOW", makeColor(173, 255, 47));
|
|
colorDb.put("YELLOW GREEN", makeColor(154, 205, 50));
|
|
colorDb.put("YELLOWGREEN", makeColor(154, 205, 50));
|
|
colorDb.put("MEDIUM FOREST GREEN", makeColor(107, 142, 35));
|
|
colorDb.put("OLIVEDRAB", makeColor(107, 142, 35));
|
|
colorDb.put("MEDIUMFORESTGREEN", makeColor(107, 142, 35));
|
|
colorDb.put("DARK OLIVE GREEN", makeColor(85, 107, 47));
|
|
colorDb.put("DARKOLIVEGREEN", makeColor(85, 107, 47));
|
|
colorDb.put("DARKSEAGREEN", makeColor(143, 188, 139));
|
|
colorDb.put("LIME", makeColor(0, 255, 0));
|
|
colorDb.put("DARK GREEN", makeColor(0, 100, 0));
|
|
colorDb.put("DARKGREEN", makeColor(0, 100, 0));
|
|
colorDb.put("LIME GREEN", makeColor(50, 205, 50));
|
|
colorDb.put("LIMEGREEN", makeColor(50, 205, 50));
|
|
colorDb.put("FOREST GREEN", makeColor(34, 139, 34));
|
|
colorDb.put("FORESTGREEN", makeColor(34, 139, 34));
|
|
colorDb.put("SPRING GREEN", makeColor(0, 255, 127));
|
|
colorDb.put("SPRINGGREEN", makeColor(0, 255, 127));
|
|
colorDb.put("MEDIUM SPRING GREEN", makeColor(0, 250, 154));
|
|
colorDb.put("MEDIUMSPRINGGREEN", makeColor(0, 250, 154));
|
|
colorDb.put("SEA GREEN", makeColor(46, 139, 87));
|
|
colorDb.put("SEAGREEN", makeColor(46, 139, 87));
|
|
colorDb.put("MEDIUM SEA GREEN", makeColor(60, 179, 113));
|
|
colorDb.put("MEDIUMSEAGREEN", makeColor(60, 179, 113));
|
|
colorDb.put("AQUAMARINE", makeColor(112, 216, 144));
|
|
colorDb.put("LIGHTGREEN", makeColor(144, 238, 144));
|
|
colorDb.put("PALE GREEN", makeColor(152, 251, 152));
|
|
colorDb.put("PALEGREEN", makeColor(152, 251, 152));
|
|
colorDb.put("MEDIUM AQUAMARINE", makeColor(102, 205, 170));
|
|
colorDb.put("MEDIUMAQUAMARINE", makeColor(102, 205, 170));
|
|
colorDb.put("TURQUOISE", makeColor(64, 224, 208));
|
|
colorDb.put("LIGHTSEAGREEN", makeColor(32, 178, 170));
|
|
colorDb.put("MEDIUM TURQUOISE", makeColor(72, 209, 204));
|
|
colorDb.put("MEDIUMTURQUOISE", makeColor(72, 209, 204));
|
|
colorDb.put("HONEYDEW", makeColor(240, 255, 240));
|
|
colorDb.put("MINTCREAM", makeColor(245, 255, 250));
|
|
colorDb.put("ROYALBLUE", makeColor(65, 105, 225));
|
|
colorDb.put("DODGERBLUE", makeColor(30, 144, 255));
|
|
colorDb.put("DEEPSKYBLUE", makeColor(0, 191, 255));
|
|
colorDb.put("CORNFLOWERBLUE", makeColor(100, 149, 237));
|
|
colorDb.put("STEEL BLUE", makeColor(70, 130, 180));
|
|
colorDb.put("STEELBLUE", makeColor(70, 130, 180));
|
|
colorDb.put("LIGHTSKYBLUE", makeColor(135, 206, 250));
|
|
colorDb.put("DARK TURQUOISE", makeColor(0, 206, 209));
|
|
colorDb.put("DARKTURQUOISE", makeColor(0, 206, 209));
|
|
colorDb.put("CYAN", makeColor(0, 255, 255));
|
|
colorDb.put("AQUA", makeColor(0, 255, 255));
|
|
colorDb.put("DARKCYAN", makeColor(0, 139, 139));
|
|
colorDb.put("TEAL", makeColor(0, 128, 128));
|
|
colorDb.put("SKY BLUE", makeColor(135, 206, 235));
|
|
colorDb.put("SKYBLUE", makeColor(135, 206, 235));
|
|
colorDb.put("CADET BLUE", makeColor(96, 160, 160));
|
|
colorDb.put("CADETBLUE", makeColor(95, 158, 160));
|
|
colorDb.put("DARK SLATE GRAY", makeColor(47, 79, 79));
|
|
colorDb.put("DARKSLATEGRAY", makeColor(47, 79, 79));
|
|
colorDb.put("LIGHTSLATEGRAY", makeColor(119, 136, 153));
|
|
colorDb.put("SLATEGRAY", makeColor(112, 128, 144));
|
|
colorDb.put("LIGHT STEEL BLUE", makeColor(176, 196, 222));
|
|
colorDb.put("LIGHTSTEELBLUE", makeColor(176, 196, 222));
|
|
colorDb.put("LIGHT BLUE", makeColor(173, 216, 230));
|
|
colorDb.put("LIGHTBLUE", makeColor(173, 216, 230));
|
|
colorDb.put("POWDERBLUE", makeColor(176, 224, 230));
|
|
colorDb.put("PALETURQUOISE", makeColor(175, 238, 238));
|
|
colorDb.put("LIGHTCYAN", makeColor(224, 255, 255));
|
|
colorDb.put("ALICEBLUE", makeColor(240, 248, 255));
|
|
colorDb.put("AZURE", makeColor(240, 255, 255));
|
|
colorDb.put("MEDIUM BLUE", makeColor(0, 0, 205));
|
|
colorDb.put("MEDIUMBLUE", makeColor(0, 0, 205));
|
|
colorDb.put("DARKBLUE", makeColor(0, 0, 139));
|
|
colorDb.put("MIDNIGHT BLUE", makeColor(25, 25, 112));
|
|
colorDb.put("MIDNIGHTBLUE", makeColor(25, 25, 112));
|
|
colorDb.put("NAVY", makeColor(36, 36, 140));
|
|
colorDb.put("BLUE", makeColor(0, 0, 255));
|
|
colorDb.put("INDIGO", makeColor(75, 0, 130));
|
|
colorDb.put("BLUE VIOLET", makeColor(138, 43, 226));
|
|
colorDb.put("BLUEVIOLET", makeColor(138, 43, 226));
|
|
colorDb.put("MEDIUM SLATE BLUE", makeColor(123, 104, 238));
|
|
colorDb.put("MEDIUMSLATEBLUE", makeColor(123, 104, 238));
|
|
colorDb.put("SLATE BLUE", makeColor(106, 90, 205));
|
|
colorDb.put("SLATEBLUE", makeColor(106, 90, 205));
|
|
colorDb.put("PURPLE", makeColor(160, 32, 240));
|
|
colorDb.put("DARK SLATE BLUE", makeColor(72, 61, 139));
|
|
colorDb.put("DARKSLATEBLUE", makeColor(72, 61, 139));
|
|
colorDb.put("DARKVIOLET", makeColor(148, 0, 211));
|
|
colorDb.put("DARK ORCHID", makeColor(153, 50, 204));
|
|
colorDb.put("DARKORCHID", makeColor(153, 50, 204));
|
|
colorDb.put("MEDIUMPURPLE", makeColor(147, 112, 219));
|
|
colorDb.put("CORNFLOWER BLUE", makeColor(68, 64, 108));
|
|
colorDb.put("MEDIUM ORCHID", makeColor(186, 85, 211));
|
|
colorDb.put("MEDIUMORCHID", makeColor(186, 85, 211));
|
|
colorDb.put("MAGENTA", makeColor(255, 0, 255));
|
|
colorDb.put("FUCHSIA", makeColor(255, 0, 255));
|
|
colorDb.put("DARKMAGENTA", makeColor(139, 0, 139));
|
|
colorDb.put("VIOLET", makeColor(238, 130, 238));
|
|
colorDb.put("PLUM", makeColor(221, 160, 221));
|
|
colorDb.put("LAVENDER", makeColor(230, 230, 250));
|
|
colorDb.put("THISTLE", makeColor(216, 191, 216));
|
|
colorDb.put("GHOSTWHITE", makeColor(248, 248, 255));
|
|
colorDb.put("WHITE", makeColor(255, 255, 255));
|
|
colorDb.put("WHITESMOKE", makeColor(245, 245, 245));
|
|
colorDb.put("GAINSBORO", makeColor(220, 220, 220));
|
|
colorDb.put("LIGHT GRAY", makeColor(211, 211, 211));
|
|
colorDb.put("LIGHTGRAY", makeColor(211, 211, 211));
|
|
colorDb.put("SILVER", makeColor(192, 192, 192));
|
|
colorDb.put("GRAY", makeColor(190, 190, 190));
|
|
colorDb.put("DARK GRAY", makeColor(169, 169, 169));
|
|
colorDb.put("DARKGRAY", makeColor(169, 169, 169));
|
|
colorDb.put("DIM GRAY", makeColor(105, 105, 105));
|
|
colorDb.put("DIMGRAY", makeColor(105, 105, 105));
|
|
colorDb.put("BLACK", makeColor(0, 0, 0));
|
|
|
|
|
|
|
|
EXPORTS['_colorDb'] = colorDb;
|
|
|
|
// Basic implementation of the image library.
|
|
//
|
|
// This should mimic the implementation of 2htdp/image.
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
var colorNamespace = MACHINE.modules['whalesong/image/private/color.rkt'].namespace;
|
|
var colorStruct = colorNamespace['struct:color'];
|
|
var makeColor = colorStruct.constructor;
|
|
var isColor = colorStruct.predicate;
|
|
var colorRed = function(c) { return colorStruct.accessor(c, 0); };
|
|
var colorGreen = function(c) { return colorStruct.accessor(c, 1); };
|
|
var colorBlue = function(c) { return colorStruct.accessor(c, 2); };
|
|
var colorAlpha = function(c) { return colorStruct.accessor(c, 3); };
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
var heir = plt.baselib.heir;
|
|
var clone = plt.baselib.clone;
|
|
|
|
|
|
|
|
|
|
var isAngle = function(x) {
|
|
return plt.baselib.numbers.isReal(x) &&
|
|
jsnums.greaterThanOrEqual(x, 0) &&
|
|
jsnums.lessThan(x, 360);
|
|
};
|
|
|
|
|
|
|
|
|
|
// Produces true if the value is a color or a color string.
|
|
// On the Racket side of things, this is exposed as image-color?.
|
|
var isColorOrColorString = function(thing) {
|
|
return (isColor(thing) ||
|
|
((plt.baselib.strings.isString(thing) ||
|
|
plt.baselib.symbols.isSymbol(thing)) &&
|
|
typeof(colorDb.get(thing)) != 'undefined'));
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var colorString = function(aColor) {
|
|
return ("rgb(" +
|
|
colorRed(aColor) + "," +
|
|
colorGreen(aColor) + ", " +
|
|
colorBlue(aColor) + ")");
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// Produces true if thing is an image.
|
|
var isImage = function(thing) {
|
|
return (thing instanceof BaseImage);
|
|
};
|
|
|
|
var isSideCount = function(x) {
|
|
return plt.baselib.numbers.isInteger(x) && jsnums.greaterThanOrEqual(x, 3);
|
|
};
|
|
|
|
var isStepCount = function(x) {
|
|
return plt.baselib.numbers.isInteger(x) && jsnums.greaterThanOrEqual(x, 1);
|
|
};
|
|
|
|
|
|
var isPointsCount = function(x) {
|
|
return plt.baselib.numbers.isNatural(x) && jsnums.greaterThanOrEqual(x, 2);
|
|
};
|
|
|
|
|
|
|
|
|
|
// Base class for all images.
|
|
var BaseImage = function(pinholeX, pinholeY) {
|
|
this.pinholeX = pinholeX;
|
|
this.pinholeY = pinholeY;
|
|
};
|
|
|
|
|
|
|
|
BaseImage.prototype.updatePinhole = function(x, y) {
|
|
var aCopy = clone(this);
|
|
aCopy.pinholeX = x;
|
|
aCopy.pinholeY = y;
|
|
return aCopy;
|
|
};
|
|
|
|
BaseImage.prototype.getHeight = function(){
|
|
return this.height;
|
|
};
|
|
|
|
BaseImage.prototype.getWidth = function(){
|
|
return this.width;
|
|
};
|
|
|
|
BaseImage.prototype.getBaseline = function(){
|
|
return this.height;
|
|
};
|
|
|
|
|
|
// render: context fixnum fixnum: -> void
|
|
// Render the image, where the upper-left corner of the image is drawn at
|
|
// (x, y).
|
|
// NOTE: the rendering should be oblivous to the pinhole.
|
|
BaseImage.prototype.render = function(ctx, x, y) {
|
|
throw new Error('BaseImage.render unimplemented!');
|
|
};
|
|
|
|
|
|
// makeCanvas: number number -> canvas
|
|
// Constructs a canvas object of a particular width and height.
|
|
var makeCanvas = function(width, height) {
|
|
var canvas = document.createElement("canvas");
|
|
canvas.width = width;
|
|
canvas.height = height;
|
|
|
|
canvas.style.width = canvas.width + "px";
|
|
canvas.style.height = canvas.height + "px";
|
|
|
|
// KLUDGE: IE compatibility uses /js/excanvas.js, and dynamic
|
|
// elements must be marked this way.
|
|
if (window && typeof window.G_vmlCanvasManager != 'undefined') {
|
|
canvas = window.G_vmlCanvasManager.initElement(canvas);
|
|
}
|
|
return canvas;
|
|
};
|
|
|
|
|
|
|
|
var withIeHack = function(canvas, f) {
|
|
// canvas.style.display = 'none';
|
|
// document.body.appendChild(canvas);
|
|
// try {
|
|
var result = f(canvas);
|
|
// } catch(e) {
|
|
// document.body.removeChild(canvas);
|
|
// canvas.style.display = '';
|
|
// throw e;
|
|
// }
|
|
// document.body.removeChild(canvas);
|
|
// canvas.style.display = '';
|
|
return result;
|
|
};
|
|
|
|
|
|
|
|
// Images are expected to define a render() method, which is used
|
|
// here to draw to the canvas.
|
|
BaseImage.prototype.toDomNode = function(cache) {
|
|
var that = this;
|
|
var width = that.getWidth();
|
|
var height = that.getHeight();
|
|
var canvas = makeCanvas(width, height);
|
|
|
|
|
|
// KLUDGE: on IE, the canvas rendering functions depend on a
|
|
// context where the canvas is attached to the DOM tree.
|
|
|
|
// We initialize an afterAttach hook; the client's responsible
|
|
// for calling this after the dom node is attached to the
|
|
// document.
|
|
$(canvas).bind('afterAttach',
|
|
function(event) {
|
|
var ctx = canvas.getContext("2d");
|
|
that.render(ctx, 0, 0);
|
|
});
|
|
return canvas;
|
|
};
|
|
|
|
|
|
|
|
|
|
BaseImage.prototype.toWrittenString = function(cache) { return "<image>"; }
|
|
BaseImage.prototype.toDisplayedString = function(cache) { return "<image>"; }
|
|
|
|
BaseImage.prototype.equals = function(other, aUnionFind) {
|
|
return (this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY);
|
|
};
|
|
|
|
|
|
|
|
|
|
// isScene: any -> boolean
|
|
// Produces true when x is a scene.
|
|
var isScene = function(x) {
|
|
return ((x != undefined) && (x != null) && (x instanceof SceneImage));
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// SceneImage: primitive-number primitive-number (listof image) -> Scene
|
|
var SceneImage = function(width, height, children, withBorder) {
|
|
BaseImage.call(this, 0, 0);
|
|
this.width = width;
|
|
this.height = height;
|
|
this.children = children; // arrayof [image, number, number]
|
|
this.withBorder = withBorder;
|
|
}
|
|
SceneImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
// add: image primitive-number primitive-number -> Scene
|
|
SceneImage.prototype.add = function(anImage, x, y) {
|
|
return new SceneImage(this.width,
|
|
this.height,
|
|
this.children.concat([[anImage,
|
|
x - anImage.pinholeX,
|
|
y - anImage.pinholeY]]),
|
|
this.withBorder);
|
|
};
|
|
|
|
// render: 2d-context primitive-number primitive-number -> void
|
|
SceneImage.prototype.render = function(ctx, x, y) {
|
|
var i;
|
|
var childImage, childX, childY;
|
|
// Clear the scene.
|
|
ctx.clearRect(x, y, this.width, this.height);
|
|
// Then ask every object to render itself.
|
|
for(i = 0; i < this.children.length; i++) {
|
|
childImage = this.children[i][0];
|
|
childX = this.children[i][1];
|
|
childY = this.children[i][2];
|
|
ctx.save();
|
|
childImage.render(ctx, childX + x, childY + y);
|
|
ctx.restore();
|
|
|
|
|
|
}
|
|
// Finally, draw the black border if withBorder is true
|
|
if (this.withBorder) {
|
|
ctx.strokeStyle = 'black';
|
|
ctx.strokeRect(x, y, this.width, this.height);
|
|
}
|
|
};
|
|
|
|
SceneImage.prototype.equals = function(other, aUnionFind) {
|
|
if (!(other instanceof SceneImage)) {
|
|
return false;
|
|
}
|
|
|
|
if (this.pinholeX != other.pinholeX ||
|
|
this.pinholeY != other.pinholeY ||
|
|
this.width != other.width ||
|
|
this.height != other.height ||
|
|
this.children.length != other.children.length) {
|
|
return false;
|
|
}
|
|
|
|
for (var i = 0; i < this.children.length; i++) {
|
|
var rec1 = this.children[i];
|
|
var rec2 = other.children[i];
|
|
if (rec1[1] !== rec2[1] ||
|
|
rec1[2] !== rec2[2] ||
|
|
!plt.baselib.equality.equals(rec1[0],
|
|
rec2[0],
|
|
aUnionFind)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// FileImage: string node -> Image
|
|
var FileImage = function(src, rawImage) {
|
|
BaseImage.call(this, 0, 0);
|
|
var self = this;
|
|
this.src = src;
|
|
this.isLoaded = false;
|
|
if (rawImage && rawImage.complete) {
|
|
this.img = rawImage;
|
|
this.isLoaded = true;
|
|
this.pinholeX = self.img.width / 2;
|
|
this.pinholeY = self.img.height / 2;
|
|
} else {
|
|
// fixme: we may want to do something blocking here for
|
|
// onload, since we don't know at this time what the file size
|
|
// should be, nor will drawImage do the right thing until the
|
|
// file is loaded.
|
|
this.img = new Image();
|
|
this.img.onload = function() {
|
|
self.isLoaded = true;
|
|
self.pinholeX = self.img.width / 2;
|
|
self.pinholeY = self.img.height / 2;
|
|
};
|
|
this.img.onerror = function(e) {
|
|
self.img.onerror = "";
|
|
self.img.src = "http://www.wescheme.org/images/broken.png";
|
|
}
|
|
this.img.src = src;
|
|
}
|
|
}
|
|
FileImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
var imageCache = {};
|
|
FileImage.makeInstance = function(path, rawImage) {
|
|
if (! (path in imageCache)) {
|
|
imageCache[path] = new FileImage(path, rawImage);
|
|
}
|
|
return imageCache[path];
|
|
};
|
|
|
|
FileImage.installInstance = function(path, rawImage) {
|
|
imageCache[path] = new FileImage(path, rawImage);
|
|
};
|
|
|
|
FileImage.installBrokenImage = function(path) {
|
|
imageCache[path] = new TextImage("Unable to load " + path, 10, colorDb.get("red"),
|
|
"normal", "Optimer","","",false);
|
|
};
|
|
|
|
|
|
|
|
FileImage.prototype.render = function(ctx, x, y) {
|
|
ctx.drawImage(this.img, x, y);
|
|
};
|
|
|
|
|
|
FileImage.prototype.getWidth = function() {
|
|
return this.img.width;
|
|
};
|
|
|
|
|
|
FileImage.prototype.getHeight = function() {
|
|
return this.img.height;
|
|
};
|
|
|
|
// Override toDomNode: we don't need a full-fledged canvas here.
|
|
FileImage.prototype.toDomNode = function(cache) {
|
|
return this.img.cloneNode(true);
|
|
};
|
|
|
|
FileImage.prototype.equals = function(other, aUnionFind) {
|
|
return (other instanceof FileImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.src == other.src);
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// VideoImage: String Node -> Video
|
|
var VideoImage = function(src, rawVideo) {
|
|
BaseImage.call(this, 0, 0);
|
|
var self = this;
|
|
this.src = src;
|
|
if (rawVideo) {
|
|
this.video = rawVideo;
|
|
this.width = self.video.videoWidth;
|
|
this.height = self.video.videoHeight;
|
|
this.pinholeX = self.width / 2;
|
|
this.pinholeY = self.height / 2;
|
|
this.video.volume = 1;
|
|
this.video.poster = "http://www.wescheme.org/images/broken.png";
|
|
this.video.autoplay = true;
|
|
this.video.autobuffer=true;
|
|
this.video.loop = true;
|
|
this.video.play();
|
|
} else {
|
|
// fixme: we may want to do something blocking here for
|
|
// onload, since we don't know at this time what the file size
|
|
// should be, nor will drawImage do the right thing until the
|
|
// file is loaded.
|
|
this.video = document.createElement('video');
|
|
this.video.src = src;
|
|
this.video.addEventListener('canplay', function() {
|
|
this.width = self.video.videoWidth;
|
|
this.height = self.video.videoHeight;
|
|
this.pinholeX = self.width / 2;
|
|
this.pinholeY = self.height / 2;
|
|
this.video.poster = "http://www.wescheme.org/images/broken.png";
|
|
this.video.autoplay = true;
|
|
this.video.autobuffer=true;
|
|
this.video.loop = true;
|
|
this.video.play();
|
|
});
|
|
this.video.addEventListener('error', function(e) {
|
|
self.video.onerror = "";
|
|
self.video.poster = "http://www.wescheme.org/images/broken.png";
|
|
});
|
|
}
|
|
}
|
|
VideoImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
videos = {};
|
|
VideoImage.makeInstance = function(path, rawVideo) {
|
|
if (! (path in VideoImage)) {
|
|
videos[path] = new VideoImage(path, rawVideo);
|
|
}
|
|
return videos[path];
|
|
};
|
|
|
|
VideoImage.prototype.render = function(ctx, x, y) {
|
|
ctx.drawImage(this.video, x, y);
|
|
};
|
|
|
|
VideoImage.prototype.equals = function(other, aUnionFind) {
|
|
return (other instanceof VideoImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.src == other.src);
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// OverlayImage: image image placeX placeY -> image
|
|
// Creates an image that overlays img1 on top of the
|
|
// other image.
|
|
var OverlayImage = function(img1, img2, placeX, placeY) {
|
|
// calculate centers using width/height, so we are scene/image agnostic
|
|
var c1x = img1.getWidth()/2;
|
|
var c1y = img1.getHeight()/2;
|
|
var c2x = img2.getWidth()/2;
|
|
var c2y = img2.getHeight()/2;
|
|
var X, Y;
|
|
|
|
|
|
// keep absolute X and Y values
|
|
// convert relative X,Y to absolute amounts
|
|
// we also handle "beside" and "above"
|
|
if (placeX == "right")
|
|
X = (c1x>c2x)? img2.getWidth()-(c1x+c2x) : img1.getWidth()-(c1x+c2x);
|
|
else if (placeX == "left")
|
|
X = (c1x>c2x)? img1.getWidth()-(c1x+c2x) : img2.getWidth()-(c1x+c2x);
|
|
else if (placeX == "beside")
|
|
X = c1x+c2x;
|
|
else if (placeX == "middle" ||
|
|
placeX == "center")
|
|
X = 0;
|
|
else
|
|
X = placeX;
|
|
|
|
if (placeY == "bottom")
|
|
Y = (c1y>c2y)? img2.getHeight()-(c1y+c2y) : img1.getHeight()-(c1y+c2y);
|
|
else if (placeY == "top")
|
|
Y = (c1y>c2y)? img1.getHeight()-(c1y+c2y) : img2.getHeight()-(c1y+c2y);
|
|
else if (placeY == "above")
|
|
Y = c1y+c2y;
|
|
else if (placeY == "baseline")
|
|
Y = img1.getBaseline()-img2.getBaseline();
|
|
else if (placeY == "middle" || placeY == "center")
|
|
Y = 0;
|
|
else
|
|
Y = placeY;
|
|
|
|
|
|
// correct offsets when dealing with Scenes instead of images
|
|
if(isScene(img1)){
|
|
X = X + c1x; Y = Y + c1x;
|
|
}
|
|
if(isScene(img2)){
|
|
X = X - c2x; Y = Y - c2x;
|
|
}
|
|
|
|
var deltaX = img1.pinholeX - img2.pinholeX + X;
|
|
var deltaY = img1.pinholeY - img2.pinholeY + Y;
|
|
|
|
var left = Math.min(0, deltaX);
|
|
var top = Math.min(0, deltaY);
|
|
var right = Math.max(deltaX + img2.getWidth(), img1.getWidth());
|
|
var bottom = Math.max(deltaY + img2.getHeight(), img1.getHeight());
|
|
BaseImage.call(this,
|
|
Math.floor((right-left) / 2),
|
|
Math.floor((bottom-top) / 2));
|
|
this.img1 = img1;
|
|
this.img2 = img2;
|
|
this.width = right - left;
|
|
this.height = bottom - top;
|
|
|
|
this.img1Dx = -left;
|
|
this.img1Dy = -top;
|
|
this.img2Dx = deltaX - left;
|
|
this.img2Dy = deltaY - top;
|
|
};
|
|
|
|
OverlayImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
OverlayImage.prototype.render = function(ctx, x, y) {
|
|
ctx.save();
|
|
this.img2.render(ctx, x + this.img2Dx, y + this.img2Dy);
|
|
this.img1.render(ctx, x + this.img1Dx, y + this.img1Dy);
|
|
ctx.restore();
|
|
};
|
|
|
|
OverlayImage.prototype.equals = function(other, aUnionFind) {
|
|
return ( other instanceof OverlayImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.width == other.width &&
|
|
this.height == other.height &&
|
|
this.img1Dx == other.img1Dx &&
|
|
this.img1Dy == other.img1Dy &&
|
|
this.img2Dx == other.img2Dx &&
|
|
this.img2Dy == other.img2Dy &&
|
|
plt.baselib.equality.equals(this.img1, other.img1, aUnionFind) &&
|
|
plt.baselib.equality.equals(this.img2, other.img2, aUnionFind) );
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// rotate: angle image -> image
|
|
// Rotates image by angle degrees in a counter-clockwise direction.
|
|
// based on http://stackoverflow.com/questions/3276467/adjusting-div-width-and-height-after-rotated
|
|
var RotateImage = function(angle, img) {
|
|
var sin = Math.sin(angle * Math.PI / 180),
|
|
cos = Math.cos(angle * Math.PI / 180);
|
|
|
|
// (w,0) rotation
|
|
var x1 = Math.floor(cos * img.getWidth()),
|
|
y1 = Math.floor(sin * img.getWidth());
|
|
|
|
// (0,h) rotation
|
|
var x2 = Math.floor(-sin * img.getHeight()),
|
|
y2 = Math.floor( cos * img.getHeight());
|
|
|
|
// (w,h) rotation
|
|
var x3 = Math.floor(cos * img.getWidth() - sin * img.getHeight()),
|
|
y3 = Math.floor(sin * img.getWidth() + cos * img.getHeight());
|
|
|
|
var minX = Math.min(0, x1, x2, x3),
|
|
maxX = Math.max(0, x1, x2, x3),
|
|
minY = Math.min(0, y1, y2, y3),
|
|
maxY = Math.max(0, y1, y2, y3);
|
|
|
|
var rotatedWidth = maxX - minX,
|
|
rotatedHeight = maxY - minY;
|
|
|
|
// resize the image
|
|
BaseImage.call(this,
|
|
Math.floor(rotatedWidth / 2),
|
|
Math.floor(rotatedHeight / 2));
|
|
|
|
this.img = img;
|
|
this.width = rotatedWidth;
|
|
this.height = rotatedHeight;
|
|
this.angle = angle;
|
|
this.translateX = -minX;
|
|
this.translateY = -minY;
|
|
};
|
|
|
|
RotateImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
// translate the canvas using the calculated values, then draw at the rotated (x,y) offset.
|
|
RotateImage.prototype.render = function(ctx, x, y) {
|
|
// calculate the new x and y offsets, by rotating the radius formed by the hypoteneuse
|
|
var sin = Math.sin(this.angle * Math.PI / 180),
|
|
cos = Math.cos(this.angle * Math.PI / 180),
|
|
r = Math.sqrt(x*x + y*y);
|
|
x = Math.ceil(cos * r);
|
|
y = -Math.floor(sin * r);
|
|
ctx.save();
|
|
ctx.translate(this.translateX, this.translateY);
|
|
ctx.rotate(this.angle * Math.PI / 180);
|
|
this.img.render(ctx, x, y);
|
|
ctx.restore();
|
|
};
|
|
|
|
RotateImage.prototype.equals = function(other, aUnionFind) {
|
|
return ( other instanceof RotateImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.width == other.width &&
|
|
this.height == other.height &&
|
|
this.angle == other.angle &&
|
|
this.translateX == other.translateX &&
|
|
this.translateY == other.translateY &&
|
|
plt.baselib.equality.equals(this.img, other.img, aUnionFind) );
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// ScaleImage: factor factor image -> image
|
|
// Scale an image
|
|
var ScaleImage = function(xFactor, yFactor, img) {
|
|
|
|
// resize the image
|
|
BaseImage.call(this,
|
|
Math.floor((img.getWidth() * xFactor) / 2),
|
|
Math.floor((img.getHeight() * yFactor) / 2));
|
|
|
|
this.img = img;
|
|
this.width = img.getWidth() * xFactor;
|
|
this.height = img.getHeight() * yFactor;
|
|
this.xFactor = xFactor;
|
|
this.yFactor = yFactor;
|
|
};
|
|
|
|
ScaleImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
// scale the context, and pass it to the image's render function
|
|
ScaleImage.prototype.render = function(ctx, x, y) {
|
|
ctx.save();
|
|
ctx.scale(this.xFactor, this.yFactor);
|
|
this.img.render(ctx, x / this.xFactor, y / this.yFactor);
|
|
ctx.restore();
|
|
};
|
|
|
|
|
|
ScaleImage.prototype.equals = function(other, aUnionFind) {
|
|
return ( other instanceof ScaleImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.width == other.width &&
|
|
this.height == other.height &&
|
|
this.xFactor == other.xFactor &&
|
|
this.yFactor == other.yFactor &&
|
|
plt.baselib.equality.equals(this.img, other.img, aUnionFind) );
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// CropImage: startX startY width height image -> image
|
|
// Crop an image
|
|
var CropImage = function(x, y, width, height, img) {
|
|
|
|
BaseImage.call(this,
|
|
Math.floor(width / 2),
|
|
Math.floor(height / 2));
|
|
|
|
this.x = x;
|
|
this.y = y;
|
|
this.width = width;
|
|
this.height = height;
|
|
this.img = img;
|
|
};
|
|
|
|
CropImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
CropImage.prototype.render = function(ctx, x, y) {
|
|
ctx.save();
|
|
ctx.translate(-this.x, -this.y);
|
|
this.img.render(ctx, x, y);
|
|
ctx.restore();
|
|
};
|
|
|
|
CropImage.prototype.equals = function(other, aUnionFind) {
|
|
return ( other instanceof CropImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.width == other.width &&
|
|
this.height == other.height &&
|
|
this.x == other.x &&
|
|
this.y == other.y &&
|
|
plt.baselib.equality.equals(this.img, other.img, aUnionFind) );
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// FrameImage: factor factor image -> image
|
|
// Stick a frame around the image
|
|
var FrameImage = function(img) {
|
|
|
|
BaseImage.call(this,
|
|
Math.floor(img.getWidth()/ 2),
|
|
Math.floor(img.getHeight()/ 2));
|
|
|
|
this.img = img;
|
|
this.width = img.getWidth();
|
|
this.height = img.getHeight();
|
|
};
|
|
|
|
FrameImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
// scale the context, and pass it to the image's render function
|
|
FrameImage.prototype.render = function(ctx, x, y) {
|
|
ctx.save();
|
|
this.img.render(ctx, x, y);
|
|
ctx.beginPath();
|
|
ctx.strokeStyle = "black";
|
|
ctx.strokeRect(x, y, this.width, this.height);
|
|
ctx.closePath();
|
|
ctx.restore();
|
|
};
|
|
|
|
FrameImage.prototype.equals = function(other, aUnionFind) {
|
|
return ( other instanceof FrameImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
plt.baselib.equality.equals(this.img, other.img, aUnionFind) );
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// FlipImage: image string -> image
|
|
// Flip an image either horizontally or vertically
|
|
var FlipImage = function(img, direction) {
|
|
this.img = img;
|
|
this.width = img.getWidth();
|
|
this.height = img.getHeight();
|
|
this.direction = direction;
|
|
BaseImage.call(this,
|
|
img.pinholeX,
|
|
img.pinholeY);
|
|
};
|
|
|
|
FlipImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
FlipImage.prototype.render = function(ctx, x, y) {
|
|
// when flipping an image of dimension M and offset by N across an axis,
|
|
// we need to translate the canvas by M+2N in the opposite direction
|
|
ctx.save();
|
|
if(this.direction == "horizontal"){
|
|
ctx.scale(-1, 1);
|
|
ctx.translate(-(this.width+2*x), 0);
|
|
this.img.render(ctx, x, y);
|
|
}
|
|
if (this.direction == "vertical"){
|
|
ctx.scale(1, -1);
|
|
ctx.translate(0, -(this.height+2*y));
|
|
this.img.render(ctx, x, y);
|
|
}
|
|
ctx.restore();
|
|
};
|
|
|
|
|
|
FlipImage.prototype.getWidth = function() {
|
|
return this.width;
|
|
};
|
|
|
|
FlipImage.prototype.getHeight = function() {
|
|
return this.height;
|
|
};
|
|
|
|
FlipImage.prototype.equals = function(other, aUnionFind) {
|
|
return ( other instanceof FlipImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.width == other.width &&
|
|
this.height == other.height &&
|
|
this.direction == other.direction &&
|
|
plt.baselib.equality.equals(this.img, other.img, aUnionFind) );
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// RectangleImage: Number Number Mode Color -> Image
|
|
var RectangleImage = function(width, height, style, color) {
|
|
BaseImage.call(this, width/2, height/2);
|
|
this.width = width;
|
|
this.height = height;
|
|
this.style = style;
|
|
this.color = color;
|
|
};
|
|
RectangleImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
RectangleImage.prototype.render = function(ctx, x, y) {
|
|
if (this.style.toString().toLowerCase() == "outline") {
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
ctx.strokeStyle = colorString(this.color);
|
|
ctx.strokeRect(x, y, this.width, this.height);
|
|
ctx.closePath();
|
|
ctx.restore();
|
|
} else {
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
|
|
ctx.fillStyle = colorString(this.color);
|
|
ctx.fillRect(x, y, this.width, this.height);
|
|
|
|
ctx.closePath();
|
|
ctx.restore();
|
|
}
|
|
};
|
|
|
|
RectangleImage.prototype.getWidth = function() {
|
|
return this.width;
|
|
};
|
|
|
|
|
|
RectangleImage.prototype.getHeight = function() {
|
|
return this.height;
|
|
};
|
|
|
|
RectangleImage.prototype.equals = function(other, aUnionFind) {
|
|
return (other instanceof RectangleImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.width == other.width &&
|
|
this.height == other.height &&
|
|
this.style == other.style &&
|
|
plt.baselib.equality.equals(this.color, other.color, aUnionFind));
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// RhombusImage: Number Number Mode Color -> Image
|
|
var RhombusImage = function(side, angle, style, color) {
|
|
// sin(angle/2-in-radians) * side = half of base
|
|
this.width = Math.sin(angle/2 * Math.PI / 180) * side * 2;
|
|
// cos(angle/2-in-radians) * side = half of height
|
|
this.height = Math.abs(Math.cos(angle/2 * Math.PI / 180)) * side * 2;
|
|
BaseImage.call(this, this.width/2, this.height/2);
|
|
this.side = side;
|
|
this.angle = angle;
|
|
this.style = style;
|
|
this.color = color;
|
|
};
|
|
RhombusImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
RhombusImage.prototype.render = function(ctx, x, y) {
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
// if angle < 180 start at the top of the canvas, otherwise start at the bottom
|
|
ctx.moveTo(x+this.getWidth()/2, y);
|
|
ctx.lineTo(x+this.getWidth(), y+this.getHeight()/2);
|
|
ctx.lineTo(x+this.getWidth()/2, y+this.getHeight());
|
|
ctx.lineTo(x, y+this.getHeight()/2);
|
|
ctx.closePath();
|
|
|
|
if (this.style.toString().toLowerCase() == "outline") {
|
|
ctx.strokeStyle = colorString(this.color);
|
|
ctx.stroke();
|
|
}
|
|
else {
|
|
ctx.fillStyle = colorString(this.color);
|
|
ctx.fill();
|
|
}
|
|
ctx.restore();
|
|
};
|
|
|
|
RhombusImage.prototype.getWidth = function() {
|
|
return this.width;
|
|
};
|
|
|
|
|
|
RhombusImage.prototype.getHeight = function() {
|
|
return this.height;
|
|
};
|
|
|
|
RhombusImage.prototype.equals = function(other, aUnionFind) {
|
|
return (other instanceof RhombusImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.side == other.side &&
|
|
this.angle == other.angle &&
|
|
this.style == other.style &&
|
|
plt.baselib.equality.equals(this.color, other.color, aUnionFind));
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
var ImageDataImage = function(imageData) {
|
|
BaseImage.call(this, 0, 0);
|
|
this.imageData = imageData;
|
|
this.width = imageData.width;
|
|
this.height = imageData.height;
|
|
};
|
|
|
|
ImageDataImage.prototype = heir(BaseImage.prototype);
|
|
|
|
ImageDataImage.prototype.render = function(ctx, x, y) {
|
|
ctx.putImageData(this.imageData, x, y);
|
|
};
|
|
|
|
ImageDataImage.prototype.getWidth = function() {
|
|
return this.width;
|
|
};
|
|
|
|
|
|
ImageDataImage.prototype.getHeight = function() {
|
|
return this.height;
|
|
};
|
|
|
|
ImageDataImage.prototype.equals = function(other, aUnionFind) {
|
|
return (other instanceof ImageDataImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY);
|
|
};
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// PolygonImage: Number Count Step Mode Color -> Image
|
|
//
|
|
// See http://www.algebra.com/algebra/homework/Polygons/Inscribed-and-circumscribed-polygons.lesson
|
|
// the polygon is inscribed in a circle, whose radius is length/2sin(pi/count)
|
|
// another circle is inscribed in the polygon, whose radius is length/2tan(pi/count)
|
|
// rotate a 3/4 quarter turn plus half the angle length to keep bottom base level
|
|
var PolygonImage = function(length, count, step, style, color) {
|
|
this.aVertices = [];
|
|
var xMax = 0;
|
|
var yMax = 0;
|
|
var xMin = 0;
|
|
var yMin = 0;
|
|
|
|
this.outerRadius = Math.floor(length/(2*Math.sin(Math.PI/count)));
|
|
this.innerRadius = Math.floor(length/(2*Math.tan(Math.PI/count)));
|
|
var adjust = (3*Math.PI/2)+Math.PI/count;
|
|
|
|
// rotate around outer circle, storing x,y pairs as vertices
|
|
// keep track of mins and maxs
|
|
var radians = 0;
|
|
for(var i = 0; i < count; i++) {
|
|
// rotate to the next vertex (skipping by this.step)
|
|
radians = radians + (step*2*Math.PI/count);
|
|
|
|
var v = { x: this.outerRadius*Math.cos(radians-adjust),
|
|
y: this.outerRadius*Math.sin(radians-adjust) };
|
|
if(v.x < xMin) xMin = v.x;
|
|
if(v.x > xMax) xMax = v.y;
|
|
if(v.y < yMin) yMin = v.x;
|
|
if(v.y > yMax) yMax = v.y;
|
|
this.aVertices.push(v);
|
|
}
|
|
// HACK: try to work around handling of non-integer coordinates in CANVAS
|
|
// by ensuring that the boundaries of the canvas are outside of the vertices
|
|
for(var i=0; i<this.aVertices.length; i++){
|
|
if(this.aVertices[i].x < xMin) xMin = this.aVertices[i].x-1;
|
|
if(this.aVertices[i].x > xMax) xMax = this.aVertices[i].x+1;
|
|
if(this.aVertices[i].y < yMin) yMin = this.aVertices[i].y-1;
|
|
if(this.aVertices[i].y > yMax) yMax = this.aVertices[i].y+1;
|
|
}
|
|
|
|
this.width = Math.floor(xMax-xMin);
|
|
this.height = Math.floor(yMax-yMin);
|
|
this.length = length;
|
|
this.count = count;
|
|
this.step = step;
|
|
this.style = style;
|
|
this.color = color;
|
|
BaseImage.call(this, Math.floor(this.width/2), Math.floor(this.height/2));
|
|
};
|
|
PolygonImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
// shift all vertices by an offset to put the center of the polygon at the
|
|
// center of the canvas. Even-sided polygons highest points are in line with
|
|
// the innerRadius. Odd-sides polygons highest vertex is on the outerRadius
|
|
PolygonImage.prototype.render = function(ctx, x, y) {
|
|
var xOffset = x+Math.round(this.width/2);
|
|
var yOffset = y+((this.count % 2)? this.outerRadius : this.innerRadius);
|
|
|
|
ctx.save();
|
|
|
|
ctx.beginPath();
|
|
ctx.moveTo(xOffset+this.aVertices[0].x, yOffset+this.aVertices[0].y);
|
|
for(var i=1; i<this.aVertices.length; i++){
|
|
ctx.lineTo(xOffset+this.aVertices[i].x, yOffset+this.aVertices[i].y);
|
|
}
|
|
ctx.lineTo(xOffset+this.aVertices[0].x, yOffset+this.aVertices[0].y);
|
|
ctx.closePath();
|
|
|
|
if (this.style.toString().toLowerCase() == "outline") {
|
|
ctx.strokeStyle = colorString(this.color);
|
|
ctx.stroke();
|
|
}
|
|
else {
|
|
ctx.fillStyle = colorString(this.color);
|
|
ctx.fill();
|
|
}
|
|
ctx.restore();
|
|
};
|
|
|
|
PolygonImage.prototype.equals = function(other, aUnionFind) {
|
|
return (other instanceof PolygonImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.length == other.length &&
|
|
this.step == other.step &&
|
|
this.count == other.count &&
|
|
this.style == other.style &&
|
|
plt.baselib.equality.equals(this.color, other.color, aUnionFind));
|
|
};
|
|
|
|
|
|
var maybeQuote = function(s) {
|
|
if (/ /.test(s)) {
|
|
return "\"" + s + "\"";
|
|
}
|
|
return s;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// TextImage: String Number Color String String String String any/c -> Image
|
|
//////////////////////////////////////////////////////////////////////
|
|
// TextImage: String Number Color String String String String any/c -> Image
|
|
var TextImage = function(msg, size, color, face, family, style, weight, underline) {
|
|
var metrics;
|
|
this.msg = msg;
|
|
this.size = size;
|
|
this.color = color;
|
|
this.face = face;
|
|
this.family = family;
|
|
this.style = (style == "slant")? "oblique" : style; // Racket's "slant" -> CSS's "oblique"
|
|
this.weight = (weight== "light")? "lighter" : weight; // Racket's "light" -> CSS's "lighter"
|
|
this.underline = underline;
|
|
// example: "bold italic 20px 'Times', sans-serif".
|
|
// Default weight is "normal", face is "Optimer"
|
|
var canvas = makeCanvas(0, 0);
|
|
var ctx = canvas.getContext("2d");
|
|
|
|
this.font = (this.weight + " " +
|
|
this.style + " " +
|
|
this.size + "px " +
|
|
maybeQuote(this.face) + " " +
|
|
maybeQuote(this.family));
|
|
try {
|
|
ctx.font = this.font;
|
|
} catch (e) {
|
|
this.fallbackOnFont();
|
|
ctx.font = this.font;
|
|
}
|
|
|
|
// Defensive: on IE, this can break.
|
|
try {
|
|
metrics = ctx.measureText(msg);
|
|
this.width = metrics.width;
|
|
this.height = Number(this.size);
|
|
} catch(e) {
|
|
this.fallbackOnFont();
|
|
}
|
|
BaseImage.call(this, Math.round(this.width/2), 0);// weird pinhole settings needed for "baseline" alignment
|
|
}
|
|
|
|
|
|
TextImage.prototype = heir(BaseImage.prototype);
|
|
|
|
TextImage.prototype.fallbackOnFont = function() {
|
|
// Defensive: if the browser doesn't support certain features, we
|
|
// reduce to a smaller feature set and try again.
|
|
this.font = this.size + "px " + maybeQuote(this.family);
|
|
var canvas = makeCanvas(0, 0);
|
|
var ctx = canvas.getContext("2d");
|
|
ctx.font = this.font;
|
|
var metrics = ctx.measureText(this.msg);
|
|
this.width = metrics.width;
|
|
// KLUDGE: I don't know how to get at the height.
|
|
this.height = Number(this.size);//ctx.measureText("m").width + 20;
|
|
};
|
|
|
|
|
|
TextImage.prototype.render = function(ctx, x, y) {
|
|
ctx.save();
|
|
|
|
ctx.textAlign = 'left';
|
|
ctx.textBaseline= 'top';
|
|
ctx.fillStyle = colorString(this.color);
|
|
ctx.font = this.font;
|
|
try {
|
|
ctx.fillText(this.msg, x, y);
|
|
} catch (e) {
|
|
this.fallbackOnFont();
|
|
ctx.font = this.font;
|
|
ctx.fillText(this.msg, x, y);
|
|
}
|
|
if(this.underline){
|
|
ctx.beginPath();
|
|
ctx.moveTo(x, y+this.size);
|
|
// we use this.size, as it is more accurate for underlining than this.height
|
|
ctx.lineTo(x+this.width, y+this.size);
|
|
ctx.closePath();
|
|
ctx.strokeStyle = colorString(this.color);
|
|
ctx.stroke();
|
|
}
|
|
ctx.restore();
|
|
};
|
|
|
|
|
|
TextImage.prototype.getBaseline = function() {
|
|
return this.size;
|
|
};
|
|
|
|
TextImage.prototype.equals = function(other, aUnionFind) {
|
|
return (other instanceof TextImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.msg == other.msg &&
|
|
this.size == other.size &&
|
|
this.face == other.face &&
|
|
this.family == other.family &&
|
|
this.style == other.style &&
|
|
this.weight == other.weight &&
|
|
this.underline == other.underline &&
|
|
plt.baselib.equality.equals(this.color, other.color, aUnionFind) &&
|
|
this.font == other.font);
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// StarImage: fixnum fixnum fixnum color -> image
|
|
var StarImage = function(points, outer, inner, style, color) {
|
|
BaseImage.call(this,
|
|
Math.max(outer, inner),
|
|
Math.max(outer, inner));
|
|
this.points = points;
|
|
this.outer = outer;
|
|
this.inner = inner;
|
|
this.style = style;
|
|
this.color = color;
|
|
this.radius = Math.max(this.inner, this.outer);
|
|
this.width = this.radius*2;
|
|
this.height = this.radius*2;
|
|
};
|
|
|
|
StarImage.prototype = heir(BaseImage.prototype);
|
|
|
|
var oneDegreeAsRadian = Math.PI / 180;
|
|
|
|
// render: context fixnum fixnum -> void
|
|
// Draws a star on the given context.
|
|
// Most of this code here adapted from the Canvas tutorial at:
|
|
// http://developer.apple.com/safari/articles/makinggraphicswithcanvas.html
|
|
StarImage.prototype.render = function(ctx, x, y) {
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
for( var pt = 0; pt < (this.points * 2) + 1; pt++ ) {
|
|
var rads = ( ( 360 / (2 * this.points) ) * pt ) * oneDegreeAsRadian - 0.5;
|
|
var radius = ( pt % 2 == 1 ) ? this.outer : this.inner;
|
|
ctx.lineTo(x + this.radius + ( Math.sin( rads ) * radius ),
|
|
y + this.radius + ( Math.cos( rads ) * radius ) );
|
|
}
|
|
ctx.closePath();
|
|
if (this.style.toString().toLowerCase() == "outline") {
|
|
ctx.strokeStyle = colorString(this.color);
|
|
ctx.stroke();
|
|
} else {
|
|
ctx.fillStyle = colorString(this.color);
|
|
ctx.fill();
|
|
}
|
|
ctx.restore();
|
|
};
|
|
|
|
StarImage.prototype.equals = function(other, aUnionFind) {
|
|
return (other instanceof StarImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.points == other.points &&
|
|
this.outer == other.outer &&
|
|
this.inner == other.inner &&
|
|
this.style == other.style &&
|
|
plt.baselib.equality.equals(this.color, other.color, aUnionFind));
|
|
};
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//TriangleImage: Number Number Mode Color -> Image
|
|
var TriangleImage = function(side, angle, style, color) {
|
|
// sin(angle/2-in-radians) * side = half of base
|
|
this.width = Math.sin(angle/2 * Math.PI / 180) * side * 2;
|
|
// cos(angle/2-in-radians) * side = height of altitude
|
|
this.height = Math.floor(Math.abs(Math.cos(angle/2 * Math.PI / 180)) * side);
|
|
|
|
BaseImage.call(this, Math.floor(this.width/2), Math.floor(this.height/2));
|
|
this.side = side;
|
|
this.angle = angle;
|
|
this.style = style;
|
|
this.color = color;
|
|
}
|
|
TriangleImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
TriangleImage.prototype.render = function(ctx, x, y) {
|
|
var width = this.getWidth();
|
|
var height = this.getHeight();
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
// if angle < 180 start at the top of the canvas, otherwise start at the bottom
|
|
if(this.angle < 180){
|
|
ctx.moveTo(x+width/2, y);
|
|
ctx.lineTo(x, y+height);
|
|
ctx.lineTo(x+width, y+height);
|
|
} else {
|
|
ctx.moveTo(x+width/2, y+height);
|
|
ctx.lineTo(x, y);
|
|
ctx.lineTo(x+width, y);
|
|
}
|
|
ctx.closePath();
|
|
|
|
if (this.style.toString().toLowerCase() == "outline") {
|
|
ctx.strokeStyle = colorString(this.color);
|
|
ctx.stroke();
|
|
}
|
|
else {
|
|
ctx.fillStyle = colorString(this.color);
|
|
ctx.fill();
|
|
}
|
|
ctx.restore();
|
|
};
|
|
|
|
TriangleImage.prototype.equals = function(other, aUnionFind) {
|
|
return (other instanceof TriangleImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.side == other.side &&
|
|
this.angle == other.angle &&
|
|
this.style == other.style &&
|
|
plt.baselib.equality.equals(this.color, other.color, aUnionFind));
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//RightTriangleImage: Number Number Mode Color -> Image
|
|
var RightTriangleImage = function(side1, side2, style, color) {
|
|
this.width = side1;
|
|
this.height = side2;
|
|
|
|
BaseImage.call(this, Math.floor(this.width/2), Math.floor(this.height/2));
|
|
this.side1 = side1;
|
|
this.side2 = side2;
|
|
this.style = style;
|
|
this.color = color;
|
|
}
|
|
RightTriangleImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
RightTriangleImage.prototype.render = function(ctx, x, y) {
|
|
var width = this.getWidth();
|
|
var height = this.getHeight();
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
ctx.moveTo(x, y+this.side2);
|
|
ctx.lineTo(x+this.side1, y+this.side2);
|
|
ctx.lineTo(x, y);
|
|
ctx.closePath();
|
|
|
|
if (this.style.toString().toLowerCase() == "outline") {
|
|
ctx.strokeStyle = colorString(this.color);
|
|
ctx.stroke();
|
|
}
|
|
else {
|
|
ctx.fillStyle = colorString(this.color);
|
|
ctx.fill();
|
|
}
|
|
ctx.restore();
|
|
};
|
|
|
|
RightTriangleImage.prototype.equals = function(other, aUnionFind) {
|
|
return (other instanceof RightTriangleImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.side1 == other.side1 &&
|
|
this.side2 == other.side2 &&
|
|
this.style == other.style &&
|
|
plt.baselib.equality.equals(this.color, other.color, aUnionFind));
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//Ellipse : Number Number Mode Color -> Image
|
|
var EllipseImage = function(width, height, style, color) {
|
|
BaseImage.call(this, Math.floor(width/2), Math.floor(height/2));
|
|
this.width = width;
|
|
this.height = height;
|
|
this.style = style;
|
|
this.color = color;
|
|
};
|
|
|
|
EllipseImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
EllipseImage.prototype.render = function(ctx, aX, aY) {
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
|
|
// Most of this code is taken from:
|
|
// http://webreflection.blogspot.com/2009/01/ellipse-and-circle-for-canvas-2d.html
|
|
var hB = (this.width / 2) * .5522848,
|
|
vB = (this.height / 2) * .5522848,
|
|
eX = aX + this.width,
|
|
eY = aY + this.height,
|
|
mX = aX + this.width / 2,
|
|
mY = aY + this.height / 2;
|
|
ctx.moveTo(aX, mY);
|
|
ctx.bezierCurveTo(aX, mY - vB, mX - hB, aY, mX, aY);
|
|
ctx.bezierCurveTo(mX + hB, aY, eX, mY - vB, eX, mY);
|
|
ctx.bezierCurveTo(eX, mY + vB, mX + hB, eY, mX, eY);
|
|
ctx.bezierCurveTo(mX - hB, eY, aX, mY + vB, aX, mY);
|
|
ctx.closePath();
|
|
if (this.style.toString().toLowerCase() == "outline") {
|
|
ctx.strokeStyle = colorString(this.color);
|
|
ctx.stroke();
|
|
}
|
|
else {
|
|
ctx.fillStyle = colorString(this.color);
|
|
ctx.fill();
|
|
}
|
|
|
|
|
|
ctx.restore();
|
|
};
|
|
|
|
EllipseImage.prototype.equals = function(other, aUnionFind) {
|
|
return (other instanceof EllipseImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.width == other.width &&
|
|
this.height == other.height &&
|
|
this.style == other.style &&
|
|
plt.baselib.equality.equals(this.color, other.color, aUnionFind));
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
//Line: Number Number Color Boolean -> Image
|
|
var LineImage = function(x, y, color, normalPinhole) {
|
|
if (x >= 0) {
|
|
if (y >= 0) {
|
|
BaseImage.call(this, 0, 0);
|
|
} else {
|
|
BaseImage.call(this, 0, -y);
|
|
}
|
|
} else {
|
|
if (y >= 0) {
|
|
BaseImage.call(this, -x, 0);
|
|
} else {
|
|
BaseImage.call(this, -x, -y);
|
|
}
|
|
}
|
|
|
|
this.x = x;
|
|
this.y = y;
|
|
this.color = color;
|
|
this.width = Math.abs(x) + 1;
|
|
this.height = Math.abs(y) + 1;
|
|
|
|
// put the pinhle in the center of the image
|
|
if(normalPinhole){
|
|
this.pinholeX = this.width/2;
|
|
this.pinholeY = this.height/2;
|
|
}
|
|
}
|
|
|
|
LineImage.prototype = heir(BaseImage.prototype);
|
|
|
|
|
|
LineImage.prototype.render = function(ctx, xstart, ystart) {
|
|
ctx.save();
|
|
ctx.beginPath();
|
|
ctx.strokeStyle = colorString(this.color);
|
|
if (this.x >= 0) {
|
|
if (this.y >= 0) {
|
|
ctx.moveTo(xstart, ystart);
|
|
ctx.lineTo((xstart + this.x),
|
|
(ystart + this.y));
|
|
} else {
|
|
ctx.moveTo(xstart, ystart + (-this.y));
|
|
ctx.lineTo(xstart + this.x, ystart);
|
|
}
|
|
} else {
|
|
if (this.y >= 0) {
|
|
ctx.moveTo(xstart + (-this.x), ystart);
|
|
ctx.lineTo(xstart,
|
|
(ystart + this.y));
|
|
} else {
|
|
ctx.moveTo(xstart + (-this.x), ystart + (-this.y));
|
|
ctx.lineTo(xstart, ystart);
|
|
}
|
|
}
|
|
ctx.closePath();
|
|
ctx.stroke();
|
|
ctx.restore();
|
|
};
|
|
|
|
|
|
LineImage.prototype.equals = function(other, aUnionFind) {
|
|
return (other instanceof LineImage &&
|
|
this.pinholeX == other.pinholeX &&
|
|
this.pinholeY == other.pinholeY &&
|
|
this.x == other.x &&
|
|
this.y == other.y &&
|
|
plt.baselib.equality.equals(this.color, other.color, aUnionFind));
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var imageToColorList = function(img) {
|
|
var width = img.getWidth(),
|
|
height = img.getHeight(),
|
|
canvas = makeCanvas(width, height),
|
|
ctx = canvas.getContext("2d"),
|
|
imageData,
|
|
data,
|
|
i,
|
|
r, g, b, a;
|
|
img.render(ctx, 0, 0);
|
|
imageData = ctx.getImageData(0, 0, width, height);
|
|
data = imageData.data;
|
|
var colors = [];
|
|
for (i = 0 ; i < data.length; i += 4) {
|
|
r = data[i];
|
|
g = data[i+1];
|
|
b = data[i+2];
|
|
a = data[i+3];
|
|
colors.push(makeColor(r, g, b, a));
|
|
}
|
|
return plt.baselib.lists.makeList.apply(null, colors);
|
|
}
|
|
|
|
|
|
var colorListToImage = function(listOfColors,
|
|
width,
|
|
height,
|
|
pinholeX,
|
|
pinholeY) {
|
|
var canvas = makeCanvas(jsnums.toFixnum(width),
|
|
jsnums.toFixnum(height)),
|
|
ctx = canvas.getContext("2d"),
|
|
imageData = ctx.createImageData(jsnums.toFixnum(width),
|
|
jsnums.toFixnum(height)),
|
|
data = imageData.data,
|
|
aColor, i = 0;
|
|
while (listOfColors !== plt.baselib.lists.EMPTY) {
|
|
aColor = listOfColors.first;
|
|
data[i] = jsnums.toFixnum(colorRed(aColor));
|
|
data[i+1] = jsnums.toFixnum(colorGreen(aColor));
|
|
data[i+2] = jsnums.toFixnum(colorBlue(aColor));
|
|
data[i+3] = jsnums.toFixnum(colorAlpha(aColor));
|
|
|
|
i += 4;
|
|
listOfColors = listOfColors.rest;
|
|
};
|
|
|
|
return makeImageDataImage(imageData);
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var makeSceneImage = function(width, height, children, withBorder) {
|
|
return new SceneImage(width, height, children, withBorder);
|
|
};
|
|
var makeCircleImage = function(radius, style, color) {
|
|
return new EllipseImage(2*radius, 2*radius, style, color);
|
|
};
|
|
var makeStarImage = function(points, outer, inner, style, color) {
|
|
return new StarImage(points, outer, inner, style, color);
|
|
};
|
|
var makeRectangleImage = function(width, height, style, color) {
|
|
return new RectangleImage(width, height, style, color);
|
|
};
|
|
var makeRhombusImage = function(side, angle, style, color) {
|
|
return new RhombusImage(side, angle, style, color);
|
|
};
|
|
var makePolygonImage = function(length, count, step, style, color) {
|
|
return new PolygonImage(length, count, step, style, color);
|
|
};
|
|
var makeSquareImage = function(length, style, color) {
|
|
return new RectangleImage(length, length, style, color);
|
|
};
|
|
var makeRightTriangleImage = function(side1, side2, style, color) {
|
|
return new RightTriangleImage(side1, side2, style, color);
|
|
};
|
|
var makeTriangleImage = function(side, angle, style, color) {
|
|
return new TriangleImage(side, angle, style, color);
|
|
};
|
|
var makeEllipseImage = function(width, height, style, color) {
|
|
return new EllipseImage(width, height, style, color);
|
|
};
|
|
var makeLineImage = function(x, y, color, normalPinhole) {
|
|
return new LineImage(x, y, color, normalPinhole);
|
|
};
|
|
var makeOverlayImage = function(img1, img2, X, Y) {
|
|
return new OverlayImage(img1, img2, X, Y);
|
|
};
|
|
var makeRotateImage = function(angle, img) {
|
|
return new RotateImage(angle, img);
|
|
};
|
|
var makeScaleImage = function(xFactor, yFactor, img) {
|
|
return new ScaleImage(xFactor, yFactor, img);
|
|
};
|
|
var makeCropImage = function(x, y, width, height, img) {
|
|
return new CropImage(x, y, width, height, img);
|
|
};
|
|
var makeFrameImage = function(img) {
|
|
return new FrameImage(img);
|
|
};
|
|
var makeFlipImage = function(img, direction) {
|
|
return new FlipImage(img, direction);
|
|
};
|
|
var makeTextImage = function(msg, size, color, face, family, style, weight, underline) {
|
|
return new TextImage(msg, size, color, face, family, style, weight, underline);
|
|
};
|
|
var makeImageDataImage = function(imageData) {
|
|
return new ImageDataImage(imageData);
|
|
};
|
|
var makeFileImage = function(path, rawImage) {
|
|
return FileImage.makeInstance(path, rawImage);
|
|
};
|
|
var makeVideoImage = function(path, rawVideo) {
|
|
return VideoImage.makeInstance(path, rawVideo);
|
|
};
|
|
|
|
|
|
var isSceneImage = function(x) { return x instanceof SceneImage; };
|
|
var isCircleImage = function(x) { return x instanceof EllipseImage &&
|
|
x.width === x.height; };
|
|
var isStarImage = function(x) { return x instanceof StarImage; };
|
|
var isRectangleImage=function(x) { return x instanceof RectangleImage; };
|
|
var isPolygonImage = function(x) { return x instanceof PolygonImage; };
|
|
var isRhombusImage = function(x) { return x instanceof RhombusImage; };
|
|
var isSquareImage = function(x) { return x instanceof SquareImage; };
|
|
var isTriangleImage= function(x) { return x instanceof TriangleImage; };
|
|
var isRightTriangleImage = function(x) { return x instanceof RightTriangleImage; };
|
|
var isEllipseImage = function(x) { return x instanceof EllipseImage; };
|
|
var isLineImage = function(x) { return x instanceof LineImage; };
|
|
var isOverlayImage = function(x) { return x instanceof OverlayImage; };
|
|
var isRotateImage = function(x) { return x instanceof RotateImage; };
|
|
var isScaleImage = function(x) { return x instanceof ScaleImage; };
|
|
var isCropImage = function(x) { return x instanceof CropImage; };
|
|
var isFrameImage = function(x) { return x instanceof FrameImage; };
|
|
var isFlipImage = function(x) { return x instanceof FlipImage; };
|
|
var isTextImage = function(x) { return x instanceof TextImage; };
|
|
var isFileImage = function(x) { return x instanceof FileImage; };
|
|
var isFileVideo = function(x) { return x instanceof FileVideo; };
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////
|
|
// Exports
|
|
|
|
// These functions are available for direct access without the typechecks
|
|
// of the Racket-exposed functions.
|
|
|
|
|
|
EXPORTS.makeCanvas = makeCanvas;
|
|
|
|
|
|
|
|
EXPORTS.BaseImage = BaseImage;
|
|
EXPORTS.SceneImage = SceneImage;
|
|
EXPORTS.FileImage = FileImage;
|
|
EXPORTS.VideoImage = VideoImage;
|
|
EXPORTS.OverlayImage = OverlayImage;
|
|
EXPORTS.RotateImage = RotateImage;
|
|
EXPORTS.ScaleImage = ScaleImage;
|
|
EXPORTS.CropImage = CropImage;
|
|
EXPORTS.FrameImage = FrameImage;
|
|
EXPORTS.FlipImage = FlipImage;
|
|
EXPORTS.RectangleImage = RectangleImage;
|
|
EXPORTS.RhombusImage = RhombusImage;
|
|
EXPORTS.ImageDataImage = ImageDataImage;
|
|
EXPORTS.PolygonImage = PolygonImage;
|
|
EXPORTS.TextImage = TextImage;
|
|
EXPORTS.StarImage = StarImage;
|
|
EXPORTS.TriangleImage = TriangleImage;
|
|
EXPORTS.RightTriangleImage = RightTriangleImage;
|
|
EXPORTS.EllipseImage = EllipseImage;
|
|
EXPORTS.LineImage = LineImage;
|
|
EXPORTS.StarImage = StarImage;
|
|
|
|
|
|
|
|
EXPORTS.colorDb = colorDb;
|
|
|
|
EXPORTS.makeSceneImage = makeSceneImage;
|
|
EXPORTS.makeCircleImage = makeCircleImage;
|
|
EXPORTS.makeStarImage = makeStarImage;
|
|
EXPORTS.makeRectangleImage = makeRectangleImage;
|
|
EXPORTS.makeRhombusImage = makeRhombusImage;
|
|
EXPORTS.makePolygonImage = makePolygonImage;
|
|
EXPORTS.makeSquareImage = makeSquareImage;
|
|
EXPORTS.makeRightTriangleImage = makeRightTriangleImage;
|
|
EXPORTS.makeTriangleImage = makeTriangleImage;
|
|
EXPORTS.makeEllipseImage = makeEllipseImage;
|
|
EXPORTS.makeLineImage = makeLineImage;
|
|
EXPORTS.makeOverlayImage = makeOverlayImage;
|
|
EXPORTS.makeRotateImage = makeRotateImage;
|
|
EXPORTS.makeScaleImage = makeScaleImage;
|
|
EXPORTS.makeCropImage = makeCropImage;
|
|
EXPORTS.makeFrameImage = makeFrameImage;
|
|
EXPORTS.makeFlipImage = makeFlipImage;
|
|
EXPORTS.makeTextImage = makeTextImage;
|
|
EXPORTS.makeImageDataImage = makeImageDataImage;
|
|
EXPORTS.makeFileImage = makeFileImage;
|
|
EXPORTS.makeVideoImage = makeVideoImage;
|
|
|
|
EXPORTS.imageToColorList = imageToColorList;
|
|
EXPORTS.colorListToImage = colorListToImage;
|
|
|
|
|
|
EXPORTS.isImage = isImage;
|
|
EXPORTS.isScene = isScene;
|
|
EXPORTS.isColorOrColorString = isColorOrColorString;
|
|
EXPORTS.isAngle = isAngle;
|
|
EXPORTS.isSideCount = isSideCount;
|
|
EXPORTS.isStepCount = isStepCount;
|
|
EXPORTS.isPointsCount = isPointsCount;
|
|
|
|
|
|
EXPORTS.isSceneImage = isSceneImage;
|
|
EXPORTS.isCircleImage = isCircleImage;
|
|
EXPORTS.isStarImage = isStarImage;
|
|
EXPORTS.isRectangleImage = isRectangleImage;
|
|
EXPORTS.isPolygonImage = isPolygonImage;
|
|
EXPORTS.isRhombusImage = isRhombusImage;
|
|
EXPORTS.isSquareImage = isSquareImage;
|
|
EXPORTS.isTriangleImage = isTriangleImage;
|
|
EXPORTS.isRightTriangleImage = isRightTriangleImage;
|
|
EXPORTS.isEllipseImage = isEllipseImage;
|
|
EXPORTS.isLineImage = isLineImage;
|
|
EXPORTS.isOverlayImage = isOverlayImage;
|
|
EXPORTS.isRotateImage = isRotateImage;
|
|
EXPORTS.isScaleImage = isScaleImage;
|
|
EXPORTS.isCropImage = isCropImage;
|
|
EXPORTS.isFrameImage = isFrameImage;
|
|
EXPORTS.isFlipImage = isFlipImage;
|
|
EXPORTS.isTextImage = isTextImage;
|
|
EXPORTS.isFileImage = isFileImage;
|
|
EXPORTS.isFileVideo = isFileVideo;
|
|
|
|
|
|
|
|
EXPORTS.makeColor = makeColor;
|
|
EXPORTS.isColor = isColor;
|
|
EXPORTS.colorRed = colorRed;
|
|
EXPORTS.colorGreen = colorGreen;
|
|
EXPORTS.colorBlue = colorBlue;
|
|
EXPORTS.colorAlpha = colorAlpha;
|
|
|
|
var makePrimitiveProcedure = plt.baselib.functions.makePrimitiveProcedure;
|
|
var makeClosure = plt.baselib.functions.makeClosure;
|
|
var finalizeClosureCall = plt.baselib.functions.finalizeClosureCall;
|
|
var PAUSE = plt.runtime.PAUSE;
|
|
|
|
|
|
var isString = plt.baselib.strings.isString;
|
|
var isSymbol = plt.baselib.symbols.isSymbol;
|
|
|
|
|
|
var isFontFamily = function(x){
|
|
return ((isString(x) || isSymbol(x)) &&
|
|
(x.toString().toLowerCase() == "default" ||
|
|
x.toString().toLowerCase() == "decorative" ||
|
|
x.toString().toLowerCase() == "roman" ||
|
|
x.toString().toLowerCase() == "script" ||
|
|
x.toString().toLowerCase() == "swiss" ||
|
|
x.toString().toLowerCase() == "modern" ||
|
|
x.toString().toLowerCase() == "symbol" ||
|
|
x.toString().toLowerCase() == "system"))
|
|
|| (x === false); // false is also acceptable
|
|
};
|
|
var isFontStyle = function(x){
|
|
return ((isString(x) || isSymbol(x)) &&
|
|
(x.toString().toLowerCase() == "normal" ||
|
|
x.toString().toLowerCase() == "italic" ||
|
|
x.toString().toLowerCase() == "slant"))
|
|
|| (x === false); // false is also acceptable
|
|
};
|
|
var isFontWeight = function(x){
|
|
return ((isString(x) || isSymbol(x)) &&
|
|
(x.toString().toLowerCase() == "normal" ||
|
|
x.toString().toLowerCase() == "bold" ||
|
|
x.toString().toLowerCase() == "light"))
|
|
|| (x === false); // false is also acceptable
|
|
};
|
|
var isMode = function(x) {
|
|
return ((isString(x) || isSymbol(x)) &&
|
|
(x.toString().toLowerCase() == "solid" ||
|
|
x.toString().toLowerCase() == "outline"));
|
|
};
|
|
|
|
var isPlaceX = function(x) {
|
|
return ((isString(x) || isSymbol(x)) &&
|
|
(x.toString().toLowerCase() == "left" ||
|
|
x.toString().toLowerCase() == "right" ||
|
|
x.toString().toLowerCase() == "center" ||
|
|
x.toString().toLowerCase() == "middle"));
|
|
};
|
|
|
|
var isPlaceY = function(x) {
|
|
return ((isString(x) || isSymbol(x)) &&
|
|
(x.toString().toLowerCase() == "top" ||
|
|
x.toString().toLowerCase() == "bottom" ||
|
|
x.toString().toLowerCase() == "baseline" ||
|
|
x.toString().toLowerCase() == "center" ||
|
|
x.toString().toLowerCase() == "middle"));
|
|
};
|
|
|
|
var isStyle = function(x) {
|
|
return ((isString(x) || isSymbol(x)) &&
|
|
(x.toString().toLowerCase() == "solid" ||
|
|
x.toString().toLowerCase() == "outline"));
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var checkString = plt.baselib.check.checkString;
|
|
var checkStringOrFalse = plt.baselib.check.makeCheckArgumentType(
|
|
function(x) { return plt.baselib.strings.isString(x) || x === false; },
|
|
"string or false");
|
|
|
|
var checkByte = plt.baselib.check.checkByte;
|
|
var checkReal = plt.baselib.check.checkReal;
|
|
var checkBoolean = plt.baselib.check.checkBoolean;
|
|
|
|
var checkNatural = plt.baselib.check.checkNatural;
|
|
var checkNonNegativeReal = plt.baselib.check.checkNonNegativeReal;
|
|
|
|
|
|
var _checkColor = plt.baselib.check.makeCheckArgumentType(
|
|
isColorOrColorString,
|
|
'color');
|
|
|
|
var checkColor = function(MACHINE, functionName, position) {
|
|
var aColor = _checkColor(MACHINE, functionName, position);
|
|
if (colorDb.get(aColor)) {
|
|
aColor = colorDb.get(aColor);
|
|
}
|
|
return aColor;
|
|
};
|
|
|
|
var checkImage = plt.baselib.check.makeCheckArgumentType(
|
|
isImage,
|
|
'image');
|
|
|
|
var checkImageOrScene = plt.baselib.check.makeCheckArgumentType(
|
|
function(x) { return isImage(x) || isScene(x); },
|
|
'image or scene');
|
|
|
|
var checkFontFamily = plt.baselib.check.makeCheckArgumentType(
|
|
isFontFamily,
|
|
'font family');
|
|
|
|
var checkFontStyle = plt.baselib.check.makeCheckArgumentType(
|
|
isFontStyle,
|
|
'font style');
|
|
|
|
var checkFontWeight = plt.baselib.check.makeCheckArgumentType(
|
|
isFontWeight,
|
|
'font weight');
|
|
|
|
var checkPlaceX = plt.baselib.check.makeCheckArgumentType(
|
|
isPlaceX,
|
|
'x-place');
|
|
|
|
var checkPlaceY = plt.baselib.check.makeCheckArgumentType(
|
|
isPlaceY,
|
|
'y-place');
|
|
|
|
|
|
var checkAngle = plt.baselib.check.makeCheckArgumentType(
|
|
isAngle,
|
|
"finite real number between 0 and 360");
|
|
|
|
|
|
var checkMode = plt.baselib.check.makeCheckArgumentType(
|
|
isMode,
|
|
'solid or outline');
|
|
|
|
|
|
var checkSideCount = plt.baselib.check.makeCheckArgumentType(
|
|
isSideCount,
|
|
"positive integer greater than or equal to 3");
|
|
|
|
|
|
var checkStepCount = plt.baselib.check.makeCheckArgumentType(
|
|
isStepCount,
|
|
"positive integer greater than or equal to 1");
|
|
|
|
|
|
var checkPointsCount = plt.baselib.check.makeCheckArgumentType(
|
|
isPointsCount,
|
|
"positive integer greater than or equal to 2");
|
|
|
|
|
|
var checkListofColor = plt.baselib.check.makeCheckListofArgumentType(
|
|
isColor,
|
|
'color');
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
EXPORTS['image-color?'] =
|
|
makePrimitiveProcedure(
|
|
'image-color?',
|
|
1,
|
|
function(MACHINE) {
|
|
var elt = MACHINE.env[MACHINE.env.length - 1];
|
|
return (isColorOrColorString(elt));
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['mode?'] =
|
|
makePrimitiveProcedure(
|
|
'mode?',
|
|
1,
|
|
function(MACHINE) {
|
|
return isMode(MACHINE.env[MACHINE.env.length - 1]);
|
|
});
|
|
|
|
EXPORTS['x-place?'] =
|
|
makePrimitiveProcedure(
|
|
'x-place?',
|
|
1,
|
|
function(MACHINE) {
|
|
return isPlaceX(MACHINE.env[MACHINE.env.length - 1]);
|
|
});
|
|
|
|
EXPORTS['y-place?'] =
|
|
makePrimitiveProcedure(
|
|
'y-place?',
|
|
1,
|
|
function(MACHINE) {
|
|
return isPlaceY(MACHINE.env[MACHINE.env.length - 1]);
|
|
});
|
|
|
|
EXPORTS['angle?'] =
|
|
makePrimitiveProcedure(
|
|
'angle?',
|
|
1,
|
|
function(MACHINE) {
|
|
return isAngle(MACHINE.env[MACHINE.env.length - 1]);
|
|
});
|
|
|
|
EXPORTS['side-count?'] =
|
|
makePrimitiveProcedure(
|
|
'side-count?',
|
|
1,
|
|
function(MACHINE) {
|
|
return isSideCount(MACHINE.env[MACHINE.env.length - 1]);
|
|
});
|
|
|
|
|
|
EXPORTS['step-count?'] =
|
|
makePrimitiveProcedure(
|
|
'step-count?',
|
|
1,
|
|
function(MACHINE) {
|
|
return isStepCount(MACHINE.env[MACHINE.env.length - 1]);
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['text'] =
|
|
makePrimitiveProcedure(
|
|
'text',
|
|
3,
|
|
function(MACHINE) {
|
|
var aString = checkString(MACHINE,'text', 0);
|
|
var aSize = checkByte(MACHINE, 'text', 1);
|
|
var aColor = checkColor(MACHINE, 'text', 2);
|
|
return makeTextImage(aString.toString(),
|
|
jsnums.toFixnum(aSize),
|
|
aColor,
|
|
"normal",
|
|
"Optimer",
|
|
"",
|
|
"",
|
|
false);
|
|
});
|
|
|
|
|
|
EXPORTS['text/font'] =
|
|
makePrimitiveProcedure(
|
|
'text/font',
|
|
8,
|
|
function(MACHINE) {
|
|
var aString = checkString(MACHINE, "text/font", 0);
|
|
var aSize = checkByte(MACHINE, "text/font", 1);
|
|
var aColor = checkColor(MACHINE, "text/font", 2);
|
|
var aFace = checkStringOrFalse(MACHINE, "text/font", 3);
|
|
var aFamily = checkFontFamily(MACHINE, "text/font", 4);
|
|
var aStyle = checkFontStyle(MACHINE, "text/font", 5);
|
|
var aWeight = checkFontWeight(MACHINE, "text/font", 6);
|
|
var aUnderline = checkBoolean(MACHINE, "text/font", 7);
|
|
return makeTextImage(aString.toString(),
|
|
jsnums.toFixnum(aSize),
|
|
aColor,
|
|
aFace.toString(),
|
|
aFamily.toString(),
|
|
aStyle.toString(),
|
|
aWeight.toString(),
|
|
aUnderline);
|
|
});
|
|
|
|
|
|
EXPORTS['image-url'] =
|
|
makeClosure(
|
|
'image-url',
|
|
1,
|
|
function(MACHINE) {
|
|
var url = checkString(MACHINE, 'image-url', 0);
|
|
var oldArgcount = MACHINE.argcount;
|
|
PAUSE(
|
|
function(restart) {
|
|
var rawImage = new Image();
|
|
rawImage.onload = function() {
|
|
restart(function(MACHINE) {
|
|
MACHINE.argcount = oldArgcount;
|
|
finalizeClosureCall(
|
|
MACHINE,
|
|
makeFileImage(url.toString(),
|
|
rawImage));
|
|
});
|
|
};
|
|
rawImage.onerror = function(e) {
|
|
restart(function(MACHINE) {
|
|
plt.baselib.exceptions.raise(
|
|
MACHINE,
|
|
new Error(plt.baselib.format.format(
|
|
"unable to load ~a: ~a",
|
|
url,
|
|
e.message)));
|
|
});
|
|
}
|
|
rawImage.src = url.toString();
|
|
}
|
|
);
|
|
});
|
|
|
|
|
|
EXPORTS['open-image-url'] =
|
|
plt.baselib.functions.renameProcedure(EXPORTS['image-url'],
|
|
'open-image-url');
|
|
|
|
|
|
EXPORTS['overlay'] =
|
|
makePrimitiveProcedure(
|
|
'overlay',
|
|
plt.baselib.arity.makeArityAtLeast(2),
|
|
function(MACHINE) {
|
|
var img1 = checkImage(MACHINE, "overlay", 0);
|
|
var img2 = checkImage(MACHINE, "overlay", 1);
|
|
var restImages = [];
|
|
for (var i = 2; i < MACHINE.argcount; i++) {
|
|
restImages.push(checkImage(MACHINE, "overlay", i));
|
|
}
|
|
|
|
var img = makeOverlayImage(img1, img2, "middle", "middle");
|
|
for (var i = 0; i < restImages.length; i++) {
|
|
img = makeOverlayImage(img, restImages[i], "middle", "middle");
|
|
}
|
|
return img;
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['overlay/xy'] =
|
|
makePrimitiveProcedure(
|
|
'overlay/xy',
|
|
4,
|
|
function(MACHINE) {
|
|
var img1 = checkImage(MACHINE, "overlay/xy", 0);
|
|
var deltaX = checkReal(MACHINE, "overlay/xy", 1);
|
|
var deltaY = checkReal(MACHINE, "overlay/xy", 2);
|
|
var img2 = checkImage(MACHINE, "overlay/xy", 3);
|
|
return makeOverlayImage(img1.updatePinhole(0, 0),
|
|
img2.updatePinhole(0, 0),
|
|
jsnums.toFixnum(deltaX),
|
|
jsnums.toFixnum(deltaY));
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['overlay/align'] =
|
|
makePrimitiveProcedure(
|
|
'overlay/align',
|
|
plt.baselib.arity.makeArityAtLeast(4),
|
|
function(MACHINE) {
|
|
var placeX = checkPlaceX(MACHINE, "overlay/align", 0);
|
|
var placeY = checkPlaceY(MACHINE, "overlay/align", 1);
|
|
var img1 = checkImage(MACHINE, "overlay/align", 2);
|
|
var img2 = checkImage(MACHINE, "overlay/align", 3);
|
|
var restImages = [];
|
|
for (var i = 4; i < MACHINE.argcount; i++) {
|
|
restImages.push(checkImage(MACHINE, "overlay/align", i));
|
|
}
|
|
var img = makeOverlayImage(img1,
|
|
img2,
|
|
placeX.toString(),
|
|
placeY.toString());
|
|
for (var i = 0; i < restImages.length; i++)
|
|
img = makeOverlayImage(img,
|
|
restImages[i],
|
|
placeX.toString(),
|
|
placeY.toString());
|
|
return img;
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
EXPORTS['underlay'] =
|
|
makePrimitiveProcedure(
|
|
'underlay',
|
|
plt.baselib.arity.makeArityAtLeast(2),
|
|
function(MACHINE) {
|
|
var img1 = checkImage(MACHINE, "underlay", 0);
|
|
var img2 = checkImage(MACHINE, "underlay", 1);
|
|
var restImages = [];
|
|
for (var i = 2; i < MACHINE.argcount; i++) {
|
|
restImages.push(checkImage(MACHINE, "underlay", i));
|
|
}
|
|
|
|
var img = makeOverlayImage(img2, img1, 0, 0);
|
|
for (var i = 0; i < restImages.length; i++) {
|
|
img = makeOverlayImage(restImages[i], img, 0, 0);
|
|
}
|
|
return img;
|
|
});
|
|
|
|
|
|
EXPORTS['underlay/xy'] =
|
|
makePrimitiveProcedure(
|
|
'underlay/xy',
|
|
4,
|
|
function(MACHINE) {
|
|
var img1 = checkImage(MACHINE, "underlay/xy", 0);
|
|
var deltaX = checkReal(MACHINE, "underlay/xy", 1);
|
|
var deltaY = checkReal(MACHINE, "underlay/xy", 2);
|
|
var img2 = checkImage(MACHINE, "underlay/xy", 3);
|
|
return makeOverlayImage(img2.updatePinhole(0, 0),
|
|
img1.updatePinhole(0, 0),
|
|
-(jsnums.toFixnum(deltaX)),
|
|
-(jsnums.toFixnum(deltaY)));
|
|
});
|
|
|
|
EXPORTS['underlay/align'] =
|
|
makePrimitiveProcedure(
|
|
'underlay/align',
|
|
plt.baselib.arity.makeArityAtLeast(4),
|
|
function(MACHINE) {
|
|
var placeX = checkPlaceX(MACHINE, "underlay/align", 0);
|
|
var placeY = checkPlaceY(MACHINE, "underlay/align", 1);
|
|
var img1 = checkImage(MACHINE, "underlay/align", 2);
|
|
var img2 = checkImage(MACHINE, "underlay/align", 3);
|
|
var restImages = [];
|
|
for (var i = 4; i < MACHINE.argcount; i++) {
|
|
restImages.push(checkImage(MACHINE, "underlay/align", i));
|
|
}
|
|
|
|
var img = makeOverlayImage(img2,
|
|
img1,
|
|
placeX.toString(),
|
|
placeY.toString());
|
|
|
|
for (var i = 0; i < restImages.length; i++) {
|
|
img = makeOverlayImage(restImages[i],
|
|
img,
|
|
placeX.toString(),
|
|
placeY.toString());
|
|
}
|
|
return img;
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['beside'] =
|
|
makePrimitiveProcedure(
|
|
'beside',
|
|
plt.baselib.arity.makeArityAtLeast(2),
|
|
function(MACHINE) {
|
|
var img1 = checkImage(MACHINE, "beside", 0);
|
|
var img2 = checkImage(MACHINE, "beside", 1);
|
|
var restImages = [];
|
|
for (var i = 2; i < MACHINE.argcount; i++) {
|
|
restImages.push(checkImage(MACHINE, "beside", i));
|
|
}
|
|
|
|
var img = makeOverlayImage(img1,
|
|
img2,
|
|
"beside",
|
|
"middle");
|
|
|
|
for (var i = 0; i < restImages.length; i++) {
|
|
img = makeOverlayImage(img, restImages[i], "beside", "middle");
|
|
}
|
|
|
|
return img;
|
|
});
|
|
|
|
|
|
EXPORTS['beside/align'] =
|
|
makePrimitiveProcedure(
|
|
'beside/align',
|
|
plt.baselib.arity.makeArityAtLeast(3),
|
|
function(MACHINE) {
|
|
var placeY = checkPlaceY(MACHINE, "beside/align", 0);
|
|
var img1 = checkImage(MACHINE, "beside/align", 1);
|
|
var img2 = checkImage(MACHINE, "beside/align", 2);
|
|
var restImages = [];
|
|
for (var i = 3; i < MACHINE.argcount; i++) {
|
|
restImages.push(checkImage(MACHINE, "beside/align", i));
|
|
}
|
|
|
|
var img = makeOverlayImage(img1,
|
|
img2,
|
|
"beside",
|
|
placeY.toString());
|
|
|
|
for (var i = 0; i < restImages.length; i++) {
|
|
img = makeOverlayImage(img,
|
|
restImages[i],
|
|
"beside",
|
|
placeY.toString());
|
|
}
|
|
|
|
return img;
|
|
|
|
});
|
|
|
|
EXPORTS['above'] =
|
|
makePrimitiveProcedure(
|
|
'above',
|
|
plt.baselib.arity.makeArityAtLeast(2),
|
|
function(MACHINE) {
|
|
var img1 = checkImage(MACHINE, "above", 0);
|
|
var img2 = checkImage(MACHINE, "above", 1);
|
|
var restImages = [];
|
|
for (var i = 2; i < MACHINE.argcount; i++) {
|
|
restImages.push(checkImage(MACHINE, "above", i));
|
|
}
|
|
|
|
var img = makeOverlayImage(img1,
|
|
img2,
|
|
"middle",
|
|
"above");
|
|
|
|
for (var i = 0; i < restImages.length; i++)
|
|
img = makeOverlayImage(img,
|
|
restImages[i],
|
|
"middle",
|
|
"above");
|
|
return img;
|
|
|
|
});
|
|
|
|
EXPORTS['above/align'] =
|
|
makePrimitiveProcedure(
|
|
'above/align',
|
|
plt.baselib.arity.makeArityAtLeast(3),
|
|
function(MACHINE) {
|
|
var placeX = checkPlaceX(MACHINE, "above/align", 0);
|
|
var img1 = checkImage(MACHINE, "above/align", 1);
|
|
var img2 = checkImage(MACHINE, "above/align", 2);
|
|
var restImages = [];
|
|
for (var i = 3; i < MACHINE.argcount; i++) {
|
|
restImages.push(checkImage(MACHINE, "above/align", i));
|
|
}
|
|
|
|
|
|
var img = makeOverlayImage(img1,
|
|
img2,
|
|
placeX.toString(),
|
|
"above");
|
|
|
|
for (var i = 0; i < restImages.length; i++)
|
|
img = makeOverlayImage(img,
|
|
restImages[i],
|
|
placeX.toString(),
|
|
"above");
|
|
|
|
return img;
|
|
});
|
|
|
|
|
|
|
|
|
|
EXPORTS['empty-scene'] =
|
|
makePrimitiveProcedure(
|
|
'empty-scene',
|
|
2,
|
|
function(MACHINE) {
|
|
var width = checkNonNegativeReal(MACHINE, 'empty-scene', 0);
|
|
var height = checkNonNegativeReal(MACHINE, 'empty-scene', 1);
|
|
return makeSceneImage(jsnums.toFixnum(width),
|
|
jsnums.toFixnum(height),
|
|
[],
|
|
true);
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['place-image'] =
|
|
makePrimitiveProcedure(
|
|
'place-image',
|
|
4,
|
|
function(MACHINE) {
|
|
var picture = checkImage(MACHINE, "place-image", 0);
|
|
var x = checkReal(MACHINE, "place-image", 1);
|
|
var y = checkReal(MACHINE, "place-image", 2);
|
|
var background = checkImageOrScene(MACHINE, "place-image", 3);
|
|
if (isScene(background)) {
|
|
return background.add(picture, jsnums.toFixnum(x), jsnums.toFixnum(y));
|
|
} else {
|
|
var newScene = makeSceneImage(background.getWidth(),
|
|
background.getHeight(),
|
|
[],
|
|
false);
|
|
newScene = newScene.add(background.updatePinhole(0, 0), 0, 0);
|
|
newScene = newScene.add(picture, jsnums.toFixnum(x), jsnums.toFixnum(y));
|
|
return newScene;
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['place-image/align'] =
|
|
makePrimitiveProcedure(
|
|
'place-image/align',
|
|
6,
|
|
function(MACHINE) {
|
|
var img = checkImage(MACHINE, "place-image/align", 0);
|
|
var x = checkReal(MACHINE, "place-image/align", 1);
|
|
var y = checkReal(MACHINE, "place-image/align", 2);
|
|
var placeX = checkPlaceX(MACHINE, "place-image/align", 3);
|
|
var placeY = checkPlaceY(MACHINE, "place-image/align", 4);
|
|
var background = checkImageOrScene(MACHINE, "place-image/align", 5);
|
|
|
|
// calculate x and y based on placeX and placeY
|
|
if (placeX == "left") x = x + img.pinholeX;
|
|
else if (placeX == "right") x = x - img.pinholeX;
|
|
if (placeY == "top") y = y + img.pinholeY;
|
|
else if (placeY == "bottom") y = y - img.pinholeY;
|
|
|
|
if (isScene(background)) {
|
|
return background.add(img, jsnums.toFixnum(x), jsnums.toFixnum(y));
|
|
} else {
|
|
var newScene = makeSceneImage(background.getWidth(),
|
|
background.getHeight(),
|
|
[],
|
|
false);
|
|
newScene = newScene.add(background.updatePinhole(0, 0), 0, 0);
|
|
newScene = newScene.add(img, jsnums.toFixnum(x), jsnums.toFixnum(y));
|
|
return newScene;
|
|
}
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
EXPORTS['rotate'] =
|
|
makePrimitiveProcedure(
|
|
'rotate',
|
|
2,
|
|
function(MACHINE) {
|
|
var angle = checkAngle(MACHINE, "rotate", 0);
|
|
var img = checkImage(MACHINE, "rotate", 1);
|
|
return makeRotateImage(jsnums.toFixnum(-angle), img);
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['scale'] =
|
|
makePrimitiveProcedure(
|
|
'scale',
|
|
2,
|
|
function(MACHINE) {
|
|
var factor = checkReal(MACHINE, "scale", 0);
|
|
var img = checkImage(MACHINE, "image", 1);
|
|
|
|
return makeScaleImage(jsnums.toFixnum(factor),
|
|
jsnums.toFixnum(factor),
|
|
img);
|
|
});
|
|
|
|
|
|
EXPORTS['scale/xy'] =
|
|
makePrimitiveProcedure(
|
|
'scale/xy',
|
|
3,
|
|
function(MACHINE) {
|
|
var xFactor = checkReal(MACHINE, "scale/xy", 0);
|
|
var yFactor = checkReal(MACHINE, "scale/xy", 1);
|
|
var img = checkImage(MACHINE, "scale/xy", 2);
|
|
return makeScaleImage(jsnums.toFixnum(xFactor),
|
|
jsnums.toFixnum(yFactor),
|
|
img);
|
|
|
|
});
|
|
|
|
|
|
EXPORTS['flip-horizontal'] =
|
|
makePrimitiveProcedure(
|
|
'flip-horizontal',
|
|
1,
|
|
function(MACHINE) {
|
|
var img = checkImage(MACHINE, "flip-horizontal", 0);
|
|
return makeFlipImage(img, "horizontal");
|
|
});
|
|
|
|
|
|
EXPORTS['flip-vertical'] =
|
|
makePrimitiveProcedure(
|
|
'flip-vertical',
|
|
1,
|
|
function(MACHINE) {
|
|
var img = checkImage(MACHINE, "flip-vertical", 0);
|
|
return makeFlipImage(img, "vertical");
|
|
});
|
|
|
|
|
|
EXPORTS['frame'] =
|
|
makePrimitiveProcedure(
|
|
'frame',
|
|
1,
|
|
function(MACHINE) {
|
|
var img = checkImage(MACHINE, "frame", 0);
|
|
return makeFrameImage(img);
|
|
});
|
|
|
|
|
|
EXPORTS['crop'] =
|
|
makePrimitiveProcedure(
|
|
'crop',
|
|
5,
|
|
function(MACHINE) {
|
|
var x = checkReal(MACHINE, "crop", 0);
|
|
var y = checkReal(MACHINE, "crop", 1);
|
|
var width = checkNonNegativeReal(MACHINE, "crop", 2);
|
|
var height = checkNonNegativeReal(MACHINE, "crop", 3);
|
|
var img = checkImage(MACHINE, "crop", 4);
|
|
return makeCropImage(jsnums.toFixnum(x),
|
|
jsnums.toFixnum(y),
|
|
jsnums.toFixnum(width),
|
|
jsnums.toFixnum(height),
|
|
img);
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['line'] =
|
|
makePrimitiveProcedure(
|
|
'line',
|
|
3,
|
|
function(MACHINE) {
|
|
var x = checkReal(MACHINE, 'line', 0);
|
|
var y = checkReal(MACHINE, 'line', 1);
|
|
var c = checkColor(MACHINE, 'line', 2);
|
|
return makeLineImage(jsnums.toFixnum(x),
|
|
jsnums.toFixnum(y),
|
|
c,
|
|
true);
|
|
});
|
|
|
|
|
|
|
|
|
|
EXPORTS['add-line'] =
|
|
makePrimitiveProcedure(
|
|
'add-line',
|
|
6,
|
|
function(MACHINE) {
|
|
var img = checkImage(MACHINE, "add-line", 0);
|
|
var x1 = checkReal(MACHINE, "add-line", 1);
|
|
var y1 = checkReal(MACHINE, "add-line", 2);
|
|
var x2 = checkReal(MACHINE, "add-line", 3);
|
|
var y2 = checkReal(MACHINE, "add-line", 4);
|
|
var c = checkColor(MACHINE, "add-line", 5);
|
|
var line = makeLineImage(jsnums.toFixnum(x2-x1),
|
|
jsnums.toFixnum(y2-y1),
|
|
c,
|
|
true);
|
|
return makeOverlayImage(line, img, "middle", "middle");
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['scene+line'] =
|
|
makePrimitiveProcedure(
|
|
'scene+line',
|
|
6,
|
|
function(MACHINE) {
|
|
var img = checkImage(MACHINE, "scene+line", 0);
|
|
var x1 = checkReal(MACHINE, "scene+line", 1);
|
|
var y1 = checkReal(MACHINE, "scene+line", 2);
|
|
var x2 = checkReal(MACHINE, "scene+line", 3);
|
|
var y2 = checkReal(MACHINE, "scene+line", 4);
|
|
var c = checkColor(MACHINE, "scene+line", 5);
|
|
// make a scene containing the image
|
|
var newScene = makeSceneImage(jsnums.toFixnum(img.getWidth()),
|
|
jsnums.toFixnum(img.getHeight()),
|
|
[],
|
|
true);
|
|
newScene = newScene.add(img.updatePinhole(0, 0), 0, 0);
|
|
// make an image containing the line
|
|
var line = makeLineImage(jsnums.toFixnum(x2-x1),
|
|
jsnums.toFixnum(y2-y1),
|
|
c,
|
|
false);
|
|
// add the line to scene, offset by the original amount
|
|
return newScene.add(line, jsnums.toFixnum(x1), jsnums.toFixnum(y1));
|
|
});
|
|
|
|
|
|
EXPORTS['circle'] =
|
|
makePrimitiveProcedure(
|
|
'circle',
|
|
3,
|
|
function(MACHINE) {
|
|
var aRadius = checkNonNegativeReal(MACHINE, "circle", 0);
|
|
var aMode = checkMode(MACHINE, "circle", 1);
|
|
var aColor = checkColor(MACHINE, "circle", 2);
|
|
return makeCircleImage(jsnums.toFixnum(aRadius), aMode.toString(), aColor);
|
|
});
|
|
|
|
|
|
EXPORTS['square'] =
|
|
makePrimitiveProcedure(
|
|
'square',
|
|
3,
|
|
function(MACHINE) {
|
|
var l = checkNonNegativeReal(MACHINE, "square", 0);
|
|
var s = checkMode(MACHINE, "square", 1);
|
|
var c = checkColor(MACHINE, "square", 2);
|
|
return makeSquareImage(jsnums.toFixnum(l), s.toString(), c);
|
|
});
|
|
|
|
|
|
EXPORTS['rectangle'] =
|
|
makePrimitiveProcedure(
|
|
'rectangle',
|
|
4,
|
|
function(MACHINE) {
|
|
var w = checkNonNegativeReal(MACHINE, "rectangle", 0);
|
|
var h = checkNonNegativeReal(MACHINE, "rectangle", 1);
|
|
var s = checkMode(MACHINE, "rectangle", 2);
|
|
var c = checkColor(MACHINE, "rectangle", 3);
|
|
return makeRectangleImage(jsnums.toFixnum(w),
|
|
jsnums.toFixnum(h),
|
|
s.toString(),
|
|
c);
|
|
});
|
|
|
|
|
|
EXPORTS['regular-polygon'] =
|
|
makePrimitiveProcedure(
|
|
'regular-polygon',
|
|
4,
|
|
function(MACHINE) {
|
|
var length = checkNonNegativeReal(MACHINE, "regular-polygon", 0);
|
|
var count = checkSideCount(MACHINE, "regular-polygon", 1);
|
|
var s = checkMode(MACHINE, "regular-polygon", 2);
|
|
var c = checkColor(MACHINE, "regular-polygon", 3);
|
|
return makePolygonImage(jsnums.toFixnum(length),
|
|
jsnums.toFixnum(count),
|
|
jsnums.toFixnum(1),
|
|
s.toString(),
|
|
c);
|
|
});
|
|
|
|
|
|
EXPORTS['ellipse'] =
|
|
makePrimitiveProcedure(
|
|
'ellipse',
|
|
4,
|
|
function(MACHINE) {
|
|
var w = checkNonNegativeReal(MACHINE, "ellipse", 0);
|
|
var h = checkNonNegativeReal(MACHINE, "ellipse", 1);
|
|
var s = checkMode(MACHINE, "ellipse", 2);
|
|
var c = checkColor(MACHINE, MACHINE, 3);
|
|
return makeEllipseImage(jsnums.toFixnum(w),
|
|
jsnums.toFixnum(h),
|
|
s.toString(),
|
|
c);
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['triangle'] =
|
|
makePrimitiveProcedure(
|
|
'triangle',
|
|
3,
|
|
function(MACHINE) {
|
|
var s = checkNonNegativeReal(MACHINE, "triangle", 0);
|
|
var m = checkMode(MACHINE, "triangle", 1);
|
|
var c = checkColor(MACHINE, "triangle", 2);
|
|
return makeTriangleImage(jsnums.toFixnum(s),
|
|
60,
|
|
m.toString(),
|
|
c);
|
|
});
|
|
|
|
|
|
EXPORTS['right-triangle'] =
|
|
makePrimitiveProcedure(
|
|
'right-triangle',
|
|
4,
|
|
function(MACHINE) {
|
|
var side1 = checkNonNegativeReal(MACHINE, "right-triangle", 0);
|
|
var side2 = checkNonNegativeReal(MACHINE, "right-triangle", 1);
|
|
var s = checkMode(MACHINE, "right-triangle", 2);
|
|
var c = checkColor(MACHINE, "right-triangle", 3);
|
|
return makeRightTriangleImage(jsnums.toFixnum(side1),
|
|
jsnums.toFixnum(side2),
|
|
s.toString(),
|
|
c);
|
|
});
|
|
|
|
|
|
EXPORTS['isosceles-triangle'] =
|
|
makePrimitiveProcedure(
|
|
'isosceles-triangle',
|
|
4,
|
|
function(MACHINE) {
|
|
var side = checkNonNegativeReal(MACHINE, "isosceles-triangle", 0);
|
|
var angle = checkAngle(MACHINE, "isosceles-triangle", 1);
|
|
var s = checkMode(MACHINE, "isosceles-triangle", 2);
|
|
var c = checkColor(MACHINE, "isosceles-triangle", 3);
|
|
return makeTriangleImage(jsnums.toFixnum(side),
|
|
jsnums.toFixnum(angle),
|
|
s.toString(),
|
|
c);
|
|
});
|
|
|
|
|
|
EXPORTS['star'] =
|
|
makePrimitiveProcedure(
|
|
'star',
|
|
plt.baselib.lists.makeList(3, 5),
|
|
function(MACHINE) {
|
|
if (MACHINE.argcount === 3) {
|
|
var sideLength = checkNonNegativeReal(MACHINE, "star", 0);
|
|
var mode = checkMode(MACHINE, "star", 1);
|
|
var color = checkColor(MACHINE, "star", 2);
|
|
return makePolygonImage(jsnums.toFixnum(sideLength),
|
|
jsnums.toFixnum(5),
|
|
jsnums.toFixnum(2),
|
|
mode.toString(),
|
|
color);
|
|
} else if (MACHINE.argcount === 5) {
|
|
var n = checkSideCount(MACHINE, "star", 0);
|
|
var outer = checkNonNegativeReal(MACHINE, "star", 1);
|
|
var inner = checkNonNegativeReal(MACHINE, "star", 2);
|
|
var m = checkMode(MACHINE, "star", 3);
|
|
var c = checkColor(MACHINE, "star", 4);
|
|
return makeStarImage(jsnums.toFixnum(n),
|
|
jsnums.toFixnum(outer),
|
|
jsnums.toFixnum(inner),
|
|
m.toString(),
|
|
c);
|
|
}
|
|
});
|
|
|
|
EXPORTS['radial-star'] =
|
|
makePrimitiveProcedure(
|
|
'radial-star',
|
|
5,
|
|
function(MACHINE) {
|
|
var aPoints = checkPointsCount(MACHINE, 'radial-star', 0);
|
|
var anOuter = checkNonNegativeReal(MACHINE, 'radial-star', 1);
|
|
var anInner = checkNonNegativeReal(MACHINE, 'radial-star', 2);
|
|
var aStyle = checkMode(MACHINE, "radial-star", 3);
|
|
var aColor = checkColor(MACHINE, "radial-star", 4);
|
|
return makeStarImage(jsnums.toFixnum(aPoints),
|
|
jsnums.toFixnum(anOuter),
|
|
jsnums.toFixnum(anInner),
|
|
aStyle.toString(),
|
|
aColor);
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['star-polygon'] =
|
|
makePrimitiveProcedure(
|
|
'star-polygon',
|
|
5,
|
|
function(MACHINE) {
|
|
var length = checkNonNegativeReal(MACHINE, "star-polygon", 0);
|
|
var count = checkNonNegativeReal(MACHINE, "star-polygon", 1);
|
|
var step = checkStepCount(MACHINE, "star-polygon", 2);
|
|
var s = checkMode(MACHINE, "star-polygon", 3);
|
|
var c = checkColor(MACHINE, "star-polygon", 4);
|
|
return makePolygonImage(jsnums.toFixnum(length),
|
|
jsnums.toFixnum(count),
|
|
jsnums.toFixnum(step),
|
|
s.toString(),
|
|
c);
|
|
});
|
|
|
|
|
|
EXPORTS['rhombus'] =
|
|
makePrimitiveProcedure(
|
|
'rhombus',
|
|
4,
|
|
function(MACHINE) {
|
|
var l = checkNonNegativeReal(MACHINE, "rhombus", 0);
|
|
var a = checkNonNegativeReal(MACHINE, "rhombus", 1);
|
|
var s = checkMode(MACHINE, "rhombus", 2);
|
|
var c = checkColor(MACHINE, "rhombus", 3);
|
|
return makeRhombusImage(jsnums.toFixnum(l),
|
|
jsnums.toFixnum(a),
|
|
s.toString(),
|
|
c);
|
|
|
|
});
|
|
|
|
|
|
EXPORTS['image->color-list'] =
|
|
makePrimitiveProcedure(
|
|
'image->color-list',
|
|
1,
|
|
function(MACHINE) {
|
|
var img = checkImage(MACHINE, 'image->color-list', 0);
|
|
return imageToColorList(img);
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['color-list->image'] =
|
|
makePrimitiveProcedure(
|
|
'color-list->image',
|
|
5,
|
|
function(MACHINE) {
|
|
var listOfColors = checkListofColor(MACHINE, 'color-list->image', 0);
|
|
var width = checkNatural(MACHINE, 'color-list->image', 1);
|
|
var height = checkNatural(MACHINE, 'color-list->image', 2);
|
|
var pinholeX = checkNatural(MACHINE, 'color-list->image', 3);
|
|
var pinholeY = checkNatural(MACHINE, 'color-list->image', 4);
|
|
|
|
return colorListToImage(listOfColors,
|
|
width,
|
|
height,
|
|
pinholeX,
|
|
pinholeY);
|
|
});
|
|
|
|
|
|
|
|
EXPORTS['image-width'] =
|
|
makePrimitiveProcedure(
|
|
'image-width',
|
|
1,
|
|
function(MACHINE) {
|
|
var img = checkImage(MACHINE, 'image-width', 0);
|
|
return img.getWidth();
|
|
});
|
|
|
|
EXPORTS['image-height'] =
|
|
makePrimitiveProcedure(
|
|
'image-height',
|
|
1,
|
|
function(MACHINE) {
|
|
var img = checkImage(MACHINE, 'image-height', 0);
|
|
return img.getHeight();
|
|
});
|
|
|
|
EXPORTS['image-baseline'] =
|
|
makePrimitiveProcedure(
|
|
'image-baseline',
|
|
1,
|
|
function(MACHINE) {
|
|
var img = checkImage(MACHINE, 'image-baseline', 0);
|
|
return img.getBaseline();
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
})(MACHINE, plt.runtime, exports);
|
|
modrec.namespace["above13.13"] = exports["above"];
|
|
modrec.namespace["above/align14.14"] = exports["above/align"];
|
|
modrec.namespace["add-line26.26"] = exports["add-line"];
|
|
modrec.namespace["angle?49.49"] = exports["angle?"];
|
|
modrec.namespace["beside11.11"] = exports["beside"];
|
|
modrec.namespace["beside/align12.12"] = exports["beside/align"];
|
|
modrec.namespace["circle28.28"] = exports["circle"];
|
|
modrec.namespace["color-list->image41.41"] = exports["color-list->image"];
|
|
modrec.namespace["crop24.24"] = exports["crop"];
|
|
modrec.namespace["ellipse32.32"] = exports["ellipse"];
|
|
modrec.namespace["empty-scene15.15"] = exports["empty-scene"];
|
|
modrec.namespace["flip-horizontal21.21"] = exports["flip-horizontal"];
|
|
modrec.namespace["flip-vertical22.22"] = exports["flip-vertical"];
|
|
modrec.namespace["frame23.23"] = exports["frame"];
|
|
modrec.namespace["image->color-list40.40"] = exports["image->color-list"];
|
|
modrec.namespace["image-baseline44.44"] = exports["image-baseline"];
|
|
modrec.namespace["image-color?45.45"] = exports["image-color?"];
|
|
modrec.namespace["image-height43.43"] = exports["image-height"];
|
|
modrec.namespace["image-url3.3"] = exports["image-url"];
|
|
modrec.namespace["image-width42.42"] = exports["image-width"];
|
|
modrec.namespace["isosceles-triangle35.35"] = exports["isosceles-triangle"];
|
|
modrec.namespace["line25.25"] = exports["line"];
|
|
modrec.namespace["mode?46.46"] = exports["mode?"];
|
|
modrec.namespace["open-image-url4.4"] = exports["open-image-url"];
|
|
modrec.namespace["overlay5.5"] = exports["overlay"];
|
|
modrec.namespace["overlay/align7.7"] = exports["overlay/align"];
|
|
modrec.namespace["overlay/xy6.6"] = exports["overlay/xy"];
|
|
modrec.namespace["place-image16.16"] = exports["place-image"];
|
|
modrec.namespace["place-image/align17.17"] = exports["place-image/align"];
|
|
modrec.namespace["radial-star37.37"] = exports["radial-star"];
|
|
modrec.namespace["rectangle30.30"] = exports["rectangle"];
|
|
modrec.namespace["regular-polygon31.31"] = exports["regular-polygon"];
|
|
modrec.namespace["rhombus39.39"] = exports["rhombus"];
|
|
modrec.namespace["right-triangle34.34"] = exports["right-triangle"];
|
|
modrec.namespace["rotate18.18"] = exports["rotate"];
|
|
modrec.namespace["scale19.19"] = exports["scale"];
|
|
modrec.namespace["scale/xy20.20"] = exports["scale/xy"];
|
|
modrec.namespace["scene+line27.27"] = exports["scene+line"];
|
|
modrec.namespace["side-count?50.50"] = exports["side-count?"];
|
|
modrec.namespace["square29.29"] = exports["square"];
|
|
modrec.namespace["star36.36"] = exports["star"];
|
|
modrec.namespace["star-polygon38.38"] = exports["star-polygon"];
|
|
modrec.namespace["step-count?51.51"] = exports["step-count?"];
|
|
modrec.namespace["text1.1"] = exports["text"];
|
|
modrec.namespace["text/font2.2"] = exports["text/font"];
|
|
modrec.namespace["triangle33.33"] = exports["triangle"];
|
|
modrec.namespace["underlay8.8"] = exports["underlay"];
|
|
modrec.namespace["underlay/align10.10"] = exports["underlay/align"];
|
|
modrec.namespace["underlay/xy9.9"] = exports["underlay/xy"];
|
|
modrec.namespace["x-place?47.47"] = exports["x-place?"];
|
|
modrec.namespace["y-place?48.48"] = exports["y-place?"];
|
|
|
|
modrec.privateExports = exports;
|
|
return MACHINE.control.pop().label(MACHINE); };
|
|
if (! MACHINE.modules["whalesong/image/private/color.rkt"].isInvoked) {
|
|
MACHINE.modules["whalesong/image/private/color.rkt"].internalInvoke(MACHINE,
|
|
afterName1089,
|
|
MACHINE.params.currentErrorHandler);
|
|
} else {
|
|
afterName1089();
|
|
}
|
|
});
|
|
(function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start1696 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start1696;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1634, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/image/private/color.rkt"]=new RUNTIME.ModuleRecord("color", _moduleEntry1648);
|
|
return (_afterModuleBody1647)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry71 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry71;
|
|
}
|
|
if (! RUNTIME.isArityMatching(((MACHINE.proc).closedVals[(MACHINE.proc).closedVals.length - 1 - 0]).arity, MACHINE.argcount)) { return (_notMatch1635)(MACHINE); }
|
|
MACHINE.proc = (MACHINE.proc).closedVals[(MACHINE.proc).closedVals.length - 1 - 0];
|
|
return (_lamEntry72)(MACHINE);
|
|
};
|
|
|
|
var _notMatch1635 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _notMatch1635;
|
|
}
|
|
if (! RUNTIME.isArityMatching(((MACHINE.proc).closedVals[(MACHINE.proc).closedVals.length - 1 - 1]).arity, MACHINE.argcount)) { return (_notMatch1636)(MACHINE); }
|
|
MACHINE.proc = (MACHINE.proc).closedVals[(MACHINE.proc).closedVals.length - 1 - 1];
|
|
return (_lamEntry73)(MACHINE);
|
|
};
|
|
|
|
var _notMatch1636 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _notMatch1636;
|
|
}
|
|
|
|
};
|
|
|
|
var _lamEntry72 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry72;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 4][1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.val = 255;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1637)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (4 + 4), 4);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1637 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1637;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry73 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry73;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 4][1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
MACHINE.argcount = 4;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1642)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (4 + 5), 5);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1642 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1642;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies1632 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies1632;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1634, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/image/private/color.rkt"]=new RUNTIME.ModuleRecord("color", _moduleEntry1648);
|
|
return (_afterModuleBody1647)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry1648 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry1648;
|
|
}
|
|
MACHINE.modules["whalesong/image/private/color.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/lang/base.rkt"] !== undefined) !== false) { return (_linked1649)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/lang/base.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1650)(MACHINE);
|
|
};
|
|
|
|
var _linked1649 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1649;
|
|
}
|
|
if (MACHINE.modules["whalesong/lang/base.rkt"].isInvoked !== false) { return (_alreadyLoaded1650)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1652, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/lang/base.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1651 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1651;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1652)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1652 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1652;
|
|
}
|
|
MACHINE.env.push([MACHINE.params.currentNamespace["struct:color"] || MACHINE.primitives["struct:color"],MACHINE.params.currentNamespace["make-color"] || MACHINE.primitives["make-color"],MACHINE.params.currentNamespace["color?"] || MACHINE.primitives["color?"],MACHINE.params.currentNamespace["color-red"] || MACHINE.primitives["color-red"],MACHINE.params.currentNamespace["color-green"] || MACHINE.primitives["color-green"],MACHINE.params.currentNamespace["color-blue"] || MACHINE.primitives["color-blue"],MACHINE.params.currentNamespace["color-alpha"] || MACHINE.primitives["color-alpha"],MACHINE.params.currentNamespace["-color"] || MACHINE.primitives["-color"]]); MACHINE.env[MACHINE.env.length-1].names = ["struct:color","make-color","color?","color-red","color-green","color-blue","color-alpha","-color"];
|
|
MACHINE.modules["whalesong/image/private/color.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1654, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = MACHINE.primitives["make-struct-type"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = RUNTIME.makeSymbol("color");
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 4;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = RUNTIME.NULL;
|
|
|
|
MACHINE.proc = MACHINE.primitives["current-inspector"];
|
|
MACHINE.argcount = 0;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1657)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1661, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1650 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1650;
|
|
}
|
|
MACHINE.env.push([MACHINE.params.currentNamespace["struct:color"] || MACHINE.primitives["struct:color"],MACHINE.params.currentNamespace["make-color"] || MACHINE.primitives["make-color"],MACHINE.params.currentNamespace["color?"] || MACHINE.primitives["color?"],MACHINE.params.currentNamespace["color-red"] || MACHINE.primitives["color-red"],MACHINE.params.currentNamespace["color-green"] || MACHINE.primitives["color-green"],MACHINE.params.currentNamespace["color-blue"] || MACHINE.primitives["color-blue"],MACHINE.params.currentNamespace["color-alpha"] || MACHINE.primitives["color-alpha"],MACHINE.params.currentNamespace["-color"] || MACHINE.primitives["-color"]]); MACHINE.env[MACHINE.env.length-1].names = ["struct:color","make-color","color?","color-red","color-green","color-blue","color-alpha","-color"];
|
|
MACHINE.modules["whalesong/image/private/color.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1654, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = MACHINE.primitives["make-struct-type"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = RUNTIME.makeSymbol("color");
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 4;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = RUNTIME.NULL;
|
|
|
|
MACHINE.proc = MACHINE.primitives["current-inspector"];
|
|
MACHINE.argcount = 0;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1657)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1661, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1660 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1660;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1661)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1661 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1661;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
return (_afterCall1659)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1657 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1657;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
return (_afterCall1659)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1659 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1659;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = RUNTIME.makePair(0, RUNTIME.makePair(1, RUNTIME.makePair(2, RUNTIME.makePair(3, RUNTIME.NULL))));
|
|
MACHINE.env[MACHINE.env.length - 1 - 9] = false;
|
|
MACHINE.val = RUNTIME.makeSymbol("color");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = MACHINE.val;
|
|
MACHINE.argcount = 11;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1662)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1666, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1665 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1665;
|
|
}
|
|
if ((MACHINE.argcount - 5) === 0) { return (_afterValueCheck1667)(MACHINE); }
|
|
return (_procReturn1666)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1666 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1666;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 5);
|
|
return (_afterValueCheck1667)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck1667 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck1667;
|
|
}
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.primitives["values"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 0;
|
|
MACHINE.val = RUNTIME.makeSymbol("red");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1668)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1672, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1662 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1662;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.argcount = 1;
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 5);
|
|
return (_afterCall1664)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1664 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1664;
|
|
}
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.primitives["values"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 0;
|
|
MACHINE.val = RUNTIME.makeSymbol("red");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1668)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1672, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1671 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1671;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1672)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1672 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1672;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall1670)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1668 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1668;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall1670)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1670 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1670;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.val = RUNTIME.makeSymbol("green");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1673)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1677, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1676 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1676;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1677)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1677 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1677;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
return (_afterCall1675)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1673 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1673;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
return (_afterCall1675)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1675 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1675;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 2;
|
|
MACHINE.val = RUNTIME.makeSymbol("blue");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1678)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1682, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1681 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1681;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1682)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1682 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1682;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
return (_afterCall1680)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1678 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1678;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
return (_afterCall1680)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1680 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1680;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.primitives["make-struct-field-accessor"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 3;
|
|
MACHINE.val = RUNTIME.makeSymbol("alpha");
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1683)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1687, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1686 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1686;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1687)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1687 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1687;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
MACHINE.argcount = 7;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1688)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1692, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1683 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1683;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1685)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1685 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1685;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
MACHINE.argcount = 7;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1688)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1692, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1691 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1691;
|
|
}
|
|
if ((MACHINE.argcount - 7) === 0) { return (_afterValueCheck1693)(MACHINE); }
|
|
return (_procReturn1692)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1692 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1692;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 7);
|
|
return (_afterValueCheck1693)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck1693 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck1693;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((7 - 1) + 5), 5);
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][0] = MACHINE.val;
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][1] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][2] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][3] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][4] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][5] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][6] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1688 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1688;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.argcount = 1;
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 7);
|
|
return (_afterCall1690)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1690 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1690;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((7 - 1) + 5), 5);
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][0] = MACHINE.val;
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][1] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][2] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][3] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][4] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][5] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][6] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1653 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1653;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1654)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1654 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1654;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1695, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=new RUNTIME.Closure(_lamEntry72, 3, [MACHINE.env[MACHINE.env.length - 1 - 2]], "...rivate/color.rkt:12:4");
|
|
MACHINE.env[MACHINE.env.length - 1 - 1]=new RUNTIME.Closure(_lamEntry73, 4, [MACHINE.env[MACHINE.env.length - 1 - 2]], "...rivate/color.rkt:14:4");
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry71, RUNTIME.makePair(3, RUNTIME.makePair(4, RUNTIME.NULL)), [MACHINE.env[MACHINE.env.length - 1 - 1], MACHINE.env[MACHINE.env.length - 1 - 0]], "-color");
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][7] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1694 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1694;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1695)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1695 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1695;
|
|
}
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
MACHINE.modules["whalesong/image/private/color.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterModuleBody1647 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody1647;
|
|
}
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple1633 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple1633;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt1634)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt1634 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt1634;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn1652.multipleValueReturn = _onReturnMultiple1651;
|
|
_procReturn1661.multipleValueReturn = _procReturnMultiple1660;
|
|
_procReturn1666.multipleValueReturn = _procReturnMultiple1665;
|
|
_procReturn1672.multipleValueReturn = _procReturnMultiple1671;
|
|
_procReturn1677.multipleValueReturn = _procReturnMultiple1676;
|
|
_procReturn1682.multipleValueReturn = _procReturnMultiple1681;
|
|
_procReturn1687.multipleValueReturn = _procReturnMultiple1686;
|
|
_procReturn1692.multipleValueReturn = _procReturnMultiple1691;
|
|
_beforePromptPop1654.multipleValueReturn = _beforePromptPopMultiple1653;
|
|
_beforePromptPop1695.multipleValueReturn = _beforePromptPopMultiple1694;
|
|
_beforePopPrompt1634.multipleValueReturn = _beforePopPromptMultiple1633;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start1696); })(MACHINE, function() { (function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start1706 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start1706;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1699, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/lang/base.rkt"]=new RUNTIME.ModuleRecord("base", _moduleEntry1701);
|
|
return (_afterModuleBody1700)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies1697 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies1697;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1699, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/lang/base.rkt"]=new RUNTIME.ModuleRecord("base", _moduleEntry1701);
|
|
return (_afterModuleBody1700)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry1701 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry1701;
|
|
}
|
|
MACHINE.modules["whalesong/lang/base.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["collects/racket/private/modbeg.rkt"] !== undefined) !== false) { return (_linked1702)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module collects/racket/private/modbeg.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1703)(MACHINE);
|
|
};
|
|
|
|
var _linked1702 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1702;
|
|
}
|
|
if (MACHINE.modules["collects/racket/private/modbeg.rkt"].isInvoked !== false) { return (_alreadyLoaded1703)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1705, MACHINE.proc));
|
|
return (MACHINE.modules["collects/racket/private/modbeg.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1704 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1704;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1705)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1705 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1705;
|
|
}
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.modules["whalesong/lang/base.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
MACHINE.modules["whalesong/lang/base.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1703 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1703;
|
|
}
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.modules["whalesong/lang/base.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
MACHINE.modules["whalesong/lang/base.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterModuleBody1700 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody1700;
|
|
}
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple1698 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple1698;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt1699)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt1699 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt1699;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn1705.multipleValueReturn = _onReturnMultiple1704;
|
|
_beforePopPrompt1699.multipleValueReturn = _beforePopPromptMultiple1698;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start1706); })(MACHINE, function() { (function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start1729 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start1729;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1709, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["collects/racket/private/modbeg.rkt"]=new RUNTIME.ModuleRecord("modbeg", _moduleEntry1726);
|
|
return (_afterModuleBody1725)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry74 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry74;
|
|
}
|
|
RUNTIME.unspliceRestFromStack(MACHINE, 0, (MACHINE.argcount - 0));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.primitives["for-each"];
|
|
|
|
MACHINE.proc = MACHINE.primitives["current-print"];
|
|
MACHINE.argcount = 0;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1710)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1714, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1713 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1713;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1714)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1714 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1714;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1712)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1710 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1710;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1712)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1712 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1712;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1715)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1719, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1718 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1718;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1719)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1719 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1719;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.primitives["apply"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.primitives["values"];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1720)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (2 + 1), 1);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1715 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1715;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1717)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1717 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1717;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.primitives["apply"];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.primitives["values"];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1720)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - (2 + 1), 1);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1720 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1720;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies1707 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies1707;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1709, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["collects/racket/private/modbeg.rkt"]=new RUNTIME.ModuleRecord("modbeg", _moduleEntry1726);
|
|
return (_afterModuleBody1725)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry1726 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry1726;
|
|
}
|
|
MACHINE.modules["collects/racket/private/modbeg.rkt"].isInvoked = true;
|
|
MACHINE.env.push([MACHINE.params.currentNamespace["print-values"] || MACHINE.primitives["print-values"]]); MACHINE.env[MACHINE.env.length-1].names = ["print-values"];
|
|
MACHINE.modules["collects/racket/private/modbeg.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1728, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry74, (RUNTIME.makeArityAtLeast(0)), [], "print-values");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1727 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1727;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1728)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1728 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1728;
|
|
}
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
MACHINE.modules["collects/racket/private/modbeg.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterModuleBody1725 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody1725;
|
|
}
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple1708 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple1708;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt1709)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt1709 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt1709;
|
|
}
|
|
|
|
};
|
|
|
|
_procReturn1714.multipleValueReturn = _procReturnMultiple1713;
|
|
_procReturn1719.multipleValueReturn = _procReturnMultiple1718;
|
|
_beforePromptPop1728.multipleValueReturn = _beforePromptPopMultiple1727;
|
|
_beforePopPrompt1709.multipleValueReturn = _beforePopPromptMultiple1708;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start1729); })(MACHINE, function() { (function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start1743 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start1743;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1732, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/image.rkt"]=new RUNTIME.ModuleRecord("image", _moduleEntry1734);
|
|
return (_afterModuleBody1733)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies1730 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies1730;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1732, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/image.rkt"]=new RUNTIME.ModuleRecord("image", _moduleEntry1734);
|
|
return (_afterModuleBody1733)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry1734 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry1734;
|
|
}
|
|
MACHINE.modules["whalesong/image.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/lang/base.rkt"] !== undefined) !== false) { return (_linked1735)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/lang/base.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1736)(MACHINE);
|
|
};
|
|
|
|
var _linked1735 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1735;
|
|
}
|
|
if (MACHINE.modules["whalesong/lang/base.rkt"].isInvoked !== false) { return (_alreadyLoaded1736)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1738, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/lang/base.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1737 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1737;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1738)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1738 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1738;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/main.rkt"] !== undefined) !== false) { return (_linked1739)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1740)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1736 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1736;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/main.rkt"] !== undefined) !== false) { return (_linked1739)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1740)(MACHINE);
|
|
};
|
|
|
|
var _linked1739 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1739;
|
|
}
|
|
if (MACHINE.modules["whalesong/image/main.rkt"].isInvoked !== false) { return (_alreadyLoaded1740)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1742, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/image/main.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1741 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1741;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1742)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1742 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1742;
|
|
}
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.modules["whalesong/image.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
MACHINE.modules["whalesong/image.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1740 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1740;
|
|
}
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.modules["whalesong/image.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
MACHINE.modules["whalesong/image.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterModuleBody1733 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody1733;
|
|
}
|
|
MACHINE.val = MACHINE.val;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPromptMultiple1731 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple1731;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt1732)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt1732 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt1732;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn1738.multipleValueReturn = _onReturnMultiple1737;
|
|
_onReturn1742.multipleValueReturn = _onReturnMultiple1741;
|
|
_beforePopPrompt1732.multipleValueReturn = _beforePopPromptMultiple1731;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start1743); })(MACHINE, function() { plt.runtime.setReadyTrue();SUCCESS(); }, FAIL, PARAMS); }, FAIL, PARAMS); }, FAIL, PARAMS); }, FAIL, PARAMS); }, FAIL, PARAMS); }, FAIL, PARAMS); }, FAIL, PARAMS); }, FAIL, PARAMS); });});
|
|
]]>
|
|
<![CDATA[
|
|
var invokeMainModule = function() {
|
|
var MACHINE = plt.runtime.currentMachine;
|
|
invoke(MACHINE,
|
|
function() {
|
|
plt.runtime.invokeMains(
|
|
MACHINE,
|
|
function() {
|
|
// On main module invokation success
|
|
},
|
|
function(MACHINE, e) {
|
|
// On main module invokation failure
|
|
if (console && console.log) {
|
|
console.log(e.stack || e);
|
|
}
|
|
MACHINE.params.currentErrorDisplayer(
|
|
MACHINE, $(plt.baselib.format.toDomNode(e.stack || e)).css('color', 'red'));
|
|
})},
|
|
function() {
|
|
// On module loading failure
|
|
if (console && console.log) {
|
|
console.log(e.stack || e);
|
|
}
|
|
},
|
|
{});
|
|
};
|
|
|
|
$(document).ready(invokeMainModule);
|
|
]]>
|
|
</script>
|
|
<body></body>
|
|
</html>
|