555 lines
17 KiB
JavaScript
555 lines
17 KiB
JavaScript
/**
|
||
* Bootstrap procedure for Ulambda Scheme
|
||
*
|
||
* Copyright (C) 2017, 2018 Mike Gerwitz
|
||
*
|
||
* This file is part of Ulambda Scheme.
|
||
*
|
||
* Ulambda Scheme is free software: you can redistribute it and/or modify
|
||
* it under the terms of the GNU Affero General Public License as
|
||
* published by the Free Software Foundation, either version 3 of the
|
||
* License, or (at your option) any later version.
|
||
*
|
||
* This program is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
* GNU General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU Affero General Public License
|
||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
*
|
||
* Ideally, the user should be able to bootstrap Ulambda Scheme with nothing
|
||
* more than what they already have installed on their computer, in the
|
||
* environment that Ulambda was designed to run in---the web browser.
|
||
* Node.js was used during official development, but that is a large system
|
||
* that should not be a necessary dependency---it should be needed only for
|
||
* convenience.
|
||
*
|
||
* To run this process on a local development environment using Node.js, see
|
||
* `../bootstrap.js'. To run in your web browser, see `../bootstrap.html'.
|
||
*/
|
||
|
||
'use strict';
|
||
|
||
|
||
/**
|
||
* Bootstrap procedure for Ulambda Scheme
|
||
*
|
||
* This abstracts the bootstrap process in such a way that it can be run in
|
||
* any JavaScript environment. Notably, we need to support not only Node.js
|
||
* (which is convenient for development and automation), but also a web
|
||
* browser, which allows users to bootstrap using only their runtime
|
||
* environment and no additional tools.
|
||
*
|
||
* Prebirth and every compiler thereafter are designed to be able to be run
|
||
* from the command line, accepting source code on standard input. Such a
|
||
* concept does not exist in a browser environment, and therefore cannot
|
||
* exist here; there is an awkward abstraction to work around that.
|
||
*/
|
||
class Bootstrap
|
||
{
|
||
/**
|
||
* Initialize bootstrap process
|
||
*
|
||
* The file loader `getf' must accept a path to a file to load and
|
||
* return a Promise representing the contents of that file. The logger
|
||
* function `logf' must accept a string message and, as an optional
|
||
* argument an Error. `prebirth' should be `Prebirth' from
|
||
* `prebirth.js'.
|
||
*
|
||
* @param {function(string):Promise} getf file loader
|
||
* @param {function(string,Error=}} logf logger
|
||
* @param {Prebirth} prebirth Prebirth
|
||
*/
|
||
constructor( getf, logf, prebirth )
|
||
{
|
||
this._getf = getf;
|
||
this._logf = logf;
|
||
this._prebirth = prebirth;
|
||
}
|
||
|
||
|
||
/**
|
||
* Perform bootstrapping process
|
||
*
|
||
* This compiles each of the phases of Ulambda Scheme beginning with
|
||
* Prebirth. This will evolve in complexity as we continue to move
|
||
* forward.
|
||
*
|
||
* There is currently no final result from this method other than
|
||
* log output and an indication of success or failure; that'll change as
|
||
* we get further along and will produce the final compiler.
|
||
*
|
||
* @return {undefined} nothing yet.
|
||
*/
|
||
bootstrap()
|
||
{
|
||
this._strout( 'header' );
|
||
|
||
return this._birth()
|
||
.then( birth => this._rebirth( birth ) )
|
||
.catch( e => this._error( e ) )
|
||
.then( status =>
|
||
this._log( "=> " + this._doneMessage( status ) )
|
||
);
|
||
}
|
||
|
||
|
||
/**
|
||
* Produce self-hosted Birth
|
||
*
|
||
* Prebirth will be used to compile Birth, which is written in
|
||
* Prebirth Lisp. Birth will then be used to compile itself, becoming
|
||
* self-hosting.
|
||
*
|
||
* This process is self-verifying: Birth compiled with both Prebirth and
|
||
* Birth itself should produce output that is identical (with regards to
|
||
* JavaScript's string representation). In practice, since Birth uses
|
||
* only ASCII, this amounts to verifying that the outputs are
|
||
* bytewise-identical.
|
||
*
|
||
* The result of this method will be a unary function that, given a
|
||
* Birth Lisp source string, will compile that string into JavaScript.
|
||
*
|
||
* @return {Promise<function(string):string>} Birth compiler
|
||
*/
|
||
_birth()
|
||
{
|
||
return this._loadPaths( [
|
||
[ "birth.scm", "Birth" ],
|
||
[ "libprebirth.js", "libprebirth" ],
|
||
] )
|
||
.then( ( [ scm, lib ] ) =>
|
||
{
|
||
this._strout( 'prebirthDesc' );
|
||
|
||
const preout = this._prebirth.compile( scm, lib );
|
||
|
||
return [ preout, scm, lib ];
|
||
} )
|
||
.then( ( [ birthjs, scm, lib ] ) =>
|
||
{
|
||
this._strout( 'prebirthComplete', birthjs.length );
|
||
this._strout( 'birthCompiled' );
|
||
this._strout( 'birthSelfCompiling' );
|
||
|
||
const birthf = this._makeCompiler( birthjs, {
|
||
"libprebirth.js": lib
|
||
} );
|
||
|
||
const birthout = birthf( scm );
|
||
|
||
this._verifyBirthOutput( birthout, birthjs );
|
||
|
||
return birthf;
|
||
} );
|
||
}
|
||
|
||
|
||
/**
|
||
* Verify that self-compiled Birth output BIRTHOUT matches that of
|
||
* Prebirth-compiled Birth BIRTHJS
|
||
*
|
||
* @param {string} birthout self-compiled Birth
|
||
* @param {string} birthjs Prebirth-compiled Birth
|
||
*
|
||
* @throws {Error} on non-match
|
||
*
|
||
* @return {undefined}
|
||
*/
|
||
_verifyBirthOutput( birthout, birthjs )
|
||
{
|
||
if ( birthout === '' ) {
|
||
throw Error( "Self-compilation yielded no output" );
|
||
}
|
||
|
||
this._strout( 'birthVerify' );
|
||
|
||
if ( birthout !== birthjs ) {
|
||
this._strout( 'birthVerifyFail' );
|
||
|
||
throw Error(
|
||
"Birth self-compilation output does not match Prebirth!"
|
||
);
|
||
}
|
||
|
||
this._strout( 'birthVerifyOk' );
|
||
}
|
||
|
||
|
||
/**
|
||
* Create unary function wrapping the compiler JS with a stub
|
||
* filesystem FS
|
||
*
|
||
* The unary function accepts a source file which is then passed to the
|
||
* compiler via the stub filesystem on "/dev/stdin". The output of the
|
||
* compiler is returned as a string.
|
||
*
|
||
* The stub filesystem should contain the contents of all files
|
||
* dynamically loaded by the compiler JS. This abstraction allows the
|
||
* bootstrapping process to work in any environment without regards to
|
||
* whether a filesystem even exists, and regardless of whether loading
|
||
* is a synchronous or asynchronous operation.
|
||
*
|
||
* @param {string} js JavaScript code of compiler (to be eval'd)
|
||
* @param {Object} fs mapping of filename to content for stub filesystem
|
||
*
|
||
* @return {string} compiler output
|
||
*/
|
||
_makeCompiler( js, fs = {} )
|
||
{
|
||
const birth = new Function(
|
||
'let __fsinit = this.__fsinit;' +
|
||
'let require = this.require;' +
|
||
'let birthout = "";\n' +
|
||
'const console = { log: str => birthout = str + "\\n" };\n' +
|
||
js +
|
||
"return birthout;"
|
||
);
|
||
|
||
return scm =>
|
||
{
|
||
fs[ "/dev/stdin" ] = scm;
|
||
return birth.call( { __fsinit: fs } );
|
||
};
|
||
}
|
||
|
||
|
||
/**
|
||
* Compile Rebirth using Birth and yield unary compiler function
|
||
*
|
||
* This begins the recursive compilation of Rebirth, beginning with
|
||
* the first generation Re¹birth, using the self-hosted Birth. The
|
||
* first generation of Rebirth is written purely in Birth Lisp. The
|
||
* resulting compiler has more features than Birth, which is then used
|
||
* to compile itself again, producing a compiler with even more
|
||
* features. This process repeats until the output does not change.
|
||
*
|
||
* @param {function(string):string} birth Birth
|
||
*
|
||
* @return {Promise<function(string):string>} final Rebirth generation
|
||
*/
|
||
_rebirth( birth )
|
||
{
|
||
return this._loadPaths( [
|
||
[ "rebirth.scm", "Rebirth" ],
|
||
[ "rebirth/es.scm" ],
|
||
[ "rebirth/relibprebirth.scm" ],
|
||
[ "rebirth/macro.scm" ],
|
||
] ).then( ( [ scm, es, relibprebirth, macro ] ) =>
|
||
this._compileRebirth( birth, scm, {
|
||
"rebirth/es.scm": es,
|
||
"rebirth/relibprebirth.scm": relibprebirth,
|
||
"rebirth/macro.scm": macro,
|
||
} )
|
||
);
|
||
}
|
||
|
||
|
||
/**
|
||
* Recursively compile Rebirth until two consecutive generations match
|
||
* and yield the unary compiler function for the final generation
|
||
*
|
||
* The first time this method is called, it should be called with Birth
|
||
* as the unary compiler function COMPILE. It should each time be
|
||
* provided with the Rebirth source code SCM and the necessary stub
|
||
* filesystem FS (these are identical for each recursive invocation of
|
||
* this method).
|
||
*
|
||
* Recursion terminates when the compiler COMPILE output matches that of
|
||
* the previous generation PREV, at which point the unary compiler
|
||
* function COMPILE will be yielded as the final generation (with the
|
||
* final generation number being N-1 to account for the duplicate).
|
||
*
|
||
* @param {function(string):string} compile compiler (Birth or Rebirth)
|
||
* @param {string} scm Rebirth source
|
||
* @param {Object} fs stub filesystem for Rebirth
|
||
* @param {number=} n target Rebirth generation id
|
||
* @param {string=} prev previous Rebirth generation
|
||
*
|
||
* @throws {Error} if compiler COMPILE produces no output
|
||
*
|
||
* @return {Promise<function(string):string>} final Rebirth generation
|
||
*/
|
||
_compileRebirth( compile, scm, fs, n = 1, prev = "" )
|
||
{
|
||
this._strout( 'rebirthCompiling', n );
|
||
|
||
const birthout = compile( scm );
|
||
|
||
if ( birthout === '' ) {
|
||
return Promise.reject(
|
||
Error( "Rebirth compilation yielded no output" )
|
||
);
|
||
}
|
||
|
||
this._strout( 'rebirthCompiled', n, birthout.length );
|
||
|
||
const rebirthf = this._makeCompiler( birthout, fs );
|
||
|
||
if ( birthout === prev ) {
|
||
this._strout( 'rebirthDone', ( n - 1 ) );
|
||
return Promise.resolve( compile );
|
||
}
|
||
|
||
// recurse, but just in case we're running in a browser, give a
|
||
// change to repaint the log (otherwise we'd just hang until every
|
||
// Rebirth is compiled)
|
||
return new Promise( accept =>
|
||
setTimeout( () => accept( this._compileRebirth(
|
||
rebirthf, scm, fs, ( n + 1 ), birthout
|
||
) ) )
|
||
);
|
||
}
|
||
|
||
|
||
/**
|
||
* Produce a promise for the file contents of each of `path'
|
||
*
|
||
* See also `#_loadPath'.
|
||
*
|
||
* @param {Array<string>} paths file paths
|
||
*
|
||
* @return {Promise} resolved with file contents or failure
|
||
*/
|
||
_loadPaths( paths )
|
||
{
|
||
return Promise.all(
|
||
paths.map( ( [ path, desc ] ) =>
|
||
this._loadPath( path, desc )
|
||
)
|
||
);
|
||
}
|
||
|
||
|
||
/**
|
||
* Produce a promise for the file contents of `path'
|
||
*
|
||
* This action is logged with the description `desc' and the length of
|
||
* the result.
|
||
*
|
||
* This uses the loader function provided via the constructor, which
|
||
* must return a Promise.
|
||
*
|
||
* @param {string} path file path
|
||
* @param {string=} desc file description for logging
|
||
*
|
||
* @return {Promise} promise of string file contents
|
||
*/
|
||
_loadPath( path, desc = "" )
|
||
{
|
||
this._strout( 'loadingf', desc, path );
|
||
|
||
return this._getf( path )
|
||
.then( data =>
|
||
{
|
||
this._strout( 'loadedf', path, data.length );
|
||
|
||
return data;
|
||
} );
|
||
}
|
||
|
||
|
||
/**
|
||
* Promise to log a string identified by `id'
|
||
*
|
||
* All given arguments in `args' will be passed to the function handling
|
||
* that identifier.
|
||
*
|
||
* @param {string} id string identifier (see `_strmap')
|
||
* @param {Array} args string arguments
|
||
*
|
||
* @return {Promise}
|
||
*/
|
||
_strout( id, ...args )
|
||
{
|
||
return Promise.resolve(
|
||
this._log( this._str.apply( this, arguments ) )
|
||
);
|
||
}
|
||
|
||
|
||
/**
|
||
* Generate a string identified by `id'
|
||
*
|
||
* All given arguments in `args' will be passed to the function handling
|
||
* that identifier.
|
||
*
|
||
* @param {string} id string identifier (see `_strmap')
|
||
* @param {Array} args string arguments
|
||
*
|
||
* @return {string} generated string
|
||
*/
|
||
_str( id, ...args )
|
||
{
|
||
const strf = Bootstrap._strmap[ id ];
|
||
|
||
if ( strf === undefined ) {
|
||
throw Error( `Unknown strmap '${id}'` );
|
||
}
|
||
|
||
return strf.apply( null, args );
|
||
}
|
||
|
||
|
||
/**
|
||
* Log string using logger function
|
||
*
|
||
* @param {string} str string to log
|
||
*
|
||
* @return {undefined}
|
||
*/
|
||
_log( str )
|
||
{
|
||
this._logf( str );
|
||
}
|
||
|
||
|
||
/**
|
||
* Log error using logger function
|
||
*
|
||
* `e.message' will be used as the log string, with `e' itself being
|
||
* passed as the second argument to the logger function.
|
||
*
|
||
* @param {Error} e error
|
||
*
|
||
* @throws {Error} e
|
||
*
|
||
* @return {undefined}
|
||
*/
|
||
_error( e )
|
||
{
|
||
const str = this._str( 'fatal', e );
|
||
|
||
this._logf( str, e );
|
||
|
||
throw e;
|
||
}
|
||
|
||
|
||
/**
|
||
* Return either success or failure message given `status'
|
||
*
|
||
* @param {boolean} status success/failure indicator
|
||
*
|
||
* @return {string} success/failure message
|
||
*/
|
||
_doneMessage( status )
|
||
{
|
||
return ( status === false )
|
||
? this._str( 'fail' )
|
||
: this._str( 'ok' );
|
||
}
|
||
}
|
||
|
||
|
||
/**
|
||
* Output strings in an easily accessible map
|
||
*
|
||
* This both keeps the code a bit more easily comprehensible by removing
|
||
* large strings from procedural logic, and allows for future localization.
|
||
*
|
||
* We can do better once we get to a localization stage---Error messages
|
||
* aren't part of this map, for example.
|
||
*
|
||
* @type {string}
|
||
*/
|
||
Bootstrap._strmap = {
|
||
header: () =>
|
||
"\\\\ // \\\\\\\n" +
|
||
" \\\\ // \\\\\\\n" +
|
||
" \\\\// Ulambda \\\\\\\n" +
|
||
" \\\\\\ Scheme ///\n" +
|
||
" \\\\\\ ///\n" +
|
||
" \\\\\\ ///\n",
|
||
|
||
loadingf: ( desc, path ) =>
|
||
( desc )
|
||
? `Loading ${desc} from ${path}...`
|
||
: `Loading ${path}...`,
|
||
|
||
loadedf: ( path, len ) =>
|
||
`Loaded ${path} (len=${len}).`,
|
||
|
||
prebirthDesc: () =>
|
||
"+ Prebirth is a very basic Lisp dialect with a compiler\n" +
|
||
"+ implemented in ECMAScript. Birth is the same\n" +
|
||
"+ compiler, but re-implemented in Prebirth Lisp.",
|
||
|
||
prebirthComplete: ( len ) =>
|
||
`Birth compilation complete (len=${len}).`,
|
||
|
||
birthCompiled: () =>
|
||
"+ Birth has been compiled with Prebirth. Since Birth is\n" +
|
||
"+ a re-implementation of Prebirth, it can now be used\n" +
|
||
"+ to compile itself.",
|
||
|
||
birthSelfCompiling: () =>
|
||
"Self-compiling Birth...",
|
||
|
||
birthVerify: () =>
|
||
"Verifying self-compilation output...",
|
||
|
||
birthVerifyFail: () =>
|
||
"\n" +
|
||
"The self-compilation of Birth yielded output\n" +
|
||
"that differs from Prebirth's compilation of Birth.\n" +
|
||
"This verification step is a self-test to ensure\n" +
|
||
"consistency between the two implementations.\n\n" +
|
||
"Unfortunately, to fix this, you need to hack\n" +
|
||
"Prebirth and/or Birth. Please report a bug!",
|
||
|
||
birthVerifyOk: () =>
|
||
"Birth output matches that of Prebirth.\n" +
|
||
"+ We are now bootstrapped using a very primitive\n" +
|
||
"+ Birth Lisp. Birth can now be used to compile the\n" +
|
||
"+ next generation of bootstrap compilers, Rebirth.",
|
||
|
||
rebirthCompiling: n =>
|
||
"Compiling Re" + Bootstrap._supmap[ n ] + "birth...",
|
||
|
||
rebirthCompiled: ( n, len ) =>
|
||
( n > 1 ) ? `Compilation complete (len=${len}).` :
|
||
`+ The first generation of Rebirth (Re¹birth) has been\n` +
|
||
`+ compiled using Birth (len=${len}). The next step is\n` +
|
||
`+ to have Re¹birth build itself, producing Re²birth.\n` +
|
||
`+ This will repeat, each time producing a compiler with\n` +
|
||
`+ additional features capable of compiling the next\n` +
|
||
`+ generation. This process will end once two\n` +
|
||
`+ consecutive generations yield identical output.`,
|
||
|
||
rebirthDone: n =>
|
||
"+ Rebirth stopped changing after Re" + Bootstrap._supmap[ n ] +
|
||
"birth, so that\n" +
|
||
"+ generation will serve as our final one. The last\n" +
|
||
"+ step is to use it to compile Ulambda.",
|
||
|
||
fatal: ( e ) =>
|
||
"\n\n!!! " + e.toString() + "\n\n" +
|
||
"Something has gone terribly wrong!\n" +
|
||
"See the console for a stack trace.\n\n",
|
||
|
||
ok: () =>
|
||
"Bootstrap successful (but not yet complete)!",
|
||
|
||
fail: () =>
|
||
"Bootstrap failed.",
|
||
};
|
||
|
||
|
||
/**
|
||
* Map of number to Unicode superscript
|
||
*
|
||
* This may be implemented as either a string or an array; the notation
|
||
* _supmap[n] will work the same in either case.
|
||
*
|
||
* @type {string}
|
||
*/
|
||
Bootstrap._supmap = "⁰¹²³⁴⁵⁶⁷⁸⁹";
|
||
|
||
|
||
// for use in a CommonJS (e.g. Node.js) environment
|
||
if ( typeof module !== 'undefined' ) {
|
||
module.exports = Bootstrap;
|
||
}
|