use Perl

On behalf of the Parrot team, I'm proud to announce Parrot 0.4.17
"Two for Finching." Parrot (http://parrotcode.org/) is a virtual machine aimed
at running all dynamic languages.

Parrot 0.4.17 can be obtained via CPAN (soon), or follow the
download instructions at http://parrotcode.org/source.html.
For those who would like to develop on Parrot, or help develop
Parrot itself, we recommend using Subversion or SVK on the
source code repository to get the latest and best Parrot code.

Parrot 0.4.17 News:
- Implementation
  + Bug fixes (including Coverity IDs 20, 22, 30, 119-122, 124-126, 129-131)
      Also various GC, memory, and segfault issues
  + Fix & reenable CGP core
  + Parrot's -r flag now works again (compile to and execute bytecode)
  + Updates to pmc2c & PIR syntaxes
  + Fix Complex PMC
  + Minor performance improvements, especially in PGE
- Documentation
  + PDD02 "Vtables" - superceded by PDD17
  + PDD06 "PASM" - minor updates
  + PDD17 "PMC" - add VTABLE syntax, update core PMC struct, restore UnionVal
  + PDD19 "PIR" - early review started
  + PDD21 "Namespaces" - cleanup
  + PDD24 "Events" - draft approved
  + PDD25 "Concurrency" - minor updates
  + PDD26 "AST" - draft version begun
  + PIR tutorials updated
- Languages/Compilers
  + Make scheme work with the current calling conventions, other major work.
  + Updates to m4, lua, compilers/pirc, languages/PIR, dotnet, tcl
- Miscellaneous:
  + make -j functional again
  + Code cleanup (refactoring, optimizations)

Thanks to all our contributors for making this possible, and our
sponsors for supporting this project.

Enjoy!

See the Parrot 0.4.10 release announcement.

We're able to run quite a few more tests now with some judicious skips of certain tests. We're still not running tcltest.tcl natively (though we're getting close!); So, this is with our Test::More like 'test' proc, which doesn't parse all the variants of tcl's test proc. (We've recently modified it to run tests with simple constraint specs: we run it regardless of whether the constraint would have said don't bother.)

446 subtests skipped.
Failed 41/65 test scripts, 33.85% okay. 4131/7608 subtests failed, 45.70% okay.

That's 3031 tests passing, out of 20683 in a recent cvs checkout of tcl's test suite. That's 14.65%

Recent tcl on parrot work:

1) update [expr] to use the parrot compiler tools, PGE, TGE - this allows us to write the expr grammar using perl6 rules instead of handrolled PIR.

2) create a test::more like set of procedures which allow us to run the tcl tests with only very minor modifications. This lets us drop the huge (and incomplete) test conversions to a perl based suite. partcl tests are mostly converted to using this like test::more - we provide a 'test' sub that is implemented in terms of the test::more subs - this lets us generate the normal (to us) TAP output, even on the tclsh tests.

The conversion means we're running larger tcl files (in the form of tests) than we have to date. This is exposing issues in both partcl and parrot that are spurring development on both fronts.

Because the tests are now being written in tcl, we can easily run them with the latest tclsh to verify we're testing for the right things: this helped find a bug in tcl8.5a4.

Here's the result of all the tcl tests we can currently parse ``natively'' (in quotes because we're still not using tcltest.tcl):


Failed 34/38 test scripts, 10.53% okay. 568/937 subtests failed, 39.38% okay.


So, passing 369 tests using the current method. We'd be shown passing more, but some test files die because of their size (chokes the compiler), or for other reasons after some passes. Any test that dies prematurely isn't counted in this list.

tcl on parrot is still not dead.

Matt Diephouse is effectively taking over partcl, though I anticipate I will help out with some PGE/TGE commits; I just committed some changes to the tcl-test harness so we can once again run the transformed test suite. (still hovering at just under 6%)

If you look at the last posting, you'll see the template is very verbose and optimized for the build tool. Changed it to be more like the actual usage mentioned on the man page: so, exit's manpage says:

    exit ?returnCode?

And our exit template now says:

    usage => "?returnCode:int=0?",

Which automatically generates code to treat it as an optional argument, generates the appropriate usage message if the user miscalls, expects the argument to be an integer (and carps properly if it's not), and sets the default value to 0.

In the past few days, added a build tool that lets us declare inline'd tcl builtins (originally, everything was interpreted. Now several commands have a version that generates PIR), rather than hand rolling them. this lets you declare the argument types (and whether they are optional, default values, etc.) and have them compiled automatically, and just define the small bit of PIR code that you need to process the arguments. It also automatically generates errors for bad calls, etc.

By moving all this setup code into the build script, we should lower the bar for implementing the builtins. as of this writing, six builtins have been converted to the new template style. Here's a sample:

{
    command => 'join',
    args =>
    [
        {
            name => 'list',
            type => 'list',
        },
        {
            name => 'joinString',
            type => 'string',
            optional => 1,
            default => " ",
        }
    ],
    code => <<'END_PIR',

$S{register_joinString} = $P{register_joinString}
$S{register_num} = join $S{register_joinString}, $P{register_list}
$P{register_num} = new .TclString
$P{register_num} = $S{register_num}
END_PIR
}

Most of the declaration is pulled right from the manpage, as far as arguments go. The actual PIR code that does the work is actually a bit longer than it needs to be, due to boxing. (The compiler currently assumes that the result of the compilation is always a PMC - being able to specify a specific register as opposed to a PMC will let us reduce the amount of code even further.)

Committed a patch last night changing some tests to expect error messages that are nowhere to seen in tcl 8.4, which prompted some confusion.

Just added a comment to partcl's README which will hopefully explain:

Note that we are targetting Tcl's cvs-latest, which is going to be 8.5. This allows us to test against what will likely be state of the art by the time we approach completion. As we get closer to that day, we'll probably settle down and code against the most recent version (which hopefully won't be 9.x by then).

This has the disadvantage that for side by side testing, you'll need to build your own tcl. Partcl users don't need to worry about this, and even most partcl developers can simply code against the test suite.

I've not had much time the past few weeks to work on partcl, as I've a major work deadline that ended up going long.

But, that's alright, because Matt Diephouse has been fixing quite a few things up; Alberto Simões has picked up some PIR and begun fleshing out all the missing [string] subcommands (Yay!), and we got a commit from Bernhard Schmalhofer enabling us to have a test_like variant for our suite, giving us another passing test!

So, with no commits by me, we've increased our passing rate of the tcl test suite by nearly 100 tests in two days. At this rate,
we'll have a fully functional version of tcl in 307 days. ^_^

Robert Spier posted some preliminary yearly stats to parrot, which show me as the #2 contributor this year (behind Leo), and #3 the year before that (behind leo and dan): Leo and I are the only two on the top 10 two years running. Which might explain why...

We also got a mention by Larry Wall:

Likewise Parrot is targeting Perl as its "first" language, but if you
look at recent history you'd think they were mainly targeting TCL.
And that's fine by us, both officially and unofficially.

Current stats with the converted tcl suite: 5.28%.

This is lower than the last reported percentage, because:

1) I'm not skipping [clock] anymore (7568 tests out of 16210!)
2) we've lost a bit of ground on some tests because of internal changes in the past year (including -> compiler). But, given these reorgs, we seem to be gaining passing tests now faster than we have in the past.

Also, 5.28% is pretty good when I think about trying to figure out how much of Perl6 is working on parrot. At least I have a known test suite to run against.

On the short list coming up are namespaces (Chip? 'allo?), and some developer support for generating builtins using our compiler that should simplify things and allow us to start doing more, more quickly.

Thanks to all the folks that have been working on partcl!

Posted to RT (and mentioned on the internals list) a few smallish projects that could probably be tackled by someone looking to do some PIR work. Within 30 minutes, Klaas-Jan Stol had already started working on it. We now have a working [flush], at least for the most part. Thanks, KJ.

Talked to Donal Fellows on #tcl on freenode this week. We talked briefly about if any of tcl's builtins were implementable in terms of other builtins, which led to his posting at http://wiki.tcl.tk/15051

Having someone actually *implement* these for inclusion in partcl would allow us to reduce the amount of work necessary to pass more of tcl's test suite. (And, of course, for any other tcl implementors that aren't core-tcl).