Difference between revisions of "Boostrapping Specific Languages"

From bootstrapping
Jump to navigation Jump to search
m (Minor edit)
Line 22: Line 22:
 
Contrary to what you would expect, it actually ends up being far easier to implement as Macro-assembler than it is to implement an assembler without Macros.
 
Contrary to what you would expect, it actually ends up being far easier to implement as Macro-assembler than it is to implement an assembler without Macros.
 
This is especially true when it comes to the easiest form of Macros, line macros.
 
This is especially true when it comes to the easiest form of Macros, line macros.
 +
 +
== Rust ==
 +
 +
<blockquote>
 +
This project is an attempt at creating a simple rust compiler in C++, with the ultimate goal of being a separate re-implementation.
 +
 +
mrustc works by comping assumed-valid rust code (i.e. without borrow checking) into a high-level assembly (currently using C, but LLVM/cretonne or even direct machine code could work) and getting an external code generator to turn that into optimised machine code. This works because the borrow checker doesn't have any impact on the generated code, just in checking that the code would be valid.
 +
</blockquote>
 +
 +
* https://github.com/thepowersgang/mrustc

Revision as of 08:59, 25 December 2017

go

gcc-go lets you compile the golang implementation of go.

So you can bootstrap go given just gcc.

lisp

Lisp interpreters are relatively easy to write in assembly or C, the primary issue is macros. To properly implement macros in lisp, you have two options: 1) Implement lazy evaluation on top of eager evaluation (can get very ugly) or 2) Implement a lazy lisp (a boatload of work) and simply use straight lambdas to provide macro functionality

FORTH

FORTH interpreters are far easier to write in assembly than they are to write in any other (non-functional) language. The biggest issue ends up being what FORTH standard to follow and finding programmers willing to use/improve your FORTH.

Assembly

Contrary to what you would expect, it actually ends up being far easier to implement as Macro-assembler than it is to implement an assembler without Macros. This is especially true when it comes to the easiest form of Macros, line macros.

Rust

This project is an attempt at creating a simple rust compiler in C++, with the ultimate goal of being a separate re-implementation.

mrustc works by comping assumed-valid rust code (i.e. without borrow checking) into a high-level assembly (currently using C, but LLVM/cretonne or even direct machine code could work) and getting an external code generator to turn that into optimised machine code. This works because the borrow checker doesn't have any impact on the generated code, just in checking that the code would be valid.