41928 lines
1.5 MiB
41928 lines
1.5 MiB
<!DOCTYPE html>
|
|
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
|
|
<head>
|
|
<meta charset="utf-8"/>
|
|
<title>Hello</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 _start1543 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start1543;
|
|
}
|
|
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/hello.rkt"]=new RUNTIME.ModuleRecord("hello", _moduleEntry1514);
|
|
return (_afterModuleBody1513)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry12 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry12;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch152)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn156, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple155 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple155;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn156)(MACHINE);
|
|
};
|
|
|
|
var _procReturn156 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn156;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall154)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch152 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch152;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall154)(MACHINE);
|
|
};
|
|
|
|
var _afterCall154 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall154;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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.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 (_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 _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;
|
|
return (_afterCall159)(MACHINE);
|
|
};
|
|
|
|
var _afterCall159 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall159;
|
|
}
|
|
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 (_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;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn166)(MACHINE);
|
|
};
|
|
|
|
var _procReturn166 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn166;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_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 _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;
|
|
return (_afterCall164)(MACHINE);
|
|
};
|
|
|
|
var _afterCall164 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall164;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_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.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch172)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn176, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple175 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple175;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn176)(MACHINE);
|
|
};
|
|
|
|
var _procReturn176 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn176;
|
|
}
|
|
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 (_primitiveBranch177)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn181, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch172 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch172;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall174)(MACHINE);
|
|
};
|
|
|
|
var _afterCall174 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall174;
|
|
}
|
|
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 (_primitiveBranch177)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn181, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple180 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple180;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn181)(MACHINE);
|
|
};
|
|
|
|
var _procReturn181 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn181;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch182)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn186, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch177 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch177;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall179)(MACHINE);
|
|
};
|
|
|
|
var _afterCall179 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall179;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch182)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn186, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple185 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple185;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn186)(MACHINE);
|
|
};
|
|
|
|
var _procReturn186 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn186;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall184)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch182 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch182;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall184)(MACHINE);
|
|
};
|
|
|
|
var _afterCall184 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall184;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch187)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn191, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple190 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple190;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn191)(MACHINE);
|
|
};
|
|
|
|
var _procReturn191 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn191;
|
|
}
|
|
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 (_primitiveBranch192)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn196, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch187 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch187;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall189)(MACHINE);
|
|
};
|
|
|
|
var _afterCall189 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall189;
|
|
}
|
|
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 (_primitiveBranch192)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn196, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple195 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple195;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn196)(MACHINE);
|
|
};
|
|
|
|
var _procReturn196 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn196;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch197)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn201, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch192 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch192;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall194)(MACHINE);
|
|
};
|
|
|
|
var _afterCall194 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall194;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch197)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn201, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple200 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple200;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn201)(MACHINE);
|
|
};
|
|
|
|
var _procReturn201 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn201;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall199)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch197 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch197;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall199)(MACHINE);
|
|
};
|
|
|
|
var _afterCall199 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall199;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch202)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn206, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple205 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple205;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn206)(MACHINE);
|
|
};
|
|
|
|
var _procReturn206 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn206;
|
|
}
|
|
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 (_primitiveBranch207)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn211, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch202 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch202;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall204)(MACHINE);
|
|
};
|
|
|
|
var _afterCall204 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall204;
|
|
}
|
|
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 (_primitiveBranch207)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn211, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple210 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple210;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn211)(MACHINE);
|
|
};
|
|
|
|
var _procReturn211 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn211;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch212)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn216, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch207 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch207;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall209)(MACHINE);
|
|
};
|
|
|
|
var _afterCall209 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall209;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch212)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn216, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple215 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple215;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn216)(MACHINE);
|
|
};
|
|
|
|
var _procReturn216 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn216;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall214)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch212 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch212;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall214)(MACHINE);
|
|
};
|
|
|
|
var _afterCall214 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall214;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch217)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn221, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple220 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple220;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn221)(MACHINE);
|
|
};
|
|
|
|
var _procReturn221 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn221;
|
|
}
|
|
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 (_primitiveBranch222)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn226, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch217 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch217;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall219)(MACHINE);
|
|
};
|
|
|
|
var _afterCall219 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall219;
|
|
}
|
|
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 (_primitiveBranch222)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn226, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple225 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple225;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn226)(MACHINE);
|
|
};
|
|
|
|
var _procReturn226 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn226;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch227)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn231, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch222 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch222;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall224)(MACHINE);
|
|
};
|
|
|
|
var _afterCall224 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall224;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch227)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn231, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple230 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple230;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn231)(MACHINE);
|
|
};
|
|
|
|
var _procReturn231 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn231;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall229)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch227 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch227;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall229)(MACHINE);
|
|
};
|
|
|
|
var _afterCall229 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall229;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch232)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn236, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple235 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple235;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn236)(MACHINE);
|
|
};
|
|
|
|
var _procReturn236 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn236;
|
|
}
|
|
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 (_primitiveBranch237)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn241, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch232 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch232;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall234)(MACHINE);
|
|
};
|
|
|
|
var _afterCall234 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall234;
|
|
}
|
|
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 (_primitiveBranch237)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn241, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple240 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple240;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn241)(MACHINE);
|
|
};
|
|
|
|
var _procReturn241 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn241;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch242)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn246, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch237 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch237;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall239)(MACHINE);
|
|
};
|
|
|
|
var _afterCall239 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall239;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch242)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn246, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple245 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple245;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn246)(MACHINE);
|
|
};
|
|
|
|
var _procReturn246 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn246;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall244)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch242 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch242;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall244)(MACHINE);
|
|
};
|
|
|
|
var _afterCall244 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall244;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch247)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn251, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple250 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple250;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn251)(MACHINE);
|
|
};
|
|
|
|
var _procReturn251 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn251;
|
|
}
|
|
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 (_primitiveBranch252)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn256, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch247 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch247;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall249)(MACHINE);
|
|
};
|
|
|
|
var _afterCall249 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall249;
|
|
}
|
|
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 (_primitiveBranch252)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn256, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple255 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple255;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn256)(MACHINE);
|
|
};
|
|
|
|
var _procReturn256 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn256;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch257)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn261, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch252 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch252;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall254)(MACHINE);
|
|
};
|
|
|
|
var _afterCall254 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall254;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch257)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn261, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple260 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple260;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn261)(MACHINE);
|
|
};
|
|
|
|
var _procReturn261 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn261;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall259)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch257 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch257;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall259)(MACHINE);
|
|
};
|
|
|
|
var _afterCall259 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall259;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch262)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn266, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple265 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple265;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn266)(MACHINE);
|
|
};
|
|
|
|
var _procReturn266 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn266;
|
|
}
|
|
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 (_primitiveBranch267)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn271, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch262 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch262;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall264)(MACHINE);
|
|
};
|
|
|
|
var _afterCall264 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall264;
|
|
}
|
|
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 (_primitiveBranch267)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn271, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple270 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple270;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn271)(MACHINE);
|
|
};
|
|
|
|
var _procReturn271 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn271;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch272)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn276, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch267 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch267;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall269)(MACHINE);
|
|
};
|
|
|
|
var _afterCall269 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall269;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch272)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn276, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple275 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple275;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn276)(MACHINE);
|
|
};
|
|
|
|
var _procReturn276 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn276;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall274)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch272 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch272;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall274)(MACHINE);
|
|
};
|
|
|
|
var _afterCall274 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall274;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch277)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn281, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple280 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple280;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn281)(MACHINE);
|
|
};
|
|
|
|
var _procReturn281 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn281;
|
|
}
|
|
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 (_primitiveBranch282)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn286, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch277 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch277;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall279)(MACHINE);
|
|
};
|
|
|
|
var _afterCall279 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall279;
|
|
}
|
|
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 (_primitiveBranch282)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn286, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple285 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple285;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn286)(MACHINE);
|
|
};
|
|
|
|
var _procReturn286 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn286;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch287)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn291, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch282 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch282;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall284)(MACHINE);
|
|
};
|
|
|
|
var _afterCall284 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall284;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch287)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn291, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple290 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple290;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn291)(MACHINE);
|
|
};
|
|
|
|
var _procReturn291 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn291;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall289)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch287 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch287;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall289)(MACHINE);
|
|
};
|
|
|
|
var _afterCall289 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall289;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch292)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn296, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple295 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple295;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn296)(MACHINE);
|
|
};
|
|
|
|
var _procReturn296 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn296;
|
|
}
|
|
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 (_primitiveBranch297)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn301, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch292 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch292;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall294)(MACHINE);
|
|
};
|
|
|
|
var _afterCall294 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall294;
|
|
}
|
|
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 (_primitiveBranch297)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn301, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple300 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple300;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn301)(MACHINE);
|
|
};
|
|
|
|
var _procReturn301 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn301;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch302)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn306, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch297 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch297;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall299)(MACHINE);
|
|
};
|
|
|
|
var _afterCall299 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall299;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch302)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn306, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple305 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple305;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn306)(MACHINE);
|
|
};
|
|
|
|
var _procReturn306 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn306;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall304)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch302 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch302;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall304)(MACHINE);
|
|
};
|
|
|
|
var _afterCall304 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall304;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch307)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn311, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple310 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple310;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn311)(MACHINE);
|
|
};
|
|
|
|
var _procReturn311 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn311;
|
|
}
|
|
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 (_primitiveBranch312)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn316, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch307 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch307;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall309)(MACHINE);
|
|
};
|
|
|
|
var _afterCall309 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall309;
|
|
}
|
|
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 (_primitiveBranch312)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn316, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple315 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple315;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn316)(MACHINE);
|
|
};
|
|
|
|
var _procReturn316 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn316;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch317)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn321, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch312 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch312;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall314)(MACHINE);
|
|
};
|
|
|
|
var _afterCall314 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall314;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch317)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn321, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple320 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple320;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn321)(MACHINE);
|
|
};
|
|
|
|
var _procReturn321 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn321;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall319)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch317 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch317;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall319)(MACHINE);
|
|
};
|
|
|
|
var _afterCall319 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall319;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch322)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn326, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple325 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple325;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn326)(MACHINE);
|
|
};
|
|
|
|
var _procReturn326 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn326;
|
|
}
|
|
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 (_primitiveBranch327)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn331, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch322 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch322;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall324)(MACHINE);
|
|
};
|
|
|
|
var _afterCall324 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall324;
|
|
}
|
|
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 (_primitiveBranch327)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn331, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple330 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple330;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn331)(MACHINE);
|
|
};
|
|
|
|
var _procReturn331 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn331;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch332)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn336, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch327 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch327;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall329)(MACHINE);
|
|
};
|
|
|
|
var _afterCall329 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall329;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch332)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn336, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple335 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple335;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn336)(MACHINE);
|
|
};
|
|
|
|
var _procReturn336 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn336;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall334)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch332 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch332;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall334)(MACHINE);
|
|
};
|
|
|
|
var _afterCall334 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall334;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch337)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn341, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple340 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple340;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn341)(MACHINE);
|
|
};
|
|
|
|
var _procReturn341 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn341;
|
|
}
|
|
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 (_primitiveBranch342)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn346, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch337 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch337;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall339)(MACHINE);
|
|
};
|
|
|
|
var _afterCall339 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall339;
|
|
}
|
|
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 (_primitiveBranch342)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn346, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple345 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple345;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn346)(MACHINE);
|
|
};
|
|
|
|
var _procReturn346 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn346;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch347)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn351, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch342 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch342;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall344)(MACHINE);
|
|
};
|
|
|
|
var _afterCall344 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall344;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch347)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn351, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple350 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple350;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn351)(MACHINE);
|
|
};
|
|
|
|
var _procReturn351 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn351;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall349)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch347 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch347;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall349)(MACHINE);
|
|
};
|
|
|
|
var _afterCall349 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall349;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch352)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn356, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple355 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple355;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn356)(MACHINE);
|
|
};
|
|
|
|
var _procReturn356 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn356;
|
|
}
|
|
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 (_primitiveBranch357)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn361, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch352 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch352;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall354)(MACHINE);
|
|
};
|
|
|
|
var _afterCall354 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall354;
|
|
}
|
|
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 (_primitiveBranch357)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn361, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple360 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple360;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn361)(MACHINE);
|
|
};
|
|
|
|
var _procReturn361 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn361;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch362)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn366, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch357 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch357;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall359)(MACHINE);
|
|
};
|
|
|
|
var _afterCall359 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall359;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch362)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn366, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple365 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple365;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn366)(MACHINE);
|
|
};
|
|
|
|
var _procReturn366 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn366;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall364)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch362 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch362;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall364)(MACHINE);
|
|
};
|
|
|
|
var _afterCall364 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall364;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch367)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn371, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple370 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple370;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn371)(MACHINE);
|
|
};
|
|
|
|
var _procReturn371 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn371;
|
|
}
|
|
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 (_primitiveBranch372)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn376, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch367 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch367;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall369)(MACHINE);
|
|
};
|
|
|
|
var _afterCall369 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall369;
|
|
}
|
|
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 (_primitiveBranch372)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn376, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple375 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple375;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn376)(MACHINE);
|
|
};
|
|
|
|
var _procReturn376 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn376;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch377)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn381, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch372 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch372;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall374)(MACHINE);
|
|
};
|
|
|
|
var _afterCall374 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall374;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch377)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn381, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple380 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple380;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn381)(MACHINE);
|
|
};
|
|
|
|
var _procReturn381 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn381;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall379)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch377 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch377;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall379)(MACHINE);
|
|
};
|
|
|
|
var _afterCall379 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall379;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch382)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn386, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple385 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple385;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn386)(MACHINE);
|
|
};
|
|
|
|
var _procReturn386 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn386;
|
|
}
|
|
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 (_primitiveBranch387)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn391, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch382 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch382;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall384)(MACHINE);
|
|
};
|
|
|
|
var _afterCall384 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall384;
|
|
}
|
|
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 (_primitiveBranch387)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn391, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple390 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple390;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn391)(MACHINE);
|
|
};
|
|
|
|
var _procReturn391 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn391;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch392)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn396, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch387 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch387;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall389)(MACHINE);
|
|
};
|
|
|
|
var _afterCall389 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall389;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch392)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn396, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple395 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple395;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn396)(MACHINE);
|
|
};
|
|
|
|
var _procReturn396 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn396;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall394)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch392 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch392;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall394)(MACHINE);
|
|
};
|
|
|
|
var _afterCall394 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall394;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch397)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn401, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple400 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple400;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn401)(MACHINE);
|
|
};
|
|
|
|
var _procReturn401 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn401;
|
|
}
|
|
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 (_primitiveBranch402)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn406, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch397 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch397;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall399)(MACHINE);
|
|
};
|
|
|
|
var _afterCall399 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall399;
|
|
}
|
|
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 (_primitiveBranch402)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn406, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple405 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple405;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn406)(MACHINE);
|
|
};
|
|
|
|
var _procReturn406 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn406;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch407)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn411, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch402 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch402;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall404)(MACHINE);
|
|
};
|
|
|
|
var _afterCall404 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall404;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch407)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn411, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple410 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple410;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn411)(MACHINE);
|
|
};
|
|
|
|
var _procReturn411 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn411;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall409)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch407 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch407;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall409)(MACHINE);
|
|
};
|
|
|
|
var _afterCall409 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall409;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch412)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn416, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple415 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple415;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn416)(MACHINE);
|
|
};
|
|
|
|
var _procReturn416 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn416;
|
|
}
|
|
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 (_primitiveBranch417)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn421, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch412 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch412;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall414)(MACHINE);
|
|
};
|
|
|
|
var _afterCall414 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall414;
|
|
}
|
|
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 (_primitiveBranch417)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn421, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple420 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple420;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn421)(MACHINE);
|
|
};
|
|
|
|
var _procReturn421 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn421;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch422)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn426, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch417 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch417;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall419)(MACHINE);
|
|
};
|
|
|
|
var _afterCall419 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall419;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch422)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn426, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple425 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple425;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn426)(MACHINE);
|
|
};
|
|
|
|
var _procReturn426 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn426;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall424)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch422 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch422;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall424)(MACHINE);
|
|
};
|
|
|
|
var _afterCall424 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall424;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch427)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn431, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple430 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple430;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn431)(MACHINE);
|
|
};
|
|
|
|
var _procReturn431 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn431;
|
|
}
|
|
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 (_primitiveBranch432)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn436, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch427 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch427;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall429)(MACHINE);
|
|
};
|
|
|
|
var _afterCall429 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall429;
|
|
}
|
|
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 (_primitiveBranch432)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn436, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple435 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple435;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn436)(MACHINE);
|
|
};
|
|
|
|
var _procReturn436 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn436;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch437)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn441, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch432 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch432;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall434)(MACHINE);
|
|
};
|
|
|
|
var _afterCall434 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall434;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch437)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn441, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple440 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple440;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn441)(MACHINE);
|
|
};
|
|
|
|
var _procReturn441 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn441;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall439)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch437 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch437;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall439)(MACHINE);
|
|
};
|
|
|
|
var _afterCall439 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall439;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch442)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn446, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple445 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple445;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn446)(MACHINE);
|
|
};
|
|
|
|
var _procReturn446 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn446;
|
|
}
|
|
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 (_primitiveBranch447)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn451, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch442 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch442;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall444)(MACHINE);
|
|
};
|
|
|
|
var _afterCall444 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall444;
|
|
}
|
|
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 (_primitiveBranch447)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn451, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple450 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple450;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn451)(MACHINE);
|
|
};
|
|
|
|
var _procReturn451 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn451;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch452)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn456, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch447 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch447;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall449)(MACHINE);
|
|
};
|
|
|
|
var _afterCall449 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall449;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch452)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn456, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple455 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple455;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn456)(MACHINE);
|
|
};
|
|
|
|
var _procReturn456 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn456;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall454)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch452 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch452;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall454)(MACHINE);
|
|
};
|
|
|
|
var _afterCall454 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall454;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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;
|
|
}
|
|
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 (_primitiveBranch462)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn466, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(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;
|
|
}
|
|
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 (_primitiveBranch462)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn466, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple465 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple465;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn466)(MACHINE);
|
|
};
|
|
|
|
var _procReturn466 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn466;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "-", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "-", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "-", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "-", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch467)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn471, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch462 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch462;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall464)(MACHINE);
|
|
};
|
|
|
|
var _afterCall464 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall464;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "-", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "-", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "-", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "-", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch467)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn471, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple470 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple470;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn471)(MACHINE);
|
|
};
|
|
|
|
var _procReturn471 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn471;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall469)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch467 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch467;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall469)(MACHINE);
|
|
};
|
|
|
|
var _afterCall469 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall469;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch472)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn476, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple475 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple475;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn476)(MACHINE);
|
|
};
|
|
|
|
var _procReturn476 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn476;
|
|
}
|
|
MACHINE.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 (_primitiveBranch477)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn481, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch472 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch472;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall474)(MACHINE);
|
|
};
|
|
|
|
var _afterCall474 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall474;
|
|
}
|
|
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 (_primitiveBranch477)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn481, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple480 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple480;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn481)(MACHINE);
|
|
};
|
|
|
|
var _procReturn481 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn481;
|
|
}
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4][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 (_primitiveBranch485)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn489, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch477 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch477;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall479)(MACHINE);
|
|
};
|
|
|
|
var _afterCall479 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall479;
|
|
}
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4][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 (_primitiveBranch485)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn489, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple488 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple488;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn489)(MACHINE);
|
|
};
|
|
|
|
var _procReturn489 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn489;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall487)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch485 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch485;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall487)(MACHINE);
|
|
};
|
|
|
|
var _afterCall487 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall487;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 0;
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0])) ? (MACHINE.env[MACHINE.env.length - 1 - 0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0])),MACHINE.env[MACHINE.env.length - 1 - 1])));
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
if (MACHINE.val === false) { return (_falseBranch483)(MACHINE); }
|
|
MACHINE.val = RUNTIME.VOID;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch483 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch483;
|
|
}
|
|
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0][9];
|
|
MACHINE.argcount = 0;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch490)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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.length = MACHINE.env.length - 1;
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch490 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch490;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry13 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry13;
|
|
}
|
|
|
|
MACHINE.env.splice.apply(MACHINE.env, [MACHINE.env.length, 0].concat(MACHINE.proc.closedVals));
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch495)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn499, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple498 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple498;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn499)(MACHINE);
|
|
};
|
|
|
|
var _procReturn499 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn499;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall497)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch495 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch495;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall497)(MACHINE);
|
|
};
|
|
|
|
var _afterCall497 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall497;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch500)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn504, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple503 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple503;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn504)(MACHINE);
|
|
};
|
|
|
|
var _procReturn504 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn504;
|
|
}
|
|
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 (_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 _primitiveBranch500 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch500;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall502)(MACHINE);
|
|
};
|
|
|
|
var _afterCall502 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall502;
|
|
}
|
|
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 (_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;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn509)(MACHINE);
|
|
};
|
|
|
|
var _procReturn509 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn509;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch510)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn514, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(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;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch510)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn514, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple513 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple513;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn514)(MACHINE);
|
|
};
|
|
|
|
var _procReturn514 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn514;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall512)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch510 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch510;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall512)(MACHINE);
|
|
};
|
|
|
|
var _afterCall512 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall512;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch515)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn519, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple518 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple518;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn519)(MACHINE);
|
|
};
|
|
|
|
var _procReturn519 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn519;
|
|
}
|
|
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 (_primitiveBranch520)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn524, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch515 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch515;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall517)(MACHINE);
|
|
};
|
|
|
|
var _afterCall517 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall517;
|
|
}
|
|
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 (_primitiveBranch520)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn524, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple523 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple523;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn524)(MACHINE);
|
|
};
|
|
|
|
var _procReturn524 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn524;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch525)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn529, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch520 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch520;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall522)(MACHINE);
|
|
};
|
|
|
|
var _afterCall522 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall522;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch525)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn529, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple528 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple528;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn529)(MACHINE);
|
|
};
|
|
|
|
var _procReturn529 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn529;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall527)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch525 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch525;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall527)(MACHINE);
|
|
};
|
|
|
|
var _afterCall527 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall527;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch530)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn534, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple533 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple533;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn534)(MACHINE);
|
|
};
|
|
|
|
var _procReturn534 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn534;
|
|
}
|
|
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 (_primitiveBranch535)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn539, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch530 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch530;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall532)(MACHINE);
|
|
};
|
|
|
|
var _afterCall532 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall532;
|
|
}
|
|
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 (_primitiveBranch535)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn539, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple538 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple538;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn539)(MACHINE);
|
|
};
|
|
|
|
var _procReturn539 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn539;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch540)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn544, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch535 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch535;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall537)(MACHINE);
|
|
};
|
|
|
|
var _afterCall537 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall537;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch540)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn544, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple543 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple543;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn544)(MACHINE);
|
|
};
|
|
|
|
var _procReturn544 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn544;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall542)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch540 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch540;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall542)(MACHINE);
|
|
};
|
|
|
|
var _afterCall542 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall542;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch545)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn549, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple548 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple548;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn549)(MACHINE);
|
|
};
|
|
|
|
var _procReturn549 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn549;
|
|
}
|
|
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 (_primitiveBranch550)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn554, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch545 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch545;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall547)(MACHINE);
|
|
};
|
|
|
|
var _afterCall547 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall547;
|
|
}
|
|
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 (_primitiveBranch550)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn554, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple553 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple553;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn554)(MACHINE);
|
|
};
|
|
|
|
var _procReturn554 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn554;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch555)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn559, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch550 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch550;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall552)(MACHINE);
|
|
};
|
|
|
|
var _afterCall552 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall552;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch555)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn559, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple558 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple558;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn559)(MACHINE);
|
|
};
|
|
|
|
var _procReturn559 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn559;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall557)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch555 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch555;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall557)(MACHINE);
|
|
};
|
|
|
|
var _afterCall557 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall557;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 1];
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.val;
|
|
MACHINE.argcount = 2;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch560)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn564, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple563 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple563;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn564)(MACHINE);
|
|
};
|
|
|
|
var _procReturn564 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn564;
|
|
}
|
|
MACHINE.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 (_primitiveBranch565)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn569, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch560 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch560;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall562)(MACHINE);
|
|
};
|
|
|
|
var _afterCall562 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall562;
|
|
}
|
|
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 (_primitiveBranch565)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn569, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple568 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple568;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn569)(MACHINE);
|
|
};
|
|
|
|
var _procReturn569 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn569;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch570)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn574, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch565 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch565;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall567)(MACHINE);
|
|
};
|
|
|
|
var _afterCall567 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall567;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch570)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn574, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple573 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple573;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn574)(MACHINE);
|
|
};
|
|
|
|
var _procReturn574 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn574;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall572)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch570 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch570;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall572)(MACHINE);
|
|
};
|
|
|
|
var _afterCall572 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall572;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch575)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn579, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple578 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple578;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn579)(MACHINE);
|
|
};
|
|
|
|
var _procReturn579 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn579;
|
|
}
|
|
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 (_primitiveBranch580)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn584, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch575 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch575;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall577)(MACHINE);
|
|
};
|
|
|
|
var _afterCall577 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall577;
|
|
}
|
|
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 (_primitiveBranch580)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn584, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple583 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple583;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn584)(MACHINE);
|
|
};
|
|
|
|
var _procReturn584 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn584;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch585)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn589, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch580 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch580;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall582)(MACHINE);
|
|
};
|
|
|
|
var _afterCall582 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall582;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch585)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn589, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple588 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple588;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn589)(MACHINE);
|
|
};
|
|
|
|
var _procReturn589 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn589;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall587)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch585 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch585;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall587)(MACHINE);
|
|
};
|
|
|
|
var _afterCall587 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall587;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch590)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn594, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple593 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple593;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn594)(MACHINE);
|
|
};
|
|
|
|
var _procReturn594 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn594;
|
|
}
|
|
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 (_primitiveBranch595)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn599, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch590 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch590;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall592)(MACHINE);
|
|
};
|
|
|
|
var _afterCall592 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall592;
|
|
}
|
|
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 (_primitiveBranch595)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn599, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple598 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple598;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn599)(MACHINE);
|
|
};
|
|
|
|
var _procReturn599 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn599;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch600)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn604, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch595 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch595;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall597)(MACHINE);
|
|
};
|
|
|
|
var _afterCall597 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall597;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch600)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn604, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple603 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple603;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn604)(MACHINE);
|
|
};
|
|
|
|
var _procReturn604 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn604;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall602)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch600 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch600;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall602)(MACHINE);
|
|
};
|
|
|
|
var _afterCall602 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall602;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch605)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn609, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple608 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple608;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn609)(MACHINE);
|
|
};
|
|
|
|
var _procReturn609 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn609;
|
|
}
|
|
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 (_primitiveBranch610)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn614, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch605 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch605;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall607)(MACHINE);
|
|
};
|
|
|
|
var _afterCall607 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall607;
|
|
}
|
|
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 (_primitiveBranch610)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn614, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple613 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple613;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn614)(MACHINE);
|
|
};
|
|
|
|
var _procReturn614 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn614;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch615)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn619, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch610 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch610;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall612)(MACHINE);
|
|
};
|
|
|
|
var _afterCall612 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall612;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch615)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn619, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple618 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple618;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn619)(MACHINE);
|
|
};
|
|
|
|
var _procReturn619 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn619;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall617)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch615 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch615;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall617)(MACHINE);
|
|
};
|
|
|
|
var _afterCall617 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall617;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch620)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn624, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple623 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple623;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn624)(MACHINE);
|
|
};
|
|
|
|
var _procReturn624 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn624;
|
|
}
|
|
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 (_primitiveBranch625)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn629, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch620 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch620;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall622)(MACHINE);
|
|
};
|
|
|
|
var _afterCall622 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall622;
|
|
}
|
|
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 (_primitiveBranch625)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn629, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple628 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple628;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn629)(MACHINE);
|
|
};
|
|
|
|
var _procReturn629 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn629;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch630)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn634, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch625 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch625;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall627)(MACHINE);
|
|
};
|
|
|
|
var _afterCall627 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall627;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch630)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn634, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple633 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple633;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn634)(MACHINE);
|
|
};
|
|
|
|
var _procReturn634 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn634;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall632)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch630 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch630;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall632)(MACHINE);
|
|
};
|
|
|
|
var _afterCall632 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall632;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch635)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn639, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple638 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple638;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn639)(MACHINE);
|
|
};
|
|
|
|
var _procReturn639 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn639;
|
|
}
|
|
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 (_primitiveBranch640)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn644, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch635 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch635;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall637)(MACHINE);
|
|
};
|
|
|
|
var _afterCall637 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall637;
|
|
}
|
|
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 (_primitiveBranch640)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn644, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple643 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple643;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn644)(MACHINE);
|
|
};
|
|
|
|
var _procReturn644 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn644;
|
|
}
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4][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 (_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.control.push(new RUNTIME.CallFrame(_procReturn652, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch640 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch640;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall642)(MACHINE);
|
|
};
|
|
|
|
var _afterCall642 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall642;
|
|
}
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 4][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 4][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 4].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 4][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 (_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.control.push(new RUNTIME.CallFrame(_procReturn652, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple651 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple651;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn652)(MACHINE);
|
|
};
|
|
|
|
var _procReturn652 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn652;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall650)(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[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall650)(MACHINE);
|
|
};
|
|
|
|
var _afterCall650 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall650;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 0;
|
|
MACHINE.val=((plt.baselib.numbers.equals(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0])) ? (MACHINE.env[MACHINE.env.length - 1 - 0]) : RUNTIME.raiseArgumentTypeError(MACHINE, "=", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0])),MACHINE.env[MACHINE.env.length - 1 - 1])));
|
|
MACHINE.env.length = MACHINE.env.length - 2;
|
|
if (MACHINE.val === false) { return (_falseBranch646)(MACHINE); }
|
|
MACHINE.val = RUNTIME.VOID;
|
|
return (_afterIf647)(MACHINE);
|
|
};
|
|
|
|
var _falseBranch646 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _falseBranch646;
|
|
}
|
|
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0][9];
|
|
MACHINE.argcount = 0;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch653)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn657, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple656 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple656;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn657)(MACHINE);
|
|
};
|
|
|
|
var _procReturn657 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn657;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch658)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn662, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch653 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch653;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall655)(MACHINE);
|
|
};
|
|
|
|
var _afterCall655 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall655;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch658)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn662, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _afterIf647 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterIf647;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch658)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn662, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple661 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple661;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn662)(MACHINE);
|
|
};
|
|
|
|
var _procReturn662 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn662;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall660)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch658 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch658;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall660)(MACHINE);
|
|
};
|
|
|
|
var _afterCall660 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall660;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch663)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn667, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple666 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple666;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn667)(MACHINE);
|
|
};
|
|
|
|
var _procReturn667 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn667;
|
|
}
|
|
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 (_primitiveBranch668)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn672, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch663 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch663;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall665)(MACHINE);
|
|
};
|
|
|
|
var _afterCall665 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall665;
|
|
}
|
|
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 (_primitiveBranch668)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn672, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple671 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple671;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn672)(MACHINE);
|
|
};
|
|
|
|
var _procReturn672 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn672;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch673)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn677, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch668 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch668;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall670)(MACHINE);
|
|
};
|
|
|
|
var _afterCall670 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall670;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch673)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn677, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple676 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple676;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn677)(MACHINE);
|
|
};
|
|
|
|
var _procReturn677 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn677;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall675)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch673 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch673;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall675)(MACHINE);
|
|
};
|
|
|
|
var _afterCall675 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall675;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch678)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn682, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple681 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple681;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn682)(MACHINE);
|
|
};
|
|
|
|
var _procReturn682 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn682;
|
|
}
|
|
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 (_primitiveBranch683)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn687, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch678 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch678;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall680)(MACHINE);
|
|
};
|
|
|
|
var _afterCall680 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall680;
|
|
}
|
|
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 (_primitiveBranch683)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn687, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple686 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple686;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn687)(MACHINE);
|
|
};
|
|
|
|
var _procReturn687 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn687;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch688)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn692, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch683 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch683;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall685)(MACHINE);
|
|
};
|
|
|
|
var _afterCall685 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall685;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch688)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn692, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple691 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple691;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn692)(MACHINE);
|
|
};
|
|
|
|
var _procReturn692 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn692;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
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 _primitiveBranch688 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch688;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall690)(MACHINE);
|
|
};
|
|
|
|
var _afterCall690 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall690;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
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;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn697)(MACHINE);
|
|
};
|
|
|
|
var _procReturn697 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn697;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch698)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn702, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(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;
|
|
return (_afterCall695)(MACHINE);
|
|
};
|
|
|
|
var _afterCall695 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall695;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch698)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn702, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple701 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple701;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn702)(MACHINE);
|
|
};
|
|
|
|
var _procReturn702 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn702;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall700)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch698 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch698;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall700)(MACHINE);
|
|
};
|
|
|
|
var _afterCall700 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall700;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch703)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn707, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple706 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple706;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn707)(MACHINE);
|
|
};
|
|
|
|
var _procReturn707 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn707;
|
|
}
|
|
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 (_primitiveBranch708)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn712, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch703 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch703;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall705)(MACHINE);
|
|
};
|
|
|
|
var _afterCall705 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall705;
|
|
}
|
|
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 (_primitiveBranch708)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn712, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple711 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple711;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn712)(MACHINE);
|
|
};
|
|
|
|
var _procReturn712 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn712;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch713)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn717, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch708 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch708;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall710)(MACHINE);
|
|
};
|
|
|
|
var _afterCall710 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall710;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch713)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn717, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple716 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple716;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn717)(MACHINE);
|
|
};
|
|
|
|
var _procReturn717 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn717;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch718)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn722, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch713 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch713;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall715)(MACHINE);
|
|
};
|
|
|
|
var _afterCall715 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall715;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch718)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn722, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple721 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple721;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn722)(MACHINE);
|
|
};
|
|
|
|
var _procReturn722 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn722;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch723)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn727, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch718 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch718;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall720)(MACHINE);
|
|
};
|
|
|
|
var _afterCall720 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall720;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch723)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn727, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple726 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple726;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn727)(MACHINE);
|
|
};
|
|
|
|
var _procReturn727 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn727;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall725)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch723 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch723;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall725)(MACHINE);
|
|
};
|
|
|
|
var _afterCall725 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall725;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch728)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn732, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple731 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple731;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn732)(MACHINE);
|
|
};
|
|
|
|
var _procReturn732 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn732;
|
|
}
|
|
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 (_primitiveBranch733)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn737, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch728 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch728;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall730)(MACHINE);
|
|
};
|
|
|
|
var _afterCall730 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall730;
|
|
}
|
|
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 (_primitiveBranch733)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn737, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple736 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple736;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn737)(MACHINE);
|
|
};
|
|
|
|
var _procReturn737 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn737;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch738)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn742, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch733 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch733;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall735)(MACHINE);
|
|
};
|
|
|
|
var _afterCall735 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall735;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch738)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn742, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple741 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple741;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn742)(MACHINE);
|
|
};
|
|
|
|
var _procReturn742 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn742;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall740)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch738 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch738;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall740)(MACHINE);
|
|
};
|
|
|
|
var _afterCall740 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall740;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch743)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn747, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple746 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple746;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn747)(MACHINE);
|
|
};
|
|
|
|
var _procReturn747 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn747;
|
|
}
|
|
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 (_primitiveBranch748)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn752, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch743 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch743;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall745)(MACHINE);
|
|
};
|
|
|
|
var _afterCall745 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall745;
|
|
}
|
|
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 (_primitiveBranch748)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn752, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple751 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple751;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn752)(MACHINE);
|
|
};
|
|
|
|
var _procReturn752 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn752;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch753)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn757, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch748 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch748;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall750)(MACHINE);
|
|
};
|
|
|
|
var _afterCall750 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall750;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch753)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn757, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple756 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple756;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn757)(MACHINE);
|
|
};
|
|
|
|
var _procReturn757 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn757;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall755)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch753 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch753;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall755)(MACHINE);
|
|
};
|
|
|
|
var _afterCall755 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall755;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch758)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn762, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple761 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple761;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn762)(MACHINE);
|
|
};
|
|
|
|
var _procReturn762 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn762;
|
|
}
|
|
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 (_primitiveBranch763)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn767, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch758 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch758;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall760)(MACHINE);
|
|
};
|
|
|
|
var _afterCall760 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall760;
|
|
}
|
|
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 (_primitiveBranch763)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn767, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple766 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple766;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn767)(MACHINE);
|
|
};
|
|
|
|
var _procReturn767 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn767;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch768)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn772, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch763 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch763;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall765)(MACHINE);
|
|
};
|
|
|
|
var _afterCall765 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall765;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch768)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn772, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple771 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple771;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn772)(MACHINE);
|
|
};
|
|
|
|
var _procReturn772 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn772;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall770)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch768 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch768;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall770)(MACHINE);
|
|
};
|
|
|
|
var _afterCall770 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall770;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch773)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn777, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple776 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple776;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn777)(MACHINE);
|
|
};
|
|
|
|
var _procReturn777 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn777;
|
|
}
|
|
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 (_primitiveBranch778)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn782, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch773 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch773;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall775)(MACHINE);
|
|
};
|
|
|
|
var _afterCall775 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall775;
|
|
}
|
|
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 (_primitiveBranch778)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn782, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple781 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple781;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn782)(MACHINE);
|
|
};
|
|
|
|
var _procReturn782 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn782;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch783)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn787, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch778 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch778;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall780)(MACHINE);
|
|
};
|
|
|
|
var _afterCall780 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall780;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch783)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn787, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple786 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple786;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn787)(MACHINE);
|
|
};
|
|
|
|
var _procReturn787 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn787;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall785)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch783 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch783;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall785)(MACHINE);
|
|
};
|
|
|
|
var _afterCall785 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall785;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch788)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn792, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple791 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple791;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn792)(MACHINE);
|
|
};
|
|
|
|
var _procReturn792 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn792;
|
|
}
|
|
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 (_primitiveBranch793)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn797, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch788 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch788;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall790)(MACHINE);
|
|
};
|
|
|
|
var _afterCall790 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall790;
|
|
}
|
|
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 (_primitiveBranch793)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn797, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple796 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple796;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn797)(MACHINE);
|
|
};
|
|
|
|
var _procReturn797 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn797;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch798)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn802, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch793 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch793;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall795)(MACHINE);
|
|
};
|
|
|
|
var _afterCall795 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall795;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch798)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn802, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple801 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple801;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn802)(MACHINE);
|
|
};
|
|
|
|
var _procReturn802 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn802;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall800)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch798 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch798;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall800)(MACHINE);
|
|
};
|
|
|
|
var _afterCall800 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall800;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch803)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn807, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple806 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple806;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn807)(MACHINE);
|
|
};
|
|
|
|
var _procReturn807 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn807;
|
|
}
|
|
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 (_primitiveBranch808)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn812, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch803 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch803;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall805)(MACHINE);
|
|
};
|
|
|
|
var _afterCall805 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall805;
|
|
}
|
|
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 (_primitiveBranch808)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn812, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple811 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple811;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn812)(MACHINE);
|
|
};
|
|
|
|
var _procReturn812 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn812;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch813)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn817, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch808 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch808;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall810)(MACHINE);
|
|
};
|
|
|
|
var _afterCall810 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall810;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch813)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn817, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple816 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple816;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn817)(MACHINE);
|
|
};
|
|
|
|
var _procReturn817 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn817;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall815)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch813 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch813;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall815)(MACHINE);
|
|
};
|
|
|
|
var _afterCall815 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall815;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch818)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn822, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple821 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple821;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn822)(MACHINE);
|
|
};
|
|
|
|
var _procReturn822 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn822;
|
|
}
|
|
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 (_primitiveBranch823)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn827, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch818 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch818;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall820)(MACHINE);
|
|
};
|
|
|
|
var _afterCall820 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall820;
|
|
}
|
|
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 (_primitiveBranch823)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn827, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple826 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple826;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn827)(MACHINE);
|
|
};
|
|
|
|
var _procReturn827 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn827;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch828)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn832, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch823 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch823;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall825)(MACHINE);
|
|
};
|
|
|
|
var _afterCall825 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall825;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch828)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn832, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple831 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple831;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn832)(MACHINE);
|
|
};
|
|
|
|
var _procReturn832 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn832;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch833)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn837, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch828 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch828;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall830)(MACHINE);
|
|
};
|
|
|
|
var _afterCall830 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall830;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch833)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn837, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple836 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple836;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn837)(MACHINE);
|
|
};
|
|
|
|
var _procReturn837 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn837;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch838)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn842, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch833 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch833;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall835)(MACHINE);
|
|
};
|
|
|
|
var _afterCall835 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall835;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch838)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn842, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple841 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple841;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn842)(MACHINE);
|
|
};
|
|
|
|
var _procReturn842 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn842;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch843)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn847, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch838 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch838;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall840)(MACHINE);
|
|
};
|
|
|
|
var _afterCall840 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall840;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch843)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn847, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple846 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple846;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn847)(MACHINE);
|
|
};
|
|
|
|
var _procReturn847 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn847;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch848)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn852, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch843 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch843;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall845)(MACHINE);
|
|
};
|
|
|
|
var _afterCall845 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall845;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch848)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn852, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple851 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple851;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn852)(MACHINE);
|
|
};
|
|
|
|
var _procReturn852 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn852;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall850)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch848 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch848;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall850)(MACHINE);
|
|
};
|
|
|
|
var _afterCall850 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall850;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch853)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn857, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple856 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple856;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn857)(MACHINE);
|
|
};
|
|
|
|
var _procReturn857 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn857;
|
|
}
|
|
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 (_primitiveBranch858)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn862, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch853 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch853;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall855)(MACHINE);
|
|
};
|
|
|
|
var _afterCall855 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall855;
|
|
}
|
|
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 (_primitiveBranch858)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn862, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple861 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple861;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn862)(MACHINE);
|
|
};
|
|
|
|
var _procReturn862 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn862;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch863)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn867, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch858 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch858;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall860)(MACHINE);
|
|
};
|
|
|
|
var _afterCall860 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall860;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch863)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn867, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple866 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple866;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn867)(MACHINE);
|
|
};
|
|
|
|
var _procReturn867 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn867;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall865)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch863 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch863;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall865)(MACHINE);
|
|
};
|
|
|
|
var _afterCall865 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall865;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch868)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn872, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple871 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple871;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn872)(MACHINE);
|
|
};
|
|
|
|
var _procReturn872 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn872;
|
|
}
|
|
MACHINE.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 (_primitiveBranch873)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn877, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch868 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch868;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall870)(MACHINE);
|
|
};
|
|
|
|
var _afterCall870 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall870;
|
|
}
|
|
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 (_primitiveBranch873)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn877, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple876 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple876;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn877)(MACHINE);
|
|
};
|
|
|
|
var _procReturn877 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn877;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch878)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn882, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch873 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch873;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall875)(MACHINE);
|
|
};
|
|
|
|
var _afterCall875 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall875;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch878)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn882, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple881 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple881;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn882)(MACHINE);
|
|
};
|
|
|
|
var _procReturn882 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn882;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall880)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch878 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch878;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall880)(MACHINE);
|
|
};
|
|
|
|
var _afterCall880 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall880;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch883)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn887, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple886 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple886;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn887)(MACHINE);
|
|
};
|
|
|
|
var _procReturn887 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn887;
|
|
}
|
|
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 (_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 _primitiveBranch883 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch883;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall885)(MACHINE);
|
|
};
|
|
|
|
var _afterCall885 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall885;
|
|
}
|
|
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 (_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;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn892)(MACHINE);
|
|
};
|
|
|
|
var _procReturn892 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn892;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_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.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_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.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
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 _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;
|
|
return (_afterCall895)(MACHINE);
|
|
};
|
|
|
|
var _afterCall895 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall895;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
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;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn902)(MACHINE);
|
|
};
|
|
|
|
var _procReturn902 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn902;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_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.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_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;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn907)(MACHINE);
|
|
};
|
|
|
|
var _procReturn907 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn907;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall905)(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;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall905)(MACHINE);
|
|
};
|
|
|
|
var _afterCall905 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall905;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_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.control.push(new RUNTIME.CallFrame(_procReturn912, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple911 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple911;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn912)(MACHINE);
|
|
};
|
|
|
|
var _procReturn912 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn912;
|
|
}
|
|
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 (_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 _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;
|
|
return (_afterCall910)(MACHINE);
|
|
};
|
|
|
|
var _afterCall910 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall910;
|
|
}
|
|
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 (_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;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn917)(MACHINE);
|
|
};
|
|
|
|
var _procReturn917 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn917;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_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 _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;
|
|
return (_afterCall915)(MACHINE);
|
|
};
|
|
|
|
var _afterCall915 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall915;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_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.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch923)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn927, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple926 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple926;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn927)(MACHINE);
|
|
};
|
|
|
|
var _procReturn927 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn927;
|
|
}
|
|
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 (_primitiveBranch928)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn932, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch923 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch923;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall925)(MACHINE);
|
|
};
|
|
|
|
var _afterCall925 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall925;
|
|
}
|
|
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 (_primitiveBranch928)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn932, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple931 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple931;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn932)(MACHINE);
|
|
};
|
|
|
|
var _procReturn932 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn932;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_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 _primitiveBranch928 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch928;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall930)(MACHINE);
|
|
};
|
|
|
|
var _afterCall930 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall930;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_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.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch938)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn942, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(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;
|
|
return (_afterCall935)(MACHINE);
|
|
};
|
|
|
|
var _afterCall935 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall935;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch938)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn942, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple941 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple941;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn942)(MACHINE);
|
|
};
|
|
|
|
var _procReturn942 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn942;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "-", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "-", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch943)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn947, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch938 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch938;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall940)(MACHINE);
|
|
};
|
|
|
|
var _afterCall940 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall940;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "-", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.subtract(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "-", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch943)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn947, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple946 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple946;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn947)(MACHINE);
|
|
};
|
|
|
|
var _procReturn947 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn947;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall945)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch943 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch943;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall945)(MACHINE);
|
|
};
|
|
|
|
var _afterCall945 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall945;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch948)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn952, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple951 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple951;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn952)(MACHINE);
|
|
};
|
|
|
|
var _procReturn952 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn952;
|
|
}
|
|
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 (_primitiveBranch953)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn957, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch948 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch948;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall950)(MACHINE);
|
|
};
|
|
|
|
var _afterCall950 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall950;
|
|
}
|
|
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 (_primitiveBranch953)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn957, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple956 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple956;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn957)(MACHINE);
|
|
};
|
|
|
|
var _procReturn957 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn957;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch958)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn962, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch953 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch953;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall955)(MACHINE);
|
|
};
|
|
|
|
var _afterCall955 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall955;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch958)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn962, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple961 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple961;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn962)(MACHINE);
|
|
};
|
|
|
|
var _procReturn962 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn962;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall960)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch958 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch958;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall960)(MACHINE);
|
|
};
|
|
|
|
var _afterCall960 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall960;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_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.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 (_primitiveBranch968)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn972, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(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;
|
|
return (_afterCall965)(MACHINE);
|
|
};
|
|
|
|
var _afterCall965 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall965;
|
|
}
|
|
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 (_primitiveBranch968)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn972, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple971 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple971;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn972)(MACHINE);
|
|
};
|
|
|
|
var _procReturn972 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn972;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch973)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn977, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch968 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch968;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall970)(MACHINE);
|
|
};
|
|
|
|
var _afterCall970 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall970;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch973)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn977, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple976 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple976;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn977)(MACHINE);
|
|
};
|
|
|
|
var _procReturn977 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn977;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall975)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch973 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch973;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall975)(MACHINE);
|
|
};
|
|
|
|
var _afterCall975 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall975;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch978)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn982, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple981 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple981;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn982)(MACHINE);
|
|
};
|
|
|
|
var _procReturn982 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn982;
|
|
}
|
|
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 (_primitiveBranch983)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn987, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch978 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch978;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall980)(MACHINE);
|
|
};
|
|
|
|
var _afterCall980 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall980;
|
|
}
|
|
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 (_primitiveBranch983)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn987, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple986 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple986;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn987)(MACHINE);
|
|
};
|
|
|
|
var _procReturn987 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn987;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch988)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn992, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch983 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch983;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall985)(MACHINE);
|
|
};
|
|
|
|
var _afterCall985 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall985;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch988)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn992, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple991 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple991;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn992)(MACHINE);
|
|
};
|
|
|
|
var _procReturn992 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn992;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall990)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch988 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch988;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall990)(MACHINE);
|
|
};
|
|
|
|
var _afterCall990 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall990;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch993)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn997, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple996 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple996;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn997)(MACHINE);
|
|
};
|
|
|
|
var _procReturn997 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn997;
|
|
}
|
|
MACHINE.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 (_primitiveBranch998)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1002, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch993 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch993;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall995)(MACHINE);
|
|
};
|
|
|
|
var _afterCall995 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall995;
|
|
}
|
|
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 (_primitiveBranch998)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1002, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1001 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1001;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1002)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1002 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1002;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1003)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1007, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch998 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch998;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1000)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1000 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1000;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1003)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1007, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1006 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1006;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1007)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1007 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1007;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1005)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1003 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1003;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1005)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1005 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1005;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch1008)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1012, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1011 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1011;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1012)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1012 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1012;
|
|
}
|
|
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 (_primitiveBranch1013)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1017, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1008 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1008;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1010)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1010 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1010;
|
|
}
|
|
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 (_primitiveBranch1013)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1017, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1016 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1016;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1017)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1017 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1017;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1018)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1022, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1013 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1013;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1015)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1015 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1015;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1018)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1022, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1021 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1021;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1022)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1022 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1022;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1020)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1018 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1018;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1020)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1020 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1020;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch1023)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1027, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1026 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1026;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1027)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1027 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1027;
|
|
}
|
|
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 (_primitiveBranch1028)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1032, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1023 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1023;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1025)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1025 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1025;
|
|
}
|
|
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 (_primitiveBranch1028)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1032, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1031 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1031;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1032)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1032 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1032;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1033)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1037, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1028 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1028;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1030)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1030 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1030;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1033)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1037, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1036 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1036;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1037)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1037 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1037;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1035)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1033 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1033;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1035)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1035 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1035;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch1038)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1042, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1041 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1041;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1042)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1042 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1042;
|
|
}
|
|
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 (_primitiveBranch1043)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1047, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1038 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1038;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1040)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1040 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1040;
|
|
}
|
|
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 (_primitiveBranch1043)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1047, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1046 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1046;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1047)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1047 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1047;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1048)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1052, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1043 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1043;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1045)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1045 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1045;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1048)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1052, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1051 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1051;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1052)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1052 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1052;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1050)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1048 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1048;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1050)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1050 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1050;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch1053)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1057, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1056 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1056;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1057)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1057 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1057;
|
|
}
|
|
MACHINE.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 (_primitiveBranch1058)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1062, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1053 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1053;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1055)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1055 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1055;
|
|
}
|
|
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 (_primitiveBranch1058)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1062, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1061 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1061;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1062)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1062 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1062;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1063)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1067, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1058 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1058;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1060)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1060 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1060;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_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.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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.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 (_primitiveBranch1073)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1077, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1068 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1068;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1070)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1070 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1070;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
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;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1077)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1077 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1077;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1078)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1082, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _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;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1078)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1082, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1081 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1081;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1082)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1082 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1082;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1080)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1078 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1078;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1080)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1080 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1080;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch1083)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1087, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1086 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1086;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1087)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1087 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1087;
|
|
}
|
|
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 (_primitiveBranch1088)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1092, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1083 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1083;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1085)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1085 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1085;
|
|
}
|
|
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 (_primitiveBranch1088)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1092, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1091 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1091;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1092)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1092 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1092;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1093)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1097, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1088 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1088;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1090)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1090 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1090;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1093)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1097, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1096 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1096;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1097)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1097 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1097;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1095)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1093 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1093;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1095)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1095 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1095;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch1098)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1102, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1101 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1101;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1102)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1102 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1102;
|
|
}
|
|
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 (_primitiveBranch1103)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1107, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1098 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1098;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1100)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1100 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1100;
|
|
}
|
|
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 (_primitiveBranch1103)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1107, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1106 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1106;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1107)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1107 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1107;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1108)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1112, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1103 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1103;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1105)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1105 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1105;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1108)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1112, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1111 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1111;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1112)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1112 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1112;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1110)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1108 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1108;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1110)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1110 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1110;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch1113)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1117, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1116 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1116;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1117)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1117 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1117;
|
|
}
|
|
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 (_primitiveBranch1118)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1122, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1113 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1113;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1115)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1115 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1115;
|
|
}
|
|
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 (_primitiveBranch1118)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1122, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1121 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1121;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1122)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1122 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1122;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1123)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1127, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1118 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1118;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1120)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1120 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1120;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1123)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1127, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1126 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1126;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1127)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1127 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1127;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1125)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1123 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1123;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1125)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1125 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1125;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch1128)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1132, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1131 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1131;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1132)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1132 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1132;
|
|
}
|
|
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 (_primitiveBranch1133)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1137, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1128 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1128;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1130)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1130 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1130;
|
|
}
|
|
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 (_primitiveBranch1133)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1137, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1136 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1136;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1137)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1137 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1137;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1138)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1142, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1133 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1133;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1135)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1135 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1135;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1138)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1142, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1141 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1141;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1142)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1142 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1142;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1140)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1138 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1138;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1140)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1140 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1140;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch1143)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1147, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1146 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1146;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1147)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1147 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1147;
|
|
}
|
|
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 (_primitiveBranch1148)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1152, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1143 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1143;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1145)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1145 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1145;
|
|
}
|
|
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 (_primitiveBranch1148)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1152, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1151 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1151;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1152)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1152 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1152;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1153)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1157, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1148 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1148;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1150)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1150 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1150;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1153)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1157, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1156 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1156;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1157)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1157 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1157;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1155)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1153 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1153;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1155)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1155 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1155;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch1158)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1162, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1161 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1161;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1162)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1162 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1162;
|
|
}
|
|
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 (_primitiveBranch1163)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1167, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1158 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1158;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1160)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1160 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1160;
|
|
}
|
|
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 (_primitiveBranch1163)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1167, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1166 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1166;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1167)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1167 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1167;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch1168)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1172, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1163 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1163;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1165)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1165 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1165;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch1168)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1172, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1171 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1171;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1172)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1172 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1172;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1173)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1177, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1168 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1168;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1170)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1170 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1170;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1173)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1177, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1176 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1176;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1177)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1177 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1177;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch1178)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1182, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1173 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1173;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1175)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1175 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1175;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch1178)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1182, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1181 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1181;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1182)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1182 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1182;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1183)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1187, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1178 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1178;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1180)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1180 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1180;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1183)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1187, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1186 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1186;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1187)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1187 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1187;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1188)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1192, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1183 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1183;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1185)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1185 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1185;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1188)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1192, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1191 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1191;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1192)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1192 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1192;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1190)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1188 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1188;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1190)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1190 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1190;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch1193)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1197, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1196 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1196;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1197)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1197 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1197;
|
|
}
|
|
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 (_primitiveBranch1198)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1202, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1193 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1193;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1195)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1195 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1195;
|
|
}
|
|
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 (_primitiveBranch1198)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1202, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1201 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1201;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1202)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1202 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1202;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1203)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1207, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1198 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1198;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1200)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1200 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1200;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1203)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1207, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1206 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1206;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1207)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1207 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1207;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1205)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1203 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1203;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1205)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1205 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1205;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch1208)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1212, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1211 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1211;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1212)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1212 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1212;
|
|
}
|
|
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 (_primitiveBranch1213)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1217, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1208 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1208;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1210)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1210 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1210;
|
|
}
|
|
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 (_primitiveBranch1213)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1217, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1216 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1216;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1217)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1217 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1217;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1218)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1222, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1213 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1213;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1215)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1215 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1215;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1218)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1222, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1221 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1221;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1222)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1222 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1222;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1220)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1218 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1218;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1220)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1220 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1220;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch1223)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1227, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1226 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1226;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1227)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1227 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1227;
|
|
}
|
|
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 (_primitiveBranch1228)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1232, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1223 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1223;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1225)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1225 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1225;
|
|
}
|
|
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 (_primitiveBranch1228)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1232, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1231 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1231;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1232)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1232 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1232;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch1233)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1237, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1228 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1228;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1230)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1230 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1230;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch1233)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1237, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1236 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1236;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1237)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1237 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1237;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1238)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1242, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1233 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1233;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1235)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1235 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1235;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1238)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1242, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1241 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1241;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1242)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1242 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1242;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1243)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1247, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1238 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1238;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1240)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1240 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1240;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1243)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1247, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1246 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1246;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1247)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1247 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1247;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1245)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1243 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1243;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1245)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1245 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1245;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
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 (_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.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 (_primitiveBranch1253)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1257, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(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;
|
|
return (_afterCall1250)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1250 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1250;
|
|
}
|
|
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 (_primitiveBranch1253)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1257, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1256 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1256;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1257)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1257 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1257;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1258)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1262, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1253 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1253;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1255)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1255 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1255;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1258)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1262, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1261 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1261;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1262)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1262 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1262;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1260)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1258 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1258;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1260)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1260 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1260;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
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 (_primitiveBranch1263)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1267, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1266 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1266;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1267)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1267 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1267;
|
|
}
|
|
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 (_primitiveBranch1268)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1272, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1263 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1263;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1265)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1265 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1265;
|
|
}
|
|
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 (_primitiveBranch1268)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1272, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1271 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1271;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1272)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1272 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1272;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1273)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1277, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1268 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1268;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1270)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1270 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1270;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1273)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1277, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1276 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1276;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1277)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1277 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1277;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1275)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1273 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1273;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1275)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1275 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1275;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
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 (_primitiveBranch1278)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1282, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1281 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1281;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1282)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1282 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1282;
|
|
}
|
|
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 (_primitiveBranch1283)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1287, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1278 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1278;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1280)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1280 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1280;
|
|
}
|
|
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 (_primitiveBranch1283)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1287, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1286 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1286;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1287)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1287 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1287;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1288)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1292, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1283 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1283;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1285)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1285 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1285;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1288)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1292, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1291 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1291;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1292)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1292 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1292;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1290)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1288 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1288;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1290)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1290 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1290;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
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 (_primitiveBranch1293)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1297, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1296 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1296;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1297)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1297 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1297;
|
|
}
|
|
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 (_primitiveBranch1298)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1302, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1293 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1293;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1295)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1295 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1295;
|
|
}
|
|
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 (_primitiveBranch1298)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1302, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1301 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1301;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1302)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1302 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1302;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1303)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1307, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1298 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1298;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1300)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1300 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1300;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1303)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1307, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1306 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1306;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1307)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1307 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1307;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1305)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1303 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1303;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1305)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1305 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1305;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
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 (_primitiveBranch1308)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1312, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1311 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1311;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1312)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1312 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1312;
|
|
}
|
|
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 (_primitiveBranch1313)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1317, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1308 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1308;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1310)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1310 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1310;
|
|
}
|
|
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 (_primitiveBranch1313)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1317, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1316 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1316;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1317)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1317 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1317;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1318)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1322, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1313 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1313;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1315)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1315 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1315;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1318)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1322, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1321 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1321;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1322)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1322 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1322;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1320)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1318 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1318;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1320)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1320 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1320;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
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 (_primitiveBranch1323)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1327, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1326 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1326;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1327)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1327 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1327;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1328)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1332, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1323 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1323;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1325)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1325 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1325;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.val;
|
|
MACHINE.argcount = 3;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1328)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1332, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1331 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1331;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1332)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1332 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1332;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch1333)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1337, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1328 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1328;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1330)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1330 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1330;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch1333)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1337, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1336 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1336;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1337)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1337 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1337;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1338)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1342, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1333 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1333;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1335)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1335 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1335;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1338)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1342, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1341 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1341;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1342)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1342 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1342;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1343)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1347, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1338 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1338;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1340)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1340 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1340;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1343)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1347, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1346 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1346;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1347)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1347 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1347;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1345)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1343 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1343;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1345)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1345 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1345;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
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 (_primitiveBranch1348)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1352, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1351 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1351;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1352)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1352 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1352;
|
|
}
|
|
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 (_primitiveBranch1353)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1357, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1348 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1348;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1350)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1350 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1350;
|
|
}
|
|
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 (_primitiveBranch1353)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1357, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1356 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1356;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1357)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1357 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1357;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1358)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1362, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1353 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1353;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1355)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1355 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1355;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1358)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1362, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1361 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1361;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1362)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1362 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1362;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1360)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1358 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1358;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1360)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1360 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1360;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
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 (_primitiveBranch1363)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1367, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1366 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1366;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1367)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1367 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1367;
|
|
}
|
|
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 (_primitiveBranch1368)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1372, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1363 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1363;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1365)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1365 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1365;
|
|
}
|
|
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 (_primitiveBranch1368)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1372, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1371 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1371;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1372)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1372 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1372;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1373)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1377, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1368 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1368;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1370)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1370 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1370;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1373)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1377, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1376 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1376;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1377)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1377 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1377;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1375)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1373 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1373;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1375)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1375 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1375;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
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 (_primitiveBranch1378)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1382, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1381 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1381;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1382)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1382 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1382;
|
|
}
|
|
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 (_primitiveBranch1383)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1387, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1378 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1378;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1380)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1380 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1380;
|
|
}
|
|
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 (_primitiveBranch1383)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1387, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1386 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1386;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1387)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1387 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1387;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1388)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1392, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1383 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1383;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1385)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1385 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1385;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1388)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1392, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1391 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1391;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1392)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1392 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1392;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1390)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1388 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1388;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1390)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1390 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1390;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
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 (_primitiveBranch1393)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1397, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1396 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1396;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1397)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1397 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1397;
|
|
}
|
|
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 (_primitiveBranch1398)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1402, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1393 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1393;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1395)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1395 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1395;
|
|
}
|
|
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 (_primitiveBranch1398)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1402, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1401 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1401;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1402)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1402 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1402;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1403)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1407, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1398 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1398;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1400)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1400 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1400;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1403)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1407, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1406 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1406;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1407)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1407 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1407;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1405)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1403 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1403;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1405)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1405 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1405;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
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 (_primitiveBranch1408)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1412, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1411 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1411;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1412)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1412 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1412;
|
|
}
|
|
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 (_primitiveBranch1413)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1417, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1408 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1408;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1410)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1410 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1410;
|
|
}
|
|
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 (_primitiveBranch1413)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1417, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1416 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1416;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1417)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1417 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1417;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1418)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1422, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1413 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1413;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1415)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1415 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1415;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1418)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1422, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1421 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1421;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1422)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1422 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1422;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1420)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1418 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1418;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1420)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1420 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1420;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
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 (_primitiveBranch1423)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1427, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1426 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1426;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1427)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1427 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1427;
|
|
}
|
|
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 (_primitiveBranch1428)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1432, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1423 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1423;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1425)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1425 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1425;
|
|
}
|
|
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 (_primitiveBranch1428)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1432, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1431 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1431;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1432)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1432 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1432;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1433)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1437, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1428 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1428;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1430)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1430 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1430;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1433)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1437, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1436 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1436;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1437)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1437 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1437;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1435)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1433 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1433;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1435)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1435 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1435;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
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 (_primitiveBranch1438)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1442, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1441 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1441;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1442)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1442 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1442;
|
|
}
|
|
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 (_primitiveBranch1443)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1447, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1438 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1438;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.val=MACHINE.proc(MACHINE);
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_afterCall1440)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1440 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1440;
|
|
}
|
|
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 (_primitiveBranch1443)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1447, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1446 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1446;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1447)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1447 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1447;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1448)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1452, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1443 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1443;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1445)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1445 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1445;
|
|
}
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1448)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1452, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1451 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1451;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1452)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1452 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1452;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1450)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1448 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1448;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1450)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1450 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1450;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=plt.baselib.numbers.subtract(((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 = 256;
|
|
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 (_primitiveBranch1453)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1457, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1456 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1456;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1457)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1457 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1457;
|
|
}
|
|
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 (_primitiveBranch1458)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1462, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1453 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1453;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1455)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1455 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1455;
|
|
}
|
|
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 (_primitiveBranch1458)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1462, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1461 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1461;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1462)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1462 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1462;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch1463)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1467, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1458 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1458;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1460)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1460 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1460;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch1463)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1467, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1466 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1466;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1467)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1467 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1467;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1468)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1472, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1463 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1463;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1465)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1465 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1465;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1468)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1472, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1471 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1471;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1472)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1472 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1472;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1473)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1477, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1468 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1468;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1470)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1470 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1470;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(undefined, undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 2] = MACHINE.env[MACHINE.env.length - 1 - 3][4];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 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 - 5][5];
|
|
MACHINE.env.push(undefined, undefined);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 9][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 9][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 9][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 9].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 9][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 (_primitiveBranch1473)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1477, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1476 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1476;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1477)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1477 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1477;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1475)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1473 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1473;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1475)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1475 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1475;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = 1;
|
|
MACHINE.env[MACHINE.env.length - 1 - 2]=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 = 256;
|
|
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 (_primitiveBranch1478)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1482, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1481 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1481;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1482)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1482 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1482;
|
|
}
|
|
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 (_primitiveBranch1483)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1487, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1478 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1478;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1480)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1480 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1480;
|
|
}
|
|
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 (_primitiveBranch1483)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1487, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1486 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1486;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1487)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1487 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1487;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch1488)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1492, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1483 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1483;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1485)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1485 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1485;
|
|
}
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch1488)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1492, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1491 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1491;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1492)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1492 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1492;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1493)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1497, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1488 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1488;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1490)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1490 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1490;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1493)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1497, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1496 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1496;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1497)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1497 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1497;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch1498)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1502, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1493 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1493;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1495)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1495 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1495;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][1]=plt.baselib.numbers.add(((RUNTIME.isNumber(MACHINE.env[MACHINE.env.length - 1 - 0][1])) ? (MACHINE.env[MACHINE.env.length - 1 - 0][1]) : RUNTIME.raiseArgumentTypeError(MACHINE, "+", "number", 0, MACHINE.env[MACHINE.env.length - 1 - 0][1])), 1);
|
|
MACHINE.val = RUNTIME.VOID;
|
|
|
|
MACHINE.env.push(MACHINE.env[MACHINE.env.length - 1 - 0][7]);
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 3][6];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.env[MACHINE.env.length - 1 - 3][0];
|
|
if (MACHINE.env[MACHINE.env.length - 1 - 3][1] === undefined) { RUNTIME.raiseUnboundToplevelError(MACHINE.env[MACHINE.env.length - 1 - 3].names[1]); }
|
|
MACHINE.val = MACHINE.env[MACHINE.env.length - 1 - 3][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 (_primitiveBranch1498)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1502, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1501 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1501;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1502)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1502 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1502;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1503)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1507, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1498 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1498;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1500)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1500 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1500;
|
|
}
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
MACHINE.argcount = 1;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1503)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1507, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1506 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1506;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1507)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1507 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1507;
|
|
}
|
|
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0][8];
|
|
MACHINE.argcount = 0;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1508)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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.length = MACHINE.env.length - 1;
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1503 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1503;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1505)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1505 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1505;
|
|
}
|
|
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0][8];
|
|
MACHINE.argcount = 0;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1508)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
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.length = MACHINE.env.length - 1;
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1508 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1508;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.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 _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/hello.rkt"]=new RUNTIME.ModuleRecord("hello", _moduleEntry1514);
|
|
return (_afterModuleBody1513)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry1514 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry1514;
|
|
}
|
|
MACHINE.modules["whalesong/racketcon/hello.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/bf/language.rkt"] !== undefined) !== false) { return (_linked1515)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/bf/language.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1516)(MACHINE);
|
|
};
|
|
|
|
var _linked1515 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1515;
|
|
}
|
|
if (MACHINE.modules["whalesong/bf/language.rkt"].isInvoked !== false) { return (_alreadyLoaded1516)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1518, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/bf/language.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1517 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1517;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1518)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1518 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1518;
|
|
}
|
|
MACHINE.env.push([MACHINE.params.currentNamespace["current-data"] || MACHINE.primitives["current-data"],MACHINE.params.currentNamespace["current-ptr"] || MACHINE.primitives["current-ptr"],MACHINE.primitives["make-vector"],MACHINE.params.currentNamespace["run.1"] || MACHINE.primitives["run.1"],MACHINE.primitives["vector-set!"],MACHINE.primitives["modulo"],MACHINE.primitives["vector-ref"],MACHINE.primitives["write-byte"],MACHINE.primitives["void"],false]); MACHINE.env[MACHINE.env.length-1].names = ["current-data","current-ptr","make-vector","run.1","vector-set!","modulo","vector-ref","write-byte","void",false];
|
|
MACHINE.modules["whalesong/racketcon/hello.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1520, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry12, 0, [MACHINE.env[MACHINE.env.length - 1 - 0]], "loop");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][9] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1516 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1516;
|
|
}
|
|
MACHINE.env.push([MACHINE.params.currentNamespace["current-data"] || MACHINE.primitives["current-data"],MACHINE.params.currentNamespace["current-ptr"] || MACHINE.primitives["current-ptr"],MACHINE.primitives["make-vector"],MACHINE.params.currentNamespace["run.1"] || MACHINE.primitives["run.1"],MACHINE.primitives["vector-set!"],MACHINE.primitives["modulo"],MACHINE.primitives["vector-ref"],MACHINE.primitives["write-byte"],MACHINE.primitives["void"],false]); MACHINE.env[MACHINE.env.length-1].names = ["current-data","current-ptr","make-vector","run.1","vector-set!","modulo","vector-ref","write-byte","void",false];
|
|
MACHINE.modules["whalesong/racketcon/hello.rkt"].prefix = MACHINE.env[MACHINE.env.length - 1 - 0];
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1520, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry12, 0, [MACHINE.env[MACHINE.env.length - 1 - 0]], "loop");
|
|
MACHINE.env[MACHINE.env.length - 1 - 0][9] = MACHINE.val;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1519 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1519;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1520)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1520 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1520;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1522, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.primitives["values"];
|
|
|
|
MACHINE.env.push(undefined, undefined);
|
|
MACHINE.env[MACHINE.env.length - 1 - 1] = MACHINE.env[MACHINE.env.length - 1 - 4][2];
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = 30000;
|
|
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 (_primitiveBranch1523)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1527, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1526 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1526;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1527)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1527 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1527;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1525)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1523 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1523;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1525)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1525 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1525;
|
|
}
|
|
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 (_primitiveBranch1528)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1532, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1531 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1531;
|
|
}
|
|
if ((MACHINE.argcount - 2) === 0) { return (_afterValueCheck1533)(MACHINE); }
|
|
return (_procReturn1532)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1532 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1532;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 2);
|
|
return (_afterValueCheck1533)(MACHINE);
|
|
};
|
|
|
|
var _afterValueCheck1533 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterValueCheck1533;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1][0] = MACHINE.val;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1][1] = 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();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1528 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1528;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
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, 2);
|
|
return (_afterCall1530)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1530 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1530;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 1][0] = MACHINE.val;
|
|
MACHINE.env[MACHINE.env.length - 1 - 1][1] = 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();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1521 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1521;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1522)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1522 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1522;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1535, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry13, 0, [MACHINE.env[MACHINE.env.length - 1 - 0]], "run");
|
|
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 _beforePromptPopMultiple1534 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1534;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1535)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1535 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1535;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePromptPop1537, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
|
|
MACHINE.proc = MACHINE.env[MACHINE.env.length - 1 - 0][3];
|
|
MACHINE.argcount = 0;
|
|
if (typeof(MACHINE.proc) === 'function') { return (_primitiveBranch1538)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1542, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1541 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1541;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_procReturn1542)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1542 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1542;
|
|
}
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1538 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1538;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.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 (_afterCall1540)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1540 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1540;
|
|
}
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPopMultiple1536 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1536;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1537)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1537 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1537;
|
|
}
|
|
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/hello.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterModuleBody1513 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody1513;
|
|
}
|
|
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/hello.rkt"]);
|
|
};
|
|
|
|
_procReturn156.multipleValueReturn = _procReturnMultiple155;
|
|
_procReturn161.multipleValueReturn = _procReturnMultiple160;
|
|
_procReturn166.multipleValueReturn = _procReturnMultiple165;
|
|
_procReturn171.multipleValueReturn = _procReturnMultiple170;
|
|
_procReturn176.multipleValueReturn = _procReturnMultiple175;
|
|
_procReturn181.multipleValueReturn = _procReturnMultiple180;
|
|
_procReturn186.multipleValueReturn = _procReturnMultiple185;
|
|
_procReturn191.multipleValueReturn = _procReturnMultiple190;
|
|
_procReturn196.multipleValueReturn = _procReturnMultiple195;
|
|
_procReturn201.multipleValueReturn = _procReturnMultiple200;
|
|
_procReturn206.multipleValueReturn = _procReturnMultiple205;
|
|
_procReturn211.multipleValueReturn = _procReturnMultiple210;
|
|
_procReturn216.multipleValueReturn = _procReturnMultiple215;
|
|
_procReturn221.multipleValueReturn = _procReturnMultiple220;
|
|
_procReturn226.multipleValueReturn = _procReturnMultiple225;
|
|
_procReturn231.multipleValueReturn = _procReturnMultiple230;
|
|
_procReturn236.multipleValueReturn = _procReturnMultiple235;
|
|
_procReturn241.multipleValueReturn = _procReturnMultiple240;
|
|
_procReturn246.multipleValueReturn = _procReturnMultiple245;
|
|
_procReturn251.multipleValueReturn = _procReturnMultiple250;
|
|
_procReturn256.multipleValueReturn = _procReturnMultiple255;
|
|
_procReturn261.multipleValueReturn = _procReturnMultiple260;
|
|
_procReturn266.multipleValueReturn = _procReturnMultiple265;
|
|
_procReturn271.multipleValueReturn = _procReturnMultiple270;
|
|
_procReturn276.multipleValueReturn = _procReturnMultiple275;
|
|
_procReturn281.multipleValueReturn = _procReturnMultiple280;
|
|
_procReturn286.multipleValueReturn = _procReturnMultiple285;
|
|
_procReturn291.multipleValueReturn = _procReturnMultiple290;
|
|
_procReturn296.multipleValueReturn = _procReturnMultiple295;
|
|
_procReturn301.multipleValueReturn = _procReturnMultiple300;
|
|
_procReturn306.multipleValueReturn = _procReturnMultiple305;
|
|
_procReturn311.multipleValueReturn = _procReturnMultiple310;
|
|
_procReturn316.multipleValueReturn = _procReturnMultiple315;
|
|
_procReturn321.multipleValueReturn = _procReturnMultiple320;
|
|
_procReturn326.multipleValueReturn = _procReturnMultiple325;
|
|
_procReturn331.multipleValueReturn = _procReturnMultiple330;
|
|
_procReturn336.multipleValueReturn = _procReturnMultiple335;
|
|
_procReturn341.multipleValueReturn = _procReturnMultiple340;
|
|
_procReturn346.multipleValueReturn = _procReturnMultiple345;
|
|
_procReturn351.multipleValueReturn = _procReturnMultiple350;
|
|
_procReturn356.multipleValueReturn = _procReturnMultiple355;
|
|
_procReturn361.multipleValueReturn = _procReturnMultiple360;
|
|
_procReturn366.multipleValueReturn = _procReturnMultiple365;
|
|
_procReturn371.multipleValueReturn = _procReturnMultiple370;
|
|
_procReturn376.multipleValueReturn = _procReturnMultiple375;
|
|
_procReturn381.multipleValueReturn = _procReturnMultiple380;
|
|
_procReturn386.multipleValueReturn = _procReturnMultiple385;
|
|
_procReturn391.multipleValueReturn = _procReturnMultiple390;
|
|
_procReturn396.multipleValueReturn = _procReturnMultiple395;
|
|
_procReturn401.multipleValueReturn = _procReturnMultiple400;
|
|
_procReturn406.multipleValueReturn = _procReturnMultiple405;
|
|
_procReturn411.multipleValueReturn = _procReturnMultiple410;
|
|
_procReturn416.multipleValueReturn = _procReturnMultiple415;
|
|
_procReturn421.multipleValueReturn = _procReturnMultiple420;
|
|
_procReturn426.multipleValueReturn = _procReturnMultiple425;
|
|
_procReturn431.multipleValueReturn = _procReturnMultiple430;
|
|
_procReturn436.multipleValueReturn = _procReturnMultiple435;
|
|
_procReturn441.multipleValueReturn = _procReturnMultiple440;
|
|
_procReturn446.multipleValueReturn = _procReturnMultiple445;
|
|
_procReturn451.multipleValueReturn = _procReturnMultiple450;
|
|
_procReturn456.multipleValueReturn = _procReturnMultiple455;
|
|
_procReturn461.multipleValueReturn = _procReturnMultiple460;
|
|
_procReturn466.multipleValueReturn = _procReturnMultiple465;
|
|
_procReturn471.multipleValueReturn = _procReturnMultiple470;
|
|
_procReturn476.multipleValueReturn = _procReturnMultiple475;
|
|
_procReturn481.multipleValueReturn = _procReturnMultiple480;
|
|
_procReturn489.multipleValueReturn = _procReturnMultiple488;
|
|
_procReturn499.multipleValueReturn = _procReturnMultiple498;
|
|
_procReturn504.multipleValueReturn = _procReturnMultiple503;
|
|
_procReturn509.multipleValueReturn = _procReturnMultiple508;
|
|
_procReturn514.multipleValueReturn = _procReturnMultiple513;
|
|
_procReturn519.multipleValueReturn = _procReturnMultiple518;
|
|
_procReturn524.multipleValueReturn = _procReturnMultiple523;
|
|
_procReturn529.multipleValueReturn = _procReturnMultiple528;
|
|
_procReturn534.multipleValueReturn = _procReturnMultiple533;
|
|
_procReturn539.multipleValueReturn = _procReturnMultiple538;
|
|
_procReturn544.multipleValueReturn = _procReturnMultiple543;
|
|
_procReturn549.multipleValueReturn = _procReturnMultiple548;
|
|
_procReturn554.multipleValueReturn = _procReturnMultiple553;
|
|
_procReturn559.multipleValueReturn = _procReturnMultiple558;
|
|
_procReturn564.multipleValueReturn = _procReturnMultiple563;
|
|
_procReturn569.multipleValueReturn = _procReturnMultiple568;
|
|
_procReturn574.multipleValueReturn = _procReturnMultiple573;
|
|
_procReturn579.multipleValueReturn = _procReturnMultiple578;
|
|
_procReturn584.multipleValueReturn = _procReturnMultiple583;
|
|
_procReturn589.multipleValueReturn = _procReturnMultiple588;
|
|
_procReturn594.multipleValueReturn = _procReturnMultiple593;
|
|
_procReturn599.multipleValueReturn = _procReturnMultiple598;
|
|
_procReturn604.multipleValueReturn = _procReturnMultiple603;
|
|
_procReturn609.multipleValueReturn = _procReturnMultiple608;
|
|
_procReturn614.multipleValueReturn = _procReturnMultiple613;
|
|
_procReturn619.multipleValueReturn = _procReturnMultiple618;
|
|
_procReturn624.multipleValueReturn = _procReturnMultiple623;
|
|
_procReturn629.multipleValueReturn = _procReturnMultiple628;
|
|
_procReturn634.multipleValueReturn = _procReturnMultiple633;
|
|
_procReturn639.multipleValueReturn = _procReturnMultiple638;
|
|
_procReturn644.multipleValueReturn = _procReturnMultiple643;
|
|
_procReturn652.multipleValueReturn = _procReturnMultiple651;
|
|
_procReturn657.multipleValueReturn = _procReturnMultiple656;
|
|
_procReturn662.multipleValueReturn = _procReturnMultiple661;
|
|
_procReturn667.multipleValueReturn = _procReturnMultiple666;
|
|
_procReturn672.multipleValueReturn = _procReturnMultiple671;
|
|
_procReturn677.multipleValueReturn = _procReturnMultiple676;
|
|
_procReturn682.multipleValueReturn = _procReturnMultiple681;
|
|
_procReturn687.multipleValueReturn = _procReturnMultiple686;
|
|
_procReturn692.multipleValueReturn = _procReturnMultiple691;
|
|
_procReturn697.multipleValueReturn = _procReturnMultiple696;
|
|
_procReturn702.multipleValueReturn = _procReturnMultiple701;
|
|
_procReturn707.multipleValueReturn = _procReturnMultiple706;
|
|
_procReturn712.multipleValueReturn = _procReturnMultiple711;
|
|
_procReturn717.multipleValueReturn = _procReturnMultiple716;
|
|
_procReturn722.multipleValueReturn = _procReturnMultiple721;
|
|
_procReturn727.multipleValueReturn = _procReturnMultiple726;
|
|
_procReturn732.multipleValueReturn = _procReturnMultiple731;
|
|
_procReturn737.multipleValueReturn = _procReturnMultiple736;
|
|
_procReturn742.multipleValueReturn = _procReturnMultiple741;
|
|
_procReturn747.multipleValueReturn = _procReturnMultiple746;
|
|
_procReturn752.multipleValueReturn = _procReturnMultiple751;
|
|
_procReturn757.multipleValueReturn = _procReturnMultiple756;
|
|
_procReturn762.multipleValueReturn = _procReturnMultiple761;
|
|
_procReturn767.multipleValueReturn = _procReturnMultiple766;
|
|
_procReturn772.multipleValueReturn = _procReturnMultiple771;
|
|
_procReturn777.multipleValueReturn = _procReturnMultiple776;
|
|
_procReturn782.multipleValueReturn = _procReturnMultiple781;
|
|
_procReturn787.multipleValueReturn = _procReturnMultiple786;
|
|
_procReturn792.multipleValueReturn = _procReturnMultiple791;
|
|
_procReturn797.multipleValueReturn = _procReturnMultiple796;
|
|
_procReturn802.multipleValueReturn = _procReturnMultiple801;
|
|
_procReturn807.multipleValueReturn = _procReturnMultiple806;
|
|
_procReturn812.multipleValueReturn = _procReturnMultiple811;
|
|
_procReturn817.multipleValueReturn = _procReturnMultiple816;
|
|
_procReturn822.multipleValueReturn = _procReturnMultiple821;
|
|
_procReturn827.multipleValueReturn = _procReturnMultiple826;
|
|
_procReturn832.multipleValueReturn = _procReturnMultiple831;
|
|
_procReturn837.multipleValueReturn = _procReturnMultiple836;
|
|
_procReturn842.multipleValueReturn = _procReturnMultiple841;
|
|
_procReturn847.multipleValueReturn = _procReturnMultiple846;
|
|
_procReturn852.multipleValueReturn = _procReturnMultiple851;
|
|
_procReturn857.multipleValueReturn = _procReturnMultiple856;
|
|
_procReturn862.multipleValueReturn = _procReturnMultiple861;
|
|
_procReturn867.multipleValueReturn = _procReturnMultiple866;
|
|
_procReturn872.multipleValueReturn = _procReturnMultiple871;
|
|
_procReturn877.multipleValueReturn = _procReturnMultiple876;
|
|
_procReturn882.multipleValueReturn = _procReturnMultiple881;
|
|
_procReturn887.multipleValueReturn = _procReturnMultiple886;
|
|
_procReturn892.multipleValueReturn = _procReturnMultiple891;
|
|
_procReturn897.multipleValueReturn = _procReturnMultiple896;
|
|
_procReturn902.multipleValueReturn = _procReturnMultiple901;
|
|
_procReturn907.multipleValueReturn = _procReturnMultiple906;
|
|
_procReturn912.multipleValueReturn = _procReturnMultiple911;
|
|
_procReturn917.multipleValueReturn = _procReturnMultiple916;
|
|
_procReturn922.multipleValueReturn = _procReturnMultiple921;
|
|
_procReturn927.multipleValueReturn = _procReturnMultiple926;
|
|
_procReturn932.multipleValueReturn = _procReturnMultiple931;
|
|
_procReturn937.multipleValueReturn = _procReturnMultiple936;
|
|
_procReturn942.multipleValueReturn = _procReturnMultiple941;
|
|
_procReturn947.multipleValueReturn = _procReturnMultiple946;
|
|
_procReturn952.multipleValueReturn = _procReturnMultiple951;
|
|
_procReturn957.multipleValueReturn = _procReturnMultiple956;
|
|
_procReturn962.multipleValueReturn = _procReturnMultiple961;
|
|
_procReturn967.multipleValueReturn = _procReturnMultiple966;
|
|
_procReturn972.multipleValueReturn = _procReturnMultiple971;
|
|
_procReturn977.multipleValueReturn = _procReturnMultiple976;
|
|
_procReturn982.multipleValueReturn = _procReturnMultiple981;
|
|
_procReturn987.multipleValueReturn = _procReturnMultiple986;
|
|
_procReturn992.multipleValueReturn = _procReturnMultiple991;
|
|
_procReturn997.multipleValueReturn = _procReturnMultiple996;
|
|
_procReturn1002.multipleValueReturn = _procReturnMultiple1001;
|
|
_procReturn1007.multipleValueReturn = _procReturnMultiple1006;
|
|
_procReturn1012.multipleValueReturn = _procReturnMultiple1011;
|
|
_procReturn1017.multipleValueReturn = _procReturnMultiple1016;
|
|
_procReturn1022.multipleValueReturn = _procReturnMultiple1021;
|
|
_procReturn1027.multipleValueReturn = _procReturnMultiple1026;
|
|
_procReturn1032.multipleValueReturn = _procReturnMultiple1031;
|
|
_procReturn1037.multipleValueReturn = _procReturnMultiple1036;
|
|
_procReturn1042.multipleValueReturn = _procReturnMultiple1041;
|
|
_procReturn1047.multipleValueReturn = _procReturnMultiple1046;
|
|
_procReturn1052.multipleValueReturn = _procReturnMultiple1051;
|
|
_procReturn1057.multipleValueReturn = _procReturnMultiple1056;
|
|
_procReturn1062.multipleValueReturn = _procReturnMultiple1061;
|
|
_procReturn1067.multipleValueReturn = _procReturnMultiple1066;
|
|
_procReturn1072.multipleValueReturn = _procReturnMultiple1071;
|
|
_procReturn1077.multipleValueReturn = _procReturnMultiple1076;
|
|
_procReturn1082.multipleValueReturn = _procReturnMultiple1081;
|
|
_procReturn1087.multipleValueReturn = _procReturnMultiple1086;
|
|
_procReturn1092.multipleValueReturn = _procReturnMultiple1091;
|
|
_procReturn1097.multipleValueReturn = _procReturnMultiple1096;
|
|
_procReturn1102.multipleValueReturn = _procReturnMultiple1101;
|
|
_procReturn1107.multipleValueReturn = _procReturnMultiple1106;
|
|
_procReturn1112.multipleValueReturn = _procReturnMultiple1111;
|
|
_procReturn1117.multipleValueReturn = _procReturnMultiple1116;
|
|
_procReturn1122.multipleValueReturn = _procReturnMultiple1121;
|
|
_procReturn1127.multipleValueReturn = _procReturnMultiple1126;
|
|
_procReturn1132.multipleValueReturn = _procReturnMultiple1131;
|
|
_procReturn1137.multipleValueReturn = _procReturnMultiple1136;
|
|
_procReturn1142.multipleValueReturn = _procReturnMultiple1141;
|
|
_procReturn1147.multipleValueReturn = _procReturnMultiple1146;
|
|
_procReturn1152.multipleValueReturn = _procReturnMultiple1151;
|
|
_procReturn1157.multipleValueReturn = _procReturnMultiple1156;
|
|
_procReturn1162.multipleValueReturn = _procReturnMultiple1161;
|
|
_procReturn1167.multipleValueReturn = _procReturnMultiple1166;
|
|
_procReturn1172.multipleValueReturn = _procReturnMultiple1171;
|
|
_procReturn1177.multipleValueReturn = _procReturnMultiple1176;
|
|
_procReturn1182.multipleValueReturn = _procReturnMultiple1181;
|
|
_procReturn1187.multipleValueReturn = _procReturnMultiple1186;
|
|
_procReturn1192.multipleValueReturn = _procReturnMultiple1191;
|
|
_procReturn1197.multipleValueReturn = _procReturnMultiple1196;
|
|
_procReturn1202.multipleValueReturn = _procReturnMultiple1201;
|
|
_procReturn1207.multipleValueReturn = _procReturnMultiple1206;
|
|
_procReturn1212.multipleValueReturn = _procReturnMultiple1211;
|
|
_procReturn1217.multipleValueReturn = _procReturnMultiple1216;
|
|
_procReturn1222.multipleValueReturn = _procReturnMultiple1221;
|
|
_procReturn1227.multipleValueReturn = _procReturnMultiple1226;
|
|
_procReturn1232.multipleValueReturn = _procReturnMultiple1231;
|
|
_procReturn1237.multipleValueReturn = _procReturnMultiple1236;
|
|
_procReturn1242.multipleValueReturn = _procReturnMultiple1241;
|
|
_procReturn1247.multipleValueReturn = _procReturnMultiple1246;
|
|
_procReturn1252.multipleValueReturn = _procReturnMultiple1251;
|
|
_procReturn1257.multipleValueReturn = _procReturnMultiple1256;
|
|
_procReturn1262.multipleValueReturn = _procReturnMultiple1261;
|
|
_procReturn1267.multipleValueReturn = _procReturnMultiple1266;
|
|
_procReturn1272.multipleValueReturn = _procReturnMultiple1271;
|
|
_procReturn1277.multipleValueReturn = _procReturnMultiple1276;
|
|
_procReturn1282.multipleValueReturn = _procReturnMultiple1281;
|
|
_procReturn1287.multipleValueReturn = _procReturnMultiple1286;
|
|
_procReturn1292.multipleValueReturn = _procReturnMultiple1291;
|
|
_procReturn1297.multipleValueReturn = _procReturnMultiple1296;
|
|
_procReturn1302.multipleValueReturn = _procReturnMultiple1301;
|
|
_procReturn1307.multipleValueReturn = _procReturnMultiple1306;
|
|
_procReturn1312.multipleValueReturn = _procReturnMultiple1311;
|
|
_procReturn1317.multipleValueReturn = _procReturnMultiple1316;
|
|
_procReturn1322.multipleValueReturn = _procReturnMultiple1321;
|
|
_procReturn1327.multipleValueReturn = _procReturnMultiple1326;
|
|
_procReturn1332.multipleValueReturn = _procReturnMultiple1331;
|
|
_procReturn1337.multipleValueReturn = _procReturnMultiple1336;
|
|
_procReturn1342.multipleValueReturn = _procReturnMultiple1341;
|
|
_procReturn1347.multipleValueReturn = _procReturnMultiple1346;
|
|
_procReturn1352.multipleValueReturn = _procReturnMultiple1351;
|
|
_procReturn1357.multipleValueReturn = _procReturnMultiple1356;
|
|
_procReturn1362.multipleValueReturn = _procReturnMultiple1361;
|
|
_procReturn1367.multipleValueReturn = _procReturnMultiple1366;
|
|
_procReturn1372.multipleValueReturn = _procReturnMultiple1371;
|
|
_procReturn1377.multipleValueReturn = _procReturnMultiple1376;
|
|
_procReturn1382.multipleValueReturn = _procReturnMultiple1381;
|
|
_procReturn1387.multipleValueReturn = _procReturnMultiple1386;
|
|
_procReturn1392.multipleValueReturn = _procReturnMultiple1391;
|
|
_procReturn1397.multipleValueReturn = _procReturnMultiple1396;
|
|
_procReturn1402.multipleValueReturn = _procReturnMultiple1401;
|
|
_procReturn1407.multipleValueReturn = _procReturnMultiple1406;
|
|
_procReturn1412.multipleValueReturn = _procReturnMultiple1411;
|
|
_procReturn1417.multipleValueReturn = _procReturnMultiple1416;
|
|
_procReturn1422.multipleValueReturn = _procReturnMultiple1421;
|
|
_procReturn1427.multipleValueReturn = _procReturnMultiple1426;
|
|
_procReturn1432.multipleValueReturn = _procReturnMultiple1431;
|
|
_procReturn1437.multipleValueReturn = _procReturnMultiple1436;
|
|
_procReturn1442.multipleValueReturn = _procReturnMultiple1441;
|
|
_procReturn1447.multipleValueReturn = _procReturnMultiple1446;
|
|
_procReturn1452.multipleValueReturn = _procReturnMultiple1451;
|
|
_procReturn1457.multipleValueReturn = _procReturnMultiple1456;
|
|
_procReturn1462.multipleValueReturn = _procReturnMultiple1461;
|
|
_procReturn1467.multipleValueReturn = _procReturnMultiple1466;
|
|
_procReturn1472.multipleValueReturn = _procReturnMultiple1471;
|
|
_procReturn1477.multipleValueReturn = _procReturnMultiple1476;
|
|
_procReturn1482.multipleValueReturn = _procReturnMultiple1481;
|
|
_procReturn1487.multipleValueReturn = _procReturnMultiple1486;
|
|
_procReturn1492.multipleValueReturn = _procReturnMultiple1491;
|
|
_procReturn1497.multipleValueReturn = _procReturnMultiple1496;
|
|
_procReturn1502.multipleValueReturn = _procReturnMultiple1501;
|
|
_procReturn1507.multipleValueReturn = _procReturnMultiple1506;
|
|
_onReturn1518.multipleValueReturn = _onReturnMultiple1517;
|
|
_beforePromptPop1520.multipleValueReturn = _beforePromptPopMultiple1519;
|
|
_procReturn1527.multipleValueReturn = _procReturnMultiple1526;
|
|
_procReturn1532.multipleValueReturn = _procReturnMultiple1531;
|
|
_beforePromptPop1522.multipleValueReturn = _beforePromptPopMultiple1521;
|
|
_beforePromptPop1535.multipleValueReturn = _beforePromptPopMultiple1534;
|
|
_procReturn1542.multipleValueReturn = _procReturnMultiple1541;
|
|
_beforePromptPop1537.multipleValueReturn = _beforePromptPopMultiple1536;
|
|
_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, _start1543); })(MACHINE, function() { (function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start1557 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start1557;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1546, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/bf/language.rkt"]=new RUNTIME.ModuleRecord("language", _moduleEntry1548);
|
|
return (_afterModuleBody1547)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies1544 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies1544;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1546, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/bf/language.rkt"]=new RUNTIME.ModuleRecord("language", _moduleEntry1548);
|
|
return (_afterModuleBody1547)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry1548 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry1548;
|
|
}
|
|
MACHINE.modules["whalesong/bf/language.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/lang/base.rkt"] !== undefined) !== false) { return (_linked1549)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/lang/base.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1550)(MACHINE);
|
|
};
|
|
|
|
var _linked1549 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1549;
|
|
}
|
|
if (MACHINE.modules["whalesong/lang/base.rkt"].isInvoked !== false) { return (_alreadyLoaded1550)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1552, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/lang/base.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1551 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1551;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1552)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1552 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1552;
|
|
}
|
|
if ((MACHINE.modules["whalesong/bf/semantics.rkt"] !== undefined) !== false) { return (_linked1553)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/bf/semantics.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1554)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1550 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1550;
|
|
}
|
|
if ((MACHINE.modules["whalesong/bf/semantics.rkt"] !== undefined) !== false) { return (_linked1553)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/bf/semantics.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1554)(MACHINE);
|
|
};
|
|
|
|
var _linked1553 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1553;
|
|
}
|
|
if (MACHINE.modules["whalesong/bf/semantics.rkt"].isInvoked !== false) { return (_alreadyLoaded1554)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1556, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/bf/semantics.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1555 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1555;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1556)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1556 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1556;
|
|
}
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.modules["whalesong/bf/language.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/bf/language.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1554 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1554;
|
|
}
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.modules["whalesong/bf/language.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/bf/language.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterModuleBody1547 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody1547;
|
|
}
|
|
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 _beforePopPromptMultiple1545 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple1545;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt1546)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt1546 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt1546;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn1552.multipleValueReturn = _onReturnMultiple1551;
|
|
_onReturn1556.multipleValueReturn = _onReturnMultiple1555;
|
|
_beforePopPrompt1546.multipleValueReturn = _beforePopPromptMultiple1545;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start1557); })(MACHINE, function() { (function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start1567 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start1567;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1560, 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", _moduleEntry1562);
|
|
return (_afterModuleBody1561)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies1558 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies1558;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1560, 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", _moduleEntry1562);
|
|
return (_afterModuleBody1561)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry1562 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry1562;
|
|
}
|
|
MACHINE.modules["whalesong/lang/base.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["collects/racket/private/modbeg.rkt"] !== undefined) !== false) { return (_linked1563)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module collects/racket/private/modbeg.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1564)(MACHINE);
|
|
};
|
|
|
|
var _linked1563 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1563;
|
|
}
|
|
if (MACHINE.modules["collects/racket/private/modbeg.rkt"].isInvoked !== false) { return (_alreadyLoaded1564)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1566, MACHINE.proc));
|
|
return (MACHINE.modules["collects/racket/private/modbeg.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1565 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1565;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1566)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1566 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1566;
|
|
}
|
|
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 _alreadyLoaded1564 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1564;
|
|
}
|
|
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 _afterModuleBody1561 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody1561;
|
|
}
|
|
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 _beforePopPromptMultiple1559 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple1559;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt1560)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt1560 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt1560;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn1566.multipleValueReturn = _onReturnMultiple1565;
|
|
_beforePopPrompt1560.multipleValueReturn = _beforePopPromptMultiple1559;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start1567); })(MACHINE, function() { (function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start1590 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start1590;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1570, 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", _moduleEntry1587);
|
|
return (_afterModuleBody1586)(MACHINE);
|
|
};
|
|
|
|
var _lamEntry14 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _lamEntry14;
|
|
}
|
|
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 (_primitiveBranch1571)(MACHINE); }
|
|
if (! (MACHINE.proc instanceof RUNTIME.Closure)) {
|
|
RUNTIME.raiseOperatorIsNotClosure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
MACHINE.proc.arity,
|
|
MACHINE.argcount);
|
|
}
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_procReturn1575, MACHINE.proc));
|
|
return ((MACHINE.proc).label)(MACHINE);
|
|
};
|
|
|
|
var _procReturnMultiple1574 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturnMultiple1574;
|
|
}
|
|
RUNTIME.raiseContextExpectedValuesError(MACHINE, 1);
|
|
return (_procReturn1575)(MACHINE);
|
|
};
|
|
|
|
var _procReturn1575 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _procReturn1575;
|
|
}
|
|
MACHINE.env[MACHINE.env.length - 1 - 0] = MACHINE.val;
|
|
return (_afterCall1573)(MACHINE);
|
|
};
|
|
|
|
var _primitiveBranch1571 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _primitiveBranch1571;
|
|
}
|
|
if (! (typeof(MACHINE.proc) === 'function')) {
|
|
RUNTIME.raiseOperatorIsNotPrimitiveProcedure(MACHINE, MACHINE.proc);
|
|
}
|
|
if (! RUNTIME.isArityMatching(MACHINE.proc.arity, MACHINE.argcount)) {
|
|
RUNTIME.raiseArityMismatchError(MACHINE,
|
|
MACHINE.proc,
|
|
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 (_afterCall1573)(MACHINE);
|
|
};
|
|
|
|
var _afterCall1573 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterCall1573;
|
|
}
|
|
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 (_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.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 (_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.env.splice(MACHINE.env.length - (2 + 1), 1);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(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.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 (_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.env.splice(MACHINE.env.length - (2 + 1), 1);
|
|
MACHINE.control[MACHINE.control.length-1].proc = MACHINE.proc;
|
|
return ((MACHINE.proc).label)(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.length = MACHINE.env.length - 1;
|
|
MACHINE.proc = MACHINE.control[MACHINE.control.length-1].label;
|
|
MACHINE.control.pop();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies1568 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies1568;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1570, 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", _moduleEntry1587);
|
|
return (_afterModuleBody1586)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry1587 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry1587;
|
|
}
|
|
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(_beforePromptPop1589, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.val=new RUNTIME.Closure(_lamEntry14, (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 _beforePromptPopMultiple1588 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPopMultiple1588;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_beforePromptPop1589)(MACHINE);
|
|
};
|
|
|
|
var _beforePromptPop1589 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePromptPop1589;
|
|
}
|
|
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 _afterModuleBody1586 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody1586;
|
|
}
|
|
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 _beforePopPromptMultiple1569 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple1569;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt1570)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt1570 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt1570;
|
|
}
|
|
|
|
};
|
|
|
|
_procReturn1575.multipleValueReturn = _procReturnMultiple1574;
|
|
_procReturn1580.multipleValueReturn = _procReturnMultiple1579;
|
|
_beforePromptPop1589.multipleValueReturn = _beforePromptPopMultiple1588;
|
|
_beforePopPrompt1570.multipleValueReturn = _beforePopPromptMultiple1569;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start1590); })(MACHINE, function() { (function(MACHINE, success, fail, params) {
|
|
var param;
|
|
var RUNTIME = plt.runtime;
|
|
var _start1600 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _start1600;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1593, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/bf/semantics.rkt"]=new RUNTIME.ModuleRecord("semantics", _moduleEntry1595);
|
|
return (_afterModuleBody1594)(MACHINE);
|
|
};
|
|
|
|
var _afterLamBodies1591 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterLamBodies1591;
|
|
}
|
|
MACHINE.control.push(new RUNTIME.PromptFrame(_beforePopPrompt1593, RUNTIME.DEFAULT_CONTINUATION_PROMPT_TAG));
|
|
MACHINE.env.push([false]); MACHINE.env[MACHINE.env.length-1].names = [false];
|
|
MACHINE.modules["whalesong/bf/semantics.rkt"]=new RUNTIME.ModuleRecord("semantics", _moduleEntry1595);
|
|
return (_afterModuleBody1594)(MACHINE);
|
|
};
|
|
|
|
var _moduleEntry1595 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _moduleEntry1595;
|
|
}
|
|
MACHINE.modules["whalesong/bf/semantics.rkt"].isInvoked = true;
|
|
if ((MACHINE.modules["whalesong/lang/base.rkt"] !== undefined) !== false) { return (_linked1596)(MACHINE); }
|
|
MACHINE.params.currentOutputPort.writeDomNode(MACHINE, $('<span/>').text("DEBUG: the module whalesong/lang/base.rkt hasn't been linked in!!!"));
|
|
return (_alreadyLoaded1597)(MACHINE);
|
|
};
|
|
|
|
var _linked1596 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _linked1596;
|
|
}
|
|
if (MACHINE.modules["whalesong/lang/base.rkt"].isInvoked !== false) { return (_alreadyLoaded1597)(MACHINE); }
|
|
MACHINE.control.push(new RUNTIME.CallFrame(_onReturn1599, MACHINE.proc));
|
|
return (MACHINE.modules["whalesong/lang/base.rkt"].label)(MACHINE);
|
|
};
|
|
|
|
var _onReturnMultiple1598 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturnMultiple1598;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - (MACHINE.argcount - 1);
|
|
return (_onReturn1599)(MACHINE);
|
|
};
|
|
|
|
var _onReturn1599 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _onReturn1599;
|
|
}
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.modules["whalesong/bf/semantics.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/bf/semantics.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _alreadyLoaded1597 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _alreadyLoaded1597;
|
|
}
|
|
MACHINE.env.push([]); MACHINE.env[MACHINE.env.length-1].names = [];
|
|
MACHINE.modules["whalesong/bf/semantics.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/bf/semantics.rkt"].finalizeModuleInvokation();
|
|
return (MACHINE.proc)(MACHINE);
|
|
};
|
|
|
|
var _afterModuleBody1594 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _afterModuleBody1594;
|
|
}
|
|
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 _beforePopPromptMultiple1592 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPromptMultiple1592;
|
|
}
|
|
MACHINE.env.length = MACHINE.env.length - MACHINE.argcount;
|
|
return (_beforePopPrompt1593)(MACHINE);
|
|
};
|
|
|
|
var _beforePopPrompt1593 = function(MACHINE){
|
|
if(--MACHINE.callsBeforeTrampoline < 0) {
|
|
throw _beforePopPrompt1593;
|
|
}
|
|
|
|
};
|
|
|
|
_onReturn1599.multipleValueReturn = _onReturnMultiple1598;
|
|
_beforePopPrompt1593.multipleValueReturn = _beforePopPromptMultiple1592;
|
|
MACHINE.params.currentErrorHandler = fail;
|
|
MACHINE.params.currentSuccessHandler = success;
|
|
for (param in params) {
|
|
if (params.hasOwnProperty(param)) {
|
|
MACHINE.params[param] = params[param];
|
|
}
|
|
}RUNTIME.trampoline(MACHINE, _start1600); })(MACHINE, function() { plt.runtime.setReadyTrue();SUCCESS(); }, 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>
|