At the moment, the compilation and execution phases are separate. When we ship the final code, they'll be combined.

It was easiest to have them separate to begin with--we built a standalone assembler that could generate bytecode files that the interpreter can mmap in an directly exectute, which made it possible to get up and going quickly. The languages that have been implemented on Parrot so far have more or less gone that route (well, except for the ones that are true interpreters, like BASIC and Befunge) because, well, it's easiest. The compilers can be written in anything, and Parrot doesn't need to have a functional parser built in.

We're moving to an integrated system where the compiler and interpreter are together in the same executable--necessary for perl's eval, for example. It's more complex, though, so it's coming along slower. That's OK, since we have more than enough to keep us busy as it is. :)

Per my understanding of Apocalypse 5, it'll be possible to change the grammar rules of Perl 6 at runtime. This leads me to the strong belief that the parser, lexer, and compiler will be built on Parrot. If this is the case, dumping Parrot bytecode will be optional.

Elian will probably be along to correct any misconceptions, though.

The perl6 prototype currently works similar to perl5, where you can simply type ./perl6 script.pl and it will run just fine. This is because the prototype works in 5 stages:

1. Generate a parse tree.
2. Decipher parse tree, optimize, and output assembly code
3. Assemble
4. Compile
5. Run

This has many advantages. For instance, you can stop at one step, and pick up again later at it (e.g. stop after compilation to create an executatble). How it will work \ in the "Real Thing" hasn't been decided yet. However, even if the entire process takes longer than perl5's, thats not really a problem. If you really need the speed, you can stop at stage 3 or 4 to create a program that skips the slower steps.

I'm curious: what's the difference between stage 3 (assembly) and stage 4 (compilation) ?

laughingboy

Sorry, I wasn't too clear there. Step 3 (Assemble) assembles (using the assembler assemble.pl) parrot assembly into bytecode. From there, one of two things happens: either the program is compiled into an executable, or is run. :)

Invoking a separate process to compile a string into Parrot would have serious performance implications. To avoid losing the power of eval, the compiler would need to be in the same process. I think it's that simple, unless someone has come up with a clever innovation.