--iRyNH1DQkCWWk0hj9Rv
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable

tis 2006-01-10 klockan 02:16 +0900 skrev Nicolas Cannasse:
> Anders Höckersten wrote:
> > Hello everyone,
> > 
> > During the last few months me and Andreas Farre have been doing our
> > master's thesis on a proof-of-concept compiler for Ruby. The idea is to
> > test how well a language like Ruby can be compiled to C--[1]. We are
> > nearing the end of our thesis and will be focusing most of our remaining
> > time towards writing our report. We would however like feedback on our
> > work from the Ruby community.
> 
> Hello,
> 
> Some people are interested in doing the same thing for Neko 
> (http://nekovm.org). How you would compare the work needed to target 
> Neko against targeting directly x86 bytecode ? What where the difficult 
> point is writing the compiler ? Is there some Ruby Language Reference 
> available somewhere on what you work is based ?
> 
> Best,
> 
> Nicolas

Nicolas,

The focus of C-- is different from that of Neko. C-- is designed as a
portable assembly language. What that means is that we (when writing a
Ruby compiler for C--) write code that targets "x86 C--". In other
words, our code and the C-- compiler can take advantage of knowing that
the underlying machine has certain characteristics. The C-- developers
claim that in theory, generating C-- could lead to perhaps 90-95% the
speed of generating native x86 assembler (unfortunately, current C--
compilers are not that good).

Generating good C-- is also much easier than generating x86 assembly
directly (for example, C-- does register allocation for us). Retargeting
our compiler to another platform than x86 should also be relatively easy
- we just have to rewrite some of the platform specific parts. Of
course, that assumes a C-- compiler is available for the platform we
wish to target.

C-- also provides a very simple runtime system that we hook our own
runtime system (written in a mix of mostly C and some C--) into. This
enables us to do all the dynamic stuff that Ruby needs.

I have not looked extensively at Neko, so most of the following will be
guessing from looking through the specification. I think it should be at
least slightly easier to target Neko than C--, since Neko provides a
much larger existing runtime system to use. I read the discussion you
had on this list a few months ago about Neko with much interest and I
think a Ruby to Neko compiler is a very interesting idea.

The most difficult part of writing our compiler was finding out how
things were supposed to work. The closest thing we have found to a
reference is the "Programming Ruby" book, but it does not go into great
details about the semantics of Ruby. It does however have a very good
description of the object model Ruby uses, as well as an informal
description of all language constructs. This together with experimenting
with the Ruby interpreter gave us a decent picture of how things were
supposed to work, but I'm certain some things are wrong.

This got rather long. I hope I answered all your questions in some
way. :)

All the best,
Anders

--iRyNH1DQkCWWk0hj9Rv
Content-Type: application/pgp-signature; name=signature.asc
Content-Description: Detta =?ISO-8859-1?Q?=E4r?= en digitalt signerad
	meddelandedel

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.1 (GNU/Linux)

iD8DBQBDwqxZ9vwv2G5xhTwRAjb9AKDHgfCrEYFf1S13/91oy9MEBvxN4ACfTqqB
IoHZkE4gz60BQLV2H3vjBgkGQ
-----END PGP SIGNATURE-----

--iRyNH1DQkCWWk0hj9Rv--