resin 0.0.1

data/amber/js/amber.js

@@ -0,0 +1,250 @@
+/* Amber package loading
+   usage example:
+   amber.load({
+   files: ['MyCategory1.js', 'MyCategory2.js'],
+   ready: function() {smalltalk.Browser._open()}
+   })
+*/
+
+amber = (function() {
+	var that = {};
+
+	var scripts = document.getElementsByTagName("script");
+	var src     = scripts[ scripts.length - 1 ].src;
+	var home    = src.split("/").slice(0, -2).join("/") + "/";
+	var nocache = '?' + (new Date()).getTime();
+
+	var debug;
+	var deploy;
+
+	var spec;
+	var jsToLoad = [];
+	var loadJS;
+
+	that.toggleIDE = function() {
+		if ($('#jtalk').length == 0) {
+			smalltalk.Browser._open();
+		} else if ($('#jtalk').is(':visible')) {
+			smalltalk.TabManager._current()._close();
+		} else {
+			smalltalk.TabManager._current()._open();
+		}
+		return false;
+	}
+
+	that.load = function(obj) {
+		spec = obj || {};
+
+		// In deployment mode, only the compressed version of Kernel
+		// and Canvas are loaded
+		deploy = spec.deploy || false;
+		debug = spec.debug || false;
+
+		// When debug is turned on, logs are written to the console,
+		// and the user will be prompted before they leave the page.
+		if (debug) {
+			window.onbeforeunload = function(){ return 'You will loose all code that you have not committed'; }
+		}
+
+		// Allow loading default Amber files from a different location
+		// e.g. http://amber-lang.net/amber/
+		if (spec.home) home = spec.home;
+
+		// Specify a version string to avoid wrong browser caching
+		if (spec.version) {
+			nocache = '?' + spec.version;
+		}
+
+		loadDependencies();
+		addJSToLoad('compat.js');
+		addJSToLoad('boot.js');
+
+		if (deploy) {
+			loadPackages([
+				'Kernel-Objects.deploy',
+				'Kernel-Classes.deploy',
+				'Kernel-Methods.deploy',
+				'Kernel-Collections.deploy',
+				'Kernel-Exceptions.deploy',
+				'Kernel-Transcript.deploy',
+				'Kernel-Announcements.deploy',
+				'Canvas.deploy'
+			]);
+		} else {
+			loadIDEDependencies();
+			loadCSS('amber.css');
+
+			loadPackages([
+				'Kernel-Objects',
+				'Kernel-Classes',
+				'Kernel-Methods',
+				'Kernel-Collections',
+				'Kernel-Exceptions',
+				'Kernel-Transcript',
+				'Kernel-Announcements',
+				'Canvas',
+				'Compiler',
+				'parser',
+				'IDE',
+				'SUnit',
+				'Examples',
+				'Benchfib',
+				'Kernel-Tests'
+			]);
+		}
+
+		var additionalFiles = spec.packages || spec.files;
+		if (additionalFiles) {
+			loadPackages(additionalFiles, spec.prefix);
+		}
+
+		// Be sure to setup & initialize smalltalk classes
+		addJSToLoad('init.js');
+		initializeSmalltalk();
+	};
+
+	function loadPackages(names, prefix){
+		var name, url;
+		var prefix = prefix || 'js';
+
+		for (var i=0; i < names.length; i++) {
+			name = names[i].split(/\.js$/)[0];
+			addJSToLoad(name + '.js', prefix);
+		}
+	};
+
+	function addJSToLoad(name, prefix) {
+		jsToLoad.push(buildJSURL(name, prefix));
+	};
+
+	function buildJSURL(name, prefix) {
+		var prefix = prefix || 'js';
+		var name = name;
+
+		if (!deploy) {
+			name = name + nocache;
+		}
+
+		return home + prefix + '/' + name;
+	};
+
+	function loadCSS(name, prefix) {
+		var prefix = prefix || 'css';
+		var name = name;
+		if (!deploy) {
+			name = name + nocache;
+		}
+
+		var url = home + prefix + '/' + name;
+
+		var link = document.createElement("link");
+		link.setAttribute("rel", "stylesheet");
+		link.setAttribute("type", "text/css");
+		link.setAttribute("href", url);
+		document.getElementsByTagName("head")[0].appendChild(link);
+	};
+
+	function loadDependencies() {
+		if (typeof jQuery == 'undefined') {
+			writeScriptTag(buildJSURL('lib/jQuery/jquery-1.6.4.min.js'));
+		}
+
+		if ((typeof jQuery == 'undefined') || (typeof jQuery.ui == 'undefined')) {      
+			writeScriptTag(buildJSURL('lib/jQuery/jquery-ui-1.8.16.custom.min.js'));
+		}
+	};
+
+	function loadIDEDependencies() {
+		addJSToLoad('lib/jQuery/jquery.textarea.js');
+		addJSToLoad('lib/CodeMirror/codemirror.js');
+		addJSToLoad('lib/CodeMirror/smalltalk.js');
+		loadCSS('lib/CodeMirror/codemirror.css', 'js');
+		loadCSS('lib/CodeMirror/amber.css', 'js');
+	};
+
+	// This will be called after JS files have been loaded
+	function initializeSmalltalk() {
+		window.smalltalkReady = function() {
+			if (deploy) {
+				smalltalk.setDeploymentMode();
+			}
+
+			if (spec.ready) {
+				spec.ready();
+			}
+		}
+
+		loadAllJS(); 
+	};
+
+	/* 
+	 * When loaded using AJAX, scripts order not guaranteed.
+	 * Load JS in the order they have been added using addJSToLoad().
+	 * If loaded, will use jQuery's getScript instead of adding a script element
+	 */
+	function loadAllJS() {
+		loadJS = loadJSViaScriptTag;
+		if (typeof jQuery != 'undefined') {
+			loadJS = loadJSViaJQuery;
+		}
+		loadNextJS();
+	};
+
+	function loadNextJS() {
+		loadJS(jsToLoad[0], function(){
+			jsToLoad.shift();
+			if (jsToLoad.length > 0) {
+				loadNextJS();
+			}
+		});
+	};
+
+	function loadJSViaScriptTag(url, callback) {
+		writeScriptTag(url);
+		callback();
+	};
+
+	function loadJSViaJQuery(url, callback) {
+		$.getScript(jsToLoad[0], callback);
+	};
+
+	function writeScriptTag(src) {
+		var scriptString = '<script src="' + src + '" type="text/javascript"></script>';
+		document.write(scriptString);
+	};
+
+	function populateLocalPackages(){
+		var localStorageRE = /^smalltalk\.packages\.(.*)$/;
+		localPackages = {};
+
+		var match, key;
+
+		for(var i=0; i < localStorage.length; i++) {
+			key = localStorage.key(i);
+
+			if (match = key.match(localStorageRE)) {
+				localPackages[match[1]] = localStorage[key];
+			}
+		}
+
+		return localPackages;
+	};
+
+	function clearLocalPackages() {
+		for (var name in localPackages) {
+			log('Removing ' + name + ' from local storage');
+			localStorage.removeItem('smalltalk.packages.' + name);
+		}
+	};
+
+	function log(string) {
+		if (debug) {
+			console.log(string);
+		}
+	}
+
+	return that;
+})();
+
+window.loadAmber = amber.load;
+window.toggleAmberIDE = amber.toggleIDE;

data/amber/js/boot.js

@@ -0,0 +1,587 @@
+/* ====================================================================
+   |
+   |   Amber Smalltalk
+   |   http://amber-lang.net
+   |
+   ======================================================================
+
+   ======================================================================
+   |
+   | Copyright (c) 2010-2011
+   | Nicolas Petton <petton.nicolas@gmail.com>
+   |
+   | Amber is released under the MIT license
+   |
+   | Permission is hereby granted, free of charge, to any person obtaining
+   | a copy of this software and associated documentation files (the 
+   | 'Software'), to deal in the Software without restriction, including 
+   | without limitation the rights to use, copy, modify, merge, publish, 
+   | distribute, sublicense, and/or sell copies of the Software, and to 
+   | permit persons to whom the Software is furnished to do so, subject to 
+   | the following conditions:
+   |
+   | The above copyright notice and this permission notice shall be 
+   | included in all copies or substantial portions of the Software.
+   |
+   | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, 
+   | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+   | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+   | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
+   | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
+   | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+   | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  
+   |
+   ==================================================================== */
+
+/* Make that console is defined */
+
+if (typeof console === "undefined") {
+	this.console = {
+		log: function() {},
+		warn: function() {},
+		info: function() {},
+		debug: function() {},
+		error: function() {}
+	};
+}
+
+
+/* Smalltalk constructors definition */
+
+function SmalltalkObject(){};
+function SmalltalkBehavior(){};
+function SmalltalkClass(){};
+function SmalltalkPackage(){};
+function SmalltalkMetaclass(){
+	this.meta = true;
+};
+function SmalltalkMethod(){};
+function SmalltalkNil(){};
+
+function SmalltalkSymbol(string){
+	this.value = string;
+};
+
+function Smalltalk(){
+
+	var st = this;
+
+	/* This is the current call context object. While it is publicly available,
+	   Use smalltalk.getThisContext() instead which will answer a safe copy of 
+	   the current context */
+
+	st.thisContext = undefined;
+
+	/* List of all reserved words in JavaScript. They may not be used as variables
+	   in Smalltalk. */
+
+	st.reservedWords = ['break', 'case', 'catch', 'char', 'class', 'continue', 'debugger', 
+		'default', 'delete', 'do', 'else', 'finally', 'for', 'function', 
+		'if', 'in', 'instanceof', 'new', 'private', 'protected', 
+		'public', 'return', 'static', 'switch', 'this', 'throw',
+		'try', 'typeof', 'var', 'void', 'while', 'with', 'yield'];
+
+	/* The symbol table ensures symbol unicity */
+
+	symbolTable = {};
+	st.symbolFor = function(string) {
+		if(symbolTable[string] === undefined) {
+			symbolTable[string] = new SmalltalkSymbol(string);
+		};
+
+		return symbolTable[string];
+	};
+
+	/* Unique ID number generator */
+
+	oid = 0;
+	st.nextId = function() {
+		oid += 1;
+		return oid;
+	};
+
+	/* We hold all Packages in a separate Object */
+
+	st.packages = {};
+
+	/* Smalltalk package creation. To add a Package, use smalltalk.addPackage() */
+
+	function pkg(spec) {
+		var that      = new SmalltalkPackage();
+		that.pkgName  = spec.pkgName;
+		that.properties = spec.properties || {};
+		return that;
+	};
+
+	/* Smalltalk class creation. A class is an instance of an automatically 
+	   created metaclass object. Newly created classes (not their metaclass) 
+	   should be added to the smalltalk object, see smalltalk.addClass().
+	   Superclass linking is *not* handled here, see smalltalk.init()  */
+
+	function klass(spec) {
+		var spec = spec || {};
+		var that;
+		if(spec.meta) {
+			that = new SmalltalkMetaclass();
+		} else {
+			that = new (klass({meta: true})).fn;
+			that.klass.instanceClass = that;
+			that.className = spec.className;
+			that.klass.className = that.className + ' class';
+		}
+
+		that.fn = spec.fn || function(){};
+		that.superclass = spec.superclass;
+		that.iVarNames = spec.iVarNames || [];
+		if(that.superclass) {
+			that.klass.superclass = that.superclass.klass;
+		}
+		that.pkg = spec.pkg;
+		that.fn.prototype.methods = {};
+		that.fn.prototype.inheritedMethods = {};
+		that.fn.prototype.klass = that;
+
+		return that;
+	};
+
+	/* Smalltalk method object. To add a method to a class,
+	   use smalltalk.addMethod() */
+
+	st.method = function(spec) {
+		var that = new SmalltalkMethod();
+		that.selector          = spec.selector;
+		that.jsSelector        = spec.jsSelector;
+		that.args              = spec.args || {};
+		that.category          = spec.category;
+		that.source            = spec.source;
+		that.messageSends      = spec.messageSends || [];
+		that.referencedClasses = spec.referencedClasses || [];
+		that.fn                = spec.fn;
+		return that
+	};
+
+	/* Initialize a class in its class hierarchy. Handle both class and
+	   metaclasses. */
+
+	st.init = function(klass) {
+		var subclasses = st.subclasses(klass);
+		var methods;
+
+		if(klass.superclass && klass.superclass !== nil) {
+			methods = st.methods(klass.superclass);
+
+			//Methods linking
+			for(var i in methods) {
+				if(!klass.fn.prototype.methods[i]) {
+					klass.fn.prototype.inheritedMethods[i] = methods[i];
+					klass.fn.prototype[methods[i].jsSelector] = methods[i].fn;
+				}
+			}
+		}
+
+		for(var i=0;i<subclasses.length;i++) {
+			st.init(subclasses[i]);
+		}
+		if(klass.klass && !klass.meta) {
+			st.init(klass.klass);
+		}
+	};
+
+	/* Answer all registered Packages as Array */
+
+	st.packages.all = function() {
+		var packages = [];
+		for(var i in st.packages) {
+			if (!st.packages.hasOwnProperty(i) || typeof(st.packages[i]) === "function") continue;
+			packages.push(st.packages[i]);
+		}
+		return packages
+	};
+
+	/* Answer all registered Smalltalk classes */
+
+	st.classes = function() {
+		var classes = [];
+		for(var i in st) {
+			if(i.search(/^[A-Z]/g) != -1) {
+				classes.push(st[i]);
+			}
+		}
+		return classes
+	};
+
+	/* Answer all methods (included inherited ones) of klass. */
+
+	st.methods = function(klass) {
+		var methods = {};
+		for(var i in klass.fn.prototype.methods) {
+			methods[i] = klass.fn.prototype.methods[i]
+		}
+		for(var i in klass.fn.prototype.inheritedMethods) {
+			methods[i] = klass.fn.prototype.inheritedMethods[i]
+		}
+		return methods;
+	}
+
+	/* Answer the direct subclasses of klass. */
+
+	st.subclasses = function(klass) {
+		var subclasses = [];
+		var classes = st.classes();
+		for(var i in classes) {
+			if(classes[i].fn) {
+				//Metaclasses
+				if(classes[i].klass && classes[i].klass.superclass === klass) {
+					subclasses.push(classes[i].klass);
+				}
+				//Classes
+				if(classes[i].superclass === klass) {
+					subclasses.push(classes[i]);
+				}
+			}
+		}
+		return subclasses;
+	};
+
+	/* Create a new class wrapping a JavaScript constructor, and add it to the 
+	   global smalltalk object. Package is lazily created if it does not exist with given name. */
+
+	st.mapClassName = function(className, pkgName, fn, superclass) {
+		var pkg = st.addPackage(pkgName);
+		st[className] = klass({
+			className:  className, 
+			superclass: superclass,
+			pkg:        pkg, 
+			fn:         fn
+		});
+	};
+
+	/* Add a package to the smalltalk.packages object, creating a new one if needed.
+	   If pkgName is null or empty we return nil, which is an allowed package for a class.
+	   If package already exists we still update the properties of it. */
+
+	st.addPackage = function(pkgName, properties) {
+		if(!pkgName) {return nil;}
+		if(!(st.packages[pkgName])) {
+			st.packages[pkgName] = pkg({
+				pkgName: pkgName,
+				properties: properties
+			});
+		} else {
+			if(properties) {
+				st.packages[pkgName].properties = properties;
+			}	
+		}
+		return st.packages[pkgName];
+	};
+
+	/* Add a class to the smalltalk object, creating a new one if needed.
+	   Package is lazily created if it does not exist with given name.*/
+
+	st.addClass = function(className, superclass, iVarNames, pkgName) {
+		var pkg = st.addPackage(pkgName);
+		if(st[className]) {
+			st[className].superclass = superclass;
+			st[className].iVarNames = iVarNames;
+			st[className].pkg = pkg || st[className].pkg;
+		} else {    
+			st[className] = klass({
+				className: className, 
+				superclass: superclass,
+				pkg: pkg,
+				iVarNames: iVarNames
+			});
+		}
+	};
+
+	/* Add a method to a class */
+
+	st.addMethod = function(jsSelector, method, klass) {
+		klass.fn.prototype[jsSelector] = method.fn;
+		klass.fn.prototype.methods[method.selector] = method;
+		method.methodClass = klass;
+		method.jsSelector = jsSelector;
+	};
+
+	/* Handles Smalltalk message send. Automatically converts undefined to the nil object.
+	   If the receiver does not understand the selector, call its #doesNotUnderstand: method */
+
+	sendWithoutContext = function(receiver, selector, args, klass) {
+		if(receiver === undefined || receiver === null) {
+			receiver = nil;
+		}
+		if(!klass && receiver.klass && receiver[selector]) {
+			return receiver[selector].apply(receiver, args);
+		} else if(klass && klass.fn.prototype[selector]) {
+			return klass.fn.prototype[selector].apply(receiver, args)
+		}
+		return messageNotUnderstood(receiver, selector, args);
+	};
+
+
+	/* Handles unhandled errors during message sends */
+
+	sendWithContext = function(receiver, selector, args, klass) {
+		if(st.thisContext) {
+			return withContextSend(receiver, selector, args, klass);
+		} else {
+			try {return withContextSend(receiver, selector, args, klass)}
+			catch(error) {
+				// Reset the context stack in any case
+				st.thisContext = undefined;
+				if(error.smalltalkError) {
+					handleError(error);
+				} else {
+					throw(error);
+				}
+			}
+		}
+	};
+
+	/* Same as sendWithoutContext but creates a methodContext. */
+
+	withContextSend = function(receiver, selector, args, klass) {
+		var call, context;
+		if(receiver === undefined || receiver === null) {
+			receiver = nil;
+		}
+		if(!klass && receiver.klass && receiver[selector]) {
+			context = pushContext(receiver, selector, args);
+			call = receiver[selector].apply(receiver, args);
+			popContext(context);
+			return call;
+		} else if(klass && klass.fn.prototype[selector]) {
+			context = pushContext(receiver, selector, args);
+			call = klass.fn.prototype[selector].apply(receiver, args);
+			popContext(context);
+			return call;
+		}
+		return messageNotUnderstood(receiver, selector, args);
+	};
+
+	/* Handles Smalltalk errors. Triggers the registered ErrorHandler 
+	   (See the Smalltalk class ErrorHandler and its subclasses */
+
+	function handleError(error) {
+		st.thisContext = undefined;
+		smalltalk.ErrorHandler._current()._handleError_(error);
+	}
+
+	/* Handles #dnu: *and* JavaScript method calls.
+	   if the receiver has no klass, we consider it a JS object (outside of the
+	   Amber system). Else assume that the receiver understands #doesNotUnderstand: */
+
+	function messageNotUnderstood(receiver, selector, args) {
+		/* Handles JS method calls. */
+		if(receiver.klass === undefined || receiver.allowJavaScriptCalls) {
+			return callJavaScriptMethod(receiver, selector, args);
+		}
+
+		/* Handles not understood messages. Also see the Amber counter-part 
+		   Object>>doesNotUnderstand: */
+
+		return receiver._doesNotUnderstand_(
+				st.Message._new()
+				._selector_(st.convertSelector(selector))
+				._arguments_(args)
+				);
+	};
+
+	/* Call a method of a JS object, or answer a property if it exists.
+	   Else try wrapping a JSObjectProxy around the receiver.
+
+	   Converts keyword-based selectors by using the first
+	   keyword only, but keeping all message arguments.
+
+	   Example:
+	   "self do: aBlock with: anObject" -> "self.do(aBlock, anObject)" */
+
+	function callJavaScriptMethod(receiver, selector, args) {
+		var jsSelector = selector._asJavaScriptSelector();
+		var jsProperty = receiver[jsSelector];
+		if(typeof jsProperty === "function") {
+			return jsProperty.apply(receiver, args);
+		} else if(jsProperty !== undefined) {
+			if(args[0]) {
+				receiver[jsSelector] = args[0];
+				return nil;
+			} else {
+				return jsProperty
+			}
+		}
+
+		return st.send(st.JSObjectProxy._on_(receiver), selector, args);
+	};
+
+
+	/* Reuse old contexts stored in oldContexts */
+
+	st.oldContexts = [];
+
+
+	/* Handle thisContext pseudo variable */
+
+	st.getThisContext = function() {
+		if(st.thisContext) {
+			return st.thisContext.copy();
+		} else {
+			return undefined;
+		}
+	}
+
+	pushContext = function(receiver, selector, temps) {
+		if(st.thisContext) {
+			return st.thisContext = st.thisContext.newContext(receiver, selector, temps);
+		} else {
+			return st.thisContext = new SmalltalkMethodContext(receiver, selector, temps);
+		}
+	};
+
+	popContext = function(context) {
+		if(context) {
+			context.removeYourself();
+		}
+	};
+
+	/* Convert a string to a valid smalltalk selector.
+	   if you modify the following functions, also change String>>asSelector
+	   accordingly */
+
+	st.convertSelector = function(selector) {
+		if(selector.match(/__/)) {
+			return convertBinarySelector(selector);
+		} else {
+			return convertKeywordSelector(selector);
+		}
+	};
+
+	function convertKeywordSelector(selector) {
+		return selector.replace(/^_/, '').replace(/_/g, ':');
+	};
+
+	function convertBinarySelector(selector) {
+		return selector
+			.replace(/^_/, '')
+			.replace(/_plus/, '+')
+			.replace(/_minus/, '-')
+			.replace(/_star/, '*')
+			.replace(/_slash/, '/')
+			.replace(/_gt/, '>')
+			.replace(/_lt/, '<')
+			.replace(/_eq/, '=')
+			.replace(/_comma/, ',')
+			.replace(/_at/, '@')
+	};
+
+	/* Converts a JavaScript object to valid Smalltalk Object */
+	st.readJSObject = function(js) {
+		var object = js;
+		var readObject = (js.constructor === Object);
+		var readArray = (js.constructor === Array);
+
+		if(readObject) {
+			object = smalltalk.Dictionary._new();
+		}
+		for(var i in js) {
+			if(readObject) {
+				object._at_put_(i, st.readJSObject(js[i]));
+			} 
+			if(readArray) {
+				object[i] = st.readJSObject(js[i]);
+			}
+		}
+		return object;
+	};
+
+	/* Toggle deployment mode (no context will be handled during message send */
+	st.setDeploymentMode = function() {
+		st.send = sendWithoutContext;
+	};
+
+	st.setDevelopmentMode = function() {
+		st.send = sendWithContext;
+	}
+
+	/* Set development mode by default */
+	st.setDevelopmentMode();
+}
+
+function SmalltalkMethodContext(receiver, selector, temps, home) {
+	var that = this;
+	that.receiver = receiver;
+	that.selector = selector;
+	that.temps = temps || {};
+	that.homeContext = home;
+
+	that.copy = function() {
+		var home = that.homeContext;
+		if(home) {home = home.copy()}
+		return new SmalltalkMethodContext(
+				that.receiver, 
+				that.selector, 
+				that.temps, 
+				home
+				);
+	}
+
+	that.newContext = function(receiver, selector, temps) {
+		var c = smalltalk.oldContexts.pop();
+		if(c) {
+			c.homeContext = that;
+			c.receiver = receiver;
+			c.selector = selector;
+			c.temps = temps || {};
+		} else {
+			c = new SmalltalkMethodContext(receiver, selector, temps, that);
+		}
+		return c;
+	}
+
+	that.removeYourself = function() {
+		smalltalk.thisContext = that.homeContext;
+		that.homeContext = undefined;
+		smalltalk.oldContexts.push(that);
+	}
+}
+
+/* Global Smalltalk objects. */
+
+var nil = new SmalltalkNil();
+var smalltalk = new Smalltalk();
+
+if(this.jQuery) {
+	this.jQuery.allowJavaScriptCalls = true;
+}
+
+/****************************************************************************************/
+
+
+/* Base classes mapping. If you edit this part, do not forget to set the superclass of the
+   object metaclass to Class after the definition of Object */
+
+smalltalk.mapClassName("Object", "Kernel", SmalltalkObject);
+smalltalk.mapClassName("Smalltalk", "Kernel", Smalltalk, smalltalk.Object);
+smalltalk.mapClassName("Package", "Kernel", SmalltalkPackage, smalltalk.Object);
+smalltalk.mapClassName("Behavior", "Kernel", SmalltalkBehavior, smalltalk.Object);
+smalltalk.mapClassName("Class", "Kernel", SmalltalkClass, smalltalk.Behavior);
+smalltalk.mapClassName("Metaclass", "Kernel", SmalltalkMetaclass, smalltalk.Behavior);
+smalltalk.mapClassName("CompiledMethod", "Kernel", SmalltalkMethod, smalltalk.Object);
+
+smalltalk.Object.klass.superclass = smalltalk.Class;
+
+smalltalk.mapClassName("Number", "Kernel", Number, smalltalk.Object);
+smalltalk.mapClassName("BlockClosure", "Kernel", Function, smalltalk.Object);
+smalltalk.mapClassName("Boolean", "Kernel", Boolean, smalltalk.Object);
+smalltalk.mapClassName("Date", "Kernel", Date, smalltalk.Object);
+smalltalk.mapClassName("UndefinedObject", "Kernel", SmalltalkNil, smalltalk.Object);
+
+smalltalk.mapClassName("Collection", "Kernel", null, smalltalk.Object);
+smalltalk.mapClassName("SequenceableCollection", "Kernel", null, smalltalk.Collection);
+smalltalk.mapClassName("CharacterArray", "Kernel", null, smalltalk.SequenceableCollection);
+smalltalk.mapClassName("String", "Kernel", String, smalltalk.CharacterArray);
+smalltalk.mapClassName("Symbol", "Kernel", SmalltalkSymbol, smalltalk.CharacterArray);
+smalltalk.mapClassName("Array", "Kernel", Array, smalltalk.SequenceableCollection);
+smalltalk.mapClassName("RegularExpression", "Kernel", RegExp, smalltalk.String);
+
+smalltalk.mapClassName("Error", "Kernel", Error, smalltalk.Object);
+smalltalk.mapClassName("MethodContext", "Kernel", SmalltalkMethodContext, smalltalk.Object);