56737 lines
2.0 MiB
56737 lines
2.0 MiB
<!DOCTYPE html>
|
|
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
|
|
<head>
|
|
<meta charset="utf-8"/>
|
|
<title>Pacman</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 _start2780 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start2780;
|
|
}
|
|
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/pacman.rkt"]=new RUNTIME.ModuleRecord("pacman", _moduleEntry2282);
|
|
return (_afterModuleBody2281)(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.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 4])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 1][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 1][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch153)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch153 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch153;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=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.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 15];
|
|
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.val = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
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 (_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 - 2] = 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 - 2] = MACHINE.val;
|
|
return (_afterCall164)(MACHINE);
|
|
};
|
|
|
|
var _afterCall164 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall164;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
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 (_primitiveBranch167)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn171, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple170 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple170;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn171)(MACHINE);
|
|
};
|
|
|
|
var _procReturn171 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn171;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall169)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch167 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch167;
|
|
}
|
|
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 (_afterCall169)(MACHINE);
|
|
};
|
|
|
|
var _afterCall169 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall169;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 3][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 3][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch175)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 9;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch175 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch175;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
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 - 13];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 17];
|
|
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 - 0] = 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 - 0] = MACHINE.val;
|
|
return (_afterCall181)(MACHINE);
|
|
};
|
|
|
|
var _afterCall181 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall181;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
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 (_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.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall186)(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;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall186)(MACHINE);
|
|
};
|
|
|
|
var _afterCall186 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall186;
|
|
}
|
|
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 (_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.control.push(new RUNTIME.CallFrame(_procReturn193, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple192 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple192;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn193)(MACHINE);
|
|
};
|
|
|
|
var _procReturn193 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn193;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall191)(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[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall191)(MACHINE);
|
|
};
|
|
|
|
var _afterCall191 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall191;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 5][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 5][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch197)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 11;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch197 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch197;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
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 - 15];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 17];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 19];
|
|
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 (_primitiveBranch201)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn205, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple204 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple204;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn205)(MACHINE);
|
|
};
|
|
|
|
var _procReturn205 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn205;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall203)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch201 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch201;
|
|
}
|
|
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 (_afterCall203)(MACHINE);
|
|
};
|
|
|
|
var _afterCall203 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall203;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
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 (_primitiveBranch206)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn210, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple209 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple209;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn210)(MACHINE);
|
|
};
|
|
|
|
var _procReturn210 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn210;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall208)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch206 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch206;
|
|
}
|
|
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 (_afterCall208)(MACHINE);
|
|
};
|
|
|
|
var _afterCall208 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall208;
|
|
}
|
|
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 (_primitiveBranch211)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn215, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple214 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple214;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn215)(MACHINE);
|
|
};
|
|
|
|
var _procReturn215 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn215;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall213)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch211 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch211;
|
|
}
|
|
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 (_afterCall213)(MACHINE);
|
|
};
|
|
|
|
var _afterCall213 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall213;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 7][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 7][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch219)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 13;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch219 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch219;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 12][99];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 15];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7])) ? (MACHINE.env[MACHINE.env.length - 1 - 7]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7])));
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 17];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 18];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 21];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 18][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 20][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 23];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 25];
|
|
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 (_primitiveBranch221)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn225, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple224 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple224;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn225)(MACHINE);
|
|
};
|
|
|
|
var _procReturn225 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn225;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall223)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch221 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch221;
|
|
}
|
|
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 (_afterCall223)(MACHINE);
|
|
};
|
|
|
|
var _afterCall223 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall223;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
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 (_primitiveBranch226)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn230, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple229 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple229;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn230)(MACHINE);
|
|
};
|
|
|
|
var _procReturn230 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn230;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall228)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch226 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch226;
|
|
}
|
|
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 (_afterCall228)(MACHINE);
|
|
};
|
|
|
|
var _afterCall228 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall228;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
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 (_primitiveBranch231)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn235, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple234 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple234;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn235)(MACHINE);
|
|
};
|
|
|
|
var _procReturn235 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn235;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch236)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (6 + 13), 13);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch231 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch231;
|
|
}
|
|
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 (_afterCall233)(MACHINE);
|
|
};
|
|
|
|
var _afterCall233 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall233;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch236)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (6 + 13), 13);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch236 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch236;
|
|
}
|
|
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 - 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 - 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);
|
|
};
|
|
|
|
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.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5])) ? (MACHINE.env[MACHINE.env.length - 1 - 5]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 5])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 2][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch242)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch242 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch242;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.val=((plt.baselib.numbers.equals(0,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 3][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 3][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch247)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
return (_afterIf248)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch247 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch247;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 9][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
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 (_primitiveBranch249)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn253, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple252 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple252;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn253)(MACHINE);
|
|
};
|
|
|
|
var _procReturn253 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn253;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall251)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch249 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch249;
|
|
}
|
|
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 (_afterCall251)(MACHINE);
|
|
};
|
|
|
|
var _afterCall251 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall251;
|
|
}
|
|
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 (_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;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall256)(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;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall256)(MACHINE);
|
|
};
|
|
|
|
var _afterCall256 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall256;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
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 (_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 - 0] = 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 - 0] = MACHINE.val;
|
|
return (_afterCall261)(MACHINE);
|
|
};
|
|
|
|
var _afterCall261 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall261;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(1,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 4][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 4][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch267)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
return (_afterIf268)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch267 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch267;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 9][99];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 2;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 14];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 18];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 15][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 17][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 21];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 22];
|
|
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 (_primitiveBranch269)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn273, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple272 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple272;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn273)(MACHINE);
|
|
};
|
|
|
|
var _procReturn273 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn273;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall271)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch269 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch269;
|
|
}
|
|
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 (_afterCall271)(MACHINE);
|
|
};
|
|
|
|
var _afterCall271 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall271;
|
|
}
|
|
MACHINE.val = 1;
|
|
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 (_primitiveBranch274)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn278, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple277 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple277;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn278)(MACHINE);
|
|
};
|
|
|
|
var _procReturn278 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn278;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall276)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch274 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch274;
|
|
}
|
|
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 (_afterCall276)(MACHINE);
|
|
};
|
|
|
|
var _afterCall276 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall276;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
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 (_primitiveBranch279)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn283, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple282 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple282;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn283)(MACHINE);
|
|
};
|
|
|
|
var _procReturn283 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn283;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch284)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn288, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch279 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch279;
|
|
}
|
|
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 (_afterCall281)(MACHINE);
|
|
};
|
|
|
|
var _afterCall281 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall281;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch284)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn288, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple287 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple287;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn288)(MACHINE);
|
|
};
|
|
|
|
var _procReturn288 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn288;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall286)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch284 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch284;
|
|
}
|
|
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 (_afterCall286)(MACHINE);
|
|
};
|
|
|
|
var _afterCall286 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall286;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf248)(MACHINE);
|
|
};
|
|
|
|
var _afterIf268 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf268;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf248)(MACHINE);
|
|
};
|
|
|
|
var _afterIf248 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf248;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 4][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 4][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch292)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 9;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch292 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch292;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.val=((plt.baselib.numbers.equals(0,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 5][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 5][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch297)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
return (_afterIf298)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch297 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch297;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 10][99];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 14];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 17];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 16][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 18][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 22];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 17];
|
|
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 (_primitiveBranch299)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn303, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple302 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple302;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn303)(MACHINE);
|
|
};
|
|
|
|
var _procReturn303 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn303;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall301)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch299 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch299;
|
|
}
|
|
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 (_afterCall301)(MACHINE);
|
|
};
|
|
|
|
var _afterCall301 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall301;
|
|
}
|
|
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 (_primitiveBranch304)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn308, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple307 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple307;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn308)(MACHINE);
|
|
};
|
|
|
|
var _procReturn308 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn308;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall306)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch304 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch304;
|
|
}
|
|
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 (_afterCall306)(MACHINE);
|
|
};
|
|
|
|
var _afterCall306 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall306;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
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 (_primitiveBranch309)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn313, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple312 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple312;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn313)(MACHINE);
|
|
};
|
|
|
|
var _procReturn313 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn313;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch314)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn318, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch309 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch309;
|
|
}
|
|
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 (_afterCall311)(MACHINE);
|
|
};
|
|
|
|
var _afterCall311 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall311;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch314)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn318, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple317 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple317;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn318)(MACHINE);
|
|
};
|
|
|
|
var _procReturn318 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn318;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall316)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch314 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch314;
|
|
}
|
|
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 (_afterCall316)(MACHINE);
|
|
};
|
|
|
|
var _afterCall316 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall316;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 6][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch322)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 11;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterIf298 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf298;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 6][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch322)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 11;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch322 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch322;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 12][99];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 15];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch326)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn330, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple329 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple329;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn330)(MACHINE);
|
|
};
|
|
|
|
var _procReturn330 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn330;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall328)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch326 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch326;
|
|
}
|
|
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 (_afterCall328)(MACHINE);
|
|
};
|
|
|
|
var _afterCall328 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall328;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 8][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 8][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 8][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch334)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 13;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch334 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch334;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 14][99];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 15];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 17];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 18];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch338)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn342, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple341 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple341;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn342)(MACHINE);
|
|
};
|
|
|
|
var _procReturn342 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn342;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall340)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch338 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch338;
|
|
}
|
|
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 (_afterCall340)(MACHINE);
|
|
};
|
|
|
|
var _afterCall340 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall340;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 10][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 10][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 10][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch346)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 15;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch346 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch346;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 14][98];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 15];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 17];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 18];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7])) ? (MACHINE.env[MACHINE.env.length - 1 - 7]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7])));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 20][99];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 21];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 23];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 24];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch348)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn352, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple351 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple351;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn352)(MACHINE);
|
|
};
|
|
|
|
var _procReturn352 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn352;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch353)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (6 + 15), 15);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch348 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch348;
|
|
}
|
|
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 (_afterCall350)(MACHINE);
|
|
};
|
|
|
|
var _afterCall350 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall350;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch353)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (6 + 15), 15);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch353 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch353;
|
|
}
|
|
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 - 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 - 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);
|
|
};
|
|
|
|
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=((plt.baselib.numbers.lessThan(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 4])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2])))));
|
|
if (MACHINE.val === false) { return (_falseBranch359)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][81];
|
|
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 - 7];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6]);
|
|
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 (_primitiveBranch361)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn365, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple364 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple364;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn365)(MACHINE);
|
|
};
|
|
|
|
var _procReturn365 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn365;
|
|
}
|
|
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 (_primitiveBranch366)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn370, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch361 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch361;
|
|
}
|
|
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 (_afterCall363)(MACHINE);
|
|
};
|
|
|
|
var _afterCall363 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall363;
|
|
}
|
|
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 (_primitiveBranch366)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn370, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple369 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple369;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn370)(MACHINE);
|
|
};
|
|
|
|
var _procReturn370 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn370;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=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.val=((plt.baselib.numbers.lessThan(((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 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 3])))));
|
|
if (MACHINE.val === false) { return (_falseBranch374)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 4][81];
|
|
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 - 3];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 7]);
|
|
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 (_primitiveBranch376)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn380, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch366 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch366;
|
|
}
|
|
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 (_afterCall368)(MACHINE);
|
|
};
|
|
|
|
var _afterCall368 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall368;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=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.val=((plt.baselib.numbers.lessThan(((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 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 3])))));
|
|
if (MACHINE.val === false) { return (_falseBranch374)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 4][81];
|
|
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 - 3];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 7]);
|
|
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 (_primitiveBranch376)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn380, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple379 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple379;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn380)(MACHINE);
|
|
};
|
|
|
|
var _procReturn380 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn380;
|
|
}
|
|
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 (_primitiveBranch381)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn385, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch376 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch376;
|
|
}
|
|
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 (_afterCall378)(MACHINE);
|
|
};
|
|
|
|
var _afterCall378 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall378;
|
|
}
|
|
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 (_primitiveBranch381)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn385, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple384 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple384;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn385)(MACHINE);
|
|
};
|
|
|
|
var _procReturn385 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn385;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])));
|
|
MACHINE.val=((plt.baselib.numbers.lessThan(((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 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 4])))));
|
|
if (MACHINE.val === false) { return (_falseBranch389)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 5][81];
|
|
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 - 3];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 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 (_primitiveBranch391)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn395, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch381 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch381;
|
|
}
|
|
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 (_afterCall383)(MACHINE);
|
|
};
|
|
|
|
var _afterCall383 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall383;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])));
|
|
MACHINE.val=((plt.baselib.numbers.lessThan(((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 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 4])))));
|
|
if (MACHINE.val === false) { return (_falseBranch389)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 5][81];
|
|
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 - 3];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 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 (_primitiveBranch391)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn395, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple394 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple394;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn395)(MACHINE);
|
|
};
|
|
|
|
var _procReturn395 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn395;
|
|
}
|
|
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 (_primitiveBranch396)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn400, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch391 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch391;
|
|
}
|
|
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 (_afterCall393)(MACHINE);
|
|
};
|
|
|
|
var _afterCall393 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall393;
|
|
}
|
|
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 (_primitiveBranch396)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn400, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple399 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple399;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn400)(MACHINE);
|
|
};
|
|
|
|
var _procReturn400 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn400;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])));
|
|
MACHINE.val=((plt.baselib.numbers.lessThan(((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 - 5])) ? (MACHINE.env[MACHINE.env.length - 1 - 5]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 5])))));
|
|
if (MACHINE.val === false) { return (_falseBranch404)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 6][81];
|
|
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 - 3];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 9]);
|
|
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 (_primitiveBranch406)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn410, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch396 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch396;
|
|
}
|
|
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 (_afterCall398)(MACHINE);
|
|
};
|
|
|
|
var _afterCall398 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall398;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])));
|
|
MACHINE.val=((plt.baselib.numbers.lessThan(((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 - 5])) ? (MACHINE.env[MACHINE.env.length - 1 - 5]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 5])))));
|
|
if (MACHINE.val === false) { return (_falseBranch404)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 6][81];
|
|
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 - 3];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 9]);
|
|
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 (_primitiveBranch406)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn410, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple409 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple409;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn410)(MACHINE);
|
|
};
|
|
|
|
var _procReturn410 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn410;
|
|
}
|
|
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 (_primitiveBranch411)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn415, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch406 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch406;
|
|
}
|
|
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 (_afterCall408)(MACHINE);
|
|
};
|
|
|
|
var _afterCall408 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall408;
|
|
}
|
|
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 (_primitiveBranch411)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn415, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple414 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple414;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn415)(MACHINE);
|
|
};
|
|
|
|
var _procReturn415 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn415;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 7][97];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.val=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 4])));
|
|
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 (_primitiveBranch416)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 + 8), 8);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch411 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch411;
|
|
}
|
|
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 (_afterCall413)(MACHINE);
|
|
};
|
|
|
|
var _afterCall413 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall413;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 7][97];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.val=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 4])));
|
|
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 (_primitiveBranch416)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 + 8), 8);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch416 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch416;
|
|
}
|
|
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 - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch404 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch404;
|
|
}
|
|
MACHINE.val = RUNTIME.VOID;
|
|
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 - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch389 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch389;
|
|
}
|
|
MACHINE.val = RUNTIME.VOID;
|
|
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 - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch374 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch374;
|
|
}
|
|
MACHINE.val = RUNTIME.VOID;
|
|
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);
|
|
};
|
|
|
|
var _falseBranch359 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch359;
|
|
}
|
|
MACHINE.val = RUNTIME.VOID;
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
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.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 3])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 1][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 1][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch422)(MACHINE); }
|
|
MACHINE.val = 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 _falseBranch422 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch422;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 4])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 5][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
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 (_primitiveBranch426)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn430, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple429 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple429;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn430)(MACHINE);
|
|
};
|
|
|
|
var _procReturn430 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn430;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall428)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch426 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch426;
|
|
}
|
|
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 (_afterCall428)(MACHINE);
|
|
};
|
|
|
|
var _afterCall428 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall428;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
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 (_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;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall433)(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;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall433)(MACHINE);
|
|
};
|
|
|
|
var _afterCall433 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall433;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "empty";
|
|
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 (_primitiveBranch441)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn445, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple444 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple444;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn445)(MACHINE);
|
|
};
|
|
|
|
var _procReturn445 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn445;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch439)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][17];
|
|
return (_afterIf440)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch441 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch441;
|
|
}
|
|
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 (_afterCall443)(MACHINE);
|
|
};
|
|
|
|
var _afterCall443 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall443;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch439)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][17];
|
|
return (_afterIf440)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch439 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch439;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "dot";
|
|
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;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch447)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][19];
|
|
return (_afterIf448)(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;
|
|
return (_afterCall451)(MACHINE);
|
|
};
|
|
|
|
var _afterCall451 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall451;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch447)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][19];
|
|
return (_afterIf448)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch447 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch447;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch457)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn461, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple460 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple460;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn461)(MACHINE);
|
|
};
|
|
|
|
var _procReturn461 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn461;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch455)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][21];
|
|
return (_afterIf456)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch457 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch457;
|
|
}
|
|
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 (_afterCall459)(MACHINE);
|
|
};
|
|
|
|
var _afterCall459 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall459;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch455)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][21];
|
|
return (_afterIf456)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch455 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch455;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = RUNTIME.VOID;
|
|
return (_afterIf456)(MACHINE);
|
|
};
|
|
|
|
var _afterIf456 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf456;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 8][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 13])) ? (MACHINE.env[MACHINE.env.length - 1 - 13]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 13])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 14])) ? (MACHINE.env[MACHINE.env.length - 1 - 14]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 14])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
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 (_primitiveBranch464)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn468, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _afterIf448 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf448;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 8][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 13])) ? (MACHINE.env[MACHINE.env.length - 1 - 13]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 13])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 14])) ? (MACHINE.env[MACHINE.env.length - 1 - 14]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 14])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
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 (_primitiveBranch464)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn468, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _afterIf440 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf440;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 8][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 13])) ? (MACHINE.env[MACHINE.env.length - 1 - 13]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 13])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 14])) ? (MACHINE.env[MACHINE.env.length - 1 - 14]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 14])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
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 (_primitiveBranch464)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn468, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple467 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple467;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn468)(MACHINE);
|
|
};
|
|
|
|
var _procReturn468 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn468;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall466)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch464 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch464;
|
|
}
|
|
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 (_afterCall466)(MACHINE);
|
|
};
|
|
|
|
var _afterCall466 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall466;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 3][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 3][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch472)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch472 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch472;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 7][96];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6])));
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 14];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
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 (_primitiveBranch474)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn478, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple477 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple477;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn478)(MACHINE);
|
|
};
|
|
|
|
var _procReturn478 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn478;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall476)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch474 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch474;
|
|
}
|
|
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 (_afterCall476)(MACHINE);
|
|
};
|
|
|
|
var _afterCall476 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall476;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
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 (_primitiveBranch479)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn483, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple482 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple482;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn483)(MACHINE);
|
|
};
|
|
|
|
var _procReturn483 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn483;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall481)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch479 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch479;
|
|
}
|
|
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 (_afterCall481)(MACHINE);
|
|
};
|
|
|
|
var _afterCall481 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall481;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "empty";
|
|
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 (_primitiveBranch489)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn493, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple492 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple492;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn493)(MACHINE);
|
|
};
|
|
|
|
var _procReturn493 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn493;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch487)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][17];
|
|
return (_afterIf488)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch489 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch489;
|
|
}
|
|
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 (_afterCall491)(MACHINE);
|
|
};
|
|
|
|
var _afterCall491 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall491;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch487)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][17];
|
|
return (_afterIf488)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch487 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch487;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "dot";
|
|
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;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch495)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][19];
|
|
return (_afterIf496)(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;
|
|
return (_afterCall499)(MACHINE);
|
|
};
|
|
|
|
var _afterCall499 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall499;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch495)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][19];
|
|
return (_afterIf496)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch495 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch495;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch505)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn509, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple508 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple508;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn509)(MACHINE);
|
|
};
|
|
|
|
var _procReturn509 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn509;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch503)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][21];
|
|
return (_afterIf504)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch505 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch505;
|
|
}
|
|
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 (_afterCall507)(MACHINE);
|
|
};
|
|
|
|
var _afterCall507 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall507;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch503)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][21];
|
|
return (_afterIf504)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch503 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch503;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = RUNTIME.VOID;
|
|
return (_afterIf504)(MACHINE);
|
|
};
|
|
|
|
var _afterIf504 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf504;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 13][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 14])) ? (MACHINE.env[MACHINE.env.length - 1 - 14]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 14])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 19])) ? (MACHINE.env[MACHINE.env.length - 1 - 19]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 19])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
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 (_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 _afterIf496 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf496;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 13][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 14])) ? (MACHINE.env[MACHINE.env.length - 1 - 14]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 14])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 19])) ? (MACHINE.env[MACHINE.env.length - 1 - 19]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 19])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
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 (_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 _afterIf488 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf488;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 13][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 14])) ? (MACHINE.env[MACHINE.env.length - 1 - 14]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 14])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 19])) ? (MACHINE.env[MACHINE.env.length - 1 - 19]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 19])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
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 (_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.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
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 (_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.env.splice(MACHINE.env.length - (5 + 8), 8);
|
|
MACHINE.control[MACHINE.control.length-1].proc = 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.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
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 (_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.env.splice(MACHINE.env.length - (5 + 8), 8);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(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.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 - 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);
|
|
};
|
|
|
|
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.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 4])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 1][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 1][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch523)(MACHINE); }
|
|
MACHINE.val = 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 _falseBranch523 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch523;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=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.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 7][96];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
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 (_primitiveBranch527)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn531, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple530 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple530;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn531)(MACHINE);
|
|
};
|
|
|
|
var _procReturn531 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn531;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall529)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch527 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch527;
|
|
}
|
|
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 (_afterCall529)(MACHINE);
|
|
};
|
|
|
|
var _afterCall529 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall529;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 3][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 3][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch535)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch535 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch535;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 9][96];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
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 (_primitiveBranch539)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn543, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple542 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple542;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn543)(MACHINE);
|
|
};
|
|
|
|
var _procReturn543 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn543;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall541)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch539 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch539;
|
|
}
|
|
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 (_afterCall541)(MACHINE);
|
|
};
|
|
|
|
var _afterCall541 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall541;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 5][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 5][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch547)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 10;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch547 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch547;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 11][96];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
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 (_primitiveBranch551)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn555, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple554 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple554;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn555)(MACHINE);
|
|
};
|
|
|
|
var _procReturn555 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn555;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall553)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch551 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch551;
|
|
}
|
|
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 (_afterCall553)(MACHINE);
|
|
};
|
|
|
|
var _afterCall553 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall553;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 7][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 7][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch559)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 12;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch559 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch559;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 11][95];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 14];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6])));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 16][96];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 18];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 19];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
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 (_primitiveBranch561)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn565, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple564 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple564;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn565)(MACHINE);
|
|
};
|
|
|
|
var _procReturn565 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn565;
|
|
}
|
|
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 (_primitiveBranch566)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (5 + 12), 12);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch561 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch561;
|
|
}
|
|
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 (_afterCall563)(MACHINE);
|
|
};
|
|
|
|
var _afterCall563 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall563;
|
|
}
|
|
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 (_primitiveBranch566)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (5 + 12), 12);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch566 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch566;
|
|
}
|
|
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);
|
|
};
|
|
|
|
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.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 3])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 1][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 1][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch572)(MACHINE); }
|
|
MACHINE.val = 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 _falseBranch572 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch572;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 4])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 5][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
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 (_primitiveBranch576)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn580, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple579 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple579;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn580)(MACHINE);
|
|
};
|
|
|
|
var _procReturn580 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn580;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall578)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch576 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch576;
|
|
}
|
|
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 (_afterCall578)(MACHINE);
|
|
};
|
|
|
|
var _afterCall578 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall578;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
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 (_primitiveBranch581)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn585, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple584 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple584;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn585)(MACHINE);
|
|
};
|
|
|
|
var _procReturn585 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn585;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall583)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch581 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch581;
|
|
}
|
|
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 (_afterCall583)(MACHINE);
|
|
};
|
|
|
|
var _afterCall583 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall583;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
if (MACHINE.val === false) { return (_falseBranch589)(MACHINE); }
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "dot";
|
|
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 (_primitiveBranch591)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn595, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple594 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple594;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn595)(MACHINE);
|
|
};
|
|
|
|
var _procReturn595 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn595;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall593)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch591 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch591;
|
|
}
|
|
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 (_afterCall593)(MACHINE);
|
|
};
|
|
|
|
var _afterCall593 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall593;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=(MACHINE.env[MACHINE.env.length - 1 - 0] === false);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf590)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch589 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch589;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = false;
|
|
return (_afterIf590)(MACHINE);
|
|
};
|
|
|
|
var _afterIf590 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf590;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 3][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 3][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch599)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch599 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch599;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
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 (_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.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 (_primitiveBranch608)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn612, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple611 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple611;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn612)(MACHINE);
|
|
};
|
|
|
|
var _procReturn612 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn612;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall610)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch608 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch608;
|
|
}
|
|
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 (_afterCall610)(MACHINE);
|
|
};
|
|
|
|
var _afterCall610 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall610;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
if (MACHINE.val === false) { return (_falseBranch616)(MACHINE); }
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "dot";
|
|
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 (_primitiveBranch618)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn622, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple621 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple621;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn622)(MACHINE);
|
|
};
|
|
|
|
var _procReturn622 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn622;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall620)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch618 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch618;
|
|
}
|
|
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 (_afterCall620)(MACHINE);
|
|
};
|
|
|
|
var _afterCall620 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall620;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=(MACHINE.env[MACHINE.env.length - 1 - 0] === false);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf617)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch616 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch616;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = false;
|
|
return (_afterIf617)(MACHINE);
|
|
};
|
|
|
|
var _afterIf617 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf617;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 5][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 5][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch626)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 10;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch626 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch626;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 9][94];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6])));
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 18];
|
|
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 (_primitiveBranch628)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn632, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple631 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple631;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn632)(MACHINE);
|
|
};
|
|
|
|
var _procReturn632 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn632;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall630)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch628 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch628;
|
|
}
|
|
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 (_afterCall630)(MACHINE);
|
|
};
|
|
|
|
var _afterCall630 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall630;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
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 (_primitiveBranch633)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn637, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple636 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple636;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn637)(MACHINE);
|
|
};
|
|
|
|
var _procReturn637 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn637;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall635)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch633 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch633;
|
|
}
|
|
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 (_afterCall635)(MACHINE);
|
|
};
|
|
|
|
var _afterCall635 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall635;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
if (MACHINE.val === false) { return (_falseBranch641)(MACHINE); }
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 13][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "dot";
|
|
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 (_primitiveBranch643)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn647, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple646 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple646;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn647)(MACHINE);
|
|
};
|
|
|
|
var _procReturn647 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn647;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall645)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch643 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch643;
|
|
}
|
|
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 (_afterCall645)(MACHINE);
|
|
};
|
|
|
|
var _afterCall645 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall645;
|
|
}
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === false);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf642)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch641 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch641;
|
|
}
|
|
MACHINE.val = false;
|
|
return (_afterIf642)(MACHINE);
|
|
};
|
|
|
|
var _afterIf642 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf642;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
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 (_primitiveBranch648)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (5 + 10), 10);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch648 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch648;
|
|
}
|
|
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 - 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 - 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);
|
|
};
|
|
|
|
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.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 4])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 2][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch654)(MACHINE); }
|
|
MACHINE.val = 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 _falseBranch654 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch654;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=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.env.push(undefined);
|
|
MACHINE.val=((plt.baselib.numbers.equals(0,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 3][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 3][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch659)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
return (_afterIf660)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch659 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch659;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 7][94];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 15];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
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 (_primitiveBranch661)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn665, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple664 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple664;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn665)(MACHINE);
|
|
};
|
|
|
|
var _procReturn665 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn665;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall663)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch661 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch661;
|
|
}
|
|
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 (_afterCall663)(MACHINE);
|
|
};
|
|
|
|
var _afterCall663 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall663;
|
|
}
|
|
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 (_primitiveBranch666)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn670, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple669 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple669;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn670)(MACHINE);
|
|
};
|
|
|
|
var _procReturn670 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn670;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall668)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch666 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch666;
|
|
}
|
|
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 (_afterCall668)(MACHINE);
|
|
};
|
|
|
|
var _afterCall668 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall668;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
if (MACHINE.val === false) { return (_falseBranch674)(MACHINE); }
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "dot";
|
|
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 (_primitiveBranch676)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn680, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple679 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple679;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn680)(MACHINE);
|
|
};
|
|
|
|
var _procReturn680 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn680;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall678)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch676 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch676;
|
|
}
|
|
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 (_afterCall678)(MACHINE);
|
|
};
|
|
|
|
var _afterCall678 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall678;
|
|
}
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === false);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf675)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch674 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch674;
|
|
}
|
|
MACHINE.val = false;
|
|
return (_afterIf675)(MACHINE);
|
|
};
|
|
|
|
var _afterIf675 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf675;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
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 (_primitiveBranch681)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn685, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple684 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple684;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn685)(MACHINE);
|
|
};
|
|
|
|
var _procReturn685 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn685;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall683)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch681 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch681;
|
|
}
|
|
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 (_afterCall683)(MACHINE);
|
|
};
|
|
|
|
var _afterCall683 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall683;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 4][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 4][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch689)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterIf660 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf660;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 4][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 4][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch689)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch689 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch689;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 9][94];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
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 (_primitiveBranch693)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn697, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple696 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple696;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn697)(MACHINE);
|
|
};
|
|
|
|
var _procReturn697 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn697;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall695)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch693 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch693;
|
|
}
|
|
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 (_afterCall695)(MACHINE);
|
|
};
|
|
|
|
var _afterCall695 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall695;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 6][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch701)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 10;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch701 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch701;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 11][94];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
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 (_primitiveBranch705)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn709, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple708 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple708;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn709)(MACHINE);
|
|
};
|
|
|
|
var _procReturn709 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn709;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall707)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch705 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch705;
|
|
}
|
|
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 (_afterCall707)(MACHINE);
|
|
};
|
|
|
|
var _afterCall707 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall707;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 8][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 8][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 8][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch713)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 12;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch713 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch713;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 11][93];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 14];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6])));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 16][94];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 17];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 19];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
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 (_primitiveBranch715)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn719, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple718 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple718;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn719)(MACHINE);
|
|
};
|
|
|
|
var _procReturn719 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn719;
|
|
}
|
|
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 (_primitiveBranch720)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (5 + 12), 12);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch715 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch715;
|
|
}
|
|
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 (_afterCall717)(MACHINE);
|
|
};
|
|
|
|
var _afterCall717 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall717;
|
|
}
|
|
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 (_primitiveBranch720)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (5 + 12), 12);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch720 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch720;
|
|
}
|
|
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);
|
|
};
|
|
|
|
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.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 3])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 1][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 1][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch726)(MACHINE); }
|
|
MACHINE.val = 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 _falseBranch726 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch726;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 4])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 5][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
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 (_primitiveBranch730)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn734, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple733 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple733;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn734)(MACHINE);
|
|
};
|
|
|
|
var _procReturn734 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn734;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall732)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch730 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch730;
|
|
}
|
|
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 (_afterCall732)(MACHINE);
|
|
};
|
|
|
|
var _afterCall732 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall732;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
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 (_primitiveBranch735)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn739, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple738 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple738;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn739)(MACHINE);
|
|
};
|
|
|
|
var _procReturn739 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn739;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall737)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch735 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch735;
|
|
}
|
|
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 (_afterCall737)(MACHINE);
|
|
};
|
|
|
|
var _afterCall737 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall737;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
if (MACHINE.val === false) { return (_falseBranch743)(MACHINE); }
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "dot";
|
|
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 (_primitiveBranch745)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn749, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple748 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple748;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn749)(MACHINE);
|
|
};
|
|
|
|
var _procReturn749 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn749;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall747)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch745 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch745;
|
|
}
|
|
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 (_afterCall747)(MACHINE);
|
|
};
|
|
|
|
var _afterCall747 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall747;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=(MACHINE.env[MACHINE.env.length - 1 - 0] === false);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf744)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch743 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch743;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = false;
|
|
return (_afterIf744)(MACHINE);
|
|
};
|
|
|
|
var _afterIf744 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf744;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 3][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 3][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch753)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch753 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch753;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 7][92];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6])));
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 14];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
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 (_primitiveBranch755)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn759, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple758 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple758;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn759)(MACHINE);
|
|
};
|
|
|
|
var _procReturn759 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn759;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall757)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch755 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch755;
|
|
}
|
|
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 (_afterCall757)(MACHINE);
|
|
};
|
|
|
|
var _afterCall757 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall757;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
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 (_primitiveBranch760)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn764, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple763 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple763;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn764)(MACHINE);
|
|
};
|
|
|
|
var _procReturn764 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn764;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall762)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch760 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch760;
|
|
}
|
|
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 (_afterCall762)(MACHINE);
|
|
};
|
|
|
|
var _afterCall762 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall762;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
if (MACHINE.val === false) { return (_falseBranch768)(MACHINE); }
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "dot";
|
|
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 (_primitiveBranch770)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn774, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple773 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple773;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn774)(MACHINE);
|
|
};
|
|
|
|
var _procReturn774 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn774;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall772)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch770 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch770;
|
|
}
|
|
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 (_afterCall772)(MACHINE);
|
|
};
|
|
|
|
var _afterCall772 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall772;
|
|
}
|
|
MACHINE.val=(MACHINE.env[MACHINE.env.length - 1 - 0] === false);
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf769)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch768 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch768;
|
|
}
|
|
MACHINE.val = false;
|
|
return (_afterIf769)(MACHINE);
|
|
};
|
|
|
|
var _afterIf769 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf769;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
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 (_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.env.splice(MACHINE.env.length - (5 + 8), 8);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(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.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 - 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);
|
|
};
|
|
|
|
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.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 4])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 1][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 1][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch781)(MACHINE); }
|
|
MACHINE.val = 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 _falseBranch781 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch781;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=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.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 7][92];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
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 (_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 - 0] = 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 - 0] = MACHINE.val;
|
|
return (_afterCall787)(MACHINE);
|
|
};
|
|
|
|
var _afterCall787 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall787;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 3][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 3][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch793)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch793 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch793;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 9][92];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
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 (_primitiveBranch797)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn801, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple800 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple800;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn801)(MACHINE);
|
|
};
|
|
|
|
var _procReturn801 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn801;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall799)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch797 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch797;
|
|
}
|
|
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 (_afterCall799)(MACHINE);
|
|
};
|
|
|
|
var _afterCall799 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall799;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1])) ? (MACHINE.env[MACHINE.env.length - 1 - 1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 5][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 5][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch805)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 10;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch805 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch805;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 9][91];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6])));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 14][92];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 17];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
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 (_primitiveBranch807)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn811, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple810 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple810;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn811)(MACHINE);
|
|
};
|
|
|
|
var _procReturn811 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn811;
|
|
}
|
|
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 (_primitiveBranch812)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (5 + 10), 10);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch807 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch807;
|
|
}
|
|
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 (_afterCall809)(MACHINE);
|
|
};
|
|
|
|
var _afterCall809 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall809;
|
|
}
|
|
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 (_primitiveBranch812)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (5 + 10), 10);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch812 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch812;
|
|
}
|
|
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 - 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 - 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);
|
|
};
|
|
|
|
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.val=((plt.baselib.numbers.lessThan(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2])))));
|
|
if (MACHINE.val === false) { return (_falseBranch818)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][81];
|
|
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 - 9];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 4][8]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
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.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 (_primitiveBranch825)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn829, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(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;
|
|
return (_afterCall822)(MACHINE);
|
|
};
|
|
|
|
var _afterCall822 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall822;
|
|
}
|
|
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 (_primitiveBranch825)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn829, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple828 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple828;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn829)(MACHINE);
|
|
};
|
|
|
|
var _procReturn829 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn829;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall827)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch825 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch825;
|
|
}
|
|
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 (_afterCall827)(MACHINE);
|
|
};
|
|
|
|
var _afterCall827 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall827;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 5][80]);
|
|
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;
|
|
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, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.env[MACHINE.env.length - 1 - 12][90];
|
|
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 - 18];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 15];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 17];
|
|
MACHINE.val = 0;
|
|
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 (_primitiveBranch839)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn843, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple842 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple842;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn843)(MACHINE);
|
|
};
|
|
|
|
var _procReturn843 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn843;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
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 (_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 _primitiveBranch839 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch839;
|
|
}
|
|
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 (_afterCall841)(MACHINE);
|
|
};
|
|
|
|
var _afterCall841 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall841;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
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 (_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;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn848)(MACHINE);
|
|
};
|
|
|
|
var _procReturn848 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn848;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 6][89];
|
|
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[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.val=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 12])) ? (MACHINE.env[MACHINE.env.length - 1 - 12]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 12])));
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch849)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (6 + 7), 7);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(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;
|
|
return (_afterCall846)(MACHINE);
|
|
};
|
|
|
|
var _afterCall846 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall846;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 6][89];
|
|
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[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.val=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 12])) ? (MACHINE.env[MACHINE.env.length - 1 - 12]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 12])));
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch849)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (6 + 7), 7);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch849 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch849;
|
|
}
|
|
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 - 7;
|
|
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.val = RUNTIME.VOID;
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
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=((plt.baselib.numbers.lessThan(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7])) ? (MACHINE.env[MACHINE.env.length - 1 - 7]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2])))));
|
|
if (MACHINE.val === false) { return (_falseBranch855)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][81];
|
|
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 - 10];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 14];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
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 (_primitiveBranch857)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn861, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple860 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple860;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn861)(MACHINE);
|
|
};
|
|
|
|
var _procReturn861 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn861;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall859)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch857 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch857;
|
|
}
|
|
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 (_afterCall859)(MACHINE);
|
|
};
|
|
|
|
var _afterCall859 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall859;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
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 (_primitiveBranch862)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn866, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple865 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple865;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn866)(MACHINE);
|
|
};
|
|
|
|
var _procReturn866 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn866;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall864)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch862 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch862;
|
|
}
|
|
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 (_afterCall864)(MACHINE);
|
|
};
|
|
|
|
var _afterCall864 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall864;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 8])) ? (MACHINE.env[MACHINE.env.length - 1 - 8]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 8])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 11])) ? (MACHINE.env[MACHINE.env.length - 1 - 11]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 11])))));
|
|
if (MACHINE.val === false) { return (_falseBranch870)(MACHINE); }
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 9])) ? (MACHINE.env[MACHINE.env.length - 1 - 9]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 9])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7])) ? (MACHINE.env[MACHINE.env.length - 1 - 7]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 7])))));
|
|
if (MACHINE.val === false) { return (_falseBranch873)(MACHINE); }
|
|
MACHINE.val = "empty";
|
|
return (_afterIf871)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch873 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch873;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
return (_afterIf871)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch870 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch870;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
return (_afterIf871)(MACHINE);
|
|
};
|
|
|
|
var _afterIf871 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf871;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
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 (_primitiveBranch875)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn879, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple878 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple878;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn879)(MACHINE);
|
|
};
|
|
|
|
var _procReturn879 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn879;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.env[MACHINE.env.length - 1 - 7][90];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.val=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 14])) ? (MACHINE.env[MACHINE.env.length - 1 - 14]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 14])));
|
|
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 (_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.env.splice(MACHINE.env.length - (7 + 8), 8);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch875 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch875;
|
|
}
|
|
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 (_afterCall877)(MACHINE);
|
|
};
|
|
|
|
var _afterCall877 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall877;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.env[MACHINE.env.length - 1 - 7][90];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.val=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 14])) ? (MACHINE.env[MACHINE.env.length - 1 - 14]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 14])));
|
|
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 (_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.env.splice(MACHINE.env.length - (7 + 8), 8);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(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.length = MACHINE.env.length - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch855 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch855;
|
|
}
|
|
MACHINE.val = RUNTIME.VOID;
|
|
MACHINE.env.length = MACHINE.env.length - 8;
|
|
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.val=((plt.baselib.numbers.lessThan(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2])))));
|
|
if (MACHINE.val === false) { return (_falseBranch886)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][81];
|
|
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 - 9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 5][79];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 5][8]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 14];
|
|
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 (_primitiveBranch888)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn892, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple891 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple891;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn892)(MACHINE);
|
|
};
|
|
|
|
var _procReturn892 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn892;
|
|
}
|
|
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 (_primitiveBranch893)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn897, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch888 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch888;
|
|
}
|
|
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 (_afterCall890)(MACHINE);
|
|
};
|
|
|
|
var _afterCall890 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall890;
|
|
}
|
|
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 (_primitiveBranch893)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn897, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple896 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple896;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn897)(MACHINE);
|
|
};
|
|
|
|
var _procReturn897 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn897;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall895)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch893 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch893;
|
|
}
|
|
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 (_afterCall895)(MACHINE);
|
|
};
|
|
|
|
var _afterCall895 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall895;
|
|
}
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry24, 1, [MACHINE.env[MACHINE.env.length - 1 - 5], MACHINE.env[MACHINE.env.length - 1 - 10], MACHINE.env[MACHINE.env.length - 1 - 9], MACHINE.env[MACHINE.env.length - 1 - 8], MACHINE.env[MACHINE.env.length - 1 - 11]], "...etcon/pacman.rkt:404:32");
|
|
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 (_primitiveBranch898)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn902, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple901 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple901;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn902)(MACHINE);
|
|
};
|
|
|
|
var _procReturn902 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn902;
|
|
}
|
|
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 (_primitiveBranch903)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn907, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch898 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch898;
|
|
}
|
|
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 (_afterCall900)(MACHINE);
|
|
};
|
|
|
|
var _afterCall900 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall900;
|
|
}
|
|
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 (_primitiveBranch903)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn907, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple906 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple906;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn907)(MACHINE);
|
|
};
|
|
|
|
var _procReturn907 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn907;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 6][88];
|
|
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[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.val=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 12])) ? (MACHINE.env[MACHINE.env.length - 1 - 12]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 12])));
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch908)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (6 + 7), 7);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch903 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch903;
|
|
}
|
|
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 (_afterCall905)(MACHINE);
|
|
};
|
|
|
|
var _afterCall905 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall905;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 6][88];
|
|
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[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.val=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 12])) ? (MACHINE.env[MACHINE.env.length - 1 - 12]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 12])));
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch908)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (6 + 7), 7);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch908 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch908;
|
|
}
|
|
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 - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch886 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch886;
|
|
}
|
|
MACHINE.val = RUNTIME.VOID;
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry24 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry24;
|
|
}
|
|
|
|
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[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
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 (_primitiveBranch913)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn917, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple916 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple916;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn917)(MACHINE);
|
|
};
|
|
|
|
var _procReturn917 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn917;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall915)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch913 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch913;
|
|
}
|
|
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 (_afterCall915)(MACHINE);
|
|
};
|
|
|
|
var _afterCall915 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall915;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
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 (_primitiveBranch918)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn922, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple921 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple921;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn922)(MACHINE);
|
|
};
|
|
|
|
var _procReturn922 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn922;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall920)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch918 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch918;
|
|
}
|
|
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 (_afterCall920)(MACHINE);
|
|
};
|
|
|
|
var _afterCall920 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall920;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 3][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 3][0])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 6])))));
|
|
if (MACHINE.val === false) { return (_falseBranch926)(MACHINE); }
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 2][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2][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])))));
|
|
if (MACHINE.val === false) { return (_falseBranch929)(MACHINE); }
|
|
MACHINE.val = "empty";
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
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.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch926 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch926;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
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 - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry25 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry25;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 2][37] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 2].names[37]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 2][37];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
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][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][0] = MACHINE.val;
|
|
return (_afterCall935)(MACHINE);
|
|
};
|
|
|
|
var _afterCall935 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall935;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][38] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[38]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][38];
|
|
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 (_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][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][0] = MACHINE.val;
|
|
return (_afterCall942)(MACHINE);
|
|
};
|
|
|
|
var _afterCall942 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall942;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][39] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[39]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][39];
|
|
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 (_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 - 0][0] = 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 - 0][0] = MACHINE.val;
|
|
return (_afterCall949)(MACHINE);
|
|
};
|
|
|
|
var _afterCall949 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall949;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 4][40]);
|
|
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 (_primitiveBranch954)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn958, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple957 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple957;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn958)(MACHINE);
|
|
};
|
|
|
|
var _procReturn958 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn958;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall956)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch954 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch954;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall956)(MACHINE);
|
|
};
|
|
|
|
var _afterCall956 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall956;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 7][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 7].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 7][29];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6][0];
|
|
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 (_primitiveBranch963)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn967, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple966 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple966;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn967)(MACHINE);
|
|
};
|
|
|
|
var _procReturn967 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn967;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall965)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch963 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch963;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall965)(MACHINE);
|
|
};
|
|
|
|
var _afterCall965 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall965;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 8][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 8].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8][30];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7][0];
|
|
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 (_primitiveBranch970)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn974, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple973 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple973;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn974)(MACHINE);
|
|
};
|
|
|
|
var _procReturn974 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn974;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall972)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch970 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch970;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall972)(MACHINE);
|
|
};
|
|
|
|
var _afterCall972 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall972;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 8][31]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8][0];
|
|
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 (_primitiveBranch977)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn981, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple980 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple980;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn981)(MACHINE);
|
|
};
|
|
|
|
var _procReturn981 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn981;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall979)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch977 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch977;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall979)(MACHINE);
|
|
};
|
|
|
|
var _afterCall979 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall979;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 11][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 11].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 11][27];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 13][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "L";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch985)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn989, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple988 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple988;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn989)(MACHINE);
|
|
};
|
|
|
|
var _procReturn989 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn989;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch983)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])), 1);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 7][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7][0])), 1);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 15][57];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 13][0]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 18][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 20][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 13][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 (_primitiveBranch999)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1003, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch985 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch985;
|
|
}
|
|
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 (_afterCall987)(MACHINE);
|
|
};
|
|
|
|
var _afterCall987 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall987;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch983)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])), 1);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 7][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7][0])), 1);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 15][57];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 13][0]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 18][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 20][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 13][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 (_primitiveBranch999)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1003, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1002 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1002;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1003)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1003 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1003;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1001)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch999 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch999;
|
|
}
|
|
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 (_afterCall1001)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1001 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1001;
|
|
}
|
|
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 (_primitiveBranch1004)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1008, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1007 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1007;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1008)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1008 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1008;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1006)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1004 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1004;
|
|
}
|
|
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 (_afterCall1006)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1006 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1006;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch1009)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1013, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1012 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1012;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1013)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1013 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1013;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch995)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 7][0];
|
|
return (_afterLetBody993)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1009 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1009;
|
|
}
|
|
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 (_afterCall1011)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1011 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1011;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch995)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 7][0];
|
|
return (_afterLetBody993)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch995 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch995;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
return (_afterLetBody993)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody993 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody993;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterLetBody991)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody991 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody991;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf984)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch983 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch983;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 13][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "R";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch1017)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1021, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1020 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1020;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1021)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1021 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1021;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1015)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 7][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7][0])));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 15][57];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 13][0]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 18][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 20][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 13][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 (_primitiveBranch1031)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1035, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1017 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1017;
|
|
}
|
|
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 (_afterCall1019)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1019 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1019;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1015)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 7][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7][0])));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 15][57];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 13][0]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 18][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 20][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 13][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 (_primitiveBranch1031)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1035, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1034 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1034;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1035)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1035 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1035;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1033)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1031 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1031;
|
|
}
|
|
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 (_afterCall1033)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1033 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1033;
|
|
}
|
|
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 (_primitiveBranch1036)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1040, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1039 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1039;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1040)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1040 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1040;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1038)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1036 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1036;
|
|
}
|
|
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 (_afterCall1038)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1038 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1038;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch1041)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1045, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1044 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1044;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1045)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1045 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1045;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1027)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 7][0];
|
|
return (_afterLetBody1025)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1041 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1041;
|
|
}
|
|
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 (_afterCall1043)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1043 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1043;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1027)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 7][0];
|
|
return (_afterLetBody1025)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1027 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1027;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
return (_afterLetBody1025)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1025 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1025;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterLetBody1023)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1023 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1023;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf1016)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1015 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1015;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][0];
|
|
return (_afterIf1016)(MACHINE);
|
|
};
|
|
|
|
var _afterIf1016 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf1016;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 13][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "U";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch1049)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1053, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _afterIf984 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf984;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 13][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "U";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch1049)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1053, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1052 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1052;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1053)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1053 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1053;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1047)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 5][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 5][0])), 1);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])), 1);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 15][57];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 13][0]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 18][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 20][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
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 (_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 _primitiveBranch1049 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1049;
|
|
}
|
|
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 (_afterCall1051)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1051 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1051;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1047)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 5][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 5][0])), 1);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])), 1);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 15][57];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 13][0]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 18][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 20][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
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 (_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 - 0] = 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 - 0] = MACHINE.val;
|
|
return (_afterCall1065)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1065 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1065;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 12][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 (_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.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1070)(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;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1070)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1070 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1070;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val = "wall";
|
|
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 (_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;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1059)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 6][0];
|
|
return (_afterLetBody1057)(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;
|
|
return (_afterCall1075)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1075 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1075;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1059)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 6][0];
|
|
return (_afterLetBody1057)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1059 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1059;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
return (_afterLetBody1057)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1057 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1057;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterLetBody1055)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1055 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1055;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf1048)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1047 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1047;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 13][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "D";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch1081)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1085, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1084 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1084;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1085)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1085 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1085;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1079)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 5][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 5][0])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 15][57];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 13][0]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 18][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 20][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
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 (_primitiveBranch1095)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1099, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1081 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1081;
|
|
}
|
|
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 (_afterCall1083)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1083 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1083;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1079)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 5][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 5][0])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 15][57];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 13][0]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 18][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 20][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
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 (_primitiveBranch1095)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1099, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1098 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1098;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1099)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1099 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1099;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1097)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1095 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1095;
|
|
}
|
|
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 (_afterCall1097)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1097 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1097;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 12][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 (_primitiveBranch1100)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1104, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1103 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1103;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1104)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1104 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1104;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1102)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1100 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1100;
|
|
}
|
|
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 (_afterCall1102)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1102 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1102;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch1105)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1109, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1108 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1108;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1109)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1109 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1109;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1091)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 6][0];
|
|
return (_afterLetBody1089)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1105 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1105;
|
|
}
|
|
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 (_afterCall1107)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1107 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1107;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1091)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 6][0];
|
|
return (_afterLetBody1089)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1091 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1091;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
return (_afterLetBody1089)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1089 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1089;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterLetBody1087)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1087 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1087;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf1080)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1079 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1079;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][0];
|
|
return (_afterIf1080)(MACHINE);
|
|
};
|
|
|
|
var _afterIf1080 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf1080;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
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 (_primitiveBranch1110)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1114, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _afterIf1048 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf1048;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
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 (_primitiveBranch1110)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1114, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1113 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1113;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1114)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1114 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1114;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3][0] = MACHINE.val;
|
|
return (_afterCall1112)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1110 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1110;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1112)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1112 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1112;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 8][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 8].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8][29];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
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 (_primitiveBranch1119)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1123, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1122 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1122;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1123)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1123 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1123;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1121)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1119 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1119;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1121)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1121 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1121;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][30];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4][0];
|
|
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 - 0][0] = 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 - 0][0] = MACHINE.val;
|
|
return (_afterCall1128)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1128 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1128;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12][0];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6][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 (_primitiveBranch1134)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1138, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1137 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1137;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1138)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1138 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1138;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1136)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1134 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1134;
|
|
}
|
|
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 (_afterCall1136)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1136 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1136;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch1139)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1143, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1142 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1142;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1143)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1143 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1143;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1141)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1139 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1139;
|
|
}
|
|
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 (_afterCall1141)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1141 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1141;
|
|
}
|
|
MACHINE.val = "empty";
|
|
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 (_primitiveBranch1144)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1148, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1147 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1147;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1148)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1148 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1148;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1132)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2][0] = MACHINE.env[MACHINE.env.length - 1 - 6][0];
|
|
return (_afterIf1133)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1144 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1144;
|
|
}
|
|
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 (_afterCall1146)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1146 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1146;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1132)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2][0] = MACHINE.env[MACHINE.env.length - 1 - 6][0];
|
|
return (_afterIf1133)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1132 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1132;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][61];
|
|
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry26, 3, [MACHINE.env[MACHINE.env.length - 1 - 3], MACHINE.env[MACHINE.env.length - 1 - 2]], "...etcon/pacman.rkt:202:13");
|
|
MACHINE.argcount = 1;
|
|
if (MACHINE.argcount === 0) { return (_afterFirstSeqEvaluated1149)(MACHINE); }
|
|
MACHINE.env.push(MACHINE.val);
|
|
return (_afterFirstSeqEvaluated1149)(MACHINE);
|
|
};
|
|
|
|
var _afterFirstSeqEvaluated1149 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterFirstSeqEvaluated1149;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.Frame());
|
|
MACHINE.control[MACHINE.control.length-1].pendingBegin0Count = MACHINE.argcount;
|
|
RUNTIME.unspliceRestFromStack(MACHINE, 0, MACHINE.argcount);
|
|
MACHINE.control[MACHINE.control.length-1].pendingBegin0Values = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.push(MACHINE.control[MACHINE.control.length-1].pendingBegin0Values);
|
|
RUNTIME.spliceListIntoStack(MACHINE, 0);
|
|
MACHINE.argcount = MACHINE.control[MACHINE.control.length-1].pendingBegin0Count;
|
|
MACHINE.control.pop();
|
|
if (MACHINE.argcount === 0) { return (_afterValuesReinstated1150)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterValuesReinstated1150)(MACHINE);
|
|
};
|
|
|
|
var _afterValuesReinstated1150 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValuesReinstated1150;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8][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 (_primitiveBranch1151)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1155, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1154 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1154;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1155)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1155 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1155;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2][0] = MACHINE.val;
|
|
return (_afterCall1153)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1151 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1151;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1153)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1153 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1153;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][29];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4][0];
|
|
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 (_primitiveBranch1160)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1164, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _afterIf1133 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf1133;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][29];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4][0];
|
|
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 (_primitiveBranch1160)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1164, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1163 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1163;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1164)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1164 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1164;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1162)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1160 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1160;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1162)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1162 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1162;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 10][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 10].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10][30];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][0];
|
|
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 (_primitiveBranch1167)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1171, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1170 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1170;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1171)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1171 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1171;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1169)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1167 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1167;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1169)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1169 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1169;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 11][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 13][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 15][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13][0];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6][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 (_primitiveBranch1175)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1179, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1178 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1178;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1179)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1179 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1179;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1177)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1175 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1175;
|
|
}
|
|
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 (_afterCall1177)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1177 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1177;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch1180)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1184, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1183 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1183;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1184)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1184 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1184;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1182)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1180 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1180;
|
|
}
|
|
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 (_afterCall1182)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1182 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1182;
|
|
}
|
|
MACHINE.val = "dot";
|
|
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 (_primitiveBranch1185)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1189, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1188 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1188;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1189)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1189 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1189;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1173)(MACHINE); }
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 9][17]);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 7][0]);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 15][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 9][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 9][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 9][0])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 8][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 8][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 8][0])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
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 (_primitiveBranch1194)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1198, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1185 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1185;
|
|
}
|
|
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 (_afterCall1187)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1187 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1187;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1173)(MACHINE); }
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 9][17]);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 7][0]);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 15][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 9][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 9][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 9][0])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 8][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 8][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 8][0])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
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 (_primitiveBranch1194)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1198, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1197 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1197;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1198)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1198 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1198;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 4][0] = MACHINE.val;
|
|
return (_afterCall1196)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1194 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1194;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1196)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1196 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1196;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterLetBody1191)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1193 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1193;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterLetBody1191)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1191 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1191;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf1174)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1173 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1173;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2][0] = MACHINE.env[MACHINE.env.length - 1 - 6][0];
|
|
return (_afterIf1174)(MACHINE);
|
|
};
|
|
|
|
var _afterIf1174 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf1174;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 3][0]);
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 11][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 11].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 11][29];
|
|
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;
|
|
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][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][0] = MACHINE.val;
|
|
return (_afterCall1207)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1207 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1207;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 12][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 12].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12][30];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
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 (_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 - 0][0] = 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 - 0][0] = MACHINE.val;
|
|
return (_afterCall1214)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1214 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1214;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 13][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 15][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 17][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 15][0];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6][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 (_primitiveBranch1220)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1224, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1223 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1223;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1224)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1224 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1224;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1222)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1220 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1220;
|
|
}
|
|
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 (_afterCall1222)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1222 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1222;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch1225)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1229, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1228 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1228;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1229)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1229 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1229;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1227)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1225 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1225;
|
|
}
|
|
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 (_afterCall1227)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1227 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1227;
|
|
}
|
|
MACHINE.val = "dot";
|
|
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 (_primitiveBranch1230)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1234, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1233 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1233;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1234)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1234 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1234;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1218)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3][0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 7][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7][0])));
|
|
return (_afterIf1219)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1230 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1230;
|
|
}
|
|
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 (_afterCall1232)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1232 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1232;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1218)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3][0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 7][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7][0])));
|
|
return (_afterIf1219)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1218 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1218;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3][0] = MACHINE.env[MACHINE.env.length - 1 - 7][0];
|
|
return (_afterIf1219)(MACHINE);
|
|
};
|
|
|
|
var _afterIf1219 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf1219;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 12][35] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 12].names[35]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 12][35];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 7][0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 5][0];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4][0];
|
|
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 (_primitiveBranch1235)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 + 10), 10);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1235 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1235;
|
|
}
|
|
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 - 10;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
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 - 9;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
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 - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
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 - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
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 - 3;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry26 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry26;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 1][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 1][0])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2])))));
|
|
if (MACHINE.val === false) { return (_falseBranch1241)(MACHINE); }
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][0])),((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 3])))));
|
|
if (MACHINE.val === false) { return (_falseBranch1244)(MACHINE); }
|
|
MACHINE.val = "empty";
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1244 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1244;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1241 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1241;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry27 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry27;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 2][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 2].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 2][29];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
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 (_primitiveBranch1248)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1252, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1251 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1251;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1252)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1252 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1252;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1250)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1248 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1248;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1250)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1250 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1250;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][30];
|
|
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 (_primitiveBranch1255)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1259, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1258 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1258;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1259)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1259 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1259;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1257)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1255 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1255;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1257)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1257 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1257;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 3][31]);
|
|
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 (_primitiveBranch1262)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1266, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1265 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1265;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1266)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1266 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1266;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1264)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1262 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1262;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1264)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1264 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1264;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 6][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 6].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 6][27];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "L";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_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;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1268)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])), 1);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 7][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7][0])), 1);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 12][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 (_primitiveBranch1282)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1286, 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;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1268)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])), 1);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 7][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7][0])), 1);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 12][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 (_primitiveBranch1282)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1286, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1285 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1285;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1286)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1286 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1286;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1284)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1282 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1282;
|
|
}
|
|
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 (_afterCall1284)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1284 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1284;
|
|
}
|
|
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 (_primitiveBranch1287)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1291, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1290 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1290;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1291)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1291 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1291;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1289)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1287 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1287;
|
|
}
|
|
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 (_afterCall1289)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1289 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1289;
|
|
}
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch1292)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1296, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1295 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1295;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1296)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1296 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1296;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1280)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 7][0];
|
|
return (_afterLetBody1278)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1292 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1292;
|
|
}
|
|
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 (_afterCall1294)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1294 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1294;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1280)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 7][0];
|
|
return (_afterLetBody1278)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1280 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1280;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
return (_afterLetBody1278)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1278 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1278;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterLetBody1276)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1276 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1276;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf1269)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1268 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1268;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "R";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch1300)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1304, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1303 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1303;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1304)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1304 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1304;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1298)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 7][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7][0])));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 12][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 (_primitiveBranch1312)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1316, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1300 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1300;
|
|
}
|
|
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 (_afterCall1302)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1302 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1302;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1298)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 7][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7][0])));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 12][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 (_primitiveBranch1312)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1316, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1315 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1315;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1316)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1316 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1316;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1314)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1312 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1312;
|
|
}
|
|
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 (_afterCall1314)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1314 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1314;
|
|
}
|
|
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 (_primitiveBranch1317)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1321, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1320 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1320;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1321)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1321 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1321;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1319)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1317 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1317;
|
|
}
|
|
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 (_afterCall1319)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1319 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1319;
|
|
}
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch1322)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1326, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1325 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1325;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1326)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1326 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1326;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1310)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 7][0];
|
|
return (_afterLetBody1308)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1322 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1322;
|
|
}
|
|
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 (_afterCall1324)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1324 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1324;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1310)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 7][0];
|
|
return (_afterLetBody1308)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1310 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1310;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
return (_afterLetBody1308)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1308 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1308;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterLetBody1306)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1306 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1306;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf1299)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1298 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1298;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][0];
|
|
return (_afterIf1299)(MACHINE);
|
|
};
|
|
|
|
var _afterIf1299 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf1299;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "U";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch1330)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1334, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _afterIf1269 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf1269;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "U";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch1330)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1334, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1333 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1333;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1334)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1334 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1334;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1328)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 5][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 5][0])), 1);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])), 1);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1342)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1346, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1330 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1330;
|
|
}
|
|
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 (_afterCall1332)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1332 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1332;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1328)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 5][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 5][0])), 1);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])), 1);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1342)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1346, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1345 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1345;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1346)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1346 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1346;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1344)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1342 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1342;
|
|
}
|
|
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 (_afterCall1344)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1344 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1344;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 11][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 (_primitiveBranch1347)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1351, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1350 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1350;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1351)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1351 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1351;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1349)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1347 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1347;
|
|
}
|
|
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 (_afterCall1349)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1349 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1349;
|
|
}
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch1352)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1356, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1355 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1355;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1356)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1356 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1356;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1340)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 6][0];
|
|
return (_afterLetBody1338)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1352 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1352;
|
|
}
|
|
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 (_afterCall1354)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1354 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1354;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1340)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 6][0];
|
|
return (_afterLetBody1338)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1340 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1340;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
return (_afterLetBody1338)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1338 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1338;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterLetBody1336)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1336 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1336;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf1329)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1328 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1328;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "D";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch1360)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1364, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1363 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1363;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1364)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1364 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1364;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1358)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 5][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 5][0])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1372)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1376, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1360 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1360;
|
|
}
|
|
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 (_afterCall1362)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1362 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1362;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1358)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 5][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 5][0])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 6][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6][0])));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 14][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 16];
|
|
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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1372)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1376, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1375 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1375;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1376)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1376 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1376;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1374)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1372 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1372;
|
|
}
|
|
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 (_afterCall1374)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1374 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1374;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 11][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 (_primitiveBranch1377)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1381, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1380 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1380;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1381)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1381 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1381;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1379)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1377 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1377;
|
|
}
|
|
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 (_afterCall1379)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1379 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1379;
|
|
}
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch1382)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1386, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1385 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1385;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1386)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1386 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1386;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1370)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 6][0];
|
|
return (_afterLetBody1368)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1382 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1382;
|
|
}
|
|
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 (_afterCall1384)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1384 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1384;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1370)(MACHINE); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 6][0];
|
|
return (_afterLetBody1368)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1370 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1370;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
return (_afterLetBody1368)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1368 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1368;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterLetBody1366)(MACHINE);
|
|
};
|
|
|
|
var _afterLetBody1366 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLetBody1366;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
return (_afterIf1359)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1358 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1358;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][0];
|
|
return (_afterIf1359)(MACHINE);
|
|
};
|
|
|
|
var _afterIf1359 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf1359;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
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 (_primitiveBranch1387)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 + 6), 6);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _afterIf1329 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf1329;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
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 (_primitiveBranch1387)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 + 6), 6);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1387 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1387;
|
|
}
|
|
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 - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
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 - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry28 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry28;
|
|
}
|
|
|
|
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][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "L";
|
|
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 (_primitiveBranch1395)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1399, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1398 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1398;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1399)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1399 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1399;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1393)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])), 1);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 3])), 1);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
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 (_primitiveBranch1407)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1411, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1395 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1395;
|
|
}
|
|
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 (_afterCall1397)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1397 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1397;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1393)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])), 1);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 3])), 1);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
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 (_primitiveBranch1407)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1411, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1410 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1410;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1411)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1411 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1411;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1409)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1407 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1407;
|
|
}
|
|
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 (_afterCall1409)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1409 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1409;
|
|
}
|
|
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 (_primitiveBranch1412)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1416, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1415 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1415;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1416)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1416 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1416;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1414)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1412 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1412;
|
|
}
|
|
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 (_afterCall1414)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1414 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1414;
|
|
}
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch1417)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1421, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1420 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1420;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1421)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1421 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1421;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1405)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1417 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1417;
|
|
}
|
|
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 (_afterCall1419)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1419 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1419;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1405)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1405 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1405;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
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 - 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);
|
|
};
|
|
|
|
var _falseBranch1393 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1393;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 2][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "R";
|
|
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 (_primitiveBranch1425)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1429, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1428 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1428;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1429)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1429 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1429;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1423)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 3])));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
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 (_primitiveBranch1437)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1441, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1425 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1425;
|
|
}
|
|
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 (_afterCall1427)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1427 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1427;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1423)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 3])));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
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 (_primitiveBranch1437)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1441, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1440 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1440;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1441)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1441 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1441;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1439)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1437 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1437;
|
|
}
|
|
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 (_afterCall1439)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1439 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1439;
|
|
}
|
|
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 (_primitiveBranch1442)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1446, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1445 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1445;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1446)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1446 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1446;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1444)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1442 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1442;
|
|
}
|
|
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 (_afterCall1444)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1444 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1444;
|
|
}
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch1447)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1451, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1450 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1450;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1451)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1451 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1451;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1435)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1447 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1447;
|
|
}
|
|
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 (_afterCall1449)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1449 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1449;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1435)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1435 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1435;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
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 - 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);
|
|
};
|
|
|
|
var _falseBranch1423 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1423;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 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 _lamEntry29 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry29;
|
|
}
|
|
|
|
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][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "U";
|
|
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 (_primitiveBranch1455)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1459, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1458 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1458;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1459)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1459 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1459;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1453)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 3])), 1);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 4])), 1);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1467)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1471, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1455 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1455;
|
|
}
|
|
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 (_afterCall1457)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1457 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1457;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1453)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 3])), 1);
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "sub1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 4])), 1);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1467)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1471, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1470 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1470;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1471)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1471 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1471;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1469)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1467 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1467;
|
|
}
|
|
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 (_afterCall1469)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1469 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1469;
|
|
}
|
|
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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1472)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1476, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1475 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1475;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1476)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1476 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1476;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1474)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1472 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1472;
|
|
}
|
|
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 (_afterCall1474)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1474 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1474;
|
|
}
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch1477)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1481, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1480 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1480;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1481)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1481 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1481;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1465)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1477 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1477;
|
|
}
|
|
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 (_afterCall1479)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1479 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1479;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1465)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1465 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1465;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
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 - 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);
|
|
};
|
|
|
|
var _falseBranch1453 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1453;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 2][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "D";
|
|
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 (_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;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1483)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 3])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 4])));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1497)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1501, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(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;
|
|
return (_afterCall1487)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1487 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1487;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1483)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3])) ? (MACHINE.env[MACHINE.env.length - 1 - 3]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 3])));
|
|
|
|
MACHINE.env.push(undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.add(1, ((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4])) ? (MACHINE.env[MACHINE.env.length - 1 - 4]) : RUNTIME.raiseArgumentTypeError(MACHINE, "add1", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 4])));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1497)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1501, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1500 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1500;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1501)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1501 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1501;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1499)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1497 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1497;
|
|
}
|
|
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 (_afterCall1499)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1499 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1499;
|
|
}
|
|
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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1502)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1506, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1505 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1505;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1506)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1506 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1506;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1504)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1502 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1502;
|
|
}
|
|
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 (_afterCall1504)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1504 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1504;
|
|
}
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch1507)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1511, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1510 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1510;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1511)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1511 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1511;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1495)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1507 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1507;
|
|
}
|
|
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 (_afterCall1509)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1509 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1509;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1495)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1495 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1495;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
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 - 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);
|
|
};
|
|
|
|
var _falseBranch1483 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1483;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 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 _lamEntry30 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry30;
|
|
}
|
|
|
|
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][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
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 (_primitiveBranch1515)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1519, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1518 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1518;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1519)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1519 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1519;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1517)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1515 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1515;
|
|
}
|
|
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 (_afterCall1517)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1517 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1517;
|
|
}
|
|
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 (_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.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1522)(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;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1522)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1522 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1522;
|
|
}
|
|
MACHINE.val = "wall";
|
|
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 (_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;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1529)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1529 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1529;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1513)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
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;
|
|
return (_afterCall1527)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1527 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1527;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1513)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1513 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1513;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry31 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry31;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 2][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 2].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 2][29];
|
|
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 (_primitiveBranch1532)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1536, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1535 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1535;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1536)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1536 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1536;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1534)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1532 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1532;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1534)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1534 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1534;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][30];
|
|
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 (_primitiveBranch1539)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1543, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1542 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1542;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1543)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1543 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1543;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1541)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1539 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1539;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1541)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1541 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1541;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6][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 (_primitiveBranch1547)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1551, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1550 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1550;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1551)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1551 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1551;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1549)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1547 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1547;
|
|
}
|
|
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 (_afterCall1549)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1549 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1549;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch1552)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1556, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1555 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1555;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1556)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1556 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1556;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1554)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1552 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1552;
|
|
}
|
|
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 (_afterCall1554)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1554 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1554;
|
|
}
|
|
MACHINE.val = "empty";
|
|
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 (_primitiveBranch1557)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1561, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1560 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1560;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1561)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1561 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1561;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1545)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1557 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1557;
|
|
}
|
|
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 (_afterCall1559)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1559 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1559;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1545)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1545 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1545;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 3][8]);
|
|
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 (_primitiveBranch1562)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1566, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1565 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1565;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1566)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1566 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1566;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1564)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1562 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1562;
|
|
}
|
|
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 (_afterCall1564)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1564 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1564;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 4][80]);
|
|
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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1569)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1573, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1572 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1572;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1573)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1573 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1573;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1571)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1569 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1569;
|
|
}
|
|
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 (_afterCall1571)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1571 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1571;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 10][88];
|
|
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[MACHINE.env.length - 1 - 9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.val = 0;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
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.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
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 - 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 - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(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 _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.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
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 - 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 - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(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 _lamEntry32 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry32;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 1][8]);
|
|
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 (_primitiveBranch1581)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1585, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1584 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1584;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1585)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1585 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1585;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1583)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1581 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1581;
|
|
}
|
|
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 (_afterCall1583)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1583 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1583;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 2][80]);
|
|
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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1588)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1592, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1591 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1591;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1592)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1592 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1592;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1590)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1588 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1588;
|
|
}
|
|
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 (_afterCall1590)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1590 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1590;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 8][89];
|
|
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 - 9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.val = 0;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1595)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1599, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1598 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1598;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1599)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1599 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1599;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
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);
|
|
};
|
|
|
|
var _primitiveBranch1595 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1595;
|
|
}
|
|
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 (_afterCall1597)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1597 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1597;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
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);
|
|
};
|
|
|
|
var _lamEntry33 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry33;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 2][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 2].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 2][29];
|
|
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 (_primitiveBranch1602)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1606, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1605 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1605;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1606)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1606 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1606;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1604)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1602 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1602;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1604)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1604 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1604;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][30];
|
|
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 (_primitiveBranch1609)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1613, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1612 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1612;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1613)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1613 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1613;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1611)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1609 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1609;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1611)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1611 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1611;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6][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 (_primitiveBranch1617)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1621, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1620 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1620;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1621)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1621 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1621;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1619)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1617 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1617;
|
|
}
|
|
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 (_afterCall1619)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1619 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1619;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch1622)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1626, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1625 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1625;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1626)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1626 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1626;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1624)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1622 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1622;
|
|
}
|
|
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 (_afterCall1624)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1624 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1624;
|
|
}
|
|
MACHINE.val = "dot";
|
|
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 (_primitiveBranch1627)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1631, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1630 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1630;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1631)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1631 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1631;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1615)(MACHINE); }
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 2][17]);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 7][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 8][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 8][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 8][0])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 7][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7][0])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
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 (_primitiveBranch1634)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 + 7), 7);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1627 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1627;
|
|
}
|
|
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 (_afterCall1629)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1629 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1629;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1615)(MACHINE); }
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 2][17]);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 7][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 8][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 8][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 8][0])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 7][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7][0])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
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 (_primitiveBranch1634)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 + 7), 7);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1634 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1634;
|
|
}
|
|
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 - 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 - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1615 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1615;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
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 - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry34 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry34;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 2][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 2].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 2][29];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
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 (_primitiveBranch1641)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1645, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1644 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1644;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1645)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1645 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1645;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1643)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1641 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1641;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1643)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1643 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1643;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][30];
|
|
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 (_primitiveBranch1648)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1652, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1651 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1651;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1652)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1652 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1652;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1650)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1648 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1648;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1650)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1650 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1650;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][57];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6][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 (_primitiveBranch1656)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1660, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1659 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1659;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1660)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1660 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1660;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1658)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1656 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1656;
|
|
}
|
|
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 (_afterCall1658)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1658 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1658;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5][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 (_primitiveBranch1661)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1665, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1664 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1664;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1665)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1665 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1665;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1663)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1661 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1661;
|
|
}
|
|
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 (_afterCall1663)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1663 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1663;
|
|
}
|
|
MACHINE.val = "dot";
|
|
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 (_primitiveBranch1666)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1670, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1669 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1669;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1670)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1670 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1670;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1654)(MACHINE); }
|
|
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.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1666 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1666;
|
|
}
|
|
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 (_afterCall1668)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1668 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1668;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1654)(MACHINE); }
|
|
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.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1654 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1654;
|
|
}
|
|
MACHINE.val = 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);
|
|
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 - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry35 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry35;
|
|
}
|
|
|
|
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][35] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[35]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 4][35];
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 6][37] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 6].names[37]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6][37];
|
|
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 (_primitiveBranch1671)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1675, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1674 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1674;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1675)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1675 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1675;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1673)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1671 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1671;
|
|
}
|
|
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 (_afterCall1673)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1673 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1673;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][65];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "up";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
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 (_primitiveBranch1681)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1685, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1684 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1684;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1685)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1685 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1685;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1679)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 8][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 8].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 8][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][29];
|
|
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 (_primitiveBranch1686)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1690, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1681 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1681;
|
|
}
|
|
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 (_afterCall1683)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1683 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1683;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1679)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 8][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 8].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 8][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][29];
|
|
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 (_primitiveBranch1686)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1690, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1689 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1689;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1690)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1690 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1690;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1688)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1686 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1686;
|
|
}
|
|
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 (_afterCall1688)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1688 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1688;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][30];
|
|
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 (_primitiveBranch1691)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1695, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1694 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1694;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1695)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1695 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1695;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1693)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1691 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1691;
|
|
}
|
|
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 (_afterCall1693)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1693 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1693;
|
|
}
|
|
MACHINE.val = "U";
|
|
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 (_primitiveBranch1696)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1700, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1699 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1699;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1700)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1700 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1700;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1698)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1696 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1696;
|
|
}
|
|
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 (_afterCall1698)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1698 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1698;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][38] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[38]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][38];
|
|
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 (_primitiveBranch1770)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1774, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1679 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1679;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][65];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "down";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
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 (_primitiveBranch1704)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1708, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1707 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1707;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1708)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1708 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1708;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1702)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 8][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 8].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 8][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][29];
|
|
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 (_primitiveBranch1709)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1713, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1704 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1704;
|
|
}
|
|
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 (_afterCall1706)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1706 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1706;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1702)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 8][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 8].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 8][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][29];
|
|
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 (_primitiveBranch1709)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1713, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1712 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1712;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1713)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1713 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1713;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1711)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1709 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1709;
|
|
}
|
|
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 (_afterCall1711)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1711 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1711;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][30];
|
|
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 (_primitiveBranch1714)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1718, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1717 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1717;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1718)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1718 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1718;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1716)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1714 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1714;
|
|
}
|
|
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 (_afterCall1716)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1716 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1716;
|
|
}
|
|
MACHINE.val = "D";
|
|
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 (_primitiveBranch1719)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1723, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1722 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1722;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1723)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1723 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1723;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1721)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1719 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1719;
|
|
}
|
|
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 (_afterCall1721)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1721 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1721;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][38] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[38]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][38];
|
|
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 (_primitiveBranch1770)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1774, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1702 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1702;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][65];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "left";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
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 (_primitiveBranch1727)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1731, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1730 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1730;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1731)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1731 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1731;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1725)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 8][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 8].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 8][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][29];
|
|
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 (_primitiveBranch1732)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1736, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1727 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1727;
|
|
}
|
|
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 (_afterCall1729)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1729 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1729;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1725)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 8][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 8].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 8][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][29];
|
|
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 (_primitiveBranch1732)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1736, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1735 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1735;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1736)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1736 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1736;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1734)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1732 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1732;
|
|
}
|
|
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 (_afterCall1734)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1734 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1734;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][30];
|
|
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 (_primitiveBranch1737)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1741, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1740 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1740;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1741)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1741 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1741;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1739)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1737 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1737;
|
|
}
|
|
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 (_afterCall1739)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1739 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1739;
|
|
}
|
|
MACHINE.val = "L";
|
|
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 (_primitiveBranch1742)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1746, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1745 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1745;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1746)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1746 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1746;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1744)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1742 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1742;
|
|
}
|
|
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 (_afterCall1744)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1744 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1744;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][38] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[38]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][38];
|
|
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 (_primitiveBranch1770)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1774, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1725 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1725;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][65];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "right";
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
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 (_primitiveBranch1750)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1754, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1753 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1753;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1754)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1754 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1754;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1748)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 8][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 8].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 8][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][29];
|
|
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 (_primitiveBranch1755)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1759, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1750 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1750;
|
|
}
|
|
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 (_afterCall1752)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1752 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1752;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1748)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 8][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 8].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 8][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][29];
|
|
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 (_primitiveBranch1755)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1759, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1758 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1758;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1759)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1759 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1759;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1757)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1755 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1755;
|
|
}
|
|
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 (_afterCall1757)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1757 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1757;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][30];
|
|
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 (_primitiveBranch1760)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1764, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1763 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1763;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1764)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1764 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1764;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1762)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1760 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1760;
|
|
}
|
|
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 (_afterCall1762)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1762 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1762;
|
|
}
|
|
MACHINE.val = "R";
|
|
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 (_primitiveBranch1765)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1769, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1768 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1768;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1769)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1769 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1769;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1767)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1765 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1765;
|
|
}
|
|
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 (_afterCall1767)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1767 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1767;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][38] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[38]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][38];
|
|
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 (_primitiveBranch1770)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1774, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch1748 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1748;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
return (_afterIf1749)(MACHINE);
|
|
};
|
|
|
|
var _afterIf1749 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf1749;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][38] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[38]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][38];
|
|
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 (_primitiveBranch1770)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1774, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _afterIf1726 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf1726;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][38] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[38]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][38];
|
|
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 (_primitiveBranch1770)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1774, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _afterIf1703 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf1703;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][38] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[38]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][38];
|
|
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 (_primitiveBranch1770)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1774, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _afterIf1680 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf1680;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][38] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[38]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][38];
|
|
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 (_primitiveBranch1770)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1774, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1773 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1773;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1774)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1774 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1774;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1772)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1770 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1770;
|
|
}
|
|
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 (_afterCall1772)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1772 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1772;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][39] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[39]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][39];
|
|
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 (_primitiveBranch1775)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1779, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1778 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1778;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1779)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1779 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1779;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall1777)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1775 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1775;
|
|
}
|
|
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 (_afterCall1777)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1777 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1777;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 4][40]);
|
|
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 (_primitiveBranch1780)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1784, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1783 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1783;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1784)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1784 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1784;
|
|
}
|
|
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 (_primitiveBranch1785)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 _primitiveBranch1780 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1780;
|
|
}
|
|
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 (_afterCall1782)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1782 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1782;
|
|
}
|
|
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 (_primitiveBranch1785)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 _primitiveBranch1785 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1785;
|
|
}
|
|
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 _lamEntry36 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry36;
|
|
}
|
|
|
|
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][65];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "up";
|
|
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 (_primitiveBranch1793)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1797, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1796 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1796;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1797)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1797 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1797;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1791)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][29];
|
|
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 (_primitiveBranch1798)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1802, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1793 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1793;
|
|
}
|
|
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 (_afterCall1795)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1795 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1795;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1791)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][29];
|
|
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 (_primitiveBranch1798)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1802, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1801 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1801;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1802)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1802 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1802;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1800)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1798 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1798;
|
|
}
|
|
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 (_afterCall1800)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1800 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1800;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][30];
|
|
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 (_primitiveBranch1803)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1807, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1806 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1806;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1807)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1807 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1807;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1805)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1803 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1803;
|
|
}
|
|
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 (_afterCall1805)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1805 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1805;
|
|
}
|
|
MACHINE.val = "U";
|
|
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 (_primitiveBranch1808)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 _primitiveBranch1808 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1808;
|
|
}
|
|
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 _falseBranch1791 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1791;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 2][65];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "down";
|
|
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 (_primitiveBranch1816)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1820, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1819 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1819;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1820)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1820 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1820;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1814)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][29];
|
|
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 (_primitiveBranch1821)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1825, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1816 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1816;
|
|
}
|
|
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 (_afterCall1818)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1818 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1818;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1814)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][29];
|
|
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 (_primitiveBranch1821)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1825, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1824 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1824;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1825)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1825 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1825;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1823)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1821 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1821;
|
|
}
|
|
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 (_afterCall1823)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1823 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1823;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][30];
|
|
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 (_primitiveBranch1826)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1830, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1829 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1829;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1830)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1830 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1830;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1828)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1826 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1826;
|
|
}
|
|
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 (_afterCall1828)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1828 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1828;
|
|
}
|
|
MACHINE.val = "D";
|
|
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 (_primitiveBranch1831)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 _primitiveBranch1831 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1831;
|
|
}
|
|
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 _falseBranch1814 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1814;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 2][65];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "left";
|
|
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 (_primitiveBranch1839)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1843, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1842 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1842;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1843)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1843 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1843;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1837)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][29];
|
|
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 (_primitiveBranch1844)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1848, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1839 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1839;
|
|
}
|
|
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 (_afterCall1841)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1841 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1841;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1837)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][29];
|
|
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 (_primitiveBranch1844)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1848, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1847 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1847;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1848)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1848 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1848;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1846)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1844 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1844;
|
|
}
|
|
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 (_afterCall1846)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1846 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1846;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][30];
|
|
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 (_primitiveBranch1849)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1853, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1852 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1852;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1853)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1853 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1853;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1851)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1849 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1849;
|
|
}
|
|
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 (_afterCall1851)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1851 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1851;
|
|
}
|
|
MACHINE.val = "L";
|
|
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 (_primitiveBranch1854)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 _primitiveBranch1854 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1854;
|
|
}
|
|
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 _falseBranch1837 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1837;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 2][65];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "right";
|
|
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 (_primitiveBranch1862)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1866, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1865 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1865;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1866)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1866 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1866;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1860)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][29];
|
|
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 (_primitiveBranch1867)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1871, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1862 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1862;
|
|
}
|
|
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 (_afterCall1864)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1864 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1864;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch1860)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][27];
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][29];
|
|
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 (_primitiveBranch1867)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1871, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1870 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1870;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1871)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1871 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1871;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1869)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1867 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1867;
|
|
}
|
|
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 (_afterCall1869)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1869 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1869;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][30];
|
|
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 (_primitiveBranch1872)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1876, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1875 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1875;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1876)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1876 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1876;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall1874)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1872 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1872;
|
|
}
|
|
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 (_afterCall1874)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1874 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1874;
|
|
}
|
|
MACHINE.val = "R";
|
|
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 (_primitiveBranch1877)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 _primitiveBranch1877 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1877;
|
|
}
|
|
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 _falseBranch1860 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch1860;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 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 _lamEntry37 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry37;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 2][38] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 2].names[38]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 2][38];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
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 (_primitiveBranch1882)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1886, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1885 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1885;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1886)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1886 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1886;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1884)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1882 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1882;
|
|
}
|
|
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 (_afterCall1884)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1884 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1884;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 1][69]);
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 3][8]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
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 (_primitiveBranch1893)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1897, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1896 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1896;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1897)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1897 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1897;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1895)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1893 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1893;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1895)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1895 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1895;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 4][8]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
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 (_primitiveBranch1900)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1904, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1903 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1903;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1904)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1904 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1904;
|
|
}
|
|
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 (_primitiveBranch1905)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1909, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1900 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1900;
|
|
}
|
|
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 (_afterCall1902)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1902 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1902;
|
|
}
|
|
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 (_primitiveBranch1905)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1909, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1908 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1908;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1909)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1909 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1909;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1907)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1905 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1905;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1907)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1907 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1907;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 9][91];
|
|
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 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 0;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
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 (_primitiveBranch1910)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (5 + 6), 6);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1910 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1910;
|
|
}
|
|
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 - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
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 _lamEntry38 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry38;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][69]);
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 2][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 (_primitiveBranch1919)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1923, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1922 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1922;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1923)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1923 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1923;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1921)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1919 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1919;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1921)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1921 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1921;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 3][8]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
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 (_primitiveBranch1926)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1930, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1929 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1929;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1930)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1930 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1930;
|
|
}
|
|
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 (_primitiveBranch1931)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1935, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1926 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1926;
|
|
}
|
|
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 (_afterCall1928)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1928 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1928;
|
|
}
|
|
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 (_primitiveBranch1931)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1935, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1934 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1934;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1935)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1935 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1935;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1933)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1931 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1931;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1933)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1933 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1933;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 8][93];
|
|
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 - 9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 0;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
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 (_primitiveBranch1936)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (5 + 5), 5);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1936 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1936;
|
|
}
|
|
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);
|
|
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 - 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 _lamEntry39 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry39;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 2][37] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 2].names[37]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 2][37];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
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 (_primitiveBranch1941)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1945, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1944 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1944;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1945)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1945 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1945;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1943)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1941 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1941;
|
|
}
|
|
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 (_afterCall1943)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1943 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1943;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 3][40]);
|
|
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 (_primitiveBranch1948)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1952, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1951 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1951;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1952)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1952 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1952;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1950)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1948 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1948;
|
|
}
|
|
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 (_afterCall1950)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1950 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1950;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][39] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[39]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][39];
|
|
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 (_primitiveBranch1955)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1959, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1958 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1958;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1959)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1959 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1959;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1957)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1955 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1955;
|
|
}
|
|
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 (_afterCall1957)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1957 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1957;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 8][75];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][76];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "Score: ";
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 10][77]);
|
|
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 (_primitiveBranch1964)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1968, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1967 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1967;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1968)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1968 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1968;
|
|
}
|
|
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 (_primitiveBranch1969)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1973, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1964 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1964;
|
|
}
|
|
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 (_afterCall1966)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1966 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1966;
|
|
}
|
|
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 (_primitiveBranch1969)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1973, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1972 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1972;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1973)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1973 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1973;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1971)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1969 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1969;
|
|
}
|
|
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 (_afterCall1971)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1971 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1971;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 20;
|
|
MACHINE.val = "black";
|
|
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 (_primitiveBranch1974)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1978, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1977 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1977;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1978)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1978 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1978;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall1976)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1974 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1974;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall1976)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1976 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1976;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 9][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1]=plt.baselib.numbers.divide(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 9][7])) ? (MACHINE.env[MACHINE.env.length - 1 - 9][7]) : RUNTIME.raiseArgumentTypeError(MACHINE, "/", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 9][7])), 2);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 9][10];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
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 (_primitiveBranch1979)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1983, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1982 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1982;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1983)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1983 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1983;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall1981)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1979 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1979;
|
|
}
|
|
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 (_afterCall1981)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1981 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1981;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 2][15]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][29];
|
|
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 (_primitiveBranch1988)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1992, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1991 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1991;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1992)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1992 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1992;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1990)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1988 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1988;
|
|
}
|
|
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 (_afterCall1990)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1990 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1990;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 6][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 6].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6][30];
|
|
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 (_primitiveBranch1995)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn1999, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1998 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1998;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1999)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1999 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1999;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1997)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1995 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1995;
|
|
}
|
|
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 (_afterCall1997)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1997 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1997;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 9][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7])) ? (MACHINE.env[MACHINE.env.length - 1 - 7]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
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 (_primitiveBranch2002)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 + 7), 7);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2002 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2002;
|
|
}
|
|
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 - 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 - 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 _lamEntry40 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry40;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][22]);
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 2][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 (_primitiveBranch2011)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2015, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2014 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2014;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2015)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2015 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2015;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall2013)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2011 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2011;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall2013)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2013 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2013;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 3][8]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
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 (_primitiveBranch2018)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2022, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2021 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2021;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2022)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2022 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2022;
|
|
}
|
|
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 (_primitiveBranch2023)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2027, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2018 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2018;
|
|
}
|
|
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 (_afterCall2020)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2020 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2020;
|
|
}
|
|
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 (_primitiveBranch2023)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2027, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2026 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2026;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2027)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2027 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2027;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall2025)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2023 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2023;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall2025)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2025 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2025;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(0,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 1][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 1][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 1][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch2029)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 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 _falseBranch2029 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch2029;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 9][96];
|
|
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 - 10];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 0;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
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 (_primitiveBranch2031)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2035, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2034 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2034;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2035)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2035 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2035;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2033)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2031 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2031;
|
|
}
|
|
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 (_afterCall2033)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2033 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2033;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(1,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 2][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch2039)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch2039 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch2039;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 10][96];
|
|
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 - 11];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 1;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
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 (_primitiveBranch2041)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2045, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2044 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2044;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2045)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2045 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2045;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2043)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2041 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2041;
|
|
}
|
|
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 (_afterCall2043)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2043 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2043;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(2,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 3][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 3][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 3][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch2049)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 7;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch2049 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch2049;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 11][96];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 2;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
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 (_primitiveBranch2051)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2055, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2054 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2054;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2055)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2055 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2055;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2053)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2051 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2051;
|
|
}
|
|
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 (_afterCall2053)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2053 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2053;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.equals(3,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 4][0])) ? (MACHINE.env[MACHINE.env.length - 1 - 4][0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 4][0])))));
|
|
if (MACHINE.val === false) { return (_falseBranch2059)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env.length = MACHINE.env.length - 8;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch2059 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch2059;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 11][95];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
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 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 4;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 16][96];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 13];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 17];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = 3;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
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 (_primitiveBranch2061)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2065, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2064 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2064;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2065)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2065 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2065;
|
|
}
|
|
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 (_primitiveBranch2066)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (5 + 8), 8);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2061 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2061;
|
|
}
|
|
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 (_afterCall2063)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2063 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2063;
|
|
}
|
|
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 (_primitiveBranch2066)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (5 + 8), 8);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2066 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2066;
|
|
}
|
|
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 - 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 - 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 - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
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 _lamEntry41 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry41;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][15]);
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][29] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[29]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][29];
|
|
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 (_primitiveBranch2073)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2077, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2076 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2076;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2077)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2077 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2077;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2075)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2073 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2073;
|
|
}
|
|
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 (_afterCall2075)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2075 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2075;
|
|
}
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][30] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[30]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][30];
|
|
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 (_primitiveBranch2080)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2084, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2083 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2083;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2084)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2084 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2084;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2082)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2080 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2080;
|
|
}
|
|
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 (_afterCall2082)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2082 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2082;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 7][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 7])) ? (MACHINE.env[MACHINE.env.length - 1 - 7]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 7])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 6])) ? (MACHINE.env[MACHINE.env.length - 1 - 6]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 6])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
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 (_primitiveBranch2087)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 + 6), 6);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2087 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2087;
|
|
}
|
|
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 _lamEntry42 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry42;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 4][75];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 6][76];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "Score: ";
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6][77]);
|
|
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 (_primitiveBranch2094)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2098, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2097 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2097;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2098)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2098 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2098;
|
|
}
|
|
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 (_primitiveBranch2099)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2103, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2094 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2094;
|
|
}
|
|
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 (_afterCall2096)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2096 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2096;
|
|
}
|
|
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 (_primitiveBranch2099)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2103, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2102 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2102;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2103)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2103 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2103;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2101)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2099 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2099;
|
|
}
|
|
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 (_afterCall2101)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2101 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2101;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 20;
|
|
MACHINE.val = "black";
|
|
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 (_primitiveBranch2104)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2108, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2107 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2107;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2108)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2108 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2108;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall2106)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2104 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2104;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall2106)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2106 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2106;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 5][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1]=plt.baselib.numbers.divide(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 5][7])) ? (MACHINE.env[MACHINE.env.length - 1 - 5][7]) : RUNTIME.raiseArgumentTypeError(MACHINE, "/", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 5][7])), 2);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 5][10];
|
|
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 (_primitiveBranch2109)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 _primitiveBranch2109 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2109;
|
|
}
|
|
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);
|
|
MACHINE.env.length = MACHINE.env.length - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry43 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry43;
|
|
}
|
|
|
|
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][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "empty";
|
|
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 (_primitiveBranch2117)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2121, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2120 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2120;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2121)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2121 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2121;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch2115)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0][17];
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2117 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2117;
|
|
}
|
|
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 (_afterCall2119)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2119 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2119;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch2115)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0][17];
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch2115 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch2115;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 2][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "dot";
|
|
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 (_primitiveBranch2125)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2129, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2128 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2128;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2129)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2129 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2129;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch2123)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0][19];
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2125 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2125;
|
|
}
|
|
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 (_afterCall2127)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2127 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2127;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch2123)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0][19];
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch2123 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch2123;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 2][57];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch2133)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2137, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2136 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2136;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2137)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2137 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2137;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch2131)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0][21];
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2133 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2133;
|
|
}
|
|
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 (_afterCall2135)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2135 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2135;
|
|
}
|
|
if (MACHINE.val === false) { return (_falseBranch2131)(MACHINE); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0][21];
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch2131 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch2131;
|
|
}
|
|
MACHINE.val = RUNTIME.VOID;
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry44 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry44;
|
|
}
|
|
|
|
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][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2138)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2142, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2141 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2141;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2142)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2142 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2142;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2140)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2138 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2138;
|
|
}
|
|
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 (_afterCall2140)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2140 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2140;
|
|
}
|
|
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 (_primitiveBranch2143)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 + 4), 4);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2143 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2143;
|
|
}
|
|
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 _lamEntry45 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry45;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 1][80]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
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 (_primitiveBranch2148)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2152, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2151 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2151;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2152)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2152 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2152;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2150)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2148 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2148;
|
|
}
|
|
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 (_afterCall2150)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2150 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2150;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.lessThan(0,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2])))));
|
|
if (MACHINE.val === false) { return (_falseBranch2156)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 4][81];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 0;
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6]);
|
|
MACHINE.val = 0;
|
|
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 (_primitiveBranch2158)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2162, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2161 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2161;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2162)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2162 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2162;
|
|
}
|
|
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 (_primitiveBranch2163)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2167, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2158 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2158;
|
|
}
|
|
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 (_afterCall2160)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2160 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2160;
|
|
}
|
|
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 (_primitiveBranch2163)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2167, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2166 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2166;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn2167)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2167 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2167;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.lessThan(1,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2])))));
|
|
if (MACHINE.val === false) { return (_falseBranch2169)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 4][81];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6]);
|
|
MACHINE.val = 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 (_primitiveBranch2171)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2175, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2163 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2163;
|
|
}
|
|
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 (_afterCall2165)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2165 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2165;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.lessThan(1,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2])))));
|
|
if (MACHINE.val === false) { return (_falseBranch2169)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 4][81];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6]);
|
|
MACHINE.val = 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 (_primitiveBranch2171)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2175, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2174 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2174;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2175)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2175 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2175;
|
|
}
|
|
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 (_primitiveBranch2176)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2180, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2171 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2171;
|
|
}
|
|
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 (_afterCall2173)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2173 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2173;
|
|
}
|
|
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 (_primitiveBranch2176)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2180, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2179 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2179;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn2180)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2180 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2180;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.lessThan(2,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2])))));
|
|
if (MACHINE.val === false) { return (_falseBranch2182)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 4][81];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 2;
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6]);
|
|
MACHINE.val = 2;
|
|
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 (_primitiveBranch2184)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2188, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2176 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2176;
|
|
}
|
|
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 (_afterCall2178)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2178 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2178;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.lessThan(2,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2])))));
|
|
if (MACHINE.val === false) { return (_falseBranch2182)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 4][81];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 2;
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6]);
|
|
MACHINE.val = 2;
|
|
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 (_primitiveBranch2184)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2188, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2187 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2187;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2188)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2188 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2188;
|
|
}
|
|
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 (_primitiveBranch2189)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2193, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2184 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2184;
|
|
}
|
|
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 (_afterCall2186)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2186 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2186;
|
|
}
|
|
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 (_primitiveBranch2189)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2193, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2192 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2192;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn2193)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2193 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2193;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.lessThan(3,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2])))));
|
|
if (MACHINE.val === false) { return (_falseBranch2195)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 4][81];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 3;
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6]);
|
|
MACHINE.val = 3;
|
|
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 (_primitiveBranch2197)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2201, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2189 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2189;
|
|
}
|
|
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 (_afterCall2191)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2191 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2191;
|
|
}
|
|
MACHINE.val=((plt.baselib.numbers.lessThan(3,((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2])) ? (MACHINE.env[MACHINE.env.length - 1 - 2]) : RUNTIME.raiseArgumentTypeError(MACHINE, "<", "number", 1, MACHINE.env[MACHINE.env.length - 1 - 2])))));
|
|
if (MACHINE.val === false) { return (_falseBranch2195)(MACHINE); }
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 4][81];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 3;
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6]);
|
|
MACHINE.val = 3;
|
|
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 (_primitiveBranch2197)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2201, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2200 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2200;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2201)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2201 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2201;
|
|
}
|
|
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 (_primitiveBranch2202)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2206, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2197 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2197;
|
|
}
|
|
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 (_afterCall2199)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2199 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2199;
|
|
}
|
|
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 (_primitiveBranch2202)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2206, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2205 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2205;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn2206)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2206 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2206;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 5][97];
|
|
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 - 6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.val = 4;
|
|
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 (_primitiveBranch2207)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2211, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2202 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2202;
|
|
}
|
|
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 (_afterCall2204)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2204 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2204;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 5][97];
|
|
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 - 6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.val = 4;
|
|
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 (_primitiveBranch2207)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2211, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2210 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2210;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn2211)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2211 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2211;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
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 - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2207 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2207;
|
|
}
|
|
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 (_afterCall2209)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2209 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2209;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
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 - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch2195 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch2195;
|
|
}
|
|
MACHINE.val = RUNTIME.VOID;
|
|
return (_afterIf2157)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch2182 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch2182;
|
|
}
|
|
MACHINE.val = RUNTIME.VOID;
|
|
return (_afterIf2157)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch2169 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch2169;
|
|
}
|
|
MACHINE.val = RUNTIME.VOID;
|
|
return (_afterIf2157)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch2156 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch2156;
|
|
}
|
|
MACHINE.val = RUNTIME.VOID;
|
|
return (_afterIf2157)(MACHINE);
|
|
};
|
|
|
|
var _afterIf2157 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf2157;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
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 - 4;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry46 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry46;
|
|
}
|
|
|
|
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][79];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 2][8]);
|
|
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 (_primitiveBranch2212)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2216, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2215 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2215;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2216)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2216 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2216;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2214)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2212 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2212;
|
|
}
|
|
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 (_afterCall2214)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2214 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2214;
|
|
}
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry47, 1, [MACHINE.env[MACHINE.env.length - 1 - 2], MACHINE.env[MACHINE.env.length - 1 - 4], MACHINE.env[MACHINE.env.length - 1 - 3]], "...etcon/pacman.rkt:402:16");
|
|
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 (_primitiveBranch2217)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 _primitiveBranch2217 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2217;
|
|
}
|
|
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 _lamEntry47 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry47;
|
|
}
|
|
|
|
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 - 4][79];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 4][8]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 7][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 6];
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
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 (_primitiveBranch2222)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2226, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2225 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2225;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2226)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2226 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2226;
|
|
}
|
|
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 (_primitiveBranch2227)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2231, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2222 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2222;
|
|
}
|
|
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 (_afterCall2224)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2224 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2224;
|
|
}
|
|
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 (_primitiveBranch2227)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2231, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2230 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2230;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2231)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2231 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2231;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2229)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2227 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2227;
|
|
}
|
|
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 (_afterCall2229)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2229 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2229;
|
|
}
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry48, 1, [MACHINE.env[MACHINE.env.length - 1 - 4], MACHINE.env[MACHINE.env.length - 1 - 3], MACHINE.env[MACHINE.env.length - 1 - 2], MACHINE.env[MACHINE.env.length - 1 - 5]], "...etcon/pacman.rkt:404:32");
|
|
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 (_primitiveBranch2232)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 + 4), 4);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2232 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2232;
|
|
}
|
|
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 _lamEntry48 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry48;
|
|
}
|
|
|
|
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 - 4];
|
|
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 - 3];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][9];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 10][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2237)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2241, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2240 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2240;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2241)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2241 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2241;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2239)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2237 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2237;
|
|
}
|
|
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 (_afterCall2239)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2239 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2239;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9];
|
|
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 (_primitiveBranch2242)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2246, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2245 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2245;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2246)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2246 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2246;
|
|
}
|
|
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 (_primitiveBranch2247)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 + 5), 5);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2242 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2242;
|
|
}
|
|
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 (_afterCall2244)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2244 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2244;
|
|
}
|
|
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 (_primitiveBranch2247)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 + 5), 5);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2247 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2247;
|
|
}
|
|
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 _lamEntry49 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry49;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 1][8]);
|
|
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 (_primitiveBranch2254)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2258, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2257 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2257;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2258)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2258 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2258;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall2256)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2254 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2254;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall2256)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2256 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2256;
|
|
}
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 2][8]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 5][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8];
|
|
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 (_primitiveBranch2261)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2265, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2264 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2264;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2265)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2265 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2265;
|
|
}
|
|
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 (_primitiveBranch2266)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2270, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2261 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2261;
|
|
}
|
|
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 (_afterCall2263)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2263 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2263;
|
|
}
|
|
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 (_primitiveBranch2266)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2270, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2269 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2269;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2270)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2270 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2270;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall2268)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2266 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2266;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall2268)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2268 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2268;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.env[MACHINE.env.length - 1 - 8][98];
|
|
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 - 9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 11];
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = 0;
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 10];
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2271)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 - (6 + 6), 6);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2271 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2271;
|
|
}
|
|
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 - 6;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry50 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry50;
|
|
}
|
|
|
|
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][78];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 8])) ? (MACHINE.env[MACHINE.env.length - 1 - 8]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 8])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 3]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=plt.baselib.numbers.multiply(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 9])) ? (MACHINE.env[MACHINE.env.length - 1 - 9]) : RUNTIME.raiseArgumentTypeError(MACHINE, "*", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 9])), 20);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 4]=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])), MACHINE.env[MACHINE.env.length - 1 - 1]);
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
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 (_primitiveBranch2276)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 _primitiveBranch2276 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2276;
|
|
}
|
|
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 _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/pacman.rkt"]=new RUNTIME.ModuleRecord("pacman", _moduleEntry2282);
|
|
return (_afterModuleBody2281)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry2282 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry2282;
|
|
}
|
|
MACHINE.modules["whalesong/racketcon/pacman.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/lang/base.rkt"] !== undefined) !== false) { return (_linked2283)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/lang/base.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2284)(MACHINE);
|
|
};
|
|
|
|
var _linked2283 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked2283;
|
|
}
|
|
if (MACHINE.modules["whalesong/lang/base.rkt"].isInvoked !== false) { return (_alreadyLoaded2284)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn2286, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/lang/base.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple2285 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple2285;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn2286)(MACHINE);
|
|
};
|
|
|
|
var _onReturn2286 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn2286;
|
|
}
|
|
if ((MACHINE.modules["whalesong/world.rkt"] !== undefined) !== false) { return (_linked2287)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/world.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2288)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded2284 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded2284;
|
|
}
|
|
if ((MACHINE.modules["whalesong/world.rkt"] !== undefined) !== false) { return (_linked2287)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/world.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2288)(MACHINE);
|
|
};
|
|
|
|
var _linked2287 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked2287;
|
|
}
|
|
if (MACHINE.modules["whalesong/world.rkt"].isInvoked !== false) { return (_alreadyLoaded2288)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn2290, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/world.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple2289 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple2289;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn2290)(MACHINE);
|
|
};
|
|
|
|
var _onReturn2290 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn2290;
|
|
}
|
|
MACHINE.env.push([MACHINE.params.currentNamespace["E"] || MACHINE.primitives["E"],MACHINE.params.currentNamespace["D"] || MACHINE.primitives["D"],MACHINE.params.currentNamespace["W"] || MACHINE.primitives["W"],MACHINE.params.currentNamespace["INIT-BOARD"] || MACHINE.primitives["INIT-BOARD"],MACHINE.primitives["vector"],MACHINE.params.currentNamespace["SMALL-BOARD"] || MACHINE.primitives["SMALL-BOARD"],MACHINE.params.currentNamespace["CELL-SIZE"] || MACHINE.primitives["CELL-SIZE"],MACHINE.params.currentNamespace["BOARD-WIDTH"] || MACHINE.primitives["BOARD-WIDTH"],MACHINE.primitives["vector-length"],MACHINE.primitives["vector-ref"],MACHINE.params.currentNamespace["BOARD-HEIGHT"] || MACHINE.primitives["BOARD-HEIGHT"],MACHINE.params.currentNamespace["SMALL-BOARD-WIDTH"] || MACHINE.primitives["SMALL-BOARD-WIDTH"],MACHINE.params.currentNamespace["SMALL-BOARD-HEIGHT"] || MACHINE.primitives["SMALL-BOARD-HEIGHT"],MACHINE.params.currentNamespace["SCORE-HEIGHT"] || MACHINE.primitives["SCORE-HEIGHT"],MACHINE.params.currentNamespace["SCORE-TEXT-SIZE"] || MACHINE.primitives["SCORE-TEXT-SIZE"],MACHINE.params.currentNamespace["PM"] || MACHINE.primitives["PM"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["circle28.28"],MACHINE.params.currentNamespace["MTC"] || MACHINE.primitives["MTC"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["rectangle30.30"],MACHINE.params.currentNamespace["DTC"] || MACHINE.primitives["DTC"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["overlay5.5"],MACHINE.params.currentNamespace["WALL"] || MACHINE.primitives["WALL"],MACHINE.params.currentNamespace["MTB"] || MACHINE.primitives["MTB"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["empty-scene15.15"],MACHINE.params.currentNamespace["SMALL-MTB"] || MACHINE.primitives["SMALL-MTB"],MACHINE.params.currentNamespace["INIT-SCORE"] || MACHINE.primitives["INIT-SCORE"],MACHINE.params.currentNamespace["struct:sprite"] || MACHINE.primitives["struct:sprite"],MACHINE.params.currentNamespace["make-sprite"] || MACHINE.primitives["make-sprite"],MACHINE.params.currentNamespace["sprite?"] || MACHINE.primitives["sprite?"],MACHINE.params.currentNamespace["sprite-x"] || MACHINE.primitives["sprite-x"],MACHINE.params.currentNamespace["sprite-y"] || MACHINE.primitives["sprite-y"],MACHINE.params.currentNamespace["sprite-dir"] || MACHINE.primitives["sprite-dir"],MACHINE.params.currentNamespace["INIT-PM"] || MACHINE.primitives["INIT-PM"],MACHINE.params.currentNamespace["RENDER-TEST-BOARD"] || MACHINE.primitives["RENDER-TEST-BOARD"],MACHINE.params.currentNamespace["struct:gs"] || MACHINE.primitives["struct:gs"],MACHINE.params.currentNamespace["make-gs"] || MACHINE.primitives["make-gs"],MACHINE.params.currentNamespace["gs?"] || MACHINE.primitives["gs?"],MACHINE.params.currentNamespace["gs-pm"] || MACHINE.primitives["gs-pm"],MACHINE.params.currentNamespace["gs-board"] || MACHINE.primitives["gs-board"],MACHINE.params.currentNamespace["gs-board-image"] || MACHINE.primitives["gs-board-image"],MACHINE.params.currentNamespace["gs-score"] || MACHINE.primitives["gs-score"],MACHINE.params.currentNamespace["MTB-GS"] || MACHINE.primitives["MTB-GS"],MACHINE.params.currentNamespace["R-SPRITE"] || MACHINE.primitives["R-SPRITE"],MACHINE.params.currentNamespace["L-SPRITE"] || MACHINE.primitives["L-SPRITE"],MACHINE.params.currentNamespace["U-SPRITE"] || MACHINE.primitives["U-SPRITE"],MACHINE.params.currentNamespace["D-SPRITE"] || MACHINE.primitives["D-SPRITE"],MACHINE.params.currentNamespace["EE-BOARD"] || MACHINE.primitives["EE-BOARD"],MACHINE.params.currentNamespace["ED-BOARD"] || MACHINE.primitives["ED-BOARD"],MACHINE.params.currentNamespace["DD-BOARD"] || MACHINE.primitives["DD-BOARD"],MACHINE.params.currentNamespace["END-GS"] || MACHINE.primitives["END-GS"],MACHINE.params.currentNamespace["tick"] || MACHINE.primitives["tick"],MACHINE.params.currentNamespace["tick-pm"] || MACHINE.primitives["tick-pm"],MACHINE.params.currentNamespace["tick-board"] || MACHINE.primitives["tick-board"],MACHINE.params.currentNamespace["tick-board-image"] || MACHINE.primitives["tick-board-image"],MACHINE.params.currentNamespace["tick-score"] || MACHINE.primitives["tick-score"],MACHINE.params.currentNamespace["checked-move-x"] || MACHINE.primitives["checked-move-x"],MACHINE.params.currentNamespace["checked-move-y"] || MACHINE.primitives["checked-move-y"],MACHINE.primitives["string=?"],MACHINE.params.currentNamespace["restrict-move"] || MACHINE.primitives["restrict-move"],MACHINE.params.currentNamespace["board-ref"] || MACHINE.primitives["board-ref"],MACHINE.params.currentNamespace["new-board-w-empty-at"] || MACHINE.primitives["new-board-w-empty-at"],MACHINE.params.currentNamespace["map-board"] || MACHINE.primitives["map-board"],MACHINE.params.currentNamespace["place-cell-image"] || MACHINE.primitives["place-cell-image"],MACHINE.params.currentNamespace["key-handler"] || MACHINE.primitives["key-handler"],MACHINE.params.currentNamespace["new-dir-pm"] || MACHINE.primitives["new-dir-pm"],MACHINE.modules["whalesong/world/main.rkt"].namespace["key=?4.4"],MACHINE.params.currentNamespace["game-over?"] || MACHINE.primitives["game-over?"],MACHINE.params.currentNamespace["empty-board?"] || MACHINE.primitives["empty-board?"],MACHINE.params.currentNamespace["foldr-board"] || MACHINE.primitives["foldr-board"],MACHINE.primitives["true"],MACHINE.params.currentNamespace["render"] || MACHINE.primitives["render"],MACHINE.params.currentNamespace["render-pm"] || MACHINE.primitives["render-pm"],MACHINE.params.currentNamespace["render-score"] || MACHINE.primitives["render-score"],MACHINE.params.currentNamespace["render-board"] || MACHINE.primitives["render-board"],MACHINE.params.currentNamespace["cell-image"] || MACHINE.primitives["cell-image"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["text1.1"],MACHINE.primitives["string-append"],MACHINE.primitives["number->string"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["place-image16.16"],MACHINE.params.currentNamespace["build-vector"] || MACHINE.primitives["build-vector"],MACHINE.primitives["make-vector"],MACHINE.primitives["vector-set!"],MACHINE.modules["whalesong/world/main.rkt"].namespace["big-bang1.1"],MACHINE.modules["whalesong/world/main.rkt"].namespace["on-tick2.2"],MACHINE.modules["whalesong/world/main.rkt"].namespace["to-draw5.5"],MACHINE.modules["whalesong/world/main.rkt"].namespace["on-key3.3"],MACHINE.modules["whalesong/world/main.rkt"].namespace["stop-when6.6"],MACHINE.modules["collects/racket/private/modbeg.rkt"].namespace["print-values"],false,false,false,false,false,false,false,false,false,false,false,false]); MACHINE.env[MACHINE.env.length-1].names = ["E","D","W","INIT-BOARD","vector","SMALL-BOARD","CELL-SIZE","BOARD-WIDTH","vector-length","vector-ref","BOARD-HEIGHT","SMALL-BOARD-WIDTH","SMALL-BOARD-HEIGHT","SCORE-HEIGHT","SCORE-TEXT-SIZE","PM","circle28.28","MTC","rectangle30.30","DTC","overlay5.5","WALL","MTB","empty-scene15.15","SMALL-MTB","INIT-SCORE","struct:sprite","make-sprite","sprite?","sprite-x","sprite-y","sprite-dir","INIT-PM","RENDER-TEST-BOARD","struct:gs","make-gs","gs?","gs-pm","gs-board","gs-board-image","gs-score","MTB-GS","R-SPRITE","L-SPRITE","U-SPRITE","D-SPRITE","EE-BOARD","ED-BOARD","DD-BOARD","END-GS","tick","tick-pm","tick-board","tick-board-image","tick-score","checked-move-x","checked-move-y","string=?","restrict-move","board-ref","new-board-w-empty-at","map-board","place-cell-image","key-handler","new-dir-pm","key=?4.4","game-over?","empty-board?","foldr-board","true","render","render-pm","render-score","render-board","cell-image","text1.1","string-append","number->string","place-image16.16","build-vector","make-vector","vector-set!","big-bang1.1","on-tick2.2","to-draw5.5","on-key3.3","stop-when6.6","print-values",false,false,false,false,false,false,false,false,false,false,false,false];
|
|
MACHINE.modules["whalesong/racketcon/pacman.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2292, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry12, 6, [MACHINE.env[MACHINE.env.length - 1 - 0]], "cols");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][99] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded2288 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded2288;
|
|
}
|
|
MACHINE.env.push([MACHINE.params.currentNamespace["E"] || MACHINE.primitives["E"],MACHINE.params.currentNamespace["D"] || MACHINE.primitives["D"],MACHINE.params.currentNamespace["W"] || MACHINE.primitives["W"],MACHINE.params.currentNamespace["INIT-BOARD"] || MACHINE.primitives["INIT-BOARD"],MACHINE.primitives["vector"],MACHINE.params.currentNamespace["SMALL-BOARD"] || MACHINE.primitives["SMALL-BOARD"],MACHINE.params.currentNamespace["CELL-SIZE"] || MACHINE.primitives["CELL-SIZE"],MACHINE.params.currentNamespace["BOARD-WIDTH"] || MACHINE.primitives["BOARD-WIDTH"],MACHINE.primitives["vector-length"],MACHINE.primitives["vector-ref"],MACHINE.params.currentNamespace["BOARD-HEIGHT"] || MACHINE.primitives["BOARD-HEIGHT"],MACHINE.params.currentNamespace["SMALL-BOARD-WIDTH"] || MACHINE.primitives["SMALL-BOARD-WIDTH"],MACHINE.params.currentNamespace["SMALL-BOARD-HEIGHT"] || MACHINE.primitives["SMALL-BOARD-HEIGHT"],MACHINE.params.currentNamespace["SCORE-HEIGHT"] || MACHINE.primitives["SCORE-HEIGHT"],MACHINE.params.currentNamespace["SCORE-TEXT-SIZE"] || MACHINE.primitives["SCORE-TEXT-SIZE"],MACHINE.params.currentNamespace["PM"] || MACHINE.primitives["PM"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["circle28.28"],MACHINE.params.currentNamespace["MTC"] || MACHINE.primitives["MTC"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["rectangle30.30"],MACHINE.params.currentNamespace["DTC"] || MACHINE.primitives["DTC"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["overlay5.5"],MACHINE.params.currentNamespace["WALL"] || MACHINE.primitives["WALL"],MACHINE.params.currentNamespace["MTB"] || MACHINE.primitives["MTB"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["empty-scene15.15"],MACHINE.params.currentNamespace["SMALL-MTB"] || MACHINE.primitives["SMALL-MTB"],MACHINE.params.currentNamespace["INIT-SCORE"] || MACHINE.primitives["INIT-SCORE"],MACHINE.params.currentNamespace["struct:sprite"] || MACHINE.primitives["struct:sprite"],MACHINE.params.currentNamespace["make-sprite"] || MACHINE.primitives["make-sprite"],MACHINE.params.currentNamespace["sprite?"] || MACHINE.primitives["sprite?"],MACHINE.params.currentNamespace["sprite-x"] || MACHINE.primitives["sprite-x"],MACHINE.params.currentNamespace["sprite-y"] || MACHINE.primitives["sprite-y"],MACHINE.params.currentNamespace["sprite-dir"] || MACHINE.primitives["sprite-dir"],MACHINE.params.currentNamespace["INIT-PM"] || MACHINE.primitives["INIT-PM"],MACHINE.params.currentNamespace["RENDER-TEST-BOARD"] || MACHINE.primitives["RENDER-TEST-BOARD"],MACHINE.params.currentNamespace["struct:gs"] || MACHINE.primitives["struct:gs"],MACHINE.params.currentNamespace["make-gs"] || MACHINE.primitives["make-gs"],MACHINE.params.currentNamespace["gs?"] || MACHINE.primitives["gs?"],MACHINE.params.currentNamespace["gs-pm"] || MACHINE.primitives["gs-pm"],MACHINE.params.currentNamespace["gs-board"] || MACHINE.primitives["gs-board"],MACHINE.params.currentNamespace["gs-board-image"] || MACHINE.primitives["gs-board-image"],MACHINE.params.currentNamespace["gs-score"] || MACHINE.primitives["gs-score"],MACHINE.params.currentNamespace["MTB-GS"] || MACHINE.primitives["MTB-GS"],MACHINE.params.currentNamespace["R-SPRITE"] || MACHINE.primitives["R-SPRITE"],MACHINE.params.currentNamespace["L-SPRITE"] || MACHINE.primitives["L-SPRITE"],MACHINE.params.currentNamespace["U-SPRITE"] || MACHINE.primitives["U-SPRITE"],MACHINE.params.currentNamespace["D-SPRITE"] || MACHINE.primitives["D-SPRITE"],MACHINE.params.currentNamespace["EE-BOARD"] || MACHINE.primitives["EE-BOARD"],MACHINE.params.currentNamespace["ED-BOARD"] || MACHINE.primitives["ED-BOARD"],MACHINE.params.currentNamespace["DD-BOARD"] || MACHINE.primitives["DD-BOARD"],MACHINE.params.currentNamespace["END-GS"] || MACHINE.primitives["END-GS"],MACHINE.params.currentNamespace["tick"] || MACHINE.primitives["tick"],MACHINE.params.currentNamespace["tick-pm"] || MACHINE.primitives["tick-pm"],MACHINE.params.currentNamespace["tick-board"] || MACHINE.primitives["tick-board"],MACHINE.params.currentNamespace["tick-board-image"] || MACHINE.primitives["tick-board-image"],MACHINE.params.currentNamespace["tick-score"] || MACHINE.primitives["tick-score"],MACHINE.params.currentNamespace["checked-move-x"] || MACHINE.primitives["checked-move-x"],MACHINE.params.currentNamespace["checked-move-y"] || MACHINE.primitives["checked-move-y"],MACHINE.primitives["string=?"],MACHINE.params.currentNamespace["restrict-move"] || MACHINE.primitives["restrict-move"],MACHINE.params.currentNamespace["board-ref"] || MACHINE.primitives["board-ref"],MACHINE.params.currentNamespace["new-board-w-empty-at"] || MACHINE.primitives["new-board-w-empty-at"],MACHINE.params.currentNamespace["map-board"] || MACHINE.primitives["map-board"],MACHINE.params.currentNamespace["place-cell-image"] || MACHINE.primitives["place-cell-image"],MACHINE.params.currentNamespace["key-handler"] || MACHINE.primitives["key-handler"],MACHINE.params.currentNamespace["new-dir-pm"] || MACHINE.primitives["new-dir-pm"],MACHINE.modules["whalesong/world/main.rkt"].namespace["key=?4.4"],MACHINE.params.currentNamespace["game-over?"] || MACHINE.primitives["game-over?"],MACHINE.params.currentNamespace["empty-board?"] || MACHINE.primitives["empty-board?"],MACHINE.params.currentNamespace["foldr-board"] || MACHINE.primitives["foldr-board"],MACHINE.primitives["true"],MACHINE.params.currentNamespace["render"] || MACHINE.primitives["render"],MACHINE.params.currentNamespace["render-pm"] || MACHINE.primitives["render-pm"],MACHINE.params.currentNamespace["render-score"] || MACHINE.primitives["render-score"],MACHINE.params.currentNamespace["render-board"] || MACHINE.primitives["render-board"],MACHINE.params.currentNamespace["cell-image"] || MACHINE.primitives["cell-image"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["text1.1"],MACHINE.primitives["string-append"],MACHINE.primitives["number->string"],MACHINE.modules["whalesong/image/private/main.rkt"].namespace["place-image16.16"],MACHINE.params.currentNamespace["build-vector"] || MACHINE.primitives["build-vector"],MACHINE.primitives["make-vector"],MACHINE.primitives["vector-set!"],MACHINE.modules["whalesong/world/main.rkt"].namespace["big-bang1.1"],MACHINE.modules["whalesong/world/main.rkt"].namespace["on-tick2.2"],MACHINE.modules["whalesong/world/main.rkt"].namespace["to-draw5.5"],MACHINE.modules["whalesong/world/main.rkt"].namespace["on-key3.3"],MACHINE.modules["whalesong/world/main.rkt"].namespace["stop-when6.6"],MACHINE.modules["collects/racket/private/modbeg.rkt"].namespace["print-values"],false,false,false,false,false,false,false,false,false,false,false,false]); MACHINE.env[MACHINE.env.length-1].names = ["E","D","W","INIT-BOARD","vector","SMALL-BOARD","CELL-SIZE","BOARD-WIDTH","vector-length","vector-ref","BOARD-HEIGHT","SMALL-BOARD-WIDTH","SMALL-BOARD-HEIGHT","SCORE-HEIGHT","SCORE-TEXT-SIZE","PM","circle28.28","MTC","rectangle30.30","DTC","overlay5.5","WALL","MTB","empty-scene15.15","SMALL-MTB","INIT-SCORE","struct:sprite","make-sprite","sprite?","sprite-x","sprite-y","sprite-dir","INIT-PM","RENDER-TEST-BOARD","struct:gs","make-gs","gs?","gs-pm","gs-board","gs-board-image","gs-score","MTB-GS","R-SPRITE","L-SPRITE","U-SPRITE","D-SPRITE","EE-BOARD","ED-BOARD","DD-BOARD","END-GS","tick","tick-pm","tick-board","tick-board-image","tick-score","checked-move-x","checked-move-y","string=?","restrict-move","board-ref","new-board-w-empty-at","map-board","place-cell-image","key-handler","new-dir-pm","key=?4.4","game-over?","empty-board?","foldr-board","true","render","render-pm","render-score","render-board","cell-image","text1.1","string-append","number->string","place-image16.16","build-vector","make-vector","vector-set!","big-bang1.1","on-tick2.2","to-draw5.5","on-key3.3","stop-when6.6","print-values",false,false,false,false,false,false,false,false,false,false,false,false];
|
|
MACHINE.modules["whalesong/racketcon/pacman.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2292, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry12, 6, [MACHINE.env[MACHINE.env.length - 1 - 0]], "cols");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][99] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2291 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2291;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2292)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2292 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2292;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2294, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry13, 6, [MACHINE.env[MACHINE.env.length - 1 - 0]], "rows");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][98] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2293 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2293;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2294)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2294 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2294;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2296, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry14, 4, [MACHINE.env[MACHINE.env.length - 1 - 0]], "loop");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][97] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2295 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2295;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2296)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2296 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2296;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2298, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry15, 5, [MACHINE.env[MACHINE.env.length - 1 - 0]], "cols");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][96] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2297 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2297;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2298)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2298 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2298;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2300, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry16, 5, [MACHINE.env[MACHINE.env.length - 1 - 0]], "rows");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][95] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2299 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2299;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2300)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2300 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2300;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2302, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry17, 5, [MACHINE.env[MACHINE.env.length - 1 - 0]], "cols");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][94] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2301 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2301;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2302)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2302 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2302;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2304, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry18, 5, [MACHINE.env[MACHINE.env.length - 1 - 0]], "rows");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][93] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2303 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2303;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2304)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2304 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2304;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2306, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry19, 5, [MACHINE.env[MACHINE.env.length - 1 - 0]], "cols");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][92] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2305 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2305;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2306)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2306 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2306;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2308, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry20, 5, [MACHINE.env[MACHINE.env.length - 1 - 0]], "rows");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][91] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2307 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2307;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2308)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2308 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2308;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2310, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry21, 6, [MACHINE.env[MACHINE.env.length - 1 - 0]], "loop");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][89] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2309 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2309;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2310)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2310 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2310;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2312, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry22, 7, [MACHINE.env[MACHINE.env.length - 1 - 0]], "loop");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][90] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2311 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2311;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2312)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2312 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2312;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2314, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry23, 6, [MACHINE.env[MACHINE.env.length - 1 - 0]], "loop");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][88] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2313 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2313;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2314)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2314 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2314;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2316, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val = "empty";
|
|
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 _beforePromptPopMultiple2315 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2315;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2316)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2316 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2316;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2318, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val = "dot";
|
|
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 _beforePromptPopMultiple2317 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2317;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2318)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2318 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2318;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2320, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val = "wall";
|
|
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 _beforePromptPopMultiple2319 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2319;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2320)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2320 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2320;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2322, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = MACHINE.env[MACHINE.env.length - 1 - 8][4];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.env[MACHINE.env.length - 1 - 21][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 9] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 11] = "wall";
|
|
MACHINE.val = "wall";
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.val;
|
|
MACHINE.argcount = 13;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2323)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2327, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2326 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2326;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2327)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2327 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2327;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2325)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2323 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2323;
|
|
}
|
|
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 (_afterCall2325)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2325 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2325;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.env[MACHINE.env.length - 1 - 21][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 9] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 11] = "dot";
|
|
MACHINE.val = "wall";
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.val;
|
|
MACHINE.argcount = 13;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2328)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2332, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2331 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2331;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2332)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2332 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2332;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall2330)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2328 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2328;
|
|
}
|
|
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 (_afterCall2330)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2330 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2330;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.env[MACHINE.env.length - 1 - 21][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 9] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 11] = "dot";
|
|
MACHINE.val = "wall";
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.val;
|
|
MACHINE.argcount = 13;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2333)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2337, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2336 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2336;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2337)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2337 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2337;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall2335)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2333 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2333;
|
|
}
|
|
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 (_afterCall2335)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2335 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2335;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.env[MACHINE.env.length - 1 - 21][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 9] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 11] = "dot";
|
|
MACHINE.val = "wall";
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.val;
|
|
MACHINE.argcount = 13;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2338)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2342, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2341 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2341;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2342)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2342 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2342;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall2340)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2338 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2338;
|
|
}
|
|
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 (_afterCall2340)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2340 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2340;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.env[MACHINE.env.length - 1 - 21][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 9] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 11] = "dot";
|
|
MACHINE.val = "wall";
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.val;
|
|
MACHINE.argcount = 13;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2343)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2347, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2346 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2346;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2347)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2347 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2347;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
return (_afterCall2345)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2343 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2343;
|
|
}
|
|
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 (_afterCall2345)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2345 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2345;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.env[MACHINE.env.length - 1 - 21][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 9] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 11] = "dot";
|
|
MACHINE.val = "wall";
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.val;
|
|
MACHINE.argcount = 13;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2348)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2352, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2351 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2351;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2352)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2352 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2352;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
return (_afterCall2350)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2348 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2348;
|
|
}
|
|
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 (_afterCall2350)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2350 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2350;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.env[MACHINE.env.length - 1 - 21][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = "empty";
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 9] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 11] = "dot";
|
|
MACHINE.val = "wall";
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.val;
|
|
MACHINE.argcount = 13;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2353)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2357, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2356 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2356;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2357)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2357 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2357;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
return (_afterCall2355)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2353 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2353;
|
|
}
|
|
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 (_afterCall2355)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2355 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2355;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.env[MACHINE.env.length - 1 - 21][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 8] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 9] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 10] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 11] = "wall";
|
|
MACHINE.val = "wall";
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 12] = MACHINE.val;
|
|
MACHINE.argcount = 13;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2358)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2362, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2361 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2361;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2362)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2362 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2362;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = MACHINE.val;
|
|
MACHINE.argcount = 8;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2363)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2367, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2358 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2358;
|
|
}
|
|
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 (_afterCall2360)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2360 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2360;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 7];
|
|
MACHINE.env[MACHINE.env.length - 1 - 7] = MACHINE.val;
|
|
MACHINE.argcount = 8;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2363)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2367, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2366 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2366;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2367)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2367 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2367;
|
|
}
|
|
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 _primitiveBranch2363 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2363;
|
|
}
|
|
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 (_afterCall2365)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2365 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2365;
|
|
}
|
|
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 _beforePromptPopMultiple2321 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2321;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2322)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2322 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2322;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2369, 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.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 5][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "empty";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "empty";
|
|
MACHINE.val = "empty";
|
|
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 (_primitiveBranch2370)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2374, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2373 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2373;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2374)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2374 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2374;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2372)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2370 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2370;
|
|
}
|
|
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 (_afterCall2372)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2372 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2372;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 5][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "empty";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "empty";
|
|
MACHINE.val = "empty";
|
|
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 (_primitiveBranch2375)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2379, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2378 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2378;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2379)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2379 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2379;
|
|
}
|
|
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 (_primitiveBranch2380)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2384, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2375 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2375;
|
|
}
|
|
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 (_afterCall2377)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2377 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2377;
|
|
}
|
|
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 (_primitiveBranch2380)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2384, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2383 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2383;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2384)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2384 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2384;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][5] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2380 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2380;
|
|
}
|
|
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 (_afterCall2382)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2382 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2382;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][5] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2368 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2368;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2369)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2369 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2369;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2386, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val = 20;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][6] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2385 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2385;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2386)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2386 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2386;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2388, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 1][8]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][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;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2389)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2393, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2392 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2392;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2393)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2393 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2393;
|
|
}
|
|
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 (_primitiveBranch2394)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2398, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2389 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2389;
|
|
}
|
|
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 (_afterCall2391)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2391 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2391;
|
|
}
|
|
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 (_primitiveBranch2394)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2398, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2397 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2397;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2398)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2398 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2398;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2396)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2394 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2394;
|
|
}
|
|
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 (_afterCall2396)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2396 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2396;
|
|
}
|
|
MACHINE.val=plt.baselib.numbers.multiply(20, ((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[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 _beforePromptPopMultiple2387 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2387;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2388)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2388 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2388;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2400, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 1][8]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2][3];
|
|
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 (_primitiveBranch2401)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2405, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2404 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2404;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2405)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2405 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2405;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2403)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2401 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2401;
|
|
}
|
|
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 (_afterCall2403)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2403 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2403;
|
|
}
|
|
MACHINE.val=plt.baselib.numbers.multiply(20, ((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[MACHINE.env.length - 1 - 0][10] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2399 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2399;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2400)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2400 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2400;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2407, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 1][8]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][9];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][5];
|
|
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 (_primitiveBranch2408)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2412, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2411 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2411;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2412)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2412 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2412;
|
|
}
|
|
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 (_primitiveBranch2413)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2417, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2408 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2408;
|
|
}
|
|
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 (_afterCall2410)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2410 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2410;
|
|
}
|
|
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 (_primitiveBranch2413)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2417, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2416 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2416;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2417)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2417 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2417;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2415)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2413 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2413;
|
|
}
|
|
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 (_afterCall2415)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2415 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2415;
|
|
}
|
|
MACHINE.val=plt.baselib.numbers.multiply(20, ((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[MACHINE.env.length - 1 - 0][11] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2406 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2406;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2407)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2407 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2407;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2419, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push(undefined);
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 1][8]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2][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 (_primitiveBranch2420)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2424, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2423 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2423;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2424)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2424 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2424;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2422)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2420 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2420;
|
|
}
|
|
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 (_afterCall2422)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2422 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2422;
|
|
}
|
|
MACHINE.val=plt.baselib.numbers.multiply(20, ((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[MACHINE.env.length - 1 - 0][12] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2418 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2418;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2419)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2419 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2419;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2426, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val = 30;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][13] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2425 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2425;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2426)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2426 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2426;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2428, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val = 20;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][14] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2427 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2427;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2428)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2428 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2428;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2430, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][16];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = 10;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "solid";
|
|
MACHINE.val = "yellow";
|
|
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 (_primitiveBranch2431)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2435, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2434 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2434;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2435)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2435 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2435;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][15] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2431 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2431;
|
|
}
|
|
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 (_afterCall2433)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2433 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2433;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][15] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2429 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2429;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2430)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2430 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2430;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2437, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 4][18];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = 20;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 20;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "solid";
|
|
MACHINE.val = "black";
|
|
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 (_primitiveBranch2438)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2442, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2441 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2441;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2442)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2442 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2442;
|
|
}
|
|
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 _primitiveBranch2438 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2438;
|
|
}
|
|
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 (_afterCall2440)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2440 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2440;
|
|
}
|
|
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 _beforePromptPopMultiple2436 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2436;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2437)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2437 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2437;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2444, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 2][20];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 5][16];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = 3;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "solid";
|
|
MACHINE.val = "white";
|
|
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 (_primitiveBranch2445)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2449, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2448 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2448;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2449)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2449 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2449;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2447)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2445 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2445;
|
|
}
|
|
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 (_afterCall2447)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2447 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2447;
|
|
}
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 2][17];
|
|
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 (_primitiveBranch2450)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2454, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2453 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2453;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2454)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2454 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2454;
|
|
}
|
|
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 _primitiveBranch2450 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2450;
|
|
}
|
|
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 (_afterCall2452)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2452 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2452;
|
|
}
|
|
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 _beforePromptPopMultiple2443 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2443;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2444)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2444 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2444;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2456, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 4][18];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = 20;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 20;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "solid";
|
|
MACHINE.val = "blue";
|
|
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 (_primitiveBranch2457)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2461, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2460 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2460;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2461)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2461 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2461;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][21] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2457 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2457;
|
|
}
|
|
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 (_afterCall2459)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2459 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2459;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][21] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2455 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2455;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2456)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2456 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2456;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2463, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 2][23];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 2][7];
|
|
MACHINE.val=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2][10])) ? (MACHINE.env[MACHINE.env.length - 1 - 2][10]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2][10])), 30);
|
|
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 (_primitiveBranch2464)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2468, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2467 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2467;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2468)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2468 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2468;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][22] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2464 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2464;
|
|
}
|
|
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 (_afterCall2466)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2466 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2466;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][22] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2462 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2462;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2463)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2463 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2463;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2470, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 2][23];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 2][11];
|
|
MACHINE.val=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 2][12])) ? (MACHINE.env[MACHINE.env.length - 1 - 2][12]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 2][12])), 30);
|
|
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 (_primitiveBranch2471)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2475, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2474 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2474;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2475)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2475 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2475;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][24] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2471 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2471;
|
|
}
|
|
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 (_afterCall2473)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2473 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2473;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][24] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2469 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2469;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2470)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2470 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2470;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2477, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val = 0;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][25] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2476 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2476;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2477)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2477 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2477;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2479, 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("sprite");
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = false;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = 3;
|
|
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 (_primitiveBranch2482)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2486, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2485 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2485;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2486)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2486 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2486;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
return (_afterCall2484)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2482 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2482;
|
|
}
|
|
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 (_afterCall2484)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2484 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2484;
|
|
}
|
|
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.NULL)));
|
|
MACHINE.env[MACHINE.env.length - 1 - 9] = false;
|
|
MACHINE.val = RUNTIME.makeSymbol("sprite");
|
|
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 (_primitiveBranch2487)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2491, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2490 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2490;
|
|
}
|
|
if ((MACHINE.argcount - 5) === 0) { return (_afterValueCheck2492)(MACHINE); }
|
|
return (_procReturn2491)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2491 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2491;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 5);
|
|
return (_afterValueCheck2492)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck2492 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck2492;
|
|
}
|
|
|
|
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);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.primitives["values"];
|
|
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.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 - 12];
|
|
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 (_primitiveBranch2493)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2497, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2487 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2487;
|
|
}
|
|
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 (_afterCall2489)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2489 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2489;
|
|
}
|
|
|
|
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);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.primitives["values"];
|
|
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.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 - 12];
|
|
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 (_primitiveBranch2493)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2497, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2496 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2496;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2497)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2497 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2497;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall2495)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2493 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2493;
|
|
}
|
|
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 (_afterCall2495)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2495 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2495;
|
|
}
|
|
|
|
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 - 12];
|
|
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 (_primitiveBranch2498)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2502, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2501 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2501;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2502)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2502 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2502;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
return (_afterCall2500)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2498 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2498;
|
|
}
|
|
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 (_afterCall2500)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2500 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2500;
|
|
}
|
|
|
|
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 - 12];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 2;
|
|
MACHINE.val = RUNTIME.makeSymbol("dir");
|
|
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 (_primitiveBranch2503)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2507, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2506 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2506;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2507)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2507 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2507;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2508)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2512, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2503 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2503;
|
|
}
|
|
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 (_afterCall2505)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2505 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2505;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 5];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
MACHINE.argcount = 6;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2508)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2512, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2511 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2511;
|
|
}
|
|
if ((MACHINE.argcount - 6) === 0) { return (_afterValueCheck2513)(MACHINE); }
|
|
return (_procReturn2512)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2512 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2512;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 6);
|
|
return (_afterValueCheck2513)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck2513 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck2513;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((6 - 1) + 5), 5);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5][26] = MACHINE.val;
|
|
MACHINE.env[MACHINE.env.length - 1 - 5][27] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5][28] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5][29] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5][30] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5][31] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2508 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2508;
|
|
}
|
|
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, 6);
|
|
return (_afterCall2510)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2510 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2510;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((6 - 1) + 5), 5);
|
|
MACHINE.env[MACHINE.env.length - 1 - 5][26] = MACHINE.val;
|
|
MACHINE.env[MACHINE.env.length - 1 - 5][27] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5][28] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5][29] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5][30] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 5][31] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env.length = MACHINE.env.length - 5;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2478 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2478;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2479)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2479 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2479;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2515, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][27];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = 6;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 6;
|
|
MACHINE.val = "U";
|
|
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 (_primitiveBranch2516)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2520, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2519 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2519;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2520)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2520 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2520;
|
|
}
|
|
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 _primitiveBranch2516 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2516;
|
|
}
|
|
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 (_afterCall2518)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2518 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2518;
|
|
}
|
|
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 _beforePromptPopMultiple2514 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2514;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2515)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2515 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2515;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2522, 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.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.val = "empty";
|
|
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 (_primitiveBranch2523)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2527, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2526 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2526;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2527)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2527 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2527;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2525)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2523 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2523;
|
|
}
|
|
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 (_afterCall2525)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2525 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2525;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "dot";
|
|
MACHINE.val = "empty";
|
|
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 (_primitiveBranch2528)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2532, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2531 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2531;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2532)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2532 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2532;
|
|
}
|
|
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 (_primitiveBranch2533)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2537, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2528 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2528;
|
|
}
|
|
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 (_afterCall2530)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2530 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2530;
|
|
}
|
|
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 (_primitiveBranch2533)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2537, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2536 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2536;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2537)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2537 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2537;
|
|
}
|
|
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 _primitiveBranch2533 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2533;
|
|
}
|
|
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 (_afterCall2535)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2535 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2535;
|
|
}
|
|
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 _beforePromptPopMultiple2521 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2521;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2522)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2522 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2522;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2539, 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("gs");
|
|
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 (_primitiveBranch2542)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2546, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2545 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2545;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2546)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2546 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2546;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
return (_afterCall2544)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2542 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2542;
|
|
}
|
|
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 (_afterCall2544)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2544 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2544;
|
|
}
|
|
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("gs");
|
|
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 (_primitiveBranch2547)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2551, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2550 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2550;
|
|
}
|
|
if ((MACHINE.argcount - 5) === 0) { return (_afterValueCheck2552)(MACHINE); }
|
|
return (_procReturn2551)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2551 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2551;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 5);
|
|
return (_afterValueCheck2552)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck2552 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck2552;
|
|
}
|
|
|
|
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("pm");
|
|
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 (_primitiveBranch2553)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2557, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2547 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2547;
|
|
}
|
|
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 (_afterCall2549)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2549 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2549;
|
|
}
|
|
|
|
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("pm");
|
|
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 (_primitiveBranch2553)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2557, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2556 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2556;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2557)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2557 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2557;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall2555)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2553 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2553;
|
|
}
|
|
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 (_afterCall2555)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2555 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2555;
|
|
}
|
|
|
|
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("board");
|
|
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 (_primitiveBranch2558)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2562, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2561 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2561;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2562)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2562 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2562;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
return (_afterCall2560)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2558 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2558;
|
|
}
|
|
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 (_afterCall2560)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2560 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2560;
|
|
}
|
|
|
|
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("board-image");
|
|
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 (_primitiveBranch2563)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2567, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2566 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2566;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2567)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2567 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2567;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
return (_afterCall2565)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2563 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2563;
|
|
}
|
|
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 (_afterCall2565)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2565 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2565;
|
|
}
|
|
|
|
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("score");
|
|
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 (_primitiveBranch2568)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2572, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2571 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2571;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2572)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2572 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2572;
|
|
}
|
|
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 (_primitiveBranch2573)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2577, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2568 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2568;
|
|
}
|
|
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 (_afterCall2570)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2570 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2570;
|
|
}
|
|
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 (_primitiveBranch2573)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2577, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2576 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2576;
|
|
}
|
|
if ((MACHINE.argcount - 7) === 0) { return (_afterValueCheck2578)(MACHINE); }
|
|
return (_procReturn2577)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2577 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2577;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 7);
|
|
return (_afterValueCheck2578)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck2578 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck2578;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((7 - 1) + 5), 5);
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][34] = MACHINE.val;
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][35] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][36] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][37] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][38] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][39] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][40] = 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 _primitiveBranch2573 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2573;
|
|
}
|
|
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 (_afterCall2575)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2575 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2575;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((7 - 1) + 5), 5);
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][34] = MACHINE.val;
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][35] = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][36] = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][37] = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][38] = MACHINE.env[MACHINE.env.length - 1 - 3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][39] = MACHINE.env[MACHINE.env.length - 1 - 4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 6][40] = 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 _beforePromptPopMultiple2538 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2538;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2539)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2539 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2539;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2580, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][35] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[35]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 4][35];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][32];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][3];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 4][22];
|
|
MACHINE.val = 0;
|
|
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 (_primitiveBranch2581)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2585, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2584 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2584;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2585)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2585 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2585;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][41] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2581 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2581;
|
|
}
|
|
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 (_afterCall2583)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2583 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2583;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][41] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2579 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2579;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2580)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2580 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2580;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2587, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][27];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.val = "R";
|
|
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 (_primitiveBranch2588)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2592, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2591 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2591;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2592)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2592 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2592;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][42] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2588 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2588;
|
|
}
|
|
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 (_afterCall2590)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2590 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2590;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][42] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2586 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2586;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2587)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2587 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2587;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2594, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][27];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.val = "L";
|
|
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 (_primitiveBranch2595)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2599, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2598 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2598;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2599)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2599 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2599;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][43] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2595 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2595;
|
|
}
|
|
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 (_afterCall2597)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2597 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2597;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][43] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2593 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2593;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2594)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2594 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2594;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2601, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][27];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.val = "U";
|
|
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 (_primitiveBranch2602)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2606, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2605 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2605;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2606)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2606 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2606;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][44] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2602 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2602;
|
|
}
|
|
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 (_afterCall2604)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2604 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2604;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][44] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2600 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2600;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2601)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2601 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2601;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2608, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][27] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[27]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][27];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.val = "D";
|
|
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 (_primitiveBranch2609)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2613, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2612 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2612;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2613)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2613 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2613;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][45] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2609 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2609;
|
|
}
|
|
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 (_afterCall2611)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2611 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2611;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][45] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2607 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2607;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2608)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2608 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2608;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2615, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 7][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "wall";
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch2616)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2620, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2619 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2619;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2620)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2620 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2620;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2618)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2616 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2616;
|
|
}
|
|
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 (_afterCall2618)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2618 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2618;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 7][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "empty";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "empty";
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch2621)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2625, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2624 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2624;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2625)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2625 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2625;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall2623)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2621 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2621;
|
|
}
|
|
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 (_afterCall2623)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2623 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2623;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 7][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "wall";
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch2626)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2630, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2629 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2629;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2630)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2630 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2630;
|
|
}
|
|
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 (_primitiveBranch2631)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2635, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2626 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2626;
|
|
}
|
|
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 (_afterCall2628)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2628 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2628;
|
|
}
|
|
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 (_primitiveBranch2631)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2635, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2634 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2634;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2635)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2635 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2635;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][46] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2631 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2631;
|
|
}
|
|
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 (_afterCall2633)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2633 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2633;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][46] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2614 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2614;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2615)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2615 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2615;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2637, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 7][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "wall";
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch2638)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2642, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2641 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2641;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2642)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2642 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2642;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2640)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2638 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2638;
|
|
}
|
|
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 (_afterCall2640)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2640 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2640;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 7][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "empty";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "dot";
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch2643)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2647, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2646 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2646;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2647)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2647 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2647;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall2645)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2643 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2643;
|
|
}
|
|
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 (_afterCall2645)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2645 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2645;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 7][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "wall";
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch2648)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2652, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2651 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2651;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2652)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2652 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2652;
|
|
}
|
|
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 (_primitiveBranch2653)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2657, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2648 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2648;
|
|
}
|
|
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 (_afterCall2650)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2650 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2650;
|
|
}
|
|
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 (_primitiveBranch2653)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2657, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2656 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2656;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2657)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2657 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2657;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][47] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2653 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2653;
|
|
}
|
|
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 (_afterCall2655)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2655 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2655;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][47] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2636 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2636;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2637)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2637 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2637;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2659, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 7][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "wall";
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch2660)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2664, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2663 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2663;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2664)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2664 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2664;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2662)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2660 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2660;
|
|
}
|
|
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 (_afterCall2662)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2662 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2662;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 7][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "dot";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "dot";
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch2665)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2669, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2668 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2668;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2669)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2669 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2669;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall2667)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2665 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2665;
|
|
}
|
|
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 (_afterCall2667)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2667 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2667;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 7][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = "wall";
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = "wall";
|
|
MACHINE.val = "wall";
|
|
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 (_primitiveBranch2670)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2674, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2673 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2673;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2674)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2674 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2674;
|
|
}
|
|
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 (_primitiveBranch2675)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2679, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2670 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2670;
|
|
}
|
|
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 (_afterCall2672)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2672 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2672;
|
|
}
|
|
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 (_primitiveBranch2675)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2679, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2678 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2678;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2679)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2679 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2679;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][48] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2675 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2675;
|
|
}
|
|
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 (_afterCall2677)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2677 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2677;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][48] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2658 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2658;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2659)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2659 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2659;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2681, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][35] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[35]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 4][35];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][42];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][46];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 4][24];
|
|
MACHINE.val = 0;
|
|
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 (_primitiveBranch2682)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2686, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2685 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2685;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2686)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2686 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2686;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][49] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2682 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2682;
|
|
}
|
|
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 (_afterCall2684)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2684 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2684;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][49] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2680 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2680;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2681)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2681 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2681;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2688, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry25, 1, [MACHINE.env[MACHINE.env.length - 1 - 0]], "tick");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][50] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2687 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2687;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2688)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2688 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2688;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2690, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry27, 2, [MACHINE.env[MACHINE.env.length - 1 - 0]], "tick-pm");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][51] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2689 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2689;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2690)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2690 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2690;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2692, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry28, 4, [MACHINE.env[MACHINE.env.length - 1 - 0]], "checked-move-x");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][55] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2691 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2691;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2692)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2692 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2692;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2694, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry29, 4, [MACHINE.env[MACHINE.env.length - 1 - 0]], "checked-move-y");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][56] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2693 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2693;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2694)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2694 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2694;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2696, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry30, 5, [MACHINE.env[MACHINE.env.length - 1 - 0]], "restrict-move");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][58] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2695 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2695;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2696)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2696 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2696;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2698, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry31, 2, [MACHINE.env[MACHINE.env.length - 1 - 0]], "tick-board");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][52] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2697 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2697;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2698)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2698 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2698;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2700, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry32, 3, [MACHINE.env[MACHINE.env.length - 1 - 0]], "new-board-w-empty-at");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][60] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2699 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2699;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2700)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2700 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2700;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2702, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry33, 3, [MACHINE.env[MACHINE.env.length - 1 - 0]], "tick-board-image");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][53] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2701 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2701;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2702)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2702 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2702;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2704, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry34, 3, [MACHINE.env[MACHINE.env.length - 1 - 0]], "tick-score");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][54] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2703 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2703;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2704)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2704 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2704;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2706, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry35, 2, [MACHINE.env[MACHINE.env.length - 1 - 0]], "key-handler");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][63] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2705 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2705;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2706)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2706 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2706;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2708, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry36, 2, [MACHINE.env[MACHINE.env.length - 1 - 0]], "new-dir-pm");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][64] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2707 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2707;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2708)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2708 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2708;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2710, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry37, 1, [MACHINE.env[MACHINE.env.length - 1 - 0]], "game-over?");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][66] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2709 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2709;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2710)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2710 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2710;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2712, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry38, 1, [MACHINE.env[MACHINE.env.length - 1 - 0]], "empty-board?");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][67] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2711 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2711;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2712)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2712 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2712;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2714, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry39, 1, [MACHINE.env[MACHINE.env.length - 1 - 0]], "render");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][70] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2713 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2713;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2714)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2714 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2714;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2716, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry40, 1, [MACHINE.env[MACHINE.env.length - 1 - 0]], "render-board");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][73] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2715 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2715;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2716)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2716 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2716;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2718, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry41, 2, [MACHINE.env[MACHINE.env.length - 1 - 0]], "render-pm");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][71] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2717 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2717;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2718)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2718 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2718;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2720, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry42, 2, [MACHINE.env[MACHINE.env.length - 1 - 0]], "render-score");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][72] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2719 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2719;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2720)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2720 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2720;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2722, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry43, 1, [MACHINE.env[MACHINE.env.length - 1 - 0]], "cell-image");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][74] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2721 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2721;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2722)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2722 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2722;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2724, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry44, 3, [MACHINE.env[MACHINE.env.length - 1 - 0]], "board-ref");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][59] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2723 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2723;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2724)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2724 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2724;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2726, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry45, 2, [MACHINE.env[MACHINE.env.length - 1 - 0]], "build-vector");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][79] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2725 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2725;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2726)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2726 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2726;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2728, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry46, 2, [MACHINE.env[MACHINE.env.length - 1 - 0]], "map-board");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][61] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2727 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2727;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2728)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2728 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2728;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2730, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry49, 3, [MACHINE.env[MACHINE.env.length - 1 - 0]], "foldr-board");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][68] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2729 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2729;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2730)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2730 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2730;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2732, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry50, 4, [MACHINE.env[MACHINE.env.length - 1 - 0]], "place-cell-image");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][62] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2731 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2731;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2732)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2732 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2732;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2734, 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][87];
|
|
|
|
MACHINE.env.push([undefined]);
|
|
|
|
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined);
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 5][35] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 5].names[35]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.env[MACHINE.env.length - 1 - 5][35];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][32];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 5][3];
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 5][73]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 6][3];
|
|
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 (_primitiveBranch2739)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2743, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2742 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2742;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2743)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2743 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2743;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall2741)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2739 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2739;
|
|
}
|
|
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 (_afterCall2741)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2741 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2741;
|
|
}
|
|
MACHINE.val = 0;
|
|
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 (_primitiveBranch2744)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2748, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2747 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2747;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2748)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2748 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2748;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][0] = MACHINE.val;
|
|
return (_afterCall2746)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2744 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2744;
|
|
}
|
|
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][0] = MACHINE.val;
|
|
return (_afterCall2746)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2746 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2746;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.env[MACHINE.env.length - 1 - 6][82];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 5][0];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 8][83];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 8][50];
|
|
MACHINE.val = RUNTIME.makeFloat(0.3);
|
|
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 (_primitiveBranch2749)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2753, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2752 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2752;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2753)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2753 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2753;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
return (_afterCall2751)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2749 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2749;
|
|
}
|
|
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 (_afterCall2751)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2751 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2751;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6][84]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7][70];
|
|
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 (_primitiveBranch2754)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2758, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2757 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2757;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2758)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2758 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2758;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
return (_afterCall2756)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2754 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2754;
|
|
}
|
|
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 (_afterCall2756)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2756 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2756;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6][85]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7][63];
|
|
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 (_primitiveBranch2759)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2763, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2762 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2762;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2763)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2763 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2763;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall2761)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2759 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2759;
|
|
}
|
|
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 (_afterCall2761)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2761 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2761;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 6][86]);
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 7][66];
|
|
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 (_primitiveBranch2764)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2768, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2767 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2767;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2768)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2768 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2768;
|
|
}
|
|
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 (_primitiveBranch2769)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2773, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2764 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2764;
|
|
}
|
|
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 (_afterCall2766)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2766 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2766;
|
|
}
|
|
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 (_primitiveBranch2769)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2773, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2772 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2772;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((MACHINE.argcount - 1) + 1), 1);
|
|
if (MACHINE.argcount === 0) { return (_afterArgsEvaluated2736)(MACHINE); }
|
|
MACHINE.env.push(MACHINE.val);
|
|
return (_afterArgsEvaluated2736)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2773 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2773;
|
|
}
|
|
MACHINE.argcount = 1;
|
|
return (_afterReturn2774)(MACHINE);
|
|
};
|
|
|
|
var _afterReturn2774 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterReturn2774;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((MACHINE.argcount - 1) + 1), 1);
|
|
if (MACHINE.argcount === 0) { return (_afterArgsEvaluated2736)(MACHINE); }
|
|
MACHINE.env.push(MACHINE.val);
|
|
return (_afterArgsEvaluated2736)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2769 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2769;
|
|
}
|
|
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 (_afterCall2771)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2771 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2771;
|
|
}
|
|
MACHINE.env.splice(MACHINE.env.length - ((MACHINE.argcount - 1) + 1), 1);
|
|
if (MACHINE.argcount === 0) { return (_afterArgsEvaluated2736)(MACHINE); }
|
|
MACHINE.env.push(MACHINE.val);
|
|
return (_afterArgsEvaluated2736)(MACHINE);
|
|
};
|
|
|
|
var _afterArgsEvaluated2736 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterArgsEvaluated2736;
|
|
}
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].pendingApplyValuesProc;
|
|
MACHINE.control.pop();
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch2775)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2779, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2778 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2778;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn2779)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2779 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2779;
|
|
}
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2775 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2775;
|
|
}
|
|
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 (_afterCall2777)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2777 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2777;
|
|
}
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple2733 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2733;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2734)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2734 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2734;
|
|
}
|
|
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/pacman.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterModuleBody2281 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody2281;
|
|
}
|
|
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/pacman.rkt"]);
|
|
};
|
|
|
|
_procReturn161.multipleValueReturn = _procReturnMultiple160;
|
|
_procReturn166.multipleValueReturn = _procReturnMultiple165;
|
|
_procReturn171.multipleValueReturn = _procReturnMultiple170;
|
|
_procReturn183.multipleValueReturn = _procReturnMultiple182;
|
|
_procReturn188.multipleValueReturn = _procReturnMultiple187;
|
|
_procReturn193.multipleValueReturn = _procReturnMultiple192;
|
|
_procReturn205.multipleValueReturn = _procReturnMultiple204;
|
|
_procReturn210.multipleValueReturn = _procReturnMultiple209;
|
|
_procReturn215.multipleValueReturn = _procReturnMultiple214;
|
|
_procReturn225.multipleValueReturn = _procReturnMultiple224;
|
|
_procReturn230.multipleValueReturn = _procReturnMultiple229;
|
|
_procReturn235.multipleValueReturn = _procReturnMultiple234;
|
|
_procReturn253.multipleValueReturn = _procReturnMultiple252;
|
|
_procReturn258.multipleValueReturn = _procReturnMultiple257;
|
|
_procReturn263.multipleValueReturn = _procReturnMultiple262;
|
|
_procReturn273.multipleValueReturn = _procReturnMultiple272;
|
|
_procReturn278.multipleValueReturn = _procReturnMultiple277;
|
|
_procReturn283.multipleValueReturn = _procReturnMultiple282;
|
|
_procReturn288.multipleValueReturn = _procReturnMultiple287;
|
|
_procReturn303.multipleValueReturn = _procReturnMultiple302;
|
|
_procReturn308.multipleValueReturn = _procReturnMultiple307;
|
|
_procReturn313.multipleValueReturn = _procReturnMultiple312;
|
|
_procReturn318.multipleValueReturn = _procReturnMultiple317;
|
|
_procReturn330.multipleValueReturn = _procReturnMultiple329;
|
|
_procReturn342.multipleValueReturn = _procReturnMultiple341;
|
|
_procReturn352.multipleValueReturn = _procReturnMultiple351;
|
|
_procReturn365.multipleValueReturn = _procReturnMultiple364;
|
|
_procReturn370.multipleValueReturn = _procReturnMultiple369;
|
|
_procReturn380.multipleValueReturn = _procReturnMultiple379;
|
|
_procReturn385.multipleValueReturn = _procReturnMultiple384;
|
|
_procReturn395.multipleValueReturn = _procReturnMultiple394;
|
|
_procReturn400.multipleValueReturn = _procReturnMultiple399;
|
|
_procReturn410.multipleValueReturn = _procReturnMultiple409;
|
|
_procReturn415.multipleValueReturn = _procReturnMultiple414;
|
|
_procReturn430.multipleValueReturn = _procReturnMultiple429;
|
|
_procReturn435.multipleValueReturn = _procReturnMultiple434;
|
|
_procReturn445.multipleValueReturn = _procReturnMultiple444;
|
|
_procReturn453.multipleValueReturn = _procReturnMultiple452;
|
|
_procReturn461.multipleValueReturn = _procReturnMultiple460;
|
|
_procReturn468.multipleValueReturn = _procReturnMultiple467;
|
|
_procReturn478.multipleValueReturn = _procReturnMultiple477;
|
|
_procReturn483.multipleValueReturn = _procReturnMultiple482;
|
|
_procReturn493.multipleValueReturn = _procReturnMultiple492;
|
|
_procReturn501.multipleValueReturn = _procReturnMultiple500;
|
|
_procReturn509.multipleValueReturn = _procReturnMultiple508;
|
|
_procReturn516.multipleValueReturn = _procReturnMultiple515;
|
|
_procReturn531.multipleValueReturn = _procReturnMultiple530;
|
|
_procReturn543.multipleValueReturn = _procReturnMultiple542;
|
|
_procReturn555.multipleValueReturn = _procReturnMultiple554;
|
|
_procReturn565.multipleValueReturn = _procReturnMultiple564;
|
|
_procReturn580.multipleValueReturn = _procReturnMultiple579;
|
|
_procReturn585.multipleValueReturn = _procReturnMultiple584;
|
|
_procReturn595.multipleValueReturn = _procReturnMultiple594;
|
|
_procReturn607.multipleValueReturn = _procReturnMultiple606;
|
|
_procReturn612.multipleValueReturn = _procReturnMultiple611;
|
|
_procReturn622.multipleValueReturn = _procReturnMultiple621;
|
|
_procReturn632.multipleValueReturn = _procReturnMultiple631;
|
|
_procReturn637.multipleValueReturn = _procReturnMultiple636;
|
|
_procReturn647.multipleValueReturn = _procReturnMultiple646;
|
|
_procReturn665.multipleValueReturn = _procReturnMultiple664;
|
|
_procReturn670.multipleValueReturn = _procReturnMultiple669;
|
|
_procReturn680.multipleValueReturn = _procReturnMultiple679;
|
|
_procReturn685.multipleValueReturn = _procReturnMultiple684;
|
|
_procReturn697.multipleValueReturn = _procReturnMultiple696;
|
|
_procReturn709.multipleValueReturn = _procReturnMultiple708;
|
|
_procReturn719.multipleValueReturn = _procReturnMultiple718;
|
|
_procReturn734.multipleValueReturn = _procReturnMultiple733;
|
|
_procReturn739.multipleValueReturn = _procReturnMultiple738;
|
|
_procReturn749.multipleValueReturn = _procReturnMultiple748;
|
|
_procReturn759.multipleValueReturn = _procReturnMultiple758;
|
|
_procReturn764.multipleValueReturn = _procReturnMultiple763;
|
|
_procReturn774.multipleValueReturn = _procReturnMultiple773;
|
|
_procReturn789.multipleValueReturn = _procReturnMultiple788;
|
|
_procReturn801.multipleValueReturn = _procReturnMultiple800;
|
|
_procReturn811.multipleValueReturn = _procReturnMultiple810;
|
|
_procReturn824.multipleValueReturn = _procReturnMultiple823;
|
|
_procReturn829.multipleValueReturn = _procReturnMultiple828;
|
|
_procReturn836.multipleValueReturn = _procReturnMultiple835;
|
|
_procReturn843.multipleValueReturn = _procReturnMultiple842;
|
|
_procReturn848.multipleValueReturn = _procReturnMultiple847;
|
|
_procReturn861.multipleValueReturn = _procReturnMultiple860;
|
|
_procReturn866.multipleValueReturn = _procReturnMultiple865;
|
|
_procReturn879.multipleValueReturn = _procReturnMultiple878;
|
|
_procReturn892.multipleValueReturn = _procReturnMultiple891;
|
|
_procReturn897.multipleValueReturn = _procReturnMultiple896;
|
|
_procReturn902.multipleValueReturn = _procReturnMultiple901;
|
|
_procReturn907.multipleValueReturn = _procReturnMultiple906;
|
|
_procReturn917.multipleValueReturn = _procReturnMultiple916;
|
|
_procReturn922.multipleValueReturn = _procReturnMultiple921;
|
|
_procReturn937.multipleValueReturn = _procReturnMultiple936;
|
|
_procReturn944.multipleValueReturn = _procReturnMultiple943;
|
|
_procReturn951.multipleValueReturn = _procReturnMultiple950;
|
|
_procReturn958.multipleValueReturn = _procReturnMultiple957;
|
|
_procReturn967.multipleValueReturn = _procReturnMultiple966;
|
|
_procReturn974.multipleValueReturn = _procReturnMultiple973;
|
|
_procReturn981.multipleValueReturn = _procReturnMultiple980;
|
|
_procReturn989.multipleValueReturn = _procReturnMultiple988;
|
|
_procReturn1003.multipleValueReturn = _procReturnMultiple1002;
|
|
_procReturn1008.multipleValueReturn = _procReturnMultiple1007;
|
|
_procReturn1013.multipleValueReturn = _procReturnMultiple1012;
|
|
_procReturn1021.multipleValueReturn = _procReturnMultiple1020;
|
|
_procReturn1035.multipleValueReturn = _procReturnMultiple1034;
|
|
_procReturn1040.multipleValueReturn = _procReturnMultiple1039;
|
|
_procReturn1045.multipleValueReturn = _procReturnMultiple1044;
|
|
_procReturn1053.multipleValueReturn = _procReturnMultiple1052;
|
|
_procReturn1067.multipleValueReturn = _procReturnMultiple1066;
|
|
_procReturn1072.multipleValueReturn = _procReturnMultiple1071;
|
|
_procReturn1077.multipleValueReturn = _procReturnMultiple1076;
|
|
_procReturn1085.multipleValueReturn = _procReturnMultiple1084;
|
|
_procReturn1099.multipleValueReturn = _procReturnMultiple1098;
|
|
_procReturn1104.multipleValueReturn = _procReturnMultiple1103;
|
|
_procReturn1109.multipleValueReturn = _procReturnMultiple1108;
|
|
_procReturn1114.multipleValueReturn = _procReturnMultiple1113;
|
|
_procReturn1123.multipleValueReturn = _procReturnMultiple1122;
|
|
_procReturn1130.multipleValueReturn = _procReturnMultiple1129;
|
|
_procReturn1138.multipleValueReturn = _procReturnMultiple1137;
|
|
_procReturn1143.multipleValueReturn = _procReturnMultiple1142;
|
|
_procReturn1148.multipleValueReturn = _procReturnMultiple1147;
|
|
_procReturn1155.multipleValueReturn = _procReturnMultiple1154;
|
|
_procReturn1164.multipleValueReturn = _procReturnMultiple1163;
|
|
_procReturn1171.multipleValueReturn = _procReturnMultiple1170;
|
|
_procReturn1179.multipleValueReturn = _procReturnMultiple1178;
|
|
_procReturn1184.multipleValueReturn = _procReturnMultiple1183;
|
|
_procReturn1189.multipleValueReturn = _procReturnMultiple1188;
|
|
_procReturn1198.multipleValueReturn = _procReturnMultiple1197;
|
|
_procReturn1209.multipleValueReturn = _procReturnMultiple1208;
|
|
_procReturn1216.multipleValueReturn = _procReturnMultiple1215;
|
|
_procReturn1224.multipleValueReturn = _procReturnMultiple1223;
|
|
_procReturn1229.multipleValueReturn = _procReturnMultiple1228;
|
|
_procReturn1234.multipleValueReturn = _procReturnMultiple1233;
|
|
_procReturn1252.multipleValueReturn = _procReturnMultiple1251;
|
|
_procReturn1259.multipleValueReturn = _procReturnMultiple1258;
|
|
_procReturn1266.multipleValueReturn = _procReturnMultiple1265;
|
|
_procReturn1274.multipleValueReturn = _procReturnMultiple1273;
|
|
_procReturn1286.multipleValueReturn = _procReturnMultiple1285;
|
|
_procReturn1291.multipleValueReturn = _procReturnMultiple1290;
|
|
_procReturn1296.multipleValueReturn = _procReturnMultiple1295;
|
|
_procReturn1304.multipleValueReturn = _procReturnMultiple1303;
|
|
_procReturn1316.multipleValueReturn = _procReturnMultiple1315;
|
|
_procReturn1321.multipleValueReturn = _procReturnMultiple1320;
|
|
_procReturn1326.multipleValueReturn = _procReturnMultiple1325;
|
|
_procReturn1334.multipleValueReturn = _procReturnMultiple1333;
|
|
_procReturn1346.multipleValueReturn = _procReturnMultiple1345;
|
|
_procReturn1351.multipleValueReturn = _procReturnMultiple1350;
|
|
_procReturn1356.multipleValueReturn = _procReturnMultiple1355;
|
|
_procReturn1364.multipleValueReturn = _procReturnMultiple1363;
|
|
_procReturn1376.multipleValueReturn = _procReturnMultiple1375;
|
|
_procReturn1381.multipleValueReturn = _procReturnMultiple1380;
|
|
_procReturn1386.multipleValueReturn = _procReturnMultiple1385;
|
|
_procReturn1399.multipleValueReturn = _procReturnMultiple1398;
|
|
_procReturn1411.multipleValueReturn = _procReturnMultiple1410;
|
|
_procReturn1416.multipleValueReturn = _procReturnMultiple1415;
|
|
_procReturn1421.multipleValueReturn = _procReturnMultiple1420;
|
|
_procReturn1429.multipleValueReturn = _procReturnMultiple1428;
|
|
_procReturn1441.multipleValueReturn = _procReturnMultiple1440;
|
|
_procReturn1446.multipleValueReturn = _procReturnMultiple1445;
|
|
_procReturn1451.multipleValueReturn = _procReturnMultiple1450;
|
|
_procReturn1459.multipleValueReturn = _procReturnMultiple1458;
|
|
_procReturn1471.multipleValueReturn = _procReturnMultiple1470;
|
|
_procReturn1476.multipleValueReturn = _procReturnMultiple1475;
|
|
_procReturn1481.multipleValueReturn = _procReturnMultiple1480;
|
|
_procReturn1489.multipleValueReturn = _procReturnMultiple1488;
|
|
_procReturn1501.multipleValueReturn = _procReturnMultiple1500;
|
|
_procReturn1506.multipleValueReturn = _procReturnMultiple1505;
|
|
_procReturn1511.multipleValueReturn = _procReturnMultiple1510;
|
|
_procReturn1519.multipleValueReturn = _procReturnMultiple1518;
|
|
_procReturn1524.multipleValueReturn = _procReturnMultiple1523;
|
|
_procReturn1529.multipleValueReturn = _procReturnMultiple1528;
|
|
_procReturn1536.multipleValueReturn = _procReturnMultiple1535;
|
|
_procReturn1543.multipleValueReturn = _procReturnMultiple1542;
|
|
_procReturn1551.multipleValueReturn = _procReturnMultiple1550;
|
|
_procReturn1556.multipleValueReturn = _procReturnMultiple1555;
|
|
_procReturn1561.multipleValueReturn = _procReturnMultiple1560;
|
|
_procReturn1566.multipleValueReturn = _procReturnMultiple1565;
|
|
_procReturn1573.multipleValueReturn = _procReturnMultiple1572;
|
|
_procReturn1580.multipleValueReturn = _procReturnMultiple1579;
|
|
_procReturn1585.multipleValueReturn = _procReturnMultiple1584;
|
|
_procReturn1592.multipleValueReturn = _procReturnMultiple1591;
|
|
_procReturn1599.multipleValueReturn = _procReturnMultiple1598;
|
|
_procReturn1606.multipleValueReturn = _procReturnMultiple1605;
|
|
_procReturn1613.multipleValueReturn = _procReturnMultiple1612;
|
|
_procReturn1621.multipleValueReturn = _procReturnMultiple1620;
|
|
_procReturn1626.multipleValueReturn = _procReturnMultiple1625;
|
|
_procReturn1631.multipleValueReturn = _procReturnMultiple1630;
|
|
_procReturn1645.multipleValueReturn = _procReturnMultiple1644;
|
|
_procReturn1652.multipleValueReturn = _procReturnMultiple1651;
|
|
_procReturn1660.multipleValueReturn = _procReturnMultiple1659;
|
|
_procReturn1665.multipleValueReturn = _procReturnMultiple1664;
|
|
_procReturn1670.multipleValueReturn = _procReturnMultiple1669;
|
|
_procReturn1675.multipleValueReturn = _procReturnMultiple1674;
|
|
_procReturn1685.multipleValueReturn = _procReturnMultiple1684;
|
|
_procReturn1690.multipleValueReturn = _procReturnMultiple1689;
|
|
_procReturn1695.multipleValueReturn = _procReturnMultiple1694;
|
|
_procReturn1700.multipleValueReturn = _procReturnMultiple1699;
|
|
_procReturn1708.multipleValueReturn = _procReturnMultiple1707;
|
|
_procReturn1713.multipleValueReturn = _procReturnMultiple1712;
|
|
_procReturn1718.multipleValueReturn = _procReturnMultiple1717;
|
|
_procReturn1723.multipleValueReturn = _procReturnMultiple1722;
|
|
_procReturn1731.multipleValueReturn = _procReturnMultiple1730;
|
|
_procReturn1736.multipleValueReturn = _procReturnMultiple1735;
|
|
_procReturn1741.multipleValueReturn = _procReturnMultiple1740;
|
|
_procReturn1746.multipleValueReturn = _procReturnMultiple1745;
|
|
_procReturn1754.multipleValueReturn = _procReturnMultiple1753;
|
|
_procReturn1759.multipleValueReturn = _procReturnMultiple1758;
|
|
_procReturn1764.multipleValueReturn = _procReturnMultiple1763;
|
|
_procReturn1769.multipleValueReturn = _procReturnMultiple1768;
|
|
_procReturn1774.multipleValueReturn = _procReturnMultiple1773;
|
|
_procReturn1779.multipleValueReturn = _procReturnMultiple1778;
|
|
_procReturn1784.multipleValueReturn = _procReturnMultiple1783;
|
|
_procReturn1797.multipleValueReturn = _procReturnMultiple1796;
|
|
_procReturn1802.multipleValueReturn = _procReturnMultiple1801;
|
|
_procReturn1807.multipleValueReturn = _procReturnMultiple1806;
|
|
_procReturn1820.multipleValueReturn = _procReturnMultiple1819;
|
|
_procReturn1825.multipleValueReturn = _procReturnMultiple1824;
|
|
_procReturn1830.multipleValueReturn = _procReturnMultiple1829;
|
|
_procReturn1843.multipleValueReturn = _procReturnMultiple1842;
|
|
_procReturn1848.multipleValueReturn = _procReturnMultiple1847;
|
|
_procReturn1853.multipleValueReturn = _procReturnMultiple1852;
|
|
_procReturn1866.multipleValueReturn = _procReturnMultiple1865;
|
|
_procReturn1871.multipleValueReturn = _procReturnMultiple1870;
|
|
_procReturn1876.multipleValueReturn = _procReturnMultiple1875;
|
|
_procReturn1886.multipleValueReturn = _procReturnMultiple1885;
|
|
_procReturn1897.multipleValueReturn = _procReturnMultiple1896;
|
|
_procReturn1904.multipleValueReturn = _procReturnMultiple1903;
|
|
_procReturn1909.multipleValueReturn = _procReturnMultiple1908;
|
|
_procReturn1923.multipleValueReturn = _procReturnMultiple1922;
|
|
_procReturn1930.multipleValueReturn = _procReturnMultiple1929;
|
|
_procReturn1935.multipleValueReturn = _procReturnMultiple1934;
|
|
_procReturn1945.multipleValueReturn = _procReturnMultiple1944;
|
|
_procReturn1952.multipleValueReturn = _procReturnMultiple1951;
|
|
_procReturn1959.multipleValueReturn = _procReturnMultiple1958;
|
|
_procReturn1968.multipleValueReturn = _procReturnMultiple1967;
|
|
_procReturn1973.multipleValueReturn = _procReturnMultiple1972;
|
|
_procReturn1978.multipleValueReturn = _procReturnMultiple1977;
|
|
_procReturn1983.multipleValueReturn = _procReturnMultiple1982;
|
|
_procReturn1992.multipleValueReturn = _procReturnMultiple1991;
|
|
_procReturn1999.multipleValueReturn = _procReturnMultiple1998;
|
|
_procReturn2015.multipleValueReturn = _procReturnMultiple2014;
|
|
_procReturn2022.multipleValueReturn = _procReturnMultiple2021;
|
|
_procReturn2027.multipleValueReturn = _procReturnMultiple2026;
|
|
_procReturn2035.multipleValueReturn = _procReturnMultiple2034;
|
|
_procReturn2045.multipleValueReturn = _procReturnMultiple2044;
|
|
_procReturn2055.multipleValueReturn = _procReturnMultiple2054;
|
|
_procReturn2065.multipleValueReturn = _procReturnMultiple2064;
|
|
_procReturn2077.multipleValueReturn = _procReturnMultiple2076;
|
|
_procReturn2084.multipleValueReturn = _procReturnMultiple2083;
|
|
_procReturn2098.multipleValueReturn = _procReturnMultiple2097;
|
|
_procReturn2103.multipleValueReturn = _procReturnMultiple2102;
|
|
_procReturn2108.multipleValueReturn = _procReturnMultiple2107;
|
|
_procReturn2121.multipleValueReturn = _procReturnMultiple2120;
|
|
_procReturn2129.multipleValueReturn = _procReturnMultiple2128;
|
|
_procReturn2137.multipleValueReturn = _procReturnMultiple2136;
|
|
_procReturn2142.multipleValueReturn = _procReturnMultiple2141;
|
|
_procReturn2152.multipleValueReturn = _procReturnMultiple2151;
|
|
_procReturn2162.multipleValueReturn = _procReturnMultiple2161;
|
|
_procReturn2167.multipleValueReturn = _procReturnMultiple2166;
|
|
_procReturn2175.multipleValueReturn = _procReturnMultiple2174;
|
|
_procReturn2180.multipleValueReturn = _procReturnMultiple2179;
|
|
_procReturn2188.multipleValueReturn = _procReturnMultiple2187;
|
|
_procReturn2193.multipleValueReturn = _procReturnMultiple2192;
|
|
_procReturn2201.multipleValueReturn = _procReturnMultiple2200;
|
|
_procReturn2206.multipleValueReturn = _procReturnMultiple2205;
|
|
_procReturn2211.multipleValueReturn = _procReturnMultiple2210;
|
|
_procReturn2216.multipleValueReturn = _procReturnMultiple2215;
|
|
_procReturn2226.multipleValueReturn = _procReturnMultiple2225;
|
|
_procReturn2231.multipleValueReturn = _procReturnMultiple2230;
|
|
_procReturn2241.multipleValueReturn = _procReturnMultiple2240;
|
|
_procReturn2246.multipleValueReturn = _procReturnMultiple2245;
|
|
_procReturn2258.multipleValueReturn = _procReturnMultiple2257;
|
|
_procReturn2265.multipleValueReturn = _procReturnMultiple2264;
|
|
_procReturn2270.multipleValueReturn = _procReturnMultiple2269;
|
|
_onReturn2286.multipleValueReturn = _onReturnMultiple2285;
|
|
_onReturn2290.multipleValueReturn = _onReturnMultiple2289;
|
|
_beforePromptPop2292.multipleValueReturn = _beforePromptPopMultiple2291;
|
|
_beforePromptPop2294.multipleValueReturn = _beforePromptPopMultiple2293;
|
|
_beforePromptPop2296.multipleValueReturn = _beforePromptPopMultiple2295;
|
|
_beforePromptPop2298.multipleValueReturn = _beforePromptPopMultiple2297;
|
|
_beforePromptPop2300.multipleValueReturn = _beforePromptPopMultiple2299;
|
|
_beforePromptPop2302.multipleValueReturn = _beforePromptPopMultiple2301;
|
|
_beforePromptPop2304.multipleValueReturn = _beforePromptPopMultiple2303;
|
|
_beforePromptPop2306.multipleValueReturn = _beforePromptPopMultiple2305;
|
|
_beforePromptPop2308.multipleValueReturn = _beforePromptPopMultiple2307;
|
|
_beforePromptPop2310.multipleValueReturn = _beforePromptPopMultiple2309;
|
|
_beforePromptPop2312.multipleValueReturn = _beforePromptPopMultiple2311;
|
|
_beforePromptPop2314.multipleValueReturn = _beforePromptPopMultiple2313;
|
|
_beforePromptPop2316.multipleValueReturn = _beforePromptPopMultiple2315;
|
|
_beforePromptPop2318.multipleValueReturn = _beforePromptPopMultiple2317;
|
|
_beforePromptPop2320.multipleValueReturn = _beforePromptPopMultiple2319;
|
|
_procReturn2327.multipleValueReturn = _procReturnMultiple2326;
|
|
_procReturn2332.multipleValueReturn = _procReturnMultiple2331;
|
|
_procReturn2337.multipleValueReturn = _procReturnMultiple2336;
|
|
_procReturn2342.multipleValueReturn = _procReturnMultiple2341;
|
|
_procReturn2347.multipleValueReturn = _procReturnMultiple2346;
|
|
_procReturn2352.multipleValueReturn = _procReturnMultiple2351;
|
|
_procReturn2357.multipleValueReturn = _procReturnMultiple2356;
|
|
_procReturn2362.multipleValueReturn = _procReturnMultiple2361;
|
|
_procReturn2367.multipleValueReturn = _procReturnMultiple2366;
|
|
_beforePromptPop2322.multipleValueReturn = _beforePromptPopMultiple2321;
|
|
_procReturn2374.multipleValueReturn = _procReturnMultiple2373;
|
|
_procReturn2379.multipleValueReturn = _procReturnMultiple2378;
|
|
_procReturn2384.multipleValueReturn = _procReturnMultiple2383;
|
|
_beforePromptPop2369.multipleValueReturn = _beforePromptPopMultiple2368;
|
|
_beforePromptPop2386.multipleValueReturn = _beforePromptPopMultiple2385;
|
|
_procReturn2393.multipleValueReturn = _procReturnMultiple2392;
|
|
_procReturn2398.multipleValueReturn = _procReturnMultiple2397;
|
|
_beforePromptPop2388.multipleValueReturn = _beforePromptPopMultiple2387;
|
|
_procReturn2405.multipleValueReturn = _procReturnMultiple2404;
|
|
_beforePromptPop2400.multipleValueReturn = _beforePromptPopMultiple2399;
|
|
_procReturn2412.multipleValueReturn = _procReturnMultiple2411;
|
|
_procReturn2417.multipleValueReturn = _procReturnMultiple2416;
|
|
_beforePromptPop2407.multipleValueReturn = _beforePromptPopMultiple2406;
|
|
_procReturn2424.multipleValueReturn = _procReturnMultiple2423;
|
|
_beforePromptPop2419.multipleValueReturn = _beforePromptPopMultiple2418;
|
|
_beforePromptPop2426.multipleValueReturn = _beforePromptPopMultiple2425;
|
|
_beforePromptPop2428.multipleValueReturn = _beforePromptPopMultiple2427;
|
|
_procReturn2435.multipleValueReturn = _procReturnMultiple2434;
|
|
_beforePromptPop2430.multipleValueReturn = _beforePromptPopMultiple2429;
|
|
_procReturn2442.multipleValueReturn = _procReturnMultiple2441;
|
|
_beforePromptPop2437.multipleValueReturn = _beforePromptPopMultiple2436;
|
|
_procReturn2449.multipleValueReturn = _procReturnMultiple2448;
|
|
_procReturn2454.multipleValueReturn = _procReturnMultiple2453;
|
|
_beforePromptPop2444.multipleValueReturn = _beforePromptPopMultiple2443;
|
|
_procReturn2461.multipleValueReturn = _procReturnMultiple2460;
|
|
_beforePromptPop2456.multipleValueReturn = _beforePromptPopMultiple2455;
|
|
_procReturn2468.multipleValueReturn = _procReturnMultiple2467;
|
|
_beforePromptPop2463.multipleValueReturn = _beforePromptPopMultiple2462;
|
|
_procReturn2475.multipleValueReturn = _procReturnMultiple2474;
|
|
_beforePromptPop2470.multipleValueReturn = _beforePromptPopMultiple2469;
|
|
_beforePromptPop2477.multipleValueReturn = _beforePromptPopMultiple2476;
|
|
_procReturn2486.multipleValueReturn = _procReturnMultiple2485;
|
|
_procReturn2491.multipleValueReturn = _procReturnMultiple2490;
|
|
_procReturn2497.multipleValueReturn = _procReturnMultiple2496;
|
|
_procReturn2502.multipleValueReturn = _procReturnMultiple2501;
|
|
_procReturn2507.multipleValueReturn = _procReturnMultiple2506;
|
|
_procReturn2512.multipleValueReturn = _procReturnMultiple2511;
|
|
_beforePromptPop2479.multipleValueReturn = _beforePromptPopMultiple2478;
|
|
_procReturn2520.multipleValueReturn = _procReturnMultiple2519;
|
|
_beforePromptPop2515.multipleValueReturn = _beforePromptPopMultiple2514;
|
|
_procReturn2527.multipleValueReturn = _procReturnMultiple2526;
|
|
_procReturn2532.multipleValueReturn = _procReturnMultiple2531;
|
|
_procReturn2537.multipleValueReturn = _procReturnMultiple2536;
|
|
_beforePromptPop2522.multipleValueReturn = _beforePromptPopMultiple2521;
|
|
_procReturn2546.multipleValueReturn = _procReturnMultiple2545;
|
|
_procReturn2551.multipleValueReturn = _procReturnMultiple2550;
|
|
_procReturn2557.multipleValueReturn = _procReturnMultiple2556;
|
|
_procReturn2562.multipleValueReturn = _procReturnMultiple2561;
|
|
_procReturn2567.multipleValueReturn = _procReturnMultiple2566;
|
|
_procReturn2572.multipleValueReturn = _procReturnMultiple2571;
|
|
_procReturn2577.multipleValueReturn = _procReturnMultiple2576;
|
|
_beforePromptPop2539.multipleValueReturn = _beforePromptPopMultiple2538;
|
|
_procReturn2585.multipleValueReturn = _procReturnMultiple2584;
|
|
_beforePromptPop2580.multipleValueReturn = _beforePromptPopMultiple2579;
|
|
_procReturn2592.multipleValueReturn = _procReturnMultiple2591;
|
|
_beforePromptPop2587.multipleValueReturn = _beforePromptPopMultiple2586;
|
|
_procReturn2599.multipleValueReturn = _procReturnMultiple2598;
|
|
_beforePromptPop2594.multipleValueReturn = _beforePromptPopMultiple2593;
|
|
_procReturn2606.multipleValueReturn = _procReturnMultiple2605;
|
|
_beforePromptPop2601.multipleValueReturn = _beforePromptPopMultiple2600;
|
|
_procReturn2613.multipleValueReturn = _procReturnMultiple2612;
|
|
_beforePromptPop2608.multipleValueReturn = _beforePromptPopMultiple2607;
|
|
_procReturn2620.multipleValueReturn = _procReturnMultiple2619;
|
|
_procReturn2625.multipleValueReturn = _procReturnMultiple2624;
|
|
_procReturn2630.multipleValueReturn = _procReturnMultiple2629;
|
|
_procReturn2635.multipleValueReturn = _procReturnMultiple2634;
|
|
_beforePromptPop2615.multipleValueReturn = _beforePromptPopMultiple2614;
|
|
_procReturn2642.multipleValueReturn = _procReturnMultiple2641;
|
|
_procReturn2647.multipleValueReturn = _procReturnMultiple2646;
|
|
_procReturn2652.multipleValueReturn = _procReturnMultiple2651;
|
|
_procReturn2657.multipleValueReturn = _procReturnMultiple2656;
|
|
_beforePromptPop2637.multipleValueReturn = _beforePromptPopMultiple2636;
|
|
_procReturn2664.multipleValueReturn = _procReturnMultiple2663;
|
|
_procReturn2669.multipleValueReturn = _procReturnMultiple2668;
|
|
_procReturn2674.multipleValueReturn = _procReturnMultiple2673;
|
|
_procReturn2679.multipleValueReturn = _procReturnMultiple2678;
|
|
_beforePromptPop2659.multipleValueReturn = _beforePromptPopMultiple2658;
|
|
_procReturn2686.multipleValueReturn = _procReturnMultiple2685;
|
|
_beforePromptPop2681.multipleValueReturn = _beforePromptPopMultiple2680;
|
|
_beforePromptPop2688.multipleValueReturn = _beforePromptPopMultiple2687;
|
|
_beforePromptPop2690.multipleValueReturn = _beforePromptPopMultiple2689;
|
|
_beforePromptPop2692.multipleValueReturn = _beforePromptPopMultiple2691;
|
|
_beforePromptPop2694.multipleValueReturn = _beforePromptPopMultiple2693;
|
|
_beforePromptPop2696.multipleValueReturn = _beforePromptPopMultiple2695;
|
|
_beforePromptPop2698.multipleValueReturn = _beforePromptPopMultiple2697;
|
|
_beforePromptPop2700.multipleValueReturn = _beforePromptPopMultiple2699;
|
|
_beforePromptPop2702.multipleValueReturn = _beforePromptPopMultiple2701;
|
|
_beforePromptPop2704.multipleValueReturn = _beforePromptPopMultiple2703;
|
|
_beforePromptPop2706.multipleValueReturn = _beforePromptPopMultiple2705;
|
|
_beforePromptPop2708.multipleValueReturn = _beforePromptPopMultiple2707;
|
|
_beforePromptPop2710.multipleValueReturn = _beforePromptPopMultiple2709;
|
|
_beforePromptPop2712.multipleValueReturn = _beforePromptPopMultiple2711;
|
|
_beforePromptPop2714.multipleValueReturn = _beforePromptPopMultiple2713;
|
|
_beforePromptPop2716.multipleValueReturn = _beforePromptPopMultiple2715;
|
|
_beforePromptPop2718.multipleValueReturn = _beforePromptPopMultiple2717;
|
|
_beforePromptPop2720.multipleValueReturn = _beforePromptPopMultiple2719;
|
|
_beforePromptPop2722.multipleValueReturn = _beforePromptPopMultiple2721;
|
|
_beforePromptPop2724.multipleValueReturn = _beforePromptPopMultiple2723;
|
|
_beforePromptPop2726.multipleValueReturn = _beforePromptPopMultiple2725;
|
|
_beforePromptPop2728.multipleValueReturn = _beforePromptPopMultiple2727;
|
|
_beforePromptPop2730.multipleValueReturn = _beforePromptPopMultiple2729;
|
|
_beforePromptPop2732.multipleValueReturn = _beforePromptPopMultiple2731;
|
|
_procReturn2743.multipleValueReturn = _procReturnMultiple2742;
|
|
_procReturn2748.multipleValueReturn = _procReturnMultiple2747;
|
|
_procReturn2753.multipleValueReturn = _procReturnMultiple2752;
|
|
_procReturn2758.multipleValueReturn = _procReturnMultiple2757;
|
|
_procReturn2763.multipleValueReturn = _procReturnMultiple2762;
|
|
_procReturn2768.multipleValueReturn = _procReturnMultiple2767;
|
|
_procReturn2773.multipleValueReturn = _procReturnMultiple2772;
|
|
_procReturn2779.multipleValueReturn = _procReturnMultiple2778;
|
|
_beforePromptPop2734.multipleValueReturn = _beforePromptPopMultiple2733;
|
|
_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, _start2780); })(MACHINE, function() { (function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start2790 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start2790;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt2783, 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", _moduleEntry2785);
|
|
return (_afterModuleBody2784)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies2781 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies2781;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt2783, 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", _moduleEntry2785);
|
|
return (_afterModuleBody2784)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry2785 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry2785;
|
|
}
|
|
MACHINE.modules["whalesong/lang/base.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["collects/racket/private/modbeg.rkt"] !== undefined) !== false) { return (_linked2786)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module collects/racket/private/modbeg.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2787)(MACHINE);
|
|
};
|
|
|
|
var _linked2786 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked2786;
|
|
}
|
|
if (MACHINE.modules["collects/racket/private/modbeg.rkt"].isInvoked !== false) { return (_alreadyLoaded2787)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn2789, MACHINE.proc));
|
|
return (MACHINE.modules["collects/racket/private/modbeg.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple2788 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple2788;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn2789)(MACHINE);
|
|
};
|
|
|
|
var _onReturn2789 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn2789;
|
|
}
|
|
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 _alreadyLoaded2787 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded2787;
|
|
}
|
|
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 _afterModuleBody2784 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody2784;
|
|
}
|
|
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 _beforePopPromptMultiple2782 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple2782;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt2783)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt2783 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt2783;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn2789.multipleValueReturn = _onReturnMultiple2788;
|
|
_beforePopPrompt2783.multipleValueReturn = _beforePopPromptMultiple2782;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start2790); })(MACHINE, function() { (function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start2813 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start2813;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt2793, 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", _moduleEntry2810);
|
|
return (_afterModuleBody2809)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry51 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry51;
|
|
}
|
|
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 (_primitiveBranch2794)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2798, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2797 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2797;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2798)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2798 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2798;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall2796)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2794 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2794;
|
|
}
|
|
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 (_afterCall2796)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2796 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2796;
|
|
}
|
|
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 (_primitiveBranch2799)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2803, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2802 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2802;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn2803)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2803 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2803;
|
|
}
|
|
|
|
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 (_primitiveBranch2804)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 _primitiveBranch2799 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2799;
|
|
}
|
|
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 (_afterCall2801)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2801 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2801;
|
|
}
|
|
|
|
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 (_primitiveBranch2804)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 _primitiveBranch2804 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2804;
|
|
}
|
|
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 _afterLamBodies2791 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies2791;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt2793, 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", _moduleEntry2810);
|
|
return (_afterModuleBody2809)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry2810 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry2810;
|
|
}
|
|
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(_beforePromptPop2812, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry51, (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 _beforePromptPopMultiple2811 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2811;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2812)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2812 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2812;
|
|
}
|
|
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 _afterModuleBody2809 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody2809;
|
|
}
|
|
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 _beforePopPromptMultiple2792 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple2792;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt2793)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt2793 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt2793;
|
|
}
|
|
|
|
};
|
|
|
|
_procReturn2798.multipleValueReturn = _procReturnMultiple2797;
|
|
_procReturn2803.multipleValueReturn = _procReturnMultiple2802;
|
|
_beforePromptPop2812.multipleValueReturn = _beforePromptPopMultiple2811;
|
|
_beforePopPrompt2793.multipleValueReturn = _beforePopPromptMultiple2792;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start2813); })(MACHINE, function() { (function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start2831 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start2831;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt2816, 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", _moduleEntry2818);
|
|
return (_afterModuleBody2817)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies2814 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies2814;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt2816, 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", _moduleEntry2818);
|
|
return (_afterModuleBody2817)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry2818 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry2818;
|
|
}
|
|
MACHINE.modules["whalesong/world.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/lang/base.rkt"] !== undefined) !== false) { return (_linked2819)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/lang/base.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2820)(MACHINE);
|
|
};
|
|
|
|
var _linked2819 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked2819;
|
|
}
|
|
if (MACHINE.modules["whalesong/lang/base.rkt"].isInvoked !== false) { return (_alreadyLoaded2820)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn2822, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/lang/base.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple2821 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple2821;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn2822)(MACHINE);
|
|
};
|
|
|
|
var _onReturn2822 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn2822;
|
|
}
|
|
if ((MACHINE.modules["whalesong/world/main.rkt"] !== undefined) !== false) { return (_linked2823)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/world/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2824)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded2820 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded2820;
|
|
}
|
|
if ((MACHINE.modules["whalesong/world/main.rkt"] !== undefined) !== false) { return (_linked2823)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/world/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2824)(MACHINE);
|
|
};
|
|
|
|
var _linked2823 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked2823;
|
|
}
|
|
if (MACHINE.modules["whalesong/world/main.rkt"].isInvoked !== false) { return (_alreadyLoaded2824)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn2826, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/world/main.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple2825 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple2825;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn2826)(MACHINE);
|
|
};
|
|
|
|
var _onReturn2826 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn2826;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image.rkt"] !== undefined) !== false) { return (_linked2827)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2828)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded2824 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded2824;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image.rkt"] !== undefined) !== false) { return (_linked2827)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2828)(MACHINE);
|
|
};
|
|
|
|
var _linked2827 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked2827;
|
|
}
|
|
if (MACHINE.modules["whalesong/image.rkt"].isInvoked !== false) { return (_alreadyLoaded2828)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn2830, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/image.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple2829 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple2829;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn2830)(MACHINE);
|
|
};
|
|
|
|
var _onReturn2830 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn2830;
|
|
}
|
|
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 _alreadyLoaded2828 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded2828;
|
|
}
|
|
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 _afterModuleBody2817 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody2817;
|
|
}
|
|
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 _beforePopPromptMultiple2815 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple2815;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt2816)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt2816 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt2816;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn2822.multipleValueReturn = _onReturnMultiple2821;
|
|
_onReturn2826.multipleValueReturn = _onReturnMultiple2825;
|
|
_onReturn2830.multipleValueReturn = _onReturnMultiple2829;
|
|
_beforePopPrompt2816.multipleValueReturn = _beforePopPromptMultiple2815;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start2831); })(MACHINE, function() {
|
|
MACHINE.modules["whalesong/world/main.rkt"] =
|
|
new plt.runtime.ModuleRecord("whalesong/world/main.rkt",
|
|
function(MACHINE) {
|
|
var afterName1008 = 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,
|
|
afterName1008,
|
|
MACHINE.params.currentErrorHandler);
|
|
} else {
|
|
afterName1008();
|
|
}
|
|
});
|
|
(function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start2845 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start2845;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt2834, 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", _moduleEntry2836);
|
|
return (_afterModuleBody2835)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies2832 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies2832;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt2834, 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", _moduleEntry2836);
|
|
return (_afterModuleBody2835)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry2836 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry2836;
|
|
}
|
|
MACHINE.modules["whalesong/image.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/lang/base.rkt"] !== undefined) !== false) { return (_linked2837)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/lang/base.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2838)(MACHINE);
|
|
};
|
|
|
|
var _linked2837 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked2837;
|
|
}
|
|
if (MACHINE.modules["whalesong/lang/base.rkt"].isInvoked !== false) { return (_alreadyLoaded2838)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn2840, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/lang/base.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple2839 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple2839;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn2840)(MACHINE);
|
|
};
|
|
|
|
var _onReturn2840 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn2840;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/main.rkt"] !== undefined) !== false) { return (_linked2841)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2842)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded2838 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded2838;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/main.rkt"] !== undefined) !== false) { return (_linked2841)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2842)(MACHINE);
|
|
};
|
|
|
|
var _linked2841 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked2841;
|
|
}
|
|
if (MACHINE.modules["whalesong/image/main.rkt"].isInvoked !== false) { return (_alreadyLoaded2842)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn2844, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/image/main.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple2843 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple2843;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn2844)(MACHINE);
|
|
};
|
|
|
|
var _onReturn2844 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn2844;
|
|
}
|
|
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 _alreadyLoaded2842 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded2842;
|
|
}
|
|
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 _afterModuleBody2835 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody2835;
|
|
}
|
|
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 _beforePopPromptMultiple2833 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple2833;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt2834)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt2834 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt2834;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn2840.multipleValueReturn = _onReturnMultiple2839;
|
|
_onReturn2844.multipleValueReturn = _onReturnMultiple2843;
|
|
_beforePopPrompt2834.multipleValueReturn = _beforePopPromptMultiple2833;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start2845); })(MACHINE, function() { (function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start2863 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start2863;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt2848, 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", _moduleEntry2850);
|
|
return (_afterModuleBody2849)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies2846 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies2846;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt2848, 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", _moduleEntry2850);
|
|
return (_afterModuleBody2849)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry2850 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry2850;
|
|
}
|
|
MACHINE.modules["whalesong/image/main.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/lang/base.rkt"] !== undefined) !== false) { return (_linked2851)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/lang/base.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2852)(MACHINE);
|
|
};
|
|
|
|
var _linked2851 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked2851;
|
|
}
|
|
if (MACHINE.modules["whalesong/lang/base.rkt"].isInvoked !== false) { return (_alreadyLoaded2852)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn2854, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/lang/base.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple2853 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple2853;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn2854)(MACHINE);
|
|
};
|
|
|
|
var _onReturn2854 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn2854;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/private/main.rkt"] !== undefined) !== false) { return (_linked2855)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/private/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2856)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded2852 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded2852;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/private/main.rkt"] !== undefined) !== false) { return (_linked2855)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/private/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2856)(MACHINE);
|
|
};
|
|
|
|
var _linked2855 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked2855;
|
|
}
|
|
if (MACHINE.modules["whalesong/image/private/main.rkt"].isInvoked !== false) { return (_alreadyLoaded2856)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn2858, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/image/private/main.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple2857 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple2857;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn2858)(MACHINE);
|
|
};
|
|
|
|
var _onReturn2858 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn2858;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/private/color.rkt"] !== undefined) !== false) { return (_linked2859)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/private/color.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2860)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded2856 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded2856;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/private/color.rkt"] !== undefined) !== false) { return (_linked2859)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/private/color.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2860)(MACHINE);
|
|
};
|
|
|
|
var _linked2859 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked2859;
|
|
}
|
|
if (MACHINE.modules["whalesong/image/private/color.rkt"].isInvoked !== false) { return (_alreadyLoaded2860)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn2862, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/image/private/color.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple2861 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple2861;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn2862)(MACHINE);
|
|
};
|
|
|
|
var _onReturn2862 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn2862;
|
|
}
|
|
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 _alreadyLoaded2860 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded2860;
|
|
}
|
|
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 _afterModuleBody2849 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody2849;
|
|
}
|
|
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 _beforePopPromptMultiple2847 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple2847;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt2848)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt2848 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt2848;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn2854.multipleValueReturn = _onReturnMultiple2853;
|
|
_onReturn2858.multipleValueReturn = _onReturnMultiple2857;
|
|
_onReturn2862.multipleValueReturn = _onReturnMultiple2861;
|
|
_beforePopPrompt2848.multipleValueReturn = _beforePopPromptMultiple2847;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start2863); })(MACHINE, function() { (function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start2928 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start2928;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt2866, 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", _moduleEntry2880);
|
|
return (_afterModuleBody2879)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry99 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry99;
|
|
}
|
|
if (! RUNTIME.isArityMatching(((MACHINE.proc).closedVals[(MACHINE.proc).closedVals.length - 1 - 0]).arity, MACHINE.argcount)) { return (_notMatch2867)(MACHINE); }
|
|
MACHINE.proc = (MACHINE.proc).closedVals[(MACHINE.proc).closedVals.length - 1 - 0];
|
|
return (_lamEntry100)(MACHINE);
|
|
};
|
|
|
|
var _notMatch2867 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _notMatch2867;
|
|
}
|
|
if (! RUNTIME.isArityMatching(((MACHINE.proc).closedVals[(MACHINE.proc).closedVals.length - 1 - 1]).arity, MACHINE.argcount)) { return (_notMatch2868)(MACHINE); }
|
|
MACHINE.proc = (MACHINE.proc).closedVals[(MACHINE.proc).closedVals.length - 1 - 1];
|
|
return (_lamEntry101)(MACHINE);
|
|
};
|
|
|
|
var _notMatch2868 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _notMatch2868;
|
|
}
|
|
|
|
};
|
|
|
|
var _lamEntry100 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry100;
|
|
}
|
|
|
|
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 (_primitiveBranch2869)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 _primitiveBranch2869 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2869;
|
|
}
|
|
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 _lamEntry101 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry101;
|
|
}
|
|
|
|
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 (_primitiveBranch2874)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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 _primitiveBranch2874 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2874;
|
|
}
|
|
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 _afterLamBodies2864 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies2864;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt2866, 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", _moduleEntry2880);
|
|
return (_afterModuleBody2879)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry2880 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry2880;
|
|
}
|
|
MACHINE.modules["whalesong/image/private/color.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/lang/base.rkt"] !== undefined) !== false) { return (_linked2881)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/lang/base.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2882)(MACHINE);
|
|
};
|
|
|
|
var _linked2881 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked2881;
|
|
}
|
|
if (MACHINE.modules["whalesong/lang/base.rkt"].isInvoked !== false) { return (_alreadyLoaded2882)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn2884, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/lang/base.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple2883 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple2883;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn2884)(MACHINE);
|
|
};
|
|
|
|
var _onReturn2884 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn2884;
|
|
}
|
|
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(_beforePromptPop2886, 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 (_primitiveBranch2889)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2893, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded2882 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded2882;
|
|
}
|
|
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(_beforePromptPop2886, 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 (_primitiveBranch2889)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2893, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2892 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2892;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2893)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2893 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2893;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 6] = MACHINE.val;
|
|
return (_afterCall2891)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2889 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2889;
|
|
}
|
|
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 (_afterCall2891)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2891 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2891;
|
|
}
|
|
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 (_primitiveBranch2894)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2898, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2897 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2897;
|
|
}
|
|
if ((MACHINE.argcount - 5) === 0) { return (_afterValueCheck2899)(MACHINE); }
|
|
return (_procReturn2898)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2898 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2898;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 5);
|
|
return (_afterValueCheck2899)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck2899 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck2899;
|
|
}
|
|
|
|
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 (_primitiveBranch2900)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2904, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2894 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2894;
|
|
}
|
|
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 (_afterCall2896)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2896 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2896;
|
|
}
|
|
|
|
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 (_primitiveBranch2900)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2904, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2903 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2903;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2904)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2904 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2904;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 3] = MACHINE.val;
|
|
return (_afterCall2902)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2900 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2900;
|
|
}
|
|
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 (_afterCall2902)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2902 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2902;
|
|
}
|
|
|
|
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 (_primitiveBranch2905)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2909, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2908 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2908;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2909)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2909 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2909;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 4] = MACHINE.val;
|
|
return (_afterCall2907)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2905 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2905;
|
|
}
|
|
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 (_afterCall2907)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2907 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2907;
|
|
}
|
|
|
|
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 (_primitiveBranch2910)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2914, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2913 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2913;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2914)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2914 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2914;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 5] = MACHINE.val;
|
|
return (_afterCall2912)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2910 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2910;
|
|
}
|
|
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 (_afterCall2912)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2912 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2912;
|
|
}
|
|
|
|
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 (_primitiveBranch2915)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2919, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2918 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2918;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn2919)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2919 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2919;
|
|
}
|
|
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 (_primitiveBranch2920)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2924, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch2915 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2915;
|
|
}
|
|
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 (_afterCall2917)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2917 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2917;
|
|
}
|
|
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 (_primitiveBranch2920)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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(_procReturn2924, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple2923 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple2923;
|
|
}
|
|
if ((MACHINE.argcount - 7) === 0) { return (_afterValueCheck2925)(MACHINE); }
|
|
return (_procReturn2924)(MACHINE);
|
|
};
|
|
|
|
var _procReturn2924 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn2924;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 7);
|
|
return (_afterValueCheck2925)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck2925 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck2925;
|
|
}
|
|
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 _primitiveBranch2920 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch2920;
|
|
}
|
|
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 (_afterCall2922)(MACHINE);
|
|
};
|
|
|
|
var _afterCall2922 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall2922;
|
|
}
|
|
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 _beforePromptPopMultiple2885 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2885;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2886)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2886 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2886;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop2927, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 0]=new RUNTIME.Closure(_lamEntry100, 3, [MACHINE.env[MACHINE.env.length - 1 - 2]], "...rivate/color.rkt:12:4");
|
|
MACHINE.env[MACHINE.env.length - 1 - 1]=new RUNTIME.Closure(_lamEntry101, 4, [MACHINE.env[MACHINE.env.length - 1 - 2]], "...rivate/color.rkt:14:4");
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry99, 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 _beforePromptPopMultiple2926 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple2926;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop2927)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop2927 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop2927;
|
|
}
|
|
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 _afterModuleBody2879 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody2879;
|
|
}
|
|
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 _beforePopPromptMultiple2865 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple2865;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt2866)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt2866 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt2866;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn2884.multipleValueReturn = _onReturnMultiple2883;
|
|
_procReturn2893.multipleValueReturn = _procReturnMultiple2892;
|
|
_procReturn2898.multipleValueReturn = _procReturnMultiple2897;
|
|
_procReturn2904.multipleValueReturn = _procReturnMultiple2903;
|
|
_procReturn2909.multipleValueReturn = _procReturnMultiple2908;
|
|
_procReturn2914.multipleValueReturn = _procReturnMultiple2913;
|
|
_procReturn2919.multipleValueReturn = _procReturnMultiple2918;
|
|
_procReturn2924.multipleValueReturn = _procReturnMultiple2923;
|
|
_beforePromptPop2886.multipleValueReturn = _beforePromptPopMultiple2885;
|
|
_beforePromptPop2927.multipleValueReturn = _beforePromptPopMultiple2926;
|
|
_beforePopPrompt2866.multipleValueReturn = _beforePopPromptMultiple2865;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start2928); })(MACHINE, function() {
|
|
MACHINE.modules["whalesong/image/private/main.rkt"] =
|
|
new plt.runtime.ModuleRecord("whalesong/image/private/main.rkt",
|
|
function(MACHINE) {
|
|
var afterName1109 = 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,
|
|
afterName1109,
|
|
MACHINE.params.currentErrorHandler);
|
|
} else {
|
|
afterName1109();
|
|
}
|
|
});
|
|
(function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start2942 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start2942;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt2931, 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", _moduleEntry2933);
|
|
return (_afterModuleBody2932)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies2929 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies2929;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt2931, 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", _moduleEntry2933);
|
|
return (_afterModuleBody2932)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry2933 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry2933;
|
|
}
|
|
MACHINE.modules["whalesong/image.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/lang/base.rkt"] !== undefined) !== false) { return (_linked2934)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/lang/base.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2935)(MACHINE);
|
|
};
|
|
|
|
var _linked2934 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked2934;
|
|
}
|
|
if (MACHINE.modules["whalesong/lang/base.rkt"].isInvoked !== false) { return (_alreadyLoaded2935)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn2937, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/lang/base.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple2936 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple2936;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn2937)(MACHINE);
|
|
};
|
|
|
|
var _onReturn2937 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn2937;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/main.rkt"] !== undefined) !== false) { return (_linked2938)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2939)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded2935 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded2935;
|
|
}
|
|
if ((MACHINE.modules["whalesong/image/main.rkt"] !== undefined) !== false) { return (_linked2938)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/image/main.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded2939)(MACHINE);
|
|
};
|
|
|
|
var _linked2938 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked2938;
|
|
}
|
|
if (MACHINE.modules["whalesong/image/main.rkt"].isInvoked !== false) { return (_alreadyLoaded2939)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn2941, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/image/main.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple2940 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple2940;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn2941)(MACHINE);
|
|
};
|
|
|
|
var _onReturn2941 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn2941;
|
|
}
|
|
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 _alreadyLoaded2939 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded2939;
|
|
}
|
|
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 _afterModuleBody2932 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody2932;
|
|
}
|
|
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 _beforePopPromptMultiple2930 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple2930;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt2931)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt2931 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt2931;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn2937.multipleValueReturn = _onReturnMultiple2936;
|
|
_onReturn2941.multipleValueReturn = _onReturnMultiple2940;
|
|
_beforePopPrompt2931.multipleValueReturn = _beforePopPromptMultiple2930;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start2942); })(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>
|